language-lua 0.6.2 → 0.6.2.1

raw patch · 30 files changed

+9045/−1 lines, 30 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• language-lua.cabal +8/−1
• lua-5.2.2-tests/all.lua +258/−0
• lua-5.2.2-tests/api.lua +1009/−0
• lua-5.2.2-tests/attrib.lua +421/−0
• lua-5.2.2-tests/big.lua +79/−0
• lua-5.2.2-tests/bitwise.lua +115/−0
• lua-5.2.2-tests/calls.lua +310/−0
• lua-5.2.2-tests/checktable.lua +77/−0
• lua-5.2.2-tests/closure.lua +244/−0
• lua-5.2.2-tests/code.lua +182/−0
• lua-5.2.2-tests/constructs.lua +310/−0
• lua-5.2.2-tests/coroutine.lua +728/−0
• lua-5.2.2-tests/db.lua +631/−0
• lua-5.2.2-tests/errors.lua +422/−0
• lua-5.2.2-tests/events.lua +388/−0
• lua-5.2.2-tests/files.lua +615/−0
• lua-5.2.2-tests/gc.lua +575/−0
• lua-5.2.2-tests/goto.lua +173/−0
• lua-5.2.2-tests/literals.lua +258/−0
• lua-5.2.2-tests/locals.lua +157/−0
• lua-5.2.2-tests/main.lua +258/−0
• lua-5.2.2-tests/math.lua +288/−0
• lua-5.2.2-tests/nextvar.lua +461/−0
• lua-5.2.2-tests/pm.lua +344/−0
• lua-5.2.2-tests/sort.lua +167/−0
• lua-5.2.2-tests/strings.lua +281/−0
• lua-5.2.2-tests/vararg.lua +125/−0
• lua-5.2.2-tests/verybig.lua +144/−0
• tests/numbers +9/−0
• tests/strings +8/−0

@@ -5,6 +5,10 @@     .     Changelog:     .+    \0.6.2.1:+    .+    - Missing test files are added to Cabal package.+    .     \0.6.2:     .     - `base` dependency is relaxed for GHC 7.10. Note that alex version@@ -87,7 +91,7 @@     - Syntax tree is annotated. All parsers(`parseText`, `parseFile`) annotate       resulting tree with source positions. -Version:             0.6.2+Version:             0.6.2.1 Synopsis:            Lua parser and pretty-printer Homepage:            http://github.com/osa1/language-lua Bug-reports:         http://github.com/osa1/language-lua/issues@@ -101,6 +105,9 @@ Cabal-version:       >= 1.9.2  Extra-source-files:  src/Text/PrettyPrint/LICENSE+                     tests/numbers+                     tests/strings+                     lua-5.2.2-tests/*.lua  Source-repository head   Type:              git

