4 files changed, 139 insertions, 67 deletions

diff --git a/tests/basic.lua b/tests/basic.lua
index 020fe78..6fcfd53 100644
--- a/tests/basic.lua
+++ b/tests/basic.lua
@@ -114,7 +114,7 @@ collectgarbage()
 
 PRINT( "\n\n", "---=== Tasking (cancelling) ===---", "\n\n")
 
-local task_launch2= lanes_gen( "", { cancelstep=100, globals={hey=true}, gc_cb = gc_cb}, task )
+local task_launch2= lanes_gen( "", { globals={hey=true}, gc_cb = gc_cb}, task )
 
 local N=999999999
 local lane9= task_launch2(1,N,1)   -- huuuuuuge...
@@ -138,7 +138,7 @@ if st=="done" then
 end
 assert( st=="running" )
 
-lane9:cancel()
+lane9:cancel( "count", 100) -- 0 timeout, 100 instructions count hook
 
 local t0= os.time()
 while os.time()-t0 < 5 do
@@ -166,7 +166,7 @@ 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()
+wait_send_lane:cancel() -- hard cancel, 0 timeout
 repeat until wait_send_lane.status == "cancelled"
 print "wait_send_lane is cancelled"
 --################################################]]
@@ -179,7 +179,7 @@ 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()
+wait_receive_lane:cancel() -- hard cancel, 0 timeout
 repeat until wait_receive_lane.status == "cancelled"
 print "wait_receive_lane is cancelled"
 --################################################]]
@@ -192,7 +192,7 @@ 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()
+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/tests/cancel.lua b/tests/cancel.lua
index 6429487..0d9d143 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -27,9 +27,29 @@ linda:set( "lock")
 linda:limit( "atomic", -1)
 linda:set( "atomic")
 
+-- a numeric value to read
+linda:set( "val", 33.0)
+
+print "test OK"
 --####################################################################
 
-local laneBody = function( timeout_)
+local waitCancellation = function( h, expected_status)
+        local l = lanes.linda()
+        if expected_status ~= "running" then
+                repeat
+                        -- print( "lane status:", h.status)
+                        l:receive( 0.1, "yeah") -- wait a bit
+                until h.status ~= "running"
+        end
+        print( "lane status:", h.status)
+        assert( h.status == expected_status, h.status .. " ~= " .. expected_status)
+        print "test OK"
+end
+
+local laneBody = function( mode_, payload_)
+        local name = "laneBody("..tostring(mode_)..","..tostring(payload_)..")"
+        set_debug_threadname( name)
+
         set_finalizer( function( err, stk)
                 if err == lanes.cancel_error then
                         -- note that we don't get the cancel_error when running wrapped inside a protected call if it doesn't rethrow it
@@ -41,14 +61,39 @@ local laneBody = function( timeout_)
                 end
         end)
 
-        print( "                        entering lane with " .. tostring( timeout_) .. " timeout")
+        print( "                        entering " , name)
         repeat
-                -- block-wait to be hard-cancelled
-                print "                 lane calling receive()"
-                local key, val = linda:receive( timeout_, "boob")
-                print( "                        receive() -> ", lanes.cancel_error == key and "cancel_error" or tostring( key), tostring( val))
+                if mode_ == "receive" then
+                        -- linda mode
+                        io.stdout:write( "                      lane calling receive() ... ")
+                        local key, val = linda:receive( payload_, "boob")
+                        print( lanes.cancel_error == key and "cancel_error" or tostring( key), tostring( val))
+                        if key == lanes.cancel_error then
+                                break -- gracefully abort loop
+                        end
+                elseif mode_ == "get" then
+                        -- busy wait mode getting data from the linda
+                        io.stdout:write( "                      lane busy waiting ... ")
+                        for i = 1, payload_ do
+                                -- force a non-jitable call
+                                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")
+                        for i = 1, payload_ do
+                                a = a * 2
+                                a = math.sin( a) * math.sin( a) + math.cos( a) * math.cos( a) -- aka 1
+                        end
+                        print( "again?")
+                else
+                        error "no mode: raise an error"
+                end
         until cancel_test() -- soft cancel self test
