8 files changed, 37 insertions, 37 deletions

diff --git a/tests/basic.lua b/tests/basic.lua
index a9c85cc..9aaad97 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)
 -- [[################################################
@@ -255,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
@@ -410,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
 
@@ -461,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")
diff --git a/tests/cancel.lua b/tests/cancel.lua
index 80e6c6a..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
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/error.lua b/tests/error.lua
index 306c51d..28cfff1 100644
--- a/tests/error.lua
+++ b/tests/error.lua
@@ -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()

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/keeper.lua b/tests/keeper.lua
index f566927..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)
 
diff --git a/tests/linda_perf.lua b/tests/linda_perf.lua
index 107fd25..83b8921 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)
@@ -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
@@ -165,7 +165,7 @@ 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), batch or 1
diff --git a/tests/tobeclosed.lua b/tests/tobeclosed.lua
index ef09df3..447b936 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
@@ -99,7 +99,7 @@ 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
@@ -114,7 +114,7 @@ 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