10 files changed, 299 insertions, 100 deletions

diff --git a/unit_tests/scripts/coro/basics.lua b/unit_tests/scripts/coro/basics.lua
deleted file mode 100644
index cd2f410..0000000
--- a/unit_tests/scripts/coro/basics.lua
+++ /dev/null
@@ -1,97 +0,0 @@
-local lanes = require "lanes"
-
-local fixture = require "fixture"
-lanes.finally(fixture.throwing_finalizer)
-
-local utils = lanes.require "_utils"
-local PRINT = utils.MAKE_PRINT()
-
-if true then
-    -- a lane body that just returns some value
-    local lane = function(msg_)
-        local utils = lanes.require "_utils"
-        local PRINT = utils.MAKE_PRINT()
-        PRINT "In lane"
-        assert(msg_ == "hi")
-        return "bye"
-    end
-
-    -- the generator
-    local g1 = lanes.coro("*", {name = "auto"}, lane)
-
-    -- launch lane
-    local h1 = g1("hi")
-
-    local r = h1[1]
-    assert(r == "bye")
-end
-
--- a lane coroutine that yields back what got in, one element at a time
-local yielder = function(...)
-    local utils = lanes.require "_utils"
-    local PRINT = utils.MAKE_PRINT()
-    PRINT "In lane"
-    for _i  = 1, select('#', ...) do
-        local _val = select(_i, ...)
-        PRINT("yielding #", _i, _val)
-        local _ack = coroutine.yield(_val)
-        assert(_ack == _i)
-    end
-    return "done!"
-end
-
-if true then
-    -- if we start a non-coroutine lane with a yielding function, we should get an error, right?
-    local fun_g = lanes.gen("*", { name = 'auto' }, yielder)
-    local h = fun_g("hello", "world", "!")
-    local err, status, stack = h:join()
-    PRINT(err, status, stack)
-    -- the actual error message is not the same for Lua 5.1
-    -- of course, it also has to be different for LuaJIT as well
-    -- also, LuaJIT prepends a file:line to the actual error message, which Lua5.1 does not.
-    local msgs = {
-        ["Lua 5.1"] = jit and "attempt to yield across C-call boundary" or "attempt to yield across metamethod/C-call boundary",
-        ["Lua 5.2"] = "attempt to yield from outside a coroutine",
-        ["Lua 5.3"] = "attempt to yield from outside a coroutine",
-        ["Lua 5.4"] = "attempt to yield from outside a coroutine"
-    }
-    local expected_msg = msgs[_VERSION]
-    PRINT("expected_msg = " .. expected_msg)
-    assert(err == nil and string.find(status, expected_msg, 1, true) and stack == nil, "status = " .. status)
-end
-
--- the generator
-local coro_g = lanes.coro("*", {name = "auto"}, yielder)
-
-if true then
-    -- launch coroutine lane
-    local h2 = coro_g("hello", "world", "!")
-    -- read the yielded values, sending back the expected index
-    assert(h2:resume(1) == "hello")
-    assert(h2:resume(2) == "world")
-    assert(h2:resume(3) == "!")
-    -- the lane return value is available as usual
-    local r = h2[1]
-    assert(r == "done!")
-end
-
-if true then
-    -- another coroutine lane
-    local h3 = coro_g("hello", "world", "!")
-
-    -- yielded values are available as regular return values
-    assert(h3[1] == "hello" and h3.status == "suspended")
-    -- since we consumed the returned values, they should not be here when we resume
-    assert(h3:resume(1) == nil)
-
-    -- similarly, we can get them with join()
-    assert(h3:join() == "world" and h3.status == "suspended")
-    -- since we consumed the returned values, they should not be here when we resume
-    assert(h3:resume(2) == nil)
-
-    -- the rest should work as usual
-    assert(h3:resume(3) == "!")
-
-    -- the final return value of the lane body remains to be read
-    assert(h3:join() == "done!" and h3.status == "done")
-end
diff --git a/unit_tests/scripts/coro/cancelling_suspended.lua b/unit_tests/scripts/coro/cancelling_suspended.lua
new file mode 100644
index 0000000..3a29e55
--- /dev/null
+++ b/unit_tests/scripts/coro/cancelling_suspended.lua
@@ -0,0 +1,31 @@
+local fixture = require "fixture"
+local lanes = require "lanes".configure{on_state_create = fixture.on_state_create}
+
+local fixture = require "fixture"
+lanes.finally(fixture.throwing_finalizer)
+
+local utils = lanes.require "_utils"
+local PRINT = utils.MAKE_PRINT()
+
+--------------------------------------------------
+-- TEST: cancelling a suspended Lane should end it
+--------------------------------------------------
+if true then
+        -- the generator
+        local coro_g = lanes.coro("*", utils.yield_one_by_one)
+
+        -- start the lane
+        local h = coro_g("hello", "world", "!")
+        repeat until h.status == "suspended"
+
+        -- first cancellation attempt: don't wake the lane
+        local b, r = h:cancel("soft", 0.5)
+        -- the lane is still blocked in its suspended state
+        assert(b == false and r == "timeout" and h.status == "suspended", "got " .. tostring(b) .. " " .. tostring(r) .. " " .. h.status)
+
+        -- cancel the Lane again, this time waking it. it will resume, and yielder()'s will break out of its infinite loop
+        h:cancel("soft", nil, true)
+
+        -- lane should be done, because it returned cooperatively when detecting a soft cancel
+        assert(h.status == "done", "got " .. h.status)
+end
diff --git a/unit_tests/scripts/coro/collect_yielded_lane.lua b/unit_tests/scripts/coro/collect_yielded_lane.lua
new file mode 100644
index 0000000..2ee58f8
--- /dev/null
+++ b/unit_tests/scripts/coro/collect_yielded_lane.lua
@@ -0,0 +1,64 @@
+local fixture = require "fixture"
+local lanes = require "lanes".configure{on_state_create = fixture.on_state_create}
+
+local fixture = require "fixture"
+lanes.finally(fixture.throwing_finalizer)
+
+-- this test is only for Lua 5.4+
+local utils = lanes.require "_utils54"
+local PRINT = utils.MAKE_PRINT()
+
+local out_linda = lanes.linda()
+
+------------------------------------------------------------------------------
+-- TEST: to-be-closed variables are properly closed when the lane is collected
+------------------------------------------------------------------------------
+if true then
+        -- the generator
+        local coro_g = lanes.coro("*", utils.yielder_with_to_be_closed)
+
+        -- start the lane
+        local h = coro_g(out_linda)
+
+        -- join the lane. it should be done and give back the values resulting of the first yield point
+        local r, v1, v2 = h:join()
+        assert(r == true and v1 == "I yield!" and v2 == 1, "got " .. tostring(r) .. " " .. tostring(v1) .. " " .. tostring(v2))
+        assert(h.status == "done", "got " .. h.status)
+
+        -- force collection of the lane
+        h = nil
+        collectgarbage()
+
+        -- I want the to-be-closed variable of the coroutine linda to be properly closed
+        local s, r = out_linda:receive(0, "out")
+        assert(s == "out" and r == "Closed!", "coro got " .. tostring(s) .. " " .. tostring(r)) -- THIS TEST FAILS
+end
+
+---------------------------------------------------------------------------------------------------
+-- TEST: if a to-be-closed handler takes longer than the join timeout, everything works as expected
+---------------------------------------------------------------------------------------------------
+if true then
+        -- the generator
+        local coro_g = lanes.coro("*", utils.yielder_with_to_be_closed)
+
+        -- start the lane. The to-be-closed handler will sleep for 1 second
+        local h = coro_g(out_linda, 1)
+
+        -- first join attempt should timeout
+        local r, v = h:join(0.6)
+        assert(r == nil and v == "timeout", "got " .. tostring(r) .. " " .. tostring(v))
+        assert(h.status == "running", "got " .. h.status)
+
+        -- join the lane again. it should be done and give back the values resulting of the first yield point
+        local r, v1, v2 = h:join(0.6)
+        assert(r == true and v1 == "I yield!" and v2 == 1, "got " .. tostring(r) .. " " .. tostring(v1) .. " " .. tostring(v2))
+        assert(h.status == "done", "got " .. h.status)
+
+        -- force collection of the lane
+        h = nil
+        collectgarbage()
+
+        -- I want the to-be-closed variable of the coroutine linda to be properly closed
+        local s, r = out_linda:receive(0, "out")
+        assert(s == "out" and r == "Closed!", "coro got " .. tostring(s) .. " " .. tostring(r)) -- THIS TEST FAILS
+end
diff --git a/unit_tests/scripts/coro/error_handling.lua b/unit_tests/scripts/coro/error_handling.lua
index ba6cff6..1cfb8c8 100644
--- a/unit_tests/scripts/coro/error_handling.lua
+++ b/unit_tests/scripts/coro/error_handling.lua
@@ -38,15 +38,15 @@ local force_error_test = function(error_trace_level_)
     utils.dump_error_stack(error_trace_level_, c)
 end
 
