9 files changed, 177 insertions, 91 deletions

diff --git a/unit_tests/scripts/lane/body_is_a_c_function.lua b/unit_tests/scripts/lane/body_is_a_c_function.lua
new file mode 100644
index 0000000..d8d329f
--- /dev/null
+++ b/unit_tests/scripts/lane/body_is_a_c_function.lua
@@ -0,0 +1,28 @@
+local lanes = require "lanes".configure()
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+-- we can create a generator where the lane body is a C function
+do
+    local b, g = pcall(lanes.gen, "*", print)
+    assert(b == true and type(g) == "function")
+    -- we can start the lane
+    local b, h = pcall(g, "hello")
+    -- the lane runs normally
+    h:join()
+    assert(h.status == "done")
+end
+
+-- we can create a generator where the lane body is a C function that raises an error
+do
+    local b, g = pcall(lanes.gen, "*", error)
+    assert(b == true and type(g) == "function")
+    -- we can start the lane
+    local b, h = pcall(g, "this is an error")
+    -- this provides the error that occurred in the lane
+    local s, e, t = h:join()
+    assert(h.status == "error")
+    assert(s == nil and e == "this is an error" and t == nil)
+end
diff --git a/unit_tests/scripts/lane/cooperative_shutdown.lua b/unit_tests/scripts/lane/cooperative_shutdown.lua
index 756e33c..0a0943e 100644
--- a/unit_tests/scripts/lane/cooperative_shutdown.lua
+++ b/unit_tests/scripts/lane/cooperative_shutdown.lua
@@ -1,10 +1,10 @@
-local lanes = require "lanes"
+local lanes = require "lanes".configure{on_state_create = require "fixture".on_state_create}
 
 -- launch lanes that cooperate properly with cancellation request
 
 local lane1 = function()
         lane_threadname("lane1")
-        -- loop breaks on cancellation request
+        -- loop breaks on soft cancellation request
         repeat
                 lanes.sleep(0)
         until cancel_test()
@@ -23,7 +23,6 @@ end
 local lane3 = function()
         lane_threadname("lane3")
         -- this one cooperates too, because of the hook cancellation modes that Lanes will be using
-        -- but not with LuaJIT, because the function is compiled, and we don't call anyone, so no hook triggers
         local fixture = require "fixture"
         repeat until fixture.give_me_back(false)
 end
@@ -43,7 +42,14 @@ local h2 = g2(linda)
 
 local h3 = g3()
 
--- wait until they are both started
-repeat until h1.status == "running" and h2.status == "waiting" and h3.status == "running"
+lanes.sleep(0.1)
+
+local is_running = function(lane_h)
+        local status = lane_h.status
+        return status == "running" or status == "waiting"
+end
+
+-- wait until they are all started
+repeat until is_running(h1) and is_running(h2) and is_running(h3)
 
 -- let the script terminate, Lanes should not crash at shutdown
diff --git a/unit_tests/scripts/lane/tasking_cancelling.lua b/unit_tests/scripts/lane/tasking_cancelling.lua
index 85600ab..d153ffa 100644
--- a/unit_tests/scripts/lane/tasking_cancelling.lua
+++ b/unit_tests/scripts/lane/tasking_cancelling.lua
@@ -1,4 +1,7 @@
-local require_lanes_result_1, require_lanes_result_2 = require "lanes".configure(config).configure()
+local require_fixture_result_1, require_fixture_result_2 = require "fixture"
+local fixture = assert(require_fixture_result_1)
+
+local require_lanes_result_1, require_lanes_result_2 = require "lanes".configure{on_state_create = fixture.on_state_create}.configure()
 print("require_lanes_result:", require_lanes_result_1, require_lanes_result_2)
 local lanes = require_lanes_result_1
 
@@ -15,69 +18,34 @@ local lanes_linda = assert(lanes.linda)
 -- ##################################################################################################
 -- ##################################################################################################
 
