1 files changed, 36 insertions, 26 deletions

diff --git a/tests/basic.lua b/tests/basic.lua
index 068dc25..f393175 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -163,7 +163,7 @@ 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)
 -- [[################################################
@@ -173,42 +173,51 @@ for k, v in pairs(limited:dump()) do
 end
 local wait_send = function()
     local a,b
-    set_finalizer(function() print("wait_send", a, b) end)
+    set_finalizer(function(err, stack_tbl) print("wait_send", a, b, " -> ", tostring(err)) end)
+    print("in wait_send")
     a,b = limited:send("key", "bybye") -- infinite timeout, returns only when lane is cancelled
 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
-    set_finalizer(function() print("wait_receive", k, v) end)
+    set_finalizer(function(err, stack_tbl) print("wait_receive", k, v, " -> ", tostring(err)) end)
     k, v = limited:receive("dummy") -- infinite timeout, returns only when lane is cancelled
 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"
+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"
 --################################################]]
 
 -- ##################################################################################################
@@ -246,7 +255,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
@@ -264,7 +273,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)
@@ -401,7 +410,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
 
@@ -437,7 +446,7 @@ local function chunk2(linda)
     assert(config.strip_functions and info.short_src=="?" or string.match(info.short_src, "^.*basic.lua$"), "bad info.short_src")
     -- These vary so let's not be picky (they're there..)
     --
-    assert(info.linedefined == 422, "bad linedefined")   -- start of 'chunk2'
+    assert(info.linedefined == 431, "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")
@@ -452,7 +461,7 @@ local function chunk2(linda)
     linda:send("up", function() return ":)" end, "ok2")
 end
 
-local linda = lanes_linda("auto")
+local linda = lanes_linda{name = "auto"}
 local t2 = lanes.gen("debug,string,io", { name = 'auto', gc_cb = gc_cb }, chunk2)(linda)     -- prepare & launch
 linda:send("down", function(linda) linda:send("up", "ready!") end,
                     "ok")
@@ -460,7 +469,7 @@ linda:send("down", function(linda) linda:send("up", "ready!") end,
 --
 local k,s= linda:receive(1, "up")
 if t2.status == "error" then
-    print("t2 error: " , t2:join())
+    PRINT("t2 error: " , t2:join())
 end
 PRINT(s)
 assert(s=="ready!")
@@ -498,19 +507,20 @@ 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
+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)
-    assert(a==14)
-    assert(b==13)
-    assert(c==12)
-    assert(d==nil)
+    print(h:get_threadname(), r,a,b,c,d)
+    assert(r == true)
+    assert(a == 14)
+    assert(b == 13)
+    assert(c == 12)
+    assert(d == nil)
 end
 
 local nameof_type, nameof_name = lanes.nameof(print)