linda :get(), :set(), :limit() return value changes

12 files changed, 129 insertions, 93 deletions

diff --git a/CHANGES b/CHANGES
index 64c8bdf..80e94cf 100644
--- a/CHANGES
+++ b/CHANGES
@@ -18,13 +18,14 @@ CHANGE 2: BGe 11-Jun-24
             - new function lanes.finally(). Installs a function that gets called at Lanes shutdown.
             - lanes have a __close metamethod that calls join().
             - lanes can no longer be "killed" by hard-stopping their thread without any resource cleanup (see lane:cancel()).
-            - lane:join(), linda:receive(), linda:send() return nil, error in case of problem.
+            - lane:join() returns nil, error in case of problem.
             - lane function body must return a non-nil first value on success if lane is waited upon with lane:join().
             - lanes.sleep() accept a new argument "indefinitely" to block forever (until hard cancellation is received).
         - Lindas:
             - providing "auto" as name when constructing a Linda cause Lanes to provide a name built from the source location of the construction.
             - specifying a group to lanes.linda() is mandatory when Lanes is configured with user Keepers.
             - linda:deep() result no longer contains the raw C pointer of the Linda object.
+            - linda :receive(), :send(), :get(), :set(), :limit() return nil, error in case of problem. Returned values in case of success change too.
             - Lindas have a __close metamethod that calls any provided suitable handler at Linda creation.
         - Lane generator settings:
             - error_trace_level added. Replaces the global verbose_errors setting.
diff --git a/docs/index.html b/docs/index.html
index e884145..06ce610 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1209,13 +1209,14 @@
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        true|(nil,[lanes.cancel_error|"timeout"]) = h:limit(key, n_uint)
+        bool|(nil,[lanes.cancel_error|"timeout"]) = h:limit(key, n_uint)
 </pre></td></tr></table>
 
 <p>
         By default, queue sizes are unlimited but limits can be enforced using the <tt>limit()</tt> method. This can be useful to balance execution speeds in a producer/consumer scenario. <tt>nil</tt> removes the limit.<br />
         A limit of 0 is allowed to block everything.<br />
-        If the key was full but the limit change added some room, <tt>limit()</tt> returns <tt>true</tt> and the Linda is signalled so that <tt>send()</tt>-blocked threads are awakened.<br />
+        If the key was full but the limit change added some room, <tt>limit()</tt> returns <tt>true</tt> and the Linda is signalled so that <tt>send()</tt>-blocked threads are awakened, else the return value is <tt>false</tt>.<br />
+        Or <tt>nil, lanes.cancel_error</tt> in case of cancellation, of course.
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
@@ -1276,15 +1277,19 @@
 </p>
 
 <table border="1" bgcolor="#E0E0FF" cellpadding="10" style="width:50%"><tr><td><pre>
-        true|lanes.cancel_error = linda_h:set(key [, val [, ...]])
+        true|nil,lanes.cancel_error = linda_h:set(key [, val [, ...]])
 
-        [[val [, ...]]|lanes.cancel_error] = linda_h:get(key [, count = 1])
+        [number,[val [, ...]]|nil,lanes.cancel_error] = linda_h:get(key [, count = 1])
 </pre></td></tr></table>
 
 <p>
         The table access methods are for accessing a slot without queuing or consuming. They can be used for making shared tables of storage among the lanes.<br />
         Writing to a slot never blocks because it ignores the limit. It overwrites existing value and clears any possible queued entries.<br />
-        Reading doesn't block either because <tt>get()</tt> returns whatever is available (which can be nothing), up to the specified count.<br />
+        Reading doesn't block either because <tt>get()</tt> returns:
+        <ul>
+                <li><tt>nil, lanes.cancel_error</tt> in case of cancellation.</li>
+                <li><tt>number, val...</tt> where number is the actual count of items obtained from the linda (can be 0).</li>
+        </ul>
         Table access and <tt>send()</tt>/<tt>receive()</tt> can be used together; reading a slot essentially peeks the next outcoming value of a queue.
 </p>
 