-local function task(a, b, c)
-    lane_threadname("task("..a..","..b..","..c..")")
-    --error "111"     -- testing error messages
-    assert(hey)
-    local v=0
-    for i=a,b,c do
-        v= v+i
-    end
-    return v, hey
-end
-
-local gc_cb = function(name_, status_)
-    PRINT("                             ---> lane '" .. name_ .. "' collected with status '" .. status_ .. "'")
+-- cancellation of cooperating lanes
+local cooperative = function()
+    local fixture = assert(require "fixture")
+    local which_cancel
+    repeat
+        fixture.block_for(0.2)
+        which_cancel = cancel_test()
+    until which_cancel
+    return which_cancel
 end
+-- soft and hard are behaviorally equivalent when no blocking linda operation is involved
+local cooperative_lane_soft = lanes_gen("*", { name = 'auto' }, cooperative)()
+local a, b = cooperative_lane_soft:cancel("soft", 0) -- issue request, do not wait for lane to terminate
+assert(a == false and b == "timeout", "got " .. tostring(a) .. " " .. tostring(b))
+assert(cooperative_lane_soft[1] == "soft") -- return value of the lane body is the value returned by cancel_test()
+local cooperative_lane_hard = lanes_gen("*", { name = 'auto' }, cooperative)()
+local c, d = cooperative_lane_hard:cancel("hard", 0) -- issue request, do not wait for lane to terminate
+assert(a == false and b == "timeout", "got " .. tostring(c) .. " " .. tostring(d))
+assert(cooperative_lane_hard[1] == "hard") -- return value of the lane body is the value returned by cancel_test()
 
 -- ##################################################################################################
--- ##################################################################################################
--- ##################################################################################################
-
-PRINT("\n\n", "---=== Tasking (cancelling) ===---", "\n\n")
-
-local task_launch2 = lanes_gen("", { name = 'auto', globals={hey=true}, gc_cb = gc_cb }, task)
-
-local N=999999999
-local lane9= task_launch2(1,N,1)   -- huuuuuuge...
-
--- Wait until state changes "pending"->"running"
---
-local st
-local t0= os.time()
-while os.time()-t0 < 5 do
-    st= lane9.status
-    io.stderr:write((i==1) and st.." " or '.')
-    if st~="pending" then break end
-end
-PRINT(" "..st)
-
-if st=="error" then
-    local _= lane9[0]  -- propagate the error here
-end
-if st=="done" then
-    error("Looping to "..N.." was not long enough (cannot test cancellation)")
-end
-assert(st=="running", "st == " .. st)
-
--- when running under luajit, the function is JIT-ed, and the instruction count isn't hit, so we need a different hook
-lane9:cancel(jit and "line" or "count", 100) -- 0 timeout, hook triggers cancelslation when reaching the specified count
-
-local t0= os.time()
-while os.time()-t0 < 5 do
-    st= lane9.status
-    io.stderr:write((i==1) and st.." " or '.')
-    if st~="running" then break end
-end
-PRINT(" "..st)
-assert(st == "cancelled", "st is '" .. st .. "' instead of 'cancelled'")
 
 -- cancellation of lanes waiting on a linda
