Bring all interesting fixes from the C++ implementation back into the C implementation

1 files changed, 123 insertions, 89 deletions

diff --git a/tests/cancel.lua b/tests/cancel.lua
index 0d9d143..4e57184 100644
--- a/tests/cancel.lua
+++ b/tests/cancel.lua
@@ -1,36 +1,47 @@
-local lanes = require "lanes" .configure{ with_timers = false}
-
-local linda = lanes.linda()
+local which_tests, remaining_tests = {}, {}
+for k,v in ipairs{...} do
+        print("got arg:", type(v), tostring(v))
+        which_tests[v] = true
+        remaining_tests[v] = true
+end
 
 --####################################################################
-print "\n\n####################################################################\nbegin genlock & genatomic cancel test\n"
-
--- get a lock and a atomic operator
-local lock = lanes.genlock( linda, "lock", 1)
-local atomic = lanes.genatomic( linda, "atomic")
-
--- check that cancelled lindas give cancel_error as they should
-linda:cancel()
-assert( linda:get( "empty") == lanes.cancel_error)
-assert( lanes.genlock( linda, "any", 1) == lanes.cancel_error)
-assert( lanes.genatomic( linda, "any") == lanes.cancel_error)
-
--- check that lock and atomic functions return cancel_error if the linda was cancelled
-assert( lock( 1) == lanes.cancel_error)
-assert( lock( -1) == lanes.cancel_error)
-assert( atomic( 1) == lanes.cancel_error)
-
--- reset the linda so that the other tests work
-linda:cancel( "none")
-linda:limit( "lock", -1)
-linda:set( "lock")
-linda:limit( "atomic", -1)
-linda:set( "atomic")
 
+local lanes = require "lanes" .configure{ with_timers = false}
+
+local linda = lanes.linda()
 -- a numeric value to read
 linda:set( "val", 33.0)
 
-print "test OK"
+--####################################################################
+if not next(which_tests) or which_tests.genlock then
+        remaining_tests.genlock = nil
+        print "\n\n####################################################################\nbegin genlock & genatomic cancel test\n"
+
+        -- get a lock and a atomic operator
+        local lock = lanes.genlock( linda, "lock", 1)
+        local atomic = lanes.genatomic( linda, "atomic")
+
+        -- check that cancelled lindas give cancel_error as they should
+        linda:cancel()
+        assert( linda:get( "empty") == lanes.cancel_error)
+        assert( lanes.genlock( linda, "any", 1) == lanes.cancel_error)
+        assert( lanes.genatomic( linda, "any") == lanes.cancel_error)
+
+        -- check that lock and atomic functions return cancel_error if the linda was cancelled
+        assert( lock( 1) == lanes.cancel_error)
+        assert( lock( -1) == lanes.cancel_error)
+        assert( atomic( 1) == lanes.cancel_error)
+
+        -- reset the linda so that the other tests work
+        linda:cancel( "none")
+        linda:limit( "lock", -1)
+        linda:set( "lock")
+        linda:limit( "atomic", -1)
+        linda:set( "atomic")
+
+        print "test OK"
+end
 --####################################################################
 
 local waitCancellation = function( h, expected_status)
@@ -119,92 +130,115 @@ 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")
+if not next(which_tests) or which_tests.linda then
+        remaining_tests.linda = nil
+        print "\n\n####################################################################\nbegin linda cancel test\n"
+        h = lanes.gen( "*", laneBody)( "receive", nil) -- start an infinite wait on the linda
 
--- wait until cancellation is effective.
-waitCancellation( h, "done")
+        print "wait 1s"
+        linda:receive( 1, "yeah")
 
--- reset the linda so that the other tests work
-linda:cancel( "none")
+        -- linda cancel: linda:receive() returns cancel_error immediately
+        print "cancelling"
+        linda:cancel( "both")
 
-print "\n\n####################################################################\nbegin soft cancel test\n"
-h = lanes.gen( "*", protectedBody)( "receive") -- start an infinite wait on the linda
+        -- wait until cancellation is effective.
+        waitCancellation( h, "done")
 
-print "wait 1s"
-linda:receive( 1, "yeah")
+        -- reset the linda so that the other tests work
+        linda:cancel( "none")
+end
 
--- 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")
+if not next(which_tests) or which_tests.soft then
+        remaining_tests.soft = nil
+        print "\n\n####################################################################\nbegin soft cancel test\n"
+        h = lanes.gen( "*", protectedBody)( "receive") -- start an infinite wait on the linda
 
--- soft cancel, this time awakens waiting linda operations, which returns cancel_error immediately, no timeout.
-h:cancel( "soft", true)
+        print "wait 1s"
+        linda:receive( 1, "yeah")
 
--- wait until cancellation is effective. the lane will interrupt its loop and print the exit message
-waitCancellation( h, "done")
+        -- 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")
 
