Append all unit tests to depot

17 files changed, 1390 insertions, 0 deletions

diff --git a/unit_tests/scripts/_assert.lua b/unit_tests/scripts/_assert.lua
new file mode 100644
index 0000000..9bc8d32
--- /dev/null
+++ b/unit_tests/scripts/_assert.lua
@@ -0,0 +1,321 @@
+--
+-- ASSERT.LUA                    Copyright (c) 2006-07, <akauppi@gmail.com>
+--
+-- Converting the Lua 'assert' function into a namespace table (without
+-- breaking compatibility with the basic 'assert()' calling).
+--
+-- This module allows shorthand use s.a. 'assert.table()' for asserting 
+-- variable types, and is also being used by Lua-super constraints system
+-- for testing function argument & return types.
+--
+-- All in all, a worthy module and could be part of Lua future versions.
+--
+-- Note: the 'assert' table is available for your own assertions, too. Just add
+--       more functions s.a. 'assert.myobj()' to check for custom invariants. 
+--       They will then be available for the constraints check, too.
+--
+-- Author:  <akauppi@gmail.com>
+--
+--[[
+/******************************************************************************
+* Lua 5.1.1 support and extension functions (assert.lua)
+*
+* Copyright (C) 2006-07, Asko Kauppi.
+*
+* NOTE: This license concerns only the particular source file; not necessarily
+*       the project with which it has been delivered (the project may have a more
+*       restrictive license, s.a. [L]GPL).
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the 
+* "Software"), to deal in the Software without restriction, including   
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to   
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+]]--
+
+local m= { _info= { MODULE= "Assert.* functions for constraints, and unit testing",
+                    AUTHOR= "akauppi@gmail.com",
+                    VERSION= 20240702,    -- last change (yyyymmdd)
+                    LICENSE= "MIT/X11" } }
+
+-- Global changes:
+--      'assert' redefined, in a backwards compatible way
+--
+-- Module functions:
+--      none
+
+assert( type(assert) == "function" )    -- system assert function
+assert( type(error) == "function")
+
+-----
+-- Integer range: INT_MIN..INT_MAX
+--
+local function try_maxint( n )
+    return (n > n-1) and n-1   -- false when outside the integer range 
+end
+
+local INT_MAX=
+    try_maxint( 2^64 ) or
+    try_maxint( 2^32 ) or
+    try_maxint( 2^24 ) or     -- float (24-bit mantissa)
+    assert( false )
+
+local INT_MIN= -(INT_MAX+1)
+
+
+---=== assert.*() ===---
+
+local at_msg= "type assertion error"  -- TBD: better messages, about that exact situation
+local av_msg= "value assertion error"
+
+-- void= _assert( val [, msg_str [, lev_uint]] )
+--
+local function _assert( cond, msg, lev ) 
+    -- original 'assert' provides no level override, so we use 'error'.
+    --
+    if not cond then
+        error( msg or "assertion failed!", (lev or 1)+1 )
+    end
+end
+
+-- Note: following code uses the _new_ 'assert()' by purpose, since it provides
+--       a level override (original doesn't)
+--
+local function assert_v( v0 )
+    return function(v,msg) 
+                _assert( v == v0, msg or av_msg, 2 )
+                return v
+           end
+end
+local function assert_t( str )
+    return function(v,msg) 
+                _assert( type(v) == str, msg or at_msg, 2 )
+                return v
+           end
+end
+local function assert_t2( str )
+    return function(v,subtype,msg) 
+                local t,st= type(v)
+                _assert( t==str and ((not subtype) or (st==subtype)),
+                         msg or at_msg, 2 )
+                return v
+           end
+end
+
+-- global base function assert() is replaced by this table
+assert= 
+  {
+    __metatable = "assert()",
+    __call= function(_,v,msg)     -- plain 'assert()' (compatibility)
+            if v then return v end
+            _assert( v, msg, 2 )
+        end,
+
+    -- Hopefully, Lua will allow use of 'nil', 'function' and other reserved words as table 
+    -- shortcuts in the future (5.1.1 does not). 
+    --
+    ["nil"]= assert_v( nil ),
+    boolean= assert_t "boolean",
+    table= assert_t2 "table",
+    ["function"]= assert_t "function",
+    userdata= assert_t2 "userdata",
+
+    string= function( v, msg )
+        local s= tostring(v)
+        _assert( s, msg or at_msg, 2 )
+        return v
+    end,
+
+    char= function( v, msg )
+        -- 'char' is _not_ doing int->string conversion
+        _assert( type(v)=="string" and v:len()==1, msg or at_msg, 2 )
+        return v
+    end,
+
+    number= function( v, msg )
+        _assert( tonumber(v), msg or at_msg, 2 )
+        return v
+    end,
+
+    int= function( v, msg )
+        local n= tonumber(v)
+        _assert( n and (n >= INT_MIN) and (n <= INT_MAX) and math.floor(n) == n,
+                    msg or at_msg, 2 )
+        return v
+    end,
+
+    uint= function( v, msg )
+        local n= tonumber(v)
+        -- unsigned integer upper range is the same as integers' (there's no
+        -- real unsigned within the Lua)
+        _assert( n and (n >= 0) and (n <= INT_MAX) and math.floor(n) == n,
+                    msg or at_msg, 2 )
+        return v
+    end,
+    
+    ['true']= assert_v( true ),
+    ['false']= assert_v( false ),
+
+    string_or_table= function( v, msg )
+        assert( tostring(v) or type(v)=="table", msg or at_msg, 2 )
+        return v
+    end,
+    
+    number_or_string= function( v, msg )
+        assert( tonumber(v) or type(v)=="table", msg or at_msg, 2 )
+        return v
+    end,
+
+    any= function( v, msg )
+        assert( v ~= nil, msg or av_msg, 2 )
+        return v
+    end,
+
+    -- Range assertion, with extra arguments per instance
+    -- 
+    -- Note: values may be of _any_ type that can do >=, <= comparisons.
+    --
+    range= function( lo, hi )
+        _assert( lo and hi and lo <= hi, "Bad limits", 2 )
+             -- make sure the limits make sense (just once)
+
+        return function(v,msg,lev)
+            if ( (lo and v<lo) or (hi and v>hi) ) then
+                msg= msg or "not in range: ("..(lo or "")..","..(hi or "")..")"
+                _assert( false, msg, 2 )
+            end
+            return v
+        end
+    end,
+    
+    -- Table contents assertion
+    --      - no unknown (non-numeric) keys are allowed
+    --      - numeric keys are ignored
+    --
+    -- Constraints patch should point to this, when using the ":{ ... }" constraint.
+    -- 
+    ["{}"]= function( tbl )
+
+        -- check all keys in 't' (including numeric, if any) that they do exist,
+        -- and carry the right type
+        --
+        local function subf1(v,t,msg,lev)
+            _assert(lev)
+            for k,f in pairs(t) do
+                -- 'f' is an assert function, or subtable
+                local ft= type(f)
+                if ft=="function" then
+                    f( v[k], msg, lev+1 )
+                elseif ft=="table" then
+                    _assert( type(v[k])=="table", msg or "no subtable "..tostring(k), lev+1 )
+                    subf1( v[k], f, msg, lev+1 )
+                else
+                    error( "Bad constraints table for '"..tostring(k).."'! (not a function)", lev+1 )
+                end
+            end
+        end
+                        
+        -- check there are no other (non-numeric) keys in 'v'
+        local function subf2(v,t,msg,lev)
+            _assert(lev)
+            for k,vv in pairs(v) do
+                if type(k)=="number" then
+                    -- skip them
+                elseif not t[k] then
+                    _assert( false, msg or "extra field: '"..tostring(k).."'", lev+1 )
+                elseif type(vv)=="table" then
+                    subf2( vv, t[k], msg, lev+1 )
+                end
+            end
+        end
+        
+        _assert( type(tbl)=="table", "Wrong argument to assert['{}']" )
+
+        return function( v, msg, lev )
+            lev= (lev or 1)+1
+            _assert( type(v)=="table" ,msg, lev )
+            subf1( v, tbl, msg, lev )
+            subf2( v, tbl, msg, lev )
+            return v
+        end
+    end,
+
+    -- ...
+}
+setmetatable( assert, assert )
+
+assert.void= assert["nil"]
+
+
+-----    
+-- void= assert.fails( function [,err_msg_str] )
+--
+-- Special assert function, to make sure the call within it fails, and gives a 
+-- specific error message (to be used in unit testing).
+--
+function assert.fails( func_block, err_msg )
+    --
+    local st,err= pcall( func_block )
+    if st then
+        _assert( false, "Block expected to fail, but didn't.", 2 )
+    elseif err_msg and err ~= err_msg then
+        _assert( false, "Failed with wrong error message: \n"..
+                       "'"..err.."'\nexpected: '"..err_msg.."'", 2 )
+    end
+end
+
+
+-----    
+-- void= assert.failsnot( function [,err_msg_str] )
+--
+-- Similar to 'assert.fails' but expects the code to survive.
+--
+function assert.failsnot( func_block, err_msg )
+    --
+    local st,err= pcall( func_block )
+    if not st then
+        _assert( false, "Block expected NOT to fail, but did."..
+                        (err and "\n\tError: '"..err.."'" or ""), 2 )
+    end
+end
+
+
+-----    
+-- void= assert.nilerr( function [,err_msg_str] )
+--
+-- Expects the function to return with 'nil,err' failure code, with
+-- optionally error string matching. Similar to --> 'assert.fails()'
+--
+function assert.nilerr( func_block, err_msg )
+    --
+    local v,err= func_block()
+    _assert( v==nil, "Expected to return nil, but didn't: "..tostring(v), 2 )
+    if err_msg and err ~= err_msg then
+        _assert( false, "Failed with wrong error message: \n"..
+                       "'"..err.."'\nexpected: '"..err_msg.."'", 2 )
+    end
+end
+
+
+-- Sanity check
+--
+assert( true )
+assert.fails( function() assert( false ) end )
+assert.fails( function() assert( nil ) end )
+
+
+return m    -- just info
diff --git a/unit_tests/scripts/_utils.lua b/unit_tests/scripts/_utils.lua
new file mode 100644
index 0000000..d710702
--- /dev/null
+++ b/unit_tests/scripts/_utils.lua
@@ -0,0 +1,75 @@
+local io = assert(io)
+local pairs = assert(pairs)
+local select = assert(select)
+local string_format = assert(string.format)
+local tostring = assert(tostring)
+local type = assert(type)
+
+local print_id = 0
+local P = function(whence_, ...)
+    if not io then return end
+    print_id = print_id + 1
+    local _str = string_format("%s: %02d.\t", whence_, print_id)
+    for _i  = 1, select('#', ...) do
+        _str = _str .. tostring(select(_i, ...)) .. "\t"
+    end
+    if io then
+        io.stderr:write(_str .. "\n")
+    end
+end
+
+local MAKE_PRINT = function()
+    local _whence = lane_threadname and lane_threadname() or "main"
+    return function(...)
+        P(_whence, ...)
+    end
+end
+
+local tables_match
+
+-- true if 'a' is a subtable of 'b'
+--
+local function subtable(a, b)
+    --
+    assert(type(a)=="table" and type(b)=="table")
+
+    for k,v in pairs(b) do
+        if type(v)~=type(a[k]) then
+            return false    -- not subtable (different types, or missing key)
+        elseif type(v)=="table" then
+            if not tables_match(v,a[k]) then return false end
+        else
+            if a[k] ~= v then return false end
+        end
+    end
+    return true     -- is a subtable
+end
+
+-- true when contents of 'a' and 'b' are identical
+--
+tables_match = function(a, b)
+    return subtable(a, b) and subtable(b, a)
+end
+
+local function dump_error_stack(error_reporting_mode_, stack)
+    local PRINT = MAKE_PRINT()
+    if error_reporting_mode_ == "minimal" then
+        assert(stack == nil, table.concat{"stack is a ", type(stack)})
+    elseif error_reporting_mode_ == "basic" then -- each stack line is a string in basic mode
+        PRINT("STACK:\n", table.concat(stack,"\n\t"));
+    else -- each stack line is a table in extended mode
+        PRINT "STACK:"
+        for line, details in pairs(stack) do
+            PRINT("\t", line);
+            for detail, value in pairs(details) do
+                PRINT("\t\t", detail, ": ", value)
+            end
+        end
+    end
+end
+
+return {
+    MAKE_PRINT = MAKE_PRINT,
+    tables_match = tables_match,
+    dump_error_stack = dump_error_stack
+}
diff --git a/unit_tests/scripts/coro/basics.lua b/unit_tests/scripts/coro/basics.lua
new file mode 100644
index 0000000..4444e87
--- /dev/null
+++ b/unit_tests/scripts/coro/basics.lua
@@ -0,0 +1,94 @@
+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
+    local msgs = {
+        ["Lua 5.1"] = "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]
+    assert(err == nil and status == expected_msg 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/error_handling.lua b/unit_tests/scripts/coro/error_handling.lua
new file mode 100644
index 0000000..3b50c7f
--- /dev/null
+++ b/unit_tests/scripts/coro/error_handling.lua
@@ -0,0 +1,64 @@
+local lanes = require "lanes".configure{strip_functions = true}
+
+local fixture = require "fixture"
+lanes.finally(fixture.throwing_finalizer)
+
+local utils = lanes.require "_utils"
+local PRINT = utils.MAKE_PRINT()
+
+-- 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, "unexpected reply ".._ack)
+    end
+    return "done!"
+end
+
+local force_error_test = function(error_trace_level_)
+    -- the generator, minimal error handling
+    local coro_g = lanes.coro("*", {name = "auto", error_trace_level = error_trace_level_}, yielder)
+
+    -- 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")
+    -- mistake: we resume with 0 when the lane expects 3 -> assert() in the lane body!
+    assert(h:resume(0) == "!")
+    local a, b, c = h:join()
+    PRINT(error_trace_level_ .. ":", a, b, c)
+    local expected_c_type = error_trace_level_ == "minimal" and "nil" or "table"
+    assert(h.status == "error" and string.find(b, "unexpected reply 0", 1, true) and type(c) == expected_c_type, "error message is " .. b)
+    utils.dump_error_stack(error_trace_level_, c)
+end
+
+if false then
+    force_error_test("minimal")
+end
+
+if false then
+    force_error_test("basic")
+end
+
+if false then
+    force_error_test("extended")
+end
+
+if true then
+    -- start a coroutine lane that ends with a non-string error
+    local non_string_thrower = function()
+        error({"string in table"})
+    end
+    local coro_g = lanes.coro("*", {name = "auto"}, non_string_thrower)
+    local h = coro_g()
+    local a, b, c = h:join()
+    -- we get the expected error back
+    PRINT("non_string_thrower:", a, b, c)
+    assert(a == nil and type(b) == "table" and b[1] == "string in table" and c == nil)
+end
diff --git a/unit_tests/scripts/lane/cooperative_shutdown.lua b/unit_tests/scripts/lane/cooperative_shutdown.lua
new file mode 100644
index 0000000..2649079
--- /dev/null
+++ b/unit_tests/scripts/lane/cooperative_shutdown.lua
@@ -0,0 +1,45 @@
+local lanes = require "lanes"
+
+-- launch lanes that cooperate properly with cancellation request
+
+local lane1 = function()
+        -- loop breaks on cancellation request
+        repeat
+                lanes.sleep(0)
+        until cancel_test()
+        print "lane1 cancelled"
+end
+
+local lane2 = function(linda_)
+        -- loop breaks on lane/linda cancellation
+        repeat
+                local k, v = linda_:receive('k')
+        until v == lanes.cancel_error
+        print "lane2 cancelled"
+end
+
+local lane3 = function()
+        -- 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
+        repeat until false
+end
+
+
+
+-- the generators
+local g1 = lanes.gen("*", lane1)
+local g2 = lanes.gen("*", lane2)
+local g3 = lanes.gen("*", lane3)
+
+-- launch lanes
+local h1 = g1()
+
+local linda = lanes.linda()
+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"
+
+-- let the script terminate, Lanes should not crash at shutdown
diff --git a/unit_tests/scripts/lane/stdlib_naming.lua b/unit_tests/scripts/lane/stdlib_naming.lua
new file mode 100644
index 0000000..2e045c3
--- /dev/null
+++ b/unit_tests/scripts/lane/stdlib_naming.lua
@@ -0,0 +1,87 @@
+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 lanes_gen = assert(lanes.gen)
+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_ .. "'")
+end
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+PRINT("\n\n", "---=== Stdlib naming ===---", "\n\n")
+
+local function dump_g(_x)
+    lane_threadname "dump_g"
+    assert(print)
+    print("### dumping _G for '" .. _x .. "'")
+    for k, v in pairs(_G) do
+        print("\t" .. k .. ": " .. type(v))
+    end
+    return true
+end
+
+local function io_os_f(_x)
+    lane_threadname "io_os_f"
+    assert(print)
+    print("### checking io and os libs existence for '" .. _x .. "'")
+    assert(io)
+    assert(os)
+    return true
+end
+
+local function coro_f(_x)
+    lane_threadname "coro_f"
+    assert(print)
+    print("### checking coroutine lib existence for '" .. _x .. "'")
+    assert(coroutine)
+    return true
+end
+
+assert.fails(function() lanes_gen("xxx", {gc_cb = gc_cb}, io_os_f) end)
+
+local stdlib_naming_tests =
+{
+    -- { "", dump_g},
+    -- { "coroutine", dump_g},
+    -- { "io", dump_g},
+    -- { "bit32", dump_g},
+    { "coroutine?", coro_f}, -- in Lua 5.1, the coroutine base library doesn't exist (coroutine table is created when 'base' is opened)
+    { "*", io_os_f},
+    { "io,os", io_os_f},
+    { "io+os", io_os_f},
+    { "/io;os[base{", io_os_f}, -- use unconventional name separators to check that everything works fine
+}
+
+for _, t in ipairs(stdlib_naming_tests) do
+    local f= lanes_gen(t[1], {gc_cb = gc_cb}, t[2])     -- any delimiter will do
+    assert(f(t[1])[1])
+end
+
+PRINT("collectgarbage")
+collectgarbage()
diff --git a/unit_tests/scripts/lane/tasking_basic.lua b/unit_tests/scripts/lane/tasking_basic.lua
new file mode 100644
index 0000000..99be321
--- /dev/null
+++ b/unit_tests/scripts/lane/tasking_basic.lua
@@ -0,0 +1,74 @@
+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 lanes_gen = assert(lanes.gen)
+local lanes_linda = assert(lanes.linda)
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local function task(a, b, c)
+    local new_name = "task("..a..","..b..","..c..")"
+    -- test lane naming change
+    lane_threadname(new_name)
+    assert(lane_threadname() == new_name)
+    --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
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+PRINT("\n\n", "---=== Tasking (basic) ===---", "\n\n")
+
+local task_launch = lanes_gen("", { globals={hey=true}, gc_cb = gc_cb}, task)
+    -- base stdlibs, normal priority
+
+-- 'task_launch' is a factory of multithreaded tasks, we can launch several:
+
+local lane1 = task_launch(100,200,3)
+assert.fails(function() print(lane1[lane1]) end) -- indexing the lane with anything other than a string or a number should fail
+lanes.sleep(0.1) -- give some time so that the lane can set its name
+assert(lane1:get_threadname() == "task(100,200,3)", "Lane name is " .. lane1:get_threadname())
+
+local lane2= task_launch(200,300,4)
+
+-- At this stage, states may be "pending", "running" or "done"
+
+local st1,st2= lane1.status, lane2.status
+PRINT(st1,st2)
+assert(st1=="pending" or st1=="running" or st1=="done")
+assert(st2=="pending" or st2=="running" or st2=="done")
+
+-- Accessing results ([1..N]) pends until they are available
+--
+PRINT("waiting...")
+local v1, v1_hey= lane1[1], lane1[2]
+local v2, v2_hey= lane2[1], lane2[2]
+
+PRINT(v1, v1_hey)
+assert(v1_hey == true)
+
+PRINT(v2, v2_hey)
+assert(v2_hey == true)
+
+assert(lane1.status == "done")
+assert(lane1.status == "done")
diff --git a/unit_tests/scripts/lane/tasking_cancelling.lua b/unit_tests/scripts/lane/tasking_cancelling.lua
new file mode 100644
index 0000000..a4e0fde
--- /dev/null
+++ b/unit_tests/scripts/lane/tasking_cancelling.lua
@@ -0,0 +1,122 @@
+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 lanes_gen = assert(lanes.gen)
+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_ .. "'")
+end
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+PRINT("\n\n", "---=== Tasking (cancelling) ===---", "\n\n")
+
+local task_launch2 = lanes_gen("", { 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")
+assert.fails(function() limited:limit("key", -1) end)
+assert.failsnot(function() limited:limit("key", 1) end)
+-- [[################################################
+limited:send("key", "hello") -- saturate linda
+for k, v in pairs(limited:dump()) do
+    PRINT("limited[" .. tostring(k) .. "] = " .. tostring(v))
+end
+local wait_send = function()
+    local a,b
+    set_finalizer(function() print("wait_send", a, b) end)
+    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"
+wait_send_lane:cancel() -- hard cancel, 0 timeout
+repeat until wait_send_lane.status == "cancelled"
+print "wait_send_lane is cancelled"
+--################################################]]
+local wait_receive = function()
+    local k, v
+    set_finalizer(function() print("wait_receive", k, v) 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"
+wait_receive_lane:cancel() -- hard cancel, 0 timeout
+repeat until wait_receive_lane.status == "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
+end
+
+local wait_receive_batched_lane = lanes.gen("*", wait_receive_batched)()
+repeat 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"
+--################################################]]
diff --git a/unit_tests/scripts/lane/tasking_comms_criss_cross.lua b/unit_tests/scripts/lane/tasking_comms_criss_cross.lua
new file mode 100644
index 0000000..db63b8e
--- /dev/null
+++ b/unit_tests/scripts/lane/tasking_comms_criss_cross.lua
@@ -0,0 +1,53 @@
+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 lanes_gen = assert(lanes.gen)
+local lanes_linda = assert(lanes.linda)
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local gc_cb = function(name_, status_)
+    PRINT("                             ---> lane '" .. name_ .. "' collected with status '" .. status_ .. "'")
+end
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+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},
+  function(linda, ch_in, ch_out)
+        lane_threadname("criss cross " .. ch_in .. " -> " .. ch_out)
+    local function STAGE(str)
+        io.stderr:write(ch_in..": "..str.."\n")
+        linda:send(nil, ch_out, str)
+        local k,v= linda:receive(nil, ch_in)
+        assert(v==str)
+    end
+    STAGE("Hello")
+    STAGE("I was here first!")
+    STAGE("So what?")
+  end
+)
+
+local linda= lanes_linda("criss cross")
+
+local a,b= tc(linda, "A","B"), tc(linda, "B","A")   -- launching two lanes, twisted comms
+
+local _= a[0],b[0]  -- waits until they are both ready
+
+PRINT("collectgarbage")
+a, b = nil
+collectgarbage()
diff --git a/unit_tests/scripts/lane/tasking_communications.lua b/unit_tests/scripts/lane/tasking_communications.lua
new file mode 100644
index 0000000..b922973
--- /dev/null
+++ b/unit_tests/scripts/lane/tasking_communications.lua
@@ -0,0 +1,149 @@
+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 lanes_gen = assert(lanes.gen)
+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_ .. "'")
+end
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local tables_match = utils.tables_match
+
+local SLEEP = function(...)
+    local k, v = lanes.sleep(...)
+    assert(k == nil and v == "timeout")
+end
+
+PRINT("\n\n", "---=== Communications ===---", "\n\n")
+
+local function WR(...) io.stderr:write(...) end
+
+local chunk= function(linda)
+    local function receive() return linda:receive("->") end
+    local function send(...) local _res, _err = linda:send("<-", ...) assert(_res == true and _err == nil) end
+
+    WR("chunk ", "Lane starts!\n")
+
+    local k,v
+    k,v=receive(); WR("chunk ", v.." received (expecting 1)\n"); assert(k and v==1)
+    k,v=receive(); WR("chunk ", v.." received (expecting 2)\n"); assert(k and v==2)
+    k,v=receive(); WR("chunk ", v.." received  (expecting 3)\n"); assert(k and v==3)
+    k,v=receive(); WR("chunk ", tostring(v).." received  (expecting nil from __lanesconvert)\n"); assert(k and v==nil, "table with __lanesconvert==lanes.null should be received as nil, got " .. tostring(v)) -- a table with __lanesconvert was sent
+    k,v=receive(); WR("chunk ", tostring(v).." received (expecting nil)\n"); assert(k and v==nil)
+
+    send(4,5,6);              WR("chunk ", "4,5,6 sent\n")
+    send 'aaa';               WR("chunk ", "'aaa' sent\n")
+    send(nil);                WR("chunk ", "nil sent\n")
+    send { 'a', 'b', 'c', d=10 }; WR("chunk ","{'a','b','c',d=10} sent\n")
+
+    k,v=receive(); WR("chunk ", v.." received\n"); assert(v==4)
+
+    local subT1 = { "subT1"}
+    local subT2 = { "subT2"}
+    send { subT1, subT2, subT1, subT2}; WR("chunk ", "{ subT1, subT2, subT1, subT2} sent\n")
+
+    WR("chunk ", "Lane ends!\n")
+end
+
+local linda = lanes_linda("communications")
+assert(type(linda) == "userdata" and tostring(linda) == "Linda: communications")
+    --
+    -- ["->"] master -> slave
+    -- ["<-"] slave <- master
+
+WR "test linda:get/set..."
+linda:set("<->", "x", "y", "z")
+local b,x,y,z = linda:get("<->", 1)
+assert(b == 1 and x == "x" and y == nil and z == nil)
+local b,x,y,z = linda:get("<->", 2)
+assert(b == 2 and x == "x" and y == "y" and z == nil)
+local b,x,y,z = linda:get("<->", 3)
+assert(b == 3 and x == "x" and y == "y" and z == "z")
+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)
+assert(k == "<->" and y == "y" and z == "z")
+linda:set("<->")
+local b,x,y,z,w = linda:get("<->", 4)
+assert(b == 0 and x == nil and y == nil and z == nil and w == nil)
+WR "ok\n"
+
+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
+
+SEND(1);  WR("main ", "1 sent\n")
+SEND(2);  WR("main ", "2 sent\n")
+SEND(3);  WR("main ", "3 sent\n")
+SEND(setmetatable({"should be ignored"},{__lanesconvert=lanes.null})); WR("main ", "__lanesconvert table sent\n")
+for i=1,40 do
+    WR "."
+    SLEEP(0.0001)
+    assert(PEEK() == 0)    -- nothing coming in, yet
+end
+SEND(nil);  WR("\nmain ", "nil sent\n")
+
+local a,b,c = RECEIVE(), RECEIVE(), RECEIVE()
+
+print("lane status: " .. comms_lane.status)
+if comms_lane.status == "error" then
+    print(comms_lane:join())
+else
+    WR("main ", tostring(a)..", "..tostring(b)..", "..tostring(c).." received\n")
+end
+
+assert(a==4 and b==5 and c==6)
+
+local aaa = RECEIVE(); WR("main ", aaa.." received\n")
+assert(aaa=='aaa')
+
+local null = RECEIVE();   WR(tostring(null).." received\n")
+assert(null==nil)
+
+local out_t = RECEIVE();   WR(type(out_t).." received\n")
+assert(tables_match(out_t, {'a','b','c',d=10}))
+
+assert(PEEK() == 0)
+SEND(4)
+
+local complex_table = RECEIVE(); WR(type(complex_table).." received\n")
+assert(complex_table[1] == complex_table[3] and complex_table[2] == complex_table[4])
+WR(table.concat({complex_table[1][1],complex_table[2][1],complex_table[3][1],complex_table[4][1]},", "))
+
+WR("collectgarbage")
+comms_lane = nil
+collectgarbage()
+-- wait
+WR("waiting 1s")
+SLEEP(1)
diff --git a/unit_tests/scripts/lane/tasking_error.lua b/unit_tests/scripts/lane/tasking_error.lua
new file mode 100644
index 0000000..1e2347f
--- /dev/null
+++ b/unit_tests/scripts/lane/tasking_error.lua
@@ -0,0 +1,49 @@
+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 lanes_gen = assert(lanes.gen)
+local lanes_linda = assert(lanes.linda)
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local gc_cb = function(name_, status_)
+    PRINT("                             ---> lane '" .. name_ .. "' collected with status '" .. status_ .. "'")
+end
+
+PRINT("---=== Tasking (error) ===---", "\n\n")
+
+-- a lane that throws immediately the error value it received
+local g = lanes_gen("", {gc_cb = gc_cb}, error)
+local errmsg = "ERROR!"
+
+if true then
+    -- if you index an errored lane, it should throw the error again
+    local lane = g(errmsg)
+    assert.fails(function() return lane[1] end)
+    assert(lane.status == "error")
+    -- even after indexing, joining a lane in error should give nil,<error>
+    local a,b = lane:join()
+    assert(a == nil and string.find(b, errmsg))
+end
+
+if true then
+    local lane = g(errmsg)
+    -- after indexing, joining a lane in error should give nil,<error>
+    local a, b = lane:join()
+    assert(lane.status == "error")
+    assert(a == nil and string.find(b, errmsg))
+    -- even after joining, indexing should raise an error
+    assert.fails(function() return lane[1] end)
+    -- unless we index with a negative value to get the error message
+    local c = lane[-1]
+    assert(c == b)
+end
diff --git a/unit_tests/scripts/lane/tasking_join_test.lua b/unit_tests/scripts/lane/tasking_join_test.lua
new file mode 100644
index 0000000..8f2d4db
--- /dev/null
+++ b/unit_tests/scripts/lane/tasking_join_test.lua
@@ -0,0 +1,65 @@
+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 lanes_gen = assert(lanes.gen)
+local lanes_linda = assert(lanes.linda)
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local gc_cb = function(name_, status_)
+    PRINT("                             ---> lane '" .. name_ .. "' collected with status '" .. status_ .. "'")
+end
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local SLEEP = function(...)
+    local k, v = lanes.sleep(...)
+    assert(k == nil and v == "timeout")
+end
+
+PRINT("---=== :join test ===---", "\n\n")
+
+-- 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", {gc_cb = gc_cb},
+    function(arg)
+        lane_threadname "join test lane"
+        set_finalizer(function() end)
+        local aux= {}
+        for i, v in ipairs(arg) do
+           table.insert(aux, 1, v)
+        end
+        -- unpack was renamed table.unpack in Lua 5.2: cater for both!
+    return (unpack or table.unpack)(aux)
+end)
+
+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()
+if h.status == "error" then
+    print(h:get_threadname(), "error: " , a, b, c, d)
+else
+    print(h:get_threadname(), a,b,c,d)
+    assert(a==14, "a == " .. tostring(a))
+    assert(b==13, "b == " .. tostring(b))
+    assert(c==12, "c == " .. tostring(c))
+    assert(d==nil, "d == " .. tostring(d))
+end
+
+local nameof_type, nameof_name = lanes.nameof(print)
+PRINT("name of " .. nameof_type .. " print = '" .. nameof_name .. "'")
diff --git a/unit_tests/scripts/lane/tasking_send_receive_code.lua b/unit_tests/scripts/lane/tasking_send_receive_code.lua
new file mode 100644
index 0000000..77a4b12
--- /dev/null
+++ b/unit_tests/scripts/lane/tasking_send_receive_code.lua
@@ -0,0 +1,91 @@
+local config = { with_timers = false, strip_functions = false, internal_allocator = "libc"}
+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 lanes_gen = assert(lanes.gen)
+local lanes_linda = assert(lanes.linda)
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+local gc_cb = function(name_, status_)
+    PRINT("                             ---> lane '" .. name_ .. "' collected with status '" .. status_ .. "'")
+end
+
+-- ##################################################################################################
+-- ##################################################################################################
+-- ##################################################################################################
+
+PRINT("---=== Receive & send of code ===---", "\n")
+
+local upvalue = "123"
+local tostring = tostring
+
+local function chunk2(linda)
+    local utils = require "_utils"
+    local PRINT = utils.MAKE_PRINT()
+    PRINT("here")
+    assert(upvalue == "123")    -- even when running as separate thread
+    -- function name & line number should be there even as separate thread
+    --
+    local info= debug.getinfo(1)    -- 1 = us
+    --
+    PRINT("linda named-> '" ..tostring(linda).."'")
+    PRINT "debug.getinfo->"
+    for k,v in pairs(info) do PRINT(k,v) end
+
+    -- some assertions are adjusted depending on config.strip_functions, because it changes what we get out of debug.getinfo
+    assert(info.nups == (_VERSION == "Lua 5.1" and 3 or 4), "bad nups " .. info.nups)    -- upvalue + config + tostring + _ENV (Lua > 5.2 only)
+    assert(info.what == "Lua", "bad what")
+    --assert(info.name == "chunk2")   -- name does not seem to come through
+    assert(config.strip_functions and info.source=="=?" or string.match(info.source, "^@.*tasking_send_receive_code.lua$"), "bad info.source " .. info.source)
+    assert(config.strip_functions and info.short_src=="?" or string.match(info.short_src, "^.*tasking_send_receive_code.lua$"), "bad info.short_src " .. info.short_src)
+    -- These vary so let's not be picky (they're there..)
+    --
+    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(k=="down")
+
+    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 t2= lanes_gen("debug,package,string,io", {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())
+    assert(false)
+end
+PRINT(s)
+assert(s=="ready!", s .. " is not 'ready!'")
+
+-- returns of the 'chunk2' itself
+--
+local k,f= linda:receive("up")
+assert(type(f)=="function")
+
+local s2= f()
+assert(s2==":)")
+
+local k,ok2= linda:receive("up")
+assert(ok2 == "ok2")
diff --git a/unit_tests/scripts/lane/uncooperative_shutdown.lua b/unit_tests/scripts/lane/uncooperative_shutdown.lua
new file mode 100644
index 0000000..ce7df57
--- /dev/null
+++ b/unit_tests/scripts/lane/uncooperative_shutdown.lua
@@ -0,0 +1,24 @@
+if not package.preload.fixture then
+        error "can't be run outside of UnitTest framework"
+end
+local fixture = require "fixture"
+
+local lanes = require "lanes".configure{shutdown_timeout = 0.001, on_state_create = fixture.on_state_create}
+
+-- launch lanes that blocks forever
+local lane = function()
+        local fixture = require "fixture"
+        fixture.forever()
+end
+
+-- the generator
+local g1 = lanes.gen("*", lane)
+
+-- launch lane
+local h1 = g1()
+
+-- wait until the lane is running
+repeat until h1.status == "running"
+
+-- let the script end, Lanes should throw std::logic_error because the lane did not gracefully terminate
+lanes.finally(fixture.throwing_finalizer)
diff --git a/unit_tests/scripts/linda/multiple_keepers.lua b/unit_tests/scripts/linda/multiple_keepers.lua
new file mode 100644
index 0000000..8733087
--- /dev/null
+++ b/unit_tests/scripts/linda/multiple_keepers.lua
@@ -0,0 +1,26 @@
+-- 3 keepers in addition to the one reserved for the timer linda
+local require_lanes_result_1, require_lanes_result_2 = require "lanes".configure{nb_user_keepers = 3, keepers_gc_threshold = 500}
+local lanes = require_lanes_result_1
+
+local a = lanes.linda("A", 1)
+local b = lanes.linda("B", 2)
+local c = lanes.linda("C", 3)
+
+-- store each linda in the other 2
+do
+        a:set("kA", a, b, c)
+        local nA, rA, rB, rC = a:get("kA", 3)
+        assert(nA == 3 and rA == a and rB == b and rC == c)
+end
+
+do
+        b:set("kB", a, b, c)
+        local nB, rA, rB, rC = b:get("kB", 3)
+        assert(nB == 3 and rA == a and rB == b and rC == c)
+end
+
+do
+        c:set("kC", a, b, c)
+        local nC, rA, rB, rC = c:get("kC", 3)
+        assert(nC == 3 and rA == a and rB == b and rC == c)
+end
diff --git a/unit_tests/scripts/linda/send_receive.lua b/unit_tests/scripts/linda/send_receive.lua
new file mode 100644
index 0000000..9a6a7be
--- /dev/null
+++ b/unit_tests/scripts/linda/send_receive.lua
@@ -0,0 +1,46 @@
+local lanes = require "lanes"
+
+-- a newly created linda doesn't contain anything
+local l = lanes.linda()
+assert(l.null == lanes.null)
+assert(l:dump() == nil)
+
+-- read something with 0 timeout, should fail
+local k,v = l:receive(0, "k")
+assert(k == nil and v == 'timeout')
+
+-- send some value
+assert(l:send("k1", 99) == true)
+-- make sure the contents look as expected
+local t = l:dump()
+assert(type(t) == 'table')
+local tk1 = t.k1
+assert(type(tk1) == 'table')
+assert(tk1.first == 1 and tk1.count == 1 and tk1.limit == 'unlimited' and tk1.restrict == 'none')
+assert(#tk1.fifo == tk1.count, #tk1.fifo .. " ~= " .. tk1.count)
+assert(tk1.fifo[1] == 99, tk1.fifo[1] .. " ~= " .. 99)
+
+-- read the value, should succeed
+local k,v = l:receive("k1")
+assert(k == "k1" and v == 99)
+-- after reading, the data is no longer available (even if the key itself still exists within the linda)
+local t = l:dump()
+assert(type(t) == 'table')
+local tk1 = t.k1
+assert(type(tk1) == 'table')
+assert(tk1.first == 1 and tk1.count == 0 and tk1.limit == 'unlimited' and tk1.restrict == 'none')
+assert(#tk1.fifo == tk1.count and tk1.fifo[1] == nil)
+-- read again, should fail
+local k,v = l:receive(0, "k1")
+assert(k == nil and v == 'timeout')
+
+-- send null, read nil
+l:send("k", l.null)
+local k,v = l:receive(0, "k")
+assert(k == "k" and v == nil)
+
+-- using a deep userdata (such as another linda) as key, should work
+local l2 = lanes.linda()
+l:send(nil, l2, 99)
+local k,v = l:receive(0, l2)
+assert(k == l2 and v == 99)
diff --git a/unit_tests/scripts/linda/send_registered_userdata.lua b/unit_tests/scripts/linda/send_registered_userdata.lua
new file mode 100644
index 0000000..2c0195a
--- /dev/null
+++ b/unit_tests/scripts/linda/send_registered_userdata.lua
@@ -0,0 +1,5 @@
+local lanes = require 'lanes'.configure{with_timers = false}
+local l = lanes.linda'gleh'
+l:set('yo', io.stdin)
+local n, stdin_out = l:get('yo')
+assert(n == 1 and stdin_out == io.stdin, tostring(stdin_out) .. " ~= " .. tostring(io.stdin))