diff options
Diffstat (limited to 'test/test_timeout.rb')
| -rw-r--r-- | test/test_timeout.rb | 303 |
1 files changed, 295 insertions, 8 deletions
diff --git a/test/test_timeout.rb b/test/test_timeout.rb index 2d3dd16245..b11fc92aea 100644 --- a/test/test_timeout.rb +++ b/test/test_timeout.rb @@ -4,12 +4,62 @@ require 'timeout' class TestTimeout < Test::Unit::TestCase + private def kill_timeout_thread + thread = Timeout.const_get(:State).instance.instance_variable_get(:@timeout_thread) + if thread + thread.kill + thread.join + end + end + + def test_public_methods + assert_equal [:timeout], Timeout.private_instance_methods(false) + assert_equal [], Timeout.public_instance_methods(false) + + assert_equal [:timeout], Timeout.singleton_class.public_instance_methods(false) + + assert_equal [:Error, :ExitException, :VERSION], Timeout.constants.sort + end + + def test_work_is_done_in_same_thread_as_caller + assert_equal Thread.current, Timeout.timeout(10){ Thread.current } + end + + def test_work_is_done_in_same_fiber_as_caller + require 'fiber' # needed for ruby 3.0 and lower + assert_equal Fiber.current, Timeout.timeout(10){ Fiber.current } + end + def test_non_timing_out_code_is_successful assert_nothing_raised do assert_equal :ok, Timeout.timeout(1){ :ok } end end + def test_allows_zero_seconds + assert_nothing_raised do + assert_equal :ok, Timeout.timeout(0){:ok} + end + end + + def test_allows_nil_seconds + assert_nothing_raised do + assert_equal :ok, Timeout.timeout(nil){:ok} + end + end + + def test_raise_for_neg_second + assert_raise(ArgumentError) do + Timeout.timeout(-1) { sleep(0.01) } + end + end + + def test_raise_for_string_argument + assert_raise(NoMethodError) do + Timeout.timeout("1") { sleep(0.01) } + end + end + def test_included c = Class.new do include Timeout @@ -41,25 +91,87 @@ class TestTimeout < Test::Unit::TestCase end end + def test_nested_timeout + a = nil + assert_raise(Timeout::Error) do + Timeout.timeout(0.1) { + Timeout.timeout(30) { + nil while true + } + a = 1 + } + end + assert_nil a + end + + class MyNewErrorOuter < StandardError; end + class MyNewErrorInner < StandardError; end + + # DOES NOT fail with + # - raise new(message) if exc.equal?(e) + # + raise new(message) if exc.class == e.class + def test_nested_timeout_error_identity + begin + Timeout.timeout(0.1, MyNewErrorOuter) { + Timeout.timeout(30, MyNewErrorInner) { + nil while true + } + } + rescue => e + assert e.class == MyNewErrorOuter + end + end + + # DOES fail with + # - raise new(message) if exc.equal?(e) + # + raise new(message) if exc.class == e.class + def test_nested_timeout_which_error_bubbles_up + raised_exception = nil + begin + Timeout.timeout(0.1) { + Timeout.timeout(1) { + raise Timeout::ExitException.new("inner message") + } + } + rescue Exception => e + raised_exception = e + end + + assert_equal 'inner message', raised_exception.message + end + def test_cannot_convert_into_time_interval bug3168 = '[ruby-dev:41010]' def (n = Object.new).zero?; false; end - assert_raise(TypeError, bug3168) {Timeout.timeout(n) { sleep 0.1 }} + assert_raise(ArgumentError, bug3168) {Timeout.timeout(n) { sleep 0.1 }} end - def test_skip_rescue - bug8730 = '[Bug #8730]' + def test_skip_rescue_standarderror e = nil - assert_raise_with_message(Timeout::Error, /execution expired/, bug8730) do + assert_raise_with_message(Timeout::Error, /execution expired/) do Timeout.timeout 0.01 do begin sleep 3 - rescue Exception => e + rescue => e flunk "should not see any exception but saw #{e.inspect}" end end end - assert_nil(e, bug8730) + end + + def test_raises_exception_internally + e = nil + assert_raise_with_message(Timeout::Error, /execution expired/) do + Timeout.timeout 0.01 do + begin + sleep 3 + rescue Exception => exc + e = exc + raise + end + end + end + assert_equal Timeout::ExitException, e.class end def test_rescue_exit @@ -123,16 +235,17 @@ class TestTimeout < Test::Unit::TestCase end end - def test_handle_interrupt + def test_handle_interrupt_with_exception_class bug11344 = '[ruby-dev:49179] [Bug #11344]' ok = false assert_raise(Timeout::Error) { Thread.handle_interrupt(Timeout::Error => :never) { - Timeout.timeout(0.01) { + Timeout.timeout(0.01, Timeout::Error) { sleep 0.2 ok = true Thread.handle_interrupt(Timeout::Error => :on_blocking) { sleep 0.2 + raise "unreachable" } } } @@ -140,6 +253,112 @@ class TestTimeout < Test::Unit::TestCase assert(ok, bug11344) end + def test_handle_interrupt + bug11344 = '[ruby-dev:49179] [Bug #11344]' + ok = false + assert_raise(Timeout::Error) { + Thread.handle_interrupt(Timeout::ExitException => :never) { + Timeout.timeout(0.01) { + sleep 0.2 + ok = true + Thread.handle_interrupt(Timeout::ExitException => :on_blocking) { + sleep 0.2 + raise "unreachable" + } + } + } + } + assert(ok, bug11344) + end + + def test_handle_interrupt_with_interrupt_mask_inheritance + issue = 'https://github.com/ruby/timeout/issues/41' + + [ + -> {}, # not blocking so no opportunity to interrupt + -> { sleep 5 } + ].each_with_index do |body, idx| + # We need to create a new Timeout thread + kill_timeout_thread + + # Create the timeout thread under a handle_interrupt(:never) + # due to the interrupt mask being inherited + Thread.handle_interrupt(Object => :never) { + assert_equal :ok, Timeout.timeout(1) { :ok } + } + + # Ensure a simple timeout works and the interrupt mask was not inherited + assert_raise(Timeout::Error) { + Timeout.timeout(0.001) { sleep 1 } + } + + r = [] + # This raises Timeout::ExitException and not Timeout::Error for the non-blocking body + # because of the handle_interrupt(:never) which delays raising Timeout::ExitException + # on the main thread until getting outside of that handle_interrupt(:never) call. + # For this reason we document handle_interrupt(Timeout::ExitException) should not be used. + exc = idx == 0 ? Timeout::ExitException : Timeout::Error + assert_raise(exc) { + Thread.handle_interrupt(Timeout::ExitException => :never) { + Timeout.timeout(0.1) do + sleep 0.2 + r << :sleep_before_done + Thread.handle_interrupt(Timeout::ExitException => :on_blocking) { + r << :body + body.call + } + ensure + sleep 0.2 + r << :ensure_sleep_done + end + } + } + assert_equal([:sleep_before_done, :body, :ensure_sleep_done], r, issue) + end + end + + # Same as above but with an exception class + def test_handle_interrupt_with_interrupt_mask_inheritance_with_exception_class + issue = 'https://github.com/ruby/timeout/issues/41' + + [ + -> {}, # not blocking so no opportunity to interrupt + -> { sleep 5 } + ].each do |body| + # We need to create a new Timeout thread + kill_timeout_thread + + # Create the timeout thread under a handle_interrupt(:never) + # due to the interrupt mask being inherited + Thread.handle_interrupt(Object => :never) { + assert_equal :ok, Timeout.timeout(1) { :ok } + } + + # Ensure a simple timeout works and the interrupt mask was not inherited + assert_raise(Timeout::Error) { + Timeout.timeout(0.001) { sleep 1 } + } + + r = [] + assert_raise(Timeout::Error) { + Thread.handle_interrupt(Timeout::Error => :never) { + Timeout.timeout(0.1, Timeout::Error) do + sleep 0.2 + r << :sleep_before_done + Thread.handle_interrupt(Timeout::Error => :on_blocking) { + r << :body + body.call + } + ensure + sleep 0.2 + r << :ensure_sleep_done + end + } + } + assert_equal([:sleep_before_done, :body, :ensure_sleep_done], r, issue) + end + end + def test_fork omit 'fork not supported' unless Process.respond_to?(:fork) r, w = IO.pipe @@ -172,4 +391,72 @@ class TestTimeout < Test::Unit::TestCase end; end + # https://github.com/ruby/timeout/issues/24 + def test_handling_enclosed_threadgroup + assert_separately(%w[-rtimeout], <<-'end;') + Thread.new { + t = Thread.current + group = ThreadGroup.new + group.add(t) + group.enclose + + assert_equal 42, Timeout.timeout(1) { 42 } + }.join + end; + end + + def test_ractor + assert_separately(%w[-rtimeout -W0], <<-'end;') + r = Ractor.new do + Timeout.timeout(1) { 42 } + end.value + + assert_equal 42, r + + r = Ractor.new do + begin + Timeout.timeout(0.1) { sleep } + rescue Timeout::Error + :ok + end + end.value + + assert_equal :ok, r + end; + end if defined?(::Ractor) && RUBY_VERSION >= '4.0' + + def test_timeout_in_trap_handler + # https://github.com/ruby/timeout/issues/17 + + # Test as if this was the first timeout usage + kill_timeout_thread + + rd, wr = IO.pipe + + signal = :TERM + + original_handler = trap(signal) do + begin + Timeout.timeout(0.1) do + sleep 1 + end + rescue Timeout::Error + wr.write "OK" + wr.close + else + wr.write "did not raise" + ensure + wr.close + end + end + + begin + Process.kill signal, Process.pid + + assert_equal "OK", rd.read + rd.close + ensure + trap(signal, original_handler) + end + end end |