1 files changed, 117 insertions, 45 deletions

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")
 
 --####################################################################