--- do return end
+        -- soft cancel, this time awakens waiting linda operations, which returns cancel_error immediately, no timeout.
+        print "cancelling"
+        h:cancel( "soft", true)
 
-print "\n\n####################################################################\nbegin hook cancel test\n"
-h = lanes.gen( "*", protectedBody)( "get", 300000)
-print "wait 2s"
-linda:receive( 2, "yeah")
+        -- wait until cancellation is effective. the lane will interrupt its loop and print the exit message
+        waitCancellation( h, "done")
+end
 
--- count hook cancel after 3 instructions
-h:cancel( "count", 300, 5.0)
+if not next(which_tests) or which_tests.hook then
+        remaining_tests.hook = nil
+        print "\n\n####################################################################\nbegin hook cancel test\n"
+        h = lanes.gen( "*", protectedBody)( "get", 300000)
+        print "wait 2s"
+        linda:receive( 2, "yeah")
 
--- wait until cancellation is effective. the lane will interrupt its loop and print the exit message
-waitCancellation( h, "cancelled")
+        -- count hook cancel after some instruction instructions
+        print "cancelling"
+        h:cancel( "line", 300, 5.0)
 
-print "\n\n####################################################################\nbegin hard cancel test\n"
-h = lanes.gen( "*", protectedBody)( "receive", nil) -- infinite timeout
+        -- wait until cancellation is effective. the lane will interrupt its loop and print the exit message
+        waitCancellation( h, "cancelled")
+end
 
--- wait 2s before cancelling the lane
-print "wait 2s"
-linda:receive( 2, "yeah")
+if not next(which_tests) or which_tests.hard then
+        remaining_tests.hard = nil
+        print "\n\n####################################################################\nbegin hard cancel test\n"
+        h = lanes.gen( "*", protectedBody)( "receive", nil) -- infinite timeout
 
--- hard cancel: the lane will be interrupted from inside its current linda:receive() and won't return from it
-h:cancel()
+        -- wait 2s before cancelling the lane
+        print "wait 2s"
+        linda:receive( 2, "yeah")
 
--- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
-waitCancellation( h, "cancelled")
+        -- hard cancel: the lane will be interrupted from inside its current linda:receive() and won't return from it
+        print "cancelling"
+        h:cancel()
 
-print "\n\n####################################################################\nbegin hard cancel test with unprotected lane body\n"
-h = lanes.gen( "*", laneBody)( "receive", nil)
+        -- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
+        waitCancellation( h, "cancelled")
+end
 
--- wait 2s before cancelling the lane
-print "wait 2s"
-linda:receive( 2, "yeah")
+if not next(which_tests) or which_tests.hard_unprotected then
+        remaining_tests.hard_unprotected = nil
+        print "\n\n####################################################################\nbegin hard cancel test with unprotected lane body\n"
+        h = lanes.gen( "*", laneBody)( "receive", nil)
 
--- hard cancel: the lane will be interrupted from inside its current linda:receive() and won't return from it
-h:cancel()
+        -- wait 2s before cancelling the lane
+        print "wait 2s"
+        linda:receive( 2, "yeah")
 
--- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
-waitCancellation( h, "cancelled")
+        -- hard cancel: the lane will be interrupted from inside its current linda:receive() and won't return from it
+        print "cancelling"
+        h:cancel()
 
-print "\n\n####################################################################\nbegin kill cancel test\n"
-h = lanes.gen( "*", laneBody)( "busy", 50000000) -- start a pure Lua busy loop lane
+        -- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
+        waitCancellation( h, "cancelled")
+end
 
--- wait 1/3s before cancelling the lane, before the busy loop can finish
-print "wait 0.3s"
-linda:receive( 0.3, "yeah")
+if not next(which_tests) or which_tests.kill then
+        remaining_tests.kill = nil
+        print "\n\n####################################################################\nbegin kill cancel test\n"
+        h = lanes.gen( "*", laneBody)( "busy", 50000000) -- start a pure Lua busy loop lane
 
--- hard cancel with kill: the lane thread will be forcefully terminated
-h:cancel( true)
+        -- wait 1/3s before cancelling the lane, before the busy loop can finish
+        print "wait 0.3s"
+        linda:receive( 0.3, "yeah")
 
--- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
-waitCancellation( h, "killed")
+        -- hard cancel with kill: the lane thread will be forcefully terminated. kill timeout is pthread-specific
+        print "cancelling"
+        h:cancel( true, 1.0)
 
+        -- wait until cancellation is effective. the lane will be stopped by the linda operation throwing an error
+        waitCancellation( h, "killed")
+end
 --####################################################################
 
-print "\ndone"
+local unknown_test, val = next(remaining_tests)
+assert(not unknown_test, tostring(unknown_test) .. " test is unknown")
 
+print "\nTHE END"