@@ -0,0 +1,258 @@++local version = "Lua 5.2"+if _VERSION ~= version then+  io.stderr:write("\nThis test suite is for ", version, ", not for ", _VERSION,+    "\nExiting tests\n")+  return+end+++-- next variables control the execution of some tests+-- true means no test (so an undefined variable does not skip a test)+-- defaults are for Linux; test everything++_soft = false      -- true to avoid long or memory consuming tests+_port = false      -- true to avoid non-portable tests+_no32 = false      -- true to avoid tests that assume 32 bits+_nomsg = false     -- true to avoid messages about tests not performed+_noposix = false   -- false assumes LUA_USE_POSIX+_nolonglong = false  -- false assumes LUA_USE_LONGLONG+_noformatA = false   -- false assumes LUA_USE_AFORMAT+++local usertests = rawget(_G, "_U")++if usertests then+  -- tests for sissies ;)  Avoid problems+  _soft = true+  _port = true+  _no32 = true+  _nomsg = true+  _noposix = true+  _nolonglong = true+  _noformatA = true; +end++-- no "internal" tests for user tests+if usertests then T = nil end++T = rawget(_G, "T")  -- avoid problems with 'strict' module++package.path = "?;./?.lua" .. package.path++math.randomseed(0)++collectgarbage("setstepmul", 200)+collectgarbage("setpause", 200)+++--[=[+  example of a long [comment],+  [[spanning several [lines]]]++]=]++print("current path:\n****" .. package.path .. "****\n")+++local c = os.clock()++local collectgarbage = collectgarbage++do   -- (++-- track messages for tests not performed+local msgs = {}+function Message (m)+  if not _nomsg then+    print(m)+    msgs[#msgs+1] = string.sub(m, 3, -3)+  end+end++assert(os.setlocale"C")++local T,print,format,write,assert,type,unpack,floor =+      T,print,string.format,io.write,assert,type,table.unpack,math.floor++-- use K for 1000 and M for 1000000 (not 2^10 -- 2^20)+local function F (m)+  local function round (m)+    m = m + 0.04999+    return m - (m % 0.1)     -- keep one decimal digit+  end+  if m < 1000 then return m+  else+    m = m / 1000+    if m < 1000 then return round(m).."K"+    else+      return round(m/1000).."M"+    end+  end+end++local showmem+if not T then+  local max = 0+  showmem = function ()+    local m = collectgarbage("count") * 1024+    max = (m > max) and m or max+    print(format("    ---- total memory: %s, max memory: %s ----\n",+          F(m), F(max)))+  end+else+  showmem = function ()+    T.checkmemory()+    local total, numblocks, maxmem = T.totalmem()+    local count = collectgarbage("count")+    print(format(+      "\n    ---- total memory: %s (%.0fK), max use: %s,  blocks: %d\n",+      F(total), count, F(maxmem), numblocks))+    print(format("\t(strings:  %d, tables: %d, functions: %d, "..+                 "\n\tudata: %d, threads: %d)",+                 T.totalmem"string", T.totalmem"table", T.totalmem"function",+                 T.totalmem"userdata", T.totalmem"thread"))+  end+end+++--+-- redefine dofile to run files through dump/undump+--+local function report (n) print("\n***** FILE '"..n.."'*****") end+local olddofile = dofile+dofile = function (n)+  showmem()+  report(n)+  local f = assert(loadfile(n))+  local b = string.dump(f)+  f = assert(load(b))+  return f()+end++dofile('main.lua')++do+  local next, setmetatable, stderr = next, setmetatable, io.stderr+  local mt = {}+  -- each time a table is collected, create a new one to be+  -- collected next cycle+  mt.__gc = function (o)+    stderr:write'.'    -- mark progress+    local n = setmetatable({}, mt)   -- replicate object+    o = nil+    local a,b,c,d,e = nil    -- erase 'o' from the stack+  end+  local n = setmetatable({}, mt)   -- replicate object+end++report"gc.lua"+local f = assert(loadfile('gc.lua'))+f()++collectgarbage("generational")+dofile('db.lua')+assert(dofile('calls.lua') == deep and deep)+olddofile('strings.lua')+olddofile('literals.lua')+assert(dofile('attrib.lua') == 27)++collectgarbage("incremental")   -- redo some tests in incremental mode+olddofile('strings.lua')+olddofile('literals.lua')+dofile('constructs.lua')+dofile('api.lua')++collectgarbage("generational")   -- back to generational mode+collectgarbage("setpause", 200)+collectgarbage("setmajorinc", 500)+assert(dofile('locals.lua') == 5)+dofile('constructs.lua')+dofile('code.lua')+if not _G._soft then+  report('big.lua')+  local f = coroutine.wrap(assert(loadfile('big.lua')))+  assert(f() == 'b')+  assert(f() == 'a')+end+dofile('nextvar.lua')+dofile('pm.lua')+dofile('api.lua')+assert(dofile('events.lua') == 12)+dofile('vararg.lua')+dofile('closure.lua')+dofile('coroutine.lua')+dofile('goto.lua')+dofile('errors.lua')+dofile('math.lua')+dofile('sort.lua')+dofile('bitwise.lua')+assert(dofile('verybig.lua') == 10); collectgarbage()+dofile('files.lua')++if #msgs > 0 then+  print("\ntests not performed:")+  for i=1,#msgs do+    print(msgs[i])+  end+  print()+end++print("final OK !!!")++local debug = require "debug"++debug.sethook(function (a) assert(type(a) == 'string') end, "cr")++-- to survive outside block+_G.showmem = showmem++end   --)++local _G, showmem, print, format, clock, assert, open =+      _G, showmem, print, string.format, os.clock, assert, io.open++-- file with time of last performed test+local fname = T and "time-debug.txt" or "time.txt"+local lasttime++if not usertests then+  -- open file with time of last performed test+  local f = io.open(fname)+  if f then+    lasttime = assert(tonumber(f:read'*a'))+    f:close();+  else   -- no such file; assume it is recording time for first time+    lasttime = nil+  end+end++-- erase (almost) all globals+print('cleaning all!!!!')+for n in pairs(_G) do+  if not ({___Glob = 1, tostring = 1})[n] then+    _G[n] = nil+  end+end+++collectgarbage()+collectgarbage()+collectgarbage()+collectgarbage()+collectgarbage()+collectgarbage();showmem()++local time = clock() - c++print(format("\n\ntotal time: %.2f\n", time))++if not usertests then+  lasttime = lasttime or time    -- if there is no last time, ignore difference+  -- check whether current test time differs more than 5% from last time+  local diff = (time - lasttime) / time+  local tolerance = 0.05    -- 5%+  assert(diff < tolerance and diff > -tolerance)+  assert(open(fname, "w")):write(time):close()+end+

@@ -0,0 +1,1009 @@++if T==nil then+  (Message or print)('\a\n >>> testC not active: skipping API tests <<<\n\a')+  return+end++local debug = require "debug"++local pack = table.pack+++function tcheck (t1, t2)+  assert(t1.n == (t2.n or #t2) + 1)+  for i = 2, t1.n do assert(t1[i] == t2[i - 1]) end+end+++print('testing C API')++a = T.testC("pushvalue R; return 1")+assert(a == debug.getregistry())+++-- absindex+assert(T.testC("settop 10; absindex -1; return 1") == 10)+assert(T.testC("settop 5; absindex -5; return 1") == 1)+assert(T.testC("settop 10; absindex 1; return 1") == 1)+assert(T.testC("settop 10; absindex R; return 1") < -10)++-- testing allignment+a = T.d2s(12458954321123)+assert(string.len(a) == 8)   -- sizeof(double)+assert(T.s2d(a) == 12458954321123)++a,b,c = T.testC("pushnum 1; pushnum 2; pushnum 3; return 2")+assert(a == 2 and b == 3 and not c)++f = T.makeCfunc("pushnum 1; pushnum 2; pushnum 3; return 2")+a,b,c = f()+assert(a == 2 and b == 3 and not c)++-- test that all trues are equal+a,b,c = T.testC("pushbool 1; pushbool 2; pushbool 0; return 3")+assert(a == b and a == true and c == false)+a,b,c = T.testC"pushbool 0; pushbool 10; pushnil;\+                      tobool -3; tobool -3; tobool -3; return 3"+assert(a==false and b==true and c==false)+++a,b,c = T.testC("gettop; return 2", 10, 20, 30, 40)+assert(a == 40 and b == 5 and not c)++t = pack(T.testC("settop 5; gettop; return .", 2, 3))+tcheck(t, {n=4,2,3})++t = pack(T.testC("settop 0; settop 15; return 10", 3, 1, 23))+assert(t.n == 10 and t[1] == nil and t[10] == nil)++t = pack(T.testC("remove -2; gettop; return .", 2, 3, 4))+tcheck(t, {n=2,2,4})++t = pack(T.testC("insert -1; gettop; return .", 2, 3))+tcheck(t, {n=2,2,3})++t = pack(T.testC("insert 3; gettop; return .", 2, 3, 4, 5))+tcheck(t, {n=4,2,5,3,4})++t = pack(T.testC("replace 2; gettop; return .", 2, 3, 4, 5))+tcheck(t, {n=3,5,3,4})++t = pack(T.testC("replace -2; gettop; return .", 2, 3, 4, 5))+tcheck(t, {n=3,2,3,5})++t = pack(T.testC("remove 3; gettop; return .", 2, 3, 4, 5))+tcheck(t, {n=3,2,4,5})++t = pack(T.testC("copy 3 4; gettop; return .", 2, 3, 4, 5))+tcheck(t, {n=4,2,3,3,5})++t = pack(T.testC("copy -3 -1; gettop; return .", 2, 3, 4, 5))+tcheck(t, {n=4,2,3,4,3})+++++t = pack(T.testC("insert 3; pushvalue 3; remove 3; pushvalue 2; remove 2; \+                  insert 2; pushvalue 1; remove 1; insert 1; \+      insert -2; pushvalue -2; remove -3; gettop; return .",+      2, 3, 4, 5, 10, 40, 90))+tcheck(t, {n=7,2,3,4,5,10,40,90})++t = pack(T.testC("concat 5; gettop; return .", "alo", 2, 3, "joao", 12))+tcheck(t, {n=1,"alo23joao12"})++-- testing MULTRET+t = pack(T.testC("call 2,-1; gettop; return .",+     function (a,b) return 1,2,3,4,a,b end, "alo", "joao"))+tcheck(t, {n=6,1,2,3,4,"alo", "joao"})++do  -- test returning more results than fit in the caller stack+  local a = {}+  for i=1,1000 do a[i] = true end; a[999] = 10+  local b = T.testC([[pcall 1 -1; pop 1; tostring -1; return 1]],+                    table.unpack, a)+  assert(b == "10")+end+++-- testing globals+_G.a = 14; _G.b = "a31"+local a = {T.testC[[+  getglobal a;+  getglobal b;+  getglobal b;+  setglobal a;+  gettop;+  return .+]]}+assert(a[2] == 14 and a[3] == "a31" and a[4] == nil and _G.a == "a31")+++-- testing arith+assert(T.testC("pushnum 10; pushnum 20; arith /; return 1") == 0.5)+assert(T.testC("pushnum 10; pushnum 20; arith -; return 1") == -10)+assert(T.testC("pushnum 10; pushnum -20; arith *; return 1") == -200)+assert(T.testC("pushnum 10; pushnum 3; arith ^; return 1") == 1000)+assert(T.testC("pushnum 10; pushstring 20; arith /; return 1") == 0.5)+assert(T.testC("pushstring 10; pushnum 20; arith -; return 1") == -10)+assert(T.testC("pushstring 10; pushstring -20; arith *; return 1") == -200)+assert(T.testC("pushstring 10; pushstring 3; arith ^; return 1") == 1000)+a,b,c = T.testC([[pushnum 1;+                  pushstring 10; arith _;+                  pushstring 5; return 3]])+assert(a == 1 and b == -10 and c == "5")+mt = {__add = function (a,b) return setmetatable({a[1] + b[1]}, mt) end,+      __mod = function (a,b) return setmetatable({a[1] % b[1]}, mt) end,+      __unm = function (a) return setmetatable({a[1]* 2}, mt) end}+a,b,c = setmetatable({4}, mt),+        setmetatable({8}, mt),+        setmetatable({-3}, mt)+x,y,z = T.testC("arith +; return 2", 10, a, b)+assert(x == 10 and y[1] == 12 and z == nil)+assert(T.testC("arith %; return 1", a, c)[1] == 4%-3)+assert(T.testC("arith _; arith +; arith %; return 1", b, a, c)[1] ==+               8 % (4 + (-3)*2))+++-- testing compare+-- EQ = 0; LT = 1; LE = 2++-- testing lessthan and lessequal+assert(T.testC("compare 2 5 1, return 1", 3, 2, 2, 4, 2, 2))+assert(T.testC("compare 2 5 2, return 1", 3, 2, 2, 4, 2, 2))+assert(not T.testC("compare 3 4 1, return 1", 3, 2, 2, 4, 2, 2))+assert(T.testC("compare 3 4 2, return 1", 3, 2, 2, 4, 2, 2))+assert(T.testC("compare 5 2 1, return 1", 4, 2, 2, 3, 2, 2))+assert(not T.testC("compare 2 -3 1, return 1", "4", "2", "2", "3", "2", "2"))+assert(not T.testC("compare -3 2 1, return 1", "3", "2", "2", "4", "2", "2"))++-- non-valid indices produce false+assert(not T.testC("compare 1 4 1, return 1"))+assert(not T.testC("compare 9 1 2, return 1"))+assert(not T.testC("compare 9 9 0, return 1"))++local b = {__lt = function (a,b) return a[1] < b[1] end}+local a1,a3,a4 = setmetatable({1}, b),+                 setmetatable({3}, b),+                 setmetatable({4}, b)+assert(T.testC("compare 2 5 1, return 1", a3, 2, 2, a4, 2, 2))+assert(T.testC("compare 2 5 2, return 1", a3, 2, 2, a4, 2, 2))+assert(T.testC("compare 5 -6 1, return 1", a4, 2, 2, a3, 2, 2))+a,b = T.testC("compare 5 -6 1, return 2", a1, 2, 2, a3, 2, 20)+assert(a == 20 and b == false)+a,b = T.testC("compare 5 -6 2, return 2", a1, 2, 2, a3, 2, 20)+assert(a == 20 and b == false)+a,b = T.testC("compare 5 -6 2, return 2", a1, 2, 2, a1, 2, 20)+assert(a == 20 and b == true)++-- testing length+local t = setmetatable({x = 20}, {__len = function (t) return t.x end})+a,b,c = T.testC([[+   len 2;+   Llen 2;+   objsize 2;+   return 3+]], t)+assert(a == 20 and b == 20 and c == 0)++t.x = "234"; t[1] = 20+a,b,c = T.testC([[+   len 2;+   Llen 2;+   objsize 2;+   return 3+]], t)+assert(a == "234" and b == 234 and c == 1)++t.x = print; t[1] = 20+a,c = T.testC([[+   len 2;+   objsize 2;+   return 2+]], t)+assert(a == print and c == 1)+++-- testing __concat++a = setmetatable({x="u"}, {__concat = function (a,b) return a.x..'.'..b.x end})+x,y = T.testC([[+  pushnum 5+  pushvalue 2;+  pushvalue 2;+  concat 2;+  pushvalue -2;+  return 2;+]], a, a)+assert(x == a..a and y == 5)++-- concat with 0 elements+assert(T.testC("concat 0; return 1") == "")++-- concat with 1 element+assert(T.testC("concat 1; return 1", "xuxu") == "xuxu")++++-- testing lua_is++function B(x) return x and 1 or 0 end++function count (x, n)+  n = n or 2+  local prog = [[+    isnumber %d;+    isstring %d;+    isfunction %d;+    iscfunction %d;+    istable %d;+    isuserdata %d;+    isnil %d;+    isnull %d;+    return 8+  ]]+  prog = string.format(prog, n, n, n, n, n, n, n, n)+  local a,b,c,d,e,f,g,h = T.testC(prog, x)+  return B(a)+B(b)+B(c)+B(d)+B(e)+B(f)+B(g)+(100*B(h))+end++assert(count(3) == 2)+assert(count('alo') == 1)+assert(count('32') == 2)+assert(count({}) == 1)+assert(count(print) == 2)+assert(count(function () end) == 1)+assert(count(nil) == 1)+assert(count(io.stdin) == 1)+assert(count(nil, 15) == 100)+++-- testing lua_to...++function to (s, x, n)+  n = n or 2+  return T.testC(string.format("%s %d; return 1", s, n), x)+end++assert(to("tostring", {}) == nil)+assert(to("tostring", "alo") == "alo")+assert(to("tostring", 12) == "12")+assert(to("tostring", 12, 3) == nil)+assert(to("objsize", {}) == 0)+assert(to("objsize", {1,2,3}) == 3)+assert(to("objsize", "alo\0\0a") == 6)+assert(to("objsize", T.newuserdata(0)) == 0)+assert(to("objsize", T.newuserdata(101)) == 101)+assert(to("objsize", 124) == 0)+assert(to("objsize", true) == 0)+assert(to("tonumber", {}) == 0)+assert(to("tonumber", "12") == 12)+assert(to("tonumber", "s2") == 0)+assert(to("tonumber", 1, 20) == 0)+assert(to("topointer", 10) == 0)+assert(to("topointer", true) == 0)+assert(to("topointer", T.pushuserdata(20)) == 20)+assert(to("topointer", io.read) ~= 0)+assert(to("func2num", 20) == 0)+assert(to("func2num", T.pushuserdata(10)) == 0)+assert(to("func2num", io.read) ~= 0)+a = to("tocfunction", math.deg)+assert(a(3) == math.deg(3) and a == math.deg)++++-- testing deep C stack+do+  collectgarbage("stop")+  local s, msg = pcall(T.testC, "checkstack 1000023 XXXX")   -- too deep+  assert(not s and string.find(msg, "XXXX"))+  s = string.rep("pushnil;checkstack 1 XX;", 1000000)+  s, msg = pcall(T.testC, s)+  assert(not s and string.find(msg, "XX"))+  collectgarbage("restart")+end++local prog = {"checkstack 30000 msg", "newtable"}+for i = 1,12000 do+  prog[#prog + 1] = "pushnum " .. i+  prog[#prog + 1] = "pushnum " .. i * 10+end++prog[#prog + 1] = "rawgeti R 2"   -- get global table in registry+prog[#prog + 1] = "insert " .. -(2*12000 + 2)++for i = 1,12000 do+  prog[#prog + 1] = "settable " .. -(2*(12000 - i + 1) + 1)+end++prog[#prog + 1] = "return 2"++prog = table.concat(prog, ";")+local g, t = T.testC(prog)+assert(g == _G)+for i = 1,12000 do assert(t[i] == i*10); t[i] = nil end+assert(next(t) == nil)+prog, g, t = nil++-- testing errors++a = T.testC([[+  loadstring 2; pcall 0,1;+  pushvalue 3; insert -2; pcall 1, 1;+  pcall 0, 0;+  return 1+]], "x=150", function (a) assert(a==nil); return 3 end)++assert(type(a) == 'string' and x == 150)++function check3(p, ...)+  local arg = {...}+  assert(#arg == 3)+  assert(string.find(arg[3], p))+end+check3(":1:", T.testC("loadstring 2; gettop; return .", "x="))+check3("cannot read", T.testC("loadfile 2; gettop; return .", "."))+check3("cannot open xxxx", T.testC("loadfile 2; gettop; return .", "xxxx"))++-- test errors in non protected threads+function checkerrnopro (code, msg)+  L = coroutine.create(function () end)+  local stt, err = pcall(T.testC, code)+  assert(not stt and string.find(err, msg))+end++checkerrnopro("pushnum 3; call 0 0", "attempt to call")+function f () f() end+checkerrnopro("getglobal 'f'; call 0 0;", "stack overflow")+++-- testing table access++a = {x=0, y=12}+x, y = T.testC("gettable 2; pushvalue 4; gettable 2; return 2",+                a, 3, "y", 4, "x")+assert(x == 0 and y == 12)+T.testC("settable -5", a, 3, 4, "x", 15)+assert(a.x == 15)+a[a] = print+x = T.testC("gettable 2; return 1", a)  -- table and key are the same object!+assert(x == print)+T.testC("settable 2", a, "x")    -- table and key are the same object!+assert(a[a] == "x")++b = setmetatable({p = a}, {})+getmetatable(b).__index = function (t, i) return t.p[i] end+k, x = T.testC("gettable 3, return 2", 4, b, 20, 35, "x")+assert(x == 15 and k == 35)+getmetatable(b).__index = function (t, i) return a[i] end+getmetatable(b).__newindex = function (t, i,v ) a[i] = v end+y = T.testC("insert 2; gettable -5; return 1", 2, 3, 4, "y", b)+assert(y == 12)+k = T.testC("settable -5, return 1", b, 3, 4, "x", 16)+assert(a.x == 16 and k == 4)+a[b] = 'xuxu'+y = T.testC("gettable 2, return 1", b)+assert(y == 'xuxu')+T.testC("settable 2", b, 19)+assert(a[b] == 19)++-- testing next+a = {}+t = pack(T.testC("next; gettop; return .", a, nil))+tcheck(t, {n=1,a})+a = {a=3}+t = pack(T.testC("next; gettop; return .", a, nil))+tcheck(t, {n=3,a,'a',3})+t = pack(T.testC("next; pop 1; next; gettop; return .", a, nil))+tcheck(t, {n=1,a})++++-- testing upvalues++do+  local A = T.testC[[ pushnum 10; pushnum 20; pushcclosure 2; return 1]]+  t, b, c = A([[pushvalue U0; pushvalue U1; pushvalue U2; return 3]])+  assert(b == 10 and c == 20 and type(t) == 'table')+  a, b = A([[tostring U3; tonumber U4; return 2]])+  assert(a == nil and b == 0)+  A([[pushnum 100; pushnum 200; replace U2; replace U1]])+  b, c = A([[pushvalue U1; pushvalue U2; return 2]])+  assert(b == 100 and c == 200)+  A([[replace U2; replace U1]], {x=1}, {x=2})+  b, c = A([[pushvalue U1; pushvalue U2; return 2]])+  assert(b.x == 1 and c.x == 2)+  T.checkmemory()+end+++-- testing absent upvalues from C-function pointers+assert(T.testC[[isnull U1; return 1]] == true)+assert(T.testC[[isnull U100; return 1]] == true)+assert(T.testC[[pushvalue U1; return 1]] == nil)++local f = T.testC[[ pushnum 10; pushnum 20; pushcclosure 2; return 1]]+assert(T.upvalue(f, 1) == 10 and+       T.upvalue(f, 2) == 20 and+       T.upvalue(f, 3) == nil)+T.upvalue(f, 2, "xuxu")+assert(T.upvalue(f, 2) == "xuxu")+++-- large closures+do+  local A = "checkstack 300 msg;" ..+            string.rep("pushnum 10;", 255) ..+            "pushcclosure 255; return 1"+  A = T.testC(A)+  for i=1,255 do+    assert(A(("pushvalue U%d; return 1"):format(i)) == 10)+  end+  assert(A("isnull U256; return 1"))+  assert(not A("isnil U256; return 1"))+end+  +++-- bug in 5.1.2+assert(not pcall(debug.setuservalue, 3, {}))+assert(not pcall(debug.setuservalue, nil, {}))+assert(not pcall(debug.setuservalue, T.pushuserdata(1), {}))++local b = T.newuserdata(0)+local a = {}+assert(debug.getuservalue(b) == nil)+assert(debug.setuservalue(b, a))+assert(debug.getuservalue(b) == a)+assert(debug.setuservalue(b, nil))+assert(debug.getuservalue(b) == nil)++assert(debug.getuservalue(4) == nil)++++-- testing locks (refs)++-- reuse of references+local i = T.ref{}+T.unref(i)+assert(T.ref{} == i)++Arr = {}+Lim = 100+for i=1,Lim do   -- lock many objects+  Arr[i] = T.ref({})+end++assert(T.ref(nil) == -1 and T.getref(-1) == nil)+T.unref(-1); T.unref(-1)++for i=1,Lim do   -- unlock all them+  T.unref(Arr[i])+end++function printlocks ()+  local f = T.makeCfunc("gettable R; return 1")+  local n = f("n")+  print("n", n)+  for i=0,n do+    print(i, f(i))+  end+end+++for i=1,Lim do   -- lock many objects+  Arr[i] = T.ref({})+end++for i=1,Lim,2 do   -- unlock half of them+  T.unref(Arr[i])+end++assert(type(T.getref(Arr[2])) == 'table')+++assert(T.getref(-1) == nil)+++a = T.ref({})++collectgarbage()++assert(type(T.getref(a)) == 'table')+++-- colect in cl the `val' of all collected userdata+tt = {}+cl = {n=0}+A = nil; B = nil+local F+F = function (x)+  local udval = T.udataval(x)+  table.insert(cl, udval)+  local d = T.newuserdata(100)   -- cria lixo+  d = nil+  assert(debug.getmetatable(x).__gc == F)+  assert(load("table.insert({}, {})"))()   -- cria mais lixo+  collectgarbage()   -- forca coleta de lixo durante coleta!+  assert(debug.getmetatable(x).__gc == F)   -- coleta anterior nao melou isso?+  local dummy = {}    -- cria lixo durante coleta+  if A ~= nil then+    assert(type(A) == "userdata")+    assert(T.udataval(A) == B)+    debug.getmetatable(A)    -- just acess it+  end+  A = x   -- ressucita userdata+  B = udval+  return 1,2,3+end+tt.__gc = F++-- test whether udate collection frees memory in the right time+do+  collectgarbage();+  collectgarbage();+  local x = collectgarbage("count");+  local a = T.newuserdata(5001)+  assert(T.testC("objsize 2; return 1", a) == 5001)+  assert(collectgarbage("count") >= x+4) +  a = nil+  collectgarbage();+  assert(collectgarbage("count") <= x+1)+  -- udata without finalizer+  x = collectgarbage("count")+  collectgarbage("stop")+  for i=1,1000 do T.newuserdata(0) end+  assert(collectgarbage("count") > x+10)+  collectgarbage()+  assert(collectgarbage("count") <= x+1)+  -- udata with finalizer+  x = collectgarbage("count")+  collectgarbage()+  collectgarbage("stop")+  a = {__gc = function () end}+  for i=1,1000 do debug.setmetatable(T.newuserdata(0), a) end+  assert(collectgarbage("count") >= x+10)+  collectgarbage()  -- this collection only calls TM, without freeing memory+  assert(collectgarbage("count") >= x+10)+  collectgarbage()  -- now frees memory+  assert(collectgarbage("count") <= x+1)+  collectgarbage("restart")+end+++collectgarbage("stop")++-- create 3 userdatas with tag `tt'+a = T.newuserdata(0); debug.setmetatable(a, tt); na = T.udataval(a)+b = T.newuserdata(0); debug.setmetatable(b, tt); nb = T.udataval(b)+c = T.newuserdata(0); debug.setmetatable(c, tt); nc = T.udataval(c)++-- create userdata without meta table+x = T.newuserdata(4)+y = T.newuserdata(0)++assert(not pcall(io.input, a))+assert(not pcall(io.input, x))++assert(debug.getmetatable(x) == nil and debug.getmetatable(y) == nil)++d=T.ref(a);+e=T.ref(b);+f=T.ref(c);+t = {T.getref(d), T.getref(e), T.getref(f)}+assert(t[1] == a and t[2] == b and t[3] == c)++t=nil; a=nil; c=nil;+T.unref(e); T.unref(f)++collectgarbage()++-- check that unref objects have been collected+assert(#cl == 1 and cl[1] == nc)++x = T.getref(d)+assert(type(x) == 'userdata' and debug.getmetatable(x) == tt)+x =nil+tt.b = b  -- create cycle+tt=nil    -- frees tt for GC+A = nil+b = nil+T.unref(d);+n5 = T.newuserdata(0)+debug.setmetatable(n5, {__gc=F})+n5 = T.udataval(n5)+collectgarbage()+assert(#cl == 4)+-- check order of collection+assert(cl[2] == n5 and cl[3] == nb and cl[4] == na)++collectgarbage"restart"+++a, na = {}, {}+for i=30,1,-1 do+  a[i] = T.newuserdata(0)+  debug.setmetatable(a[i], {__gc=F})+  na[i] = T.udataval(a[i])+end+cl = {}+a = nil; collectgarbage()+assert(#cl == 30)+for i=1,30 do assert(cl[i] == na[i]) end+na = nil+++for i=2,Lim,2 do   -- unlock the other half+  T.unref(Arr[i])+end++x = T.newuserdata(41); debug.setmetatable(x, {__gc=F})+assert(T.testC("objsize 2; return 1", x) == 41)+cl = {}+a = {[x] = 1}+x = T.udataval(x)+collectgarbage()+-- old `x' cannot be collected (`a' still uses it)+assert(#cl == 0)+for n in pairs(a) do a[n] = nil end+collectgarbage()+assert(#cl == 1 and cl[1] == x)   -- old `x' must be collected++-- testing lua_equal+assert(T.testC("compare 2 4 0; return 1", print, 1, print, 20))+assert(T.testC("compare 3 2 0; return 1", 'alo', "alo"))+assert(T.testC("compare 2 3 0; return 1", nil, nil))+assert(not T.testC("compare 2 3 0; return 1", {}, {}))+assert(not T.testC("compare 2 3 0; return 1"))+assert(not T.testC("compare 2 3 0; return 1", 3))++-- testing lua_equal with fallbacks+do+  local map = {}+  local t = {__eq = function (a,b) return map[a] == map[b] end}+  local function f(x)+    local u = T.newuserdata(0)+    debug.setmetatable(u, t)+    map[u] = x+    return u+  end+  assert(f(10) == f(10))+  assert(f(10) ~= f(11))+  assert(T.testC("compare 2 3 0; return 1", f(10), f(10)))+  assert(not T.testC("compare 2 3 0; return 1", f(10), f(20)))+  t.__eq = nil+  assert(f(10) ~= f(10))+end++print'+'++++-- testing changing hooks during hooks+_G.t = {}+T.sethook([[+  # set a line hook after 3 count hooks+  sethook 4 0 '+    getglobal t;+    pushvalue -3; append -2+    pushvalue -2; append -2+  ']], "c", 3)+local a = 1   -- counting+a = 1   -- counting+a = 1   -- count hook (set line hook)+a = 1   -- line hook+a = 1   -- line hook+debug.sethook()+t = _G.t+assert(t[1] == "line")+line = t[2]+assert(t[3] == "line" and t[4] == line + 1)+assert(t[5] == "line" and t[6] == line + 2)+assert(t[7] == nil)+++-------------------------------------------------------------------------+do   -- testing errors during GC+  local a = {}+  for i=1,20 do+    a[i] = T.newuserdata(i)   -- creates several udata+  end+  for i=1,20,2 do   -- mark half of them to raise errors during GC+    debug.setmetatable(a[i], {__gc = function (x) error("error inside gc") end})+  end+  for i=2,20,2 do   -- mark the other half to count and to create more garbage+    debug.setmetatable(a[i], {__gc = function (x) load("A=A+1")() end})+  end+  _G.A = 0+  a = 0+  while 1 do+    local stat, msg = pcall(collectgarbage)+    if stat then+      break   -- stop when no more errors+    else+      a = a + 1+      assert(string.find(msg, "__gc"))+    end+  end+  assert(a == 10)  -- number of errors++  assert(A == 10)  -- number of normal collections+end+-------------------------------------------------------------------------+-- test for userdata vals+do+  local a = {}; local lim = 30+  for i=0,lim do a[i] = T.pushuserdata(i) end+  for i=0,lim do assert(T.udataval(a[i]) == i) end+  for i=0,lim do assert(T.pushuserdata(i) == a[i]) end+  for i=0,lim do a[a[i]] = i end+  for i=0,lim do a[T.pushuserdata(i)] = i end+  assert(type(tostring(a[1])) == "string")+end+++-------------------------------------------------------------------------+-- testing multiple states+T.closestate(T.newstate());+L1 = T.newstate()+assert(L1)++assert(T.doremote(L1, "X='a'; return 'a'") == 'a')+++assert(#pack(T.doremote(L1, "function f () return 'alo', 3 end; f()")) == 0)++a, b = T.doremote(L1, "return f()")+assert(a == 'alo' and b == '3')++T.doremote(L1, "_ERRORMESSAGE = nil")+-- error: `sin' is not defined+a, _, b = T.doremote(L1, "return sin(1)")+assert(a == nil and b == 2)   -- 2 == run-time error++-- error: syntax error+a, b, c = T.doremote(L1, "return a+")+assert(a == nil and c == 3 and type(b) == "string")   -- 3 == syntax error++T.loadlib(L1)+a, b, c = T.doremote(L1, [[+  string = require'string'+  a = require'_G'; assert(a == _G and require("_G") == a)+  io = require'io'; assert(type(io.read) == "function")+  assert(require("io") == io)+  a = require'table'; assert(type(a.insert) == "function")+  a = require'debug'; assert(type(a.getlocal) == "function")+  a = require'math'; assert(type(a.sin) == "function")+  return string.sub('okinama', 1, 2)+]])+assert(a == "ok")++T.closestate(L1);+++L1 = T.newstate()+T.loadlib(L1)+T.doremote(L1, "a = {}")+T.testC(L1, [[getglobal "a"; pushstring "x"; pushnum 1;+             settable -3]])+assert(T.doremote(L1, "return a.x") == "1")++T.closestate(L1)++L1 = nil++print('+')++-------------------------------------------------------------------------+-- testing memory limits+-------------------------------------------------------------------------+assert(not pcall(T.newuserdata, 2^32-4))+collectgarbage()+T.totalmem(T.totalmem()+5000)   -- set low memory limit (+5k)+assert(not pcall(load"local a={}; for i=1,100000 do a[i]=i end"))+T.totalmem(1000000000)          -- restore high limit++-- test memory errors; increase memory limit in small steps, so that+-- we get memory errors in different parts of a given task, up to there+-- is enough memory to complete the task without errors+function testamem (s, f)+  collectgarbage(); collectgarbage()+  local M = T.totalmem()+  local oldM = M+  local a,b = nil+  while 1 do+    M = M+7   -- increase memory limit in small steps+    T.totalmem(M)+    a, b = pcall(f)+    T.totalmem(1000000000)  -- restore high limit+    if a and b then break end       -- stop when no more errors+    collectgarbage()+    if not a and not    -- `real' error?+      (string.find(b, "memory") or string.find(b, "overflow")) then+      error(b, 0)   -- propagate it+    end+  end+  print("\nlimit for " .. s .. ": " .. M-oldM)+  return b+end+++-- testing memory errors when creating a new state++b = testamem("state creation", T.newstate)+T.closestate(b);  -- close new state+++-- testing threads++-- get main thread from registry (at index LUA_RIDX_MAINTHREAD == 1)+mt = T.testC("rawgeti R 1; return 1")+assert(type(mt) == "thread" and coroutine.running() == mt)++++function expand (n,s)+  if n==0 then return "" end+  local e = string.rep("=", n)+  return string.format("T.doonnewstack([%s[ %s;\n collectgarbage(); %s]%s])\n",+                              e, s, expand(n-1,s), e)+end++G=0; collectgarbage(); a =collectgarbage("count")+load(expand(20,"G=G+1"))()+assert(G==20); collectgarbage();  -- assert(gcinfo() <= a+1)++testamem("thread creation", function ()+  return T.doonnewstack("x=1") == 0  -- try to create thread+end)+++-- testing memory x compiler++testamem("loadstring", function ()+  return load("x=1")  -- try to do load a string+end)+++local testprog = [[+local function foo () return end+local t = {"x"}+a = "aaa"+for i = 1, #t do a=a..t[i] end+return true+]]++-- testing memory x dofile+_G.a = nil+local t =os.tmpname()+local f = assert(io.open(t, "w"))+f:write(testprog)+f:close()+testamem("dofile", function ()+  local a = loadfile(t)+  return a and a()+end)+assert(os.remove(t))+assert(_G.a == "aaax")+++-- other generic tests++testamem("string creation", function ()+  local a, b = string.gsub("alo alo", "(a)", function (x) return x..'b' end)+  return (a == 'ablo ablo')+end)++testamem("dump/undump", function ()+  local a = load(testprog)+  local b = a and string.dump(a)+  a = b and load(b)+  return a and a()+end)++local t = os.tmpname()+testamem("file creation", function ()+  local f = assert(io.open(t, 'w'))+  assert (not io.open"nomenaoexistente")+  io.close(f);+  return not loadfile'nomenaoexistente'+end)+assert(os.remove(t))++testamem("table creation", function ()+  local a, lim = {}, 10+  for i=1,lim do a[i] = i; a[i..'a'] = {} end+  return (type(a[lim..'a']) == 'table' and a[lim] == lim)+end)++testamem("constructors", function ()+  local a = {10, 20, 30, 40, 50; a=1, b=2, c=3, d=4, e=5}+  return (type(a) == 'table' and a.e == 5)+end)++local a = 1+close = nil+testamem("closure creation", function ()+  function close (b,c)+   return function (x) return a+b+c+x end+  end+  return (close(2,3)(4) == 10)+end)++testamem("coroutines", function ()+  local a = coroutine.wrap(function ()+              coroutine.yield(string.rep("a", 10))+              return {}+            end)+  assert(string.len(a()) == 10)+  return a()+end)++print'+'++-- testing some auxlib functions+local function gsub (a, b, c)+  a, b = T.testC("gsub 2 3 4; gettop; return 2", a, b, c)+  assert(b == 5)+  return a+end++assert(gsub("alo.alo.uhuh.", ".", "//") == "alo//alo//uhuh//")+assert(gsub("alo.alo.uhuh.", "alo", "//") == "//.//.uhuh.")+assert(gsub("", "alo", "//") == "")+assert(gsub("...", ".", "/.") == "/././.")+assert(gsub("...", "...", "") == "")+++-- testing luaL_newmetatable+local mt_xuxu, res, top = T.testC("newmetatable xuxu; gettop; return 3")+assert(type(mt_xuxu) == "table" and res and top == 3)+local d, res, top = T.testC("newmetatable xuxu; gettop; return 3")+assert(mt_xuxu == d and not res and top == 3)+d, res, top = T.testC("newmetatable xuxu1; gettop; return 3")+assert(mt_xuxu ~= d and res and top == 3)++x = T.newuserdata(0);+y = T.newuserdata(0);+T.testC("pushstring xuxu; gettable R; setmetatable 2", x)+assert(getmetatable(x) == mt_xuxu)++-- testing luaL_testudata+-- correct metatable+local res1, res2, top = T.testC([[testudata -1 xuxu+   	 			  testudata 2 xuxu+				  gettop+				  return 3]], x)+assert(res1 and res2 and top == 4)++-- wrong metatable+res1, res2, top = T.testC([[testudata -1 xuxu1+			    testudata 2 xuxu1+			    gettop+			    return 3]], x)+assert(not res1 and not res2 and top == 4)++-- non-existent type+res1, res2, top = T.testC([[testudata -1 xuxu2+			    testudata 2 xuxu2+			    gettop+			    return 3]], x)+assert(not res1 and not res2 and top == 4)++-- userdata has no metatable+res1, res2, top = T.testC([[testudata -1 xuxu+			    testudata 2 xuxu+			    gettop+			    return 3]], y)+assert(not res1 and not res2 and top == 4)++-- erase metatables+do+  local r = debug.getregistry()+  assert(r.xuxu == mt_xuxu and r.xuxu1 == d)+  r.xuxu = nil; r.xuxu1 = nil+end++print'OK'+

@@ -0,0 +1,421 @@+-- The tests for 'require' assume some specific directories and libraries;+-- better to avoid them in generic machines++if not _port then --[++print "testing require"++assert(require"string" == string)+assert(require"math" == math)+assert(require"table" == table)+assert(require"io" == io)+assert(require"os" == os)+assert(require"coroutine" == coroutine)++assert(type(package.path) == "string")+assert(type(package.cpath) == "string")+assert(type(package.loaded) == "table")+assert(type(package.preload) == "table")++assert(type(package.config) == "string")+print("package config: "..string.gsub(package.config, "\n", "|"))++do+  -- create a path with 'max' templates,+  -- each with 1-10 repetitions of '?'+  local max = 2000+  local t = {}+  for i = 1,max do t[i] = string.rep("?", i%10 + 1) end+  t[#t + 1] = ";"    -- empty template+  local path = table.concat(t, ";")+  -- use that path in a search+  local s, err = package.searchpath("xuxu", path)+  -- search fails; check that message has an occurence of+  -- '??????????' with ? replaced by xuxu and at least 'max' lines+  assert(not s and+         string.find(err, string.rep("xuxu", 10)) and+         #string.gsub(err, "[^\n]", "") >= max)+  -- path with one very long template+  local path = string.rep("?", max)+  local s, err = package.searchpath("xuxu", path)+  assert(not s and string.find(err, string.rep('xuxu', max)))+end++do+  local oldpath = package.path+  package.path = {}+  local s, err = pcall(require, "no-such-file")+  assert(not s and string.find(err, "package.path"))+  package.path = oldpath+end++print('+')++-- auxiliary directory with C modules and temporary files+local DIR = "libs/"++-- prepend DIR to a name+local function D (x) return DIR .. x end+++local function createfiles (files, preextras, posextras)+  for n,c in pairs(files) do+    io.output(D(n))+    io.write(string.format(preextras, n))+    io.write(c)+    io.write(string.format(posextras, n))+    io.close(io.output())+  end+end++function removefiles (files)+  for n in pairs(files) do+    os.remove(D(n))+  end+end++local files = {+  ["names.lua"] = "do return {...} end\n",+  ["err.lua"] = "B = 15; a = a + 1;",+  ["A.lua"] = "",+  ["B.lua"] = "assert(...=='B');require 'A'",+  ["A.lc"] = "",+  ["A"] = "",+  ["L"] = "",+  ["XXxX"] = "",+  ["C.lua"] = "package.loaded[...] = 25; require'C'"+}++AA = nil+local extras = [[+NAME = '%s'+REQUIRED = ...+return AA]]++createfiles(files, "", extras)++-- testing explicit "dir" separator in 'searchpath'+assert(package.searchpath("C.lua", D"?", "", "") == D"C.lua")+assert(package.searchpath("C.lua", D"?", ".", ".") == D"C.lua")+assert(package.searchpath("--x-", D"?", "-", "X") == D"XXxX")+assert(package.searchpath("---xX", D"?", "---", "XX") == D"XXxX")+assert(package.searchpath(D"C.lua", "?", "/") == D"C.lua")+assert(package.searchpath(".\\C.lua", D"?", "\\") == D"./C.lua")++local oldpath = package.path++package.path = string.gsub("D/?.lua;D/?.lc;D/?;D/??x?;D/L", "D/", DIR)++local try = function (p, n, r)+  NAME = nil+  local rr = require(p)+  assert(NAME == n)+  assert(REQUIRED == p)+  assert(rr == r)+end++a = require"names"+assert(a[1] == "names" and a[2] == D"names.lua")++_G.a = nil+assert(not pcall(require, "err"))+assert(B == 15)++assert(package.searchpath("C", package.path) == D"C.lua")+assert(require"C" == 25)+assert(require"C" == 25)+AA = nil+try('B', 'B.lua', true)+assert(package.loaded.B)+assert(require"B" == true)+assert(package.loaded.A)+assert(require"C" == 25)+package.loaded.A = nil+try('B', nil, true)   -- should not reload package+try('A', 'A.lua', true)+package.loaded.A = nil+os.remove(D'A.lua')+AA = {}+try('A', 'A.lc', AA)  -- now must find second option+assert(package.searchpath("A", package.path) == D"A.lc")+assert(require("A") == AA)+AA = false+try('K', 'L', false)     -- default option+try('K', 'L', false)     -- default option (should reload it)+assert(rawget(_G, "_REQUIREDNAME") == nil)++AA = "x"+try("X", "XXxX", AA)+++removefiles(files)+++-- testing require of sub-packages++local _G = _G++package.path = string.gsub("D/?.lua;D/?/init.lua", "D/", DIR)++files = {+  ["P1/init.lua"] = "AA = 10",+  ["P1/xuxu.lua"] = "AA = 20",+}++createfiles(files, "_ENV = {}\n", "\nreturn _ENV\n")+AA = 0++local m = assert(require"P1")+assert(AA == 0 and m.AA == 10)+assert(require"P1" == m)+assert(require"P1" == m)++assert(package.searchpath("P1.xuxu", package.path) == D"P1/xuxu.lua")+m.xuxu = assert(require"P1.xuxu")+assert(AA == 0 and m.xuxu.AA == 20)+assert(require"P1.xuxu" == m.xuxu)+assert(require"P1.xuxu" == m.xuxu)+assert(require"P1" == m and m.AA == 10)+++removefiles(files)+++package.path = ""+assert(not pcall(require, "file_does_not_exist"))+package.path = "??\0?"+assert(not pcall(require, "file_does_not_exist1"))++package.path = oldpath++-- check 'require' error message+local fname = "file_does_not_exist2"+local m, err = pcall(require, fname)+for t in string.gmatch(package.path..";"..package.cpath, "[^;]+") do+  t = string.gsub(t, "?", fname)+  assert(string.find(err, t, 1, true))+end+++local function import(...)+  local f = {...}+  return function (m)+    for i=1, #f do m[f[i]] = _G[f[i]] end+  end+end++-- cannot change environment of a C function+assert(not pcall(module, 'XUXU'))++++-- testing require of C libraries+++local p = ""   -- On Mac OS X, redefine this to "_"++-- check whether loadlib works in this system+local st, err, when = package.loadlib(D"lib1.so", "*")+if not st then+  local f, err, when = package.loadlib("donotexist", p.."xuxu")+  assert(not f and type(err) == "string" and when == "absent")+  ;(Message or print)('\a\n >>> cannot load dynamic library <<<\n\a')+  print(err, when)+else+  -- tests for loadlib+  local f = assert(package.loadlib(D"lib1.so", p.."onefunction"))+  local a, b = f(15, 25)+  assert(a == 25 and b == 15)++  f = assert(package.loadlib(D"lib1.so", p.."anotherfunc"))+  assert(f(10, 20) == "1020\n")++  -- check error messages+  local f, err, when = package.loadlib(D"lib1.so", p.."xuxu")+  assert(not f and type(err) == "string" and when == "init")+  f, err, when = package.loadlib("donotexist", p.."xuxu")+  assert(not f and type(err) == "string" and when == "open")++  -- symbols from 'lib1' must be visible to other libraries+  f = assert(package.loadlib(D"lib11.so", p.."luaopen_lib11"))+  assert(f() == "exported")++  -- test C modules with prefixes in names+  package.cpath = D"?.so"+  local lib2 = require"v-lib2"+  -- check correct access to global environment and correct+  -- parameters+  assert(_ENV.x == "v-lib2" and _ENV.y == D"v-lib2.so")+  assert(lib2.id("x") == "x")++  -- test C submodules+  local fs = require"lib1.sub"+  assert(_ENV.x == "lib1.sub" and _ENV.y == D"lib1.so")+  assert(fs.id(45) == 45)+end++_ENV = _G+++-- testing preload++do+  local p = package+  package = {}+  p.preload.pl = function (...)+    local _ENV = {...}+    function xuxu (x) return x+20 end+    return _ENV+  end++  local pl = require"pl"+  assert(require"pl" == pl)+  assert(pl.xuxu(10) == 30)+  assert(pl[1] == "pl" and pl[2] == nil)++  package = p+  assert(type(package.path) == "string")+end++print('+')++end  --]++print("testing assignments, logical operators, and constructors")++local res, res2 = 27++a, b = 1, 2+3+assert(a==1 and b==5)+a={}+function f() return 10, 11, 12 end+a.x, b, a[1] = 1, 2, f()+assert(a.x==1 and b==2 and a[1]==10)+a[f()], b, a[f()+3] = f(), a, 'x'+assert(a[10] == 10 and b == a and a[13] == 'x')++do+  local f = function (n) local x = {}; for i=1,n do x[i]=i end;+                         return table.unpack(x) end;+  local a,b,c+  a,b = 0, f(1)+  assert(a == 0 and b == 1)+  A,b = 0, f(1)+  assert(A == 0 and b == 1)+  a,b,c = 0,5,f(4)+  assert(a==0 and b==5 and c==1)+  a,b,c = 0,5,f(0)+  assert(a==0 and b==5 and c==nil)+end++a, b, c, d = 1 and nil, 1 or nil, (1 and (nil or 1)), 6+assert(not a and b and c and d==6)++d = 20+a, b, c, d = f()+assert(a==10 and b==11 and c==12 and d==nil)+a,b = f(), 1, 2, 3, f()+assert(a==10 and b==1)++assert(a<b == false and a>b == true)+assert((10 and 2) == 2)+assert((10 or 2) == 10)+assert((10 or assert(nil)) == 10)+assert(not (nil and assert(nil)))+assert((nil or "alo") == "alo")+assert((nil and 10) == nil)+assert((false and 10) == false)+assert((true or 10) == true)+assert((false or 10) == 10)+assert(false ~= nil)+assert(nil ~= false)+assert(not nil == true)+assert(not not nil == false)+assert(not not 1 == true)+assert(not not a == true)+assert(not not (6 or nil) == true)+assert(not not (nil and 56) == false)+assert(not not (nil and true) == false)++assert({} ~= {})+print('+')++a = {}+a[true] = 20+a[false] = 10+assert(a[1<2] == 20 and a[1>2] == 10)++function f(a) return a end++local a = {}+for i=3000,-3000,-1 do a[i] = i; end+a[10e30] = "alo"; a[true] = 10; a[false] = 20+assert(a[10e30] == 'alo' and a[not 1] == 20 and a[10<20] == 10)+for i=3000,-3000,-1 do assert(a[i] == i); end+a[print] = assert+a[f] = print+a[a] = a+assert(a[a][a][a][a][print] == assert)+a[print](a[a[f]] == a[print])+assert(not pcall(function () local a = {}; a[nil] = 10 end))+assert(not pcall(function () local a = {[nil] = 10} end))+assert(a[nil] == nil)+a = nil++a = {10,9,8,7,6,5,4,3,2; [-3]='a', [f]=print, a='a', b='ab'}+a, a.x, a.y = a, a[-3]+assert(a[1]==10 and a[-3]==a.a and a[f]==print and a.x=='a' and not a.y)+a[1], f(a)[2], b, c = {['alo']=assert}, 10, a[1], a[f], 6, 10, 23, f(a), 2+a[1].alo(a[2]==10 and b==10 and c==print)++a[2^31] = 10; a[2^31+1] = 11; a[-2^31] = 12;+a[2^32] = 13; a[-2^32] = 14; a[2^32+1] = 15; a[10^33] = 16;++assert(a[2^31] == 10 and a[2^31+1] == 11 and a[-2^31] == 12 and+       a[2^32] == 13 and a[-2^32] == 14 and a[2^32+1] == 15 and+       a[10^33] == 16)++a = nil+++-- test conflicts in multiple assignment+do+  local a,i,j,b+  a = {'a', 'b'}; i=1; j=2; b=a+  i, a[i], a, j, a[j], a[i+j] = j, i, i, b, j, i+  assert(i == 2 and b[1] == 1 and a == 1 and j == b and b[2] == 2 and+         b[3] == 1)+end++-- repeat test with upvalues+do+  local a,i,j,b+  a = {'a', 'b'}; i=1; j=2; b=a+  local function foo ()+    i, a[i], a, j, a[j], a[i+j] = j, i, i, b, j, i+  end+  foo()+  assert(i == 2 and b[1] == 1 and a == 1 and j == b and b[2] == 2 and+         b[3] == 1)+  local t = {}+  (function (a) t[a], a = 10, 20  end)(1);+  assert(t[1] == 10)+end++-- bug in 5.2 beta+local function foo ()+  local a+  return function ()+    local b+    a, b = 3, 14    -- local and upvalue have same index+    return a, b+  end+end++local a, b = foo()()+assert(a == 3 and b == 14)++print('OK')++return res+

@@ -0,0 +1,79 @@+if _soft then+  return 'a'+end++print "testing large tables"++local debug = require"debug" ++local lim = 2^18 + 1000+local prog = { "local y = {0" }+for i = 1, lim do prog[#prog + 1] = i  end+prog[#prog + 1] = "}\n"+prog[#prog + 1] = "X = y\n"+prog[#prog + 1] = ("assert(X[%d] == %d)"):format(lim - 1, lim - 2)+prog[#prog + 1] = "return 0"+prog = table.concat(prog, ";")++local env = {string = string, assert = assert}+local f = assert(load(prog, nil, nil, env))++f()+assert(env.X[lim] == lim - 1 and env.X[lim + 1] == lim)+for k in pairs(env) do env[k] = nil end++-- yields during accesses larger than K (in RK)+setmetatable(env, {+  __index = function (t, n) coroutine.yield('g'); return _G[n] end,+  __newindex = function (t, n, v) coroutine.yield('s'); _G[n] = v end,+})++X = nil+co = coroutine.wrap(f)+assert(co() == 's')+assert(co() == 'g')+assert(co() == 'g')+assert(co() == 0)++assert(X[lim] == lim - 1 and X[lim + 1] == lim)++-- errors in accesses larger than K (in RK)+getmetatable(env).__index = function () end+getmetatable(env).__newindex = function () end+local e, m = pcall(f)+assert(not e and m:find("global 'X'"))++-- errors in metamethods +getmetatable(env).__newindex = function () error("hi") end+local e, m = xpcall(f, debug.traceback)+assert(not e and m:find("'__newindex'"))++f, X = nil++coroutine.yield'b'++if not _no32 then   -- {++print "testing string length overflow"++local repstrings = 192          -- number of strings to be concatenated+local ssize = math.ceil(2^32 / repstrings) + 1   -- size of each string++assert(repstrings * ssize > 2^32)  -- this should be larger than maximum size_t++local longs = string.rep("\0", ssize)   -- create one long string++-- create function to concatentate 'repstrings' copies of its argument+local rep = assert(load(+  "local a = ...; return " .. string.rep("a", repstrings, "..")))++local a, b = pcall(rep, longs)   -- call that function++-- it should fail without creating string (result would be too large)+assert(not a and string.find(b, "overflow"))++end   -- }++print'OK'++return 'a'

@@ -0,0 +1,115 @@+print("testing bitwise operations")++assert(bit32.band() == bit32.bnot(0))+assert(bit32.btest() == true)+assert(bit32.bor() == 0)+assert(bit32.bxor() == 0)++assert(bit32.band() == bit32.band(0xffffffff))+assert(bit32.band(1,2) == 0)+++-- out-of-range numbers+assert(bit32.band(-1) == 0xffffffff)+assert(bit32.band(2^33 - 1) == 0xffffffff)+assert(bit32.band(-2^33 - 1) == 0xffffffff)+assert(bit32.band(2^33 + 1) == 1)+assert(bit32.band(-2^33 + 1) == 1)+assert(bit32.band(-2^40) == 0)+assert(bit32.band(2^40) == 0)+assert(bit32.band(-2^40 - 2) == 0xfffffffe)+assert(bit32.band(2^40 - 4) == 0xfffffffc)++assert(bit32.lrotate(0, -1) == 0)+assert(bit32.lrotate(0, 7) == 0)+assert(bit32.lrotate(0x12345678, 4) == 0x23456781)+assert(bit32.rrotate(0x12345678, -4) == 0x23456781)+assert(bit32.lrotate(0x12345678, -8) == 0x78123456)+assert(bit32.rrotate(0x12345678, 8) == 0x78123456)+assert(bit32.lrotate(0xaaaaaaaa, 2) == 0xaaaaaaaa)+assert(bit32.lrotate(0xaaaaaaaa, -2) == 0xaaaaaaaa)+for i = -50, 50 do+  assert(bit32.lrotate(0x89abcdef, i) == bit32.lrotate(0x89abcdef, i%32))+end++assert(bit32.lshift(0x12345678, 4) == 0x23456780)+assert(bit32.lshift(0x12345678, 8) == 0x34567800)+assert(bit32.lshift(0x12345678, -4) == 0x01234567)+assert(bit32.lshift(0x12345678, -8) == 0x00123456)+assert(bit32.lshift(0x12345678, 32) == 0)+assert(bit32.lshift(0x12345678, -32) == 0)+assert(bit32.rshift(0x12345678, 4) == 0x01234567)+assert(bit32.rshift(0x12345678, 8) == 0x00123456)+assert(bit32.rshift(0x12345678, 32) == 0)+assert(bit32.rshift(0x12345678, -32) == 0)+assert(bit32.arshift(0x12345678, 0) == 0x12345678)+assert(bit32.arshift(0x12345678, 1) == 0x12345678 / 2)+assert(bit32.arshift(0x12345678, -1) == 0x12345678 * 2)+assert(bit32.arshift(-1, 1) == 0xffffffff)+assert(bit32.arshift(-1, 24) == 0xffffffff)+assert(bit32.arshift(-1, 32) == 0xffffffff)+assert(bit32.arshift(-1, -1) == (-1 * 2) % 2^32)++print("+")+-- some special cases+local c = {0, 1, 2, 3, 10, 0x80000000, 0xaaaaaaaa, 0x55555555,+           0xffffffff, 0x7fffffff}++for _, b in pairs(c) do+  assert(bit32.band(b) == b)+  assert(bit32.band(b, b) == b)+  assert(bit32.btest(b, b) == (b ~= 0))+  assert(bit32.band(b, b, b) == b)+  assert(bit32.btest(b, b, b) == (b ~= 0))+  assert(bit32.band(b, bit32.bnot(b)) == 0)+  assert(bit32.bor(b, bit32.bnot(b)) == bit32.bnot(0))+  assert(bit32.bor(b) == b)+  assert(bit32.bor(b, b) == b)+  assert(bit32.bor(b, b, b) == b)+  assert(bit32.bxor(b) == b)+  assert(bit32.bxor(b, b) == 0)+  assert(bit32.bxor(b, 0) == b)+  assert(bit32.bnot(b) ~= b)+  assert(bit32.bnot(bit32.bnot(b)) == b)+  assert(bit32.bnot(b) == 2^32 - 1 - b)+  assert(bit32.lrotate(b, 32) == b)+  assert(bit32.rrotate(b, 32) == b)+  assert(bit32.lshift(bit32.lshift(b, -4), 4) == bit32.band(b, bit32.bnot(0xf)))+  assert(bit32.rshift(bit32.rshift(b, 4), -4) == bit32.band(b, bit32.bnot(0xf)))+  for i = -40, 40 do+    assert(bit32.lshift(b, i) == math.floor((b * 2^i) % 2^32))+  end+end++assert(not pcall(bit32.band, {}))+assert(not pcall(bit32.bnot, "a"))+assert(not pcall(bit32.lshift, 45))+assert(not pcall(bit32.lshift, 45, print))+assert(not pcall(bit32.rshift, 45, print))++print("+")+++-- testing extract/replace++assert(bit32.extract(0x12345678, 0, 4) == 8)+assert(bit32.extract(0x12345678, 4, 4) == 7)+assert(bit32.extract(0xa0001111, 28, 4) == 0xa)+assert(bit32.extract(0xa0001111, 31, 1) == 1)+assert(bit32.extract(0x50000111, 31, 1) == 0)+assert(bit32.extract(0xf2345679, 0, 32) == 0xf2345679)++assert(not pcall(bit32.extract, 0, -1))+assert(not pcall(bit32.extract, 0, 32))+assert(not pcall(bit32.extract, 0, 0, 33))+assert(not pcall(bit32.extract, 0, 31, 2))++assert(bit32.replace(0x12345678, 5, 28, 4) == 0x52345678)+assert(bit32.replace(0x12345678, 0x87654321, 0, 32) == 0x87654321)+assert(bit32.replace(0, 1, 2) == 2^2)+assert(bit32.replace(0, -1, 4) == 2^4)+assert(bit32.replace(-1, 0, 31) == 2^31 - 1)+assert(bit32.replace(-1, 0, 1, 2) == 2^32 - 7)+++print'OK'

@@ -0,0 +1,310 @@+print("testing functions and calls")++local debug = require "debug"++-- get the opportunity to test 'type' too ;)++assert(type(1<2) == 'boolean')+assert(type(true) == 'boolean' and type(false) == 'boolean')+assert(type(nil) == 'nil' and type(-3) == 'number' and type'x' == 'string' and+       type{} == 'table' and type(type) == 'function')++assert(type(assert) == type(print))+f = nil+function f (x) return a:x (x) end+assert(type(f) == 'function')+++-- testing local-function recursion+fact = false+do+  local res = 1+  local function fact (n)+    if n==0 then return res+    else return n*fact(n-1)+    end+  end+  assert(fact(5) == 120)+end+assert(fact == false)++-- testing declarations+a = {i = 10}+self = 20+function a:x (x) return x+self.i end+function a.y (x) return x+self end++assert(a:x(1)+10 == a.y(1))++a.t = {i=-100}+a["t"].x = function (self, a,b) return self.i+a+b end++assert(a.t:x(2,3) == -95)++do+  local a = {x=0}+  function a:add (x) self.x, a.y = self.x+x, 20; return self end+  assert(a:add(10):add(20):add(30).x == 60 and a.y == 20)+end++local a = {b={c={}}}++function a.b.c.f1 (x) return x+1 end+function a.b.c:f2 (x,y) self[x] = y end+assert(a.b.c.f1(4) == 5)+a.b.c:f2('k', 12); assert(a.b.c.k == 12)++print('+')++t = nil   -- 'declare' t+function f(a,b,c) local d = 'a'; t={a,b,c,d} end++f(      -- this line change must be valid+  1,2)+assert(t[1] == 1 and t[2] == 2 and t[3] == nil and t[4] == 'a')+f(1,2,   -- this one too+      3,4)+assert(t[1] == 1 and t[2] == 2 and t[3] == 3 and t[4] == 'a')++function fat(x)+  if x <= 1 then return 1+  else return x*load("return fat(" .. x-1 .. ")")()+  end+end++assert(load "load 'assert(fat(6)==720)' () ")()+a = load('return fat(5), 3')+a,b = a()+assert(a == 120 and b == 3)+print('+')++function err_on_n (n)+  if n==0 then error(); exit(1);+  else err_on_n (n-1); exit(1);+  end+end++do+  function dummy (n)+    if n > 0 then+      assert(not pcall(err_on_n, n))+      dummy(n-1)+    end+  end+end++dummy(10)++function deep (n)+  if n>0 then deep(n-1) end+end+deep(10)+deep(200)++-- testing tail call+function deep (n) if n>0 then return deep(n-1) else return 101 end end+assert(deep(30000) == 101)+a = {}+function a:deep (n) if n>0 then return self:deep(n-1) else return 101 end end+assert(a:deep(30000) == 101)++print('+')+++a = nil+(function (x) a=x end)(23)+assert(a == 23 and (function (x) return x*2 end)(20) == 40)+++-- testing closures++-- fixed-point operator+Z = function (le)+      local function a (f)+        return le(function (x) return f(f)(x) end)+      end+      return a(a)+    end+++-- non-recursive factorial++F = function (f)+      return function (n)+               if n == 0 then return 1+               else return n*f(n-1) end+             end+    end++fat = Z(F)++assert(fat(0) == 1 and fat(4) == 24 and Z(F)(5)==5*Z(F)(4))++local function g (z)+  local function f (a,b,c,d)+    return function (x,y) return a+b+c+d+a+x+y+z end+  end+  return f(z,z+1,z+2,z+3)+end++f = g(10)+assert(f(9, 16) == 10+11+12+13+10+9+16+10)++Z, F, f = nil+print('+')++-- testing multiple returns++function unlpack (t, i)+  i = i or 1+  if (i <= #t) then+    return t[i], unlpack(t, i+1)+  end+end++function equaltab (t1, t2)+  assert(#t1 == #t2)+  for i = 1, #t1 do+    assert(t1[i] == t2[i])+  end+end++local pack = function (...) return (table.pack(...)) end++function f() return 1,2,30,4 end+function ret2 (a,b) return a,b end++local a,b,c,d = unlpack{1,2,3}+assert(a==1 and b==2 and c==3 and d==nil)+a = {1,2,3,4,false,10,'alo',false,assert}+equaltab(pack(unlpack(a)), a)+equaltab(pack(unlpack(a), -1), {1,-1})+a,b,c,d = ret2(f()), ret2(f())+assert(a==1 and b==1 and c==2 and d==nil)+a,b,c,d = unlpack(pack(ret2(f()), ret2(f())))+assert(a==1 and b==1 and c==2 and d==nil)+a,b,c,d = unlpack(pack(ret2(f()), (ret2(f()))))+assert(a==1 and b==1 and c==nil and d==nil)++a = ret2{ unlpack{1,2,3}, unlpack{3,2,1}, unlpack{"a", "b"}}+assert(a[1] == 1 and a[2] == 3 and a[3] == "a" and a[4] == "b")+++-- testing calls with 'incorrect' arguments+rawget({}, "x", 1)+rawset({}, "x", 1, 2)+assert(math.sin(1,2) == math.sin(1))+table.sort({10,9,8,4,19,23,0,0}, function (a,b) return a<b end, "extra arg")+++-- test for generic load+local x = "-- a comment\0\0\0\n  x = 10 + \n23; \+     local a = function () x = 'hi' end; \+     return '\0'"+function read1 (x)+  local i = 0+  return function ()+    collectgarbage()+    i=i+1+    return string.sub(x, i, i)+  end+end++function cannotload (msg, a,b)+  assert(not a and string.find(b, msg))+end++a = assert(load(read1(x), "modname", "t", _G))+assert(a() == "\0" and _G.x == 33)+assert(debug.getinfo(a).source == "modname")+-- cannot read text in binary mode+cannotload("attempt to load a text chunk", load(read1(x), "modname", "b", {}))+cannotload("attempt to load a text chunk", load(x, "modname", "b"))++a = assert(load(function () return nil end))+a()  -- empty chunk++assert(not load(function () return true end))+++-- small bug+local t = {nil, "return ", "3"}+f, msg = load(function () return table.remove(t, 1) end)+assert(f() == nil)   -- should read the empty chunk++-- another small bug (in 5.2.1)+f = load(string.dump(function () return 1 end), nil, "b", {})+assert(type(f) == "function" and f() == 1)+++x = string.dump(load("x = 1; return x"))+a = assert(load(read1(x), nil, "b"))+assert(a() == 1 and _G.x == 1)+cannotload("attempt to load a binary chunk", load(read1(x), nil, "t"))+cannotload("attempt to load a binary chunk", load(x, nil, "t"))++assert(not pcall(string.dump, print))  -- no dump of C functions++cannotload("unexpected symbol", load(read1("*a = 123")))+cannotload("unexpected symbol", load("*a = 123"))+cannotload("hhi", load(function () error("hhi") end))++-- any value is valid for _ENV+assert(load("return _ENV", nil, nil, 123)() == 123)+++-- load when _ENV is not first upvalue+local x; XX = 123+local function h ()+  local y=x   -- use 'x', so that it becomes 1st upvalue+  return XX   -- global name+end+local d = string.dump(h)+x = load(d, "", "b")+assert(debug.getupvalue(x, 2) == '_ENV')+debug.setupvalue(x, 2, _G)+assert(x() == 123)++assert(assert(load("return XX + ...", nil, nil, {XX = 13}))(4) == 17)+++-- test generic load with nested functions+x = [[+  return function (x)+    return function (y)+     return function (z)+       return x+y+z+     end+   end+  end+]]++a = assert(load(read1(x)))+assert(a()(2)(3)(10) == 15)+++-- test for dump/undump with upvalues+local a, b = 20, 30+x = load(string.dump(function (x)+  if x == "set" then a = 10+b; b = b+1 else+  return a+  end+end))+assert(x() == nil)+assert(debug.setupvalue(x, 1, "hi") == "a")+assert(x() == "hi")+assert(debug.setupvalue(x, 2, 13) == "b")+assert(not debug.setupvalue(x, 3, 10))   -- only 2 upvalues+x("set")+assert(x() == 23)+x("set")+assert(x() == 24)+++-- test for bug in parameter adjustment+assert((function () return nil end)(4) == nil)+assert((function () local a; return a end)(4) == nil)+assert((function (a) return a end)() == nil)++print('OK')+return deep

@@ -0,0 +1,77 @@++assert(rawget(_G, "stat") == nil)  -- module not loaded before++if T == nil then+  stat = function () print"`querytab' not active" end+  return+end+++function checktable (t)+  local asize, hsize, ff = T.querytab(t)+  local l = {}+  for i=0,hsize-1 do+    local key,val,next = T.querytab(t, i + asize)+    if key == nil then+      assert(l[i] == nil and val==nil and next==nil)+    elseif key == "<undef>" then+      assert(val==nil)+    else+      assert(t[key] == val)+      local mp = T.hash(key, t)+      if l[i] then+        assert(l[i] == mp)+      elseif mp ~= i then+        l[i] = mp+      else  -- list head+        l[mp] = {mp}   -- first element+        while next do+          assert(ff <= next and next < hsize)+          if l[next] then assert(l[next] == mp) else l[next] = mp end+          table.insert(l[mp], next)+          key,val,next = T.querytab(t, next)+          assert(key)+        end+      end+    end+  end+  l.asize = asize; l.hsize = hsize; l.ff = ff+  return l+end++function mostra (t)+  local asize, hsize, ff = T.querytab(t)+  print(asize, hsize, ff)+  print'------'+  for i=0,asize-1 do+    local _, v = T.querytab(t, i)+    print(string.format("[%d] -", i), v)+  end+  print'------'+  for i=0,hsize-1 do+    print(i, T.querytab(t, i+asize))+  end+  print'-------------'+end++function stat (t)+  t = checktable(t)+  local nelem, nlist = 0, 0+  local maxlist = {}+  for i=0,t.hsize-1 do+    if type(t[i]) == 'table' then+      local n = table.getn(t[i])+      nlist = nlist+1+      nelem = nelem + n+      if not maxlist[n] then maxlist[n] = 0 end+      maxlist[n] = maxlist[n]+1+    end+  end+  print(string.format("hsize=%d  elements=%d  load=%.2f  med.len=%.2f (asize=%d)",+          t.hsize, nelem, nelem/t.hsize, nelem/nlist, t.asize))+  for i=1,table.getn(maxlist) do+    local n = maxlist[i] or 0+    print(string.format("%5d %10d %.2f%%", i, n, n*100/nlist))+  end+end+

@@ -0,0 +1,244 @@+print "testing closures"++local A,B = 0,{g=10}+function f(x)+  local a = {}+  for i=1,1000 do+    local y = 0+    do+      a[i] = function () B.g = B.g+1; y = y+x; return y+A end+    end+  end+  local dummy = function () return a[A] end+  collectgarbage()+  A = 1; assert(dummy() == a[1]); A = 0;+  assert(a[1]() == x)+  assert(a[3]() == x)+  collectgarbage()+  assert(B.g == 12)+  return a+end++local a = f(10)+-- force a GC in this level+local x = {[1] = {}}   -- to detect a GC+setmetatable(x, {__mode = 'kv'})+while x[1] do   -- repeat until GC+  local a = A..A..A..A  -- create garbage+  A = A+1+end+assert(a[1]() == 20+A)+assert(a[1]() == 30+A)+assert(a[2]() == 10+A)+collectgarbage()+assert(a[2]() == 20+A)+assert(a[2]() == 30+A)+assert(a[3]() == 20+A)+assert(a[8]() == 10+A)+assert(getmetatable(x).__mode == 'kv')+assert(B.g == 19)+++-- testing equality+a = {}+for i = 1, 5 do  a[i] = function (x) return x + a + _ENV end  end+assert(a[3] == a[4] and a[4] == a[5])++for i = 1, 5 do  a[i] = function (x) return i + a + _ENV end  end+assert(a[3] ~= a[4] and a[4] ~= a[5])++local function f()+  return function (x)  return math.sin(_ENV[x])  end+end+assert(f() == f())+++-- testing closures with 'for' control variable+a = {}+for i=1,10 do+  a[i] = {set = function(x) i=x end, get = function () return i end}+  if i == 3 then break end+end+assert(a[4] == nil)+a[1].set(10)+assert(a[2].get() == 2)+a[2].set('a')+assert(a[3].get() == 3)+assert(a[2].get() == 'a')++a = {}+local t = {"a", "b"}+for i = 1, #t do+  local k = t[i]+  a[i] = {set = function(x, y) i=x; k=y end,+          get = function () return i, k end}+  if i == 2 then break end+end+a[1].set(10, 20)+local r,s = a[2].get()+assert(r == 2 and s == 'b')+r,s = a[1].get()+assert(r == 10 and s == 20)+a[2].set('a', 'b')+r,s = a[2].get()+assert(r == "a" and s == "b")+++-- testing closures with 'for' control variable x break+for i=1,3 do+  f = function () return i end+  break+end+assert(f() == 1)++for k = 1, #t do+  local v = t[k]+  f = function () return k, v end+  break+end+assert(({f()})[1] == 1)+assert(({f()})[2] == "a")+++-- testing closure x break x return x errors++local b+function f(x)+  local first = 1+  while 1 do+    if x == 3 and not first then return end+    local a = 'xuxu'+    b = function (op, y)+          if op == 'set' then+            a = x+y+          else+            return a+          end+        end+    if x == 1 then do break end+    elseif x == 2 then return+    else if x ~= 3 then error() end+    end+    first = nil+  end+end++for i=1,3 do+  f(i)+  assert(b('get') == 'xuxu')+  b('set', 10); assert(b('get') == 10+i)+  b = nil+end++pcall(f, 4);+assert(b('get') == 'xuxu')+b('set', 10); assert(b('get') == 14)+++local w+-- testing multi-level closure+function f(x)+  return function (y)+    return function (z) return w+x+y+z end+  end+end++y = f(10)+w = 1.345+assert(y(20)(30) == 60+w)++-- testing closures x repeat-until++local a = {}+local i = 1+repeat+  local x = i+  a[i] = function () i = x+1; return x end+until i > 10 or a[i]() ~= x+assert(i == 11 and a[1]() == 1 and a[3]() == 3 and i == 4)+++-- testing closures created in 'then' and 'else' parts of 'if's+a = {}+for i = 1, 10 do+  if i % 3 == 0 then+    local y = 0+    a[i] = function (x) local t = y; y = x; return t end+  elseif i % 3 == 1 then+    goto L1+    error'not here'+  ::L1::+    local y = 1+    a[i] = function (x) local t = y; y = x; return t end+  elseif i % 3 == 2 then+    local t+    goto l4+    ::l4a:: a[i] = t; goto l4b+    error("should never be here!")+    ::l4::+    local y = 2+    t = function (x) local t = y; y = x; return t end+    goto l4a+    error("should never be here!")+    ::l4b::+  end+end++for i = 1, 10 do+  assert(a[i](i * 10) == i % 3 and a[i]() == i * 10)+end++print'+'+++-- test for correctly closing upvalues in tail calls of vararg functions+local function t ()+  local function c(a,b) assert(a=="test" and b=="OK") end+  local function v(f, ...) c("test", f() ~= 1 and "FAILED" or "OK") end+  local x = 1+  return v(function() return x end)+end+t()+++-- test for debug manipulation of upvalues+local debug = require'debug'++do+  local a , b, c = 3, 5, 7+  foo1 = function () return a+b end;+  foo2 = function () return b+a end;+  do+    local a = 10+    foo3 = function () return a+b end;+  end+end++assert(debug.upvalueid(foo1, 1))+assert(debug.upvalueid(foo1, 2))+assert(not pcall(debug.upvalueid, foo1, 3))+assert(debug.upvalueid(foo1, 1) == debug.upvalueid(foo2, 2))+assert(debug.upvalueid(foo1, 2) == debug.upvalueid(foo2, 1))+assert(debug.upvalueid(foo3, 1))+assert(debug.upvalueid(foo1, 1) ~= debug.upvalueid(foo3, 1))+assert(debug.upvalueid(foo1, 2) == debug.upvalueid(foo3, 2))++assert(debug.upvalueid(string.gmatch("x", "x"), 1) ~= nil)++assert(foo1() == 3 + 5 and foo2() == 5 + 3)+debug.upvaluejoin(foo1, 2, foo2, 2)+assert(foo1() == 3 + 3 and foo2() == 5 + 3)+assert(foo3() == 10 + 5)+debug.upvaluejoin(foo3, 2, foo2, 1)+assert(foo3() == 10 + 5)+debug.upvaluejoin(foo3, 2, foo2, 2)+assert(foo3() == 10 + 3)++assert(not pcall(debug.upvaluejoin, foo1, 3, foo2, 1))+assert(not pcall(debug.upvaluejoin, foo1, 1, foo2, 3))+assert(not pcall(debug.upvaluejoin, foo1, 0, foo2, 1))+assert(not pcall(debug.upvaluejoin, print, 1, foo2, 1))+assert(not pcall(debug.upvaluejoin, {}, 1, foo2, 1))+assert(not pcall(debug.upvaluejoin, foo1, 1, print, 1))++print'OK'

@@ -0,0 +1,182 @@+if T==nil then+  (Message or print)('\a\n >>> testC not active: skipping opcode tests <<<\n\a')+  return+end+print "testing code generation and optimizations"+++-- this code gave an error for the code checker+do+  local function f (a)+  for k,v,w in a do end+  end+end+++function check (f, ...)+  local arg = {...}+  local c = T.listcode(f)+  for i=1, #arg do+    -- print(arg[i], c[i])+    assert(string.find(c[i], '- '..arg[i]..' *%d'))+  end+  assert(c[#arg+2] == nil)+end+++function checkequal (a, b)+  a = T.listcode(a)+  b = T.listcode(b)+  for i = 1, #a do+    a[i] = string.gsub(a[i], '%b()', '')   -- remove line number+    b[i] = string.gsub(b[i], '%b()', '')   -- remove line number+    assert(a[i] == b[i])+  end+end+++-- some basic instructions+check(function ()+  (function () end){f()}+end, 'CLOSURE', 'NEWTABLE', 'GETTABUP', 'CALL', 'SETLIST', 'CALL', 'RETURN')+++-- sequence of LOADNILs+check(function ()+  local a,b,c+  local d; local e;+  local f,g,h;+  d = nil; d=nil; b=nil; a=nil; c=nil;+end, 'LOADNIL', 'RETURN')++check(function ()+  local a,b,c,d = 1,1,1,1+  d=nil;c=nil;b=nil;a=nil+end, 'LOADK', 'LOADK', 'LOADK', 'LOADK', 'LOADNIL', 'RETURN')++do+  local a,b,c,d = 1,1,1,1+  d=nil;c=nil;b=nil;a=nil+  assert(a == nil and b == nil and c == nil and d == nil)+end+++-- single return+check (function (a,b,c) return a end, 'RETURN')+++-- infinite loops+check(function () while true do local a = -1 end end,+'LOADK', 'JMP', 'RETURN')++check(function () while 1 do local a = -1 end end,+'LOADK', 'JMP', 'RETURN')++check(function () repeat local x = 1 until true end,+'LOADK', 'RETURN')+++-- concat optimization+check(function (a,b,c,d) return a..b..c..d end,+  'MOVE', 'MOVE', 'MOVE', 'MOVE', 'CONCAT', 'RETURN')++-- not+check(function () return not not nil end, 'LOADBOOL', 'RETURN')+check(function () return not not false end, 'LOADBOOL', 'RETURN')+check(function () return not not true end, 'LOADBOOL', 'RETURN')+check(function () return not not 1 end, 'LOADBOOL', 'RETURN')++-- direct access to locals+check(function ()+  local a,b,c,d+  a = b*2+  c[4], a[b] = -((a + d/-20.5 - a[b]) ^ a.x), b+end,+  'LOADNIL',+  'MUL',+  'DIV', 'ADD', 'GETTABLE', 'SUB', 'GETTABLE', 'POW',+    'UNM', 'SETTABLE', 'SETTABLE', 'RETURN')+++-- direct access to constants+check(function ()+  local a,b+  a.x = 0+  a.x = b+  a[b] = 'y'+  a = 1 - a+  b = 1/a+  b = 5+4+  a[true] = false+end,+  'LOADNIL',+  'SETTABLE', 'SETTABLE', 'SETTABLE', 'SUB', 'DIV', 'LOADK',+  'SETTABLE', 'RETURN')++-- constant folding+local function f () return -((2^8 + -(-1)) % 8)/2 * 4 - 3 end++check(f, 'LOADK', 'RETURN')+assert(f() == -5)+++-- bug in constant folding for 5.1+check(function () return -nil end,+  'LOADNIL', 'UNM', 'RETURN')+++check(function ()+  local a,b,c+  b[c], a = c, b+  b[a], a = c, b+  a, b = c, a+  a = a+end, +  'LOADNIL',+  'MOVE', 'MOVE', 'SETTABLE',+  'MOVE', 'MOVE', 'MOVE', 'SETTABLE',+  'MOVE', 'MOVE', 'MOVE',+  -- no code for a = a+  'RETURN')+++-- x == nil , x ~= nil+checkequal(function () if (a==nil) then a=1 end; if a~=nil then a=1 end end,+           function () if (a==9) then a=1 end; if a~=9 then a=1 end end)++check(function () if a==nil then a=1 end end,+'GETTABUP', 'EQ', 'JMP', 'SETTABUP', 'RETURN')++-- de morgan+checkequal(function () local a; if not (a or b) then b=a end end,+           function () local a; if (not a and not b) then b=a end end)++checkequal(function (l) local a; return 0 <= a and a <= l end,+           function (l) local a; return not (not(a >= 0) or not(a <= l)) end)+++-- if-goto optimizations+check(function (a)+        if a == 1 then goto l1+        elseif a == 2 then goto l2+        elseif a == 3 then goto l2+        else if a == 4 then goto l3+             else goto l3+             end+        end+        ::l1:: ::l2:: ::l3:: ::l4:: +end, 'EQ', 'JMP', 'EQ', 'JMP', 'EQ', 'JMP', 'EQ', 'JMP', 'JMP', 'RETURN')++checkequal(+function (a) while a < 10 do a = a + 1 end end,+function (a) ::L2:: if not(a < 10) then goto L1 end; a = a + 1;+                goto L2; ::L1:: end+)++checkequal(+function (a) while a < 10 do a = a + 1 end end,+function (a) while true do if not(a < 10) then break end; a = a + 1; end end+)++print 'OK'+

@@ -0,0 +1,310 @@+;;print "testing syntax";;++local debug = require "debug"++-- testing semicollons+do ;;; end+; do ; a = 3; assert(a == 3) end;+;+++-- testing priorities++assert(2^3^2 == 2^(3^2));+assert(2^3*4 == (2^3)*4);+assert(2^-2 == 1/4 and -2^- -2 == - - -4);+assert(not nil and 2 and not(2>3 or 3<2));+assert(-3-1-5 == 0+0-9);+assert(-2^2 == -4 and (-2)^2 == 4 and 2*2-3-1 == 0);+assert(2*1+3/3 == 3 and 1+2 .. 3*1 == "33");+assert(not(2+1 > 3*1) and "a".."b" > "a");++assert(not ((true or false) and nil))+assert(      true or false  and nil)++-- old bug+assert((((1 or false) and true) or false) == true)+assert((((nil and true) or false) and true) == false)++local a,b = 1,nil;+assert(-(1 or 2) == -1 and (1 and 2)+(-1.25 or -4) == 0.75);+x = ((b or a)+1 == 2 and (10 or a)+1 == 11); assert(x);+x = (((2<3) or 1) == true and (2<3 and 4) == 4); assert(x);++x,y=1,2;+assert((x>y) and x or y == 2);+x,y=2,1;+assert((x>y) and x or y == 2);++assert(1234567890 == tonumber('1234567890') and 1234567890+1 == 1234567891)+++-- silly loops+repeat until 1; repeat until true;+while false do end; while nil do end;++do  -- test old bug (first name could not be an `upvalue')+ local a; function f(x) x={a=1}; x={x=1}; x={G=1} end+end++function f (i)+  if type(i) ~= 'number' then return i,'jojo'; end;+  if i > 0 then return i, f(i-1); end;+end++x = {f(3), f(5), f(10);};+assert(x[1] == 3 and x[2] == 5 and x[3] == 10 and x[4] == 9 and x[12] == 1);+assert(x[nil] == nil)+x = {f'alo', f'xixi', nil};+assert(x[1] == 'alo' and x[2] == 'xixi' and x[3] == nil);+x = {f'alo'..'xixi'};+assert(x[1] == 'aloxixi')+x = {f{}}+assert(x[2] == 'jojo' and type(x[1]) == 'table')+++local f = function (i)+  if i < 10 then return 'a';+  elseif i < 20 then return 'b';+  elseif i < 30 then return 'c';+  end;+end++assert(f(3) == 'a' and f(12) == 'b' and f(26) == 'c' and f(100) == nil)++for i=1,1000 do break; end;+n=100;+i=3;+t = {};+a=nil+while not a do+  a=0; for i=1,n do for i=i,1,-1 do a=a+1; t[i]=1; end; end;+end+assert(a == n*(n+1)/2 and i==3);+assert(t[1] and t[n] and not t[0] and not t[n+1])++function f(b)+  local x = 1;+  repeat+    local a;+    if b==1 then local b=1; x=10; break+    elseif b==2 then x=20; break;+    elseif b==3 then x=30;+    else local a,b,c,d=math.sin(1); x=x+1;+    end+  until x>=12;+  return x;+end;++assert(f(1) == 10 and f(2) == 20 and f(3) == 30 and f(4)==12)+++local f = function (i)+  if i < 10 then return 'a'+  elseif i < 20 then return 'b'+  elseif i < 30 then return 'c'+  else return 8+  end+end++assert(f(3) == 'a' and f(12) == 'b' and f(26) == 'c' and f(100) == 8)++local a, b = nil, 23+x = {f(100)*2+3 or a, a or b+2}+assert(x[1] == 19 and x[2] == 25)+x = {f=2+3 or a, a = b+2}+assert(x.f == 5 and x.a == 25)++a={y=1}+x = {a.y}+assert(x[1] == 1)++function f(i)+  while 1 do+    if i>0 then i=i-1;+    else return; end;+  end;+end;++function g(i)+  while 1 do+    if i>0 then i=i-1+    else return end+  end+end++f(10); g(10);++do+  function f () return 1,2,3; end+  local a, b, c = f();+  assert(a==1 and b==2 and c==3)+  a, b, c = (f());+  assert(a==1 and b==nil and c==nil)+end++local a,b = 3 and f();+assert(a==1 and b==nil)++function g() f(); return; end;+assert(g() == nil)+function g() return nil or f() end+a,b = g()+assert(a==1 and b==nil)++print'+';+++f = [[+return function ( a , b , c , d , e )+  local x = a >= b or c or ( d and e ) or nil+  return x+end , { a = 1 , b = 2 >= 1 , } or { 1 };+]]+f = string.gsub(f, "%s+", "\n");   -- force a SETLINE between opcodes+f,a = load(f)();+assert(a.a == 1 and a.b)++function g (a,b,c,d,e)+  if not (a>=b or c or d and e or nil) then return 0; else return 1; end;+end++function h (a,b,c,d,e)+  while (a>=b or c or (d and e) or nil) do return 1; end;+  return 0;+end;++assert(f(2,1) == true and g(2,1) == 1 and h(2,1) == 1)+assert(f(1,2,'a') == 'a' and g(1,2,'a') == 1 and h(1,2,'a') == 1)+assert(f(1,2,'a')+~=          -- force SETLINE before nil+nil, "")+assert(f(1,2,'a') == 'a' and g(1,2,'a') == 1 and h(1,2,'a') == 1)+assert(f(1,2,nil,1,'x') == 'x' and g(1,2,nil,1,'x') == 1 and+                                   h(1,2,nil,1,'x') == 1)+assert(f(1,2,nil,nil,'x') == nil and g(1,2,nil,nil,'x') == 0 and+                                     h(1,2,nil,nil,'x') == 0)+assert(f(1,2,nil,1,nil) == nil and g(1,2,nil,1,nil) == 0 and+                                   h(1,2,nil,1,nil) == 0)++assert(1 and 2<3 == true and 2<3 and 'a'<'b' == true)+x = 2<3 and not 3; assert(x==false)+x = 2<1 or (2>1 and 'a'); assert(x=='a')+++do+  local a; if nil then a=1; else a=2; end;    -- this nil comes as PUSHNIL 2+  assert(a==2)+end++function F(a)+  assert(debug.getinfo(1, "n").name == 'F')+  return a,2,3+end++a,b = F(1)~=nil; assert(a == true and b == nil);+a,b = F(nil)==nil; assert(a == true and b == nil)++----------------------------------------------------------------+-- creates all combinations of +-- [not] ([not] arg op [not] (arg op [not] arg ))+-- and tests each one++function ID(x) return x end++function f(t, i)+  local b = t.n+  local res = math.fmod(math.floor(i/c), b)+1+  c = c*b+  return t[res]+end++local arg = {" ( 1 < 2 ) ", " ( 1 >= 2 ) ", " F ( ) ", "  nil "; n=4}++local op = {" and ", " or ", " == ", " ~= "; n=4}++local neg = {" ", " not "; n=2}++local i = 0+repeat+  c = 1+  local s = f(neg, i)..'ID('..f(neg, i)..f(arg, i)..f(op, i)..+            f(neg, i)..'ID('..f(arg, i)..f(op, i)..f(neg, i)..f(arg, i)..'))'+  local s1 = string.gsub(s, 'ID', '')+  K,X,NX,WX1,WX2 = nil+  s = string.format([[+      local a = %s+      local b = not %s+      K = b+      local xxx; +      if %s then X = a  else X = b end+      if %s then NX = b  else NX = a end+      while %s do WX1 = a; break end+      while %s do WX2 = a; break end+      repeat if (%s) then break end; assert(b)  until not(%s)+  ]], s1, s, s1, s, s1, s, s1, s, s)+  assert(load(s))()+  assert(X and not NX and not WX1 == K and not WX2 == K)+  if math.fmod(i,4000) == 0 then print('+') end+  i = i+1+until i==c++print '+'++------------------------------------------------------------------+print 'testing short-circuit optimizations'++_ENV.GLOB1 = 1+_ENV.GLOB2 = 2++local basiccases = {+  {"nil", nil},+  {"false", false},+  {"true", true},+  {"10", 10},+  {"(_ENV.GLOB1 < _ENV.GLOB2)", true},+  {"(_ENV.GLOB2 < _ENV.GLOB1)", false},+}+++local binops = {+  {" and ", function (a,b) if not a then return a else return b end end},+  {" or ", function (a,b) if a then return a else return b end end},+}++local mem = {basiccases}    -- for memoization++local function allcases (n)+  if mem[n] then return mem[n] end+  local res = {}+  -- include all smaller cases+  for _, v in ipairs(allcases(n - 1)) do+    res[#res + 1] = v+  end+  for i = 1, n - 1 do+    for _, v1 in ipairs(allcases(i)) do+      for _, v2 in ipairs(allcases(n - i)) do+        for _, op in ipairs(binops) do+            res[#res + 1] = {+              "(" .. v1[1] .. op[1] .. v2[1] .. ")",+              op[2](v1[2], v2[2])+            }+        end+      end+    end+    print('+')+  end+  mem[n] = res   -- memoize+  return res+end++-- do not do too many combinations for soft tests+local level = _soft and 3 or 4++for _, v in pairs(allcases(level)) do+  local res = load("return " .. v[1])()+  assert(res == v[2])+end+------------------------------------------------------------------++print'OK'

@@ -0,0 +1,728 @@+print "testing coroutines"++local debug = require'debug'++local f++local main, ismain = coroutine.running()+assert(type(main) == "thread" and ismain)+assert(not coroutine.resume(main))+assert(not pcall(coroutine.yield))++++-- tests for multiple yield/resume arguments++local function eqtab (t1, t2)+  assert(#t1 == #t2)+  for i = 1, #t1 do+    local v = t1[i]+    assert(t2[i] == v)+  end+end++_G.x = nil   -- declare x+function foo (a, ...)+  local x, y = coroutine.running()+  assert(x == f and y == false)+  assert(coroutine.status(f) == "running")+  local arg = {...}+  for i=1,#arg do+    _G.x = {coroutine.yield(table.unpack(arg[i]))}+  end+  return table.unpack(a)+end++f = coroutine.create(foo)+assert(type(f) == "thread" and coroutine.status(f) == "suspended")+assert(string.find(tostring(f), "thread"))+local s,a,b,c,d+s,a,b,c,d = coroutine.resume(f, {1,2,3}, {}, {1}, {'a', 'b', 'c'})+assert(s and a == nil and coroutine.status(f) == "suspended")+s,a,b,c,d = coroutine.resume(f)+eqtab(_G.x, {})+assert(s and a == 1 and b == nil)+s,a,b,c,d = coroutine.resume(f, 1, 2, 3)+eqtab(_G.x, {1, 2, 3})+assert(s and a == 'a' and b == 'b' and c == 'c' and d == nil)+s,a,b,c,d = coroutine.resume(f, "xuxu")+eqtab(_G.x, {"xuxu"})+assert(s and a == 1 and b == 2 and c == 3 and d == nil)+assert(coroutine.status(f) == "dead")+s, a = coroutine.resume(f, "xuxu")+assert(not s and string.find(a, "dead") and coroutine.status(f) == "dead")+++-- yields in tail calls+local function foo (i) return coroutine.yield(i) end+f = coroutine.wrap(function ()+  for i=1,10 do+    assert(foo(i) == _G.x)+  end+  return 'a'+end)+for i=1,10 do _G.x = i; assert(f(i) == i) end+_G.x = 'xuxu'; assert(f('xuxu') == 'a')++-- recursive+function pf (n, i)+  coroutine.yield(n)+  pf(n*i, i+1)+end++f = coroutine.wrap(pf)+local s=1+for i=1,10 do+  assert(f(1, 1) == s)+  s = s*i+end++-- sieve+function gen (n)+  return coroutine.wrap(function ()+    for i=2,n do coroutine.yield(i) end+  end)+end+++function filter (p, g)+  return coroutine.wrap(function ()+    while 1 do+      local n = g()+      if n == nil then return end+      if math.fmod(n, p) ~= 0 then coroutine.yield(n) end+    end+  end)+end++local x = gen(100)+local a = {}+while 1 do+  local n = x()+  if n == nil then break end+  table.insert(a, n)+  x = filter(n, x)+end++assert(#a == 25 and a[#a] == 97)+++-- yielding across C boundaries++co = coroutine.wrap(function()+       assert(not pcall(table.sort,{1,2,3}, coroutine.yield))+       coroutine.yield(20)+       return 30+     end)++assert(co() == 20)+assert(co() == 30)+++local f = function (s, i) return coroutine.yield(i) end++local f1 = coroutine.wrap(function ()+             return xpcall(pcall, function (...) return ... end,+               function ()+                 local s = 0+                 for i in f, nil, 1 do pcall(function () s = s + i end) end+                 error({s})+               end)+           end)++f1()+for i = 1, 10 do assert(f1(i) == i) end+local r1, r2, v = f1(nil)+assert(r1 and not r2 and v[1] ==  (10 + 1)*10/2)+++function f (a, b) a = coroutine.yield(a);  error{a + b} end+function g(x) return x[1]*2 end++co = coroutine.wrap(function ()+       coroutine.yield(xpcall(f, g, 10, 20))+     end)++assert(co() == 10)+r, msg = co(100)+assert(not r and msg == 240)+++-- errors in coroutines+function foo ()+  assert(debug.getinfo(1).currentline == debug.getinfo(foo).linedefined + 1)+  assert(debug.getinfo(2).currentline == debug.getinfo(goo).linedefined)+  coroutine.yield(3)+  error(foo)+end++function goo() foo() end+x = coroutine.wrap(goo)+assert(x() == 3)+local a,b = pcall(x)+assert(not a and b == foo)++x = coroutine.create(goo)+a,b = coroutine.resume(x)+assert(a and b == 3)+a,b = coroutine.resume(x)+assert(not a and b == foo and coroutine.status(x) == "dead")+a,b = coroutine.resume(x)+assert(not a and string.find(b, "dead") and coroutine.status(x) == "dead")+++-- co-routines x for loop+function all (a, n, k)+  if k == 0 then coroutine.yield(a)+  else+    for i=1,n do+      a[k] = i+      all(a, n, k-1)+    end+  end+end++local a = 0+for t in coroutine.wrap(function () all({}, 5, 4) end) do+  a = a+1+end+assert(a == 5^4)+++-- access to locals of collected corroutines+local C = {}; setmetatable(C, {__mode = "kv"})+local x = coroutine.wrap (function ()+            local a = 10+            local function f () a = a+10; return a end+            while true do+              a = a+1+              coroutine.yield(f)+            end+          end)++C[1] = x;++local f = x()+assert(f() == 21 and x()() == 32 and x() == f)+x = nil+collectgarbage()+assert(C[1] == nil)+assert(f() == 43 and f() == 53)+++-- old bug: attempt to resume itself++function co_func (current_co)+  assert(coroutine.running() == current_co)+  assert(coroutine.resume(current_co) == false)+  assert(coroutine.resume(current_co) == false)+  return 10+end++local co = coroutine.create(co_func)+local a,b = coroutine.resume(co, co)+assert(a == true and b == 10)+assert(coroutine.resume(co, co) == false)+assert(coroutine.resume(co, co) == false)+++-- attempt to resume 'normal' coroutine+co1 = coroutine.create(function () return co2() end)+co2 = coroutine.wrap(function ()+        assert(coroutine.status(co1) == 'normal')+        assert(not coroutine.resume(co1))+        coroutine.yield(3)+      end)++a,b = coroutine.resume(co1)+assert(a and b == 3)+assert(coroutine.status(co1) == 'dead')++-- infinite recursion of coroutines+a = function(a) coroutine.wrap(a)(a) end+assert(not pcall(a, a))+++-- access to locals of erroneous coroutines+local x = coroutine.create (function ()+            local a = 10+            _G.f = function () a=a+1; return a end+            error('x')+          end)++assert(not coroutine.resume(x))+-- overwrite previous position of local `a'+assert(not coroutine.resume(x, 1, 1, 1, 1, 1, 1, 1))+assert(_G.f() == 11)+assert(_G.f() == 12)+++if not T then+  (Message or print)('\a\n >>> testC not active: skipping yield/hook tests <<<\n\a')+else+  print "testing yields inside hooks"++  local turn+  +  function fact (t, x)+    assert(turn == t)+    if x == 0 then return 1+    else return x*fact(t, x-1)+    end+  end++  local A,B,a,b = 0,0,0,0++  local x = coroutine.create(function ()+    T.sethook("yield 0", "", 2)+    A = fact("A", 10)+  end)++  local y = coroutine.create(function ()+    T.sethook("yield 0", "", 3)+    B = fact("B", 11)+  end)++  while A==0 or B==0 do+    if A==0 then turn = "A"; assert(T.resume(x)) end+    if B==0 then turn = "B"; assert(T.resume(y)) end+  end++  assert(B/A == 11)++  local line = debug.getinfo(1, "l").currentline + 2    -- get line number+  local function foo ()+    local x = 10    --<< this line is 'line'+    x = x + 10+    _G.XX = x+  end++  -- testing yields in line hook+  local co = coroutine.wrap(function ()+    T.sethook("setglobal X; yield 0", "l", 0); foo(); return 10 end)++  _G.XX = nil;+  _G.X = nil; co(); assert(_G.X == line)+  _G.X = nil; co(); assert(_G.X == line + 1)+  _G.X = nil; co(); assert(_G.X == line + 2 and _G.XX == nil)+  _G.X = nil; co(); assert(_G.X == line + 3 and _G.XX == 20)+  assert(co() == 10)++  -- testing yields in count hook+  co = coroutine.wrap(function ()+    T.sethook("yield 0", "", 1); foo(); return 10 end)++  _G.XX = nil;+  local c = 0+  repeat c = c + 1; local a = co() until a == 10+  assert(_G.XX == 20 and c == 10)++  co = coroutine.wrap(function ()+    T.sethook("yield 0", "", 2); foo(); return 10 end)++  _G.XX = nil;+  local c = 0+  repeat c = c + 1; local a = co() until a == 10+  assert(_G.XX == 20 and c == 5)+  _G.X = nil; _G.XX = nil+++  print "testing coroutine API"+  +  -- reusing a thread+  assert(T.testC([[+    newthread      # create thread+    pushvalue 2    # push body+    pushstring 'a a a'  # push argument+    xmove 0 3 2   # move values to new thread+    resume -1, 1    # call it first time+    pushstatus+    xmove 3 0 0   # move results back to stack+    setglobal X    # result+    setglobal Y    # status+    pushvalue 2     # push body (to call it again)+    pushstring 'b b b'+    xmove 0 3 2+    resume -1, 1    # call it again+    pushstatus+    xmove 3 0 0+    return 1        # return result+  ]], function (...) return ... end) == 'b b b')++  assert(X == 'a a a' and Y == 'OK')+++  -- resuming running coroutine+  C = coroutine.create(function ()+        return T.testC([[+                 pushnum 10;+                 pushnum 20;+                 resume -3 2;+                 pushstatus+                 gettop;+                 return 3]], C)+      end)+  local a, b, c, d = coroutine.resume(C)+  assert(a == true and string.find(b, "non%-suspended") and+         c == "ERRRUN" and d == 4)++  a, b, c, d = T.testC([[+    rawgeti R 1    # get main thread+    pushnum 10;+    pushnum 20;+    resume -3 2;+    pushstatus+    gettop;+    return 4]])+  assert(a == coroutine.running() and string.find(b, "non%-suspended") and+         c == "ERRRUN" and d == 4)+++  -- using a main thread as a coroutine+  local state = T.newstate()+  T.loadlib(state)++  assert(T.doremote(state, [[+    coroutine = require'coroutine';+    X = function (x) coroutine.yield(x, 'BB'); return 'CC' end;+    return 'ok']]))++  t = table.pack(T.testC(state, [[+    rawgeti R 1     # get main thread+    pushstring 'XX'+    getglobal X    # get function for body+    pushstring AA      # arg+    resume 1 1      # 'resume' shadows previous stack!+    gettop+    setglobal T    # top+    setglobal B    # second yielded value+    setglobal A    # fist yielded value+    rawgeti R 1     # get main thread+    pushnum 5       # arg (noise)+    resume 1 1      # after coroutine ends, previous stack is back+    pushstatus+    gettop+    return .+  ]]))+  assert(t.n == 4 and t[2] == 'XX' and t[3] == 'CC' and t[4] == 'OK')+  assert(T.doremote(state, "return T") == '2')+  assert(T.doremote(state, "return A") == 'AA')+  assert(T.doremote(state, "return B") == 'BB')++  T.closestate(state)++  print'+'++end+++-- leaving a pending coroutine open+_X = coroutine.wrap(function ()+      local a = 10+      local x = function () a = a+1 end+      coroutine.yield()+    end)++_X()+++if not _soft then+  -- bug (stack overflow)+  local j = 2^9+  local lim = 1000000    -- (C stack limit; assume 32-bit machine)+  local t = {lim - 10, lim - 5, lim - 1, lim, lim + 1}+  for i = 1, #t do+    local j = t[i]+    co = coroutine.create(function()+           local t = {}+           for i = 1, j do t[i] = i end+           return table.unpack(t)+         end)+    local r, msg = coroutine.resume(co)+    assert(not r)+  end+end+++assert(coroutine.running() == main)++print"+"+++print"testing yields inside metamethods"++local mt = {+  __eq = function(a,b) coroutine.yield(nil, "eq"); return a.x == b.x end,+  __lt = function(a,b) coroutine.yield(nil, "lt"); return a.x < b.x end,+  __le = function(a,b) coroutine.yield(nil, "le"); return a - b <= 0 end,+  __add = function(a,b) coroutine.yield(nil, "add"); return a.x + b.x end,+  __sub = function(a,b) coroutine.yield(nil, "sub"); return a.x - b.x end,+  __concat = function(a,b)+               coroutine.yield(nil, "concat");+               a = type(a) == "table" and a.x or a+               b = type(b) == "table" and b.x or b+               return a .. b+             end,+  __index = function (t,k) coroutine.yield(nil, "idx"); return t.k[k] end,+  __newindex = function (t,k,v) coroutine.yield(nil, "nidx"); t.k[k] = v end,+}+++local function new (x)+  return setmetatable({x = x, k = {}}, mt)+end+++local a = new(10)+local b = new(12)+local c = new"hello"++local function run (f, t)+  local i = 1+  local c = coroutine.wrap(f)+  while true do+    local res, stat = c()+    if res then assert(t[i] == nil); return res, t end+    assert(stat == t[i])+    i = i + 1+  end+end+++assert(run(function () if (a>=b) then return '>=' else return '<' end end,+       {"le", "sub"}) == "<")+-- '<=' using '<'+mt.__le = nil+assert(run(function () if (a<=b) then return '<=' else return '>' end end,+       {"lt"}) == "<=")+assert(run(function () if (a==b) then return '==' else return '~=' end end,+       {"eq"}) == "~=")++assert(run(function () return a..b end, {"concat"}) == "1012")++assert(run(function() return a .. b .. c .. a end,+       {"concat", "concat", "concat"}) == "1012hello10")++assert(run(function() return "a" .. "b" .. a .. "c" .. c .. b .. "x" end,+       {"concat", "concat", "concat"}) == "ab10chello12x")++assert(run(function ()+             a.BB = print+             return a.BB+           end, {"nidx", "idx"}) == print)++-- getuptable & setuptable+do local _ENV = _ENV+  f = function () AAA = BBB + 1; return AAA end+end+g = new(10); g.k.BBB = 10;+debug.setupvalue(f, 1, g)+assert(run(f, {"idx", "nidx", "idx"}) == 11)+assert(g.k.AAA == 11)++print"+"++print"testing yields inside 'for' iterators"++local f = function (s, i)+      if i%2 == 0 then coroutine.yield(nil, "for") end+      if i < s then return i + 1 end+    end++assert(run(function ()+             local s = 0+             for i in f, 4, 0 do s = s + i end+             return s+           end, {"for", "for", "for"}) == 10)++++-- tests for coroutine API+if T==nil then+  (Message or print)('\a\n >>> testC not active: skipping coroutine API tests <<<\n\a')+  return+end++print('testing coroutine API')++local function apico (...)+  local x = {...}+  return coroutine.wrap(function ()+    return T.testC(table.unpack(x))+  end)+end++local a = {apico(+[[+  pushstring errorcode+  pcallk 1 0 2;+  invalid command (should not arrive here)+]],+[[getctx; gettop; return .]],+"stackmark",+error+)()}+assert(#a == 6 and+       a[3] == "stackmark" and+       a[4] == "errorcode" and+       a[5] == "ERRRUN" and+       a[6] == 2)       -- 'ctx' to pcallk++local co = apico(+  "pushvalue 2; pushnum 10; pcallk 1 2 3; invalid command;",+  coroutine.yield,+  "getctx; pushvalue 2; pushstring a; pcallk 1 0 4; invalid command",+  "getctx; gettop; return .")++assert(co() == 10)+assert(co(20, 30) == 'a')+a = {co()}+assert(#a == 10 and+       a[2] == coroutine.yield and+       a[5] == 20 and a[6] == 30 and+       a[7] == "YIELD" and a[8] == 3 and+       a[9] == "YIELD" and a[10] == 4)+assert(not pcall(co))   -- coroutine is dead now+++f = T.makeCfunc("pushnum 3; pushnum 5; yield 1;")+co = coroutine.wrap(function ()+  assert(f() == 23); assert(f() == 23); return 10+end)+assert(co(23,16) == 5)+assert(co(23,16) == 5)+assert(co(23,16) == 10)+++-- testing coroutines with C bodies+f = T.makeCfunc([[+        pushnum 102+	yieldk	1 U2+	return 2+]],+[[+	pushnum 23   # continuation+	gettop+	return .+]])++x = coroutine.wrap(f)+assert(x() == 102)+assert(x() == 23)+++f = T.makeCfunc[[pushstring 'a'; pushnum 102; yield 2; ]]++a, b, c, d = T.testC([[newthread; pushvalue 2; xmove 0 3 1; resume 3 0;+                       pushstatus; xmove 3 0 0;  resume 3 0; pushstatus;+                       return 4; ]], f)++assert(a == 'YIELD' and b == 'a' and c == 102 and d == 'OK')+++-- testing chain of suspendable C calls++local count = 3   -- number of levels++f = T.makeCfunc([[+  remove 1;             # remove argument+  pushvalue U3;         # get selection function+  call 0 1;             # call it  (result is 'f' or 'yield')+  pushstring hello      # single argument for selected function+  pushupvalueindex 2;   # index of continuation program+  callk 1 -1 .;		# call selected function+  errorerror		# should never arrive here+]],+[[+  # continuation program+  pushnum 34	# return value+  gettop+  return .     # return all results+]],+function ()     -- selection function+  count = count - 1+  if count == 0 then return coroutine.yield+  else return f+  end+end+)++co = coroutine.wrap(function () return f(nil) end)+assert(co() == "hello")   -- argument to 'yield'+a = {co()}+-- three '34's (one from each pending C call)+assert(#a == 3 and a[1] == a[2] and a[2] == a[3] and a[3] == 34)+++-- testing yields with continuations++co = coroutine.wrap(function (...) return+       T.testC([[+          getctx+          yieldk 3 2+          nonexec error+       ]],+       [[  # continuation+         getctx+         yieldk 2 3 +       ]],+       [[  # continuation+         getctx+         yieldk 2 4 +       ]],+       [[  # continuation+          pushvalue 6; pushnum 10; pushnum 20;+          pcall 2 0     # call should throw an error and execution continues+          pop 1		# remove error message+          pushvalue 6+          getctx+          pcallk 2 2 5  # call should throw an error and jump to continuation+          cannot be here!+       ]],+       [[  # continuation+         gettop+         return .+       ]],+       function (a,b)  x=a; y=b; error("errmsg") end,+       ...+)+end)++local a = {co(3,4,6)}; assert(a[1] == 6 and a[2] == "OK" and a[3] == 0)+a = {co()}; assert(a[1] == "YIELD" and a[2] == 2)+a = {co()}; assert(a[1] == "YIELD" and a[2] == 3)+a = {co(7,8)};+-- original arguments+assert(type(a[1]) == 'string' and type(a[2]) == 'string' and+     type(a[3]) == 'string' and type(a[4]) == 'string' and+     type(a[5]) == 'string' and type(a[6]) == 'function')+-- arguments left from fist resume+assert(a[7] == 3 and a[8] == 4)+-- arguments to last resume+assert(a[9] == 7 and a[10] == 8)+-- error message and nothing more+assert(a[11]:find("errmsg") and #a == 11)+-- check arguments to pcallk+assert(x == "YIELD" and y == 4)++assert(not pcall(co))   -- coroutine should be dead++-- testing ctx++a,b = T.testC(+       [[ pushstring print; pcallk 0 0 12    # error+          getctx; return 2 ]])+assert(a == "OK" and b == 0)   -- no ctx outside continuations+++-- bug in nCcalls+local co = coroutine.wrap(function ()+  local a = {pcall(pcall,pcall,pcall,pcall,pcall,pcall,pcall,error,"hi")}+  return pcall(assert, table.unpack(a))+end)++local a = {co()}+assert(a[10] == "hi")+++print'OK'

@@ -0,0 +1,631 @@+-- testing debug library++debug = require "debug"++local function dostring(s) return assert(load(s))() end++print"testing debug library and debug information"++do+local a=1+end++function test (s, l, p)+  collectgarbage()   -- avoid gc during trace+  local function f (event, line)+    assert(event == 'line')+    local l = table.remove(l, 1)+    if p then print(l, line) end+    assert(l == line, "wrong trace!!")+  end+  debug.sethook(f,"l"); load(s)(); debug.sethook()+  assert(#l == 0)+end+++do+  assert(not pcall(debug.getinfo, print, "X"))   -- invalid option+  assert(debug.getinfo(1000) == nil)   -- out of range level+  assert(debug.getinfo(-1) == nil)     -- out of range level+  local a = debug.getinfo(print)+  assert(a.what == "C" and a.short_src == "[C]")+  a = debug.getinfo(print, "L")+  assert(a.activelines == nil)+  local b = debug.getinfo(test, "SfL")+  assert(b.name == nil and b.what == "Lua" and b.linedefined == 13 and+         b.lastlinedefined == b.linedefined + 10 and+         b.func == test and not string.find(b.short_src, "%["))+  assert(b.activelines[b.linedefined + 1] and+         b.activelines[b.lastlinedefined])+  assert(not b.activelines[b.linedefined] and+         not b.activelines[b.lastlinedefined + 1])+end+++-- test file and string names truncation+a = "function f () end"+local function dostring (s, x) return load(s, x)() end+dostring(a)+assert(debug.getinfo(f).short_src == string.format('[string "%s"]', a))+dostring(a..string.format("; %s\n=1", string.rep('p', 400)))+assert(string.find(debug.getinfo(f).short_src, '^%[string [^\n]*%.%.%."%]$'))+dostring(a..string.format("; %s=1", string.rep('p', 400)))+assert(string.find(debug.getinfo(f).short_src, '^%[string [^\n]*%.%.%."%]$'))+dostring("\n"..a)+assert(debug.getinfo(f).short_src == '[string "..."]')+dostring(a, "")+assert(debug.getinfo(f).short_src == '[string ""]')+dostring(a, "@xuxu")+assert(debug.getinfo(f).short_src == "xuxu")+dostring(a, "@"..string.rep('p', 1000)..'t')+assert(string.find(debug.getinfo(f).short_src, "^%.%.%.p*t$"))+dostring(a, "=xuxu")+assert(debug.getinfo(f).short_src == "xuxu")+dostring(a, string.format("=%s", string.rep('x', 500)))+assert(string.find(debug.getinfo(f).short_src, "^x*$"))+dostring(a, "=")+assert(debug.getinfo(f).short_src == "")+a = nil; f = nil;+++repeat+  local g = {x = function ()+    local a = debug.getinfo(2)+    assert(a.name == 'f' and a.namewhat == 'local')+    a = debug.getinfo(1)+    assert(a.name == 'x' and a.namewhat == 'field')+    return 'xixi'+  end}+  local f = function () return 1+1 and (not 1 or g.x()) end+  assert(f() == 'xixi')+  g = debug.getinfo(f)+  assert(g.what == "Lua" and g.func == f and g.namewhat == "" and not g.name)++  function f (x, name)   -- local!+    name = name or 'f'+    local a = debug.getinfo(1)+    assert(a.name == name and a.namewhat == 'local')+    return x+  end++  -- breaks in different conditions+  if 3>4 then break end; f()+  if 3<4 then a=1 else break end; f()+  while 1 do local x=10; break end; f()+  local b = 1+  if 3>4 then return math.sin(1) end; f()+  a = 3<4; f()+  a = 3<4 or 1; f()+  repeat local x=20; if 4>3 then f() else break end; f() until 1+  g = {}+  f(g).x = f(2) and f(10)+f(9)+  assert(g.x == f(19))+  function g(x) if not x then return 3 end return (x('a', 'x')) end+  assert(g(f) == 'a')+until 1++test([[if+math.sin(1)+then+  a=1+else+  a=2+end+]], {2,3,4,7})++test([[--+if nil then+  a=1+else+  a=2+end+]], {2,5,6})++test([[a=1+repeat+  a=a+1+until a==3+]], {1,3,4,3,4})++test([[ do+  return+end+]], {2})++test([[local a+a=1+while a<=3 do+  a=a+1+end+]], {1,2,3,4,3,4,3,4,3,5})++test([[while math.sin(1) do+  if math.sin(1)+  then break+  end+end+a=1]], {1,2,3,6})++test([[for i=1,3 do+  a=i+end+]], {1,2,1,2,1,2,1,3})++test([[for i,v in pairs{'a','b'} do+  a=i..v+end+]], {1,2,1,2,1,3})++test([[for i=1,4 do a=1 end]], {1,1,1,1,1})++++print'+'++-- invalid levels in [gs]etlocal+assert(not pcall(debug.getlocal, 20, 1))+assert(not pcall(debug.setlocal, -1, 1, 10))+++-- parameter names+local function foo (a,b,...) local d, e end+local co = coroutine.create(foo)++assert(debug.getlocal(foo, 1) == 'a')+assert(debug.getlocal(foo, 2) == 'b')+assert(debug.getlocal(foo, 3) == nil)+assert(debug.getlocal(co, foo, 1) == 'a')+assert(debug.getlocal(co, foo, 2) == 'b')+assert(debug.getlocal(co, foo, 3) == nil)++assert(debug.getlocal(print, 1) == nil)+++-- varargs+local function foo (a, ...)+  local t = table.pack(...)+  for i = 1, t.n do+    local n, v = debug.getlocal(1, -i)+    assert(n == "(*vararg)" and v == t[i])+  end+  assert(not debug.getlocal(1, -(t.n + 1)))+  assert(not debug.setlocal(1, -(t.n + 1), 30))+  if t.n > 0 then+    (function (x)+      assert(debug.setlocal(2, -1, x) == "(*vararg)")+      assert(debug.setlocal(2, -t.n, x) == "(*vararg)")+     end)(430)+     assert(... == 430)+  end+end++foo()+foo(print)+foo(200, 3, 4)+local a = {}+for i = 1,1000 do a[i] = i end+foo(table.unpack(a))+a = nil++-- access to vararg in non-vararg function+local function foo () return debug.getlocal(1, -1) end+assert(foo(10) == nil)+++a = {}; L = nil+local glob = 1+local oldglob = glob+debug.sethook(function (e,l)+  collectgarbage()   -- force GC during a hook+  local f, m, c = debug.gethook()+  assert(m == 'crl' and c == 0)+  if e == "line" then+    if glob ~= oldglob then+      L = l-1   -- get the first line where "glob" has changed+      oldglob = glob+    end+  elseif e == "call" then+      local f = debug.getinfo(2, "f").func+      a[f] = 1+  else assert(e == "return")+  end+end, "crl")+++function f(a,b)+  collectgarbage()+  local _, x = debug.getlocal(1, 1)+  local _, y = debug.getlocal(1, 2)+  assert(x == a and y == b)+  assert(debug.setlocal(2, 3, "pera") == "AA".."AA")+  assert(debug.setlocal(2, 4, "maçã") == "B")+  x = debug.getinfo(2)+  assert(x.func == g and x.what == "Lua" and x.name == 'g' and+         x.nups == 1 and string.find(x.source, "^@.*db%.lua$"))+  glob = glob+1+  assert(debug.getinfo(1, "l").currentline == L+1)+  assert(debug.getinfo(1, "l").currentline == L+2)+end++function foo()+  glob = glob+1+  assert(debug.getinfo(1, "l").currentline == L+1)+end; foo()  -- set L+-- check line counting inside strings and empty lines++_ = 'alo\+alo' .. [[++]]+--[[+]]+assert(debug.getinfo(1, "l").currentline == L+11)  -- check count of lines+++function g(...)+  local arg = {...}+  do local a,b,c; a=math.sin(40); end+  local feijao+  local AAAA,B = "xuxu", "mamão"+  f(AAAA,B)+  assert(AAAA == "pera" and B == "maçã")+  do+     local B = 13+     local x,y = debug.getlocal(1,5)+     assert(x == 'B' and y == 13)+  end+end++g()+++assert(a[f] and a[g] and a[assert] and a[debug.getlocal] and not a[print])+++-- tests for manipulating non-registered locals (C and Lua temporaries)++local n, v = debug.getlocal(0, 1)+assert(v == 0 and n == "(*temporary)")+local n, v = debug.getlocal(0, 2)+assert(v == 2 and n == "(*temporary)")+assert(not debug.getlocal(0, 3))+assert(not debug.getlocal(0, 0))++function f()+  assert(select(2, debug.getlocal(2,3)) == 1)+  assert(not debug.getlocal(2,4))+  debug.setlocal(2, 3, 10)+  return 20+end++function g(a,b) return (a+1) + f() end++assert(g(0,0) == 30)+ ++debug.sethook(nil);+assert(debug.gethook() == nil)+++-- testing access to function arguments++X = nil+a = {}+function a:f (a, b, ...) local arg = {...}; local c = 13 end+debug.sethook(function (e)+  assert(e == "call")+  dostring("XX = 12")  -- test dostring inside hooks+  -- testing errors inside hooks+  assert(not pcall(load("a='joao'+1")))+  debug.sethook(function (e, l) +    assert(debug.getinfo(2, "l").currentline == l)+    local f,m,c = debug.gethook()+    assert(e == "line")+    assert(m == 'l' and c == 0)+    debug.sethook(nil)  -- hook is called only once+    assert(not X)       -- check that+    X = {}; local i = 1+    local x,y+    while 1 do+      x,y = debug.getlocal(2, i)+      if x==nil then break end+      X[x] = y+      i = i+1+    end+  end, "l")+end, "c")++a:f(1,2,3,4,5)+assert(X.self == a and X.a == 1   and X.b == 2 and X.c == nil)+assert(XX == 12)+assert(debug.gethook() == nil)+++-- testing upvalue access+local function getupvalues (f)+  local t = {}+  local i = 1+  while true do+    local name, value = debug.getupvalue(f, i)+    if not name then break end+    assert(not t[name])+    t[name] = value+    i = i + 1+  end+  return t+end++local a,b,c = 1,2,3+local function foo1 (a) b = a; return c end+local function foo2 (x) a = x; return c+b end+assert(debug.getupvalue(foo1, 3) == nil)+assert(debug.getupvalue(foo1, 0) == nil)+assert(debug.setupvalue(foo1, 3, "xuxu") == nil)+local t = getupvalues(foo1)+assert(t.a == nil and t.b == 2 and t.c == 3)+t = getupvalues(foo2)+assert(t.a == 1 and t.b == 2 and t.c == 3)+assert(debug.setupvalue(foo1, 1, "xuxu") == "b")+assert(({debug.getupvalue(foo2, 3)})[2] == "xuxu")+-- upvalues of C functions are allways "called" "" (the empty string)+assert(debug.getupvalue(string.gmatch("x", "x"), 1) == "")  +++-- testing count hooks+local a=0+debug.sethook(function (e) a=a+1 end, "", 1)+a=0; for i=1,1000 do end; assert(1000 < a and a < 1012)+debug.sethook(function (e) a=a+1 end, "", 4)+a=0; for i=1,1000 do end; assert(250 < a and a < 255)+local f,m,c = debug.gethook()+assert(m == "" and c == 4)+debug.sethook(function (e) a=a+1 end, "", 4000)+a=0; for i=1,1000 do end; assert(a == 0)++if not _no32 then+  debug.sethook(print, "", 2^24 - 1)   -- count upperbound+  local f,m,c = debug.gethook()+  assert(({debug.gethook()})[3] == 2^24 - 1)+end++debug.sethook()+++-- tests for tail calls+local function f (x)+  if x then+    assert(debug.getinfo(1, "S").what == "Lua")+    assert(debug.getinfo(1, "t").istailcall == true)+    local tail = debug.getinfo(2)+    assert(tail.func == g1 and tail.istailcall == true)+    assert(debug.getinfo(3, "S").what == "main")+    print"+"+    end+end++function g(x) return f(x) end++function g1(x) g(x) end++local function h (x) local f=g1; return f(x) end++h(true)++local b = {}+debug.sethook(function (e) table.insert(b, e) end, "cr")+h(false)+debug.sethook()+local res = {"return",   -- first return (from sethook)+  "call", "tail call", "call", "tail call",+  "return", "return",+  "call",    -- last call (to sethook)+}+for i = 1, #res do assert(res[i] == table.remove(b, 1)) end++b = 0+debug.sethook(function (e)+                if e == "tail call" then+                  b = b + 1+                  assert(debug.getinfo(2, "t").istailcall == true)+                else+                  assert(debug.getinfo(2, "t").istailcall == false)+                end+              end, "c")+h(false)+debug.sethook()+assert(b == 2)   -- two tail calls++lim = 30000+if _soft then limit = 3000 end+local function foo (x)+  if x==0 then+    assert(debug.getinfo(2).what == "main")+    local info = debug.getinfo(1)+    assert(info.istailcall == true and info.func == foo)+  else return foo(x-1)+  end+end++foo(lim)+++print"+"+++-- testing local function information+co = load[[+  local A = function ()+    return x+  end+  return+]]++local a = 0+-- 'A' should be visible to debugger only after its complete definition+debug.sethook(function (e, l)+  if l == 3 then a = a + 1; assert(debug.getlocal(2, 1) == "(*temporary)")+  elseif l == 4 then a = a + 1; assert(debug.getlocal(2, 1) == "A")+  end+end, "l")+co()  -- run local function definition+debug.sethook()  -- turn off hook+assert(a == 2)   -- ensure all two lines where hooked++-- testing traceback++assert(debug.traceback(print) == print)+assert(debug.traceback(print, 4) == print)+assert(string.find(debug.traceback("hi", 4), "^hi\n"))+assert(string.find(debug.traceback("hi"), "^hi\n"))+assert(not string.find(debug.traceback("hi"), "'traceback'"))+assert(string.find(debug.traceback("hi", 0), "'traceback'"))+assert(string.find(debug.traceback(), "^stack traceback:\n"))+++-- testing nparams, nups e isvararg+local t = debug.getinfo(print, "u")+assert(t.isvararg == true and t.nparams == 0 and t.nups == 0)++t = debug.getinfo(function (a,b,c) end, "u")+assert(t.isvararg == false and t.nparams == 3 and t.nups == 0)++t = debug.getinfo(function (a,b,...) return t[a] end, "u")+assert(t.isvararg == true and t.nparams == 2 and t.nups == 1)++t = debug.getinfo(1)   -- main+assert(t.isvararg == true and t.nparams == 0 and t.nups == 1 and+       debug.getupvalue(t.func, 1) == "_ENV")+++-- testing debugging of coroutines++local function checktraceback (co, p, level)+  local tb = debug.traceback(co, nil, level)+  local i = 0+  for l in string.gmatch(tb, "[^\n]+\n?") do+    assert(i == 0 or string.find(l, p[i]))+    i = i+1+  end+  assert(p[i] == nil)+end+++local function f (n)+  if n > 0 then f(n-1)+  else coroutine.yield() end+end++local co = coroutine.create(f)+coroutine.resume(co, 3)+checktraceback(co, {"yield", "db.lua", "db.lua", "db.lua", "db.lua"})+checktraceback(co, {"db.lua", "db.lua", "db.lua", "db.lua"}, 1)+checktraceback(co, {"db.lua", "db.lua", "db.lua"}, 2)+checktraceback(co, {"db.lua"}, 4)+checktraceback(co, {}, 40)+++co = coroutine.create(function (x)+       local a = 1+       coroutine.yield(debug.getinfo(1, "l"))+       coroutine.yield(debug.getinfo(1, "l").currentline)+       return a+     end)++local tr = {}+local foo = function (e, l) if l then table.insert(tr, l) end end+debug.sethook(co, foo, "lcr")++local _, l = coroutine.resume(co, 10)+local x = debug.getinfo(co, 1, "lfLS")+assert(x.currentline == l.currentline and x.activelines[x.currentline])+assert(type(x.func) == "function")+for i=x.linedefined + 1, x.lastlinedefined do+  assert(x.activelines[i])+  x.activelines[i] = nil+end+assert(next(x.activelines) == nil)   -- no 'extra' elements+assert(debug.getinfo(co, 2) == nil)+local a,b = debug.getlocal(co, 1, 1)+assert(a == "x" and b == 10)+a,b = debug.getlocal(co, 1, 2)+assert(a == "a" and b == 1)+debug.setlocal(co, 1, 2, "hi")+assert(debug.gethook(co) == foo)+assert(#tr == 2 and+       tr[1] == l.currentline-1 and tr[2] == l.currentline)++a,b,c = pcall(coroutine.resume, co)+assert(a and b and c == l.currentline+1)+checktraceback(co, {"yield", "in function <"})++a,b = coroutine.resume(co)+assert(a and b == "hi")+assert(#tr == 4 and tr[4] == l.currentline+2)+assert(debug.gethook(co) == foo)+assert(debug.gethook() == nil)+checktraceback(co, {})+++-- check traceback of suspended (or dead with error) coroutines++function f(i) if i==0 then error(i) else coroutine.yield(); f(i-1) end end++co = coroutine.create(function (x) f(x) end)+a, b = coroutine.resume(co, 3)+t = {"'yield'", "'f'", "in function <"}+while coroutine.status(co) == "suspended" do+  checktraceback(co, t)+  a, b = coroutine.resume(co)+  table.insert(t, 2, "'f'")   -- one more recursive call to 'f'+end+t[1] = "'error'"+checktraceback(co, t)+++-- test acessing line numbers of a coroutine from a resume inside+-- a C function (this is a known bug in Lua 5.0)++local function g(x)+    coroutine.yield(x)+end++local function f (i)+  debug.sethook(function () end, "l")+  for j=1,1000 do+    g(i+j)+  end+end++local co = coroutine.wrap(f)+co(10)+pcall(co)+pcall(co)+++assert(type(debug.getregistry()) == "table")+++-- test tagmethod information+local a = {}+local function f (t)+  local info = debug.getinfo(1);+  assert(info.namewhat == "metamethod")+  a.op = info.name+  return info.name+end+setmetatable(a, {+  __index = f; __add = f; __div = f; __mod = f; __concat = f; __pow = f;+  __eq = f; __le = f; __lt = f;+})++local b = setmetatable({}, getmetatable(a))++assert(a[3] == "__index" and a^3 == "__pow" and a..a == "__concat")+assert(a/3 == "__div" and 3%a == "__mod")+assert (a==b and a.op == "__eq")+assert (a>=b and a.op == "__le")+assert (a>b and a.op == "__lt")+++print"OK"+

@@ -0,0 +1,422 @@+print("testing errors")++local debug = require"debug"++-- avoid problems with 'strict' module (which may generate other error messages)+local mt = getmetatable(_G) or {}+local oldmm = mt.__index+mt.__index = nil++function doit (s)+  local f, msg = load(s)+  if f == nil then return msg end+  local cond, msg = pcall(f)+  return (not cond) and msg+end+++function checkmessage (prog, msg)+  local m = doit(prog)+  assert(string.find(m, msg, 1, true))+end++function checksyntax (prog, extra, token, line)+  local msg = doit(prog)+  if not string.find(token, "^<%a") and not string.find(token, "^char%(")+    then token = "'"..token.."'" end+  token = string.gsub(token, "(%p)", "%%%1")+  local pt = string.format([[^%%[string ".*"%%]:%d: .- near %s$]],+                           line, token)+  assert(string.find(msg, pt))+  assert(string.find(msg, msg, 1, true))+end+++-- test error message with no extra info+assert(doit("error('hi', 0)") == 'hi')++-- test error message with no info+assert(doit("error()") == nil)+++-- test common errors/errors that crashed in the past+if not _no32 then+  assert(doit("table.unpack({}, 1, n=2^30)"))+end+assert(doit("a=math.sin()"))+assert(not doit("tostring(1)") and doit("tostring()"))+assert(doit"tonumber()")+assert(doit"repeat until 1; a")+assert(doit"return;;")+assert(doit"assert(false)")+assert(doit"assert(nil)")+assert(doit("function a (... , ...) end"))+assert(doit("function a (, ...) end"))+assert(doit("local t={}; t = t[#t] + 1"))++checksyntax([[+  local a = {4++]], "'}' expected (to close '{' at line 1)", "<eof>", 3)+++-- tests for better error messages++checkmessage("a=1; bbbb=2; a=math.sin(3)+bbbb(3)", "global 'bbbb'")+checkmessage("a=1; local a,bbbb=2,3; a = math.sin(1) and bbbb(3)",+       "local 'bbbb'")+checkmessage("a={}; do local a=1 end a:bbbb(3)", "method 'bbbb'")+checkmessage("local a={}; a.bbbb(3)", "field 'bbbb'")+assert(not string.find(doit"a={13}; local bbbb=1; a[bbbb](3)", "'bbbb'"))+checkmessage("a={13}; local bbbb=1; a[bbbb](3)", "number")+checkmessage("a=(1)..{}", "a table value")++aaa = nil+checkmessage("aaa.bbb:ddd(9)", "global 'aaa'")+checkmessage("local aaa={bbb=1}; aaa.bbb:ddd(9)", "field 'bbb'")+checkmessage("local aaa={bbb={}}; aaa.bbb:ddd(9)", "method 'ddd'")+checkmessage("local a,b,c; (function () a = b+1 end)()", "upvalue 'b'")+assert(not doit"local aaa={bbb={ddd=next}}; aaa.bbb:ddd(nil)")++checkmessage("local _ENV = {x={}}; a = a + 1", "global 'a'")++checkmessage("b=1; local aaa='a'; x=aaa+b", "local 'aaa'")+checkmessage("aaa={}; x=3/aaa", "global 'aaa'")+checkmessage("aaa='2'; b=nil;x=aaa*b", "global 'b'")+checkmessage("aaa={}; x=-aaa", "global 'aaa'")+assert(not string.find(doit"aaa={}; x=(aaa or aaa)+(aaa and aaa)", "'aaa'"))+assert(not string.find(doit"aaa={}; (aaa or aaa)()", "'aaa'"))++checkmessage("print(print < 10)", "function")+checkmessage("print(print < print)", "two function")+++-- passing light userdata instead of full userdata+_G.D = debug+checkmessage([[+  -- create light udata+  local x = D.upvalueid(function () return debug end, 1)+  D.setuservalue(x, {})+]], "light userdata")+_G.D = nil+++-- global functions+checkmessage("(io.write or print){}", "io.write")+checkmessage("(collectgarbage or print){}", "collectgarbage")++-- tests for field accesses after RK limit+local t = {}+for i = 1, 1000 do+  t[i] = "a = x" .. i+end+local s = table.concat(t, "; ")+t = nil+checkmessage(s.."; a = bbb + 1", "global 'bbb'")+checkmessage("local _ENV=_ENV;"..s.."; a = bbb + 1", "global 'bbb'")+checkmessage(s.."; local t = {}; a = t.bbb + 1", "field 'bbb'")+checkmessage(s.."; local t = {}; t:bbb()", "method 'bbb'")++checkmessage([[aaa=9+repeat until 3==3+local x=math.sin(math.cos(3))+if math.sin(1) == x then return math.sin(1) end   -- tail call+local a,b = 1, {+  {x='a'..'b'..'c', y='b', z=x},+  {1,2,3,4,5} or 3+3<=3+3,+  3+1>3+1,+  {d = x and aaa[x or y]}}+]], "global 'aaa'")++checkmessage([[+local x,y = {},1+if math.sin(1) == 0 then return 3 end    -- return+x.a()]], "field 'a'")++checkmessage([[+prefix = nil+insert = nil+while 1 do+  local a+  if nil then break end+  insert(prefix, a)+end]], "global 'insert'")++checkmessage([[  -- tail call+  return math.sin("a")+]], "'sin'")++checkmessage([[collectgarbage("nooption")]], "invalid option")++checkmessage([[x = print .. "a"]], "concatenate")++checkmessage("getmetatable(io.stdin).__gc()", "no value")++checkmessage([[+local Var+local function main()+  NoSuchName (function() Var=0 end)+end+main()+]], "global 'NoSuchName'")+print'+'++a = {}; setmetatable(a, {__index = string})+checkmessage("a:sub()", "bad self")+checkmessage("string.sub('a', {})", "#2")+checkmessage("('a'):sub{}", "#1")++checkmessage("table.sort({1,2,3}, table.sort)", "'table.sort'")+-- next message may be 'setmetatable' or '_G.setmetatable'+checkmessage("string.gsub('s', 's', setmetatable)", "setmetatable'")++-- tests for errors in coroutines++function f (n)+  local c = coroutine.create(f)+  local a,b = coroutine.resume(c)+  return b+end+assert(string.find(f(), "C stack overflow"))++checkmessage("coroutine.yield()", "outside a coroutine")++f1 = function () table.sort({1,2,3}, coroutine.yield) end+f = coroutine.wrap(function () return pcall(f1) end)+assert(string.find(select(2, f()), "yield across"))+++-- testing size of 'source' info; size of buffer for that info is+-- LUA_IDSIZE, declared as 60 in luaconf. Get one position for '\0'.+idsize = 60 - 1+local function checksize (source)+  -- syntax error+  local _, msg = load("x", source)+  msg = string.match(msg, "^([^:]*):")   -- get source (1st part before ':')+  assert(msg:len() <= idsize)+end++for i = 60 - 10, 60 + 10 do   -- check border cases around 60+  checksize("@" .. string.rep("x", i))   -- file names+  checksize(string.rep("x", i - 10))     -- string sources+  checksize("=" .. string.rep("x", i))   -- exact sources+end+++-- testing line error++local function lineerror (s, l)+  local err,msg = pcall(load(s))+  local line = string.match(msg, ":(%d+):")+  assert((line and line+0) == l)+end++lineerror("local a\n for i=1,'a' do \n print(i) \n end", 2)+lineerror("\n local a \n for k,v in 3 \n do \n print(k) \n end", 3)+lineerror("\n\n for k,v in \n 3 \n do \n print(k) \n end", 4)+lineerror("function a.x.y ()\na=a+1\nend", 1)++lineerror("a = \na\n+\n{}", 3)+lineerror("a = \n3\n+\n(\n4\n/\nprint)", 6)+lineerror("a = \nprint\n+\n(\n4\n/\n7)", 3)++lineerror("a\n=\n-\n\nprint\n;", 3)++lineerror([[+a+(+23)+]], 1)++lineerror([[+local a = {x = 13}+a+.+x+(+23+)+]], 2)++lineerror([[+local a = {x = 13}+a+.+x+(+23 + a+)+]], 6)++local p = [[+function g() f() end+function f(x) error('a', X) end+g()+]]+X=3;lineerror((p), 3)+X=0;lineerror((p), nil)+X=1;lineerror((p), 2)+X=2;lineerror((p), 1)+++if not _soft then+  -- several tests that exaust the Lua stack+  C = 0+  local l = debug.getinfo(1, "l").currentline; function y () C=C+1; y() end++  local function checkstackmessage (m)+    return (string.find(m, "^.-:%d+: stack overflow"))+  end+  -- repeated stack overflows (to check stack recovery)+  assert(checkstackmessage(doit('y()')))+  print('+')+  assert(checkstackmessage(doit('y()')))+  print('+')+  assert(checkstackmessage(doit('y()')))+  print('+')+++  -- error lines in stack overflow+  C = 0+  local l1+  local function g(x)+    l1 = debug.getinfo(x, "l").currentline; y()+  end+  local _, stackmsg = xpcall(g, debug.traceback, 1)+  print('+')+  local stack = {}+  for line in string.gmatch(stackmsg, "[^\n]*") do+    local curr = string.match(line, ":(%d+):")+    if curr then table.insert(stack, tonumber(curr)) end+  end+  local i=1+  while stack[i] ~= l1 do+    assert(stack[i] == l)+    i = i+1+  end+  assert(i > 15)+++  -- error in error handling+  local res, msg = xpcall(error, error)+  assert(not res and type(msg) == 'string')+  print('+')++  local function f (x)+    if x==0 then error('a\n')+    else+      local aux = function () return f(x-1) end+      local a,b = xpcall(aux, aux)+      return a,b+    end+  end+  f(3)++  local function loop (x,y,z) return 1 + loop(x, y, z) end+ +  local res, msg = xpcall(loop, function (m)+    assert(string.find(m, "stack overflow"))+    local res, msg = pcall(loop)+    assert(string.find(msg, "error handling"))+    assert(math.sin(0) == 0)+    return 15+  end)+  assert(msg == 15)++  res, msg = pcall(function ()+    for i = 999900, 1000000, 1 do table.unpack({}, 1, i) end+  end)+  assert(string.find(msg, "too many results"))++end+++-- non string messages+function f() error{msg='x'} end+res, msg = xpcall(f, function (r) return {msg=r.msg..'y'} end)+assert(msg.msg == 'xy')++-- xpcall with arguments+a, b, c = xpcall(string.find, error, "alo", "al")+assert(a and b == 1 and c == 2)+a, b, c = xpcall(string.find, function (x) return {} end, true, "al")+assert(not a and type(b) == "table" and c == nil)++print('+')+checksyntax("syntax error", "", "error", 1)+checksyntax("1.000", "", "1.000", 1)+checksyntax("[[a]]", "", "[[a]]", 1)+checksyntax("'aa'", "", "'aa'", 1)++-- test 255 as first char in a chunk+checksyntax("\255a = 1", "", "char(255)", 1)++doit('I = load("a=9+"); a=3')+assert(a==3 and I == nil)+print('+')++lim = 1000+if _soft then lim = 100 end+for i=1,lim do+  doit('a = ')+  doit('a = 4+nil')+end+++-- testing syntax limits+local function testrep (init, rep)+  local s = "local a; "..init .. string.rep(rep, 400)+  local a,b = load(s)+  assert(not a and string.find(b, "levels"))+end+testrep("a=", "{")+testrep("a=", "(")+testrep("", "a(")+testrep("", "do ")+testrep("", "while a do ")+testrep("", "if a then else ")+testrep("", "function foo () ")+testrep("a=", "a..")+testrep("a=", "a^")++local s = ("a,"):rep(200).."a=nil"+local a,b = load(s)+assert(not a and string.find(b, "levels"))+++-- testing other limits+-- upvalues+local lim = 127+local  s = "local function fooA ()\n  local "+for j = 1,lim do+  s = s.."a"..j..", "+end+s = s.."b,c\n"+s = s.."local function fooB ()\n  local "+for j = 1,lim do+  s = s.."b"..j..", "+end+s = s.."b\n"+s = s.."function fooC () return b+c"+local c = 1+2+for j = 1,lim do+  s = s.."+a"..j.."+b"..j+  c = c + 2+end+s = s.."\nend  end end"+local a,b = load(s)+assert(c > 255 and string.find(b, "too many upvalues") and+       string.find(b, "line 5"))++-- local variables+s = "\nfunction foo ()\n  local "+for j = 1,300 do+  s = s.."a"..j..", "+end+s = s.."b\n"+local a,b = load(s)+assert(string.find(b, "line 2"))++mt.__index = oldmm++print('OK')

@@ -0,0 +1,388 @@+print('testing metatables')++X = 20; B = 30++_ENV = setmetatable({}, {__index=_G})++collectgarbage()++X = X+10+assert(X == 30 and _G.X == 20)+B = false+assert(B == false)+B = nil+assert(B == 30)++assert(getmetatable{} == nil)+assert(getmetatable(4) == nil)+assert(getmetatable(nil) == nil)+a={}; setmetatable(a, {__metatable = "xuxu",+                    __tostring=function(x) return x.name end})+assert(getmetatable(a) == "xuxu")+assert(tostring(a) == nil)+-- cannot change a protected metatable+assert(pcall(setmetatable, a, {}) == false)+a.name = "gororoba"+assert(tostring(a) == "gororoba")++local a, t = {10,20,30; x="10", y="20"}, {}+assert(setmetatable(a,t) == a)+assert(getmetatable(a) == t)+assert(setmetatable(a,nil) == a)+assert(getmetatable(a) == nil)+assert(setmetatable(a,t) == a)+++function f (t, i, e)+  assert(not e)+  local p = rawget(t, "parent")+  return (p and p[i]+3), "dummy return"+end++t.__index = f++a.parent = {z=25, x=12, [4] = 24}+assert(a[1] == 10 and a.z == 28 and a[4] == 27 and a.x == "10")++collectgarbage()++a = setmetatable({}, t)+function f(t, i, v) rawset(t, i, v-3) end+setmetatable(t, t)   -- causes a bug in 5.1 !+t.__newindex = f+a[1] = 30; a.x = "101"; a[5] = 200+assert(a[1] == 27 and a.x == 98 and a[5] == 197)+++local c = {}+a = setmetatable({}, t)+t.__newindex = c+a[1] = 10; a[2] = 20; a[3] = 90+assert(c[1] == 10 and c[2] == 20 and c[3] == 90)+++do+  local a;+  a = setmetatable({}, {__index = setmetatable({},+                     {__index = setmetatable({},+                     {__index = function (_,n) return a[n-3]+4, "lixo" end})})})+  a[0] = 20+  for i=0,10 do+    assert(a[i*3] == 20 + i*4)+  end+end+++do  -- newindex+  local foi+  local a = {}+  for i=1,10 do a[i] = 0; a['a'..i] = 0; end+  setmetatable(a, {__newindex = function (t,k,v) foi=true; rawset(t,k,v) end})+  foi = false; a[1]=0; assert(not foi)+  foi = false; a['a1']=0; assert(not foi)+  foi = false; a['a11']=0; assert(foi)+  foi = false; a[11]=0; assert(foi)+  foi = false; a[1]=nil; assert(not foi)+  foi = false; a[1]=nil; assert(foi)+end+++setmetatable(t, nil)+function f (t, ...) return t, {...} end+t.__call = f++do+  local x,y = a(table.unpack{'a', 1})+  assert(x==a and y[1]=='a' and y[2]==1 and y[3]==nil)+  x,y = a()+  assert(x==a and y[1]==nil)+end+++local b = setmetatable({}, t)+setmetatable(b,t)++function f(op)+  return function (...) cap = {[0] = op, ...} ; return (...) end+end+t.__add = f("add")+t.__sub = f("sub")+t.__mul = f("mul")+t.__div = f("div")+t.__mod = f("mod")+t.__unm = f("unm")+t.__pow = f("pow")+t.__len = f("len")++assert(b+5 == b)+assert(cap[0] == "add" and cap[1] == b and cap[2] == 5 and cap[3]==nil)+assert(b+'5' == b)+assert(cap[0] == "add" and cap[1] == b and cap[2] == '5' and cap[3]==nil)+assert(5+b == 5)+assert(cap[0] == "add" and cap[1] == 5 and cap[2] == b and cap[3]==nil)+assert('5'+b == '5')+assert(cap[0] == "add" and cap[1] == '5' and cap[2] == b and cap[3]==nil)+b=b-3; assert(getmetatable(b) == t)+assert(5-a == 5)+assert(cap[0] == "sub" and cap[1] == 5 and cap[2] == a and cap[3]==nil)+assert('5'-a == '5')+assert(cap[0] == "sub" and cap[1] == '5' and cap[2] == a and cap[3]==nil)+assert(a*a == a)+assert(cap[0] == "mul" and cap[1] == a and cap[2] == a and cap[3]==nil)+assert(a/0 == a)+assert(cap[0] == "div" and cap[1] == a and cap[2] == 0 and cap[3]==nil)+assert(a%2 == a)+assert(cap[0] == "mod" and cap[1] == a and cap[2] == 2 and cap[3]==nil)+assert(-a == a)+assert(cap[0] == "unm" and cap[1] == a)+assert(a^4 == a)+assert(cap[0] == "pow" and cap[1] == a and cap[2] == 4 and cap[3]==nil)+assert(a^'4' == a)+assert(cap[0] == "pow" and cap[1] == a and cap[2] == '4' and cap[3]==nil)+assert(4^a == 4)+assert(cap[0] == "pow" and cap[1] == 4 and cap[2] == a and cap[3]==nil)+assert('4'^a == '4')+assert(cap[0] == "pow" and cap[1] == '4' and cap[2] == a and cap[3]==nil)+assert(#a == a)+assert(cap[0] == "len" and cap[1] == a)+++-- test for rawlen+t = setmetatable({1,2,3}, {__len = function () return 10 end})+assert(#t == 10 and rawlen(t) == 3)+assert(rawlen"abc" == 3)+assert(not pcall(rawlen, io.stdin))+assert(not pcall(rawlen, 34))+assert(not pcall(rawlen))++t = {}+t.__lt = function (a,b,c)+  collectgarbage()+  assert(c == nil)+  if type(a) == 'table' then a = a.x end+  if type(b) == 'table' then b = b.x end+ return a<b, "dummy"+end++function Op(x) return setmetatable({x=x}, t) end++local function test ()+  assert(not(Op(1)<Op(1)) and (Op(1)<Op(2)) and not(Op(2)<Op(1)))+  assert(not(1 < Op(1)) and (Op(1) < 2) and not(2 < Op(1)))+  assert(not(Op('a')<Op('a')) and (Op('a')<Op('b')) and not(Op('b')<Op('a')))+  assert(not('a' < Op('a')) and (Op('a') < 'b') and not(Op('b') < Op('a')))+  assert((Op(1)<=Op(1)) and (Op(1)<=Op(2)) and not(Op(2)<=Op(1)))+  assert((Op('a')<=Op('a')) and (Op('a')<=Op('b')) and not(Op('b')<=Op('a')))+  assert(not(Op(1)>Op(1)) and not(Op(1)>Op(2)) and (Op(2)>Op(1)))+  assert(not(Op('a')>Op('a')) and not(Op('a')>Op('b')) and (Op('b')>Op('a')))+  assert((Op(1)>=Op(1)) and not(Op(1)>=Op(2)) and (Op(2)>=Op(1)))+  assert((1 >= Op(1)) and not(1 >= Op(2)) and (Op(2) >= 1))+  assert((Op('a')>=Op('a')) and not(Op('a')>=Op('b')) and (Op('b')>=Op('a')))+  assert(('a' >= Op('a')) and not(Op('a') >= 'b') and (Op('b') >= Op('a')))+end++test()++t.__le = function (a,b,c)+  assert(c == nil)+  if type(a) == 'table' then a = a.x end+  if type(b) == 'table' then b = b.x end+ return a<=b, "dummy"+end++test()  -- retest comparisons, now using both `lt' and `le'+++-- test `partial order'++local function Set(x)+  local y = {}+  for _,k in pairs(x) do y[k] = 1 end+  return setmetatable(y, t)+end++t.__lt = function (a,b)+  for k in pairs(a) do+    if not b[k] then return false end+    b[k] = nil+  end+  return next(b) ~= nil+end++t.__le = nil++assert(Set{1,2,3} < Set{1,2,3,4})+assert(not(Set{1,2,3,4} < Set{1,2,3,4}))+assert((Set{1,2,3,4} <= Set{1,2,3,4}))+assert((Set{1,2,3,4} >= Set{1,2,3,4}))+assert((Set{1,3} <= Set{3,5}))   -- wrong!! model needs a `le' method ;-)++t.__le = function (a,b)+  for k in pairs(a) do+    if not b[k] then return false end+  end+  return true+end++assert(not (Set{1,3} <= Set{3,5}))   -- now its OK!+assert(not(Set{1,3} <= Set{3,5}))+assert(not(Set{1,3} >= Set{3,5}))++t.__eq = function (a,b)+  for k in pairs(a) do+    if not b[k] then return false end+    b[k] = nil+  end+  return next(b) == nil+end++local s = Set{1,3,5}+assert(s == Set{3,5,1})+assert(not rawequal(s, Set{3,5,1}))+assert(rawequal(s, s))+assert(Set{1,3,5,1} == Set{3,5,1})+assert(Set{1,3,5} ~= Set{3,5,1,6})+t[Set{1,3,5}] = 1+assert(t[Set{1,3,5}] == nil)   -- `__eq' is not valid for table accesses+++t.__concat = function (a,b,c)+  assert(c == nil)+  if type(a) == 'table' then a = a.val end+  if type(b) == 'table' then b = b.val end+  if A then return a..b+  else+    return setmetatable({val=a..b}, t)+  end+end++c = {val="c"}; setmetatable(c, t)+d = {val="d"}; setmetatable(d, t)++A = true+assert(c..d == 'cd')+assert(0 .."a".."b"..c..d.."e".."f"..(5+3).."g" == "0abcdef8g")++A = false+assert((c..d..c..d).val == 'cdcd')+x = c..d+assert(getmetatable(x) == t and x.val == 'cd')+x = 0 .."a".."b"..c..d.."e".."f".."g"+assert(x.val == "0abcdefg")+++-- concat metamethod x numbers (bug in 5.1.1)+c = {}+local x+setmetatable(c, {__concat = function (a,b)+  assert(type(a) == "number" and b == c or type(b) == "number" and a == c)+  return c+end})+assert(c..5 == c and 5 .. c == c)+assert(4 .. c .. 5 == c and 4 .. 5 .. 6 .. 7 .. c == c)+++-- test comparison compatibilities+local t1, t2, c, d+t1 = {};  c = {}; setmetatable(c, t1)+d = {}+t1.__eq = function () return true end+t1.__lt = function () return true end+setmetatable(d, t1)+assert(c == d and c < d and not(d <= c))+t2 = {}+t2.__eq = t1.__eq+t2.__lt = t1.__lt+setmetatable(d, t2)+assert(c == d and c < d and not(d <= c))++++-- test for several levels of calls+local i+local tt = {+  __call = function (t, ...)+    i = i+1+    if t.f then return t.f(...)+    else return {...}+    end+  end+}++local a = setmetatable({}, tt)+local b = setmetatable({f=a}, tt)+local c = setmetatable({f=b}, tt)++i = 0+x = c(3,4,5)+assert(i == 3 and x[1] == 3 and x[3] == 5)+++assert(_G.X == 20)++print'+'++local _g = _G+_ENV = setmetatable({}, {__index=function (_,k) return _g[k] end})+++a = {}+rawset(a, "x", 1, 2, 3)+assert(a.x == 1 and rawget(a, "x", 3) == 1)++print '+'++-- testing metatables for basic types+local debug = require'debug'+mt = {}+debug.setmetatable(10, mt)+assert(getmetatable(-2) == mt)+mt.__index = function (a,b) return a+b end+assert((10)[3] == 13)+assert((10)["3"] == 13)+debug.setmetatable(23, nil)+assert(getmetatable(-2) == nil)++debug.setmetatable(true, mt)+assert(getmetatable(false) == mt)+mt.__index = function (a,b) return a or b end+assert((true)[false] == true)+assert((false)[false] == false)+debug.setmetatable(false, nil)+assert(getmetatable(true) == nil)++debug.setmetatable(nil, mt)+assert(getmetatable(nil) == mt)+mt.__add = function (a,b) return (a or 0) + (b or 0) end+assert(10 + nil == 10)+assert(nil + 23 == 23)+assert(nil + nil == 0)+debug.setmetatable(nil, nil)+assert(getmetatable(nil) == nil)++debug.setmetatable(nil, {})+++-- loops in delegation+a = {}; setmetatable(a, a); a.__index = a; a.__newindex = a+assert(not pcall(function (a,b) return a[b] end, a, 10))+assert(not pcall(function (a,b,c) a[b] = c end, a, 10, true))++-- bug in 5.1+T, K, V = nil+grandparent = {}+grandparent.__newindex = function(t,k,v) T=t; K=k; V=v end++parent = {}+parent.__newindex = parent+setmetatable(parent, grandparent)++child = setmetatable({}, parent)+child.foo = 10      --> CRASH (on some machines)+assert(T == parent and K == "foo" and V == 10)++print 'OK'++return 12++

@@ -0,0 +1,615 @@+debug = require "debug"++assert(type(os.getenv"PATH") == "string")++assert(io.input(io.stdin) == io.stdin)+assert(not pcall(io.input, "non-existent-file"))+assert(io.output(io.stdout) == io.stdout)++-- cannot close standard files+assert(not io.close(io.stdin) and+       not io.stdout:close() and+       not io.stderr:close())+++assert(type(io.input()) == "userdata" and io.type(io.output()) == "file")+assert(type(io.stdin) == "userdata" and io.type(io.stderr) == "file")+assert(io.type(8) == nil)+local a = {}; setmetatable(a, {})+assert(io.type(a) == nil)++local a,b,c = io.open('xuxu_nao_existe')+assert(not a and type(b) == "string" and type(c) == "number")++a,b,c = io.open('/a/b/c/d', 'w')+assert(not a and type(b) == "string" and type(c) == "number")++local file = os.tmpname()+local f, msg = io.open(file, "w")+if not f then+  (Message or print)("'os.tmpname' file cannot be open; skipping file tests")++else  --{  most tests here need tmpname+f:close()++print('testing i/o')++local otherfile = os.tmpname()++assert(not pcall(io.open, file, "rw"))     -- invalid mode+assert(not pcall(io.open, file, "rb+"))    -- invalid mode+assert(not pcall(io.open, file, "r+bk"))   -- invalid mode+assert(not pcall(io.open, file, ""))       -- invalid mode+assert(not pcall(io.open, file, "+"))      -- invalid mode+assert(not pcall(io.open, file, "b"))      -- invalid mode+assert(io.open(file, "r+b")):close()+assert(io.open(file, "r+")):close()+assert(io.open(file, "rb")):close()++assert(os.setlocale('C', 'all'))++io.input(io.stdin); io.output(io.stdout);++os.remove(file)+assert(loadfile(file) == nil)+assert(io.open(file) == nil)+io.output(file)+assert(io.output() ~= io.stdout)++assert(io.output():seek() == 0)+assert(io.write("alo alo"):seek() == string.len("alo alo"))+assert(io.output():seek("cur", -3) == string.len("alo alo")-3)+assert(io.write("joao"))+assert(io.output():seek("end") == string.len("alo joao"))++assert(io.output():seek("set") == 0)++assert(io.write('"álo"', "{a}\n", "second line\n", "third line \n"))+assert(io.write('çfourth_line'))+io.output(io.stdout)+collectgarbage()  -- file should be closed by GC+assert(io.input() == io.stdin and rawequal(io.output(), io.stdout))+print('+')++-- test GC for files+collectgarbage()+for i=1,120 do+  for i=1,5 do+    io.input(file)+    assert(io.open(file, 'r'))+    io.lines(file)+  end+  collectgarbage()+end++io.input():close()+io.close()++assert(os.rename(file, otherfile))+assert(os.rename(file, otherfile) == nil)++io.output(io.open(otherfile, "ab"))+assert(io.write("\n\n\t\t  3450\n"));+io.close()++-- test line generators+assert(not pcall(io.lines, "non-existent-file"))+assert(os.rename(otherfile, file))+io.output(otherfile)+local f = io.lines(file)+while f() do end;+assert(not pcall(f))  -- read lines after EOF+assert(not pcall(f))  -- read lines after EOF+-- copy from file to otherfile+for l in io.lines(file) do io.write(l, "\n") end+io.close()+-- copy from otherfile back to file+local f = assert(io.open(otherfile))+assert(io.type(f) == "file")+io.output(file)+assert(io.output():read() == nil)+for l in f:lines() do io.write(l, "\n") end+assert(tostring(f):sub(1, 5) == "file ")+assert(f:close()); io.close()+assert(not pcall(io.close, f))   -- error trying to close again+assert(tostring(f) == "file (closed)")+assert(io.type(f) == "closed file")+io.input(file)+f = io.open(otherfile):lines()+for l in io.lines() do assert(l == f()) end+f = nil; collectgarbage()+assert(os.remove(otherfile))++io.input(file)+do  -- test error returns+  local a,b,c = io.input():write("xuxu")+  assert(not a and type(b) == "string" and type(c) == "number")+end+assert(io.read(0) == "")   -- not eof+assert(io.read(5, '*l') == '"álo"')+assert(io.read(0) == "")+assert(io.read() == "second line")+local x = io.input():seek()+assert(io.read() == "third line ")+assert(io.input():seek("set", x))+assert(io.read('*L') == "third line \n")+assert(io.read(1) == "ç")+assert(io.read(string.len"fourth_line") == "fourth_line")+assert(io.input():seek("cur", -string.len"fourth_line"))+assert(io.read() == "fourth_line")+assert(io.read() == "")  -- empty line+assert(io.read('*n') == 3450)+assert(io.read(1) == '\n')+assert(io.read(0) == nil)  -- end of file+assert(io.read(1) == nil)  -- end of file+assert(io.read(30000) == nil)  -- end of file+assert(({io.read(1)})[2] == nil)+assert(io.read() == nil)  -- end of file+assert(({io.read()})[2] == nil)+assert(io.read('*n') == nil)  -- end of file+assert(({io.read('*n')})[2] == nil)+assert(io.read('*a') == '')  -- end of file (OK for `*a')+assert(io.read('*a') == '')  -- end of file (OK for `*a')+collectgarbage()+print('+')+io.close(io.input())+assert(not pcall(io.read))++assert(os.remove(file))++local t = '0123456789'+for i=1,12 do t = t..t; end+assert(string.len(t) == 10*2^12)++io.output(file)+io.write("alo"):write("\n")+io.close()+assert(not pcall(io.write))+local f = io.open(file, "a+b")+io.output(f)+collectgarbage()++assert(io.write(' ' .. t .. ' '))+assert(io.write(';', 'end of file\n'))+f:flush(); io.flush()+f:close()+print('+')++io.input(file)+assert(io.read() == "alo")+assert(io.read(1) == ' ')+assert(io.read(string.len(t)) == t)+assert(io.read(1) == ' ')+assert(io.read(0))+assert(io.read('*a') == ';end of file\n')+assert(io.read(0) == nil)+assert(io.close(io.input()))+++-- test errors in read/write+do+  local function ismsg (m)+    -- error message is not a code number+    return (type(m) == "string" and tonumber(m) == nil)+  end++  -- read+  local f = io.open(file, "w")+  local r, m, c = f:read()+  assert(r == nil and ismsg(m) and type(c) == "number")+  assert(f:close())+  -- write+  f = io.open(file, "r")+  r, m, c = f:write("whatever")+  assert(r == nil and ismsg(m) and type(c) == "number")+  assert(f:close())+  -- lines+  f = io.open(file, "w")+  r, m = pcall(f:lines())+  assert(r == false and ismsg(m))+  assert(f:close())+end++assert(os.remove(file))++-- test for *L format+io.output(file); io.write"\n\nline\nother":close()+io.input(file)+assert(io.read"*L" == "\n")+assert(io.read"*L" == "\n")+assert(io.read"*L" == "line\n")+assert(io.read"*L" == "other")+assert(io.read"*L" == nil)+io.input():close()++local f = assert(io.open(file))+local s = ""+for l in f:lines("*L") do s = s .. l end+assert(s == "\n\nline\nother")+f:close()++io.input(file)+s = ""+for l in io.lines(nil, "*L") do s = s .. l end+assert(s == "\n\nline\nother")+io.input():close()++s = ""+for l in io.lines(file, "*L") do s = s .. l end+assert(s == "\n\nline\nother")++s = ""+for l in io.lines(file, "*l") do s = s .. l end+assert(s == "lineother")++io.output(file); io.write"a = 10 + 34\na = 2*a\na = -a\n":close()+local t = {}+load(io.lines(file, "*L"), nil, nil, t)()+assert(t.a == -((10 + 34) * 2))+++-- test for multipe arguments in 'lines'+io.output(file); io.write"0123456789\n":close()+for a,b in io.lines(file, 1, 1) do+  if a == "\n" then assert(b == nil)+  else assert(tonumber(a) == b - 1)+  end+end++for a,b,c in io.lines(file, 1, 2, "*a") do+  assert(a == "0" and b == "12" and c == "3456789\n")+end++for a,b,c in io.lines(file, "*a", 0, 1) do+  if a == "" then break end+  assert(a == "0123456789\n" and b == nil and c == nil)+end+collectgarbage()   -- to close file in previous iteration++io.output(file); io.write"00\n10\n20\n30\n40\n":close()+for a, b in io.lines(file, "*n", "*n") do+  if a == 40 then assert(b == nil)+  else assert(a == b - 10)+  end+end+++-- test load x lines+io.output(file);+io.write[[+local y+= X+X =+X *+2 ++X;+X =+X+-                                   y;+]]:close()+_G.X = 1+assert(not load(io.lines(file)))+collectgarbage()   -- to close file in previous iteration+load(io.lines(file, "*L"))()+assert(_G.X == 2)+load(io.lines(file, 1))()+assert(_G.X == 4)+load(io.lines(file, 3))()+assert(_G.X == 8)++print('+')++local x1 = "string\n\n\\com \"\"''coisas [[estranhas]] ]]'"+io.output(file)+assert(io.write(string.format("x2 = %q\n-- comment without ending EOS", x1)))+io.close()+assert(loadfile(file))()+assert(x1 == x2)+print('+')+assert(os.remove(file))+assert(os.remove(file) == nil)+assert(os.remove(otherfile) == nil)++-- testing loadfile+local function testloadfile (s, expres)+  io.output(file)+  if s then io.write(s) end+  io.close()+  local res = assert(loadfile(file))()+  assert(os.remove(file))+  assert(res == expres)+end++-- loading empty file+testloadfile(nil, nil)++-- loading file with initial comment without end of line+testloadfile("# a non-ending comment", nil)+++-- checking Unicode BOM in files+testloadfile("\xEF\xBB\xBF# some comment\nreturn 234", 234)+testloadfile("\xEF\xBB\xBFreturn 239", 239)+testloadfile("\xEF\xBB\xBF", nil)   -- empty file with a BOM+++-- checking line numbers in files with initial comments+testloadfile("# a comment\nreturn debug.getinfo(1).currentline", 2)+++-- loading binary file+io.output(io.open(file, "wb"))+assert(io.write(string.dump(function () return 10, '\0alo\255', 'hi' end)))+io.close()+a, b, c = assert(loadfile(file))()+assert(a == 10 and b == "\0alo\255" and c == "hi")+assert(os.remove(file))++-- bug in 5.2.1+do+  io.output(io.open(file, "wb"))+  -- save function with no upvalues+  assert(io.write(string.dump(function () return 1 end)))+  io.close()+  f = assert(loadfile(file, "b", {}))+  assert(type(f) == "function" and f() == 1)+  assert(os.remove(file))+end++-- loading binary file with initial comment+io.output(io.open(file, "wb"))+assert(io.write("#this is a comment for a binary file\0\n",+                string.dump(function () return 20, '\0\0\0' end)))+io.close()+a, b, c = assert(loadfile(file))()+assert(a == 20 and b == "\0\0\0" and c == nil)+assert(os.remove(file))+++-- 'loadfile' with 'env'+do+  local f = io.open(file, 'w')+  f:write[[+    if (...) then a = 15; return b, c, d+    else return _ENV+    end+  ]]+  f:close()+  local t = {b = 12, c = "xuxu", d = print}+  local f = assert(loadfile(file, 't', t))+  local b, c, d = f(1)+  assert(t.a == 15 and b == 12 and c == t.c and d == print)+  assert(f() == t)+  f = assert(loadfile(file, 't', nil))+  assert(f() == nil)+  f = assert(loadfile(file))+  assert(f() == _G)+  assert(os.remove(file))+end+++-- 'loadfile' x modes+do+  io.open(file, 'w'):write("return 10"):close()+  local s, m = loadfile(file, 'b')+  assert(not s and string.find(m, "a text chunk"))+  io.open(file, 'w'):write("\27 return 10"):close()+  local s, m = loadfile(file, 't')+  assert(not s and string.find(m, "a binary chunk"))+  assert(os.remove(file))+end+++io.output(file)+assert(io.write("qualquer coisa\n"))+assert(io.write("mais qualquer coisa"))+io.close()+assert(io.output(assert(io.open(otherfile, 'wb')))+       :write("outra coisa\0\1\3\0\0\0\0\255\0")+       :close())++local filehandle = assert(io.open(file, 'r+'))+local otherfilehandle = assert(io.open(otherfile, 'rb'))+assert(filehandle ~= otherfilehandle)+assert(type(filehandle) == "userdata")+assert(filehandle:read('*l') == "qualquer coisa")+io.input(otherfilehandle)+assert(io.read(string.len"outra coisa") == "outra coisa")+assert(filehandle:read('*l') == "mais qualquer coisa")+filehandle:close();+assert(type(filehandle) == "userdata")+io.input(otherfilehandle)+assert(io.read(4) == "\0\1\3\0")+assert(io.read(3) == "\0\0\0")+assert(io.read(0) == "")        -- 255 is not eof+assert(io.read(1) == "\255")+assert(io.read('*a') == "\0")+assert(not io.read(0))+assert(otherfilehandle == io.input())+otherfilehandle:close()+assert(os.remove(file))+assert(os.remove(otherfile))+collectgarbage()++io.output(file)+  :write[[+ 123.4	-56e-2  not a number+second line+third line++and the rest of the file+]]+  :close()+io.input(file)+local _,a,b,c,d,e,h,__ = io.read(1, '*n', '*n', '*l', '*l', '*l', '*a', 10)+assert(io.close(io.input()))+assert(_ == ' ' and __ == nil)+assert(type(a) == 'number' and a==123.4 and b==-56e-2)+assert(d=='second line' and e=='third line')+assert(h==[[++and the rest of the file+]])+assert(os.remove(file))+collectgarbage()++-- testing buffers+do+  local f = assert(io.open(file, "w"))+  local fr = assert(io.open(file, "r"))+  assert(f:setvbuf("full", 2000))+  f:write("x")+  assert(fr:read("*all") == "")  -- full buffer; output not written yet+  f:close()+  fr:seek("set")+  assert(fr:read("*all") == "x")   -- `close' flushes it+  f = assert(io.open(file), "w")+  assert(f:setvbuf("no"))+  f:write("x")+  fr:seek("set")+  assert(fr:read("*all") == "x")  -- no buffer; output is ready+  f:close()+  f = assert(io.open(file, "a"))+  assert(f:setvbuf("line"))+  f:write("x")+  fr:seek("set", 1)+  assert(fr:read("*all") == "")   -- line buffer; no output without `\n'+  f:write("a\n"):seek("set", 1)+  assert(fr:read("*all") == "xa\n")  -- now we have a whole line+  f:close(); fr:close()+  assert(os.remove(file))+end+++if not _soft then+  print("testing large files (> BUFSIZ)")+  io.output(file)+  for i=1,5001 do io.write('0123456789123') end+  io.write('\n12346'):close()+  io.input(file)+  local x = io.read('*a')+  io.input():seek('set', 0)+  local y = io.read(30001)..io.read(1005)..io.read(0)..+            io.read(1)..io.read(100003)+  assert(x == y and string.len(x) == 5001*13 + 6)+  io.input():seek('set', 0)+  y = io.read()  -- huge line+  assert(x == y..'\n'..io.read())+  assert(io.read() == nil)+  io.close(io.input())+  assert(os.remove(file))+  x = nil; y = nil+end++if not _noposix then+  print("testing popen/pclose and execute")+  local tests = {+    -- command,   what,  code+    {"ls > /dev/null", "ok"},+    {"not-to-be-found-command", "exit"},+    {"exit 3", "exit", 3},+    {"exit 129", "exit", 129},+    {"kill -s HUP $$", "signal", 1},+    {"kill -s KILL $$", "signal", 9},+    {"sh -c 'kill -s HUP $$'", "exit"},+    {'lua -e "os.exit(20, true)"', "exit", 20},+  }+  print("\n(some error messages are expected now)")+  for _, v in ipairs(tests) do+    local x, y, z = io.popen(v[1]):close()+    local x1, y1, z1 = os.execute(v[1])+    assert(x == x1 and y == y1 and z == z1)+    if v[2] == "ok" then+      assert(x == true and y == 'exit' and z == 0)+    else+      assert(x == nil and y == v[2])   -- correct status and 'what'+      -- correct code if known (but always different from 0)+      assert((v[3] == nil and z > 0) or v[3] == z)+    end+  end+end+++-- testing tmpfile+f = io.tmpfile()+assert(io.type(f) == "file")+f:write("alo")+f:seek("set")+assert(f:read"*a" == "alo")++end --}++print'+'+++assert(os.date("") == "")+assert(os.date("!") == "")+local x = string.rep("a", 10000)+assert(os.date(x) == x)+local t = os.time()+D = os.date("*t", t)+assert(os.date(string.rep("%d", 1000), t) ==+       string.rep(os.date("%d", t), 1000))+assert(os.date(string.rep("%", 200)) == string.rep("%", 100))++local t = os.time()+D = os.date("*t", t)+load(os.date([[assert(D.year==%Y and D.month==%m and D.day==%d and+  D.hour==%H and D.min==%M and D.sec==%S and+  D.wday==%w+1 and D.yday==%j and type(D.isdst) == 'boolean')]], t))()++assert(not pcall(os.date, "%9"))   -- invalid conversion specifier+assert(not pcall(os.date, "%"))   -- invalid conversion specifier+assert(not pcall(os.date, "%O"))   -- invalid conversion specifier+assert(not pcall(os.date, "%E"))   -- invalid conversion specifier+assert(not pcall(os.date, "%Ea"))   -- invalid conversion specifier++if not _noposix then+  assert(type(os.date("%Ex")) == 'string')+  assert(type(os.date("%Oy")) == 'string')+end++assert(os.time(D) == t)+assert(not pcall(os.time, {hour = 12}))++D = os.date("!*t", t)+load(os.date([[!assert(D.year==%Y and D.month==%m and D.day==%d and+  D.hour==%H and D.min==%M and D.sec==%S and+  D.wday==%w+1 and D.yday==%j and type(D.isdst) == 'boolean')]], t))()++do+  local D = os.date("*t")+  local t = os.time(D)+  assert(type(D.isdst) == 'boolean')+  D.isdst = nil+  local t1 = os.time(D)+  assert(t == t1)   -- if isdst is absent uses correct default+end++t = os.time(D)+D.year = D.year-1;+local t1 = os.time(D)+-- allow for leap years+assert(math.abs(os.difftime(t,t1)/(24*3600) - 365) < 2)++t = os.time()+t1 = os.time(os.date("*t"))+assert(os.difftime(t1,t) <= 2)++local t1 = os.time{year=2000, month=10, day=1, hour=23, min=12}+local t2 = os.time{year=2000, month=10, day=1, hour=23, min=10, sec=19}+assert(os.difftime(t1,t2) == 60*2-19)++io.output(io.stdout)+local d = os.date('%d')+local m = os.date('%m')+local a = os.date('%Y')+local ds = os.date('%w') + 1+local h = os.date('%H')+local min = os.date('%M')+local s = os.date('%S')+io.write(string.format('test done on %2.2d/%2.2d/%d', d, m, a))+io.write(string.format(', at %2.2d:%2.2d:%2.2d\n', h, min, s))+io.write(string.format('%s\n', _VERSION))++

@@ -0,0 +1,575 @@+print('testing garbage collection')++collectgarbage()++assert(collectgarbage("isrunning"))++local function gcinfo () return collectgarbage"count" * 1024 end+++-- test weird parameters+do+  -- save original parameters+  local a = collectgarbage("setpause", 200)+  local b = collectgarbage("setstepmul", 200)+  local t = {0, 2, 10, 90, 500, 5000, 30000, 2^31 - 2}+  for i = 1, #t do+    local p = t[i]+    for j = 1, #t do+      local m = t[j]+      collectgarbage("setpause", p)+      collectgarbage("setstepmul", m)+      collectgarbage("step", 0)+      collectgarbage("step", 10000)+    end+  end+  -- restore original parameters+  collectgarbage("setpause", a)+  collectgarbage("setstepmul", b)+  collectgarbage()+end+++_G["while"] = 234++limit = 5000+++local function GC1 ()+  local u+  local b     -- must be declared after 'u' (to be above it in the stack)+  local finish = false+  u = setmetatable({}, {__gc = function () finish = true end})+  b = {34}+  repeat u = {} until finish+  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not++  finish = false; local i = 1+  u = setmetatable({}, {__gc = function () finish = true end})+  repeat i = i + 1; u = i .. i until finish+  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not++  finish = false+  u = setmetatable({}, {__gc = function () finish = true end})+  repeat local i; u = function () return i end until finish+  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not+end++local function GC()  GC1(); GC1() end+++contCreate = 0++print('tables')+while contCreate <= limit do+  local a = {}; a = nil+  contCreate = contCreate+1+end++a = "a"++contCreate = 0+print('strings')+while contCreate <= limit do+  a = contCreate .. "b";+  a = string.gsub(a, '(%d%d*)', string.upper)+  a = "a"+  contCreate = contCreate+1+end+++contCreate = 0++a = {}++print('functions')+function a:test ()+  while contCreate <= limit do+    load(string.format("function temp(a) return 'a%d' end", contCreate))()+    assert(temp() == string.format('a%d', contCreate))+    contCreate = contCreate+1+  end+end++a:test()++-- collection of functions without locals, globals, etc.+do local f = function () end end+++print("functions with errors")+prog = [[+do+  a = 10;+  function foo(x,y)+    a = sin(a+0.456-0.23e-12);+    return function (z) return sin(%x+z) end+  end+  local x = function (w) a=a+w; end+end+]]+do+  local step = 1+  if _soft then step = 13 end+  for i=1, string.len(prog), step do+    for j=i, string.len(prog), step do+      pcall(load(string.sub(prog, i, j)))+    end+  end+end++foo = nil+print('long strings')+x = "01234567890123456789012345678901234567890123456789012345678901234567890123456789"+assert(string.len(x)==80)+s = ''+n = 0+k = 300+while n < k do s = s..x; n=n+1; j=tostring(n)  end+assert(string.len(s) == k*80)+s = string.sub(s, 1, 20000)+s, i = string.gsub(s, '(%d%d%d%d)', math.sin)+assert(i==20000/4)+s = nil+x = nil++assert(_G["while"] == 234)++local k,b = collectgarbage("count")+assert(k*1024 == math.floor(k)*1024 + b)++print("steps")++local bytes = gcinfo()+while 1 do+  local nbytes = gcinfo()+  if nbytes < bytes then break end   -- run until gc+  bytes = nbytes+  a = {}+end++print("steps (2)")++local function dosteps (siz)+  assert(not collectgarbage("isrunning"))+  collectgarbage()+  assert(not collectgarbage("isrunning"))+  local a = {}+  for i=1,100 do a[i] = {{}}; local b = {} end+  local x = gcinfo()+  local i = 0+  repeat   -- do steps until it completes a collection cycle+    i = i+1+  until collectgarbage("step", siz)+  assert(gcinfo() < x)+  return i+end++collectgarbage"stop"++if not _port then+  -- test the "size" of basic GC steps (whatever they mean...)+  assert(dosteps(0) > 10)+  assert(dosteps(10) < dosteps(2))+end++-- collector should do a full collection with so many steps+assert(dosteps(100000) == 1)+assert(collectgarbage("step", 1000000) == true)+assert(collectgarbage("step", 1000000) == true)++assert(not collectgarbage("isrunning"))+collectgarbage"restart"+assert(collectgarbage("isrunning"))+++if not _port then+  -- test the pace of the collector+  collectgarbage(); collectgarbage()+  local x = gcinfo()+  collectgarbage"stop"+  assert(not collectgarbage("isrunning"))+  repeat+    local a = {}+  until gcinfo() > 3 * x+  collectgarbage"restart"+  assert(collectgarbage("isrunning"))+  repeat+    local a = {}+  until gcinfo() <= x * 2+end+++print("clearing tables")+lim = 15+a = {}+-- fill a with `collectable' indices+for i=1,lim do a[{}] = i end+b = {}+for k,v in pairs(a) do b[k]=v end+-- remove all indices and collect them+for n in pairs(b) do+  a[n] = nil+  assert(type(n) == 'table' and next(n) == nil)+  collectgarbage()+end+b = nil+collectgarbage()+for n in pairs(a) do error'cannot be here' end+for i=1,lim do a[i] = i end+for i=1,lim do assert(a[i] == i) end+++print('weak tables')+a = {}; setmetatable(a, {__mode = 'k'});+-- fill a with some `collectable' indices+for i=1,lim do a[{}] = i end+-- and some non-collectable ones+for i=1,lim do a[i] = i end+for i=1,lim do local s=string.rep('@', i); a[s] = s..'#' end+collectgarbage()+local i = 0+for k,v in pairs(a) do assert(k==v or k..'#'==v); i=i+1 end+assert(i == 2*lim)++a = {}; setmetatable(a, {__mode = 'v'});+a[1] = string.rep('b', 21)+collectgarbage()+assert(a[1])   -- strings are *values*+a[1] = nil+-- fill a with some `collectable' values (in both parts of the table)+for i=1,lim do a[i] = {} end+for i=1,lim do a[i..'x'] = {} end+-- and some non-collectable ones+for i=1,lim do local t={}; a[t]=t end+for i=1,lim do a[i+lim]=i..'x' end+collectgarbage()+local i = 0+for k,v in pairs(a) do assert(k==v or k-lim..'x' == v); i=i+1 end+assert(i == 2*lim)++a = {}; setmetatable(a, {__mode = 'vk'});+local x, y, z = {}, {}, {}+-- keep only some items+a[1], a[2], a[3] = x, y, z+a[string.rep('$', 11)] = string.rep('$', 11)+-- fill a with some `collectable' values+for i=4,lim do a[i] = {} end+for i=1,lim do a[{}] = i end+for i=1,lim do local t={}; a[t]=t end+collectgarbage()+assert(next(a) ~= nil)+local i = 0+for k,v in pairs(a) do+  assert((k == 1 and v == x) or+         (k == 2 and v == y) or+         (k == 3 and v == z) or k==v);+  i = i+1+end+assert(i == 4)+x,y,z=nil+collectgarbage()+assert(next(a) == string.rep('$', 11))+++-- 'bug' in 5.1+a = {}+local t = {x = 10}+local C = setmetatable({key = t}, {__mode = 'v'})+local C1 = setmetatable({[t] = 1}, {__mode = 'k'})+a.x = t  -- this should not prevent 't' from being removed from+         -- weak table 'C' by the time 'a' is finalized++setmetatable(a, {__gc = function (u)+                          assert(C.key == nil)+                          assert(type(next(C1)) == 'table')+                          end})++a, t = nil+collectgarbage()+collectgarbage()+assert(next(C) == nil and next(C1) == nil)+C, C1 = nil+++-- ephemerons+local mt = {__mode = 'k'}+a = {10,20,30,40}; setmetatable(a, mt)+x = nil+for i = 1, 100 do local n = {}; a[n] = {k = {x}}; x = n end+GC()+local n = x+local i = 0+while n do n = a[n].k[1]; i = i + 1 end+assert(i == 100)+x = nil+GC()+for i = 1, 4 do assert(a[i] == i * 10); a[i] = nil end+assert(next(a) == nil)++local K = {}+a[K] = {}+for i=1,10 do a[K][i] = {}; a[a[K][i]] = setmetatable({}, mt) end+x = nil+local k = 1+for j = 1,100 do+  local n = {}; local nk = k%10 + 1+  a[a[K][nk]][n] = {x, k = k}; x = n; k = nk+end+GC()+local n = x+local i = 0+while n do local t = a[a[K][k]][n]; n = t[1]; k = t.k; i = i + 1 end+assert(i == 100)+K = nil+GC()+assert(next(a) == nil)+++-- testing errors during GC+do+collectgarbage("stop")   -- stop collection+local u = {}+local s = {}; setmetatable(s, {__mode = 'k'})+setmetatable(u, {__gc = function (o)+  local i = s[o]+  s[i] = true+  assert(not s[i - 1])   -- check proper finalization order+  if i == 8 then error("here") end   -- error during GC+end})++for i = 6, 10 do+  local n = setmetatable({}, getmetatable(u))+  s[n] = i+end++assert(not pcall(collectgarbage))+for i = 8, 10 do assert(s[i]) end++for i = 1, 5 do+  local n = setmetatable({}, getmetatable(u))+  s[n] = i+end++collectgarbage()+for i = 1, 10 do assert(s[i]) end++getmetatable(u).__gc = false+++-- __gc errors with non-string messages+setmetatable({}, {__gc = function () error{} end})+local a, b = pcall(collectgarbage)+assert(not a and type(b) == "string" and string.find(b, "error in __gc"))++end+print '+'+++-- testing userdata+if T==nil then+  (Message or print)('\a\n >>> testC not active: skipping userdata GC tests <<<\n\a')++else++  local function newproxy(u)+    return debug.setmetatable(T.newuserdata(0), debug.getmetatable(u))+  end++  collectgarbage("stop")   -- stop collection+  local u = newproxy(nil)+  debug.setmetatable(u, {__gc = true})+  local s = 0+  local a = {[u] = 0}; setmetatable(a, {__mode = 'vk'})+  for i=1,10 do a[newproxy(u)] = i end+  for k in pairs(a) do assert(getmetatable(k) == getmetatable(u)) end+  local a1 = {}; for k,v in pairs(a) do a1[k] = v end+  for k,v in pairs(a1) do a[v] = k end+  for i =1,10 do assert(a[i]) end+  getmetatable(u).a = a1+  getmetatable(u).u = u+  do+    local u = u+    getmetatable(u).__gc = function (o)+      assert(a[o] == 10-s)+      assert(a[10-s] == nil) -- udata already removed from weak table+      assert(getmetatable(o) == getmetatable(u))+    assert(getmetatable(o).a[o] == 10-s)+      s=s+1+    end+  end+  a1, u = nil+  assert(next(a) ~= nil)+  collectgarbage()+  assert(s==11)+  collectgarbage()+  assert(next(a) == nil)  -- finalized keys are removed in two cycles+end+++-- __gc x weak tables+local u = setmetatable({}, {__gc = true})+-- __gc metamethod should be collected before running+setmetatable(getmetatable(u), {__mode = "v"})+getmetatable(u).__gc = function (o) os.exit(1) end  -- cannot happen+u = nil+collectgarbage()++local u = setmetatable({}, {__gc = true})+local m = getmetatable(u)+m.x = {[{0}] = 1; [0] = {1}}; setmetatable(m.x, {__mode = "kv"});+m.__gc = function (o)+  assert(next(getmetatable(o).x) == nil)+  m = 10+end+u, m = nil+collectgarbage()+assert(m==10)+++-- errors during collection+u = setmetatable({}, {__gc = function () error "!!!" end})+u = nil+assert(not pcall(collectgarbage))+++if not _soft then+  print("deep structures")+  local a = {}+  for i = 1,200000 do+    a = {next = a}+  end+  collectgarbage()+end++-- create many threads with self-references and open upvalues+local thread_id = 0+local threads = {}++local function fn (thread)+    local x = {}+    threads[thread_id] = function()+                             thread = x+                         end+    coroutine.yield()+end++while thread_id < 1000 do+    local thread = coroutine.create(fn)+    coroutine.resume(thread, thread)+    thread_id = thread_id + 1+end++do+  collectgarbage()+  collectgarbage"stop"+  local x = gcinfo()+  repeat+    for i=1,1000 do _ENV.a = {} end+    collectgarbage("step", 1)   -- steps should not unblock the collector+  until gcinfo() > 2 * x+  collectgarbage"restart"+end+++if T then   -- tests for weird cases collecting upvalues+  local a = 1200+  local f = function () return a end    -- create upvalue for 'a'+  assert(f() == 1200)++  -- erase reference to upvalue 'a', mark it as dead, but does not collect it+  T.gcstate("pause"); collectgarbage("stop")+  f = nil+  T.gcstate("sweepstring")++  -- this function will reuse that dead upvalue...+  f = function () return a end+  assert(f() == 1200)++  -- create coroutine with local variable 'b'+  local co = coroutine.wrap(function()+    local b = 150+    coroutine.yield(function () return b end)+  end)++  T.gcstate("pause")+  assert(co()() == 150)  -- create upvalue for 'b'++  -- mark upvalue 'b' as dead, but does not collect it+  T.gcstate("sweepstring")++  co()   -- finish coroutine, "closing" that dead upvalue++  assert(f() == 1200)+  collectgarbage("restart")++  print"+"+end+++if T then+  local debug = require "debug"+  collectgarbage("generational"); collectgarbage("stop")+  x = T.newuserdata(0)+  T.gcstate("propagate")    -- ensure 'x' is old+  T.gcstate("sweepstring")+  T.gcstate("propagate")+  assert(string.find(T.gccolor(x), "/old"))+  local y = T.newuserdata(0)+  debug.setmetatable(y, {__gc = true})   -- bless the new udata before...+  debug.setmetatable(x, {__gc = true})   -- ...the old one+  assert(string.find(T.gccolor(y), "white"))+  T.checkmemory()+  collectgarbage("incremental"); collectgarbage("restart")+end+++if T then+  print("emergency collections")+  collectgarbage()+  collectgarbage()+  T.totalmem(T.totalmem() + 200)+  for i=1,200 do local a = {} end+  T.totalmem(1000000000)+  collectgarbage()+  local t = T.totalmem("table")+  local a = {{}, {}, {}}   -- create 4 new tables+  assert(T.totalmem("table") == t + 4)+  t = T.totalmem("function")+  a = function () end   -- create 1 new closure+  assert(T.totalmem("function") == t + 1)+  t = T.totalmem("thread")+  a = coroutine.create(function () end)   -- create 1 new coroutine+  assert(T.totalmem("thread") == t + 1)+end++-- create an object to be collected when state is closed+do+  local setmetatable,assert,type,print,getmetatable =+        setmetatable,assert,type,print,getmetatable+  local tt = {}+  tt.__gc = function (o)+    assert(getmetatable(o) == tt)+    -- create new objects during GC+    local a = 'xuxu'..(10+3)..'joao', {}+    ___Glob = o  -- ressurect object!+    setmetatable({}, tt)  -- creates a new one with same metatable+    print(">>> closing state " .. "<<<\n")+  end+  local u = setmetatable({}, tt)+  ___Glob = {u}   -- avoid object being collected before program end+end++-- create several objects to raise errors when collected while closing state+do+  local mt = {__gc = function (o) return o + 1 end}+  for i = 1,10 do+    -- create object and preserve it until the end+    table.insert(___Glob, setmetatable({}, mt))+  end+end++-- just to make sure+assert(collectgarbage'isrunning')++print('OK')

@@ -0,0 +1,173 @@+local function errmsg (code, m)+  local st, msg = load(code)+  assert(not st and string.find(msg, m))+end++-- cannot see label inside block+errmsg([[ goto l1; do ::l1:: end ]], "label 'l1'")+errmsg([[ do ::l1:: end goto l1; ]], "label 'l1'")++-- repeated label+errmsg([[ ::l1:: ::l1:: ]], "label 'l1'")+++-- undefined label+errmsg([[ goto l1; local aa ::l1:: ::l2:: print(3) ]], "local 'aa'")++-- jumping over variable definition+errmsg([[+do local bb, cc; goto l1; end+local aa+::l1:: print(3)+]], "local 'aa'")++-- jumping into a block+errmsg([[ do ::l1:: end goto l1 ]], "label 'l1'")+errmsg([[ goto l1 do ::l1:: end ]], "label 'l1'")++-- cannot continue a repeat-until with variables+errmsg([[+  repeat+    if x then goto cont end+    local xuxu = 10+    ::cont::+  until xuxu < x+]], "local 'xuxu'")++-- simple gotos+local x+do+  local y = 12+  goto l1+  ::l2:: x = x + 1; goto l3+  ::l1:: x = y; goto l2+end+::l3:: ::l3_1:: assert(x == 13)+++-- long labels+do+  local prog = [[+  do+    local a = 1+    goto l%sa; a = a + 1+   ::l%sa:: a = a + 10+    goto l%sb; a = a + 2+   ::l%sb:: a = a + 20+    return a+  end+  ]]+  local label = string.rep("0123456789", 40)+  prog = string.format(prog, label, label, label, label)+  assert(assert(load(prog))() == 31)+end++-- goto to correct label when nested+do goto l3; ::l3:: end   -- does not loop jumping to previous label 'l3'++-- ok to jump over local dec. to end of block+do+  goto l1+  local a = 23+  x = a+  ::l1::;+end++while true do+  goto l4+  goto l1  -- ok to jump over local dec. to end of block+  goto l1  -- multiple uses of same label+  local x = 45+  ::l1:: ;;;+end+::l4:: assert(x == 13)++if print then+  goto l1   -- ok to jump over local dec. to end of block+  error("should not be here")+  goto l2   -- ok to jump over local dec. to end of block+  local x+  ::l1:: ; ::l2:: ;;+else end++-- to repeat a label in a different function is OK+local function foo ()+  local a = {}+  goto l3+  ::l1:: a[#a + 1] = 1; goto l2;+  ::l2:: a[#a + 1] = 2; goto l5;+  ::l3::+  ::l3a:: a[#a + 1] = 3; goto l1;+  ::l4:: a[#a + 1] = 4; goto l6;+  ::l5:: a[#a + 1] = 5; goto l4;+  ::l6:: assert(a[1] == 3 and a[2] == 1 and a[3] == 2 and+              a[4] == 5 and a[5] == 4)+  if not a[6] then a[6] = true; goto l3a end   -- do it twice+end++::l6:: foo()++++--------------------------------------------------------------------------------+-- testing closing of upvalues++local function foo ()+  local a = {}+  do+  local i = 1+  local k = 0+  a[0] = function (y) k = y end+  ::l1:: do+    local x+    if i > 2 then goto l2 end+    a[i] = function (y) if y then x = y else return x + k end end+    i = i + 1+    goto l1+  end+  end+  ::l2:: return a+end++local a = foo()+a[1](10); a[2](20)+assert(a[1]() == 10 and a[2]() == 20 and a[3] == nil)+a[0](13)+assert(a[1]() == 23 and a[2]() == 33)++--------------------------------------------------------------------------------+-- testing if x goto optimizations++local function testG (a)+  if a == 1 then+    goto l1+    error("should never be here!")+  elseif a == 2 then goto l2+  elseif a == 3 then goto l3+  elseif a == 4 then+    goto l1  -- go to inside the block+    error("should never be here!")+    ::l1:: a = a + 1   -- must go to 'if' end+  else+    goto l4+    ::l4a:: a = a * 2; goto l4b+    error("should never be here!")+    ::l4:: goto l4a+    error("should never be here!")+    ::l4b::+  end+  do return a end+  ::l2:: do return "2" end+  ::l3:: do return "3" end+  ::l1:: return "1"+end++assert(testG(1) == "1")+assert(testG(2) == "2")+assert(testG(3) == "3")+assert(testG(4) == 5)+assert(testG(5) == 10)+--------------------------------------------------------------------------------+++print'OK'

@@ -0,0 +1,258 @@+print('testing scanner')++debug = require "debug"+++local function dostring (x) return assert(load(x))() end++dostring("x \v\f = \t\r 'a\0a' \v\f\f")+assert(x == 'a\0a' and string.len(x) == 3)++-- escape sequences+assert('\n\"\'\\' == [[++"'\]])++assert(string.find("\a\b\f\n\r\t\v", "^%c%c%c%c%c%c%c$"))++-- assume ASCII just for tests:+assert("\09912" == 'c12')+assert("\99ab" == 'cab')+assert("\099" == '\99')+assert("\099\n" == 'c\10')+assert('\0\0\0alo' == '\0' .. '\0\0' .. 'alo')++assert(010 .. 020 .. -030 == "1020-30")++-- hexadecimal escapes+assert("\x00\x05\x10\x1f\x3C\xfF\xe8" == "\0\5\16\31\60\255\232")++local function lexstring (x, y, n)+  local f = assert(load('return '..x..', debug.getinfo(1).currentline'))+  local s, l = f()+  assert(s == y and l == n)+end++lexstring("'abc\\z  \n   efg'", "abcefg", 2)+lexstring("'abc\\z  \n\n\n'", "abc", 4)+lexstring("'\\z  \n\t\f\v\n'",  "", 3)+lexstring("[[\nalo\nalo\n\n]]", "alo\nalo\n\n", 5)+lexstring("[[\nalo\ralo\n\n]]", "alo\nalo\n\n", 5)+lexstring("[[\nalo\ralo\r\n]]", "alo\nalo\n", 4)+lexstring("[[\ralo\n\ralo\r\n]]", "alo\nalo\n", 4)+lexstring("[[alo]\n]alo]]", "alo]\n]alo", 2)++assert("abc\z+        def\z+        ghi\z+       " == 'abcdefghi')++-- Error in escape sequences+local function lexerror (s, err)+  local st, msg = load('return '..s)+  if err ~= '<eof>' then err = "'"..err.."'" end+  assert(not st and string.find(msg, "near "..err, 1, true))+end+lexerror([["abc\x"]], [[\x"]])+lexerror([["abc\x]], [[\x]])+lexerror([["\x]], [[\x]])+lexerror([["\x5"]], [[\x5"]])+lexerror([["\x5]], [[\x5]])+lexerror([["\xr"]], [[\xr]])+lexerror([["\xr]], [[\xr]])+lexerror([["\x.]], [[\x.]])+lexerror([["\x8%"]], [[\x8%]])+lexerror([["\xAG]], [[\xAG]])+lexerror([["\g"]], [[\g]])+lexerror([["\g]], [[\g]])+lexerror([["\."]], [[\.]])++lexerror([["\999"]], [[\999]])+lexerror([["xyz\300"]], [[\300]])+lexerror([["   \256"]], [[\256]])+++-- unfinished strings+lexerror("[=[alo]]", "<eof>")+lexerror("[=[alo]=", "<eof>")+lexerror("[=[alo]", "<eof>")+lexerror("'alo", "<eof>")+lexerror("'alo \\z  \n\n", "<eof>")+lexerror("'alo \\z", "<eof>")+lexerror([['alo \98]], "<eof>")++-- valid characters in variable names+for i = 0, 255 do+  local s = string.char(i)+  assert(not string.find(s, "[a-zA-Z_]") == not load(s .. "=1"))+  assert(not string.find(s, "[a-zA-Z_0-9]") ==+         not load("a" .. s .. "1 = 1"))+end+++-- long variable names++var = string.rep('a', 15000)+prog = string.format("%s = 5", var)+dostring(prog)+assert(_G[var] == 5)+var = nil+print('+')++-- escapes --+assert("\n\t" == [[++	]])+assert([[++ $debug]] == "\n $debug")+assert([[ [ ]] ~= [[ ] ]])+-- long strings --+b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789"+assert(string.len(b) == 960)+prog = [=[+print('+')++a1 = [["isto e' um string com várias 'aspas'"]]+a2 = "'aspas'"++assert(string.find(a1, a2) == 31)+print('+')++a1 = [==[temp = [[um valor qualquer]]; ]==]+assert(load(a1))()+assert(temp == 'um valor qualquer')+-- long strings --+b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789"+assert(string.len(b) == 960)+print('+')++a = [[00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+00123456789012345678901234567890123456789123456789012345678901234567890123456789+]]+assert(string.len(a) == 1863)+assert(string.sub(a, 1, 40) == string.sub(b, 1, 40))+x = 1+]=]++print('+')+x = nil+dostring(prog)+assert(x)++prog = nil+a = nil+b = nil+++-- testing line ends+prog = [[+a = 1        -- a comment+b = 2+++x = [=[+hi+]=]+y = "\+hello\r\n\+"+return debug.getinfo(1).currentline+]]++for _, n in pairs{"\n", "\r", "\n\r", "\r\n"} do+  local prog, nn = string.gsub(prog, "\n", n)+  assert(dostring(prog) == nn)+  assert(_G.x == "hi\n" and _G.y == "\nhello\r\n\n")+end+++-- testing comments and strings with long brackets+a = [==[]=]==]+assert(a == "]=")++a = [==[[===[[=[]]=][====[]]===]===]==]+assert(a == "[===[[=[]]=][====[]]===]===")++a = [====[[===[[=[]]=][====[]]===]===]====]+assert(a == "[===[[=[]]=][====[]]===]===")++a = [=[]]]]]]]]]=]+assert(a == "]]]]]]]]")+++--[===[+x y z [==[ blu foo+]==+]+]=]==]+error error]=]===]++-- generate all strings of four of these chars+local x = {"=", "[", "]", "\n"}+local len = 4+local function gen (c, n)+  if n==0 then coroutine.yield(c)+  else+    for _, a in pairs(x) do+      gen(c..a, n-1)+    end+  end+end++for s in coroutine.wrap(function () gen("", len) end) do+  assert(s == load("return [====[\n"..s.."]====]")())+end+++-- testing decimal point locale+if os.setlocale("pt_BR") or os.setlocale("ptb") then+  assert(not load("á = 3"))  -- parser still works with C locale+  assert(not load("a = (3,4)"))+  assert(tonumber("3,4") == 3.4 and tonumber"3.4" == nil)+  assert(assert(load("return 3.4"))() == 3.4)+  assert(assert(load("return .4,3"))() == .4)+  assert(assert(load("return 4."))() == 4.)+  assert(assert(load("return 4.+.5"))() == 4.5)+  local a,b = load("return 4.5.")+  assert(string.find(b, "'4%.5%.'"))+  assert(os.setlocale("C"))+else+  (Message or print)(+   '\a\n >>> pt_BR locale not available: skipping decimal point tests <<<\n\a')+end+++-- testing %q x line ends+local s = "a string with \r and \n and \r\n and \n\r"+local c = string.format("return %q", s)+assert(assert(load(c))() == s)++-- testing errors+assert(not load"a = 'non-ending string")+assert(not load"a = 'non-ending string\n'")+assert(not load"a = '\\345'")+assert(not load"a = [=x]")++print('OK')

