33 files changed, 174 insertions, 159 deletions

diff --git a/tests/appendud.lua b/tests/appendud.lua
index f510c8b..2a8c8ce 100644
--- a/tests/appendud.lua
+++ b/tests/appendud.lua
@@ -42,14 +42,14 @@ function appendud(tab, ud)
                 -- ('tab' is passed over lanes by value, not by reference)
 end
 
-local t,err= lanes.gen( "base,io", appendud )( _tab, _ud )   -- create & launch a thread
+local t,err= lanes.gen( "base,io", { name = 'auto'}, appendud )( _tab, _ud )   -- create & launch a thread
 assert(t)
 assert(not err)
 
 -- test
 -- print("t:join()")
 a,b,c = t[1],t[2],t[3]    -- Need to explicitly wait for the thread, since 'ipairs()' does not
---a,b,c = t:join()    -- Need to explicitly wait for the thread, since 'ipairs()' does not
+--r,a,b,c = t:join()    -- Need to explicitly wait for the thread, since 'ipairs()' does not
             -- value the '__index' metamethod (wouldn't it be cool if it did..?)
 
 print(a,b,c)
diff --git a/tests/atexit.lua b/tests/atexit.lua
index 9fc3070..ba10d3b 100644
--- a/tests/atexit.lua
+++ b/tests/atexit.lua
@@ -16,8 +16,8 @@ local g = function()
         print "User cancellation detected!"
 end
 
-local genF = lanes.gen( "", {globals = {threadName = "mylane"}}, f)
-local genG = lanes.gen( "", g)
+local genF = lanes.gen( "", {name = 'auto', globals = {threadName = "mylane"}}, f)
+local genG = lanes.gen( "", { name = 'auto'}, g)
 
 
 -- launch a good batch of free running lanes
diff --git a/tests/basic.lua b/tests/basic.lua
index 820d3c8..f393175 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -15,7 +15,7 @@ local lanes = require_lanes_result_1
 local require_assert_result_1, require_assert_result_2 = require "assert"    -- assert.fails()
 print("require_assert_result:", require_assert_result_1, require_assert_result_2)
 
-local lanes_gen=    assert(lanes.gen)
+local lanes_gen     assert(lanes.gen)
 local lanes_linda = assert(lanes.linda)
 
 local tostring=     assert(tostring)
@@ -86,7 +86,7 @@ local function task(a, b, c)
     return v, hey
 end
 
-local task_launch= lanes_gen("", { globals={hey=true}, gc_cb = gc_cb}, task)
+local task_launch= lanes.gen("", { name = 'auto', globals={hey=true}, gc_cb = gc_cb }, task)
     -- base stdlibs, normal priority
 
 -- 'task_launch' is a factory of multithreaded tasks, we can launch several:
@@ -126,7 +126,7 @@ collectgarbage()
 
 PRINT("\n\n", "---=== Tasking (cancelling) ===---", "\n\n")
 
-local task_launch2= lanes_gen("", { globals={hey=true}, gc_cb = gc_cb}, task)
+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...
@@ -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("*", wait_send)()
-repeat until wait_send_lane.status == "waiting"
-print "wait_send_lane is waiting"
+local wait_send_lane = lanes.gen("*", { name = 'auto' }, wait_send)()
+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("*", wait_receive)()
-repeat until wait_receive_lane.status == "waiting"
-print "wait_receive_lane is waiting"
+local wait_receive_lane = lanes.gen("*", { name = 'auto' }, wait_receive)()
+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("*", wait_receive_batched)()
+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)
@@ -275,7 +284,7 @@ local function PEEK(...) return linda:get("<-", ...) end
 local function SEND(...) local _res, _err = linda:send("->", ...) assert(_res == true and _err == nil) end
 local function RECEIVE() local k,v = linda:receive(1, "<-") return v end
 
-local comms_lane = lanes_gen("io", {gc_cb = gc_cb, name = "auto"}, chunk)(linda)     -- prepare & launch
+local comms_lane = lanes.gen("io", { name = 'auto', gc_cb = gc_cb }, chunk)(linda)     -- prepare & launch
 
 SEND(1);  WR("main ", "1 sent\n")
 SEND(2);  WR("main ", "2 sent\n")
@@ -355,7 +364,7 @@ local function coro_f(_x)
     return true
 end
 
-assert.fails(function() lanes_gen("xxx", {gc_cb = gc_cb}, io_os_f) end)
+assert.fails(function() lanes_gen("xxx", {name = 'auto', gc_cb = gc_cb }, io_os_f) end)
 
 local stdlib_naming_tests =
 {
@@ -371,7 +380,7 @@ local stdlib_naming_tests =
 }
 
 for _, t in ipairs(stdlib_naming_tests) do
-    local f= lanes_gen(t[1], {gc_cb = gc_cb}, t[2])     -- any delimiter will do
+    local f= lanes.gen(t[1], { name = 'auto', gc_cb = gc_cb }, t[2])     -- any delimiter will do
     assert(f(t[1])[1])
 end
 
@@ -386,7 +395,7 @@ PRINT("\n\n", "---=== Comms criss cross ===---", "\n\n")
 
 -- We make two identical lanes, which are using the same Linda channel.
 --
