Moved in progress tests to seperate folder

10 files changed, 7260 insertions, 0 deletions

diff --git a/tests/test-suite/inprogress/attrib.js b/tests/test-suite/inprogress/attrib.js
new file mode 100644
index 0000000..ca23d26
--- /dev/null
+++ b/tests/test-suite/inprogress/attrib.js
@@ -0,0 +1,77 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+test("[test-suite] attrib: testing require", function (t) {
+    let luaCode = `
+        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 = _soft and 100 or 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
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
diff --git a/tests/test-suite/inprogress/bitwise.js b/tests/test-suite/inprogress/bitwise.js
new file mode 100644
index 0000000..3969bb0
--- /dev/null
+++ b/tests/test-suite/inprogress/bitwise.js
@@ -0,0 +1,504 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+const prefix = `
+    package.preload.bit32 = function ()     --{
+
+    -- no built-in 'bit32' library: implement it using bitwise operators
+
+    local bit = {}
+
+    function bit.bnot (a)
+      return ~a & 0xFFFFFFFF
+    end
+
+
+    --
+    -- in all vararg functions, avoid creating 'arg' table when there are
+    -- only 2 (or less) parameters, as 2 parameters is the common case
+    --
+
+    function bit.band (x, y, z, ...)
+      if not z then
+        return ((x or -1) & (y or -1)) & 0xFFFFFFFF
+      else
+        local arg = {...}
+        local res = x & y & z
+        for i = 1, #arg do res = res & arg[i] end
+        return res & 0xFFFFFFFF
+      end
+    end
+
+    function bit.bor (x, y, z, ...)
+      if not z then
+        return ((x or 0) | (y or 0)) & 0xFFFFFFFF
+      else
+        local arg = {...}
+        local res = x | y | z
+        for i = 1, #arg do res = res | arg[i] end
+        return res & 0xFFFFFFFF
+      end
+    end
+
+    function bit.bxor (x, y, z, ...)
+      if not z then
+        return ((x or 0) ~ (y or 0)) & 0xFFFFFFFF
+      else
+        local arg = {...}
+        local res = x ~ y ~ z
+        for i = 1, #arg do res = res ~ arg[i] end
+        return res & 0xFFFFFFFF
+      end
+    end
+
+    function bit.btest (...)
+      return bit.band(...) ~= 0
+    end
+
+    function bit.lshift (a, b)
+      return ((a & 0xFFFFFFFF) << b) & 0xFFFFFFFF
+    end
+
+    function bit.rshift (a, b)
+      return ((a & 0xFFFFFFFF) >> b) & 0xFFFFFFFF
+    end
+
+    function bit.arshift (a, b)
+      a = a & 0xFFFFFFFF
+      if b <= 0 or (a & 0x80000000) == 0 then
+        return (a >> b) & 0xFFFFFFFF
+      else
+        return ((a >> b) | ~(0xFFFFFFFF >> b)) & 0xFFFFFFFF
+      end
+    end
+
+    function bit.lrotate (a ,b)
+      b = b & 31
+      a = a & 0xFFFFFFFF
+      a = (a << b) | (a >> (32 - b))
+      return a & 0xFFFFFFFF
+    end
+
+    function bit.rrotate (a, b)
+      return bit.lrotate(a, -b)
+    end
+
+    local function checkfield (f, w)
+      w = w or 1
+      assert(f >= 0, "field cannot be negative")
+      assert(w > 0, "width must be positive")
+      assert(f + w <= 32, "trying to access non-existent bits")
+      return f, ~(-1 << w)
+    end
+
+    function bit.extract (a, f, w)
+      local f, mask = checkfield(f, w)
+      return (a >> f) & mask
+    end
+
+    function bit.replace (a, v, f, w)
+      local f, mask = checkfield(f, w)
+      v = v & mask
+      a = (a & ~(mask << f)) | (v << f)
+      return a & 0xFFFFFFFF
+    end
+
+    return bit
+
+    end  --}
+
+    local bit32 = require'bit32'
+`;
+
+test("[test-suite] bitwise: testing bitwise operations", function (t) {
+    let luaCode = `
+        local numbits = string.packsize('j') * 8
+
+        assert(~0 == -1)
+
+        assert((1 << (numbits - 1)) == math.mininteger)
+
+        -- basic tests for bitwise operators;
+        -- use variables to avoid constant folding
+        local a, b, c, d
+        a = 0xFFFFFFFFFFFFFFFF
+        assert(a == -1 and a & -1 == a and a & 35 == 35)
+        a = 0xF0F0F0F0F0F0F0F0
+        assert(a | -1 == -1)
+        assert(a ~ a == 0 and a ~ 0 == a and a ~ ~a == -1)
+        assert(a >> 4 == ~a)
+        a = 0xF0; b = 0xCC; c = 0xAA; d = 0xFD
+        assert(a | b ~ c & d == 0xF4)
+
+        a = 0xF0.0; b = 0xCC.0; c = "0xAA.0"; d = "0xFD.0"
+        assert(a | b ~ c & d == 0xF4)
+
+        a = 0xF0000000; b = 0xCC000000;
+        c = 0xAA000000; d = 0xFD000000
+        assert(a | b ~ c & d == 0xF4000000)
+        assert(~~a == a and ~a == -1 ~ a and -d == ~d + 1)
+
+        a = a << 32
+        b = b << 32
+        c = c << 32
+        d = d << 32
+        assert(a | b ~ c & d == 0xF4000000 << 32)
+        assert(~~a == a and ~a == -1 ~ a and -d == ~d + 1)
+
+        assert(-1 >> 1 == (1 << (numbits - 1)) - 1 and 1 << 31 == 0x80000000)
+        assert(-1 >> (numbits - 1) == 1)
+        assert(-1 >> numbits == 0 and
+               -1 >> -numbits == 0 and
+               -1 << numbits == 0 and
+               -1 << -numbits == 0)
+
+        assert((2^30 - 1) << 2^30 == 0)
+        assert((2^30 - 1) >> 2^30 == 0)
+
+        assert(1 >> -3 == 1 << 3 and 1000 >> 5 == 1000 << -5)
+
+
+        -- coercion from strings to integers
+        assert("0xffffffffffffffff" | 0 == -1)
+        assert("0xfffffffffffffffe" & "-1" == -2)
+        assert(" \\t-0xfffffffffffffffe\\n\\t" & "-1" == 2)
+        assert("   \\n  -45  \\t " >> "  -2  " == -45 * 4)
+
+        -- out of range number
+        assert(not pcall(function () return "0xffffffffffffffff.0" | 0 end))
+
+        -- embedded zeros
+        assert(not pcall(function () return "0xffffffffffffffff\\0" | 0 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] bitwise: testing bitwise library", function (t) {
+    let luaCode = `
+        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)
+    `, 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] bitwise: out-of-range numbers", function (t) {
+    let luaCode = `
+        assert(bit32.band(-1) == 0xffffffff)
+        assert(bit32.band((1 << 33) - 1) == 0xffffffff)
+        assert(bit32.band(-(1 << 33) - 1) == 0xffffffff)
+        assert(bit32.band((1 << 33) + 1) == 1)
+        assert(bit32.band(-(1 << 33) + 1) == 1)
+        assert(bit32.band(-(1 << 40)) == 0)
+        assert(bit32.band(1 << 40) == 0)
+        assert(bit32.band(-(1 << 40) - 2) == 0xfffffffe)
+        assert(bit32.band((1 << 40) - 4) == 0xfffffffc)
+
+        assert(bit32.lrotate(0, -1) == 0)
+        assert(bit32.lrotate(0, 7) == 0)
+        assert(bit32.lrotate(0x12345678, 0) == 0x12345678)
+        assert(bit32.lrotate(0x12345678, 32) == 0x12345678)
+        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) == bit32.band(-1 * 2, 0xffffffff))
+
+        assert(0x12345678 << 4 == 0x123456780)
+        assert(0x12345678 << 8 == 0x1234567800)
+        assert(0x12345678 << -4 == 0x01234567)
+        assert(0x12345678 << -8 == 0x00123456)
+        assert(0x12345678 << 32 == 0x1234567800000000)
+        assert(0x12345678 << -32 == 0)
+        assert(0x12345678 >> 4 == 0x01234567)
+        assert(0x12345678 >> 8 == 0x00123456)
+        assert(0x12345678 >> 32 == 0)
+        assert(0x12345678 >> -32 == 0x1234567800000000)
+    `, 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] bitwise: some special cases", function (t) {
+    let luaCode = `
+        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.band(b, b, b, b) == b)
+          assert(bit32.btest(b, b) == (b ~= 0))
+          assert(bit32.band(b, b, b) == b)
+          assert(bit32.band(b, b, b, ~b) == 0)
+          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.bor(b, b, 0, ~b) == 0xffffffff)
+          assert(bit32.bxor(b) == b)
+          assert(bit32.bxor(b, b) == 0)
+          assert(bit32.bxor(b, b, b) == b)
+          assert(bit32.bxor(b, b, 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) == (1 << 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)))
+        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] bitwise: for this test, use at most 24 bits (mantissa of a single float)", function (t) {
+    let luaCode = `
+        c = {0, 1, 2, 3, 10, 0x800000, 0xaaaaaa, 0x555555, 0xffffff, 0x7fffff}
+        for _, b in pairs(c) do
+          for i = -40, 40 do
+            local x = bit32.lshift(b, i)
+            local y = math.floor(math.fmod(b * 2.0^i, 2.0^32))
+            assert(math.fmod(x - y, 2.0^32) == 0)
+          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))
+    `, 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] bitwise: testing extract/replace", function (t) {
+    let luaCode = `
+        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) == (1 << 31) - 1)
+        assert(bit32.replace(-1, 0, 1, 2) == (1 << 32) - 7)
+    `, 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] bitwise: testing conversion of floats", function (t) {
+    let luaCode = `
+        assert(bit32.bor(3.0) == 3)
+        assert(bit32.bor(-4.0) == 0xfffffffc)
+    `, 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] bitwise: large floats and large-enough integers?", function (t) {
+    let luaCode = `
+        if 2.0^50 < 2.0^50 + 1.0 and 2.0^50 < (-1 >> 1) then
+          assert(bit32.bor(2.0^32 - 5.0) == 0xfffffffb)
+          assert(bit32.bor(-2.0^32 - 6.0) == 0xfffffffa)
+          assert(bit32.bor(2.0^48 - 5.0) == 0xfffffffb)
+          assert(bit32.bor(-2.0^48 - 6.0) == 0xfffffffa)
+        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");
+
+});
diff --git a/tests/test-suite/inprogress/coroutine.js b/tests/test-suite/inprogress/coroutine.js
new file mode 100644
index 0000000..a66ae7b
--- /dev/null
+++ b/tests/test-suite/inprogress/coroutine.js
@@ -0,0 +1,931 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+test("[test-suite] coroutine: is main thread", function (t) {
+    let luaCode = `
+        local main, ismain = coroutine.running()
+        assert(type(main) == "thread" and ismain)
+        assert(not coroutine.resume(main))
+        assert(not coroutine.isyieldable())
+        assert(not pcall(coroutine.yield))
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: trivial errors", function (t) {
+    let luaCode = `
+        assert(not pcall(coroutine.resume, 0))
+        assert(not pcall(coroutine.status, 0))
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: tests for multiple yield/resume arguments", function (t) {
+    let luaCode = `
+        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)
+          -- next call should not corrupt coroutine (but must fail,
+          -- as it attempts to resume the running coroutine)
+          assert(coroutine.resume(f) == false)
+          assert(coroutine.status(f) == "running")
+          local arg = {...}
+          assert(coroutine.isyieldable())
+          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")
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: yields in tail calls", function (t) {
+    let luaCode = `
+        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')
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: recursive", function (t) {
+    let luaCode = `
+        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
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: sieve", function (t) {
+    let luaCode = `
+        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)
+        x, a = nil
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: yielding across JS boundaries", function (t) {
+    let luaCode = `
+        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)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: unyieldable JS call", function (t) {
+    let luaCode = `
+        do
+          local function f (c)
+                  assert(not coroutine.isyieldable())
+                  return c .. c
+                end
+
+          local co = coroutine.wrap(function (c)
+                       assert(coroutine.isyieldable())
+                       local s = string.gsub("a", ".", f)
+                       return s
+                     end)
+          assert(co() == "aa")
+        end
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: errors in coroutines", function (t) {
+    let luaCode = `
+        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")
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: co-routines x for loop", function (t) {
+    let luaCode = `
+        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)
+   `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: old bug: attempt to resume itself", function (t) {
+    let luaCode = `
+        function co_func (current_co)
+          assert(coroutine.running() == current_co)
+          assert(coroutine.resume(current_co) == false)
+          coroutine.yield(10, 20)
+          assert(coroutine.resume(current_co) == false)
+          coroutine.yield(23)
+          return 10
+        end
+
+        local co = coroutine.create(co_func)
+        local a,b,c = coroutine.resume(co, co)
+        assert(a == true and b == 10 and c == 20)
+        a,b = coroutine.resume(co, co)
+        assert(a == true and b == 23)
+        a,b = coroutine.resume(co, co)
+        assert(a == true and b == 10)
+        assert(coroutine.resume(co, co) == false)
+        assert(coroutine.resume(co, co) == false)
+   `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: old bug: other old bug when attempting to resume itself", function (t) {
+    let luaCode = `
+        do
+          local A = coroutine.running()
+          local B = coroutine.create(function() return coroutine.resume(A) end)
+          local st, res = coroutine.resume(B)
+          assert(st == true and res == false)
+
+          A = coroutine.wrap(function() return pcall(A, 1) end)
+          st, res = A()
+          assert(not st and string.find(res, "non%-suspended"))
+        end
+   `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: attempt to resume 'normal' coroutine", function (t) {
+    let luaCode = `
+        local co1, co2
+        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')
+   `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: infinite recursion of coroutines", function (t) {
+    let luaCode = `
+        a = function(a) coroutine.wrap(a)(a) end
+        assert(not pcall(a, 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(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: access to locals of erroneous coroutines", function (t) {
+    let luaCode = `
+        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)
+   `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+test("[test-suite] coroutine: JS Tests", { skip: true }, function (t) {
+    t.comment("TODO");
+});
+
+
+test("[test-suite] coroutine: leaving a pending coroutine open", function (t) {
+    let luaCode = `
+        _X = coroutine.wrap(function ()
+              local a = 10
+              local x = function () a = a+1 end
+              coroutine.yield()
+            end)
+
+        _X()
+   `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: stack overflow", { skip: true }, function (t) {
+    let luaCode = `
+        -- 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
+        co = nil
+   `, L;
+    
+    t.comment("TODO");
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: testing yields inside metamethods", function (t) {
+    let luaCode = `
+        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,
+          __mod = function(a,b) coroutine.yield(nil, "mod"); return a.x % b.x end,
+          __unm = function(a,b) coroutine.yield(nil, "unm"); return -a.x end,
+          __bnot = function(a,b) coroutine.yield(nil, "bnot"); return ~a.x end,
+          __shl = function(a,b) coroutine.yield(nil, "shl"); return a.x << b.x end,
+          __shr = function(a,b) coroutine.yield(nil, "shr"); return a.x >> b.x end,
+          __band = function(a,b)
+                     a = type(a) == "table" and a.x or a
+                     b = type(b) == "table" and b.x or b
+                     coroutine.yield(nil, "band")
+                     return a & b
+                   end,
+          __bor = function(a,b) coroutine.yield(nil, "bor"); return a.x | b.x end,
+          __bxor = function(a,b) coroutine.yield(nil, "bxor"); 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 + a end, {"add", "band"}) == 2)
+
+        assert(run(function () return a % b end, {"mod"}) == 10)
+
+        assert(run(function () return ~a & b end, {"bnot", "band"}) == ~10 & 12)
+        assert(run(function () return a | b end, {"bor"}) == 10 | 12)
+        assert(run(function () return a ~ b end, {"bxor"}) == 10 ~ 12)
+        assert(run(function () return a << b end, {"shl"}) == 10 << 12)
+        assert(run(function () return a >> b end, {"shr"}) == 10 >> 12)
+
+        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")
+   `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: tests for comparsion operators", function (t) {
+    let luaCode = `
+        do
+          local mt1 = {
+            __le = function (a,b)
+              coroutine.yield(10)
+              return
+                (type(a) == "table" and a.x or a) <= (type(b) == "table" and b.x or b)
+            end,
+            __lt = function (a,b)
+              coroutine.yield(10)
+              return
+                (type(a) == "table" and a.x or a) < (type(b) == "table" and b.x or b)
+            end,
+          }
+          local mt2 = { __lt = mt1.__lt }   -- no __le
+
+          local function run (f)
+            local co = coroutine.wrap(f)
+            local res
+            repeat
+              res = co()
+            until res ~= 10
+            return res
+          end
+          
+          local function test ()
+            local a1 = setmetatable({x=1}, mt1)
+            local a2 = setmetatable({x=2}, mt2)
+            assert(a1 < a2)
+            assert(a1 <= a2)
+            assert(1 < a2)
+            assert(1 <= a2)
+            assert(2 > a1)
+            assert(2 >= a2)
+            return true
+          end
+          
+          run(test)
+
+        end
+
+        assert(run(function ()
+            a.BB = print
+            return a.BB
+        end, {"nidx", "idx"}) == print)
+   `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: getuptable & setuptable", function (t) {
+    let luaCode = `
+        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)
+   `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: testing yields inside 'for' iterators", function (t) {
+    let luaCode = `
+        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)
+   `, L;
+
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] coroutine: tests for coroutine API", { skip: true }, function (t) {
+    t.comment("TODO");
+});
diff --git a/tests/test-suite/inprogress/goto.js b/tests/test-suite/inprogress/goto.js
new file mode 100644
index 0000000..696ab16
--- /dev/null
+++ b/tests/test-suite/inprogress/goto.js
@@ -0,0 +1,434 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+test("[test-suite] goto: error messages", function (t) {
+    let luaCode = `
+        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'")
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] goto: simple gotos", function (t) {
+    let luaCode = `
+        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)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] goto: long labels", function (t) {
+    let luaCode = `
+        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
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] goto: goto to correct label when nested", function (t) {
+    let luaCode = `
+        do goto l3; ::l3:: end   -- does not loop jumping to previous label 'l3'
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] goto: ok to jump over local dec. to end of block", function (t) {
+    let luaCode = `
+        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
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] goto: to repeat a label in a different function is OK", function (t) {
+    let luaCode = `
+        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()
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] goto: bug in 5.2 -> 5.3.2", function (t) {
+    let luaCode = `
+        do   -- bug in 5.2 -> 5.3.2
+          local x
+          ::L1::
+          local y             -- cannot join this SETNIL with previous one
+          assert(y == nil)
+          y = true
+          if x == nil then
+            x = 1
+            goto L1
+          else
+            x = x + 1
+          end
+          assert(x == 2 and y == true)
+        end
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] goto: testing closing of upvalues", function (t) {
+    let luaCode = `
+        local function foo ()
+          local t = {}
+          do
+          local i = 1
+          local a, b, c, d
+          t[1] = function () return a, b, c, d end
+          ::l1::
+          local b
+          do
+            local c
+            t[#t + 1] = function () return a, b, c, d end    -- t[2], t[4], t[6]
+            if i > 2 then goto l2 end
+            do
+              local d
+              t[#t + 1] = function () return a, b, c, d end   -- t[3], t[5]
+              i = i + 1
+              local a
+              goto l1
+            end
+          end
+          end
+          ::l2:: return t
+        end
+
+        local a = foo()
+        assert(#a == 6)
+
+        -- all functions share same 'a'
+        for i = 2, 6 do
+          assert(debug.upvalueid(a[1], 1) == debug.upvalueid(a[i], 1))
+        end
+
+        -- 'b' and 'c' are shared among some of them
+        for i = 2, 6 do
+          -- only a[1] uses external 'b'/'b'
+          assert(debug.upvalueid(a[1], 2) ~= debug.upvalueid(a[i], 2))
+          assert(debug.upvalueid(a[1], 3) ~= debug.upvalueid(a[i], 3))
+        end
+
+        for i = 3, 5, 2 do
+          -- inner functions share 'b'/'c' with previous ones
+          assert(debug.upvalueid(a[i], 2) == debug.upvalueid(a[i - 1], 2))
+          assert(debug.upvalueid(a[i], 3) == debug.upvalueid(a[i - 1], 3))
+          -- but not with next ones
+          assert(debug.upvalueid(a[i], 2) ~= debug.upvalueid(a[i + 1], 2))
+          assert(debug.upvalueid(a[i], 3) ~= debug.upvalueid(a[i + 1], 3))
+        end
+
+        -- only external 'd' is shared
+        for i = 2, 6, 2 do
+          assert(debug.upvalueid(a[1], 4) == debug.upvalueid(a[i], 4))
+        end
+
+        -- internal 'd's are all different
+        for i = 3, 5, 2 do
+          for j = 1, 6 do
+            assert((debug.upvalueid(a[i], 4) == debug.upvalueid(a[j], 4))
+              == (i == j))
+          end
+        end
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] goto: testing if x goto optimizations", function (t) {
+    let luaCode = `
+        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)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
diff --git a/tests/test-suite/inprogress/math.js b/tests/test-suite/inprogress/math.js
new file mode 100644
index 0000000..463905f
--- /dev/null
+++ b/tests/test-suite/inprogress/math.js
@@ -0,0 +1,1614 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+const prefix = `
+    local minint = math.mininteger
+    local maxint = math.maxinteger
+
+    local intbits = math.floor(math.log(maxint, 2) + 0.5) + 1
+    --assert((1 << intbits) == 0)
+
+    local function checkerror (msg, f, ...)
+      local s, err = pcall(f, ...)
+      assert(not s and string.find(err, msg))
+    end
+
+    local msgf2i = "number.* has no integer representation"
+
+    function eq (a,b,limit)
+      if not limit then
+        if floatbits >= 50 then limit = 1E-11
+        else limit = 1E-5
+        end
+      end
+      -- a == b needed for +inf/-inf
+      return a == b or math.abs(a-b) <= limit
+    end
+
+    -- equality with types
+    function eqT (a,b)
+      return a == b and math.type(a) == math.type(b)
+    end
+
+    local function checkcompt (msg, code)
+      checkerror(msg, assert(load(code)))
+    end
+`;
+
+test("[test-suite] math: int bits", function (t) {
+    let luaCode = `
+        assert(minint == 1 << (intbits - 1))
+        assert(maxint == minint - 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] math: number of bits in the mantissa of a floating-point number", function (t) {
+    let luaCode = `
+        local floatbits = 24
+        do
+          local p = 2.0^floatbits
+          while p < p + 1.0 do
+            p = p * 2.0
+            floatbits = floatbits + 1
+          end
+        end
+
+        local function isNaN (x)
+          return (x ~= x)
+        end
+
+        assert(isNaN(0/0))
+        assert(not isNaN(1/0))
+
+
+        do
+          local x = 2.0^floatbits
+          assert(x > x - 1.0 and x == x + 1.0)
+
+          print(string.format("%d-bit integers, %d-bit (mantissa) floats",
+                               intbits, floatbits))
+        end
+
+        assert(math.type(0) == "integer" and math.type(0.0) == "float"
+               and math.type("10") == 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] math: basic float notation", function (t) {
+    let luaCode = `
+        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   -- tests for 'modf'
+          local a,b = math.modf(3.5)
+          assert(a == 3.0 and b == 0.5)
+          a,b = math.modf(-2.5)
+          assert(a == -2.0 and b == -0.5)
+          a,b = math.modf(-3e23)
+          assert(a == -3e23 and b == 0.0)
+          a,b = math.modf(3e35)
+          assert(a == 3e35 and b == 0.0)
+          a,b = math.modf(-1/0)   -- -inf
+          assert(a == -1/0 and b == 0.0)
+          a,b = math.modf(1/0)   -- inf
+          assert(a == 1/0 and b == 0.0)
+          a,b = math.modf(0/0)   -- NaN
+          assert(isNaN(a) and isNaN(b))
+          a,b = math.modf(3)  -- integer argument
+          assert(eqT(a, 3) and eqT(b, 0.0))
+          a,b = math.modf(minint)
+          assert(eqT(a, minint) and eqT(b, 0.0))
+        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] math: math.huge", function (t) {
+    let luaCode = `
+        assert(math.huge > 10e30)
+        assert(-math.huge < -10e30)
+    `, 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] math: integer arithmetic", function (t) {
+    let luaCode = `
+        assert(minint < minint + 1)
+        assert(maxint - 1 < maxint)
+        assert(0 - minint == minint)
+        assert(minint * minint == 0)
+        assert(maxint * maxint * maxint == maxint)
+    `, 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] math: testing floor division and conversions", function (t) {
+    let luaCode = `
+        for _, i in pairs{-16, -15, -3, -2, -1, 0, 1, 2, 3, 15} do
+          for _, j in pairs{-16, -15, -3, -2, -1, 1, 2, 3, 15} do
+            for _, ti in pairs{0, 0.0} do     -- try 'i' as integer and as float
+              for _, tj in pairs{0, 0.0} do   -- try 'j' as integer and as float
+                local x = i + ti
+                local y = j + tj
+                  assert(i//j == math.floor(i/j))
+              end
+            end
+          end
+        end
+
+        assert(1//0.0 == 1/0)
+        assert(-1 // 0.0 == -1/0)
+        assert(eqT(3.5 // 1.5, 2.0))
+        assert(eqT(3.5 // -1.5, -3.0))
+
+        assert(maxint // maxint == 1)
+        assert(maxint // 1 == maxint)
+        assert((maxint - 1) // maxint == 0)
+        assert(maxint // (maxint - 1) == 1)
+        assert(minint // minint == 1)
+        assert(minint // minint == 1)
+        assert((minint + 1) // minint == 0)
+        assert(minint // (minint + 1) == 1)
+        assert(minint // 1 == minint)
+
+        assert(minint // -1 == -minint)
+        assert(minint // -2 == 2^(intbits - 2))
+        assert(maxint // -1 == -maxint)
+    `, 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] math: negative exponents", function (t) {
+    let luaCode = `
+        do
+          assert(2^-3 == 1 / 2^3)
+          assert(eq((-3)^-3, 1 / (-3)^3))
+          for i = -3, 3 do    -- variables avoid constant folding
+              for j = -3, 3 do
+                -- domain errors (0^(-n)) are not portable
+                if not _port or i ~= 0 or j > 0 then
+                  assert(eq(i^j, 1 / i^(-j)))
+               end
+            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] math: comparison between floats and integers (border cases)", function (t) {
+    let luaCode = `
+        if floatbits < intbits then
+          assert(2.0^floatbits == (1 << floatbits))
+          assert(2.0^floatbits - 1.0 == (1 << floatbits) - 1.0)
+          assert(2.0^floatbits - 1.0 ~= (1 << floatbits))
+          -- float is rounded, int is not
+          assert(2.0^floatbits + 1.0 ~= (1 << floatbits) + 1)
+        else   -- floats can express all integers with full accuracy
+          assert(maxint == maxint + 0.0)
+          assert(maxint - 1 == maxint - 1.0)
+          assert(minint + 1 == minint + 1.0)
+          assert(maxint ~= maxint - 1.0)
+        end
+        assert(maxint + 0.0 == 2.0^(intbits - 1) - 1.0)
+        assert(minint + 0.0 == minint)
+        assert(minint + 0.0 == -2.0^(intbits - 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] math: order between floats and integers", function (t) {
+    let luaCode = `
+        assert(minint == 1 << (intbits - 1))
+        assert(maxint == minint - 1)
+
+        assert(1 < 1.1); assert(not (1 < 0.9))
+        assert(1 <= 1.1); assert(not (1 <= 0.9))
+        assert(-1 < -0.9); assert(not (-1 < -1.1))
+        assert(1 <= 1.1); assert(not (-1 <= -1.1))
+        assert(-1 < -0.9); assert(not (-1 < -1.1))
+        assert(-1 <= -0.9); assert(not (-1 <= -1.1))
+        assert(minint <= minint + 0.0)
+        assert(minint + 0.0 <= minint)
+        assert(not (minint < minint + 0.0))
+        assert(not (minint + 0.0 < minint))
+        assert(maxint < minint * -1.0)
+        assert(maxint <= minint * -1.0)
+
+        do
+          local fmaxi1 = 2^(intbits - 1)
+          assert(maxint < fmaxi1)
+          assert(maxint <= fmaxi1)
+          assert(not (fmaxi1 <= maxint))
+          assert(minint <= -2^(intbits - 1))
+          assert(-2^(intbits - 1) <= minint)
+        end
+
+        if floatbits < intbits then
+          print("testing order (floats cannot represent all integers)")
+          local fmax = 2^floatbits
+          local ifmax = fmax | 0
+          assert(fmax < ifmax + 1)
+          assert(fmax - 1 < ifmax)
+          assert(-(fmax - 1) > -ifmax)
+          assert(not (fmax <= ifmax - 1))
+          assert(-fmax > -(ifmax + 1))
+          assert(not (-fmax >= -(ifmax - 1)))
+
+          assert(fmax/2 - 0.5 < ifmax//2)
+          assert(-(fmax/2 - 0.5) > -ifmax//2)
+
+          assert(maxint < 2^intbits)
+          assert(minint > -2^intbits)
+          assert(maxint <= 2^intbits)
+          assert(minint >= -2^intbits)
+        else
+          print("testing order (floats can represent all integers)")
+          assert(maxint < maxint + 1.0)
+          assert(maxint < maxint + 0.5)
+          assert(maxint - 1.0 < maxint)
+          assert(maxint - 0.5 < maxint)
+          assert(not (maxint + 0.0 < maxint))
+          assert(maxint + 0.0 <= maxint)
+          assert(not (maxint < maxint + 0.0))
+          assert(maxint + 0.0 <= maxint)
+          assert(maxint <= maxint + 0.0)
+          assert(not (maxint + 1.0 <= maxint))
+          assert(not (maxint + 0.5 <= maxint))
+          assert(not (maxint <= maxint - 1.0))
+          assert(not (maxint <= maxint - 0.5))
+
+          assert(minint < minint + 1.0)
+          assert(minint < minint + 0.5)
+          assert(minint <= minint + 0.5)
+          assert(minint - 1.0 < minint)
+          assert(minint - 1.0 <= minint)
+          assert(not (minint + 0.0 < minint))
+          assert(not (minint + 0.5 < minint))
+          assert(not (minint < minint + 0.0))
+          assert(minint + 0.0 <= minint)
+          assert(minint <= minint + 0.0)
+          assert(not (minint + 1.0 <= minint))
+          assert(not (minint + 0.5 <= minint))
+          assert(not (minint <= minint - 1.0))
+        end
+
+        do
+          local NaN = 0/0
+          assert(not (NaN < 0))
+          assert(not (NaN > minint))
+          assert(not (NaN <= -9))
+          assert(not (NaN <= maxint))
+          assert(not (NaN < maxint))
+          assert(not (minint <= NaN))
+          assert(not (minint < NaN))
+        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] math: avoiding errors at compile time", function (t) {
+    let luaCode = `
+        checkcompt("divide by zero", "return 2 // 0")
+        checkcompt(msgf2i, "return 2.3 >> 0")
+        checkcompt(msgf2i, ("return 2.0^%d & 1"):format(intbits - 1))
+        checkcompt("field 'huge'", "return math.huge << 1")
+        checkcompt(msgf2i, ("return 1 | 2.0^%d"):format(intbits - 1))
+        checkcompt(msgf2i, "return 2.3 ~ '0.0'")
+    `, 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] math: testing overflow errors when converting from float to integer (runtime)", function (t) {
+    let luaCode = `
+        local function f2i (x) return x | x end
+        checkerror(msgf2i, f2i, math.huge)     -- +inf
+        checkerror(msgf2i, f2i, -math.huge)    -- -inf
+        checkerror(msgf2i, f2i, 0/0)           -- NaN
+
+        if floatbits < intbits then
+          -- conversion tests when float cannot represent all integers
+          assert(maxint + 1.0 == maxint + 0.0)
+          assert(minint - 1.0 == minint + 0.0)
+          checkerror(msgf2i, f2i, maxint + 0.0)
+          assert(f2i(2.0^(intbits - 2)) == 1 << (intbits - 2))
+          assert(f2i(-2.0^(intbits - 2)) == -(1 << (intbits - 2)))
+          assert((2.0^(floatbits - 1) + 1.0) // 1 == (1 << (floatbits - 1)) + 1)
+          -- maximum integer representable as a float
+          local mf = maxint - (1 << (floatbits - intbits)) + 1
+          assert(f2i(mf + 0.0) == mf)  -- OK up to here
+          mf = mf + 1
+          assert(f2i(mf + 0.0) ~= mf)   -- no more representable
+        else
+          -- conversion tests when float can represent all integers
+          assert(maxint + 1.0 > maxint)
+          assert(minint - 1.0 < minint)
+          assert(f2i(maxint + 0.0) == maxint)
+          checkerror("no integer rep", f2i, maxint + 1.0)
+          checkerror("no integer rep", f2i, minint - 1.0)
+        end
+
+        -- 'minint' should be representable as a float no matter the precision
+        assert(f2i(minint + 0.0) == minint)
+    `, 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] math: testing numeric strings", function (t) {
+    let luaCode = `
+        assert("2" + 1 == 3)
+        assert("2 " + 1 == 3)
+        assert(" -2 " + 1 == -1)
+        assert(" -0xa " + 1 == -9)
+    `, 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] math: Literal integer Overflows (new behavior in 5.3.3)", function (t) {
+    let luaCode = `
+        do
+          -- no overflows
+          assert(eqT(tonumber(tostring(maxint)), maxint))
+          assert(eqT(tonumber(tostring(minint)), minint))
+
+          -- add 1 to last digit as a string (it cannot be 9...)
+          local function incd (n)
+            local s = string.format("%d", n)
+            s = string.gsub(s, "%d$", function (d)
+                  assert(d ~= '9')
+                  return string.char(string.byte(d) + 1)
+                end)
+            return s
+          end
+
+          -- 'tonumber' with overflow by 1
+          assert(eqT(tonumber(incd(maxint)), maxint + 1.0))
+          assert(eqT(tonumber(incd(minint)), minint - 1.0))
+
+          -- large numbers
+          assert(eqT(tonumber("1"..string.rep("0", 30)), 1e30))
+          assert(eqT(tonumber("-1"..string.rep("0", 30)), -1e30))
+
+          -- hexa format still wraps around
+          assert(eqT(tonumber("0x1"..string.rep("0", 30)), 0))
+
+          -- lexer in the limits
+          assert(minint == load("return " .. minint)())
+          assert(eqT(maxint, load("return " .. maxint)()))
+
+          assert(eqT(10000000000000000000000.0, 10000000000000000000000))
+          assert(eqT(-10000000000000000000000.0, -10000000000000000000000))
+        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] math: 'tonumber' with numbers", function (t) {
+    let luaCode = `
+        assert(tonumber(3.4) == 3.4)
+        assert(eqT(tonumber(3), 3))
+        assert(eqT(tonumber(maxint), maxint) and eqT(tonumber(minint), minint))
+        assert(tonumber(1/0) == 1/0)
+    `, 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] math: 'tonumber' with strings", function (t) {
+    let luaCode = `
+        assert(tonumber("0") == 0)
+        assert(tonumber("") == nil)
+        assert(tonumber("  ") == nil)
+        assert(tonumber("-") == nil)
+        assert(tonumber("  -0x ") == nil)
+        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") == (1 << (4*12)) - 1)
+        assert(tonumber("0x"..string.rep("f", (intbits//4))) == -1)
+        assert(tonumber("-0x"..string.rep("f", (intbits//4))) == 1)
+
+        -- 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', (intbits - 2)), 2) + 1 == 2^(intbits - 2))
+        assert(tonumber('ffffFFFF', 16)+1 == (1 << 32))
+        assert(tonumber('0ffffFFFF', 16)+1 == (1 << 32))
+        assert(tonumber('-0ffffffFFFF', 16) - 1 == -(1 << 40))
+        for i = 2,36 do
+          local i2 = i * i
+          local i10 = i2 * i2 * i2 * i2 * i2      -- i^10
+          assert(tonumber('\\t10000000000\\t', i) == i10)
+        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] math: tests with very long numerals", { skip: true }, function (t) {
+    let luaCode = `
+        assert(tonumber("0x"..string.rep("f", 13)..".0") == 2.0^(4*13) - 1)
+        assert(tonumber("0x"..string.rep("f", 150)..".0") == 2.0^(4*150) - 1)
+        assert(tonumber("0x"..string.rep("f", 300)..".0") == 2.0^(4*300) - 1)
+        assert(tonumber("0x"..string.rep("f", 500)..".0") == 2.0^(4*500) - 1)
+        assert(tonumber('0x3.' .. string.rep('0', 1000)) == 3)
+        assert(tonumber('0x' .. string.rep('0', 1000) .. 'a') == 10)
+        assert(tonumber('0x0.' .. string.rep('0', 13).."1") == 2.0^(-4*14))
+        assert(tonumber('0x0.' .. string.rep('0', 150).."1") == 2.0^(-4*151))
+        assert(tonumber('0x0.' .. string.rep('0', 300).."1") == 2.0^(-4*301))
+        assert(tonumber('0x0.' .. string.rep('0', 500).."1") == 2.0^(-4*501))
+
+        assert(tonumber('0xe03' .. string.rep('0', 1000) .. 'p-4000') == 3587.0)
+        assert(tonumber('0x.' .. string.rep('0', 1000) .. '74p4004') == 0x7.4)
+    `, 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] math: testing 'tonumber' for invalid formats", function (t) {
+    let luaCode = `
+        local function f (...)
+          if select('#', ...) == 1 then
+            return (...)
+          else
+            return "***"
+          end
+        end
+
+        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  a', 2)) == 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)
+    `, 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] math: testing 'tonumber' for invalid hexadecimal formats", function (t) {
+    let luaCode = `
+        assert(tonumber('0x') == nil)
+        assert(tonumber('x') == nil)
+        assert(tonumber('x3') == nil)
+        assert(tonumber('0x3.3.3') == nil)   -- two decimal points
+        assert(tonumber('00x2') == nil)
+        assert(tonumber('0x 2') == nil)
+        assert(tonumber('0 x2') == nil)
+        assert(tonumber('23x') == nil)
+        assert(tonumber('- 0xaa') == nil)
+        assert(tonumber('-0xaaP ') == nil)   -- no exponent
+        assert(tonumber('0x0.51p') == nil)
+        assert(tonumber('0x5p+-2') == 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] math: testing hexadecimal numerals", function (t) {
+    let luaCode = `
+        assert(0x10 == 16 and 0xfff == 2^12 - 1 and 0XFB == 251)
+        assert(0x0p12 == 0 and 0x.0p-3 == 0)
+        assert(0xFFFFFFFF == (1 << 32) - 1)
+        assert(tonumber('+0x2') == 2)
+        assert(tonumber('-0xaA') == -170)
+        assert(tonumber('-0xffFFFfff') == -(1 << 32) + 1)
+
+        -- possible confusion with decimal exponent
+        assert(0E+1 == 0 and 0xE+1 == 15 and 0xe-1 == 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] math: floating hexas", function (t) {
+    let luaCode = `
+        assert(tonumber('  0x2.5  ') == 0x25/16)
+        assert(tonumber('  -0x2.5  ') == -0x25/16)
+        assert(tonumber('  +0x0.51p+8  ') == 0x51)
+        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(0Xabcdef.0 == 0x.ABCDEFp+24)
+
+
+        assert(1.1 == 1.+.1)
+        assert(100.0 == 1E2 and .01 == 1e-2)
+        assert(1111111111 - 1111111110 == 1000.00e-03)
+        assert(1.1 == '1.'+'.1')
+        assert(tonumber'1111111111' - tonumber'1111111110' ==
+               tonumber"  +0.001e+3 \\n\\t")
+
+        assert(0.1e-30 > 0.9E-31 and 0.9E30 < 0.1e31)
+
+        assert(0.123456 > 0.123455)
+
+        assert(tonumber('+1.23E18') == 1.23*10.0^18)
+    `, 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] math: testing order operators", function (t) {
+    let luaCode = `
+        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'))
+        assert(1.3 < 1.4 and 1.3 <= 1.4 and not (1.3 < 1.3) and 1.3 <= 1.3)
+    `, 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] math: testing mod operator", function (t) {
+    let luaCode = `
+        assert(eqT(-4 % 3, 2))
+        assert(eqT(4 % -3, -2))
+        assert(eqT(-4.0 % 3, 2.0))
+        assert(eqT(4 % -3.0, -2.0))
+        assert(math.pi - math.pi % 1 == 3)
+        assert(math.pi - math.pi % 0.001 == 3.141)
+
+        assert(eqT(minint % minint, 0))
+        assert(eqT(maxint % maxint, 0))
+        assert((minint + 1) % minint == minint + 1)
+        assert((maxint - 1) % maxint == maxint - 1)
+        assert(minint % maxint == maxint - 1)
+
+        assert(minint % -1 == 0)
+        assert(minint % -2 == 0)
+        assert(maxint % -2 == -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] math: non-portable tests because Windows C library cannot compute fmod(1, huge) correctly", function (t) {
+    let luaCode = `
+        local function anan (x) assert(isNaN(x)) end   -- assert Not a Number
+        anan(0.0 % 0)
+        anan(1.3 % 0)
+        anan(math.huge % 1)
+        anan(math.huge % 1e30)
+        anan(-math.huge % 1e30)
+        anan(-math.huge % -1e30)
+        assert(1 % math.huge == 1)
+        assert(1e30 % math.huge == 1e30)
+        assert(1e30 % -math.huge == -math.huge)
+        assert(-1 % math.huge == math.huge)
+        assert(-1 % -math.huge == -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] math: testing unsigned comparisons", function (t) {
+    let luaCode = `
+        assert(math.ult(3, 4))
+        assert(not math.ult(4, 4))
+        assert(math.ult(-2, -1))
+        assert(math.ult(2, -1))
+        assert(not math.ult(-2, -2))
+        assert(math.ult(maxint, minint))
+        assert(not math.ult(minint, maxint))
+
+
+        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.43) == 10.43)
+        assert(eqT(math.abs(minint), minint))
+        assert(eqT(math.abs(maxint), maxint))
+        assert(eqT(math.abs(-maxint), maxint))
+        assert(eq(math.atan(1,0), math.pi/2))
+        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))))
+
+
+        assert(tonumber(' 1.3e-2 ') == 1.3e-2)
+        assert(tonumber(' -1.00000000000001 ') == -1.00000000000001)
+    `, 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] math: testing constant limits", function (t) {
+    let luaCode = `
+        assert(8388609 + -8388609 == 0)
+        assert(8388608 + -8388608 == 0)
+        assert(8388607 + -8388607 == 0)
+    `, 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] math: testing floor & ceil", function (t) {
+    let luaCode = `
+        do
+          assert(eqT(math.floor(3.4), 3))
+          assert(eqT(math.ceil(3.4), 4))
+          assert(eqT(math.floor(-3.4), -4))
+          assert(eqT(math.ceil(-3.4), -3))
+          assert(eqT(math.floor(maxint), maxint))
+          assert(eqT(math.ceil(maxint), maxint))
+          assert(eqT(math.floor(minint), minint))
+          assert(eqT(math.floor(minint + 0.0), minint))
+          assert(eqT(math.ceil(minint), minint))
+          assert(eqT(math.ceil(minint + 0.0), minint))
+          assert(math.floor(1e50) == 1e50)
+          assert(math.ceil(1e50) == 1e50)
+          assert(math.floor(-1e50) == -1e50)
+          assert(math.ceil(-1e50) == -1e50)
+          for _, p in pairs{31,32,63,64} do
+            assert(math.floor(2^p) == 2^p)
+            assert(math.floor(2^p + 0.5) == 2^p)
+            assert(math.ceil(2^p) == 2^p)
+            assert(math.ceil(2^p - 0.5) == 2^p)
+          end
+          checkerror("number expected", math.floor, {})
+          checkerror("number expected", math.ceil, print)
+          assert(eqT(math.tointeger(minint), minint))
+          assert(eqT(math.tointeger(minint .. ""), minint))
+          assert(eqT(math.tointeger(maxint), maxint))
+          assert(eqT(math.tointeger(maxint .. ""), maxint))
+          assert(eqT(math.tointeger(minint + 0.0), minint))
+          assert(math.tointeger(0.0 - minint) == nil)
+          assert(math.tointeger(math.pi) == nil)
+          assert(math.tointeger(-math.pi) == nil)
+          assert(math.floor(math.huge) == math.huge)
+          assert(math.ceil(math.huge) == math.huge)
+          assert(math.tointeger(math.huge) == nil)
+          assert(math.floor(-math.huge) == -math.huge)
+          assert(math.ceil(-math.huge) == -math.huge)
+          assert(math.tointeger(-math.huge) == nil)
+          assert(math.tointeger("34.0") == 34)
+          assert(math.tointeger("34.3") == nil)
+          assert(math.tointeger({}) == nil)
+          assert(math.tointeger(0/0) == nil)    -- NaN
+        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] math: testing fmod for integers", function (t) {
+    let luaCode = `
+        for i = -6, 6 do
+          for j = -6, 6 do
+            if j ~= 0 then
+              local mi = math.fmod(i, j)
+              local mf = math.fmod(i + 0.0, j)
+              assert(mi == mf)
+              assert(math.type(mi) == 'integer' and math.type(mf) == 'float')
+              if (i >= 0 and j >= 0) or (i <= 0 and j <= 0) or mi == 0 then
+                assert(eqT(mi, i % j))
+              end
+            end
+          end
+        end
+        assert(eqT(math.fmod(minint, minint), 0))
+        assert(eqT(math.fmod(maxint, maxint), 0))
+        assert(eqT(math.fmod(minint + 1, minint), minint + 1))
+        assert(eqT(math.fmod(maxint - 1, maxint), maxint - 1))
+
+        checkerror("zero", math.fmod, 3, 0)
+    `, 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] math: testing max/min", function (t) {
+    let luaCode = `
+        do
+          checkerror("value expected", math.max)
+          checkerror("value expected", math.min)
+          assert(eqT(math.max(3), 3))
+          assert(eqT(math.max(3, 5, 9, 1), 9))
+          assert(math.max(maxint, 10e60) == 10e60)
+          assert(eqT(math.max(minint, minint + 1), minint + 1))
+          assert(eqT(math.min(3), 3))
+          assert(eqT(math.min(3, 5, 9, 1), 1))
+          assert(math.min(3.2, 5.9, -9.2, 1.1) == -9.2)
+          assert(math.min(1.9, 1.7, 1.72) == 1.7)
+          assert(math.min(-10e60, minint) == -10e60)
+          assert(eqT(math.min(maxint, maxint - 1), maxint - 1))
+          assert(eqT(math.min(maxint - 2, maxint, maxint - 1), maxint - 2))
+        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] math: testing implicit convertions", function (t) {
+    let luaCode = `
+        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')
+    `, 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] math: testing -0 and NaN", function (t) {
+    let luaCode = `
+        do
+          print("testing -0 and NaN")
+          local mz, z = -0.0, 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)
+          a[z] = 2
+          assert(a[z] == 2 and a[mz] == 2)
+          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(rawset, a, NaN, 1))
+          assert(a[NaN] == nil)
+          a[1] = 1
+          assert(not pcall(rawset, a, NaN, 1))
+          assert(a[NaN] == nil)
+          -- strings with same binary representation as 0.0 (might 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
+    `, 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] math: test random for floats", function (t) {
+    let luaCode = `
+        math.randomseed(0)
+
+        do   -- test random for floats
+          local max = -math.huge
+          local min = math.huge
+          for i = 0, 20000 do
+            local t = math.random()
+            assert(0 <= t and t < 1)
+            max = math.max(max, t)
+            min = math.min(min, t)
+            if eq(max, 1, 0.001) and eq(min, 0, 0.001) then
+              goto ok
+            end
+          end
+          -- loop ended without satisfing condition
+          assert(false)
+         ::ok::
+        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] math: test random for small intervals", function (t) {
+    let luaCode = `
+        math.randomseed(0)
+
+        do
+          local function aux (p, lim)   -- test random for small intervals
+            local x1, x2
+            if #p == 1 then x1 = 1; x2 = p[1]
+            else x1 = p[1]; x2 = p[2]
+            end
+            local mark = {}; local count = 0   -- to check that all values appeared
+            for i = 0, lim or 2000 do
+              local t = math.random(table.unpack(p))
+              assert(x1 <= t and t <= x2)
+              if not mark[t] then  -- new value
+                mark[t] = true
+                count = count + 1
+              end
+              if count == x2 - x1 + 1 then   -- all values appeared; OK
+                goto ok
+              end
+            end
+            -- loop ended without satisfing condition
+            assert(false)
+           ::ok::
+          end
+
+          aux({-10,0})
+          aux({6})
+          aux({-10, 10})
+          aux({minint, minint})
+          aux({maxint, maxint})
+          aux({minint, minint + 9})
+          aux({maxint - 3, maxint})
+        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] math: test random for large intervals", function (t) {
+    let luaCode = `
+        math.randomseed(0)
+
+        do
+          local function aux(p1, p2)       -- test random for large intervals
+            local max = minint
+            local min = maxint
+            local n = 200
+            local mark = {}; local count = 0   -- to count how many different values
+            for _ = 1, n do
+              local t = math.random(p1, p2)
+              max = math.max(max, t)
+              min = math.min(min, t)
+              if not mark[t] then  -- new value
+                mark[t] = true
+                count = count + 1
+              end
+            end
+            -- at least 80% of values are different
+            assert(count >= n * 0.8)
+            -- min and max not too far from formal min and max
+            local diff = (p2 - p1) // 8
+            assert(min < p1 + diff and max > p2 - diff)
+          end
+          aux(0, maxint)
+          aux(1, maxint)
+          aux(minint, -1)
+          aux(minint // 2, maxint // 2)
+        end
+
+        for i=1,100 do
+          assert(math.random(maxint) > 0)
+          assert(math.random(minint, -1) < 0)
+        end
+
+        assert(not pcall(math.random, 1, 2, 3))    -- too many arguments
+    `, 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] math: test random for empty interval", function (t) {
+    let luaCode = `
+        math.randomseed(0)
+
+        assert(not pcall(math.random, minint + 1, minint))
+        assert(not pcall(math.random, maxint, maxint - 1))
+        assert(not pcall(math.random, maxint, minint))
+    `, 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] math: interval too large", function (t) {
+    let luaCode = `
+        math.randomseed(0)
+
+        assert(not pcall(math.random, minint, 0))
+        assert(not pcall(math.random, -1, maxint))
+        assert(not pcall(math.random, minint // 2, maxint // 2 + 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");
+
+});
diff --git a/tests/test-suite/inprogress/nextvar.js b/tests/test-suite/inprogress/nextvar.js
new file mode 100644
index 0000000..6cf7c74
--- /dev/null
+++ b/tests/test-suite/inprogress/nextvar.js
@@ -0,0 +1,1183 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+const prefix = `
+    local function checkerror (msg, f, ...)
+      local s, err = pcall(f, ...)
+      assert(not s and string.find(err, msg))
+    end
+`;
+
+test("[test-suite] nextvar: testing size operator", function (t) {
+    let luaCode = `
+        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
+    `, 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] nextvar: testing ipairs", function (t) {
+    let luaCode = `
+        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
+    `, 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] nextvar: test for 'false' x ipair", function (t) {
+    let luaCode = `
+        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)
+    `, 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] nextvar: iterator function is always the same", function (t) {
+    let luaCode = `
+        assert(type(ipairs{}) == 'function' and ipairs{} == ipairs{})
+    `, 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] nextvar: JS tests", { skip: true }, function (t) {
+    let luaCode = `
+        -- 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
+        for a = 1, 10000 do   -- all numbers up to 10^4
+          local n = fb(a)
+          assert(a <= n and n <= a*1.125)
+        end
+        local a = 1024   -- plus a few up to 2 ^30
+        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)
+        do
+          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
+    `, 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] nextvar: test size operation on empty tables", function (t) {
+    let luaCode = `
+        assert(#{} == 0)
+        assert(#{nil} == 0)
+        assert(#{nil, nil} == 0)
+        assert(#{nil, nil, nil} == 0)
+        assert(#{nil, nil, nil, nil} == 0)
+    `, 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] nextvar: test size operation on empty tables", function (t) {
+    let luaCode = `
+        assert(#{} == 0)
+        assert(#{nil} == 0)
+        assert(#{nil, nil} == 0)
+        assert(#{nil, nil, nil} == 0)
+        assert(#{nil, nil, nil, nil} == 0)
+    `, 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] nextvar: next uses always the same iteration function", function (t) {
+    let luaCode = `
+        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"))
+    `, 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] nextvar: invalid key to 'next'", function (t) {
+    let luaCode = `
+        checkerror("invalid key", next, {10,20}, 3)
+    `, 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] nextvar: both 'pairs' and 'ipairs' need an argument", function (t) {
+    let luaCode = `
+        checkerror("bad argument", pairs)
+        checkerror("bad argument", ipairs)
+    `, 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] nextvar: fmod table", function (t) {
+    let luaCode = `
+        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
+    `, 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] nextvar: check next", function (t) {
+    let luaCode = `
+        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}
+    `, 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] nextvar: # operator", function (t) {
+    let luaCode = `
+        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
+    `, 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] nextvar: maxn", function (t) {
+    let luaCode = `
+        -- '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
+    `, 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] nextvar: int overflow", function (t) {
+    let luaCode = `
+        a = {}
+        for i=0,50 do a[2^i] = true end
+        assert(a[#a])
+    `, 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] nextvar: erasing values", function (t) {
+    let luaCode = `
+        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)
+    `, 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] nextvar: testing table library with metamethods", function (t) {
+    let luaCode = `
+        do
+          local function test (proxy, t)
+            for i = 1, 10 do
+              table.insert(proxy, 1, i)
+            end
+            assert(#proxy == 10 and #t == 10)
+            for i = 1, 10 do
+              assert(t[i] == 11 - i)
+            end
+            table.sort(proxy)
+            for i = 1, 10 do
+              assert(t[i] == i and proxy[i] == i)
+            end
+            assert(table.concat(proxy, ",") == "1,2,3,4,5,6,7,8,9,10")
+            for i = 1, 8 do
+              assert(table.remove(proxy, 1) == i)
+            end
+            assert(#proxy == 2 and #t == 2)
+            local a, b, c = table.unpack(proxy)
+            assert(a == 9 and b == 10 and c == nil)
+          end
+
+          -- all virtual
+          local t = {}
+          local proxy = setmetatable({}, {
+            __len = function () return #t end,
+            __index = t,
+            __newindex = t,
+          })
+          test(proxy, t)
+
+          -- only __newindex
+          local count = 0
+          t = setmetatable({}, {
+            __newindex = function (t,k,v) count = count + 1; rawset(t,k,v) end})
+          test(t, t)
+          assert(count == 10)   -- after first 10, all other sets are not new
+
+          -- no __newindex
+          t = setmetatable({}, {
+            __index = function (_,k) return k + 1 end,
+            __len = function (_) return 5 end})
+          assert(table.concat(t, ";") == "2;3;4;5;6")
+
+        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] nextvar: JS tests", { skip: true }, function (t) {
+    let luaCode = `
+        local tab = {10, 20, 30}
+        local mt = {}
+        local u = T.newuserdata(0)
+        checkerror("table expected", table.insert, u, 40)
+        checkerror("table expected", table.remove, u)
+        debug.setmetatable(u, mt)
+        checkerror("table expected", table.insert, u, 40)
+        checkerror("table expected", table.remove, u)
+        mt.__index = tab
+        checkerror("table expected", table.insert, u, 40)
+        checkerror("table expected", table.remove, u)
+        mt.__newindex = tab
+        checkerror("table expected", table.insert, u, 40)
+        checkerror("table expected", table.remove, u)
+        mt.__len = function () return #tab end
+        table.insert(u, 40)
+        assert(#u == 4 and #tab == 4 and u[4] == 40 and tab[4] == 40)
+        assert(table.remove(u) == 40)
+        table.insert(u, 1, 50)
+        assert(#u == 4 and #tab == 4 and u[4] == 30 and tab[1] == 50)
+
+        mt.__newindex = nil
+        mt.__len = nil
+        local tab2 = {}
+        local u2 = T.newuserdata(0) 
+        debug.setmetatable(u2, {__newindex = function (_, k, v) tab2[k] = v end})
+        table.move(u, 1, 4, 1, u2)
+        assert(#tab2 == 4 and tab2[1] == tab[1] and tab2[4] == tab[4])
+    `, 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] nextvar: next", function (t) {
+    let luaCode = `
+        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)
+    `, 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");
+
+});
+
+
+// TODO: infinite loop ?
+test("[test-suite] nextvar: testing floats in numeric for", { skip: true }, function (t) {
+    let luaCode = `
+        do
+          local a
+          -- integer count
+          a = 0; for i=1, 1, 1 do a=a+1 end; assert(a==1)
+          a = 0; for i=10000, 1e4, -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=9999, 1e4, -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)
+
+          -- float count
+          a = 0; for i=0, 0.999999999, 0.1 do a=a+1 end; assert(a==10)
+          a = 0; for i=1.0, 1, 1 do a=a+1 end; assert(a==1)
+          a = 0; for i=-1.5, -1.5, 1 do a=a+1 end; assert(a==1)
+          a = 0; for i=1e6, 1e6, -1 do a=a+1 end; assert(a==1)
+          a = 0; for i=1.0, 0.99999, 1 do a=a+1 end; assert(a==0)
+          a = 0; for i=99999, 1e5, -1.0 do a=a+1 end; assert(a==0)
+          a = 0; for i=1.0, 0.99999, -1 do a=a+1 end; assert(a==1)
+        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] nextvar: conversion", function (t) {
+    let luaCode = `
+        a = 0; for i="10","1","-2" do a=a+1 end; assert(a==5)
+    `, 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] nextvar: checking types", function (t) {
+    let luaCode = `
+        do
+          local c
+          local function checkfloat (i)
+            assert(math.type(i) == "float")
+            c = c + 1
+          end
+
+          c = 0; for i = 1.0, 10 do checkfloat(i) end
+          assert(c == 10)
+
+          c = 0; for i = -1, -10, -1.0 do checkfloat(i) end
+          assert(c == 10)
+
+          local function checkint (i)
+            assert(math.type(i) == "integer")
+            c = c + 1
+          end
+
+          local m = math.maxinteger
+          c = 0; for i = m, m - 10, -1 do checkint(i) end
+          assert(c == 11)
+
+          c = 0; for i = 1, 10.9 do checkint(i) end
+          assert(c == 10)
+
+          c = 0; for i = 10, 0.001, -1 do checkint(i) end
+          assert(c == 10)
+
+          c = 0; for i = 1, "10.8" do checkint(i) end
+          assert(c == 10)
+
+          c = 0; for i = 9, "3.4", -1 do checkint(i) end
+          assert(c == 6)
+
+          c = 0; for i = 0, " -3.4  ", -1 do checkint(i) end
+          assert(c == 4)
+
+          c = 0; for i = 100, "96.3", -2 do checkint(i) end
+          assert(c == 2)
+
+          c = 0; for i = 1, math.huge do if i > 10 then break end; checkint(i) end
+          assert(c == 10)
+
+          c = 0; for i = -1, -math.huge, -1 do
+                   if i < -10 then break end; checkint(i)
+                  end
+          assert(c == 10)
+
+
+          for i = math.mininteger, -10e100 do assert(false) end
+          for i = math.maxinteger, 10e100, -1 do assert(false) 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] nextvar: testing generic 'for'", function (t) {
+    let luaCode = `
+        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)
+    `, 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] nextvar: testing __pairs and __ipairs metamethod", function (t) {
+    let luaCode = `
+        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
+    `, 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] nextvar: testing ipairs with metamethods", function (t) {
+    let luaCode = `
+        a = {n=10}
+        setmetatable(a, { __index = function (t,k)
+                             if k <= t.n then return k * 10 end 
+                          end})
+        i = 0
+        for k,v in ipairs(a) do
+          i = i + 1
+          assert(k == i and v == i * 10)
+        end
+        assert(i == a.n)
+    `, 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");
+
+});
diff --git a/tests/test-suite/inprogress/pm.js b/tests/test-suite/inprogress/pm.js
new file mode 100644
index 0000000..1a45752
--- /dev/null
+++ b/tests/test-suite/inprogress/pm.js
@@ -0,0 +1,806 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+test("[test-suite] pm: pattern matching", function (t) {
+    let luaCode = `
+        function f(s, p)
+          local i,e = string.find(s, p)
+          if i then return string.sub(s, i, e) end
+        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")
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: tonumber", function (t) {
+    let luaCode = `
+        function f1(s, p)
+          p = string.gsub(p, "%%([0-9])", function (s)
+                return "%" .. (tonumber(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
+
+        -- 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)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: range", function (t) {
+    let luaCode = `
+        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)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: range (strset)", function (t) {
+    let luaCode = `
+        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]'))
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: classes", function (t) {
+    let luaCode = `
+        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)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: gsub", function (t) {
+    let luaCode = `
+        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')
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: empty matches", function (t) {
+    let luaCode = `
+        do   -- new (5.3.3) semantics for empty matches
+          assert(string.gsub("a b cd", " *", "-") == "-a-b-c-d-")
+
+          local res = ""
+          local sub = "a  \\nbc\\t\\td"
+          local i = 1
+          for p, e in string.gmatch(sub, "()%s*()") do
+            res = res .. string.sub(sub, i, p - 1) .. "-"
+            i = e
+          end
+          assert(res == "-a-b-c-d-")
+        end
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: gsub", function (t) {
+    let luaCode = `
+        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='x'$ novamente $return a$",
+                           "$([^$]*)%$",
+                           dostring) == "alo  novamente x")
+
+        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)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: gsub isbalanced", function (t) {
+    let luaCode = `
+        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')
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: capture", function (t) {
+    let luaCode = `
+        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)
+
+        checkerror("invalid replacement value %(a table%)",
+                    string.gsub, "alo", ".", {a = {}})
+        checkerror("invalid capture index %%2", string.gsub, "alo", ".", "%2")
+        checkerror("invalid capture index %%0", string.gsub, "alo", "(%0)", "a")
+        checkerror("invalid capture index %%1", string.gsub, "alo", "(%1)", "a")
+        checkerror("invalid use of '%%'", string.gsub, "alo", ".", "%x")
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: bug since 2.5 (C-stack overflow) (TODO: _soft)", function (t) {
+    let luaCode = `
+        _soft = true
+        if not _soft then -- TODO
+          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
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: big strings (TODO: _soft)", function (t) {
+    let luaCode = `
+        _soft = true -- TODO
+        if not _soft then
+          print("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
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: recursive nest of gsubs", function (t) {
+    let luaCode = `
+        function rev (s)
+          return string.gsub(s, "(.)(.+)", function (c,s1) return rev(s1)..c end)
+        end
+
+        local x = "abcdef"
+        assert(rev(rev(x)) == x)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: gsub with tables", function (t) {
+    let luaCode = `
+        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", "().", {'x','yy','zzz'}) == "xyyzzz 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")
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: gmatch", function (t) {
+    let luaCode = `
+        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[tonumber(i)] = tonumber(j)
+        end
+        a = 0
+        for k,v in pairs(t) do assert(k+1 == v+0); a=a+1 end
+        assert(a == 3)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: tests for '%f' ('frontiers')", function (t) {
+    let luaCode = `
+        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)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: malformed patterns", function (t) {
+    let luaCode = `
+        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("(.", "unfinished capture")
+        malform(".)", "invalid pattern capture")
+        malform("[a")
+        malform("[]")
+        malform("[^]")
+        malform("[a%]")
+        malform("[a%")
+        malform("%b")
+        malform("%ba")
+        malform("%")
+        malform("%f", "missing")
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: \\0 in patterns", function (t) {
+    let luaCode = `
+        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")
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
+
+
+test("[test-suite] pm: magic char after \\0", function (t) {
+    let luaCode = `
+        assert(string.find("abc\\0\\0","\\0.") == 4)
+        assert(string.find("abcx\\0\\0abc\\0abc","x\\0\\0abc\\0a.") == 4)
+    `, L;
+    
+    t.plan(2);
+
+    t.doesNotThrow(function () {
+
+        L = lauxlib.luaL_newstate();
+
+        lualib.luaL_openlibs(L);
+
+        lauxlib.luaL_loadstring(L, lua.to_luastring(luaCode));
+
+    }, "Lua program loaded without error");
+
+    t.doesNotThrow(function () {
+
+        lua.lua_call(L, 0, -1);
+
+    }, "Lua program ran without error");
+
+});
diff --git a/tests/test-suite/inprogress/sort.js b/tests/test-suite/inprogress/sort.js
new file mode 100644
index 0000000..3c9b8d0
--- /dev/null
+++ b/tests/test-suite/inprogress/sort.js
@@ -0,0 +1,600 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+const prefix = `
+    local unpack = table.unpack
+
+    local maxI = math.maxinteger
+    local minI = math.mininteger
+
+
+    local function checkerror (msg, f, ...)
+      local s, err = pcall(f, ...)
+      assert(not s and string.find(err, msg))
+    end
+
+    function timesort (a, n, func, msg, pre)
+      local x = os.clock()
+      table.sort(a, func)
+      x = (os.clock() - x) * 1000
+      pre = pre or ""
+      print(string.format("%ssorting %d %s elements in %.2f msec.", pre, n, msg, x))
+      check(a, func)
+    end
+
+    limit = 50000
+    if _soft then limit = 5000 end
+`;
+
+test("[test-suite] sort: testing unpack", function (t) {
+    let luaCode = `
+        checkerror("wrong number of arguments", table.insert, {}, 2, 3, 4)
+
+        local x,y,z,a,n
+        a = {}; lim = _soft and 200 or 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)
+    `, 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] sort: testing unpack", function (t) {
+    let luaCode = `
+        do
+          local maxi = (1 << 31) - 1          -- maximum value for an int (usually)
+          local mini = -(1 << 31)             -- minimum value for an int (usually)
+          checkerror("too many results", unpack, {}, 0, maxi)
+          checkerror("too many results", unpack, {}, 1, maxi)
+          checkerror("too many results", unpack, {}, 0, maxI)
+          checkerror("too many results", unpack, {}, 1, maxI)
+          checkerror("too many results", unpack, {}, mini, maxi)
+          checkerror("too many results", unpack, {}, -maxi, maxi)
+          checkerror("too many results", unpack, {}, minI, maxI)
+          unpack({}, maxi, 0)
+          unpack({}, maxi, 1)
+          unpack({}, maxI, minI)
+          pcall(unpack, {}, 1, maxi + 1)
+          local a, b = unpack({[maxi] = 20}, maxi, maxi)
+          assert(a == 20 and b == nil)
+          a, b = unpack({[maxi] = 20}, maxi - 1, maxi)
+          assert(a == nil and b == 20)
+          local t = {[maxI - 1] = 12, [maxI] = 23}
+          a, b = unpack(t, maxI - 1, maxI); assert(a == 12 and b == 23)
+          a, b = unpack(t, maxI, maxI); assert(a == 23 and b == nil)
+          a, b = unpack(t, maxI, maxI - 1); assert(a == nil and b == nil)
+          t = {[minI] = 12.3, [minI + 1] = 23.5}
+          a, b = unpack(t, minI, minI + 1); assert(a == 12.3 and b == 23.5)
+          a, b = unpack(t, minI, minI); assert(a == 12.3 and b == nil)
+          a, b = unpack(t, minI + 1, minI); assert(a == nil and b == 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] sort: testing unpack", function (t) {
+    let luaCode = `
+        do   -- length is not an integer
+          local t = setmetatable({}, {__len = function () return 'abc' end})
+          assert(#t == 'abc')
+          checkerror("object length is not an integer", table.insert, t, 1)
+        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] sort: testing pack", function (t) {
+    let luaCode = `
+        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)
+    `, 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] sort: testing move", function (t) {
+    let luaCode = `
+        do
+
+          checkerror("table expected", table.move, 1, 2, 3, 4)
+
+          local function eqT (a, b)
+            for k, v in pairs(a) do assert(b[k] == v) end 
+            for k, v in pairs(b) do assert(a[k] == v) end 
+          end
+
+          local a = table.move({10,20,30}, 1, 3, 2)  -- move forward
+          eqT(a, {10,10,20,30})
+
+          -- move forward with overlap of 1
+          a = table.move({10, 20, 30}, 1, 3, 3)
+          eqT(a, {10, 20, 10, 20, 30})
+
+          -- moving to the same table (not being explicit about it)
+          a = {10, 20, 30, 40}
+          table.move(a, 1, 4, 2, a)
+          eqT(a, {10, 10, 20, 30, 40})
+
+          a = table.move({10,20,30}, 2, 3, 1)   -- move backward
+          eqT(a, {20,30,30})
+
+          a = {}   -- move to new table
+          assert(table.move({10,20,30}, 1, 3, 1, a) == a)
+          eqT(a, {10,20,30})
+
+          a = {}
+          assert(table.move({10,20,30}, 1, 0, 3, a) == a)  -- empty move (no move)
+          eqT(a, {})
+
+          a = table.move({10,20,30}, 1, 10, 1)   -- move to the same place
+          eqT(a, {10,20,30})
+
+          -- moving on the fringes
+          a = table.move({[maxI - 2] = 1, [maxI - 1] = 2, [maxI] = 3},
+                         maxI - 2, maxI, -10, {})
+          eqT(a, {[-10] = 1, [-9] = 2, [-8] = 3})
+
+          a = table.move({[minI] = 1, [minI + 1] = 2, [minI + 2] = 3},
+                         minI, minI + 2, -10, {})
+          eqT(a, {[-10] = 1, [-9] = 2, [-8] = 3})
+
+          a = table.move({45}, 1, 1, maxI)
+          eqT(a, {45, [maxI] = 45})
+
+          a = table.move({[maxI] = 100}, maxI, maxI, minI)
+          eqT(a, {[minI] = 100, [maxI] = 100})
+
+          a = table.move({[minI] = 100}, minI, minI, maxI)
+          eqT(a, {[minI] = 100, [maxI] = 100})
+
+          a = setmetatable({}, {
+                __index = function (_,k) return k * 10 end,
+                __newindex = error})
+          local b = table.move(a, 1, 10, 3, {})
+          eqT(a, {})
+          eqT(b, {nil,nil,10,20,30,40,50,60,70,80,90,100})
+
+          b = setmetatable({""}, {
+                __index = error,
+                __newindex = function (t,k,v)
+                  t[1] = string.format("%s(%d,%d)", t[1], k, v)
+              end})
+          table.move(a, 10, 13, 3, b)
+          assert(b[1] == "(3,100)(4,110)(5,120)(6,130)")
+          local stat, msg = pcall(table.move, b, 10, 13, 3, b)
+          assert(not stat and msg == b)
+        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] sort: testing long move", function (t) {
+    let luaCode = `
+        do
+          -- for very long moves, just check initial accesses and interrupt
+          -- move with an error
+          local function checkmove (f, e, t, x, y)
+            local pos1, pos2
+            local a = setmetatable({}, {
+                        __index = function (_,k) pos1 = k end,
+                        __newindex = function (_,k) pos2 = k; error() end, })
+            local st, msg = pcall(table.move, a, f, e, t)
+            assert(not st and not msg and pos1 == x and pos2 == y)
+          end
+          checkmove(1, maxI, 0, 1, 0)
+          checkmove(0, maxI - 1, 1, maxI - 1, maxI)
+          checkmove(minI, -2, -5, -2, maxI - 6)
+          checkmove(minI + 1, -1, -2, -1, maxI - 3)
+          checkmove(minI, -2, 0, minI, 0)  -- non overlapping
+          checkmove(minI + 1, -1, 1, minI + 1, 1)  -- non overlapping
+        end
+
+        checkerror("too many", table.move, {}, 0, maxI, 1)
+        checkerror("too many", table.move, {}, -1, maxI - 1, 1)
+        checkerror("too many", table.move, {}, minI, -1, 1)
+        checkerror("too many", table.move, {}, minI, maxI, 1)
+        checkerror("wrap around", table.move, {}, 1, maxI, 2)
+        checkerror("wrap around", table.move, {}, 1, 2, maxI)
+        checkerror("wrap around", table.move, {}, minI, -2, 2)
+    `, 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] sort: testing sort, strange lengths", function (t) {
+    let luaCode = `
+        local a = setmetatable({}, {__len = function () return -1 end})
+        assert(#a == -1)
+        table.sort(a, error)    -- should not compare anything
+        a = setmetatable({}, {__len = function () return maxI end})
+        checkerror("too big", table.sort, a)
+    `, 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] sort: test checks for invalid order functions", function (t) {
+    let luaCode = `
+        local function check (t)
+          local function f(a, b) assert(a and b); return true end
+          checkerror("invalid order function", table.sort, t, f)
+        end
+
+        check{1,2,3,4}
+        check{1,2,3,4,5}
+        check{1,2,3,4,5,6}
+    `, 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] sort: sort alpha", function (t) {
+    let luaCode = `
+        function check (a, f)
+          f = f or function (x,y) return x<y end;
+          for n = #a, 2, -1 do
+            assert(not f(a[n], a[n-1]))
+          end
+        end
+
+        a = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
+             "Oct", "Nov", "Dec"}
+
+        table.sort(a)
+        check(a)
+    `, 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] sort: sort perm", function (t) {
+    let luaCode = `
+        function check (a, f)
+          f = f or function (x,y) return x<y end;
+          for n = #a, 2, -1 do
+            assert(not f(a[n], a[n-1]))
+          end
+        end
+
+        function perm (s, n)
+          n = n or #s
+          if n == 1 then
+            local t = {unpack(s)}
+            table.sort(t)
+            check(t)
+          else
+            for i = 1, n do
+              s[i], s[n] = s[n], s[i]
+              perm(s, n - 1)
+              s[i], s[n] = s[n], s[i]
+            end
+          end
+        end
+
+        perm{}
+        perm{1}
+        perm{1,2}
+        perm{1,2,3}
+        perm{1,2,3,4}
+        perm{2,2,3,4}
+        perm{1,2,3,4,5}
+        perm{1,2,3,3,5}
+        perm{1,2,3,4,5,6}
+        perm{2,2,3,3,5,6}
+    `, 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] sort: Invert-sorting", function (t) {
+    let luaCode = `
+        function check (a, f)
+          f = f or function (x,y) return x<y end;
+          for n = #a, 2, -1 do
+            assert(not f(a[n], a[n-1]))
+          end
+        end
+
+        a = {}
+        for i=1,limit do
+          a[i] = math.random()
+        end
+
+        x = os.clock(); i=0
+        table.sort(a, function(x,y) i=i+1; return y<x end)
+        x = (os.clock() - x) * 1000
+        print(string.format("Invert-sorting other %d elements in %.2f msec., with %i comparisons",
+              limit, x, i))
+        check(a, function(x,y) return y<x 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] sort: sorting", function (t) {
+    let luaCode = `
+        function check (a, f)
+          f = f or function (x,y) return x<y end;
+          for n = #a, 2, -1 do
+            assert(not f(a[n], a[n-1]))
+          end
+        end
+
+        table.sort{}  -- empty array
+
+        for i=1,limit do a[i] = false end
+        timesort(a, limit,  function(x,y) return nil end, "equal")
+
+        for i,v in pairs(a) do assert(v == false) end
+
+        A = {"álo", "\\0first :-)", "alo", "then this one", "45", "and a new"}
+        table.sort(A)
+        check(A)
+
+        table.sort(A, function (x, y)
+                  load(string.format("A[%q] = ''", x), "")()
+                  collectgarbage()
+                  return x<y
+                end)
+
+
+        tt = {__lt = function (a,b) return a.val < b.val end}
+        a = {}
+        for i=1,10 do  a[i] = {val=math.random(100)}; setmetatable(a[i], tt); end
+        table.sort(a)
+        check(a, tt.__lt)
+        check(a)
+    `, 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");
+
+});
diff --git a/tests/test-suite/inprogress/tpack.js b/tests/test-suite/inprogress/tpack.js
new file mode 100644
index 0000000..530c421
--- /dev/null
+++ b/tests/test-suite/inprogress/tpack.js
@@ -0,0 +1,693 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+const prefix = `
+    local pack = string.pack
+    local packsize = string.packsize
+    local unpack = string.unpack
+
+    function checkerror (msg, f, ...)
+      local status, err = pcall(f, ...)
+      -- print(status, err, msg)
+      assert(not status and string.find(err, msg))
+    end
+
+    local NB = 16
+`;
+
+test("[test-suite] tpack: maximum size for integers", function (t) {
+    let luaCode = `
+        local sizeshort = packsize("h")
+        local sizeint = packsize("i")
+        local sizelong = packsize("l")
+        local sizesize_t = packsize("T")
+        local sizeLI = packsize("j")
+        local sizefloat = packsize("f")
+        local sizedouble = packsize("d")
+        local sizenumber = packsize("n")
+        local little = (pack("i2", 1) == "\\1\\0")
+        local align = packsize("!xXi16")
+
+        assert(1 <= sizeshort and sizeshort <= sizeint and sizeint <= sizelong and
+               sizefloat <= sizedouble)
+
+        print("platform:")
+        print(string.format(
+          "\\tshort %d, int %d, long %d, size_t %d, float %d, double %d,\\n\\z
+           \\tlua Integer %d, lua Number %d",
+           sizeshort, sizeint, sizelong, sizesize_t, sizefloat, sizedouble,
+           sizeLI, sizenumber))
+        print("\\t" .. (little and "little" or "big") .. " endian")
+        print("\\talignment: " .. align)
+    `, 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] tpack: minimum behavior for integer formats", function (t) {
+    let luaCode = `
+        assert(unpack("B", pack("B", 0xff)) == 0xff)
+        assert(unpack("b", pack("b", 0x7f)) == 0x7f)
+        assert(unpack("b", pack("b", -0x80)) == -0x80)
+
+        assert(unpack("H", pack("H", 0xffff)) == 0xffff)
+        assert(unpack("h", pack("h", 0x7fff)) == 0x7fff)
+        assert(unpack("h", pack("h", -0x8000)) == -0x8000)
+
+        assert(unpack("L", pack("L", 0xffffffff)) == 0xffffffff)
+        assert(unpack("l", pack("l", 0x7fffffff)) == 0x7fffffff)
+        assert(unpack("l", pack("l", -0x80000000)) == -0x80000000)
+    `, 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] tpack: minimum behavior for integer formats", function (t) {
+    let luaCode = `
+        for i = 1, NB do
+          -- small numbers with signal extension ("\\xFF...")
+          local s = string.rep("\\xff", i)
+          assert(pack("i" .. i, -1) == s)
+          assert(packsize("i" .. i) == #s)
+          assert(unpack("i" .. i, s) == -1)
+
+          -- small unsigned number ("\\0...\\xAA")
+          s = "\\xAA" .. string.rep("\\0", i - 1)
+          assert(pack("<I" .. i, 0xAA) == s)
+          assert(unpack("<I" .. i, s) == 0xAA)
+          assert(pack(">I" .. i, 0xAA) == s:reverse())
+          assert(unpack(">I" .. i, s:reverse()) == 0xAA)
+        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] tpack: minimum behavior for integer formats", function (t) {
+    let luaCode = `
+        do
+          local lnum = 0x13121110090807060504030201
+          local s = pack("<j", lnum)
+          assert(unpack("<j", s) == lnum)
+          assert(unpack("<i" .. sizeLI + 1, s .. "\\0") == lnum)
+          assert(unpack("<i" .. sizeLI + 1, s .. "\\0") == lnum)
+
+          for i = sizeLI + 1, NB do
+            local s = pack("<j", -lnum)
+            assert(unpack("<j", s) == -lnum)
+            -- strings with (correct) extra bytes
+            assert(unpack("<i" .. i, s .. ("\\xFF"):rep(i - sizeLI)) == -lnum)
+            assert(unpack(">i" .. i, ("\\xFF"):rep(i - sizeLI) .. s:reverse()) == -lnum)
+            assert(unpack("<I" .. i, s .. ("\\0"):rep(i - sizeLI)) == -lnum)
+
+            -- overflows
+            checkerror("does not fit", unpack, "<I" .. i, ("\\x00"):rep(i - 1) .. "\\1")
+            checkerror("does not fit", unpack, ">i" .. i, "\\1" .. ("\\x00"):rep(i - 1))
+          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] tpack: minimum behavior for integer formats", function (t) {
+    let luaCode = `
+        for i = 1, sizeLI do
+          local lstr = "\\1\\2\\3\\4\\5\\6\\7\\8\\9\\10\\11\\12\\13"
+          local lnum = 0x13121110090807060504030201
+          local n = lnum & (~(-1 << (i * 8)))
+          local s = string.sub(lstr, 1, i)
+          assert(pack("<i" .. i, n) == s)
+          assert(pack(">i" .. i, n) == s:reverse())
+          assert(unpack(">i" .. i, s:reverse()) == n)
+        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] tpack: sign extension", function (t) {
+    let luaCode = `
+        do
+          local u = 0xf0
+          for i = 1, sizeLI - 1 do
+            assert(unpack("<i"..i, "\\xf0"..("\\xff"):rep(i - 1)) == -16)
+            assert(unpack(">I"..i, "\\xf0"..("\\xff"):rep(i - 1)) == u)
+            u = u * 256 + 0xff
+          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] tpack: mixed endianness", function (t) {
+    let luaCode = `
+        do
+          assert(pack(">i2 <i2", 10, 20) == "\\0\\10\\20\\0")
+          local a, b = unpack("<i2 >i2", "\\10\\0\\0\\20")
+          assert(a == 10 and b == 20)
+          assert(pack("=i4", 2001) == pack("i4", 2001))
+        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] tpack: testing invalid formats", function (t) {
+    let luaCode = `
+        checkerror("out of limits", pack, "i0", 0)
+        checkerror("out of limits", pack, "i" .. NB + 1, 0)
+        checkerror("out of limits", pack, "!" .. NB + 1, 0)
+        checkerror("%(17%) out of limits %[1,16%]", pack, "Xi" .. NB + 1)
+        checkerror("invalid format option 'r'", pack, "i3r", 0)
+        checkerror("16%-byte integer", unpack, "i16", string.rep('\\3', 16))
+        checkerror("not power of 2", pack, "!4i3", 0);
+        checkerror("missing size", pack, "c", "")
+        checkerror("variable%-length format", packsize, "s")
+        checkerror("variable%-length format", packsize, "z")
+    `, 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] tpack: overflow in option size (error will be in digit after limit)", function (t) {
+    let luaCode = `
+        checkerror("invalid format", packsize, "c1" .. string.rep("0", 40))
+
+        if packsize("i") == 4 then
+          -- result would be 2^31  (2^3 repetitions of 2^28 strings)
+          local s = string.rep("c268435456", 2^3)
+          checkerror("too large", packsize, s)
+          -- one less is OK
+          s = string.rep("c268435456", 2^3 - 1) .. "c268435455"
+          assert(packsize(s) == 0x7fffffff)
+        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] tpack: overflow in packing)", function (t) {
+    let luaCode = `
+        for i = 1, sizeLI - 1 do
+          local umax = (1 << (i * 8)) - 1
+          local max = umax >> 1
+          local min = ~max
+          checkerror("overflow", pack, "<I" .. i, -1)
+          checkerror("overflow", pack, "<I" .. i, min)
+          checkerror("overflow", pack, ">I" .. i, umax + 1)
+
+          checkerror("overflow", pack, ">i" .. i, umax)
+          checkerror("overflow", pack, ">i" .. i, max + 1)
+          checkerror("overflow", pack, "<i" .. i, min - 1)
+
+          assert(unpack(">i" .. i, pack(">i" .. i, max)) == max)
+          assert(unpack("<i" .. i, pack("<i" .. i, min)) == min)
+          assert(unpack(">I" .. i, pack(">I" .. i, umax)) == umax)
+        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] tpack: Lua integer size)", function (t) {
+    let luaCode = `
+        for i = 1, sizeLI - 1 do
+        assert(unpack(">j", pack(">j", math.maxinteger)) == math.maxinteger)
+        assert(unpack("<j", pack("<j", math.mininteger)) == math.mininteger)
+        assert(unpack("<J", pack("<j", -1)) == -1)   -- maximum unsigned integer
+
+        if little then
+          assert(pack("f", 24) == pack("<f", 24))
+        else
+          assert(pack("f", 24) == pack(">f", 24))
+        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] tpack: testing pack/unpack of floating-point numbers", function (t) {
+    let luaCode = `
+        for _, n in ipairs{0, -1.1, 1.9, 1/0, -1/0, 1e20, -1e20, 0.1, 2000.7} do
+            assert(unpack("n", pack("n", n)) == n)
+            assert(unpack("<n", pack("<n", n)) == n)
+            assert(unpack(">n", pack(">n", n)) == n)
+            assert(pack("<f", n) == pack(">f", n):reverse())
+            assert(pack(">d", n) == pack("<d", n):reverse())
+        end
+
+        -- for non-native precisions, test only with "round" numbers
+        for _, n in ipairs{0, -1.5, 1/0, -1/0, 1e10, -1e9, 0.5, 2000.25} do
+          assert(unpack("<f", pack("<f", n)) == n)
+          assert(unpack(">f", pack(">f", n)) == n)
+          assert(unpack("<d", pack("<d", n)) == n)
+          assert(unpack(">d", pack(">d", n)) == n)
+        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] tpack: testing pack/unpack of strings", function (t) {
+    let luaCode = `
+        do
+          local s = string.rep("abc", 1000)
+          assert(pack("zB", s, 247) == s .. "\\0\\xF7")
+          local s1, b = unpack("zB", s .. "\\0\\xF9")
+          assert(b == 249 and s1 == s)
+          s1 = pack("s", s)
+          assert(unpack("s", s1) == s)
+
+          checkerror("does not fit", pack, "s1", s)
+
+          checkerror("contains zeros", pack, "z", "alo\\0");
+
+          for i = 2, NB do
+            local s1 = pack("s" .. i, s)
+            assert(unpack("s" .. i, s1) == s and #s1 == #s + i)
+          end
+        end
+
+        do
+          local x = pack("s", "alo")
+          checkerror("too short", unpack, "s", x:sub(1, -2))
+          checkerror("too short", unpack, "c5", "abcd")
+          checkerror("out of limits", pack, "s100", "alo")
+        end
+
+        do
+          assert(pack("c0", "") == "")
+          assert(packsize("c0") == 0)
+          assert(unpack("c0", "") == "")
+          assert(pack("<! c3", "abc") == "abc")
+          assert(packsize("<! c3") == 3)
+          assert(pack(">!4 c6", "abcdef") == "abcdef")
+          assert(pack("c3", "123") == "123")
+          assert(pack("c0", "") == "")
+          assert(pack("c8", "123456") == "123456\\0\\0")
+          assert(pack("c88", "") == string.rep("\\0", 88))
+          assert(pack("c188", "ab") == "ab" .. string.rep("\\0", 188 - 2))
+          local a, b, c = unpack("!4 z c3", "abcdefghi\\0xyz")
+          assert(a == "abcdefghi" and b == "xyz" and c == 14)
+          checkerror("longer than", pack, "c3", "1234")
+        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] tpack: testing multiple types and sequence", function (t) {
+    let luaCode = `
+        do
+          local x = pack("<b h b f d f n i", 1, 2, 3, 4, 5, 6, 7, 8)
+          assert(#x == packsize("<b h b f d f n i"))
+          local a, b, c, d, e, f, g, h = unpack("<b h b f d f n i", x)
+          assert(a == 1 and b == 2 and c == 3 and d == 4 and e == 5 and f == 6 and
+                 g == 7 and h == 8) 
+        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] tpack: testing alignment", function (t) {
+    let luaCode = `
+        do
+          assert(pack(" < i1 i2 ", 2, 3) == "\\2\\3\\0")   -- no alignment by default
+          local x = pack(">!8 b Xh i4 i8 c1 Xi8", -12, 100, 200, "\\xEC")
+          assert(#x == packsize(">!8 b Xh i4 i8 c1 Xi8"))
+          assert(x == "\\xf4" .. "\\0\\0\\0" ..
+                      "\\0\\0\\0\\100" ..
+                      "\\0\\0\\0\\0\\0\\0\\0\\xC8" .. 
+                      "\\xEC" .. "\\0\\0\\0\\0\\0\\0\\0")
+          local a, b, c, d, pos = unpack(">!8 c1 Xh i4 i8 b Xi8 XI XH", x)
+          assert(a == "\\xF4" and b == 100 and c == 200 and d == -20 and (pos - 1) == #x)
+
+          x = pack(">!4 c3 c4 c2 z i4 c5 c2 Xi4",
+                          "abc", "abcd", "xz", "hello", 5, "world", "xy")
+          assert(x == "abcabcdxzhello\\0\\0\\0\\0\\0\\5worldxy\\0")
+          local a, b, c, d, e, f, g, pos = unpack(">!4 c3 c4 c2 z i4 c5 c2 Xh Xi4", x)
+          assert(a == "abc" and b == "abcd" and c == "xz" and d == "hello" and
+                 e == 5 and f == "world" and g == "xy" and (pos - 1) % 4 == 0)
+
+          x = pack(" b b Xd b Xb x", 1, 2, 3)
+          assert(packsize(" b b Xd b Xb x") == 4)
+          assert(x == "\\1\\2\\3\\0")
+          a, b, c, pos = unpack("bbXdb", x)
+          assert(a == 1 and b == 2 and c == 3 and pos == #x)
+
+          -- only alignment
+          assert(packsize("!8 xXi8") == 8)
+          local pos = unpack("!8 xXi8", "0123456701234567"); assert(pos == 9)
+          assert(packsize("!8 xXi2") == 2)
+          local pos = unpack("!8 xXi2", "0123456701234567"); assert(pos == 3)
+          assert(packsize("!2 xXi2") == 2)
+          local pos = unpack("!2 xXi2", "0123456701234567"); assert(pos == 3)
+          assert(packsize("!2 xXi8") == 2)
+          local pos = unpack("!2 xXi8", "0123456701234567"); assert(pos == 3)
+          assert(packsize("!16 xXi16") == 16)
+          local pos = unpack("!16 xXi16", "0123456701234567"); assert(pos == 17)
+
+          checkerror("invalid next option", pack, "X")
+          checkerror("invalid next option", unpack, "XXi", "")
+          checkerror("invalid next option", unpack, "X i", "")
+          checkerror("invalid next option", pack, "Xc1")
+        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] tpack: testing initial position", function (t) {
+    let luaCode = `
+        do
+          local x = pack("i4i4i4i4", 1, 2, 3, 4)
+          for pos = 1, 16, 4 do
+            local i, p = unpack("i4", x, pos)
+            assert(i == pos//4 + 1 and p == pos + 4)
+          end
+
+          -- with alignment
+          for pos = 0, 12 do    -- will always round position to power of 2
+            local i, p = unpack("!4 i4", x, pos + 1)
+            assert(i == (pos + 3)//4 + 1 and p == i*4 + 1)
+          end
+
+          -- negative indices
+          local i, p = unpack("!4 i4", x, -4)
+          assert(i == 4 and p == 17)
+          local i, p = unpack("!4 i4", x, -7)
+          assert(i == 4 and p == 17)
+          local i, p = unpack("!4 i4", x, -#x)
+          assert(i == 1 and p == 5)
+
+          -- limits
+          for i = 1, #x + 1 do
+            assert(unpack("c0", x, i) == "")
+          end
+          checkerror("out of string", unpack, "c0", x, 0)
+          checkerror("out of string", unpack, "c0", x, #x + 2)
+          checkerror("out of string", unpack, "c0", x, -(#x + 1))
+         
+        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");
+
+});
diff --git a/tests/test-suite/inprogress/utf8.js b/tests/test-suite/inprogress/utf8.js
new file mode 100644
index 0000000..3e32aec
--- /dev/null
+++ b/tests/test-suite/inprogress/utf8.js
@@ -0,0 +1,418 @@
+"use strict";
+
+const test     = require('tape');
+
+global.WEB = false;
+
+const lua     = require('../../src/lua.js');
+const lauxlib = require('../../src/lauxlib.js');
+const lualib  = require('../../src/lualib.js');
+
+
+const prefix = `
+    local function checkerror (msg, f, ...)
+      local s, err = pcall(f, ...)
+      assert(not s and string.find(err, msg))
+    end
+
+
+    local function len (s)
+      return #string.gsub(s, "[\\x80-\\xBF]", "")
+    end
+
+
+    local justone = "^" .. utf8.charpattern .. "$"
+
+    local function checksyntax (s, t)
+      local ts = {"return '"}
+      for i = 1, #t do ts[i + 1] = string.format("\\\\u{%x}", t[i]) end
+      ts[#t + 2] = "'"
+      ts = table.concat(ts)
+      assert(assert(load(ts))() == s)
+    end
+    -- 't' is the list of codepoints of 's'
+    local function check (s, t)
+      local l = utf8.len(s) 
+      assert(#t == l and len(s) == l)
+      assert(utf8.char(table.unpack(t)) == s)
+
+      assert(utf8.offset(s, 0) == 1)
+
+      checksyntax(s, t)
+
+      local t1 = {utf8.codepoint(s, 1, -1)}
+      assert(#t == #t1)
+      for i = 1, #t do assert(t[i] == t1[i]) end
+
+      for i = 1, l do
+        local pi = utf8.offset(s, i)        -- position of i-th char
+        local pi1 = utf8.offset(s, 2, pi)   -- position of next char
+        assert(string.find(string.sub(s, pi, pi1 - 1), justone))
+        assert(utf8.offset(s, -1, pi1) == pi)
+        assert(utf8.offset(s, i - l - 1) == pi)
+        assert(pi1 - pi == #utf8.char(utf8.codepoint(s, pi)))
+        for j = pi, pi1 - 1 do 
+          assert(utf8.offset(s, 0, j) == pi)
+        end
+        for j = pi + 1, pi1 - 1 do
+          assert(not utf8.len(s, j))
+        end
+       assert(utf8.len(s, pi, pi) == 1)
+       assert(utf8.len(s, pi, pi1 - 1) == 1)
+       assert(utf8.len(s, pi) == l - i + 1)
+       assert(utf8.len(s, pi1) == l - i)
+       assert(utf8.len(s, 1, pi) == i)
+      end
+
+      local i = 0
+      for p, c in utf8.codes(s) do
+        i = i + 1
+        assert(c == t[i] and p == utf8.offset(s, i))
+        assert(utf8.codepoint(s, p) == c)
+      end
+      assert(i == #t)
+
+      i = 0
+      for p, c in utf8.codes(s) do
+        i = i + 1
+        assert(c == t[i] and p == utf8.offset(s, i)) 
+      end
+      assert(i == #t)
+
+      i = 0
+      for c in string.gmatch(s, utf8.charpattern) do
+        i = i + 1
+        assert(c == utf8.char(t[i]))
+      end
+      assert(i == #t)
+
+      for i = 1, l do
+        assert(utf8.offset(s, i) == utf8.offset(s, i - l - 1, #s + 1))
+      end
+
+    end
+
+    local function invalid (s)
+      checkerror("invalid UTF%-8 code", utf8.codepoint, s)
+      assert(not utf8.len(s))
+    end
+`;
+
+test("[test-suite] utf8: offset", function (t) {
+    let luaCode = `
+        assert(utf8.offset("alo", 5) == nil)
+        assert(utf8.offset("alo", -4) == 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] utf8: error indication in utf8.len", function (t) {
+    let luaCode = `
+        do
+          local function check (s, p)
+            local a, b = utf8.len(s)
+            assert(not a and b == p)
+          end
+          check("abc\\xE3def", 4)
+          check("汉字\\x80", #("汉字") + 1)
+          check("\\xF4\\x9F\\xBF", 1)
+          check("\\xF4\\x9F\\xBF\\xBF", 1)
+        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] utf8: error in initial position for offset", function (t) {
+    let luaCode = `
+        checkerror("position out of range", utf8.offset, "abc", 1, 5)
+        checkerror("position out of range", utf8.offset, "abc", 1, -4)
+        checkerror("position out of range", utf8.offset, "", 1, 2)
+        checkerror("position out of range", utf8.offset, "", 1, -1)
+        checkerror("continuation byte", utf8.offset, "𦧺", 1, 2)
+        checkerror("continuation byte", utf8.offset, "𦧺", 1, 2)
+        checkerror("continuation byte", utf8.offset, "\\x80", 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] utf8: codepoints", function (t) {
+    let luaCode = `
+        local s = "hello World"
+        local t = {string.byte(s, 1, -1)}
+        for i = 1, utf8.len(s) do assert(t[i] == string.byte(s, i)) end
+        check(s, t)
+
+        check("汉字/漢字", {27721, 23383, 47, 28450, 23383,})
+
+        do
+          local s = "áéí\\128"
+          local t = {utf8.codepoint(s,1,#s - 1)}
+          assert(#t == 3 and t[1] == 225 and t[2] == 233 and t[3] == 237)
+          checkerror("invalid UTF%-8 code", utf8.codepoint, s, 1, #s)
+          checkerror("out of range", utf8.codepoint, s, #s + 1)
+          t = {utf8.codepoint(s, 4, 3)}
+          assert(#t == 0)
+          checkerror("out of range", utf8.codepoint, s, -(#s + 1), 1)
+          checkerror("out of range", utf8.codepoint, s, 1, #s + 1)
+        end
+
+        assert(utf8.char() == "")
+        assert(utf8.char(97, 98, 99) == "abc")
+
+        assert(utf8.codepoint(utf8.char(0x10FFFF)) == 0x10FFFF)
+
+        checkerror("value out of range", utf8.char, 0x10FFFF + 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] utf8: UTF-8 representation for 0x11ffff (value out of valid range)", function (t) {
+    let luaCode = `
+        invalid("\\xF4\\x9F\\xBF\\xBF")
+    `, 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] utf8: overlong sequences", function (t) {
+    let luaCode = `
+        invalid("\\xC0\\x80")          -- zero
+        invalid("\\xC1\\xBF")          -- 0x7F (should be coded in 1 byte)
+        invalid("\\xE0\\x9F\\xBF")      -- 0x7FF (should be coded in 2 bytes)
+        invalid("\\xF0\\x8F\\xBF\\xBF")  -- 0xFFFF (should be coded in 3 bytes)
+    `, 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] utf8: invalid bytes", function (t) {
+    let luaCode = `
+        invalid("\\x80")  -- continuation byte
+        invalid("\\xBF")  -- continuation byte
+        invalid("\\xFE")  -- invalid byte
+        invalid("\\xFF")  -- invalid byte
+    `, 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] utf8: empty strings", function (t) {
+    let luaCode = `
+        check("", {})
+    `, 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] utf8: minimum and maximum values for each sequence size", function (t) {
+    let luaCode = `
+        s = "\\0 \\x7F\\z
+             \\xC2\\x80 \\xDF\\xBF\\z
+             \\xE0\\xA0\\x80 \\xEF\\xBF\\xBF\\z
+             \\xF0\\x90\\x80\\x80  \\xF4\\x8F\\xBF\\xBF"
+        s = string.gsub(s, " ", "")
+        check(s, {0,0x7F, 0x80,0x7FF, 0x800,0xFFFF, 0x10000,0x10FFFF})
+
+        x = "日本語a-4\\0éó"
+        check(x, {26085, 26412, 35486, 97, 45, 52, 0, 233, 243})
+    `, 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] utf8: Supplementary Characters", function (t) {
+    let luaCode = `
+        check("𣲷𠜎𠱓𡁻𠵼ab𠺢",
+              {0x23CB7, 0x2070E, 0x20C53, 0x2107B, 0x20D7C, 0x61, 0x62, 0x20EA2,})
+
+        check("𨳊𩶘𦧺𨳒𥄫𤓓\\xF4\\x8F\\xBF\\xBF",
+              {0x28CCA, 0x29D98, 0x269FA, 0x28CD2, 0x2512B, 0x244D3, 0x10ffff})
+
+
+        local i = 0
+        for p, c in string.gmatch(x, "()(" .. utf8.charpattern .. ")") do
+          i = i + 1
+          assert(utf8.offset(x, i) == p)
+          assert(utf8.len(x, p) == utf8.len(x) - i + 1)
+          assert(utf8.len(c) == 1)
+          for j = 1, #c - 1 do
+            assert(utf8.offset(x, 0, p + j - 1) == p)
+          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");
+});