-        print "                 shutting down after breaking out of loop"
+        print "                 lane shutting down after breaking out of loop"
 end
 
 local protectedBody = function( ...)
@@ -61,7 +106,8 @@ local protectedBody = function( ...)
         -- Lua 5.1 doesn't pass additional xpcall arguments to the called function
         -- therefore we need to create a closure that has no arguments but pulls everything from its upvalue
         local params = {...}
-        local paramLessClosure = function() laneBody(table.unpack( params)) end
+        local unpack = table.unpack or unpack -- unpack for 5.1, table.unpack for 5.2+
+        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)) .. "'")
@@ -71,66 +117,92 @@ local protectedBody = function( ...)
 end
 
 --####################################################################
+--####################################################################
+
+print "\n\n####################################################################\nbegin linda cancel test\n"
+h = lanes.gen( "*", laneBody)( "receive", nil) -- start an infinite wait on the linda
+
+print "wait 1s"
+linda:receive( 1, "yeah")
+
+-- linda cancel: linda:receive() returns cancel_error immediately
+linda:cancel( "both")
+
+-- wait until cancellation is effective.
+waitCancellation( h, "done")
+
+-- reset the linda so that the other tests work
+linda:cancel( "none")
 
-print "####################################################################\nbegin soft cancel test\n"
-h = lanes.gen("*", protectedBody)( 0.666)
-print "wait 3s"
-linda:receive( 3, "yeah")
+print "\n\n####################################################################\nbegin soft cancel test\n"
+h = lanes.gen( "*", protectedBody)( "receive") -- start an infinite wait on the linda
 
--- soft cancel
-print "soft cancel with awakening"
-h:cancel( -1, true)
+print "wait 1s"
+linda:receive( 1, "yeah")
 
--- wait 10s: the lane will interrupt its loop and print the exit message
+-- soft cancel, no awakening of waiting linda operations, should timeout
+local a, b = h:cancel( "soft", 1, false)
+-- cancellation should fail as the lane is still waiting on its linda
+assert( a == false and b == "timeout")
+waitCancellation( h, "waiting")
+
+-- soft cancel, this time awakens waiting linda operations, which returns cancel_error immediately, no timeout.
+h:cancel( "soft", true)
+
+-- wait until cancellation is effective. the lane will interrupt its loop and print the exit message
+waitCancellation( h, "done")
+
+-- do return end
+
+print "\n\n####################################################################\nbegin hook cancel test\n"
+h = lanes.gen( "*", protectedBody)( "get", 300000)
 print "wait 2s"
 linda:receive( 2, "yeah")
 
---####################################################################
+-- count hook cancel after 3 instructions
+h:cancel( "count", 300, 5.0)
+
+-- wait until cancellation is effective. the lane will interrupt its loop and print the exit message
+waitCancellation( h, "cancelled")
 
 print "\n\n####################################################################\nbegin hard cancel test\n"
-h = lanes.gen("*", protectedBody)()
+h = lanes.gen( "*", protectedBody)( "receive", nil) -- infinite timeout
 
--- wait 3s before cancelling the lane
-print "wait 3s"
-linda:receive( 3, "yeah")
+-- wait 2s before cancelling the lane
+print "wait 2s"
+linda:receive( 2, "yeah")
 
--- hard cancel and wait 10s: the lane will be interrupted from inside its current linda:receive() and won't return from it
-print "hard cancel (always awakens)"
+-- hard cancel: the lane will be interrupted from inside its current linda:receive() and won't return from it
 h:cancel()
 
-print "wait 5s"
-linda:receive( 5, "yeah")
-
---####################################################################
+-- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
+waitCancellation( h, "cancelled")
 
 print "\n\n####################################################################\nbegin hard cancel test with unprotected lane body\n"
-h = lanes.gen("*", laneBody)()
+h = lanes.gen( "*", laneBody)( "receive", nil)
 
--- wait 3s before cancelling the lane
-print "wait 3s"
-linda:receive( 3, "yeah")
+-- wait 2s before cancelling the lane
+print "wait 2s"
+linda:receive( 2, "yeah")
 
 -- hard cancel: the lane will be interrupted from inside its current linda:receive() and won't return from it
