diff options
Diffstat (limited to 'test/ruby/test_thread.rb')
| -rw-r--r-- | test/ruby/test_thread.rb | 1294 |
1 files changed, 939 insertions, 355 deletions
diff --git a/test/ruby/test_thread.rb b/test/ruby/test_thread.rb index 145e021790..41cee124be 100644 --- a/test/ruby/test_thread.rb +++ b/test/ruby/test_thread.rb @@ -1,13 +1,14 @@ +# -*- coding: us-ascii -*- +# frozen_string_literal: false require 'test/unit' -require 'thread' -require_relative 'envutil' +require "rbconfig/sizeof" +require "timeout" class TestThread < Test::Unit::TestCase class Thread < ::Thread Threads = [] def self.new(*) th = super - th.abort_on_exception = true Threads << th th end @@ -27,6 +28,30 @@ class TestThread < Test::Unit::TestCase end end + def test_inspect + line = __LINE__+1 + th = Module.new {break module_eval("class C\u{30b9 30ec 30c3 30c9} < Thread; self; end")}.start{} + s = th.inspect + assert_include(s, "::C\u{30b9 30ec 30c3 30c9}:") + assert_include(s, " #{__FILE__}:#{line} ") + assert_equal(s, th.to_s) + ensure + th.join + end + + def test_inspect_with_fiber + inspect1 = inspect2 = nil + + Thread.new{ + inspect1 = Thread.current.inspect + Fiber.new{ + inspect2 = Thread.current.inspect + }.resume + }.join + + assert_equal inspect1, inspect2, '[Bug #13689]' + end + def test_main_thread_variable_in_enumerator assert_equal Thread.main, Thread.current @@ -64,14 +89,14 @@ class TestThread < Test::Unit::TestCase end def test_thread_variable? - refute Thread.new { Thread.current.thread_variable?("foo") }.join.value + Thread.new { assert_not_send([Thread.current, :thread_variable?, "foo"]) }.value t = Thread.new { Thread.current.thread_variable_set("foo", "bar") }.join - assert t.thread_variable?("foo") - assert t.thread_variable?(:foo) - refute t.thread_variable?(:bar) + assert_send([t, :thread_variable?, "foo"]) + assert_send([t, :thread_variable?, :foo]) + assert_not_send([t, :thread_variable?, :bar]) end def test_thread_variable_strings_and_symbols_are_the_same_key @@ -83,233 +108,72 @@ class TestThread < Test::Unit::TestCase def test_thread_variable_frozen t = Thread.new { }.join t.freeze - assert_raises(RuntimeError) do + assert_raise(FrozenError) do t.thread_variable_set(:foo, "bar") end end - def test_thread_variable_security - t = Thread.new { sleep } - - assert_raises(SecurityError) do - Thread.new { $SAFE = 4; t.thread_variable_get(:foo) }.join - end - - assert_raises(SecurityError) do - Thread.new { $SAFE = 4; t.thread_variable_set(:foo, :baz) }.join - end - end - def test_mutex_synchronize - m = Mutex.new + m = Thread::Mutex.new r = 0 - max = 10 - (1..max).map{ + num_threads = 10 + loop=100 + (1..num_threads).map{ Thread.new{ - i=0 - while i<max*max - i+=1 + loop.times{ m.synchronize{ - r += 1 + tmp = r + # empty and waste loop for making thread preemption + 100.times { + } + r = tmp + 1 } - end + } } }.each{|e| e.join } - assert_equal(max * max * max, r) - end - - def test_condvar - mutex = Mutex.new - condvar = ConditionVariable.new - result = [] - mutex.synchronize do - t = Thread.new do - mutex.synchronize do - result << 1 - condvar.signal - end - end - - result << 0 - condvar.wait(mutex) - result << 2 - t.join - end - assert_equal([0, 1, 2], result) - end - - def test_condvar_wait_exception_handling - # Calling wait in the only thread running should raise a ThreadError of - # 'stopping only thread' - mutex = Mutex.new - condvar = ConditionVariable.new - - locked = false - thread = Thread.new do - Thread.current.abort_on_exception = false - mutex.synchronize do - begin - condvar.wait(mutex) - rescue Exception - locked = mutex.locked? - raise - end - end - end - - until thread.stop? - sleep(0.1) - end - - thread.raise Interrupt, "interrupt a dead condition variable" - assert_raise(Interrupt) { thread.value } - assert(locked) - end - - def test_condvar_wait_and_broadcast - nr_threads = 3 - threads = Array.new - mutex = Mutex.new - condvar = ConditionVariable.new - result = [] - - nr_threads.times do |i| - threads[i] = Thread.new do - mutex.synchronize do - result << "C1" - condvar.wait mutex - result << "C2" - end - end - end - sleep 0.1 - mutex.synchronize do - result << "P1" - condvar.broadcast - result << "P2" - end - nr_threads.times do |i| - threads[i].join - end - - assert_equal ["C1", "C1", "C1", "P1", "P2", "C2", "C2", "C2"], result - end - -# Hmm.. don't we have a way of catch fatal exception? -# -# def test_cv_wait_deadlock -# mutex = Mutex.new -# cv = ConditionVariable.new -# -# assert_raise(fatal) { -# mutex.lock -# cv.wait mutex -# mutex.unlock -# } -# end - - def test_condvar_wait_deadlock_2 - nr_threads = 3 - threads = Array.new - mutex = Mutex.new - condvar = ConditionVariable.new - - nr_threads.times do |i| - if (i != 0) - mutex.unlock - end - threads[i] = Thread.new do - mutex.synchronize do - condvar.wait mutex - end - end - mutex.lock - end - - assert_raise(Timeout::Error) do - Timeout.timeout(0.1) { condvar.wait mutex } - end - mutex.unlock - threads.each(&:kill) - threads.each(&:join) - end - - def test_condvar_timed_wait - mutex = Mutex.new - condvar = ConditionVariable.new - timeout = 0.3 - locked = false - - t0 = Time.now - mutex.synchronize do - begin - condvar.wait(mutex, timeout) - ensure - locked = mutex.locked? - end - end - t1 = Time.now - t = t1-t0 - - assert_operator(timeout*0.9, :<, t) - assert(locked) - end - - def test_condvar_nolock - mutex = Mutex.new - condvar = ConditionVariable.new - - assert_raise(ThreadError) {condvar.wait(mutex)} - end - - def test_condvar_nolock_2 - mutex = Mutex.new - condvar = ConditionVariable.new - - Thread.new do - assert_raise(ThreadError) {condvar.wait(mutex)} - end.join + assert_equal(num_threads*loop, r) end - def test_condvar_nolock_3 - mutex = Mutex.new - condvar = ConditionVariable.new - - Thread.new do - assert_raise(ThreadError) {condvar.wait(mutex, 0.1)} - end.join + def test_mutex_synchronize_yields_no_block_params + bug8097 = '[ruby-core:53424] [Bug #8097]' + assert_empty(Thread::Mutex.new.synchronize {|*params| break params}, bug8097) end def test_local_barrier dir = File.dirname(__FILE__) lbtest = File.join(dir, "lbtest.rb") $:.unshift File.join(File.dirname(dir), 'ruby') - require 'envutil' $:.shift 3.times { `#{EnvUtil.rubybin} #{lbtest}` - assert(!$?.coredump?, '[ruby-dev:30653]') + assert_not_predicate($?, :coredump?, '[ruby-dev:30653]') } end def test_priority c1 = c2 = 0 - t1 = Thread.new { loop { c1 += 1 } } + run = true + t1 = Thread.new { c1 += 1 while run } t1.priority = 3 - t2 = Thread.new { loop { c2 += 1 } } + t2 = Thread.new { c2 += 1 while run } t2.priority = -3 assert_equal(3, t1.priority) assert_equal(-3, t2.priority) sleep 0.5 5.times do + assert_not_predicate(t1, :stop?) + assert_not_predicate(t2, :stop?) break if c1 > c2 sleep 0.1 end + run = false t1.kill t2.kill assert_operator(c1, :>, c2, "[ruby-dev:33124]") # not guaranteed + t1.join + t2.join end def test_new @@ -328,34 +192,85 @@ class TestThread < Test::Unit::TestCase end ensure - t1.kill if t1 - t2.kill if t2 + t1&.kill&.join + t2&.kill&.join + end + + def test_new_symbol_proc + bug = '[ruby-core:80147] [Bug #13313]' + assert_ruby_status([], "#{<<-"begin;"}\n#{<<-'end;'}", bug) + begin; + exit("1" == Thread.start(1, &:to_s).value) + end; end def test_join t = Thread.new { sleep } - assert_nil(t.join(0.5)) + assert_nil(t.join(0.05)) ensure - t.kill if t + t&.kill&.join end def test_join2 - t1 = Thread.new { sleep(1.5) } + ok = false + t1 = Thread.new { ok = true; sleep } + Thread.pass until ok + Thread.pass until t1.stop? t2 = Thread.new do - t1.join(1) + Thread.pass while ok + t1.join(0.01) end t3 = Thread.new do - sleep 0.5 + ok = false t1.join end assert_nil(t2.value) + t1.wakeup assert_equal(t1, t3.value) ensure - t1.kill if t1 - t2.kill if t2 - t3.kill if t3 + t1&.kill&.join + t2&.kill&.join + t3&.kill&.join + end + + def test_join_argument_conversion + t = Thread.new {} + assert_raise(TypeError) {t.join(:foo)} + + limit = Struct.new(:to_f, :count).new(0.05) + assert_same(t, t.join(limit)) + end + + { 'FIXNUM_MAX' => RbConfig::LIMITS['FIXNUM_MAX'], + 'UINT64_MAX' => RbConfig::LIMITS['UINT64_MAX'], + 'INFINITY' => Float::INFINITY + }.each do |name, limit| + define_method("test_join_limit_#{name}") do + t = Thread.new {} + assert_same t, t.join(limit), "limit=#{limit.inspect}" + end + end + + { 'minus_1' => -1, + 'minus_0_1' => -0.1, + 'FIXNUM_MIN' => RbConfig::LIMITS['FIXNUM_MIN'], + 'INT64_MIN' => RbConfig::LIMITS['INT64_MIN'], + 'minus_INFINITY' => -Float::INFINITY + }.each do |name, limit| + define_method("test_join_limit_negative_#{name}") do + t = Thread.new { sleep } + begin + assert_nothing_raised(Timeout::Error) do + Timeout.timeout(30) do + assert_nil t.join(limit), "limit=#{limit.inspect}" + end + end + ensure + t.kill + end + end end def test_kill_main_thread @@ -401,15 +316,15 @@ class TestThread < Test::Unit::TestCase Thread.stop s += 1 end - sleep 0.5 + Thread.pass until t.stop? + sleep 1 if defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled? # t.stop? behaves unexpectedly with --jit-wait assert_equal(1, s) t.wakeup - sleep 0.5 + Thread.pass while t.alive? assert_equal(2, s) assert_raise(ThreadError) { t.wakeup } - ensure - t.kill if t + t&.kill&.join end def test_stop @@ -427,7 +342,7 @@ class TestThread < Test::Unit::TestCase assert_in_out_err([], <<-INPUT) do |r, e| t1 = Thread.new { sleep } Thread.pass - t2 = Thread.new { loop { } } + t2 = Thread.new { loop { Thread.pass } } Thread.new { }.join p [Thread.current, t1, t2].map{|t| t.object_id }.sort p Thread.list.map{|t| t.object_id }.sort @@ -448,8 +363,11 @@ class TestThread < Test::Unit::TestCase assert_in_out_err([], <<-INPUT, %w(false 1), []) p Thread.abort_on_exception begin - Thread.new { raise } - sleep 0.5 + t = Thread.new { + Thread.current.report_on_exception = false + raise + } + Thread.pass until t.stop? p 1 rescue p 2 @@ -460,7 +378,10 @@ class TestThread < Test::Unit::TestCase Thread.abort_on_exception = true p Thread.abort_on_exception begin - Thread.new { raise } + Thread.new { + Thread.current.report_on_exception = false + raise + } sleep 0.5 p 1 rescue @@ -471,8 +392,8 @@ class TestThread < Test::Unit::TestCase assert_in_out_err(%w(--disable-gems -d), <<-INPUT, %w(false 2), %r".+") p Thread.abort_on_exception begin - Thread.new { raise } - sleep 0.5 + t = Thread.new { raise } + Thread.pass until t.stop? p 1 rescue p 2 @@ -482,9 +403,15 @@ class TestThread < Test::Unit::TestCase assert_in_out_err([], <<-INPUT, %w(false true 2), []) p Thread.abort_on_exception begin - t = Thread.new { sleep 0.5; raise } + ok = false + t = Thread.new { + Thread.current.report_on_exception = false + Thread.pass until ok + raise + } t.abort_on_exception = true p t.abort_on_exception + ok = 1 sleep 1 p 1 rescue @@ -493,49 +420,142 @@ class TestThread < Test::Unit::TestCase INPUT end + def test_report_on_exception + assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}") + begin; + q1 = Thread::Queue.new + q2 = Thread::Queue.new + + assert_equal(true, Thread.report_on_exception, + "global flag is true by default") + assert_equal(true, Thread.current.report_on_exception, + "the main thread has report_on_exception=true") + + Thread.report_on_exception = true + Thread.current.report_on_exception = false + assert_equal(true, + Thread.start {Thread.current.report_on_exception}.value, + "should not inherit from the parent thread but from the global flag") + + assert_warn("", "exception should be ignored silently when false") { + th = Thread.start { + Thread.current.report_on_exception = false + q1.push(Thread.current.report_on_exception) + raise "report 1" + } + assert_equal(false, q1.pop) + Thread.pass while th.alive? + assert_raise(RuntimeError) { th.join } + } + + assert_warn(/report 2/, "exception should be reported when true") { + th = Thread.start { + q1.push(Thread.current.report_on_exception = true) + raise "report 2" + } + assert_equal(true, q1.pop) + Thread.pass while th.alive? + assert_raise(RuntimeError) { th.join } + } + + assert_warn("", "the global flag should not affect already started threads") { + Thread.report_on_exception = false + th = Thread.start { + q2.pop + q1.push(Thread.current.report_on_exception) + raise "report 3" + } + q2.push(Thread.report_on_exception = true) + assert_equal(false, q1.pop) + Thread.pass while th.alive? + assert_raise(RuntimeError) { th.join } + } + + assert_warn(/report 4/, "should defaults to the global flag at the start") { + Thread.report_on_exception = true + th = Thread.start { + q1.push(Thread.current.report_on_exception) + raise "report 4" + } + assert_equal(true, q1.pop) + Thread.pass while th.alive? + assert_raise(RuntimeError) { th.join } + } + + assert_warn(/report 5/, "should first report and then raise with report_on_exception + abort_on_exception") { + th = Thread.start { + Thread.current.report_on_exception = true + Thread.current.abort_on_exception = true + q2.pop + raise "report 5" + } + assert_raise_with_message(RuntimeError, "report 5") { + q2.push(true) + Thread.pass while th.alive? + } + assert_raise(RuntimeError) { th.join } + } + end; + end + + def test_ignore_deadlock + if /mswin|mingw/ =~ RUBY_PLATFORM + skip "can't trap a signal from another process on Windows" + end + assert_in_out_err([], <<-INPUT, %w(false :sig), [], :signal=>:INT, timeout: 1, timeout_error: nil) + p Thread.ignore_deadlock + q = Thread::Queue.new + trap(:INT){q.push :sig} + Thread.ignore_deadlock = true + p q.pop + INPUT + end + def test_status_and_stop_p - a = ::Thread.new { raise("die now") } + a = ::Thread.new { + Thread.current.report_on_exception = false + raise("die now") + } b = Thread.new { Thread.stop } c = Thread.new { Thread.exit } - d = Thread.new { sleep } e = Thread.current - sleep 0.5 + Thread.pass while a.alive? or !b.stop? or c.alive? assert_equal(nil, a.status) - assert(a.stop?) + assert_predicate(a, :stop?) assert_equal("sleep", b.status) - assert(b.stop?) + assert_predicate(b, :stop?) assert_equal(false, c.status) assert_match(/^#<TestThread::Thread:.* dead>$/, c.inspect) - assert(c.stop?) + assert_predicate(c, :stop?) - d.kill - # to avoid thread switching... - ds1 = d.status - ds2 = d.stop? es1 = e.status es2 = e.stop? - assert_equal(["aborting", false], [ds1, ds2]) - assert_equal(["run", false], [es1, es2]) - + assert_raise(RuntimeError) { a.join } ensure - a.kill if a - b.kill if b - c.kill if c - d.kill if d + b&.kill&.join + c&.join end - def test_safe_level - t = Thread.new { $SAFE = 3; sleep } - sleep 0.5 - assert_equal(0, Thread.current.safe_level) - assert_equal(3, t.safe_level) - + def test_switch_while_busy_loop + bug1402 = "[ruby-dev:38319] [Bug #1402]" + flag = true + th = Thread.current + waiter = Thread.start { + sleep 0.1 + flag = false + sleep 1 + th.raise(bug1402) + } + assert_nothing_raised(RuntimeError, bug1402) do + nil while flag + end + assert(!flag, bug1402) ensure - t.kill if t + waiter&.kill&.join end def test_thread_local @@ -552,43 +572,77 @@ class TestThread < Test::Unit::TestCase assert_equal(false, t.key?(:qux)) assert_equal(false, t.key?("qux")) - assert_equal([:foo, :bar, :baz], t.keys) + assert_equal([:foo, :bar, :baz].sort, t.keys.sort) ensure - t.kill if t + t&.kill&.join end - def test_thread_local_security + def test_thread_local_fetch t = Thread.new { sleep } - assert_raise(SecurityError) do - Thread.new { $SAFE = 4; t[:foo] }.join - end + assert_equal(false, t.key?(:foo)) - assert_raise(SecurityError) do - Thread.new { $SAFE = 4; t[:foo] = :baz }.join - end + t["foo"] = "foo" + t["bar"] = "bar" + t["baz"] = "baz" + + x = nil + assert_equal("foo", t.fetch(:foo, 0)) + assert_equal("foo", t.fetch(:foo) {x = true}) + assert_nil(x) + assert_equal("foo", t.fetch("foo", 0)) + assert_equal("foo", t.fetch("foo") {x = true}) + assert_nil(x) + + x = nil + assert_equal(0, t.fetch(:qux, 0)) + assert_equal(1, t.fetch(:qux) {x = 1}) + assert_equal(1, x) + assert_equal(2, t.fetch("qux", 2)) + assert_equal(3, t.fetch("qux") {x = 3}) + assert_equal(3, x) + + e = assert_raise(KeyError) {t.fetch(:qux)} + assert_equal(:qux, e.key) + assert_equal(t, e.receiver) + ensure + t&.kill&.join + end - assert_raise(RuntimeError) do - Thread.new do - Thread.current[:foo] = :bar - Thread.current.freeze + def test_thread_local_security + Thread.new do + Thread.current[:foo] = :bar + Thread.current.freeze + assert_raise(FrozenError) do Thread.current[:foo] = :baz - end.join - end + end + end.join + end + + def test_thread_local_dynamic_symbol + bug10667 = '[ruby-core:67185] [Bug #10667]' + t = Thread.new {}.join + key_str = "foo#{rand}" + key_sym = key_str.to_sym + t.thread_variable_set(key_str, "bar") + assert_equal("bar", t.thread_variable_get(key_str), "#{bug10667}: string key") + assert_equal("bar", t.thread_variable_get(key_sym), "#{bug10667}: symbol key") end def test_select_wait - assert_nil(IO.select(nil, nil, nil, 1)) + assert_nil(IO.select(nil, nil, nil, 0.001)) t = Thread.new do IO.select(nil, nil, nil, nil) end - sleep 0.5 - t.kill + Thread.pass until t.stop? + assert_predicate(t, :alive?) + ensure + t&.kill&.join end def test_mutex_deadlock - m = Mutex.new + m = Thread::Mutex.new m.synchronize do assert_raise(ThreadError) do m.synchronize do @@ -599,30 +653,30 @@ class TestThread < Test::Unit::TestCase end def test_mutex_interrupt - m = Mutex.new + m = Thread::Mutex.new m.lock t = Thread.new do m.lock :foo end - sleep 0.5 + Thread.pass until t.stop? t.kill assert_nil(t.value) end def test_mutex_illegal_unlock - m = Mutex.new + m = Thread::Mutex.new m.lock - assert_raise(ThreadError) do - Thread.new do + Thread.new do + assert_raise(ThreadError) do m.unlock - end.join - end + end + end.join end def test_mutex_fifo_like_lock - m1 = Mutex.new - m2 = Mutex.new + m1 = Thread::Mutex.new + m2 = Thread::Mutex.new m1.lock m2.lock m1.unlock @@ -630,7 +684,7 @@ class TestThread < Test::Unit::TestCase assert_equal(false, m1.locked?) assert_equal(false, m2.locked?) - m3 = Mutex.new + m3 = Thread::Mutex.new m1.lock m2.lock m3.lock @@ -643,7 +697,7 @@ class TestThread < Test::Unit::TestCase end def test_mutex_trylock - m = Mutex.new + m = Thread::Mutex.new assert_equal(true, m.try_lock) assert_equal(false, m.try_lock, '[ruby-core:20943]') @@ -664,7 +718,7 @@ class TestThread < Test::Unit::TestCase raise "recursive_outer should short circuit intermediate calls" end assert_nothing_raised {arr.hash} - assert(obj[:visited]) + assert(obj[:visited], "obj.hash was not called") end def test_thread_instance_variable @@ -677,24 +731,22 @@ class TestThread < Test::Unit::TestCase end def test_no_valid_cfp - skip 'with win32ole, cannot run this testcase because win32ole redefines Thread#intialize' if defined?(WIN32OLE) + skip 'with win32ole, cannot run this testcase because win32ole redefines Thread#initialize' if defined?(WIN32OLE) bug5083 = '[ruby-dev:44208]' - assert_equal([], Thread.new(&Module.method(:nesting)).value) - error = assert_raise(RuntimeError) do - Thread.new(:to_s, &Module.method(:undef_method)).join - end - assert_equal("Can't call on top of Fiber or Thread", error.message, bug5083) + assert_equal([], Thread.new(&Module.method(:nesting)).value, bug5083) + assert_instance_of(Thread, Thread.new(:to_s, &Class.new.method(:undef_method)).join, bug5083) end - def make_control_interrupt_test_thread1 flag + def make_handle_interrupt_test_thread1 flag r = [] - ready_p = false + ready_q = Thread::Queue.new + done_q = Thread::Queue.new th = Thread.new{ begin - Thread.control_interrupt(RuntimeError => flag){ + Thread.handle_interrupt(RuntimeError => flag){ begin - ready_p = true - sleep 0.5 + ready_q << true + done_q.pop rescue r << :c1 end @@ -703,9 +755,10 @@ class TestThread < Test::Unit::TestCase r << :c2 end } - Thread.pass until ready_p + ready_q.pop th.raise begin + done_q << true th.join rescue r << :c3 @@ -713,32 +766,141 @@ class TestThread < Test::Unit::TestCase r end - def test_control_interrupt + def test_handle_interrupt [[:never, :c2], [:immediate, :c1], [:on_blocking, :c1]].each{|(flag, c)| - assert_equal([flag, c], [flag] + make_control_interrupt_test_thread1(flag)) + assert_equal([flag, c], [flag] + make_handle_interrupt_test_thread1(flag)) } # TODO: complex cases are needed. end - def test_check_interrupt - q = Queue.new - Thread.control_interrupt(RuntimeError => :never){ + def test_handle_interrupt_invalid_argument + assert_raise(ArgumentError) { + Thread.handle_interrupt(RuntimeError => :immediate) # no block + } + assert_raise(ArgumentError) { + Thread.handle_interrupt(RuntimeError => :xyzzy) {} + } + assert_raise(TypeError) { + Thread.handle_interrupt([]) {} # array + } + end + + def for_test_handle_interrupt_with_return + Thread.handle_interrupt(Object => :never){ + Thread.current.raise RuntimeError.new("have to be rescured") + return + } + rescue + end + + def test_handle_interrupt_with_return + assert_nothing_raised do + for_test_handle_interrupt_with_return + _dummy_for_check_ints=nil + end + end + + def test_handle_interrupt_with_break + assert_nothing_raised do + begin + Thread.handle_interrupt(Object => :never){ + Thread.current.raise RuntimeError.new("have to be rescured") + break + } + rescue + end + _dummy_for_check_ints=nil + end + end + + def test_handle_interrupt_blocking + r = nil + q = Thread::Queue.new + e = Class.new(Exception) + th_s = Thread.current + th = Thread.start { + assert_raise(RuntimeError) { + Thread.handle_interrupt(Object => :on_blocking){ + begin + q.pop + Thread.current.raise RuntimeError, "will raise in sleep" + r = :ok + sleep + ensure + th_s.raise e, "raise from ensure", $@ + end + } + } + } + assert_raise(e) {q << true; th.join} + assert_equal(:ok, r) + end + + def test_handle_interrupt_and_io + assert_in_out_err([], <<-INPUT, %w(ok), []) + th_waiting = true + q = Thread::Queue.new + + t = Thread.new { + Thread.current.report_on_exception = false + Thread.handle_interrupt(RuntimeError => :on_blocking) { + q << true + nil while th_waiting + # async interrupt should be raised _before_ writing puts arguments + puts "ng" + } + } + + q.pop + t.raise RuntimeError + th_waiting = false + t.join rescue nil + puts "ok" + INPUT + end + + def test_handle_interrupt_and_p + assert_in_out_err([], <<-INPUT, %w(:ok :ok), []) + th_waiting = false + + t = Thread.new { + Thread.current.report_on_exception = false + Thread.handle_interrupt(RuntimeError => :on_blocking) { + th_waiting = true + nil while th_waiting + # p shouldn't provide interruptible point + p :ok + p :ok + } + } + + Thread.pass until th_waiting + t.raise RuntimeError + th_waiting = false + t.join rescue nil + INPUT + end + + def test_handle_interrupted? + q = Thread::Queue.new + Thread.handle_interrupt(RuntimeError => :never){ + done = false th = Thread.new{ q.push :e begin begin - sleep 0.5 - rescue => e + Thread.pass until done + rescue q.push :ng1 end begin - Thread.check_interrupt - rescue => e + Thread.handle_interrupt(Object => :immediate){} if Thread.pending_interrupt? + rescue RuntimeError q.push :ok end - rescue => e + rescue q.push :ng2 ensure q.push :ng3 @@ -746,13 +908,14 @@ class TestThread < Test::Unit::TestCase } q.pop th.raise + done = true th.join assert_equal(:ok, q.pop) } end def test_thread_timer_and_ensure - assert_normal_exit(<<_eom, 'r36492', timeout: 3) + assert_normal_exit(<<_eom, 'r36492', timeout: 10) flag = false t = Thread.new do begin @@ -770,63 +933,26 @@ class TestThread < Test::Unit::TestCase t.join _eom end -end -class TestThreadGroup < Test::Unit::TestCase - def test_thread_init - thgrp = ThreadGroup.new - Thread.new{ - thgrp.add(Thread.current) - assert_equal(thgrp, Thread.new{sleep 1}.group) - }.join - end + def test_uninitialized + c = Class.new(Thread) {def initialize; end} + assert_raise(ThreadError) { c.new.start } - def test_frozen_thgroup - thgrp = ThreadGroup.new + bug11959 = '[ruby-core:72732] [Bug #11959]' - t = Thread.new{1} - Thread.new{ - thgrp.add(Thread.current) - thgrp.freeze - assert_raise(ThreadError) do - Thread.new{1}.join - end - assert_raise(ThreadError) do - thgrp.add(t) - end - assert_raise(ThreadError) do - ThreadGroup.new.add Thread.current - end - }.join - t.join - end + c = Class.new(Thread) {def initialize; exit; end} + assert_raise(ThreadError, bug11959) { c.new } - def test_enclosed_thgroup - thgrp = ThreadGroup.new - assert_equal(false, thgrp.enclosed?) + c = Class.new(Thread) {def initialize; raise; end} + assert_raise(ThreadError, bug11959) { c.new } - t = Thread.new{1} - Thread.new{ - thgrp.add(Thread.current) - thgrp.enclose - assert_equal(true, thgrp.enclosed?) - assert_nothing_raised do - Thread.new{1}.join + c = Class.new(Thread) { + def initialize + pending = pending_interrupt? + super {pending} end - assert_raise(ThreadError) do - thgrp.add t - end - assert_raise(ThreadError) do - ThreadGroup.new.add Thread.current - end - }.join - t.join - end - - def test_uninitialized - c = Class.new(Thread) - c.class_eval { def initialize; end } - assert_raise(ThreadError) { c.new.start } + } + assert_equal(false, c.new.value, bug11959) end def test_backtrace @@ -841,26 +967,484 @@ class TestThreadGroup < Test::Unit::TestCase def test_thread_timer_and_interrupt bug5757 = '[ruby-dev:44985]' - t0 = Time.now.to_f pid = nil - cmd = 'r,=IO.pipe; Thread.start {Thread.pass until Thread.main.stop?; puts; STDOUT.flush}; r.read' + cmd = 'Signal.trap(:INT, "DEFAULT"); pipe=IO.pipe; Thread.start {Thread.pass until Thread.main.stop?; puts; STDOUT.flush}; pipe[0].read' opt = {} opt[:new_pgroup] = true if /mswin|mingw/ =~ RUBY_PLATFORM - s, _err = EnvUtil.invoke_ruby(['-e', cmd], "", true, true, opt) do |in_p, out_p, err_p, cpid| + s, t, _err = EnvUtil.invoke_ruby(['-e', cmd], "", true, true, **opt) do |in_p, out_p, err_p, cpid| + assert IO.select([out_p], nil, nil, 10), 'subprocess not ready' out_p.gets pid = cpid + t0 = Time.now.to_f Process.kill(:SIGINT, pid) - Process.wait(pid) - [$?, err_p.read] + begin + Timeout.timeout(10) { Process.wait(pid) } + rescue Timeout::Error + EnvUtil.terminate(pid) + raise + end + t1 = Time.now.to_f + [$?, t1 - t0, err_p.read] end - t1 = Time.now.to_f assert_equal(pid, s.pid, bug5757) - unless /mswin|mingw/ =~ RUBY_PLATFORM - # status of signal is not supported on Windows - assert_equal([false, true, false, Signal.list["INT"]], - [s.exited?, s.signaled?, s.stopped?, s.termsig], - "[s.exited?, s.signaled?, s.stopped?, s.termsig]") + assert_equal([false, true, false, Signal.list["INT"]], + [s.exited?, s.signaled?, s.stopped?, s.termsig], + "[s.exited?, s.signaled?, s.stopped?, s.termsig]") + assert_include(0..2, t, bug5757) + end + + def test_thread_join_in_trap + assert_separately [], <<-'EOS' + Signal.trap(:INT, "DEFAULT") + t0 = Thread.current + assert_nothing_raised{ + t = Thread.new {Thread.pass until t0.stop?; Process.kill(:INT, $$)} + + Signal.trap :INT do + t.join + end + + t.join + } + EOS + end + + def test_thread_value_in_trap + assert_separately [], <<-'EOS' + Signal.trap(:INT, "DEFAULT") + t0 = Thread.current + t = Thread.new {Thread.pass until t0.stop?; Process.kill(:INT, $$); :normal_end} + + Signal.trap :INT do + t.value + end + assert_equal(:normal_end, t.value) + EOS + end + + def test_thread_join_current + assert_raise(ThreadError) do + Thread.current.join + end + end + + def test_thread_join_main_thread + Thread.new(Thread.current) {|t| + assert_raise(ThreadError) do + t.join + end + }.join + end + + def test_main_thread_status_at_exit + assert_in_out_err([], <<-'INPUT', ["false false aborting"], []) +q = Thread::Queue.new +Thread.new(Thread.current) {|mth| + begin + q.push nil + mth.run + Thread.pass until mth.stop? + p :mth_stopped # don't run if killed by rb_thread_terminate_all + ensure + puts "#{mth.alive?} #{mth.status} #{Thread.current.status}" + end +} +q.pop + INPUT + end + + def test_thread_status_in_trap + # when running trap handler, Thread#status must show "run" + # Even though interrupted from sleeping function + assert_in_out_err([], <<-INPUT, %w(sleep run), []) + Signal.trap(:INT) { + puts Thread.current.status + exit + } + t = Thread.current + + Thread.new(Thread.current) {|mth| + Thread.pass until t.stop? + puts mth.status + Process.kill(:INT, $$) + } + sleep 0.1 + INPUT + end + + # Bug #7450 + def test_thread_status_raise_after_kill + ary = [] + + t = Thread.new { + assert_raise(RuntimeError) do + begin + ary << Thread.current.status + sleep #1 + ensure + begin + ary << Thread.current.status + sleep #2 + ensure + ary << Thread.current.status + end + end + end + } + + Thread.pass until ary.size >= 1 + Thread.pass until t.stop? + t.kill # wake up sleep #1 + Thread.pass until ary.size >= 2 + Thread.pass until t.stop? + t.raise "wakeup" # wake up sleep #2 + Thread.pass while t.alive? + assert_equal(ary, ["run", "aborting", "aborting"]) + t.join + end + + def test_mutex_owned + mutex = Thread::Mutex.new + + assert_equal(mutex.owned?, false) + mutex.synchronize { + # Now, I have the mutex + assert_equal(mutex.owned?, true) + } + assert_equal(mutex.owned?, false) + end + + def test_mutex_owned2 + begin + mutex = Thread::Mutex.new + th = Thread.new { + # lock forever + mutex.lock + sleep + } + + # acquired by another thread. + Thread.pass until mutex.locked? + assert_equal(mutex.owned?, false) + ensure + th&.kill&.join end - assert_in_delta(t1 - t0, 1, 1, bug5757) + end + + def test_mutex_unlock_on_trap + assert_in_out_err([], <<-INPUT, %w(locked unlocked false), []) + m = Thread::Mutex.new + + trapped = false + Signal.trap("INT") { |signo| + m.unlock + trapped = true + puts "unlocked" + } + + m.lock + puts "locked" + Process.kill("INT", $$) + Thread.pass until trapped + puts m.locked? + INPUT + end + + def invoke_rec script, vm_stack_size, machine_stack_size, use_length = true + env = {} + env['RUBY_THREAD_VM_STACK_SIZE'] = vm_stack_size.to_s if vm_stack_size + env['RUBY_THREAD_MACHINE_STACK_SIZE'] = machine_stack_size.to_s if machine_stack_size + out, err, status = EnvUtil.invoke_ruby([env, '-e', script], '', true, true) + assert_not_predicate(status, :signaled?, err) + + use_length ? out.length : out + end + + def test_stack_size + h_default = eval(invoke_rec('p RubyVM::DEFAULT_PARAMS', nil, nil, false)) + h_0 = eval(invoke_rec('p RubyVM::DEFAULT_PARAMS', 0, 0, false)) + h_large = eval(invoke_rec('p RubyVM::DEFAULT_PARAMS', 1024 * 1024 * 10, 1024 * 1024 * 10, false)) + + assert_operator(h_default[:thread_vm_stack_size], :>, h_0[:thread_vm_stack_size], + "0 thread_vm_stack_size") + assert_operator(h_default[:thread_vm_stack_size], :<, h_large[:thread_vm_stack_size], + "large thread_vm_stack_size") + assert_operator(h_default[:thread_machine_stack_size], :>=, h_0[:thread_machine_stack_size], + "0 thread_machine_stack_size") + assert_operator(h_default[:thread_machine_stack_size], :<=, h_large[:thread_machine_stack_size], + "large thread_machine_stack_size") + assert_equal("ok", invoke_rec('print :ok', 1024 * 1024 * 100, nil, false)) + end + + def test_vm_machine_stack_size + script = 'def rec; print "."; STDOUT.flush; rec; end; rec' + size_default = invoke_rec script, nil, nil + assert_operator(size_default, :>, 0, "default size") + size_0 = invoke_rec script, 0, nil + assert_operator(size_default, :>, size_0, "0 size") + size_large = invoke_rec script, 1024 * 1024 * 10, nil + assert_operator(size_default, :<, size_large, "large size") + end + + def test_machine_stack_size + # check machine stack size + # Note that machine stack size may not change size (depend on OSs) + script = 'def rec; print "."; STDOUT.flush; 1.times{1.times{1.times{rec}}}; end; Thread.new{rec}.join' + vm_stack_size = 1024 * 1024 + size_default = invoke_rec script, vm_stack_size, nil + size_0 = invoke_rec script, vm_stack_size, 0 + assert_operator(size_default, :>=, size_0, "0 size") + size_large = invoke_rec script, vm_stack_size, 1024 * 1024 * 10 + assert_operator(size_default, :<=, size_large, "large size") + end unless /mswin|mingw/ =~ RUBY_PLATFORM + + def test_blocking_mutex_unlocked_on_fork + bug8433 = '[ruby-core:55102] [Bug #8433]' + + mutex = Thread::Mutex.new + mutex.lock + + th = Thread.new do + mutex.synchronize do + sleep + end + end + + Thread.pass until th.stop? + mutex.unlock + + pid = Process.fork do + exit(mutex.locked?) + end + + th.kill + + pid, status = Process.waitpid2(pid) + assert_equal(false, status.success?, bug8433) + end if Process.respond_to?(:fork) + + def test_fork_in_thread + bug9751 = '[ruby-core:62070] [Bug #9751]' + f = nil + th = Thread.start do + unless f = IO.popen("-") + STDERR.reopen(STDOUT) + exit + end + Process.wait2(f.pid) + end + unless th.join(EnvUtil.apply_timeout_scale(30)) + Process.kill(:QUIT, f.pid) + Process.kill(:KILL, f.pid) unless th.join(EnvUtil.apply_timeout_scale(1)) + end + _, status = th.value + output = f.read + f.close + assert_not_predicate(status, :signaled?, FailDesc[status, bug9751, output]) + assert_predicate(status, :success?, bug9751) + end if Process.respond_to?(:fork) + + def test_fork_value + bug18902 = "[Bug #18902]" + th = Thread.start { sleep 2 } + begin + pid = fork do + th.value + end + _, status = Process.wait2(pid) + assert_predicate(status, :success?, bug18902) + ensure + th.kill + end + end if Process.respond_to?(:fork) + + def test_fork_while_locked + m = Thread::Mutex.new + thrs = [] + 3.times do |i| + thrs << Thread.new { m.synchronize { Process.waitpid2(fork{})[1] } } + end + thrs.each do |t| + assert_predicate t.value, :success?, '[ruby-core:85940] [Bug #14578]' + end + end if Process.respond_to?(:fork) + + def test_fork_while_parent_locked + skip 'needs fork' unless Process.respond_to?(:fork) + m = Thread::Mutex.new + nr = 1 + thrs = [] + m.synchronize do + thrs = nr.times.map { Thread.new { m.synchronize {} } } + thrs.each { Thread.pass } + pid = fork do + m.locked? or exit!(2) + thrs = nr.times.map { Thread.new { m.synchronize {} } } + m.unlock + thrs.each { |t| t.join(1) == t or exit!(1) } + exit!(0) + end + _, st = Process.waitpid2(pid) + assert_predicate st, :success?, '[ruby-core:90312] [Bug #15383]' + end + thrs.each { |t| assert_same t, t.join(1) } + end + + def test_fork_while_mutex_locked_by_forker + skip 'needs fork' unless Process.respond_to?(:fork) + m = Thread::Mutex.new + m.synchronize do + pid = fork do + exit!(2) unless m.locked? + m.unlock rescue exit!(3) + m.synchronize {} rescue exit!(4) + exit!(0) + end + _, st = Timeout.timeout(30) { Process.waitpid2(pid) } + assert_predicate st, :success?, '[ruby-core:90595] [Bug #15430]' + end + end + + def test_subclass_no_initialize + t = Module.new do + break eval("class C\u{30b9 30ec 30c3 30c9} < Thread; self; end") + end + t.class_eval do + def initialize + end + end + assert_raise_with_message(ThreadError, /C\u{30b9 30ec 30c3 30c9}/) do + t.new {} + end + end + + def test_thread_name + t = Thread.start {sleep} + sleep 0.001 until t.stop? + assert_nil t.name + s = t.inspect + t.name = 'foo' + assert_equal 'foo', t.name + t.name = nil + assert_nil t.name + assert_equal s, t.inspect + ensure + t.kill + t.join + end + + def test_thread_invalid_name + bug11756 = '[ruby-core:71774] [Bug #11756]' + t = Thread.start {} + assert_raise(ArgumentError, bug11756) {t.name = "foo\0bar"} + assert_raise(ArgumentError, bug11756) {t.name = "foo".encode(Encoding::UTF_32BE)} + ensure + t.kill + t.join + end + + def test_thread_invalid_object + bug11756 = '[ruby-core:71774] [Bug #11756]' + t = Thread.start {} + assert_raise(TypeError, bug11756) {t.name = []} + ensure + t.kill + t.join + end + + def test_thread_setname_in_initialize + bug12290 = '[ruby-core:74963] [Bug #12290]' + c = Class.new(Thread) {def initialize() self.name = "foo"; super; end} + assert_equal("foo", c.new {Thread.current.name}.value, bug12290) + end + + def test_thread_native_thread_id + skip "don't support native_thread_id" unless Thread.method_defined?(:native_thread_id) + assert_instance_of Integer, Thread.main.native_thread_id + + th1 = Thread.start{sleep} + + # newly created thread which doesn't run yet returns nil or integer + assert_include [NilClass, Integer], th1.native_thread_id.class + + Thread.pass until th1.stop? + + # After a thread starts (and execute `sleep`), it returns native_thread_id + assert_instance_of Integer, th1.native_thread_id + + th1.wakeup + Thread.pass while th1.alive? + + # dead thread returns nil + assert_nil th1.native_thread_id + end + + def test_thread_interrupt_for_killed_thread + opts = { timeout: 5, timeout_error: nil } + + # prevent SIGABRT from slow shutdown with MJIT + opts[:reprieve] = 3 if defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled? + + assert_normal_exit(<<-_end, '[Bug #8996]', **opts) + Thread.report_on_exception = false + trap(:TERM){exit} + while true + t = Thread.new{sleep 0} + t.raise Interrupt + Thread.pass # allow t to finish + end + _end + end + + def test_signal_at_join + if /mswin|mingw/ =~ RUBY_PLATFORM + skip "can't trap a signal from another process on Windows" + # opt = {new_pgroup: true} + end + assert_separately([], "#{<<~"{#"}\n#{<<~'};'}", timeout: 120) + {# + n = 1000 + sig = :INT + trap(sig) {} + IO.popen([EnvUtil.rubybin, "-e", "#{<<~"{#1"}\n#{<<~'};#1'}"], "r+") do |f| + tpid = #{$$} + sig = :#{sig} + {#1 + STDOUT.sync = true + while gets + puts + Process.kill(sig, tpid) + end + };#1 + assert_nothing_raised do + n.times do + w = Thread.start do + sleep 30 + end + begin + f.puts + f.gets + ensure + w.kill + w.join + end + end + end + n.times do + w = Thread.start { sleep 30 } + begin + f.puts + f.gets + ensure + w.kill + t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC) + w.join(30) + t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC) + diff = t1 - t0 + assert_operator diff, :<=, 2 + end + end + end + }; end end |