-if false then
+if true then
     force_error_test("minimal")
 end
 
-if false then
+if true then
     force_error_test("basic")
 end
 
-if false then
+if true then
     force_error_test("extended")
 end
 
diff --git a/unit_tests/scripts/coro/index_suspended.lua b/unit_tests/scripts/coro/index_suspended.lua
new file mode 100644
index 0000000..2cd8c28
--- /dev/null
+++ b/unit_tests/scripts/coro/index_suspended.lua
@@ -0,0 +1,28 @@
+local lanes = require "lanes"
+
+local fixture = require "fixture"
+lanes.finally(fixture.throwing_finalizer)
+
+local utils = lanes.require "_utils"
+local PRINT = utils.MAKE_PRINT()
+
+-- the coroutine generator
+local coro_g = lanes.coro("*", {name = "auto"}, utils.yield_one_by_one)
+
+-------------------------------------------------------------------------
+-- TEST: if we index a yielded lane, we should get the last yielded value
+-------------------------------------------------------------------------
+if true then
+    -- launch coroutine lane
+    local h = coro_g("hello", "world", "!")
+    -- read the first yielded value, sending back the expected index
+    assert(h:resume(1) == "hello")
+    -- indexing multiple times gives back the same us the same yielded value
+    local r1 = h[1]
+    local r2 = h[1]
+    local r3 = h[1]
+    assert(r1 == "world" and r2 == "world" and r3 == "world", "got " .. r1 .. " " .. r2 .. " " .. r3)
+    -- once the lane was indexed, it is no longer resumable (just like after join)
+    local b, e = pcall(h.resume, h, 2)
+    assert(b == false and e == "cannot resume non-suspended coroutine Lane")
+end
diff --git a/unit_tests/scripts/coro/join_suspended.lua b/unit_tests/scripts/coro/join_suspended.lua
new file mode 100644
index 0000000..33be406
--- /dev/null
+++ b/unit_tests/scripts/coro/join_suspended.lua
@@ -0,0 +1,24 @@
+local lanes = require "lanes"
+
+local fixture = require "fixture"
+lanes.finally(fixture.throwing_finalizer)
+
+local utils = lanes.require "_utils"
+local PRINT = utils.MAKE_PRINT()
+
+-- the coroutine generator
+local coro_g = lanes.coro("*", {name = "auto"}, utils.yield_one_by_one)
+
+---------------------------------------------------
+-- TEST: if we join a yielded lane, the lane aborts
+---------------------------------------------------
+if true then
+    -- launch coroutine lane
+    local h = coro_g("hello", "world", "!")
+    -- read the first yielded value, sending back the expected index
+    assert(h:resume(1) == "hello")
+    -- join the lane. since it will reach a yield point, it unblocks and ends. last yielded values are returned normally
+    local b, r = h:join(0.5)
+    local s = h.status
+    assert(s == "done" and b == true and r == "world", "got " .. s .. " " .. tostring(b) .. " " .. tostring(r))
+end
diff --git a/unit_tests/scripts/coro/linda_in_close_handler.lua b/unit_tests/scripts/coro/linda_in_close_handler.lua
new file mode 100644
index 0000000..8636f01
--- /dev/null
+++ b/unit_tests/scripts/coro/linda_in_close_handler.lua
@@ -0,0 +1,43 @@
+local fixture = require "fixture"
+local lanes = require "lanes".configure{on_state_create = fixture.on_state_create}
+
+local fixture = require "fixture"
+lanes.finally(fixture.throwing_finalizer)
+
+-- this test is only for Lua 5.4+
+local utils = lanes.require "_utils54"
+local PRINT = utils.MAKE_PRINT()
+
+local out_linda = lanes.linda()
+
+local test_close = function(what_, f_)
+        local c = coroutine.create(f_)
+        for i = 1, 10 do
+                local t, r1, r2 = coroutine.resume(c, out_linda) -- returns true + <yielded values>
+                assert(t == true and r1 == "I yield!" and r2 == i, "got " .. tostring(t) .. " " .. tostring(r1) .. " " .. tostring(r2))
+                local s = coroutine.status(c)
+                assert(s == "suspended")
+        end
+        local r, s = coroutine.close(c)
+        assert(r == true and s == nil)
+        -- the local variable inside the yielder body should be closed
+        local s, r = out_linda:receive(0, "out")
+        assert(s == "out" and r == "Closed!", what_ .. " got " .. tostring(s) .. " " .. tostring(r))
+end
+
+---------------------------------------------------------
+-- TEST: first, try the close mechanism outside of a lane
+---------------------------------------------------------
+if true then
+        assert(type(utils.yielder_with_to_be_closed) == "function")
+        test_close("base", utils.yielder_with_to_be_closed)
+end
+
+---------------------------------------------------------------
+-- TEST: try again with a function obtained through dump/undump
+---------------------------------------------------------------
+if true then
+        -- note this means our yielder implementation can't have upvalues, as they are lost in the process
+        test_close("dumped", load(string.dump(utils.yielder_with_to_be_closed)))
+end
+
diff --git a/unit_tests/scripts/coro/regular_function.lua b/unit_tests/scripts/coro/regular_function.lua
new file mode 100644
index 0000000..09aa3b7
--- /dev/null
+++ b/unit_tests/scripts/coro/regular_function.lua
@@ -0,0 +1,38 @@
+local lanes = require "lanes".configure()
+
+local utils = lanes.require "_utils"
+local PRINT = utils.MAKE_PRINT()
+
+-- a lane body that just returns some value
+local returner = function(msg_)
+    local utils = lanes.require "_utils"
+    local PRINT = utils.MAKE_PRINT()
+    PRINT "In lane"
+    assert(msg_ == "hi")
+    return "bye"
+end
+
+-- a function that returns some value can run in a coroutine
+if true then
+    -- the generator
+    local g = lanes.coro("*", {name = "auto"}, returner)
+
+    -- launch lane
+    local h = g("hi")
+
+    local r = h[1]
+    assert(r == "bye")
+end
+
+-- can't resume a coro after the lane body has returned
+if true then
+    -- the generator
+    local g = lanes.coro("*", {name = "auto"}, returner)
+
+    -- launch lane
+    local h = g("hi")
+
+    -- resuming a lane that terminated execution should raise an error
+    local b, e = pcall(h.resume, h)
+    assert(b == false and type(e) == "string")
+end
diff --git a/unit_tests/scripts/coro/resume_basics.lua b/unit_tests/scripts/coro/resume_basics.lua
new file mode 100644
index 0000000..5b124f5
--- /dev/null
+++ b/unit_tests/scripts/coro/resume_basics.lua
@@ -0,0 +1,40 @@
+local lanes = require "lanes"
+
+local fixture = require "fixture"
+lanes.finally(fixture.throwing_finalizer)
+
+local utils = lanes.require "_utils"
+local PRINT = utils.MAKE_PRINT()
+
+-- the coroutine generator
+local coro_g = lanes.coro("*", {name = "auto"}, utils.yield_one_by_one)
+
+-------------------------------------------------------------------------------------------------
+-- TEST: we can resume as many times as the lane yields, then read the returned value on indexing
+-------------------------------------------------------------------------------------------------
+if true then
+    -- launch coroutine lane
+    local h = coro_g("hello", "world", "!")
+    -- read the yielded values, sending back the expected index
+    assert(h:resume(1) == "hello")
+    assert(h:resume(2) == "world")
+    assert(h:resume(3) == "!")
+    -- the lane return value is available as usual
+    local r = h[1]
+    assert(r == "bye!")
+end
+
+---------------------------------------------------------------------------------------------
+-- TEST: we can resume as many times as the lane yields, then read the returned value on join
+---------------------------------------------------------------------------------------------
+if true then
+    -- launch coroutine lane
+    local h = coro_g("hello", "world", "!")
+    -- read the yielded values, sending back the expected index
+    assert(h:resume(1) == "hello")
+    assert(h:resume(2) == "world")
+    assert(h:resume(3) == "!")
+    -- the lane return value is available as usual
+    local s, r = h:join()
+    assert(h.status == "done" and s == true and r == "bye!")
+end
diff --git a/unit_tests/scripts/coro/yielding_in_non_coro_errors.lua b/unit_tests/scripts/coro/yielding_in_non_coro_errors.lua
new file mode 100644
index 0000000..fc0c072
--- /dev/null
+++ b/unit_tests/scripts/coro/yielding_in_non_coro_errors.lua
@@ -0,0 +1,28 @@
+local lanes = require "lanes"
+
+local fixture = require "fixture"
+lanes.finally(fixture.throwing_finalizer)
+
+local utils = lanes.require "_utils"
+local PRINT = utils.MAKE_PRINT()
+
+--------------------------------------------------------------------------------------------------
+-- TEST: if we start a non-coroutine lane with a yielding function, we should get an error, right?
+--------------------------------------------------------------------------------------------------
+local fun_g = lanes.gen("*", { name = 'auto' }, utils.yield_one_by_one)
+local h = fun_g("hello", "world", "!")
+local err, status, stack = h:join()
+PRINT(err, status, stack)
+-- the actual error message is not the same for Lua 5.1
+-- of course, it also has to be different for LuaJIT as well
+-- also, LuaJIT prepends a file:line to the actual error message, which Lua5.1 does not.
+local msgs = {
+    ["Lua 5.1"] = jit and "attempt to yield across C-call boundary" or "attempt to yield across metamethod/C-call boundary",
+    ["Lua 5.2"] = "attempt to yield from outside a coroutine",
+    ["Lua 5.3"] = "attempt to yield from outside a coroutine",
+    ["Lua 5.4"] = "attempt to yield from outside a coroutine",
+    ["Lua 5.5"] = "attempt to yield from outside a coroutine"
+}
+local expected_msg = msgs[_VERSION]
+PRINT("expected_msg = " .. expected_msg)
+assert(err == nil and string.find(status, expected_msg, 1, true) and stack == nil, "status = " .. status)