-print "hard cancel (always awakens)"
 h:cancel()
 
-print "wait 5s"
-linda:receive( 5, "yeah")
+-- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
+waitCancellation( h, "cancelled")
 
---####################################################################
-print "\n\n####################################################################\nbegin linda cancel test\n"
-h = lanes.gen("*", laneBody)()
+print "\n\n####################################################################\nbegin kill cancel test\n"
+h = lanes.gen( "*", laneBody)( "busy", 50000000) -- start a pure Lua busy loop lane
 
--- wait 3s before cancelling the lane
-print "wait 3s"
-linda:receive( 3, "yeah")
+-- wait 1/3s before cancelling the lane, before the busy loop can finish
+print "wait 0.3s"
+linda:receive( 0.3, "yeah")
 
--- linda cancel: the lane will be interrupted from inside its current linda:receive() and won't return from it
-print "linda cancel (always awakens the lane)"
-linda:cancel( "both")
+-- hard cancel with kill: the lane thread will be forcefully terminated
+h:cancel( true)
 
-print "wait 5s"
-linda:receive( 5, "yeah")
+-- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
+waitCancellation( h, "killed")
 
 --####################################################################
 
diff --git a/tests/fifo.lua b/tests/fifo.lua
index 47db4c9..bef60d5 100644
--- a/tests/fifo.lua
+++ b/tests/fifo.lua
@@ -6,11 +6,11 @@
 
 local lanes = require "lanes".configure{shutdown_timeout=3,with_timers=true}
 
-local linda= lanes.linda( "atom")
-local atomic_inc= lanes.genatomic( linda, "FIFO_n" )
+local linda = lanes.linda( "atom")
+local atomic_inc= lanes.genatomic( linda, "FIFO_n")
 
-assert( atomic_inc()==1 )
-assert( atomic_inc()==2 )
+assert( atomic_inc()==1)
+assert( atomic_inc()==2)
 
 local function FIFO()
     local my_channel= "FIFO"..atomic_inc()
@@ -18,32 +18,32 @@ local function FIFO()
     return {
         -- Giving explicit 'nil' timeout allows numbers to be used as 'my_channel'
         --
-        send= function(self, ...)
-                                        linda:send( nil, my_channel, ... )
-                                end,
+        send = function(self, ...)
+            linda:send( nil, my_channel, ...)
+        end,
         receive = function(self, timeout)
-                                        return linda:receive( timeout, my_channel )
-                                end
+            return linda:receive( timeout, my_channel)
+        end
     }
 end
 
-local A= FIFO()
-local B= FIFO()
+local A = FIFO()
+local B = FIFO()
 
 print "Sending to A.."
-A:send( 1,2,3,4,5 )
+A:send( 1,2,3,4,5)
 
 print "Sending to B.."
-B:send( 'a','b','c' )
+B:send( 'a','b','c')
 
 print "Reading A.."
-print( A:receive( 1.0 ) )
+print( A:receive( 1.0))
 
 print "Reading B.."
-print( B:receive( 2.0 ) )
+print( B:receive( 2.0))
 
 -- Note: A and B can be passed between threads, or used as upvalues
 --       by multiple threads (other parts will be copied but the 'linda'
 --       handle is shared userdata and will thus point to the single place)
-lanes.timer_lane:cancel()
+lanes.timer_lane:cancel() -- hard cancel, 0 timeout
 lanes.timer_lane:join()
\ No newline at end of file
diff --git a/tests/timer.lua b/tests/timer.lua
index 805d85c..ec23cee 100644
--- a/tests/timer.lua
+++ b/tests/timer.lua
@@ -100,5 +100,5 @@ PRINT "...making sure no ticks are coming..."
 local k,v= linda:receive( 10, T1,T2 )    -- should not get any
 assert(v==nil)
 
-lanes.timer_lane:cancel()
+lanes.timer_lane:cancel() -- hard cancel, 0 timeout
 print (lanes.timer_lane[1], lanes.timer_lane[2])
\ No newline at end of file