diff --git a/src/keeper.cpp b/src/keeper.cpp
index 7000372..4175d84 100644
--- a/src/keeper.cpp
+++ b/src/keeper.cpp
@@ -123,26 +123,32 @@ KeyUD* KeyUD::GetPtr(KeeperState const K_, int idx_)
 // #################################################################################################
 
 // in: fifo
-// out: ...|nothing
-// pops the fifo, push as much data as is available (up to the specified count) without consuming it
+// out: bool ...
+// pops the fifo, push bool + as much data as is available (up to the specified count) without consuming it
+// bool is true if the requested count was served, else false
 void KeyUD::peek(KeeperState const K_, int const count_)
 {
-    LUA_ASSERT(K_, KeyUD::GetPtr(K_, -1) == this);
+    STACK_CHECK_START_ABS(K_, 1);
+    LUA_ASSERT(K_, KeyUD::GetPtr(K_, -1) == this);                                                 // K_: KeyUD
     if (count <= 0) { // no data is available
         lua_pop(K_, 1);                                                                            // K_:
+        lua_pushinteger(K_, 0);                                                                    // K_: 0
         return;
     }
 
-    // read <count_> value off the fifo
+    // read <count_> value off the fifo, if possible
     prepareAccess(K_, -1);                                                                         // K_: fifo
-    int const _at{ lua_gettop(K_) };
     int const _count{ std::min(count_, count) };
+    lua_pushinteger(K_, _count);                                                                   // K_: fifo _count
+    lua_insert(K_, 1);                                                                             // K_: _count fifo
+    STACK_CHECK(K_, 2);
     STACK_GROW(K_, _count);
     for (int const _i : std::ranges::iota_view{ 1, _count }) { // push val2 to valN
-        lua_rawgeti(K_, 1, first + _i);                                                            // K_: fifo val2..N
+        lua_rawgeti(K_, 2, first + _i);                                                            // K_: _count fifo val2..N
     }
-    lua_rawgeti(K_, 1, first); // push val1                                                        // K_: fifo val2..N val1
-    lua_replace(K_, _at); // replace fifo by val1 to get the output properly ordered               // K_: val1..N
+    lua_rawgeti(K_, 2, first); // push val1                                                        // K_: _count fifo val2..N val1
+    lua_replace(K_, 2); // replace fifo by val1 to get the output properly ordered                 // K_: _count val1..N
+    STACK_CHECK(K_, 1 + _count);
 }
 
 // #################################################################################################
@@ -418,7 +424,7 @@ int keepercall_destruct(lua_State* const L_)
 // #################################################################################################
 
 // in: linda_ud key [count]
-// out: at most <count> values
+// out: bool + at most <count> values
 int keepercall_get(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -433,11 +439,13 @@ int keepercall_get(lua_State* const L_)
     lua_remove(_K, 1);                                                                             // _K: KeyUD
     KeyUD* const _key{ KeyUD::GetPtr(_K, -1) };
     if (_key != nullptr) {
-        _key->peek(_K, _count);                                                                    // _K: val...
+        _key->peek(_K, _count);                                                                    // _K: N val...
     } else {
         // no fifo was ever registered for this key, or it is empty
         lua_pop(_K, 1);                                                                            // _K:
+        lua_pushinteger(_K, 0);                                                                    // _K: 0
     }
+    LUA_ASSERT(_K, lua_isnumber(_K, 1));
     return lua_gettop(_K);
 }
 
@@ -462,13 +470,10 @@ int keepercall_limit(lua_State* const L_)
     }
     // remove any clutter on the stack
     lua_settop(_K, 0);                                                                             // _K:
-    if (_key->changeLimit(_limit)) {
-        // return true if we decide that blocked threads waiting to write on that key should be awakened
-        // this is the case if we detect the key was full but it is no longer the case
-        lua_pushboolean(_K, 1);                                                                    // _K: true
-    }
-    // return 0 or 1 value
-    return lua_gettop(_K);
+    // return true if we decide that blocked threads waiting to write on that key should be awakened
+    // this is the case if we detect the key was full but it is no longer the case
+    lua_pushboolean(_K, _key->changeLimit(_limit) ? 1 : 0);                                        // _K: bool
+    return 1;
 }
 
 // #################################################################################################
