1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159 |
- -- $Id: testes/locals.lua $
- -- See Copyright Notice in file all.lua
- print('testing local variables and environments')
- local debug = require"debug"
- local tracegc = require"tracegc"
- -- 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)
- -- old test for limits for special instructions
- do
- local i = 2
- local p = 4 -- p == 2^i
- repeat
- 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; i = i + 1
- until p <= 0
- end
- print'+'
- if rawget(_G, "T") then
- -- testing clearing of dead elements from tables
- collectgarbage("stop") -- stop GC
- local a = {[{}] = 4, [3] = 0, alo = 1,
- a1234567890123456789012345678901234567890 = 10}
- local t = T.querytab(a)
- for k,_ in pairs(a) do a[k] = undef end
- collectgarbage() -- restore GC and collect dead fields in 'a'
- for i=0,t-1 do
- local k = querytab(a, i)
- assert(k == nil or type(k) == 'number' or k == 'alo')
- end
- -- testing allocation errors during table insertions
- local a = {}
- local function additems ()
- a.x = true; a.y = true; a.z = true
- a[1] = true
- a[2] = true
- end
- for i = 1, math.huge do
- T.alloccount(i)
- local st, msg = pcall(additems)
- T.alloccount()
- local count = 0
- for k, v in pairs(a) do
- assert(a[k] == v)
- count = count + 1
- end
- if st then assert(count == 5); break end
- end
- end
- -- testing lexical environments
- assert(_ENV == _G)
- do
- local dummy
- local _ENV = (function (...) return ... end)(_G, dummy) -- {
- do local _ENV = {assert=assert}; assert(true) end
- mt = {_G = _G}
- local foo,x
- A = false -- "declare" A
- 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)
- do -- constants
- local a<const>, b, c<const> = 10, 20, 30
- b = a + c + b -- 'b' is not constant
- assert(a == 10 and b == 60 and c == 30)
- local function checkro (name, code)
- local st, msg = load(code)
- local gab = string.format("attempt to assign to const variable '%s'", name)
- assert(not st and string.find(msg, gab))
- end
- checkro("y", "local x, y <const>, z = 10, 20, 30; x = 11; y = 12")
- checkro("x", "local x <const>, y, z <const> = 10, 20, 30; x = 11")
- checkro("z", "local x <const>, y, z <const> = 10, 20, 30; y = 10; z = 11")
- checkro("foo", "local foo <const> = 10; function foo() end")
- checkro("foo", "local foo <const> = {}; function foo() end")
- checkro("z", [[
- local a, z <const>, b = 10;
- function foo() a = 20; z = 32; end
- ]])
- checkro("var1", [[
- local a, var1 <const> = 10;
- function foo() a = 20; z = function () var1 = 12; end end
- ]])
- end
- print"testing to-be-closed variables"
- local function stack(n) n = ((n == 0) or stack(n - 1)) end
- local function func2close (f, x, y)
- local obj = setmetatable({}, {__close = f})
- if x then
- return x, obj, y
- else
- return obj
- end
- end
- do
- local a = {}
- do
- local b <close> = false -- not to be closed
- local x <close> = setmetatable({"x"}, {__close = function (self)
- a[#a + 1] = self[1] end})
- local w, y <close>, z = func2close(function (self, err)
- assert(err == nil); a[#a + 1] = "y"
- end, 10, 20)
- local c <close> = nil -- not to be closed
- a[#a + 1] = "in"
- assert(w == 10 and z == 20)
- end
- a[#a + 1] = "out"
- assert(a[1] == "in" and a[2] == "y" and a[3] == "x" and a[4] == "out")
- end
- do
- local X = false
- local x, closescope = func2close(function (_, msg)
- stack(10);
- assert(msg == nil)
- X = true
- end, 100)
- assert(x == 100); x = 101; -- 'x' is not read-only
- -- closing functions do not corrupt returning values
- local function foo (x)
- local _ <close> = closescope
- return x, X, 23
- end
- local a, b, c = foo(1.5)
- assert(a == 1.5 and b == false and c == 23 and X == true)
- X = false
- foo = function (x)
- local _<close> = func2close(function (_, msg)
- -- without errors, enclosing function should be still active when
- -- __close is called
- assert(debug.getinfo(2).name == "foo")
- assert(msg == nil)
- end)
- local _<close> = closescope
- local y = 15
- return y
- end
- assert(foo() == 15 and X == true)
- X = false
- foo = function ()
- local x <close> = closescope
- return x
- end
- assert(foo() == closescope and X == true)
- end
- -- testing to-be-closed x compile-time constants
- -- (there were some bugs here in Lua 5.4-rc3, due to a confusion
- -- between compile levels and stack levels of variables)
- do
- local flag = false
- local x = setmetatable({},
- {__close = function() assert(flag == false); flag = true end})
- local y <const> = nil
- local z <const> = nil
- do
- local a <close> = x
- end
- assert(flag) -- 'x' must be closed here
- end
- do
- -- similar problem, but with implicit close in for loops
- local flag = false
- local x = setmetatable({},
- {__close = function () assert(flag == false); flag = true end})
- -- return an empty iterator, nil, nil, and 'x' to be closed
- local function a ()
- return (function () return nil end), nil, nil, x
- end
- local v <const> = 1
- local w <const> = 1
- local x <const> = 1
- local y <const> = 1
- local z <const> = 1
- for k in a() do
- a = k
- end -- ending the loop must close 'x'
- assert(flag) -- 'x' must be closed here
- end
- do
- -- calls cannot be tail in the scope of to-be-closed variables
- local X, Y
- local function foo ()
- local _ <close> = func2close(function () Y = 10 end)
- assert(X == true and Y == nil) -- 'X' not closed yet
- return 1,2,3
- end
- local function bar ()
- local _ <close> = func2close(function () X = false end)
- X = true
- do
- return foo() -- not a tail call!
- end
- end
- local a, b, c, d = bar()
- assert(a == 1 and b == 2 and c == 3 and X == false and Y == 10 and d == nil)
- end
- do
- -- bug in 5.4.3: previous condition (calls cannot be tail in the
- -- scope of to-be-closed variables) must be valid for tbc variables
- -- created by 'for' loops.
- local closed = false
- local function foo ()
- return function () return true end, 0, 0,
- func2close(function () closed = true end)
- end
- local function tail() return closed end
- local function foo1 ()
- for k in foo() do return tail() end
- end
- assert(foo1() == false)
- assert(closed == true)
- end
- do print("testing errors in __close")
- -- original error is in __close
- local function foo ()
- local x <close> =
- func2close(function (self, msg)
- assert(string.find(msg, "@y"))
- error("@x")
- end)
- local x1 <close> =
- func2close(function (self, msg)
- assert(string.find(msg, "@y"))
- end)
- local gc <close> = func2close(function () collectgarbage() end)
- local y <close> =
- func2close(function (self, msg)
- assert(string.find(msg, "@z")) -- error in 'z'
- error("@y")
- end)
- local z <close> =
- func2close(function (self, msg)
- assert(msg == nil)
- error("@z")
- end)
- return 200
- end
- local stat, msg = pcall(foo, false)
- assert(string.find(msg, "@x"))
- -- original error not in __close
- local function foo ()
- local x <close> =
- func2close(function (self, msg)
- -- after error, 'foo' was discarded, so caller now
- -- must be 'pcall'
- assert(debug.getinfo(2).name == "pcall")
- assert(string.find(msg, "@x1"))
- end)
- local x1 <close> =
- func2close(function (self, msg)
- assert(debug.getinfo(2).name == "pcall")
- assert(string.find(msg, "@y"))
- error("@x1")
- end)
- local gc <close> = func2close(function () collectgarbage() end)
- local y <close> =
- func2close(function (self, msg)
- assert(debug.getinfo(2).name == "pcall")
- assert(string.find(msg, "@z"))
- error("@y")
- end)
- local first = true
- local z <close> =
- func2close(function (self, msg)
- assert(debug.getinfo(2).name == "pcall")
- -- 'z' close is called once
- assert(first and msg == 4)
- first = false
- error("@z")
- end)
- error(4) -- original error
- end
- local stat, msg = pcall(foo, true)
- assert(string.find(msg, "@x1"))
- -- error leaving a block
- local function foo (...)
- do
- local x1 <close> =
- func2close(function (self, msg)
- assert(string.find(msg, "@X"))
- error("@Y")
- end)
- local x123 <close> =
- func2close(function (_, msg)
- assert(msg == nil)
- error("@X")
- end)
- end
- os.exit(false) -- should not run
- end
- local st, msg = xpcall(foo, debug.traceback)
- assert(string.match(msg, "^[^ ]* @Y"))
- -- error in toclose in vararg function
- local function foo (...)
- local x123 <close> = func2close(function () error("@x123") end)
- end
- local st, msg = xpcall(foo, debug.traceback)
- assert(string.match(msg, "^[^ ]* @x123"))
- assert(string.find(msg, "in metamethod 'close'"))
- end
- do -- errors due to non-closable values
- local function foo ()
- local x <close> = {}
- os.exit(false) -- should not run
- end
- local stat, msg = pcall(foo)
- assert(not stat and
- string.find(msg, "variable 'x' got a non%-closable value"))
- local function foo ()
- local xyz <close> = setmetatable({}, {__close = print})
- getmetatable(xyz).__close = nil -- remove metamethod
- end
- local stat, msg = pcall(foo)
- assert(not stat and string.find(msg, "metamethod 'close'"))
- local function foo ()
- local a1 <close> = func2close(function (_, msg)
- assert(string.find(msg, "number value"))
- error(12)
- end)
- local a2 <close> = setmetatable({}, {__close = print})
- local a3 <close> = func2close(function (_, msg)
- assert(msg == nil)
- error(123)
- end)
- getmetatable(a2).__close = 4 -- invalidate metamethod
- end
- local stat, msg = pcall(foo)
- assert(not stat and msg == 12)
- end
- do -- tbc inside close methods
- local track = {}
- local function foo ()
- local x <close> = func2close(function ()
- local xx <close> = func2close(function (_, msg)
- assert(msg == nil)
- track[#track + 1] = "xx"
- end)
- track[#track + 1] = "x"
- end)
- track[#track + 1] = "foo"
- return 20, 30, 40
- end
- local a, b, c, d = foo()
- assert(a == 20 and b == 30 and c == 40 and d == nil)
- assert(track[1] == "foo" and track[2] == "x" and track[3] == "xx")
- -- again, with errors
- local track = {}
- local function foo ()
- local x0 <close> = func2close(function (_, msg)
- assert(msg == 202)
- track[#track + 1] = "x0"
- end)
- local x <close> = func2close(function ()
- local xx <close> = func2close(function (_, msg)
- assert(msg == 101)
- track[#track + 1] = "xx"
- error(202)
- end)
- track[#track + 1] = "x"
- error(101)
- end)
- track[#track + 1] = "foo"
- return 20, 30, 40
- end
- local st, msg = pcall(foo)
- assert(not st and msg == 202)
- assert(track[1] == "foo" and track[2] == "x" and track[3] == "xx" and
- track[4] == "x0")
- end
- local function checktable (t1, t2)
- assert(#t1 == #t2)
- for i = 1, #t1 do
- assert(t1[i] == t2[i])
- end
- end
- do -- test for tbc variable high in the stack
- -- function to force a stack overflow
- local function overflow (n)
- overflow(n + 1)
- end
- -- error handler will create tbc variable handling a stack overflow,
- -- high in the stack
- local function errorh (m)
- assert(string.find(m, "stack overflow"))
- local x <close> = func2close(function (o) o[1] = 10 end)
- return x
- end
- local flag
- local st, obj
- -- run test in a coroutine so as not to swell the main stack
- local co = coroutine.wrap(function ()
- -- tbc variable down the stack
- local y <close> = func2close(function (obj, msg)
- assert(msg == nil)
- obj[1] = 100
- flag = obj
- end)
- tracegc.stop()
- st, obj = xpcall(overflow, errorh, 0)
- tracegc.start()
- end)
- co()
- assert(not st and obj[1] == 10 and flag[1] == 100)
- end
- if rawget(_G, "T") then
- do
- -- bug in 5.4.3
- -- 'lua_settop' may use a pointer to stack invalidated by 'luaF_close'
- -- reduce stack size
- collectgarbage(); collectgarbage(); collectgarbage()
- -- force a stack reallocation
- local function loop (n)
- if n < 400 then loop(n + 1) end
- end
- -- close metamethod will reallocate the stack
- local o = setmetatable({}, {__close = function () loop(0) end})
- local script = [[toclose 2; settop 1; return 1]]
- assert(T.testC(script, o) == script)
- end
- -- memory error inside closing function
- local function foo ()
- local y <close> = func2close(function () T.alloccount() end)
- local x <close> = setmetatable({}, {__close = function ()
- T.alloccount(0); local x = {} -- force a memory error
- end})
- error(1000) -- common error inside the function's body
- end
- stack(5) -- ensure a minimal number of CI structures
- -- despite memory error, 'y' will be executed and
- -- memory limit will be lifted
- local _, msg = pcall(foo)
- assert(msg == "not enough memory")
- local closemsg
- local close = func2close(function (self, msg)
- T.alloccount()
- closemsg = msg
- end)
- -- set a memory limit and return a closing object to remove the limit
- local function enter (count)
- stack(10) -- reserve some stack space
- T.alloccount(count)
- closemsg = nil
- return close
- end
- local function test ()
- local x <close> = enter(0) -- set a memory limit
- local y = {} -- raise a memory error
- end
- local _, msg = pcall(test)
- assert(msg == "not enough memory" and closemsg == "not enough memory")
- -- repeat test with extra closing upvalues
- local function test ()
- local xxx <close> = func2close(function (self, msg)
- assert(msg == "not enough memory");
- error(1000) -- raise another error
- end)
- local xx <close> = func2close(function (self, msg)
- assert(msg == "not enough memory");
- end)
- local x <close> = enter(0) -- set a memory limit
- local y = {} -- raise a memory error
- end
- local _, msg = pcall(test)
- assert(msg == 1000 and closemsg == "not enough memory")
- do -- testing 'toclose' in C string buffer
- collectgarbage()
- local s = string.rep('a', 10000) -- large string
- local m = T.totalmem()
- collectgarbage("stop")
- s = string.upper(s) -- allocate buffer + new string (10K each)
- -- ensure buffer was deallocated
- assert(T.totalmem() - m <= 11000)
- collectgarbage("restart")
- end
- do -- now some tests for freeing buffer in case of errors
- local lim = 10000 -- some size larger than the static buffer
- local extra = 2000 -- some extra memory (for callinfo, etc.)
- local s = string.rep("a", lim)
- -- concat this table needs two buffer resizes (one for each 's')
- local a = {s, s}
- collectgarbage(); collectgarbage()
- m = T.totalmem()
- collectgarbage("stop")
- -- error in the first buffer allocation
- T. totalmem(m + extra)
- assert(not pcall(table.concat, a))
- -- first buffer was not even allocated
- assert(T.totalmem() - m <= extra)
- -- error in the second buffer allocation
- T. totalmem(m + lim + extra)
- assert(not pcall(table.concat, a))
- -- first buffer was released by 'toclose'
- assert(T.totalmem() - m <= extra)
- -- error in creation of final string
- T.totalmem(m + 2 * lim + extra)
- assert(not pcall(table.concat, a))
- -- second buffer was released by 'toclose'
- assert(T.totalmem() - m <= extra)
- -- userdata, buffer, buffer, final string
- T.totalmem(m + 4*lim + extra)
- assert(#table.concat(a) == 2*lim)
- T.totalmem(0) -- remove memory limit
- collectgarbage("restart")
- print'+'
- end
- do
- -- '__close' vs. return hooks in C functions
- local trace = {}
- local function hook (event)
- trace[#trace + 1] = event .. " " .. (debug.getinfo(2).name or "?")
- end
- -- create tbc variables to be used by C function
- local x = func2close(function (_,msg)
- trace[#trace + 1] = "x"
- end)
- local y = func2close(function (_,msg)
- trace[#trace + 1] = "y"
- end)
- debug.sethook(hook, "r")
- local t = {T.testC([[
- toclose 2 # x
- pushnum 10
- pushint 20
- toclose 3 # y
- return 2
- ]], x, y)}
- debug.sethook()
- -- hooks ran before return hook from 'testC'
- checktable(trace,
- {"return sethook", "y", "return ?", "x", "return ?", "return testC"})
- -- results are correct
- checktable(t, {10, 20})
- end
- end
- do -- '__close' vs. return hooks in Lua functions
- local trace = {}
- local function hook (event)
- trace[#trace + 1] = event .. " " .. debug.getinfo(2).name
- end
- local function foo (...)
- local x <close> = func2close(function (_,msg)
- trace[#trace + 1] = "x"
- end)
- local y <close> = func2close(function (_,msg)
- debug.sethook(hook, "r")
- end)
- return ...
- end
- local t = {foo(10,20,30)}
- debug.sethook()
- checktable(t, {10, 20, 30})
- checktable(trace,
- {"return sethook", "return close", "x", "return close", "return foo"})
- end
- print "to-be-closed variables in coroutines"
- do
- -- yielding inside closing metamethods
- local trace = {}
- local co = coroutine.wrap(function ()
- trace[#trace + 1] = "nowX"
- -- will be closed after 'y'
- local x <close> = func2close(function (_, msg)
- assert(msg == nil)
- trace[#trace + 1] = "x1"
- coroutine.yield("x")
- trace[#trace + 1] = "x2"
- end)
- return pcall(function ()
- do -- 'z' will be closed first
- local z <close> = func2close(function (_, msg)
- assert(msg == nil)
- trace[#trace + 1] = "z1"
- coroutine.yield("z")
- trace[#trace + 1] = "z2"
- end)
- end
- trace[#trace + 1] = "nowY"
- -- will be closed after 'z'
- local y <close> = func2close(function(_, msg)
- assert(msg == nil)
- trace[#trace + 1] = "y1"
- coroutine.yield("y")
- trace[#trace + 1] = "y2"
- end)
- return 10, 20, 30
- end)
- end)
- assert(co() == "z")
- assert(co() == "y")
- assert(co() == "x")
- checktable({co()}, {true, 10, 20, 30})
- checktable(trace, {"nowX", "z1", "z2", "nowY", "y1", "y2", "x1", "x2"})
- end
- do
- -- yielding inside closing metamethods while returning
- -- (bug in 5.4.3)
- local extrares -- result from extra yield (if any)
- local function check (body, extra, ...)
- local t = table.pack(...) -- expected returns
- local co = coroutine.wrap(body)
- if extra then
- extrares = co() -- runs until first (extra) yield
- end
- local res = table.pack(co()) -- runs until yield inside '__close'
- assert(res.n == 2 and res[2] == nil)
- local res2 = table.pack(co()) -- runs until end of function
- assert(res2.n == t.n)
- for i = 1, #t do
- if t[i] == "x" then
- assert(res2[i] == res[1]) -- value that was closed
- else
- assert(res2[i] == t[i])
- end
- end
- end
- local function foo ()
- local x <close> = func2close(coroutine.yield)
- local extra <close> = func2close(function (self)
- assert(self == extrares)
- coroutine.yield(100)
- end)
- extrares = extra
- return table.unpack{10, x, 30}
- end
- check(foo, true, 10, "x", 30)
- assert(extrares == 100)
- local function foo ()
- local x <close> = func2close(coroutine.yield)
- return
- end
- check(foo, false)
- local function foo ()
- local x <close> = func2close(coroutine.yield)
- local y, z = 20, 30
- return x
- end
- check(foo, false, "x")
- local function foo ()
- local x <close> = func2close(coroutine.yield)
- local extra <close> = func2close(coroutine.yield)
- return table.unpack({}, 1, 100) -- 100 nils
- end
- check(foo, true, table.unpack({}, 1, 100))
- end
- do
- -- yielding inside closing metamethods after an error
- local co = coroutine.wrap(function ()
- local function foo (err)
- local z <close> = func2close(function(_, msg)
- assert(msg == nil or msg == err + 20)
- coroutine.yield("z")
- return 100, 200
- end)
- local y <close> = func2close(function(_, msg)
- -- still gets the original error (if any)
- assert(msg == err or (msg == nil and err == 1))
- coroutine.yield("y")
- if err then error(err + 20) end -- creates or changes the error
- end)
- local x <close> = func2close(function(_, msg)
- assert(msg == err or (msg == nil and err == 1))
- coroutine.yield("x")
- return 100, 200
- end)
- if err == 10 then error(err) else return 10, 20 end
- end
- coroutine.yield(pcall(foo, nil)) -- no error
- coroutine.yield(pcall(foo, 1)) -- error in __close
- return pcall(foo, 10) -- 'foo' will raise an error
- end)
- local a, b = co() -- first foo: no error
- assert(a == "x" and b == nil) -- yields inside 'x'; Ok
- a, b = co()
- assert(a == "y" and b == nil) -- yields inside 'y'; Ok
- a, b = co()
- assert(a == "z" and b == nil) -- yields inside 'z'; Ok
- local a, b, c = co()
- assert(a and b == 10 and c == 20) -- returns from 'pcall(foo, nil)'
- local a, b = co() -- second foo: error in __close
- assert(a == "x" and b == nil) -- yields inside 'x'; Ok
- a, b = co()
- assert(a == "y" and b == nil) -- yields inside 'y'; Ok
- a, b = co()
- assert(a == "z" and b == nil) -- yields inside 'z'; Ok
- local st, msg = co() -- reports the error in 'y'
- assert(not st and msg == 21)
- local a, b = co() -- third foo: error in function body
- assert(a == "x" and b == nil) -- yields inside 'x'; Ok
- a, b = co()
- assert(a == "y" and b == nil) -- yields inside 'y'; Ok
- a, b = co()
- assert(a == "z" and b == nil) -- yields inside 'z'; Ok
- local st, msg = co() -- gets final error
- assert(not st and msg == 10 + 20)
- end
- do
- -- an error in a wrapped coroutine closes variables
- local x = false
- local y = false
- local co = coroutine.wrap(function ()
- local xv <close> = func2close(function () x = true end)
- do
- local yv <close> = func2close(function () y = true end)
- coroutine.yield(100) -- yield doesn't close variable
- end
- coroutine.yield(200) -- yield doesn't close variable
- error(23) -- error does
- end)
- local b = co()
- assert(b == 100 and not x and not y)
- b = co()
- assert(b == 200 and not x and y)
- local a, b = pcall(co)
- assert(not a and b == 23 and x and y)
- end
- do
- -- error in a wrapped coroutine raising errors when closing a variable
- local x = 0
- local co = coroutine.wrap(function ()
- local xx <close> = func2close(function (_, msg)
- x = x + 1;
- assert(string.find(msg, "@XXX"))
- error("@YYY")
- end)
- local xv <close> = func2close(function () x = x + 1; error("@XXX") end)
- coroutine.yield(100)
- error(200)
- end)
- assert(co() == 100); assert(x == 0)
- local st, msg = pcall(co); assert(x == 2)
- assert(not st and string.find(msg, "@YYY")) -- should get error raised
- local x = 0
- local y = 0
- co = coroutine.wrap(function ()
- local xx <close> = func2close(function (_, err)
- y = y + 1;
- assert(string.find(err, "XXX"))
- error("YYY")
- end)
- local xv <close> = func2close(function ()
- x = x + 1; error("XXX")
- end)
- coroutine.yield(100)
- return 200
- end)
- assert(co() == 100); assert(x == 0)
- local st, msg = pcall(co)
- assert(x == 1 and y == 1)
- -- should get first error raised
- assert(not st and string.find(msg, "%w+%.%w+:%d+: YYY"))
- end
- -- a suspended coroutine should not close its variables when collected
- local co
- co = coroutine.wrap(function()
- -- should not run
- local x <close> = func2close(function () os.exit(false) end)
- co = nil
- coroutine.yield()
- end)
- co() -- start coroutine
- assert(co == nil) -- eventually it will be collected
- collectgarbage()
- if rawget(_G, "T") then
- print("to-be-closed variables x coroutines in C")
- do
- local token = 0
- local count = 0
- local f = T.makeCfunc[[
- toclose 1
- toclose 2
- return .
- ]]
- local obj = func2close(function (_, msg)
- count = count + 1
- token = coroutine.yield(count, token)
- end)
- local co = coroutine.wrap(f)
- local ct, res = co(obj, obj, 10, 20, 30, 3) -- will return 10, 20, 30
- -- initial token value, after closing 2nd obj
- assert(ct == 1 and res == 0)
- -- run until yield when closing 1st obj
- ct, res = co(100)
- assert(ct == 2 and res == 100)
- res = {co(200)} -- run until end
- assert(res[1] == 10 and res[2] == 20 and res[3] == 30 and res[4] == nil)
- assert(token == 200)
- end
- do
- local f = T.makeCfunc[[
- toclose 1
- return .
- ]]
- local obj = func2close(function ()
- local temp
- local x <close> = func2close(function ()
- coroutine.yield(temp)
- return 1,2,3 -- to be ignored
- end)
- temp = coroutine.yield("closing obj")
- return 1,2,3 -- to be ignored
- end)
- local co = coroutine.wrap(f)
- local res = co(obj, 10, 30, 1) -- will return only 30
- assert(res == "closing obj")
- res = co("closing x")
- assert(res == "closing x")
- res = {co()}
- assert(res[1] == 30 and res[2] == nil)
- end
- do
- -- still cannot yield inside 'closeslot'
- local f = T.makeCfunc[[
- toclose 1
- closeslot 1
- ]]
- local obj = func2close(coroutine.yield)
- local co = coroutine.create(f)
- local st, msg = coroutine.resume(co, obj)
- assert(not st and string.find(msg, "attempt to yield across"))
- -- nor outside a coroutine
- local f = T.makeCfunc[[
- toclose 1
- ]]
- local st, msg = pcall(f, obj)
- assert(not st and string.find(msg, "attempt to yield from outside"))
- end
- end
- -- to-be-closed variables in generic for loops
- do
- local numopen = 0
- local function open (x)
- numopen = numopen + 1
- return
- function () -- iteraction function
- x = x - 1
- if x > 0 then return x end
- end,
- nil, -- state
- nil, -- control variable
- func2close(function () numopen = numopen - 1 end) -- closing function
- end
- local s = 0
- for i in open(10) do
- s = s + i
- end
- assert(s == 45 and numopen == 0)
- local s = 0
- for i in open(10) do
- if i < 5 then break end
- s = s + i
- end
- assert(s == 35 and numopen == 0)
- local s = 0
- for i in open(10) do
- for j in open(10) do
- if i + j < 5 then goto endloop end
- s = s + i
- end
- end
- ::endloop::
- assert(s == 375 and numopen == 0)
- end
- print('OK')
- return 5,f
- end -- }
|