summaryrefslogtreecommitdiff
path: root/tests/test-suite/inprogress
diff options
context:
space:
mode:
Diffstat (limited to 'tests/test-suite/inprogress')
-rw-r--r--tests/test-suite/inprogress/attrib.js77
-rw-r--r--tests/test-suite/inprogress/bitwise.js504
-rw-r--r--tests/test-suite/inprogress/coroutine.js931
-rw-r--r--tests/test-suite/inprogress/goto.js434
-rw-r--r--tests/test-suite/inprogress/math.js1614
-rw-r--r--tests/test-suite/inprogress/nextvar.js1183
-rw-r--r--tests/test-suite/inprogress/pm.js806
-rw-r--r--tests/test-suite/inprogress/sort.js600
-rw-r--r--tests/test-suite/inprogress/tpack.js693
-rw-r--r--tests/test-suite/inprogress/utf8.js418
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");
+});
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-11 01:42:50 +0000