@@ -570,7 +575,7 @@ int keepercall_send(lua_State* const L_)
 // #################################################################################################
 
 // in: linda key [val...]
-// out: true if the linda was full but it's no longer the case, else nothing
+// out: true if the linda was full but it's no longer the case, else false
 int keepercall_set(lua_State* const L_)
 {
     KeeperState const _K{ L_ };
@@ -593,7 +598,7 @@ int keepercall_set(lua_State* const L_)
                 lua_pushnil(_K);                                                                   // _K: KeysDB key nil
                 lua_rawset(_K, -3);                                                                // _K: KeysDB
             } else {
-                lua_remove(_K, -2);                                                                // _K: KeysDB KeyUD
+                lua_remove(_K, -2); // KeyUD::reset expects KeyUD at the top                       // _K: KeysDB KeyUD
                 // we create room if the KeyUD was full but it is no longer the case
                 _should_wake_writers = _key->reset(_K);
             }
@@ -619,7 +624,9 @@ int keepercall_set(lua_State* const L_)
         lua_replace(_K, -2 - _count);                                                              // _K: KeysDB KeyUD val...
         [[maybe_unused]] bool const _pushed{ _key->push(_K, _count) };                             // _K: KeysDB
     }
-    return _should_wake_writers ? (lua_pushboolean(_K, 1), 1) : 0;
+    // stack isn't the same here depending on what we did before, but that's not a problem
+    lua_pushboolean(_K, _should_wake_writers ? 1 : 0);                                             // _K: ... bool
+    return 1;
 }
 
 // #################################################################################################
diff --git a/src/lanes.lua b/src/lanes.lua
index d890adf..c860ba0 100644
--- a/src/lanes.lua
+++ b/src/lanes.lua
@@ -400,7 +400,8 @@ local configure_timers = function()
 
     -- Timer lane; initialize only on the first 'require "lanes"' instance (which naturally has 'table' always declared)
     local first_time_key = "first time"
-    local first_time = timerLinda:get(first_time_key) == nil
+    local _, _first_time_val = timerLinda:get(first_time_key)
+    local first_time = (_first_time_val == nil)
     timerLinda:set(first_time_key, true)
     if first_time then
 
@@ -490,8 +491,8 @@ local configure_timers = function()
                     --
                     local t2 = t1[key_]
                     if not t2 then
-                        t2= {}
-                        t1[key_]= t2
+                        t2 = {}
+                        t1[key_] = t2
                     end
 
                     t2[1] = wakeup_at_
@@ -507,10 +508,10 @@ local configure_timers = function()
                 local now = now_secs()
                 local next_wakeup
 
-                for linda_deep,t1 in pairs(collection) do
-                    for key,t2 in pairs(t1) do
+                for linda_deep, t1 in pairs(collection) do
+                    for key, t2 in pairs(t1) do
                         --
-                        if key==linda_deep then
+                        if key == linda_deep then
                             -- no 'continue' in Lua :/
                         else
                             -- 't2': { wakeup_at_secs [,period_secs] }
@@ -519,10 +520,10 @@ local configure_timers = function()
                             local period= t2[2]     -- may be 'nil'
 
                             if wakeup_at <= now then
-                                local linda= t1[linda_deep]
+                                local linda = t1[linda_deep]
                                 assert(linda)
 
-                                linda:set(key, now )
+                                linda:set(key, now)
 
                                 -- 'pairs()' allows the values to be modified (and even
                                 -- removed) as far as keys are not touched
@@ -530,13 +531,13 @@ local configure_timers = function()
                                 if not period then
                                     -- one-time timer; gone
                                     --
-                                    t1[key]= nil
-                                    wakeup_at= nil   -- no 'continue' in Lua :/
+                                    t1[key] = nil
+                                    wakeup_at = nil   -- no 'continue' in Lua :/
                                 else
                                     -- repeating timer; find next wakeup (may jump multiple repeats)
                                     --
                                     repeat
-                                            wakeup_at= wakeup_at+period
+                                        wakeup_at= wakeup_at+period
                                     until wakeup_at > now
 
                                     t2[1]= wakeup_at