@@ -0,0 +1,157 @@+print('testing local variables and environments')++local debug = require"debug"+++-- bug in 5.1:++local function f(x) x = nil; return x end+assert(f(10) == nil)++local function f() local x; return x end+assert(f(10) == nil)++local function f(x) x = nil; local y; return x, y end+assert(f(10) == nil and select(2, f(20)) == nil)++do+  local i = 10+  do local i = 100; assert(i==100) end+  do local i = 1000; assert(i==1000) end+  assert(i == 10)+  if i ~= 10 then+    local i = 20+  else+    local i = 30+    assert(i == 30)+  end+end++++f = nil++local f+x = 1++a = nil+load('local a = {}')()+assert(a == nil)++function f (a)+  local _1, _2, _3, _4, _5+  local _6, _7, _8, _9, _10+  local x = 3+  local b = a+  local c,d = a,b+  if (d == b) then+    local x = 'q'+    x = b+    assert(x == 2)+  else+    assert(nil)+  end+  assert(x == 3)+  local f = 10+end++local b=10+local a; repeat local b; a,b=1,2; assert(a+1==b); until a+b==3+++assert(x == 1)++f(2)+assert(type(f) == 'function')+++local function getenv (f)+  local a,b = debug.getupvalue(f, 1)+  assert(a == '_ENV')+  return b+end++-- test for global table of loaded chunks+assert(getenv(load"a=3") == _G)+local c = {}; local f = load("a = 3", nil, nil, c)+assert(getenv(f) == c)+assert(c.a == nil)+f()+assert(c.a == 3)++-- testing limits for special instructions++if not _soft then+  local a+  local p = 4+  for i=2,31 do+    for j=-3,3 do+      assert(load(string.format([[local a=%s;+                                        a=a+%s;+                                        assert(a ==2^%s)]], j, p-j, i))) ()+      assert(load(string.format([[local a=%s;+                                        a=a-%s;+                                        assert(a==-2^%s)]], -j, p-j, i))) ()+      assert(load(string.format([[local a,b=0,%s;+                                        a=b-%s;+                                        assert(a==-2^%s)]], -j, p-j, i))) ()+    end+    p =2*p+  end+end++print'+'+++if rawget(_G, "querytab") then+  -- testing clearing of dead elements from tables+  collectgarbage("stop")   -- stop GC+  local a = {[{}] = 4, [3] = 0, alo = 1, +             a1234567890123456789012345678901234567890 = 10}++  local t = querytab(a)++  for k,_ in pairs(a) do a[k] = nil end+  collectgarbage()   -- restore GC and collect dead fiels in `a'+  for i=0,t-1 do+    local k = querytab(a, i)+    assert(k == nil or type(k) == 'number' or k == 'alo')+  end+end+++-- testing lexical environments++assert(_ENV == _G)++do local _ENV = (function (...) return ... end)(_G, dummy)++do local _ENV = {assert=assert}; assert(true) end+mt = {_G = _G}+local foo,x+do local _ENV = mt+  function foo (x)+    A = x+    do local _ENV =  _G; A = 1000 end+    return function (x) return A .. x end+  end+end+assert(getenv(foo) == mt)+x = foo('hi'); assert(mt.A == 'hi' and A == 1000)+assert(x('*') == mt.A .. '*')++do local _ENV = {assert=assert, A=10};+  do local _ENV = {assert=assert, A=20};+    assert(A==20);x=A+  end+  assert(A==10 and x==20)+end+assert(x==20)+++print('OK')++return 5,f++end+

@@ -0,0 +1,258 @@+-- most (all?) tests here assume a reasonable "Unix-like" shell+if _port then return end++print ("testing lua.c options")++assert(os.execute())   -- machine has a system command++prog = os.tmpname()+otherprog = os.tmpname()+out = os.tmpname()++do+  local i = 0+  while arg[i] do i=i-1 end+  progname = arg[i+1]+end+print("progname: "..progname)++local prepfile = function (s, p)+  p = p or prog+  io.output(p)+  io.write(s)+  assert(io.close())+end++function getoutput ()+  io.input(out)+  local t = io.read("*a")+  io.input():close()+  assert(os.remove(out))+  return t+end++function checkprogout (s)+  local t = getoutput()+  for line in string.gmatch(s, ".-\n") do+    assert(string.find(t, line, 1, true))+  end+end++function checkout (s)+  local t = getoutput()+  if s ~= t then print(string.format("'%s' - '%s'\n", s, t)) end+  assert(s == t)+  return t+end++function auxrun (...)+  local s = string.format(...)+  s = string.gsub(s, "lua", '"'..progname..'"', 1)+  return os.execute(s)+end++function RUN (...)+  assert(auxrun(...))+end++function NoRun (...)+  assert(not auxrun(...))+end++function NoRunMsg (...)+  print("\n(the next error is expected by the test)")+  return NoRun(...)+end++-- test environment variables used by Lua+prepfile("print(package.path)")++RUN("env LUA_INIT= LUA_PATH=x lua %s > %s", prog, out)+checkout("x\n")++RUN("env LUA_INIT= LUA_PATH_5_2=y LUA_PATH=x lua %s > %s", prog, out)+checkout("y\n")++prepfile("print(package.cpath)")++RUN("env LUA_INIT= LUA_CPATH=xuxu lua %s > %s", prog, out)+checkout("xuxu\n")++RUN("env LUA_INIT= LUA_CPATH_5_2=yacc LUA_CPATH=x lua %s > %s", prog, out)+checkout("yacc\n")++prepfile("print(X)")+RUN('env LUA_INIT="X=3" lua %s > %s', prog, out)+checkout("3\n")++prepfile("print(X)")+RUN('env LUA_INIT_5_2="X=10" LUA_INIT="X=3" lua %s > %s', prog, out)+checkout("10\n")++-- test option '-E'+prepfile("print(package.path, package.cpath)")+RUN('env LUA_INIT="error(10)" LUA_PATH=xxx LUA_CPATH=xxx lua -E %s > %s',+     prog, out)+local defaultpath = getoutput()+defaultpath = string.match(defaultpath, "^(.-)\t")   -- remove tab+assert(not string.find(defaultpath, "xxx") and string.find(defaultpath, "lua"))+++-- test replacement of ';;' to default path+local function convert (p)+  prepfile("print(package.path)")+  RUN('env LUA_PATH="%s" lua %s > %s', p, prog, out)+  local expected = getoutput()+  expected = string.sub(expected, 1, -2)   -- cut final end of line+  assert(string.gsub(p, ";;", ";"..defaultpath..";") == expected)+end++convert(";")+convert(";;")+convert(";;;")+convert(";;;;")+convert(";;;;;")+convert(";;a;;;bc")+++-- test 2 files+prepfile("print(1); a=2; return {x=15}")+prepfile(("print(a); print(_G['%s'].x)"):format(prog), otherprog)+RUN('env LUA_PATH="?;;" lua -l %s -l%s -lstring -l io %s > %s', prog, otherprog, otherprog, out)+checkout("1\n2\n15\n2\n15\n")++local a = [[+  assert(#arg == 3 and arg[1] == 'a' and+         arg[2] == 'b' and arg[3] == 'c')+  assert(arg[-1] == '--' and arg[-2] == "-e " and arg[-3] == '%s')+  assert(arg[4] == nil and arg[-4] == nil)+  local a, b, c = ...+  assert(... == 'a' and a == 'a' and b == 'b' and c == 'c')+]]+a = string.format(a, progname)+prepfile(a)+RUN('lua "-e " -- %s a b c', prog)++prepfile"assert(arg==nil)"+prepfile("assert(arg)", otherprog)+RUN('env LUA_PATH="?;;" lua -l%s - < %s', prog, otherprog)++prepfile""+RUN("lua - < %s > %s", prog, out)+checkout("")++-- test many arguments+prepfile[[print(({...})[30])]]+RUN("lua %s %s > %s", prog, string.rep(" a", 30), out)+checkout("a\n")++RUN([[lua "-eprint(1)" -ea=3 -e "print(a)" > %s]], out)+checkout("1\n3\n")++prepfile[[+  print(+1, a+)+]]+RUN("lua - < %s > %s", prog, out)+checkout("1\tnil\n")++prepfile[[+= (6*2-6) -- ===+a += 10+print(a)+= a]]+RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)+checkprogout("6\n10\n10\n\n")++prepfile("a = [[b\nc\nd\ne]]\n=a")+print("temporary program file: "..prog)+RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)+checkprogout("b\nc\nd\ne\n\n")++prompt = "alo"+prepfile[[ --+a = 2+]]+RUN([[lua "-e_PROMPT='%s'" -i < %s > %s]], prompt, prog, out)+local t = getoutput()+assert(string.find(t, prompt .. ".*" .. prompt .. ".*" .. prompt))++-- test for error objects+prepfile[[+debug = require "debug"+m = {x=0}+setmetatable(m, {__tostring = function(x)+  return debug.getinfo(4).currentline + x.x+end})+error(m)+]]+NoRun([[lua %s 2> %s]], prog, out)   -- no message+checkout(progname..": 6\n")+++s = [=[ -- +function f ( x ) +  local a = [[+xuxu+]]+  local b = "\+xuxu\n"+  if x == 11 then return 1 , 2 end  --[[ test multiple returns ]]+  return x + 1 +  --\\+end+=( f( 10 ) )+assert( a == b )+=f( 11 )  ]=]+s = string.gsub(s, ' ', '\n\n')+prepfile(s)+RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)+checkprogout("11\n1\t2\n\n")+  +prepfile[[#comment in 1st line without \n at the end]]+RUN("lua %s", prog)+  +prepfile[[#test line number when file starts with comment line+debug = require"debug"+print(debug.getinfo(1).currentline)+]]+RUN("lua %s > %s", prog, out)+checkprogout('3')++-- close Lua with an open file+prepfile(string.format([[io.output(%q); io.write('alo')]], out))+RUN("lua %s", prog)+checkout('alo')++-- bug in 5.2 beta (extra \0 after version line)+RUN([[lua -v  -e'print"hello"' > %s]], out)+t = getoutput()+assert(string.find(t, "PUC%-Rio\nhello"))+++-- testing os.exit+prepfile("os.exit(nil, true)")+RUN("lua %s", prog)+prepfile("os.exit(0, true)")+RUN("lua %s", prog)+prepfile("os.exit(true, true)")+RUN("lua %s", prog)+prepfile("os.exit(1, true)")+NoRun("lua %s", prog)   -- no message+prepfile("os.exit(false, true)")+NoRun("lua %s", prog)   -- no message++assert(os.remove(prog))+assert(os.remove(otherprog))+assert(not os.remove(out))++RUN("lua -v")++NoRunMsg("lua -h")+NoRunMsg("lua -e")+NoRunMsg("lua -e a")+NoRunMsg("lua -f")++print("OK")

@@ -0,0 +1,288 @@+print("testing numbers and math lib")+++-- basic float notation+assert(0e12 == 0 and .0 == 0 and 0. == 0 and .2e2 == 20 and 2.E-1 == 0.2)++do+  local a,b,c = "2", " 3e0 ", " 10  "+  assert(a+b == 5 and -b == -3 and b+"2" == 5 and "10"-c == 0)+  assert(type(a) == 'string' and type(b) == 'string' and type(c) == 'string')+  assert(a == "2" and b == " 3e0 " and c == " 10  " and -c == -"  10 ")+  assert(c%a == 0 and a^b == 08)+  a = 0+  assert(a == -a and 0 == -0)+end++do+  local x = -1+  local mz = 0/x   -- minus zero+  t = {[0] = 10, 20, 30, 40, 50}+  assert(t[mz] == t[0] and t[-0] == t[0])+end++do+  local a,b = math.modf(3.5)+  assert(a == 3 and b == 0.5)+  assert(math.huge > 10e30)+  assert(-math.huge < -10e30)+end++function f(...)+  if select('#', ...) == 1 then+    return (...)+  else+    return "***"+  end+end+++-- testing numeric strings++assert("2" + 1 == 3)+assert("2 " + 1 == 3)+assert(" -2 " + 1 == -1)+assert(" -0xa " + 1 == -9)+++-- testing 'tonumber'+assert(tonumber{} == nil)+assert(tonumber'+0.01' == 1/100 and tonumber'+.01' == 0.01 and+       tonumber'.01' == 0.01    and tonumber'-1.' == -1 and+       tonumber'+1.' == 1)+assert(tonumber'+ 0.01' == nil and tonumber'+.e1' == nil and+       tonumber'1e' == nil     and tonumber'1.0e+' == nil and+       tonumber'.' == nil)+assert(tonumber('-012') == -010-2)+-- Commenting this line out for now, see issue #2+-- assert(tonumber('-1.2e2') == - - -120)++assert(tonumber("0xffffffffffff") == 2^(4*12) - 1)+assert(tonumber("0x"..string.rep("f", 150)) == 2^(4*150) - 1)+assert(tonumber('0x3.' .. string.rep('0', 100)) == 3)+assert(tonumber('0x0.' .. string.rep('0', 150).."1") == 2^(-4*151))++-- testing 'tonumber' with base+assert(tonumber('  001010  ', 2) == 10)+assert(tonumber('  001010  ', 10) == 001010)+assert(tonumber('  -1010  ', 2) == -10)+assert(tonumber('10', 36) == 36)+assert(tonumber('  -10  ', 36) == -36)+assert(tonumber('  +1Z  ', 36) == 36 + 35)+assert(tonumber('  -1z  ', 36) == -36 + -35)+assert(tonumber('-fFfa', 16) == -(10+(16*(15+(16*(15+(16*15)))))))+assert(tonumber(string.rep('1', 42), 2) + 1 == 2^42)+assert(tonumber(string.rep('1', 34), 2) + 1 == 2^34)+assert(tonumber('ffffFFFF', 16)+1 == 2^32)+assert(tonumber('0ffffFFFF', 16)+1 == 2^32)+assert(tonumber('-0ffffffFFFF', 16) - 1 == -2^40)+for i = 2,36 do+  assert(tonumber('\t10000000000\t', i) == i^10)+end++-- testing 'tonumber' fo invalid formats+assert(f(tonumber('fFfa', 15)) == nil)+assert(f(tonumber('099', 8)) == nil)+assert(f(tonumber('1\0', 2)) == nil)+assert(f(tonumber('', 8)) == nil)+assert(f(tonumber('  ', 9)) == nil)+assert(f(tonumber('  ', 9)) == nil)+assert(f(tonumber('0xf', 10)) == nil)++assert(f(tonumber('inf')) == nil)+assert(f(tonumber(' INF ')) == nil)+assert(f(tonumber('Nan')) == nil)+assert(f(tonumber('nan')) == nil)++assert(f(tonumber('  ')) == nil)+assert(f(tonumber('')) == nil)+assert(f(tonumber('1  a')) == nil)+assert(f(tonumber('1\0')) == nil)+assert(f(tonumber('1 \0')) == nil)+assert(f(tonumber('1\0 ')) == nil)+assert(f(tonumber('e1')) == nil)+assert(f(tonumber('e  1')) == nil)+assert(f(tonumber(' 3.4.5 ')) == nil)+++-- testing 'tonumber' for invalid hexadecimal formats++assert(tonumber('0x') == nil)+assert(tonumber('x') == nil)+assert(tonumber('x3') == nil)+assert(tonumber('00x2') == nil)+assert(tonumber('0x 2') == nil)+assert(tonumber('0 x2') == nil)+assert(tonumber('23x') == nil)+assert(tonumber('- 0xaa') == nil)+++-- testing hexadecimal numerals++assert(0x10 == 16 and 0xfff == 2^12 - 1 and 0XFB == 251)+assert(0x0p12 == 0 and 0x.0p-3 == 0)+assert(0xFFFFFFFF == 2^32 - 1)+assert(tonumber('+0x2') == 2)+assert(tonumber('-0xaA') == -170)+assert(tonumber('-0xffFFFfff') == -2^32 + 1)++-- possible confusion with decimal exponent+assert(0E+1 == 0 and 0xE+1 == 15 and 0xe-1 == 13)+++-- floating hexas++assert(tonumber('  0x2.5  ') == 0x25/16)+assert(tonumber('  -0x2.5  ') == -0x25/16)+assert(tonumber('  +0x0.51p+8  ') == 0x51)+assert(tonumber('0x0.51p') == nil)+assert(tonumber('0x5p+-2') == nil)+assert(0x.FfffFFFF == 1 - '0x.00000001')+assert('0xA.a' + 0 == 10 + 10/16)+assert(0xa.aP4 == 0XAA)+assert(0x4P-2 == 1)+assert(0x1.1 == '0x1.' + '+0x.1')+++assert(1.1 == 1.+.1)+assert(100.0 == 1E2 and .01 == 1e-2)+assert(1111111111111111-1111111111111110== 1000.00e-03)+--     1234567890123456+assert(1.1 == '1.'+'.1')+assert('1111111111111111'-'1111111111111110' == tonumber"  +0.001e+3 \n\t")++function eq (a,b,limit)+  if not limit then limit = 10E-10 end+  return math.abs(a-b) <= limit+end++assert(0.1e-30 > 0.9E-31 and 0.9E30 < 0.1e31)++assert(0.123456 > 0.123455)++assert(tonumber('+1.23E18') == 1.23*10^18)++-- testing order operators+assert(not(1<1) and (1<2) and not(2<1))+assert(not('a'<'a') and ('a'<'b') and not('b'<'a'))+assert((1<=1) and (1<=2) and not(2<=1))+assert(('a'<='a') and ('a'<='b') and not('b'<='a'))+assert(not(1>1) and not(1>2) and (2>1))+assert(not('a'>'a') and not('a'>'b') and ('b'>'a'))+assert((1>=1) and not(1>=2) and (2>=1))+assert(('a'>='a') and not('a'>='b') and ('b'>='a'))++-- testing mod operator+assert(-4%3 == 2)+assert(4%-3 == -2)+assert(math.pi - math.pi % 1 == 3)+assert(math.pi - math.pi % 0.001 == 3.141)++local function testbit(a, n)+  return a/2^n % 2 >= 1+end++assert(eq(math.sin(-9.8)^2 + math.cos(-9.8)^2, 1))+assert(eq(math.tan(math.pi/4), 1))+assert(eq(math.sin(math.pi/2), 1) and eq(math.cos(math.pi/2), 0))+assert(eq(math.atan(1), math.pi/4) and eq(math.acos(0), math.pi/2) and+       eq(math.asin(1), math.pi/2))+assert(eq(math.deg(math.pi/2), 90) and eq(math.rad(90), math.pi/2))+assert(math.abs(-10) == 10)+assert(eq(math.atan2(1,0), math.pi/2))+assert(math.ceil(4.5) == 5.0)+assert(math.floor(4.5) == 4.0)+assert(math.fmod(10,3) == 1)+assert(eq(math.sqrt(10)^2, 10))+assert(eq(math.log(2, 10), math.log(2)/math.log(10)))+assert(eq(math.log(2, 2), 1))+assert(eq(math.log(9, 3), 2))+assert(eq(math.exp(0), 1))+assert(eq(math.sin(10), math.sin(10%(2*math.pi))))+local v,e = math.frexp(math.pi)+assert(eq(math.ldexp(v,e), math.pi))++assert(eq(math.tanh(3.5), math.sinh(3.5)/math.cosh(3.5)))++assert(tonumber(' 1.3e-2 ') == 1.3e-2)+assert(tonumber(' -1.00000000000001 ') == -1.00000000000001)++-- testing constant limits+-- 2^23 = 8388608+assert(8388609 + -8388609 == 0)+assert(8388608 + -8388608 == 0)+assert(8388607 + -8388607 == 0)++-- testing implicit convertions++local a,b = '10', '20'+assert(a*b == 200 and a+b == 30 and a-b == -10 and a/b == 0.5 and -b == -20)+assert(a == '10' and b == '20')+++if not _port then+  print("testing -0 and NaN")+  local mz, z = -0, 0+  assert(mz == z)+  assert(1/mz < 0 and 0 < 1/z)+  local a = {[mz] = 1}+  assert(a[z] == 1 and a[mz] == 1)+  local inf = math.huge * 2 + 1+  mz, z = -1/inf, 1/inf+  assert(mz == z)+  assert(1/mz < 0 and 0 < 1/z)+  local NaN = inf - inf+  assert(NaN ~= NaN)+  assert(not (NaN < NaN))+  assert(not (NaN <= NaN))+  assert(not (NaN > NaN))+  assert(not (NaN >= NaN))+  assert(not (0 < NaN) and not (NaN < 0))+  local NaN1 = 0/0+  assert(NaN ~= NaN1 and not (NaN <= NaN1) and not (NaN1 <= NaN))+  local a = {}+  assert(not pcall(function () a[NaN] = 1 end))+  assert(a[NaN] == nil)+  a[1] = 1+  assert(not pcall(function () a[NaN] = 1 end))+  assert(a[NaN] == nil)+  -- string with same binary representation as 0.0 (may create problems+  -- for constant manipulation in the pre-compiler)+  local a1, a2, a3, a4, a5 = 0, 0, "\0\0\0\0\0\0\0\0", 0, "\0\0\0\0\0\0\0\0"+  assert(a1 == a2 and a2 == a4 and a1 ~= a3)+  assert(a3 == a5)+end+++if not _port then+  print("testing 'math.random'")+  math.randomseed(0)++  local function aux (x1, x2, p)+    local Max = -math.huge+    local Min = math.huge+    for i = 0, 20000 do+      local t = math.random(table.unpack(p))+      Max = math.max(Max, t)+      Min = math.min(Min, t)+      if eq(Max, x2, 0.001) and eq(Min, x1, 0.001) then+        goto ok+      end+    end+    -- loop ended without satisfing condition+    assert(false)+   ::ok::+    assert(x1 <= Min and Max<=x2)+  end++  aux(0, 1, {})+  aux(-10, 0, {-10,0})+end++for i=1,10 do+  local t = math.random(5)+  assert(1 <= t and t <= 5)+end+++print('OK')

@@ -0,0 +1,461 @@+print('testing tables, next, and for')++local a = {}++-- make sure table has lots of space in hash part+for i=1,100 do a[i.."+"] = true end+for i=1,100 do a[i.."+"] = nil end+-- fill hash part with numeric indices testing size operator+for i=1,100 do+  a[i] = true+  assert(#a == i)+end++-- testing ipairs+local x = 0+for k,v in ipairs{10,20,30;x=12} do+  x = x + 1+  assert(k == x and v == x * 10)+end++for _ in ipairs{x=12, y=24} do assert(nil) end++-- test for 'false' x ipair+x = false+local i = 0+for k,v in ipairs{true,false,true,false} do+  i = i + 1+  x = not x+  assert(x == v)+end+assert(i == 4)++-- iterator function is always the same+assert(type(ipairs{}) == 'function' and ipairs{} == ipairs{})++if T then  --[+-- testing table sizes++local function log2 (x) return math.log(x, 2) end++local function mp2 (n)   -- minimum power of 2 >= n+  local mp = 2^math.ceil(log2(n))+  assert(n == 0 or (mp/2 < n and n <= mp))+  return mp+end++local function fb (n)+  local r, nn = T.int2fb(n)+  assert(r < 256)+  return nn+end++-- test fb function+local a = 1+local lim = 2^30+while a < lim do+  local n = fb(a)+  assert(a <= n and n <= a*1.125)+  a = math.ceil(a*1.3)+end++ +local function check (t, na, nh)+  local a, h = T.querytab(t)+  if a ~= na or h ~= nh then+    print(na, nh, a, h)+    assert(nil)+  end+end+++-- testing C library sizes+do+  local s = 0+  for _ in pairs(math) do s = s + 1 end+  check(math, 0, mp2(s))+end+++-- testing constructor sizes+local lim = 40+local s = 'return {'+for i=1,lim do+  s = s..i..','+  local s = s+  for k=0,lim do +    local t = load(s..'}')()+    assert(#t == i)+    check(t, fb(i), mp2(k))+    s = string.format('%sa%d=%d,', s, k, k)+  end+end+++-- tests with unknown number of elements+local a = {}+for i=1,lim do a[i] = i end   -- build auxiliary table+for k=0,lim do+  local a = {table.unpack(a,1,k)}+  assert(#a == k)+  check(a, k, 0)+  a = {1,2,3,table.unpack(a,1,k)}+  check(a, k+3, 0)+  assert(#a == k + 3)+end+++-- testing tables dynamically built+local lim = 130+local a = {}; a[2] = 1; check(a, 0, 1)+a = {}; a[0] = 1; check(a, 0, 1); a[2] = 1; check(a, 0, 2)+a = {}; a[0] = 1; a[1] = 1; check(a, 1, 1)+a = {}+for i = 1,lim do+  a[i] = 1+  assert(#a == i)+  check(a, mp2(i), 0)+end++a = {}+for i = 1,lim do+  a['a'..i] = 1+  assert(#a == 0)+  check(a, 0, mp2(i))+end++a = {}+for i=1,16 do a[i] = i end+check(a, 16, 0)+if not _port then+  for i=1,11 do a[i] = nil end+  for i=30,50 do a[i] = nil end   -- force a rehash (?)+  check(a, 0, 8)   -- only 5 elements in the table+  a[10] = 1+  for i=30,50 do a[i] = nil end   -- force a rehash (?)+  check(a, 0, 8)   -- only 6 elements in the table+  for i=1,14 do a[i] = nil end+  for i=18,50 do a[i] = nil end   -- force a rehash (?)+  check(a, 0, 4)   -- only 2 elements ([15] and [16])+end++-- reverse filling+for i=1,lim do+  local a = {}+  for i=i,1,-1 do a[i] = i end   -- fill in reverse+  check(a, mp2(i), 0)+end++-- size tests for vararg+lim = 35+function foo (n, ...)+  local arg = {...}+  check(arg, n, 0)+  assert(select('#', ...) == n)+  arg[n+1] = true+  check(arg, mp2(n+1), 0)+  arg.x = true+  check(arg, mp2(n+1), 1)+end+local a = {}+for i=1,lim do a[i] = true; foo(i, table.unpack(a)) end++end  --]+++-- test size operation on empty tables+assert(#{} == 0)+assert(#{nil} == 0)+assert(#{nil, nil} == 0)+assert(#{nil, nil, nil} == 0)+assert(#{nil, nil, nil, nil} == 0)+print'+'+++local nofind = {}++a,b,c = 1,2,3+a,b,c = nil+++-- next uses always the same iteraction function+assert(next{} == next{})++local function find (name)+  local n,v+  while 1 do+    n,v = next(_G, n)+    if not n then return nofind end+    assert(v ~= nil)+    if n == name then return v end+  end+end++local function find1 (name)+  for n,v in pairs(_G) do+    if n==name then return v end+  end+  return nil  -- not found+end+++assert(print==find("print") and print == find1("print"))+assert(_G["print"]==find("print"))+assert(assert==find1("assert"))+assert(nofind==find("return"))+assert(not find1("return"))+_G["ret" .. "urn"] = nil+assert(nofind==find("return"))+_G["xxx"] = 1+assert(xxx==find("xxx"))++print('+')++a = {}+for i=0,10000 do+  if math.fmod(i,10) ~= 0 then+    a['x'..i] = i+  end+end++n = {n=0}+for i,v in pairs(a) do+  n.n = n.n+1+  assert(i and v and a[i] == v)+end+assert(n.n == 9000)+a = nil++do   -- clear global table+  local a = {}+  for n,v in pairs(_G) do a[n]=v end+  for n,v in pairs(a) do+    if not package.loaded[n] and type(v) ~= "function" and+       not string.find(n, "^[%u_]") then+     _G[n] = nil+    end+    collectgarbage()+  end+end+++-- ++local function checknext (a)+  local b = {}+  do local k,v = next(a); while k do b[k] = v; k,v = next(a,k) end end+  for k,v in pairs(b) do assert(a[k] == v) end+  for k,v in pairs(a) do assert(b[k] == v) end+end++checknext{1,x=1,y=2,z=3}+checknext{1,2,x=1,y=2,z=3}+checknext{1,2,3,x=1,y=2,z=3}+checknext{1,2,3,4,x=1,y=2,z=3}+checknext{1,2,3,4,5,x=1,y=2,z=3}++assert(#{} == 0)+assert(#{[-1] = 2} == 0)+assert(#{1,2,3,nil,nil} == 3)+for i=0,40 do+  local a = {}+  for j=1,i do a[j]=j end+  assert(#a == i)+end++-- 'maxn' is now deprecated, but it is easily defined in Lua+function table.maxn (t)+  local max = 0+  for k in pairs(t) do+    max = (type(k) == 'number') and math.max(max, k) or max+  end+  return max+end++assert(table.maxn{} == 0)+assert(table.maxn{["1000"] = true} == 0)+assert(table.maxn{["1000"] = true, [24.5] = 3} == 24.5)+assert(table.maxn{[1000] = true} == 1000)+assert(table.maxn{[10] = true, [100*math.pi] = print} == 100*math.pi)++table.maxn = nil++-- int overflow+a = {}+for i=0,50 do a[math.pow(2,i)] = true end+assert(a[#a])++print('+')+++-- erasing values+local t = {[{1}] = 1, [{2}] = 2, [string.rep("x ", 4)] = 3,+           [100.3] = 4, [4] = 5}++local n = 0+for k, v in pairs( t ) do+  n = n+1+  assert(t[k] == v)+  t[k] = nil+  collectgarbage()+  assert(t[k] == nil)+end+assert(n == 5)+++local function test (a)+  assert(not pcall(table.insert, a, 2, 20));+  table.insert(a, 10); table.insert(a, 2, 20);+  table.insert(a, 1, -1); table.insert(a, 40);+  table.insert(a, #a+1, 50)+  table.insert(a, 2, -2)+  assert(not pcall(table.insert, a, 0, 20));+  assert(not pcall(table.insert, a, #a + 2, 20));+  assert(table.remove(a,1) == -1)+  assert(table.remove(a,1) == -2)+  assert(table.remove(a,1) == 10)+  assert(table.remove(a,1) == 20)+  assert(table.remove(a,1) == 40)+  assert(table.remove(a,1) == 50)+  assert(table.remove(a,1) == nil)+  assert(table.remove(a) == nil)+  assert(table.remove(a, #a) == nil)+end++a = {n=0, [-7] = "ban"}+test(a)+assert(a.n == 0 and a[-7] == "ban")++a = {[-7] = "ban"};+test(a)+assert(a.n == nil and #a == 0 and a[-7] == "ban")++a = {[-1] = "ban"}+test(a)+assert(#a == 0 and table.remove(a) == nil and a[-1] == "ban")++a = {[0] = "ban"}+assert(#a == 0 and table.remove(a) == "ban" and a[0] == nil)++table.insert(a, 1, 10); table.insert(a, 1, 20); table.insert(a, 1, -1)+assert(table.remove(a) == 10)+assert(table.remove(a) == 20)+assert(table.remove(a) == -1)+assert(table.remove(a) == nil)++a = {'c', 'd'}+table.insert(a, 3, 'a')+table.insert(a, 'b')+assert(table.remove(a, 1) == 'c')+assert(table.remove(a, 1) == 'd')+assert(table.remove(a, 1) == 'a')+assert(table.remove(a, 1) == 'b')+assert(table.remove(a, 1) == nil)+assert(#a == 0 and a.n == nil)++a = {10,20,30,40}+assert(table.remove(a, #a + 1) == nil)+assert(not pcall(table.remove, a, 0))+assert(a[#a] == 40)+assert(table.remove(a, #a) == 40)+assert(a[#a] == 30)+assert(table.remove(a, 2) == 20)+assert(a[#a] == 30 and #a == 2)+print('+')++a = {}+for i=1,1000 do+  a[i] = i; a[i-1] = nil+end+assert(next(a,nil) == 1000 and next(a,1000) == nil)++assert(next({}) == nil)+assert(next({}, nil) == nil)++for a,b in pairs{} do error"not here" end+for i=1,0 do error'not here' end+for i=0,1,-1 do error'not here' end+a = nil; for i=1,1 do assert(not a); a=1 end; assert(a)+a = nil; for i=1,1,-1 do assert(not a); a=1 end; assert(a)++if not _port then+  print("testing precision in numeric for")+  local a = 0; for i=0, 1, 0.1 do a=a+1 end; assert(a==11)+  a = 0; for i=0, 0.999999999, 0.1 do a=a+1 end; assert(a==10)+  a = 0; for i=1, 1, 1 do a=a+1 end; assert(a==1)+  a = 0; for i=1e10, 1e10, -1 do a=a+1 end; assert(a==1)+  a = 0; for i=1, 0.99999, 1 do a=a+1 end; assert(a==0)+  a = 0; for i=99999, 1e5, -1 do a=a+1 end; assert(a==0)+  a = 0; for i=1, 0.99999, -1 do a=a+1 end; assert(a==1)+end++-- conversion+a = 0; for i="10","1","-2" do a=a+1 end; assert(a==5)+++collectgarbage()+++-- testing generic 'for'++local function f (n, p)+  local t = {}; for i=1,p do t[i] = i*10 end+  return function (_,n)+           if n > 0 then+             n = n-1+             return n, table.unpack(t)+           end+         end, nil, n+end++local x = 0+for n,a,b,c,d in f(5,3) do+  x = x+1+  assert(a == 10 and b == 20 and c == 30 and d == nil)+end+assert(x == 5)++++-- testing __pairs and __ipairs metamethod+a = {}+do+  local x,y,z = pairs(a)+  assert(type(x) == 'function' and y == a and z == nil)+end++local function foo (e,i)+  assert(e == a)+  if i <= 10 then return i+1, i+2 end+end++local function foo1 (e,i)+  i = i + 1+  assert(e == a)+  if i <= e.n then return i,a[i] end+end++setmetatable(a, {__pairs = function (x) return foo, x, 0 end})++local i = 0+for k,v in pairs(a) do+  i = i + 1+  assert(k == i and v == k+1)+end++a.n = 5+a[3] = 30++a = {n=10}+setmetatable(a, {__len = function (x) return x.n end,+                 __ipairs = function (x) return function (e,i)+                             if i < #e then return i+1 end+                           end, x, 0 end})+i = 0+for k,v in ipairs(a) do+  i = i + 1+  assert(k == i and v == nil)+end+assert(i == a.n)++print"OK"