-local limited = lanes_linda("limited")
+local limited = lanes_linda{name = "limited"}
 assert.fails(function() limited:limit("key", -1) end)
 assert.failsnot(function() limited:limit("key", 1) end)
 -- [[################################################
-limited:send("key", "hello") -- saturate linda
+limited:send("key", "hello") -- saturate linda, so that subsequent sends will block
 for k, v in pairs(limited:dump()) do
     PRINT("limited[" .. tostring(k) .. "] = " .. tostring(v))
 end
@@ -88,11 +56,15 @@ local wait_send = function()
 end
 
 local wait_send_lane = lanes_gen("*", { name = 'auto' }, wait_send)()
-repeat until wait_send_lane.status == "waiting"
-print "wait_send_lane is waiting"
+repeat
+    io.stderr:write('!')
+    -- currently mingw64 builds can deadlock if we cancel the lane too early (before the linda blocks, at it causes the linda condvar not to be signalled)
+    lanes.sleep(0.1)
+until wait_send_lane.status == "waiting"
+PRINT "wait_send_lane is waiting"
 wait_send_lane:cancel() -- hard cancel, 0 timeout
 repeat until wait_send_lane.status == "cancelled"
-print "wait_send_lane is cancelled"
+PRINT "wait_send_lane is cancelled"
 --################################################]]
 local wait_receive = function()
     local k, v
@@ -101,22 +73,30 @@ local wait_receive = function()
 end
 
 local wait_receive_lane = lanes_gen("*", { name = 'auto' }, wait_receive)()
-repeat until wait_receive_lane.status == "waiting"
-print "wait_receive_lane is waiting"
+repeat
+    io.stderr:write('!')
+    -- currently mingw64 builds can deadlock if we cancel the lane too early (before the linda blocks, at it causes the linda condvar not to be signalled)
+    lanes.sleep(0.1)
+until wait_receive_lane.status == "waiting"
+PRINT "wait_receive_lane is waiting"
 wait_receive_lane:cancel() -- hard cancel, 0 timeout
 repeat until wait_receive_lane.status == "cancelled"
-print "wait_receive_lane is cancelled"
+PRINT "wait_receive_lane is cancelled"
 --################################################]]
 local wait_receive_batched = function()
     local k, v1, v2
     set_finalizer(function() print("wait_receive_batched", k, v1, v2) end)
-    k, v1, v2 = limited:receive(limited.batched, "dummy", 2) -- infinite timeout, returns only when lane is cancelled
+    k, v1, v2 = limited:receive_batched("dummy", 2) -- infinite timeout, returns only when lane is cancelled
 end
 
 local wait_receive_batched_lane = lanes_gen("*", { name = 'auto' }, wait_receive_batched)()
-repeat until wait_receive_batched_lane.status == "waiting"
-print "wait_receive_batched_lane is waiting"
+repeat
+    io.stderr:write('!')
+    -- currently mingw64 builds can deadlock if we cancel the lane too early (before the linda blocks, at it causes the linda condvar not to be signalled)
+    lanes.sleep(0.1)
+until wait_receive_batched_lane.status == "waiting"
+PRINT "wait_receive_batched_lane is waiting"
 wait_receive_batched_lane:cancel() -- hard cancel, 0 timeout
 repeat until wait_receive_batched_lane.status == "cancelled"
-print "wait_receive_batched_lane is cancelled"
+PRINT "wait_receive_batched_lane is cancelled"
 --################################################]]
diff --git a/unit_tests/scripts/lane/tasking_cancelling_with_hook.lua b/unit_tests/scripts/lane/tasking_cancelling_with_hook.lua
new file mode 100644
index 0000000..56b934f
--- /dev/null
+++ b/unit_tests/scripts/lane/tasking_cancelling_with_hook.lua
@@ -0,0 +1,68 @@
+local require_lanes_result_1, require_lanes_result_2 = require "lanes".configure(config).configure()
+print("require_lanes_result:", require_lanes_result_1, require_lanes_result_2)
+local lanes = require_lanes_result_1
+
+local require_assert_result_1, require_assert_result_2 = require "_assert"
+print("require_assert_result:", require_assert_result_1, require_assert_result_2)
+
+local utils = lanes.require "_utils"
+local PRINT = utils.MAKE_PRINT()
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local function task(a, b, c)
+    lane_threadname("task("..a..","..b..","..c..")")
+    --error "111"     -- testing error messages
+    assert(hey)
+    local v=0
+    for i=a,b,c do
+        v= v+i
+    end
+    return v, hey
+end
+
+local gc_cb = function(name_, status_)
+    PRINT("                             ---> lane '" .. name_ .. "' collected with status '" .. status_ .. "'")
+end
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local generator = lanes.gen("", { name = 'auto', globals={hey=true}, gc_cb = gc_cb }, task)
+
+local N = 999999999
+local lane_h = generator(1,N,1)   -- huuuuuuge...
+
+-- Wait until state changes "pending"->"running"
+--
+local st
+local t0 = os.time()
+while os.time()-t0 < 5 do
+    st = lane_h.status
+    io.stderr:write((i==1) and st.." " or '.')
+    if st~="pending" then break end
+end
+PRINT(" "..st)
+
+if st == "error" then
+    local _ = lane_h[0]  -- propagate the error here
+end
+if st == "done" then
+    error("Looping to "..N.." was not long enough (cannot test cancellation)")
+end
+assert(st == "running", "st == " .. st)
+
+-- when running under luajit, the function is JIT-ed, and the instruction count isn't hit, so we need a different hook
+lane_h:cancel(jit and "line" or "count", 100) -- 0 timeout, hook triggers cancelslation when reaching the specified count
+
+local t0 = os.time()
+while os.time()-t0 < 5 do
+    st = lane_h.status
+    io.stderr:write((i==1) and st.." " or '.')
+    if st~="running" then break end
+end
+PRINT(" "..st)
+assert(st == "cancelled", "st is '" .. st .. "' instead of 'cancelled'")
diff --git a/unit_tests/scripts/lane/tasking_comms_criss_cross.lua b/unit_tests/scripts/lane/tasking_comms_criss_cross.lua
index 497e81d..610da8b 100644
--- a/unit_tests/scripts/lane/tasking_comms_criss_cross.lua
+++ b/unit_tests/scripts/lane/tasking_comms_criss_cross.lua
@@ -42,7 +42,7 @@ local tc = lanes_gen("io", { name = 'auto', gc_cb = gc_cb },
   end
 )
 
-local linda= lanes_linda("criss cross")
+local linda= lanes_linda{name = "criss cross"}
 
 local a,b= tc(linda, "A","B"), tc(linda, "B","A")   -- launching two lanes, twisted comms
 
diff --git a/unit_tests/scripts/lane/tasking_communications.lua b/unit_tests/scripts/lane/tasking_communications.lua
index 1fd43b0..01842b4 100644
--- a/unit_tests/scripts/lane/tasking_communications.lua
+++ b/unit_tests/scripts/lane/tasking_communications.lua
@@ -72,7 +72,7 @@ local chunk= function(linda)
     WR("chunk ", "Lane ends!\n")
 end
 
-local linda = lanes_linda("communications")
+local linda = lanes_linda{name = "communications"}
 assert(type(linda) == "userdata" and tostring(linda) == "Linda: communications")
     --
     -- ["->"] master -> slave
@@ -90,7 +90,7 @@ local b,x,y,z,w = linda:get("<->", 4)
 assert(b == 3 and x == "x" and y == "y" and z == "z" and w == nil)
 local k, x = linda:receive("<->")
 assert(k == "<->" and x == "x")
-local k,y,z = linda:receive(linda.batched, "<->", 2)
+local k,y,z = linda:receive_batched("<->", 2)
 assert(k == "<->" and y == "y" and z == "z")
 linda:set("<->")
 local b,x,y,z,w = linda:get("<->", 4)
diff --git a/unit_tests/scripts/lane/tasking_join_test.lua b/unit_tests/scripts/lane/tasking_join_test.lua
index 2fbce6c..495a709 100644
--- a/unit_tests/scripts/lane/tasking_join_test.lua
+++ b/unit_tests/scripts/lane/tasking_join_test.lua
@@ -30,14 +30,19 @@ end
 
 PRINT("---=== :join test ===---", "\n\n")
 
+-- a lane body that returns nothing is successfully joined with true, nil
+local r, ret = lanes_gen(function() end)():join()
+assert(r == true and ret == nil)
+
 -- NOTE: 'unpack()' cannot be used on the lane handle; it will always return nil
 --       (unless [1..n] has been read earlier, in which case it would seemingly
 --       work).
 
-local S= lanes_gen("table", { name = 'auto', gc_cb = gc_cb },
+local S = lanes_gen("table", { name = 'auto', gc_cb = gc_cb },
     function(arg)
         lane_threadname "join test lane"
         set_finalizer(function() end)
+        -- take arg table, reverse its contents in aux, then return the unpacked result
         local aux= {}
         for i, v in ipairs(arg) do
            table.insert(aux, 1, v)
@@ -46,15 +51,16 @@ local S= lanes_gen("table", { name = 'auto', gc_cb = gc_cb },
     return (unpack or table.unpack)(aux)
 end)
 
-h= S { 12, 13, 14 }     -- execution starts, h[1..3] will get the return values
+local h = S { 12, 13, 14 }     -- execution starts, h[1..3] will get the return values
 -- wait a bit so that the lane has a chance to set its debug name
 SLEEP(0.5)
 print("joining with '" .. h:get_threadname() .. "'")
-local a,b,c,d= h:join()
+local r, a, b, c, d = h:join()
 if h.status == "error" then
-    print(h:get_threadname(), "error: " , a, b, c, d)
+    print(h:get_threadname(), "error: " , r, a, b, c, d)
 else
-    print(h:get_threadname(), a,b,c,d)
+    print(h:get_threadname(), r, a, b, c, d)
+    assert(r==true, "r == " .. tostring(r))
     assert(a==14, "a == " .. tostring(a))
     assert(b==13, "b == " .. tostring(b))
     assert(c==12, "c == " .. tostring(c))
diff --git a/unit_tests/scripts/lane/tasking_send_receive_code.lua b/unit_tests/scripts/lane/tasking_send_receive_code.lua
index e329a88..fdc2602 100644
--- a/unit_tests/scripts/lane/tasking_send_receive_code.lua
+++ b/unit_tests/scripts/lane/tasking_send_receive_code.lua
@@ -53,28 +53,26 @@ local function chunk2(linda)
     assert(info.linedefined == 32, "bad linedefined")   -- start of 'chunk2'
     assert(config.strip_functions and info.currentline==-1 or info.currentline > info.linedefined, "bad currentline")   -- line of 'debug.getinfo'
     assert(info.lastlinedefined > info.currentline, "bad lastlinedefined")   -- end of 'chunk2'
-    local k,func= linda:receive("down")
-    assert(type(func)=="function", "not a function")
+    assert(linda:count("down") == 2, "bad linda contents") -- function, "ok"
+    local k,func,str= linda:receive_batched("down", 2)
     assert(k=="down")
+    assert(type(func)=="function", "not a function")
+    assert(str=="ok", "bad receive result: " .. tostring(k) .. " -> ".. tostring(str))
+    assert(linda:count("down") == 0, "bad linda contents") -- nothing
 
     func(linda)
-
-    local k,str= linda:receive("down")
-    assert(str=="ok", "bad receive result")
-
     linda:send("up", function() return ":)" end, "ok2")
 end
 
-local linda = lanes_linda("auto")
+local linda = lanes_linda{name = "auto"}
 local t2= lanes_gen("debug,package,string,io", { name = 'auto', gc_cb = gc_cb }, chunk2)(linda)     -- prepare & launch
-linda:send("down", function(linda) linda:send("up", "ready!") end,
-                    "ok")
+linda:send("down", function(linda) linda:send("up", "ready!") end, "ok")
 -- wait to see if the tiny function gets executed
 --
 local k,s= linda:receive(1, "up")
 if t2.status == "error" then
-    PRINT("t2 error: " , t2:join())
-    assert(false)
+    local n,err,s = t2:join()
+    assert(false, "t2 error: " .. err)
 end
 PRINT(s)
 assert(s=="ready!", s .. " is not 'ready!'")
diff --git a/unit_tests/scripts/lane/uncooperative_shutdown.lua b/unit_tests/scripts/lane/uncooperative_shutdown.lua
index 89e1ff8..eb89ed3 100644
--- a/unit_tests/scripts/lane/uncooperative_shutdown.lua
+++ b/unit_tests/scripts/lane/uncooperative_shutdown.lua
@@ -8,7 +8,7 @@ local lanes = require "lanes".configure{shutdown_timeout = 0.001, on_state_creat
 -- launch lanes that blocks forever
 local lane = function()
         local fixture = require "fixture"
-        fixture.sleep_for()
+        fixture.block_for()
 end
 
 -- the generator