@@ -544,7 +545,7 @@ local configure_timers = function()
                             end
 
                             if wakeup_at and ((not next_wakeup) or (wakeup_at < next_wakeup)) then
-                                next_wakeup= wakeup_at
+                                next_wakeup = wakeup_at
                             end
                         end
                     end -- t2 loop
@@ -675,7 +676,12 @@ local cancel_error
 local genlock = function(linda_, key_, N)
     -- clear existing data and set the limit
     N = N or 1
-    if linda_:set(key_) == cancel_error or linda_:limit(key_, N) == cancel_error then
+    local _status, _err = linda_:set(key_)
+    if _err == cancel_error then
+        return cancel_error
+    end
+    local _status, _err = linda_:limit(key_, N)
+    if _err == cancel_error then
         return cancel_error
     end
 
@@ -723,7 +729,12 @@ end -- genlock
 --
 local genatomic = function(linda_, key_, initial_val_)
     -- clears existing data (also queue). the slot may contain the stored value, and an additional boolean value
-    if linda_:limit(key_, 2) == cancel_error or linda_:set(key_, initial_val_ or 0.0) == cancel_error then
+    local _status, _err = linda_:limit(key_, 2)
+    if _err == cancel_error then
+        return cancel_error
+    end
+    local _status, _err = linda_:set(key_, initial_val_ or 0.0)
+    if _err == cancel_error then
         return cancel_error
     end
 
@@ -734,7 +745,7 @@ local genatomic = function(linda_, key_, initial_val_)
         if _err == cancel_error then
             return cancel_error
         end
-        local val = linda_:get(key_)
+        local _, val = linda_:get(key_)
         if val ~= cancel_error then
             val = val + (diff_ or 1.0)
             -- set() releases the lock by emptying queue
diff --git a/src/linda.cpp b/src/linda.cpp
index 91138c5..316e917 100644
--- a/src/linda.cpp
+++ b/src/linda.cpp
@@ -393,7 +393,7 @@ LUAG_FUNC(linda_dump)
 // #################################################################################################
 
 /*
- * [val [, ...]] = linda_get( linda_ud, key_num|str|bool|lightuserdata [, count = 1])
+ * count, [val [, ...]]|nil,cancel_error = linda:get(key_num|str|bool|lightuserdata [, count = 1])
  *
  * Get one or more values from Linda.
  */
@@ -412,9 +412,10 @@ LUAG_FUNC(linda_get)
             Keeper* const _keeper{ _linda->whichKeeper() };
             _pushed = keeper_call(_keeper->K, KEEPER_API(get), L_, _linda, 2);
         } else { // linda is cancelled
-            // do nothing and return lanes.cancel_error
+            // do nothing and return nil,lanes.cancel_error
+            lua_pushnil(L_);
             kCancelError.pushKey(L_);
-            _pushed.emplace(1);
+            _pushed.emplace(2);
         }
         // an error can be raised if we attempt to read an unregistered function
         return OptionalValue(_pushed, L_, "tried to copy unsupported types");