-local tc= lanes_gen("io", {gc_cb = gc_cb},
+local tc = lanes.gen("io", { name = 'auto', gc_cb = gc_cb },
   function(linda, ch_in, ch_out)
         lane_threadname("criss cross " .. ch_in .. " -> " .. ch_out)
     local function STAGE(str)
@@ -401,7 +410,7 @@ local tc= lanes_gen("io", {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,15 +461,15 @@ local function chunk2(linda)
     linda:send("up", function() return ":)" end, "ok2")
 end
 
-local linda = lanes_linda("auto")
-local t2= lanes_gen("debug,string,io", {gc_cb = gc_cb}, chunk2)(linda)     -- prepare & launch
+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")
 -- 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())
+    PRINT("t2 error: " , t2:join())
 end
 PRINT(s)
 assert(s=="ready!")
@@ -486,7 +495,7 @@ PRINT("\n\n", "---=== :join test ===---", "\n\n")
 --       (unless [1..n] has been read earlier, in which case it would seemingly
 --       work).
 
-local S= lanes_gen("table", {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)
@@ -498,19 +507,20 @@ local S= lanes_gen("table", {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)
diff --git a/tests/cancel.lua b/tests/cancel.lua
index 5862c85..66957c3 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -148,7 +148,7 @@ local protectedBody = function(...)
         local paramLessClosure = function() laneBody(unpack(params)) end
         local status, message = xpcall(paramLessClosure, errorHandler)
         if status == false then
-                print("                 error handler rethrowing '" .. (ce == message and "cancel_error"or tostring(message)) .. "'")
+                print("                 protectedBody rethrowing '" .. (ce == message and "cancel_error" or tostring(message)) .. "'")
                 -- if the error isn't rethrown, the lane's finalizer won't get it
                 error(message)
         end
@@ -160,7 +160,7 @@ end
 if not next(which_tests) or which_tests.linda then
         remaining_tests.linda = nil
         print "\n\n####################################################################\nbegin linda cancel test\n"
-        h = generator("*", laneBody)("receive", nil) -- start an infinite wait on the linda
+        h = generator("*", { name = 'auto' }, laneBody)("receive", nil) -- start an infinite wait on the linda
 
         print "wait 1s"
         SLEEP(1)
@@ -181,7 +181,7 @@ end
 if not next(which_tests) or which_tests.soft then
         remaining_tests.soft = nil
         print "\n\n####################################################################\nbegin soft cancel test\n"
-        h = generator("*", protectedBody)("receive") -- start an infinite wait on the linda
+        h = generator("*", { name = 'auto' }, protectedBody)("receive") -- start an infinite wait on the linda
 
         print "wait 1s"
         SLEEP(1)
@@ -205,7 +205,7 @@ end
 if not next(which_tests) or which_tests.hook then
         remaining_tests.hook = nil
         print "\n\n####################################################################\nbegin hook cancel test\n"
-        h = generator("*", protectedBody)("get", 300000)
+        h = generator("*", { name = 'auto' }, protectedBody)("get", 300000)
         print "wait 2s"
         SLEEP(2)
 
@@ -222,7 +222,7 @@ end
 if not next(which_tests) or which_tests.hard then
         remaining_tests.hard = nil
         print "\n\n####################################################################\nbegin hard cancel test\n"
-        h = lanes.gen("*", protectedBody)("receive", nil) -- infinite timeout
+        h = lanes.gen("*", { name = 'auto' }, protectedBody)("receive", nil) -- infinite timeout
 
         -- wait 2s before cancelling the lane
         print "wait 2s"
@@ -241,7 +241,7 @@ end
 if not next(which_tests) or which_tests.hard_unprotected then
         remaining_tests.hard_unprotected = nil
         print "\n\n####################################################################\nbegin hard cancel test with unprotected lane body\n"
-        h = generator("*", laneBody)("receive", nil)
+        h = generator("*", { name = 'auto' }, laneBody)("receive", nil)
 
         -- wait 2s before cancelling the lane
         print "wait 2s"
diff --git a/tests/cyclic.lua b/tests/cyclic.lua
index ed4bdba..ca4b9f5 100644
--- a/tests/cyclic.lua
+++ b/tests/cyclic.lua
@@ -31,7 +31,7 @@ local function lane1()
     assert( b[1]==a )
     return true
 end
-local L1= lanes.gen( "io", lane1 )()
+local L1= lanes.gen( "io", { name = 'auto' }, lane1 )()
     -- ...running
 
 -- Getting the tables as arguments should also keep the linkage
@@ -42,7 +42,7 @@ local function lane2( aa, bb )
     assert( bb[1]==aa )
     return true
 end
-local L2= lanes.gen( "io", lane2 )( a, b )
+local L2= lanes.gen( "io", { name = 'auto' }, lane2 )( a, b )
     -- ...running
 
 -- Really unnecessary, but let's try a directly recursive table
@@ -55,7 +55,7 @@ local function lane3( cc )
     assert( cc and cc.a==cc )
     return true
 end
-local L3= lanes.gen("io", lane3)(c)
+local L3= lanes.gen("io", { name = 'auto' }, lane3)(c)
 
 -- Without a wait, exit from the main lane will close the process
 --
diff --git a/tests/deadlock.lua b/tests/deadlock.lua
index d028e83..9b93e3b 100644
--- a/tests/deadlock.lua
+++ b/tests/deadlock.lua
@@ -16,7 +16,7 @@ print "let's begin"
 local do_extra_stuff = true
 
 if do_extra_stuff then
-    local linda = lanes.linda "deadlock_linda"
+    local linda = lanes.linda{name = "deadlock_linda"}
     -- just something to make send() succeed and receive() fail
     local payload = { io.flush }
 
diff --git a/tests/ehynes.lua b/tests/ehynes.lua
index cdcd5a5..e4b56a5 100644
--- a/tests/ehynes.lua
+++ b/tests/ehynes.lua
@@ -16,7 +16,7 @@ end
 local linda = lanes.linda()
 
 -- a linda message receiver
-local receiver_gen = lanes.gen( 'base', 'os', 'string', 'io',
+local receiver_gen = lanes.gen( 'base', 'os', 'string', 'io', { name = 'auto' },
     function (message_name)
         PRINT_FMT( 'receiver for message %s entered', message_name )
         local n = 1
diff --git a/tests/errhangtest.lua b/tests/errhangtest.lua
index fff0dee..5b3f0c0 100644
--- a/tests/errhangtest.lua
+++ b/tests/errhangtest.lua
@@ -19,7 +19,6 @@ end
 if true then
         print "\n#### reserved sentinels"
         print(pcall(linda.set, linda, lanes.cancel_error))
-        print(pcall(linda.set, linda, linda.batched))
         local _count, _val = linda:get("test")
         assert(_count == 0 and _val == nil)
         print "OK"
@@ -28,13 +27,13 @@ end
 -- get/set a few values
 if true then
         print "\n#### set 3 -> receive batched"
-        assert.fails(function() linda:receive(linda.batched, "some key", -1, 1) end)
-        assert.fails(function() linda:receive(linda.batched, "some key", 2, 1) end)
-        assert.failsnot(function() linda:receive(0, linda.batched, "some key", 1, 3) end)
+        assert.fails(function() linda:receive_batched("some key", -1, 1) end)
+        assert.fails(function() linda:receive_batched("some key", 2, 1) end)
+        assert.failsnot(function() linda:receive_batched(0, "some key", 1, 3) end)
         local fun = function() print "function test ok" end
         print(pcall(linda.set, linda, 'test', true, nil, fun))
         -- read back the contents
-        local k,b,n,f = linda:receive(linda.batched, 'test', 3)
+        local k,b,n,f = linda:receive_batched('test', 3)
         local _count, _val = linda:get("test")
         assert(_count == 0 and _val == nil)
         -- check they are ok
diff --git a/tests/error.lua b/tests/error.lua
index 243dd57..76ceea4 100644
--- a/tests/error.lua
+++ b/tests/error.lua
@@ -87,7 +87,7 @@ end
 --##################################################################################################

 

 local start_lane = function(error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_)

-    return lanes.gen("*", {error_trace_level = error_reporting_mode_}, lane_body)(error_value_, finalizer_, finalizer_error_value_)

+    return lanes.gen("*", { name = 'auto', error_trace_level = error_reporting_mode_ }, lane_body)(error_value_, finalizer_, finalizer_error_value_)

 end

 

 --##################################################################################################

@@ -106,11 +106,11 @@ end
 

 local lane_error_as_string = "'lane error as string'"

 local lane_error_as_table = setmetatable({"lane error as table"}, make_table_error_mt())

-local lane_error_as_linda = lanes.linda("'lane error'")

+local lane_error_as_linda = lanes.linda{name = "'lane error'"}

 

 local finalizer_error_as_string = "'finalizer error as string'"

 local finalizer_error_as_table = setmetatable({"finalizer error as table"}, make_table_error_mt())

-local finalizer_error_as_linda = lanes.linda("'finalizer error'")

+local finalizer_error_as_linda = lanes.linda{name = "'finalizer error'"}

 

 local test_settings = {}

 local configure_tests = function()

@@ -173,8 +173,7 @@ local do_error_catching_test = function(error_reporting_mode_, error_value_, fin
     local h = start_lane(error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_)

     local ret,err,stack= h:join()   -- wait for the lane (no automatic error propagation)

     WR("Processing results for {", error_reporting_mode_, error_value_, finalizer_, finalizer_error_value_, "}")

-    if err then

-        assert(ret == nil)

+    if ret == nil then

         assert(error_reporting_mode_ == "minimal" or type(stack)=="table") -- only true if lane was configured with error_trace_level ~= "minimal"

         if err == error_value_ then

             WR("Lane regular error: ", err)

@@ -198,8 +197,8 @@ local do_error_catching_test = function(error_reporting_mode_, error_value_, fin
             end

         end

     else -- no error

-        assert(ret == "success")

-        WR("No error in lane: ", ret)

+        assert(ret == true and err == "success")

+        WR("No error in lane: ", err, ret)

     end

     WR "TEST OK"

 end

diff --git a/tests/fibonacci.lua b/tests/fibonacci.lua
index 7885ae6..2c043c3 100644
--- a/tests/fibonacci.lua
+++ b/tests/fibonacci.lua
@@ -44,7 +44,7 @@ local function fib( n )
     else
         -- Splits into two; this task remains waiting for the results
         --
-        local gen_f= lanes.gen( "*", fib)
+        local gen_f= lanes.gen( "*", { name = 'auto' }, fib)
 
         local n1=floor(n/2) +1
         local n2=floor(n/2) -1 + n%2
diff --git a/tests/fifo.lua b/tests/fifo.lua
index 9efcbd9..1317a9f 100644
--- a/tests/fifo.lua
+++ b/tests/fifo.lua
@@ -6,10 +6,10 @@
 
 local lanes = require "lanes".configure{shutdown_timeout=3,with_timers=true}
 
-local atomic_linda = lanes.linda( "atom")
+local atomic_linda = lanes.linda{name = "atom"}
 local atomic_inc= lanes.genatomic( atomic_linda, "FIFO_n")
 
-local fifo_linda = lanes.linda( "fifo")
+local fifo_linda = lanes.linda{name = "fifo"}
 
 -- Lua 5.1 support
 local table_unpack = table.unpack or unpack
diff --git a/tests/finalizer.lua b/tests/finalizer.lua
index 8bf89b4..9fa12dc 100644
--- a/tests/finalizer.lua
+++ b/tests/finalizer.lua
@@ -69,7 +69,7 @@ cleanup = function(err)
 end

 

 -- we need error_trace_level above "minimal" to get a stack trace out of h:join()

-local lgen = lanes.gen("*", {error_trace_level = "basic"}, lane)

+local lgen = lanes.gen("*", { name = 'auto', error_trace_level = "basic" }, lane)

 

 local do_test = function(error_)

 

@@ -77,8 +77,8 @@ local do_test = function(error_)
 

     local h = lgen(error_)

 

-    local _,err,stack = h:join()   -- wait for the lane (no automatic error propagation)

-    if err then

+    local r,err,stack = h:join()   -- wait for the lane (no automatic error propagation)

+    if not r then

         assert(stack, "no stack trace on error, check 'error_trace_level'")

         io.stderr:write( "Lane error: "..tostring(err).."\n" )

         io.stderr:write( "\t", table.concat(stack,"\t\n"), "\n" )

diff --git a/tests/func_is_string.lua b/tests/func_is_string.lua
index a14c460..3c91603 100644
--- a/tests/func_is_string.lua
+++ b/tests/func_is_string.lua
@@ -7,7 +7,7 @@ if _VERSION >= "Lua 5.4" then
         local lanes = require 'lanes'
         local r
         do
-            local h <close> = lanes.gen('*', lanes.sleep)(0.5)
+            local h <close> = lanes.gen('*', { name = 'auto' }, lanes.sleep)(0.5)
             r = h
         end -- h is closed here
         return r.status
@@ -21,16 +21,17 @@ end
 
 local options = {globals = { b = 666 }}
 
-local gen1 = lanes.gen("*", "return true, dofile('fibonacci.lua')")
-local gen2 = lanes.gen(options, "return b")
+local gen1 = lanes.gen("*", { name = 'auto' }, "return true, error('bob')")
 
 fibLane = gen1()
 lanes.sleep(0.1)
 print(fibLane, fibLane.status)
-local _status, _err = fibLane:join()
-print(_status, _err)
+local _r, _err, _stk = fibLane:join()
+assert(_r == nil, "got " .. tostring(_r) .. " " .. tostring(_err) .. " " .. tostring(_stk))
 
-retLane1, retLane2 = gen2(), gen2()
+local gen2 = lanes.gen(options, { name = 'auto' }, "return b")
+local retLane1, retLane2 = gen2(), gen2()
 
 print( retLane1[1], retLane2[1])
-print "TEST OK"
\ No newline at end of file
+assert(retLane1[1] == 666 and retLane2[1] == 666)
+print "TEST OK"
diff --git a/tests/hangtest.lua b/tests/hangtest.lua
index 0e44451..e48ff60 100644
--- a/tests/hangtest.lua
+++ b/tests/hangtest.lua
@@ -7,7 +7,7 @@ local lanes = require "lanes"
 local function ret(b)

     return b

 end

-local lgen = lanes.gen("*", {}, ret)

+local lgen = lanes.gen("*", { name = 'auto' }, ret)

 

 for i=1,10000 do

     local ln = lgen(i)

diff --git a/tests/irayo_closure.lua b/tests/irayo_closure.lua
index 45189ec..40c586d 100644
--- a/tests/irayo_closure.lua
+++ b/tests/irayo_closure.lua
@@ -5,7 +5,7 @@
 "Another issue I've noticed is trying to pass a table with a function
 that uses closures in it as a global variable into a new lane.  This
 causes a segmentation fault and it appears to be related to the
-luaG_inter_move function near line 835-836 or so in lanes.c, but I
+luaW_inter_move function near line 835-836 or so in lanes.c, but I
 haven't investigated further.
 e.g. { globals = { data = 1, func = function() useclosurehere() end } }"
 ]]
@@ -33,5 +33,5 @@ local function useclosurehere()
     print "using the closure" 
 end
 
-local lane= lanes.gen( "", { globals = { data=1, func=useclosurehere } }, testrun )()
+local lane= lanes.gen( "", { name = 'auto', globals = { data=1, func=useclosurehere } }, testrun )()
 print(lane[1])
diff --git a/tests/irayo_recursive.lua b/tests/irayo_recursive.lua
index 0187a15..99522f7 100644
--- a/tests/irayo_recursive.lua
+++ b/tests/irayo_recursive.lua
@@ -11,7 +11,7 @@ local function recurse()
 
     --local lanes = require "lanes"
 
-    local lane = lanes.gen( "base,string,lanes_core", { globals = { ["i"]= i + 1 } }, recurse ) ()
+    local lane = lanes.gen( "base,string,lanes_core", { name = 'auto', globals = { ["i"]= i + 1 } }, recurse ) ()
     return lane[1]
 end
 
diff --git a/tests/keeper.lua b/tests/keeper.lua
index 0e93de2..4742732 100644
--- a/tests/keeper.lua
+++ b/tests/keeper.lua
@@ -40,14 +40,14 @@ if true then
     end
 
     -- should succeed
-    assert.failsnot(function() createLinda("zero", 0) end)
-    assert.failsnot(function() createLinda("one", 1) end)
-    assert.failsnot(function() createLinda("two", 2) end)
-    assert.failsnot(function() createLinda("three", 3) end)
+    assert.failsnot(function() createLinda{name = "zero", group = 0} end)
+    assert.failsnot(function() createLinda{name = "one", group = 1} end)
+    assert.failsnot(function() createLinda{name = "two", group = 2} end)
+    assert.failsnot(function() createLinda{name = "three", group = 3} end)
     -- should fail (and not create the lindas)
-    assert.fails(function() createLinda("minus 1", -1) end)
-    assert.fails(function() createLinda("none") end)
-    assert.fails(function() createLinda("four", 4) end)
+    assert.fails(function() createLinda{name = "minus 1", group = -1} end)
+    assert.fails(function() createLinda{name = "none"} end)
+    assert.fails(function() createLinda{name = "four", group = 4} end)
 
 end
 -- should only collect the 4 successfully created lindas
@@ -58,11 +58,11 @@ DONE()
 if true then
     PRINT "========================================================================================="
     PRINT "Linda names test:"
-    local unnamedLinda1 = lanes.linda(1)
-    local unnamedLinda2 = lanes.linda("", 2)
-    local veeeerrrryyyylooongNamedLinda3 = lanes.linda( "veeeerrrryyyylooongNamedLinda", 3)
+    local unnamedLinda1 = lanes.linda{group = 1}
+    local unnamedLinda2 = lanes.linda{name = "", group = 2}
+    local veeeerrrryyyylooongNamedLinda3 = lanes.linda{ name = "veeeerrrryyyylooongNamedLinda", group = 3}
     assert(tostring(veeeerrrryyyylooongNamedLinda3) == "Linda: veeeerrrryyyylooongNamedLinda")
-    local shortNamedLinda0 = lanes.linda( "short", 0)
+    local shortNamedLinda0 = lanes.linda{name = "short", group = 0}
     assert(tostring(shortNamedLinda0) == "Linda: short")
     PRINT(shortNamedLinda0, unnamedLinda1, unnamedLinda2, veeeerrrryyyylooongNamedLinda3)
 end
@@ -74,12 +74,12 @@ DONE()
 if true then
     PRINT "========================================================================================="
     PRINT "Linda GC test:"
-    local a = lanes.linda("A", 1)
-    local b = lanes.linda("B", 2)
-    local c = lanes.linda("C", 3)
+    local a = lanes.linda{name = "A", group = 1}
+    local b = lanes.linda{name = "B", group = 2}
+    local c = lanes.linda{name = "C", group = 3}
 
     -- store lindas in each other and in themselves
-    a:set("here", lanes.linda("temporary linda", 0))
+    a:set("here", lanes.linda{name = "temporary linda", group = 0})
     b:set("here", a, b, c)
     c:set("here", a, b, c)
 
@@ -120,13 +120,13 @@ if true then
     end
 
     --
-    local lindaA= lanes.linda( "A", 1)
+    local lindaA= lanes.linda{name = "A", group = 1}
     local A= keeper( lindaA )
 
-    local lindaB= lanes.linda( "B", 2)
+    local lindaB= lanes.linda{name = "B", group = 2}
     local B= keeper( lindaB )
 
-    local lindaC= lanes.linda( "C", 3)
+    local lindaC= lanes.linda{name = "C", group = 3}
     local C= keeper( lindaC )
     PRINT("Created", lindaA, lindaB, lindaC)
 
@@ -160,7 +160,7 @@ if true then
     end
 
     PRINT("lane started")
-    local h= lanes.gen( "io", lane )()
+    local h= lanes.gen( "io", { name = 'auto' }, lane )()
     PRINT("lane joined:", h:join())
 
     PRINT("A.some = " .. A.some )
diff --git a/tests/lanes_as_upvalue.lua b/tests/lanes_as_upvalue.lua
index e7fcd3a..beef22e 100644
--- a/tests/lanes_as_upvalue.lua
+++ b/tests/lanes_as_upvalue.lua
@@ -4,7 +4,7 @@ local function foo()
         local lanes = lanes -- lanes as upvalue
 end
 
-local g = lanes.gen( "*", {error_trace_level = "extended"}, foo)
+local g = lanes.gen( "*", { name = 'auto', error_trace_level = "extended"}, foo)
 
 -- this should raise an error as lanes.timer_lane is a Lane (a non-deep full userdata)
 local res, err = pcall( g)
diff --git a/tests/launchtest.lua b/tests/launchtest.lua
index 16db242..cdd6ffc 100644
--- a/tests/launchtest.lua
+++ b/tests/launchtest.lua
@@ -47,7 +47,7 @@ end
 
 local lanes = require "lanes"
 
-local g= lanes.gen( LIBS, function(i) 
+local g= lanes.gen( LIBS, { name = 'auto' }, function(i) 
                         --io.stderr:write( i.."\t" )
                         return i 
                     end )
@@ -69,8 +69,8 @@ else
     io.stderr:write( N.." lanes launched.\n" )
     
     for i=1,N do
-        local rc= t[i]:join()
-        assert( rc==i )
+        local r,rc = t[i]:join()
+        assert( r == true and rc == i )
     end
 
     io.stderr:write( N.." lanes finished.\n" )
diff --git a/tests/linda_perf.lua b/tests/linda_perf.lua
index 96f26f4..e68d552 100644
--- a/tests/linda_perf.lua
+++ b/tests/linda_perf.lua
@@ -22,7 +22,7 @@ if true then
         do
                 print "############################################ tests get/set"
                 -- linda:get throughput
-                local l = lanes.linda("get/set", 1)
+                local l = lanes.linda{name = "get/set", group = 1}
                 local batch = {}
                 for i = 1,1000 do
                         table.insert(batch, i)
@@ -56,7 +56,7 @@ local eater = function( l, loop)
         -- print "loop is over"
         key, val = l:receive( "done")
         print("eater: done ("..val..")")
-        return true
+        return "ate everything"
 end
 
 -- #################################################################################################
@@ -68,19 +68,19 @@ local gobbler = function( l, loop, batch)
         l:receive( "go")
         -- eat data in batches
         for i = 1, loop/batch do
-                l:receive( l.batched, "key", batch)
+                l:receive_batched("key", batch)
                 -- print("gobbler:", batch)
         end
         print "loop is over"
         key, val = l:receive( "done")
         print("gobbler: done ("..val..")")
-        return true
+        return "gobbled everything"
 end
 
 -- #################################################################################################
 
-local lane_eater_gen = lanes.gen( "*", {priority = 3}, eater)
-local lane_gobbler_gen = lanes.gen( "*", {priority = 3}, gobbler)
+local lane_eater_gen = lanes.gen( "*", { name = 'auto', priority = 3 }, eater)
+local lane_gobbler_gen = lanes.gen( "*", { name = 'auto', priority = 3 }, gobbler)
 
 -- #################################################################################################
 
@@ -90,7 +90,7 @@ local group_uid = 1
 local function ziva1( preloop, loop, batch)
         -- prefill the linda a bit to increase fifo stress
         local top = math.max( preloop, loop)
-        local l = lanes.linda("ziva1("..preloop..":"..loop..":"..batch..")", group_uid)
+        local l = lanes.linda{name = "ziva1("..preloop..":"..loop..":"..batch..")", group = group_uid}
         group_uid = (group_uid % config.nb_user_keepers) + 1
         local t1 = lanes.now_secs()
         for i = 1, preloop do
@@ -123,7 +123,8 @@ local function ziva1( preloop, loop, batch)
                 end
         end
         l:send( "done" ,"are you happy?")
-        lane:join()
+        local r, ret = lane:join()
+        assert(r == true and type(ret) == "string", "got " .. tostring(r) .. " " .. tostring(ret))
         return lanes.now_secs() - t1
 end
 
@@ -165,12 +166,12 @@ end
 
 -- sequential write/read (no parallelization involved)
 local function ziva2( preloop, loop, batch)
-        local l = lanes.linda("ziva2("..preloop..":"..loop..":"..tostring(batch)..")", group_uid)
+        local l = lanes.linda{name = "ziva2("..preloop..":"..loop..":"..tostring(batch)..")", group = group_uid}
         group_uid = (group_uid % config.nb_user_keepers) + 1
         -- prefill the linda a bit to increase fifo stress
-        local top, step = math.max( preloop, loop), (l.batched and batch) and batch or 1
+        local top, step = math.max( preloop, loop), batch or 1
         local batch_send, batch_read
-        if l.batched and batch then
+        if batch then
                 local batch_values = {}
                 for i = 1, batch do
                         table.insert( batch_values, i)
@@ -180,7 +181,7 @@ local function ziva2( preloop, loop, batch)
                         l:send( "key", table_unpack( batch_values))
                 end
                 batch_read = function()
-                        l:receive( l.batched, "key", batch)
+                        l:receive_batched("key", batch)
                 end
         else -- not batched
                 batch_send = function()
diff --git a/tests/manual_register.lua b/tests/manual_register.lua
index 52cc4ed..36a41ad 100644
--- a/tests/manual_register.lua
+++ b/tests/manual_register.lua
@@ -25,7 +25,7 @@ local f = function()
 end
 
 
-local g = lanes.gen( "*", f)
+local g = lanes.gen( "*", { name = 'auto' }, f)
 
 -- generate a lane, this will transfer f, which pulls GlobalFunc.
 local h = g()
diff --git a/tests/nameof.lua b/tests/nameof.lua
index 1abcf3d..fb7332a 100644
--- a/tests/nameof.lua
+++ b/tests/nameof.lua
@@ -18,7 +18,7 @@ local body = function()
 end
 
 -- start the lane without any library
-local h = lanes.gen(nil, body)()
+local h = lanes.gen(nil, { name = 'auto' }, body)()
 SLEEP(0.1)
 print("Name of lane: ", lanes.nameof(h), "("..h.status..")")
 assert(h.status == "running")
diff --git a/tests/objects.lua b/tests/objects.lua
index ed460af..22a4df1 100644
--- a/tests/objects.lua
+++ b/tests/objects.lua
@@ -8,7 +8,7 @@ local lanes = require "lanes"
 
 local linda= lanes.linda()
 
-local start_lane= lanes.gen("io", 
+local start_lane= lanes.gen("io", { name = 'auto' },
     function(obj1 )
 
         assert(obj1.v )
diff --git a/tests/parallel_os_calls.lua b/tests/parallel_os_calls.lua
index 8030d4c..55159e8 100644
--- a/tests/parallel_os_calls.lua
+++ b/tests/parallel_os_calls.lua
@@ -1,15 +1,15 @@
 local lanes = require "lanes"
 print( os.date())
 local linda = lanes.linda()
-local l1 = lanes.gen("os,base", function() print "start sleeping" linda:receive(3, "null") print("finished_sleeping " .. os.date()) return true end)()
-lanes.gen("os,base", function() print "start sleeping" linda:receive(2, "null") print("finished_sleeping " .. os.date()) end)()
-lanes.gen("os,base", function() print "start sleeping" linda:receive(2, "null") print("finished_sleeping " .. os.date()) end)()
-lanes.gen("os,base", function() print "start sleeping" linda:receive(2, "null") print("finished_sleeping " .. os.date()) end)()
+local l1 = lanes.gen("os,base", { name = 'auto' }, function() print "start sleeping" linda:receive(3, "null") print("finished_sleeping " .. os.date()) return true end)()
+lanes.gen("os,base", { name = 'auto' }, function() print "start sleeping" linda:receive(2, "null") print("finished_sleeping " .. os.date()) end)()
+lanes.gen("os,base", { name = 'auto' }, function() print "start sleeping" linda:receive(2, "null") print("finished_sleeping " .. os.date()) end)()
+lanes.gen("os,base", { name = 'auto' }, function() print "start sleeping" linda:receive(2, "null") print("finished_sleeping " .. os.date()) end)()
 -- wait, else all lanes will get hard-cancelled at stat shutdown
 l1:join()
 --[[
-lanes.gen("os,base", function() os.execute('sleep 10 && echo finished_sleeping') print( os.date()) end)()
-lanes.gen("os,base", function() os.execute('sleep 10 && echo finished_sleeping') print( os.date()) end)()
-lanes.gen("os,base", function() os.execute('sleep 10 && echo finished_sleeping') print( os.date()) end)()
-lanes.gen("os,base", function() os.execute('sleep 10 && echo finished_sleeping') print( os.date()) end)()
+lanes.gen("os,base", { name = 'auto' }, function() os.execute('sleep 10 && echo finished_sleeping') print( os.date()) end)()
+lanes.gen("os,base", { name = 'auto' }, function() os.execute('sleep 10 && echo finished_sleeping') print( os.date()) end)()
+lanes.gen("os,base", { name = 'auto' }, function() os.execute('sleep 10 && echo finished_sleeping') print( os.date()) end)()
+lanes.gen("os,base", { name = 'auto' }, function() os.execute('sleep 10 && echo finished_sleeping') print( os.date()) end)()
 ]]
diff --git a/tests/perftest.lua b/tests/perftest.lua
index 35f522c..35e164d 100644
--- a/tests/perftest.lua
+++ b/tests/perftest.lua
@@ -137,10 +137,10 @@ end
 -- Keep preparation code outside of the performance test
 --
 local f_even= lanes.gen( "base,coroutine,math,table,io",  -- "*" = all
-                            { priority= PRIO_EVEN }, sieve_lane )
+                            { name = 'auto', priority= PRIO_EVEN }, sieve_lane )
                              
 local f_odd= lanes.gen( "base,coroutine,math,table,io",  -- "*" = all
-                            { priority= PRIO_ODD }, sieve_lane )
+                            { name = 'auto', priority= PRIO_ODD }, sieve_lane )
 
 io.stderr:write( "*** Counting primes 1.."..M.." "..N.." times ***\n\n" )
 
@@ -175,9 +175,9 @@ else
     -- Make sure all lanes finished
     --
     for i=1,N do
-        local tmp= t[i]:join()
+        local r, tmp = t[i]:join()
         -- this assert will trigger if you change M to values below 1000 in order to solve C stack overflow
-        assert( type(tmp)=="table" and tmp[1]==2 and tmp[168]==997 )
+        assert( r == true and type(tmp) == "table" and tmp[1] == 2 and tmp[168] == 997 )
     end
 end
 
diff --git a/tests/pingpong.lua b/tests/pingpong.lua
index 3498f49..1ed5b9a 100644
--- a/tests/pingpong.lua
+++ b/tests/pingpong.lua
@@ -21,13 +21,15 @@ local pingpong = function(name, qr, qs, start)
         q:send(qs, val)
         count = count + 1
     end
-    return true
+    return "ping!"
 end
 
 -- pingpong("L1", '0', '1', true)
-local t1, err1 = lanes.gen("*", pingpong)("L1", 'a', 'b', true)
-local t2, err2 = lanes.gen("*", pingpong)("L2", 'b', 'a', false)
+local t1, err1 = lanes.gen("*", { name = 'auto' }, pingpong)("L1", 'a', 'b', true)
+local t2, err2 = lanes.gen("*", { name = 'auto' }, pingpong)("L2", 'b', 'a', false)
 
-t1:join()
-t2:join()
+local r1, ret1 = t1:join()
+assert(r1 == true and ret1 == "ping!")
+local r2, ret2 = t2:join()
+assert(r2 == true and ret2 == "ping!")
 print "TEST OK"
diff --git a/tests/protect_allocator.lua b/tests/protect_allocator.lua
index 994cb39..325726a 100644
--- a/tests/protect_allocator.lua
+++ b/tests/protect_allocator.lua
@@ -36,7 +36,7 @@ end
 
 -- start threads
 local COUNT = 4
-local gen = lanes.gen( "*", body)
+local gen = lanes.gen( "*", { name = 'auto' }, body)
 for i = 1, COUNT do
         gen( i)
 end
@@ -52,7 +52,7 @@ end
 
 -- wait for completion
 print "wait for completion"
-linda:receive( linda.batched, "key", COUNT)
+linda:receive_batched("key", COUNT)
 print "waiting a bit more ..."
 SLEEP(1)
 print "SUCCESS"
diff --git a/tests/protectproxy.lua b/tests/protectproxy.lua
index ed1bd4f..84887ec 100644
--- a/tests/protectproxy.lua
+++ b/tests/protectproxy.lua
@@ -5,7 +5,7 @@ local body = function( param)
         return 1
 end
 
-local gen = lanes.gen( "*", body)
+local gen = lanes.gen( "*", { name = 'auto' }, body)
 
 local mylane = gen( "hello")
 
diff --git a/tests/recursive.lua b/tests/recursive.lua
index 716fe60..e294104 100644
--- a/tests/recursive.lua
+++ b/tests/recursive.lua
@@ -12,7 +12,7 @@ local function func( depth )
     end
 
     local lanes = require "lanes"
-    local lane = lanes.gen("*", func)( depth-1 )
+    local lane = lanes.gen("*", { name = 'auto' }, func)( depth-1 )
     return lane[1]
 end
 
diff --git a/tests/require.lua b/tests/require.lua
index b194af1..f017ddf 100644
--- a/tests/require.lua
+++ b/tests/require.lua
@@ -19,14 +19,14 @@ local function a_lane()
     local lanes = require "lanes"
     assert( lanes and lanes.gen )
 
-    local h= lanes.gen( function() return 42 end ) ()
+    local h= lanes.gen( { name = 'auto' }, function() return 42 end ) ()
     local v= h[1]
 
     return v==42
 end
 
 -- string and table for Lanes itself, package to be able to require in the lane, math for the actual work
-local gen= lanes.gen( "math,package,string,table", {package={}},a_lane )
+local gen= lanes.gen( "math,package,string,table", { name = 'auto', package={} },a_lane )
 
 local h= gen()
 local ret= h[1]
diff --git a/tests/rupval.lua b/tests/rupval.lua
index 122e0ac..c6743b3 100644
--- a/tests/rupval.lua
+++ b/tests/rupval.lua
@@ -23,20 +23,20 @@ c = function( n)
         return n <= 0 and z or a( n-1)
 end
 
-local g = lanes.gen( "base", a)
+local g = lanes.gen( "base", { name = 'auto' }, a)
 
 local l = g(7)
-local r = l:join()
+local _, r = l:join()
 assert(r == y)
 print(r)
 
 local l = g(8)
-local r = l:join()
+local _, r = l:join()
 assert(r == z)
 print(r)
 
 local l = g(9)
-local r = l:join()
+local _, r = l:join()
 assert(r == x)
 print(r)
 
diff --git a/tests/tobeclosed.lua b/tests/tobeclosed.lua
index 7a5e3ae..fd157e2 100644
--- a/tests/tobeclosed.lua
+++ b/tests/tobeclosed.lua
@@ -36,7 +36,7 @@ do
             WR("f closing ", linda_)
             closed_by_f = true
         end
-        local lf <close> = lanes.linda("closed by f", close_handler_f)
+        local lf <close> = lanes.linda{name = "closed by f", close_handler = close_handler_f}
 
         local close_handler_t = setmetatable({},
             {
@@ -46,7 +46,7 @@ do
                 end
             }
         )
-        local lt <close> = lanes.linda("closed by t", close_handler_t)
+        local lt <close> = lanes.linda{name = "closed by t", close_handler = close_handler_t}
     end
     assert(closed_by_f == true)
     assert(closed_by_t == true)
@@ -58,13 +58,13 @@ end
 WR "================================================================================================"
 WR "Through Linda"
 do
-    local l = lanes.linda("channel")
+    local l = lanes.linda{name = "channel"}
 
     local close_handler_f = function(linda_, err_)
         WR("f closing ", linda_)
         linda_:set("closed", true)
     end
-    local l_in = lanes.linda("voyager", close_handler_f)
+    local l_in = lanes.linda{name = "voyager", close_handler = close_handler_f}
     l:set("trip", l_in)
 
     do
@@ -86,7 +86,7 @@ do
         return "success"
     end
 
-    local h = lanes.gen("*", lane_body)()
+    local h = lanes.gen("*", { name = 'auto' }, lane_body)()
     do
         local tobeclosed <close> = h
     end
@@ -99,14 +99,14 @@ end
 WR "================================================================================================"
 WR "Linda closing through Lane"
 do
-    local l = lanes.linda("channel")
+    local l = lanes.linda{name = "channel"}
     local lane_body = function(l_arg_)
         WR "In lane body"
         -- linda obtained through a linda
         local _count, l_out <close> = l:get("trip")
         -- linda from arguments
         local l_arg <close> = l_arg_
-        return true
+        return "done"
     end
 
     local close_handler_f = function(linda_, err_)
@@ -114,11 +114,12 @@ do
         local _count, _closed = linda_:get("closed")
         linda_:set("closed", (_closed or 0) + 1)
     end
-    local l_in = lanes.linda("voyager", close_handler_f)
+    local l_in = lanes.linda{name = "voyager", close_handler = close_handler_f}
     l:set("trip", l_in)
 
     do
-    lanes.gen("*", lane_body)(l_in):join()
+        local r, ret = lanes.gen("*", { name = 'auto' }, lane_body)(l_in):join()
+        assert(r == true and ret == "done")
     end
     local _count, _closed = l_in:get("closed")
     assert(_count == 1 and _closed == 2)
diff --git a/tests/track_lanes.lua b/tests/track_lanes.lua
index 803fae5..ef2ca06 100644
--- a/tests/track_lanes.lua
+++ b/tests/track_lanes.lua
@@ -43,7 +43,7 @@ end
 -- sleeper( "main", 1)
 
 -- the generator
-local g = lanes.gen( "*", sleeper)
+local g = lanes.gen( "*", { name = 'auto' }, sleeper)
 
 -- start a forever-waiting lane (nil timeout)
 local forever = g( "forever", 'indefinitely')
@@ -59,8 +59,10 @@ local threads = track( "============= START", 2)
 --     two_seconds                        forever
 assert(threads[1].status == 'waiting' and threads[2].status == 'waiting')
 
--- wait until ephemeral1 has completed
-SLEEP(2.1)
+-- wait until ephemeral1 has completed, should take about 2 seconds
+repeat
+    SLEEP(0.1)
+until ephemeral1.status == "done"
 
 local threads = track( "============= two_seconds dead", 2)
 --     two_seconds                     forever