@@ -425,7 +426,7 @@ LUAG_FUNC(linda_get)
 // #################################################################################################
 
 /*
- * [true] = linda_limit( linda_ud, key_num|str|bool|lightuserdata, [int])
+ * [bool]|nil,cancel_error = linda:limit(key_num|str|bool|lightuserdata, [int])
  *
  * Set limit to 1 Linda keys.
  * Optionally wake threads waiting to write on the linda, in case the limit enables them to do so
@@ -450,15 +451,15 @@ LUAG_FUNC(linda_limit)
         if (_linda->cancelRequest == CancelRequest::None) {
             Keeper* const _keeper{ _linda->whichKeeper() };
             _pushed = keeper_call(_keeper->K, KEEPER_API(limit), L_, _linda, 2);
-            LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 0 || _pushed.value() == 1)); // no error, optional boolean value saying if we should wake blocked writer threads
-            if (_pushed.value() == 1) {
-                LUA_ASSERT(L_, luaG_type(L_, -1) == LuaType::BOOLEAN && lua_toboolean(L_, -1) == 1);
+            LUA_ASSERT(L_, _pushed.has_value() && (_pushed.value() == 1) && luaG_type(L_, -1) == LuaType::BOOLEAN); // no error, boolean value saying if we should wake blocked writer threads
+            if (lua_toboolean(L_, -1)) {
                 _linda->readHappened.notify_all(); // To be done from within the 'K' locking area
             }
         } else { // linda is cancelled
-            // do nothing and return lanes.cancel_error
+            // do nothing and return nil,lanes.cancel_error
+            lua_pushnil(L_);
             kCancelError.pushKey(L_);
-            _pushed.emplace(1);
+            _pushed.emplace(2);
         }
         // propagate pushed boolean if any
         return _pushed.value();
@@ -470,14 +471,13 @@ LUAG_FUNC(linda_limit)
 
 /*
  * 2 modes of operation
- * [val, key]= linda_receive( linda_ud, [timeout_secs_num=nil], key_num|str|bool|lightuserdata [, ...] )
+ * [val, key]= linda:receive([timeout_secs_num=nil], key_num|str|bool|lightuserdata [, ...] )
  * Consumes a single value from the Linda, in any key.
  * Returns: received value (which is consumed from the slot), and the key which had it
 
  * [val1, ... valCOUNT]= linda_receive( linda_ud, [timeout_secs_num=-1], linda.batched, key_num|str|bool|lightuserdata, min_COUNT[, max_COUNT])
  * Consumes between min_COUNT and max_COUNT values from the linda, from a single key.
  * returns the actual consumed values, or nil if there weren't enough values to consume
- *
  */
 LUAG_FUNC(linda_receive)
 {
@@ -763,7 +763,7 @@ LUAG_FUNC(linda_send)
 // #################################################################################################
 
 /*
- * [true|lanes.cancel_error] = linda_set( linda_ud, key_num|str|bool|lightuserdata [, value [, ...]])
+ * [true|nil,lanes.cancel_error] = linda:set(key_num|str|bool|lightuserdata [, value [, ...]])
  *
  * Set one or more value to Linda. Ignores limits.
  *
@@ -773,7 +773,7 @@ LUAG_FUNC(linda_set)
 {
     auto set = [](lua_State* L_) {
         Linda* const _linda{ ToLinda<false>(L_, 1) };
-        bool const _has_value{ lua_gettop(L_) > 2 };
+        bool const _has_data{ lua_gettop(L_) > 2 };
         // make sure the key is of a valid type (throws an error if not the case)
         check_key_types(L_, 2, 2);
 
@@ -782,22 +782,22 @@ LUAG_FUNC(linda_set)
         if (_linda->cancelRequest == CancelRequest::None) {
             _pushed = keeper_call(_keeper->K, KEEPER_API(set), L_, _linda, 2);
             if (_pushed.has_value()) { // no error?
-                LUA_ASSERT(L_, _pushed.value() == 0 || _pushed.value() == 1);
+                LUA_ASSERT(L_, _pushed.value() == 1 && luaG_type(L_, -1) == LuaType::BOOLEAN);
 
-                if (_has_value) {
+                if (_has_data) {
                     // we put some data in the slot, tell readers that they should wake
                     _linda->writeHappened.notify_all(); // To be done from within the 'K' locking area
                 }
-                if (_pushed.value() == 1) {
+                if (lua_toboolean(L_, -1)) {
                     // the key was full, but it is no longer the case, tell writers they should wake
-                    LUA_ASSERT(L_, luaG_type(L_, -1) == LuaType::BOOLEAN && lua_toboolean(L_, -1) == 1);
                     _linda->readHappened.notify_all(); // To be done from within the 'K' locking area
                 }
             }
         } else { // linda is cancelled
-            // do nothing and return lanes.cancel_error
+            // do nothing and return nil,lanes.cancel_error
+            lua_pushnil(L_);
             kCancelError.pushKey(L_);
-            _pushed.emplace(1);
+            _pushed.emplace(2);
         }
 
         // must trigger any error after keeper state has been released
diff --git a/tests/basic.lua b/tests/basic.lua
index bdad44c..ae8ebd9 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -252,21 +252,21 @@ assert(type(linda) == "userdata" and tostring(linda) == "Linda: communications")
 
 WR "test linda:get/set..."
 linda:set("<->", "x", "y", "z")
-local x,y,z = linda:get("<->", 1)
-assert(x == "x" and y == nil and z == nil)
-local x,y,z = linda:get("<->", 2)
-assert(x == "x" and y == "y" and z == nil)
-local x,y,z = linda:get("<->", 3)
-assert(x == "x" and y == "y" and z == "z")
-local x,y,z,w = linda:get("<->", 4)
-assert(x == "x" and y == "y" and z == "z" and w == nil)
+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 x,y,z,w = linda:get("<->", 4)
-assert(x == nil and y == nil and z == nil and w == nil)
+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
@@ -282,7 +282,7 @@ SEND(setmetatable({"should be ignored"},{__lanesconvert=lanes.null})); WR("main
 for i=1,40 do
     WR "."
     SLEEP(0.0001)
-    assert(PEEK() == nil)    -- nothing coming in, yet
+    assert(PEEK() == 0)    -- nothing coming in, yet
 end
 SEND(nil);  WR("\nmain ", "nil sent\n")
 
@@ -306,7 +306,7 @@ 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() == nil)
+assert(PEEK() == 0)
 SEND(4)
 
 local complex_table = RECEIVE(); WR(type(complex_table).." received\n")
diff --git a/tests/cancel.lua b/tests/cancel.lua
index 42ae839..d6c293d 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -38,7 +38,8 @@ if not next(which_tests) or which_tests.genlock then
 
         -- check that cancelled lindas give cancel_error as they should
         linda:cancel()
-        assert( linda:get( "empty") == lanes.cancel_error)
+        local _status, _err = linda:get( "empty")
+        assert(_status == nil and _err == lanes.cancel_error)
         assert( lanes.genlock( linda, "any", 1) == lanes.cancel_error)
         assert( lanes.genatomic( linda, "any") == lanes.cancel_error)
 
@@ -102,14 +103,14 @@ local laneBody = function( mode_, payload_)
                         io.stdout:write( "                      lane busy waiting ... ")
                         for i = 1, payload_ do
                                 -- force a non-jitable call
-                                local a = linda:get( "val")
+                                local _, a = linda:get( "val")
                                 a = a * 2
                         end
                         print( "again?")
                 elseif mode_ == "busy" then
                         -- busy wait mode in pure Lua code
                         io.stdout:write( "                      lane busy waiting ... ")
-                        local a =  linda:get( "val")
+                        local _, a = linda:get( "val")
                         for i = 1, payload_ do
                                 a = a * 2
                                 a = math.sin( a) * math.sin( a) + math.cos( a) * math.cos( a) -- aka 1
diff --git a/tests/errhangtest.lua b/tests/errhangtest.lua
index d0ffcc4..fff0dee 100644
--- a/tests/errhangtest.lua
+++ b/tests/errhangtest.lua
@@ -11,7 +11,8 @@ if true then
         print "#### coro set"
         local coro = coroutine.create(function() end)
         print(pcall(linda.set, linda, 'test', coro))
-        assert(linda:get("test") == nil)
+        local _count, _val = linda:get("test")
+        assert(_count == 0 and _val == nil)
         print "OK"
 end
 
@@ -19,7 +20,8 @@ if true then
         print "\n#### reserved sentinels"
         print(pcall(linda.set, linda, lanes.cancel_error))
         print(pcall(linda.set, linda, linda.batched))
-        assert(linda:get("test") == nil)
+        local _count, _val = linda:get("test")
+        assert(_count == 0 and _val == nil)
         print "OK"
 end
 
@@ -33,7 +35,8 @@ if true then
         print(pcall(linda.set, linda, 'test', true, nil, fun))
         -- read back the contents
         local k,b,n,f = linda:receive(linda.batched, 'test', 3)
-        assert(linda:get("test") == nil)
+        local _count, _val = linda:get("test")
+        assert(_count == 0 and _val == nil)
         -- check they are ok
         print(k, b, n)
         f()
@@ -70,7 +73,8 @@ if true then
         print "\n#### coro send"
         local coro = coroutine.create(function() end)
         print(pcall(linda.send, linda, 'test', coro))
-        assert(linda:get("test") == nil)
+        local _count, _val = linda:get("test")
+        assert(_count == 0 and _val == nil)
         print "OK"
 end
 
diff --git a/tests/keeper.lua b/tests/keeper.lua
index 2f731f0..0e93de2 100644
--- a/tests/keeper.lua
+++ b/tests/keeper.lua
@@ -108,8 +108,9 @@ if true then
 
     local function keeper(linda)
         local mt= {
-            __index= function( _, key )
-                return linda:get( key )
+            __index= function(_, key)
+                local _count, _val = linda:get(key)
+                return _val
             end,
             __newindex= function( _, key, val ) 
                 linda:set( key, val )
diff --git a/tests/linda_perf.lua b/tests/linda_perf.lua
index 4b0c005..96f26f4 100644
--- a/tests/linda_perf.lua
+++ b/tests/linda_perf.lua
@@ -18,22 +18,22 @@ local finalizer = function(err, stk)
 end
 
 -- #################################################################################################
-if false then
+if true then
         do
                 print "############################################ tests get/set"
                 -- linda:get throughput
-                local l = lanes.linda("get/set")
+                local l = lanes.linda("get/set", 1)
                 local batch = {}
                 for i = 1,1000 do
                         table.insert(batch, i)
                 end
                 for _,size in ipairs{1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987 } do
                         l:set("<->", table_unpack(batch))
-                        local count = math.floor(20000000/size)
+                        local count = math.floor(20000/math.sqrt(size))
                         print("START", "get("..size..") " .. count, " times")
                         local t1 = lanes.now_secs()
-                        for i = 1, 2000000/math.sqrt(size) do
-                                l:get("<->", size)
+                        for i = 1, count do
+                                assert (l:get("<->", size) == size)
                         end
                         print("DURATION = " .. lanes.now_secs() - t1 .. "\n")
                 end
diff --git a/tests/timer.lua b/tests/timer.lua
index 4da1a50..ac8b385 100644
--- a/tests/timer.lua
+++ b/tests/timer.lua
@@ -94,8 +94,11 @@ lanes.timer( linda, T2, 0 )
 linda:receive( 0, T1 )    -- clear out; there could be one tick left
 linda:receive( 0, T2 )
 
-assert( linda:get(T1) == nil )
-assert( linda:get(T2) == nil )
+local _count, _val = linda:get(T1)
+assert(_count == 0 and _val == nil)
+
+local _count, _val = linda:get(T2)
+assert(_count == 0 and _val == nil)
 
 PRINT "...making sure no ticks are coming..."
 
diff --git a/tests/tobeclosed.lua b/tests/tobeclosed.lua
index 6e3de4c..5ac8ab7 100644
--- a/tests/tobeclosed.lua
+++ b/tests/tobeclosed.lua
@@ -69,9 +69,10 @@ do
 
     do
 
-        local l_out <close> = l:get("trip")
+        local _, l_out <close> = l:get("trip")
     end
-    assert(l_in:get("closed") == true)
+    local _count, _closed = l_in:get("closed")
+    assert(_count == 1 and _closed == true)
 end
 
 -- #################################################################################################
@@ -100,7 +101,7 @@ do
     local lane_body = function(l_arg_)
         WR "In lane body"
         -- linda obtained through a linda
-        local l_out <close> = l:get("trip")
+        local _count, l_out <close> = l:get("trip")
         -- linda from arguments
         local l_arg <close> = l_arg_
         return true
@@ -108,7 +109,8 @@ do
 
     local close_handler_f = function(linda_, err_)
         WR("f closing ", linda_)
-        linda_:set("closed", (linda_:get("closed") or 0) + 1)
+        local _count, _closed = linda_:get("closed")
+        linda_:set("closed", (_closed or 0) + 1)
     end
     local l_in = lanes.linda("voyager", close_handler_f)
     l:set("trip", l_in)
@@ -116,7 +118,8 @@ do
     do
     lanes.gen("*", lane_body)(l_in):join()
     end
-    assert(l_in:get("closed") == 2)
+    local _count, _closed = l_in:get("closed")
+    assert(_count == 1 and _closed == 2)
 end
 
 WR "================================================================================================"