From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/test/thread/test_cv.rb | 221 +++++++++++++++++++++++++++++ jni/ruby/test/thread/test_queue.rb | 280 +++++++++++++++++++++++++++++++++++++ jni/ruby/test/thread/test_sync.rb | 63 +++++++++ 3 files changed, 564 insertions(+) create mode 100644 jni/ruby/test/thread/test_cv.rb create mode 100644 jni/ruby/test/thread/test_queue.rb create mode 100644 jni/ruby/test/thread/test_sync.rb (limited to 'jni/ruby/test/thread') diff --git a/jni/ruby/test/thread/test_cv.rb b/jni/ruby/test/thread/test_cv.rb new file mode 100644 index 0000000..b399b47 --- /dev/null +++ b/jni/ruby/test/thread/test_cv.rb @@ -0,0 +1,221 @@ +require 'test/unit' +require 'thread' +require 'tmpdir' + +class TestConditionVariable < Test::Unit::TestCase + def test_initialized + assert_raise(TypeError) { + ConditionVariable.allocate.wait(nil) + } + end + + def test_condvar_signal_and_wait + 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 + Timeout.timeout(5) do + nr_threads.times do |i| + threads[i].join + end + end + + assert_equal ["C1", "C1", "C1", "P1", "P2", "C2", "C2", "C2"], result + end + + def test_condvar_wait_deadlock + assert_in_out_err([], <<-INPUT, ["fatal", "No live threads left. Deadlock?"], []) + require "thread" + + mutex = Mutex.new + cv = ConditionVariable.new + + klass = nil + mesg = nil + begin + mutex.lock + cv.wait mutex + mutex.unlock + rescue Exception => e + klass = e.class + mesg = e.message + end + puts klass + print mesg +INPUT + 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 + 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 + end + + def test_condvar_empty_signal + mutex = Mutex.new + condvar = ConditionVariable.new + + assert_nothing_raised(Exception) { mutex.synchronize {condvar.signal} } + end + + def test_condvar_empty_broadcast + mutex = Mutex.new + condvar = ConditionVariable.new + + assert_nothing_raised(Exception) { mutex.synchronize {condvar.broadcast} } + end + + def test_dup + bug9440 = '[ruby-core:59961] [Bug #9440]' + condvar = ConditionVariable.new + assert_raise(NoMethodError, bug9440) do + condvar.dup + end + end + + (DumpableCV = ConditionVariable.dup).class_eval {remove_method :marshal_dump} + + def test_dump + bug9674 = '[ruby-core:61677] [Bug #9674]' + condvar = ConditionVariable.new + assert_raise_with_message(TypeError, /#{ConditionVariable}/, bug9674) do + Marshal.dump(condvar) + end + + condvar = DumpableCV.new + assert_raise_with_message(TypeError, /internal Array/, bug9674) do + Marshal.dump(condvar) + end + end +end diff --git a/jni/ruby/test/thread/test_queue.rb b/jni/ruby/test/thread/test_queue.rb new file mode 100644 index 0000000..2bd71db --- /dev/null +++ b/jni/ruby/test/thread/test_queue.rb @@ -0,0 +1,280 @@ +require 'test/unit' +require 'thread' +require 'tmpdir' +require 'timeout' + +class TestQueue < Test::Unit::TestCase + def test_queue_initialized + assert_raise(TypeError) { + Queue.allocate.push(nil) + } + end + + def test_sized_queue_initialized + assert_raise(TypeError) { + SizedQueue.allocate.push(nil) + } + end + + def test_queue + grind(5, 1000, 15, Queue) + end + + def test_sized_queue + grind(5, 1000, 15, SizedQueue, 1000) + end + + def grind(num_threads, num_objects, num_iterations, klass, *args) + from_workers = klass.new(*args) + to_workers = klass.new(*args) + + workers = (1..num_threads).map { + Thread.new { + while object = to_workers.pop + from_workers.push object + end + } + } + + Thread.new { + num_iterations.times { + num_objects.times { to_workers.push 99 } + num_objects.times { from_workers.pop } + } + }.join + + num_threads.times { to_workers.push nil } + workers.each { |t| t.join } + + assert_equal 0, from_workers.size + assert_equal 0, to_workers.size + end + + def test_sized_queue_initialize + q = SizedQueue.new(1) + assert_equal 1, q.max + assert_raise(ArgumentError) { SizedQueue.new(0) } + assert_raise(ArgumentError) { SizedQueue.new(-1) } + end + + def test_sized_queue_assign_max + q = SizedQueue.new(2) + assert_equal(2, q.max) + q.max = 1 + assert_equal(1, q.max) + assert_raise(ArgumentError) { q.max = 0 } + assert_equal(1, q.max) + assert_raise(ArgumentError) { q.max = -1 } + assert_equal(1, q.max) + + before = q.max + q.max.times { q << 1 } + t1 = Thread.new { q << 1 } + sleep 0.01 until t1.stop? + q.max = q.max + 1 + assert_equal before + 1, q.max + ensure + t1.join if t1 + end + + def test_queue_pop_interrupt + q = Queue.new + t1 = Thread.new { q.pop } + sleep 0.01 until t1.stop? + t1.kill.join + assert_equal(0, q.num_waiting) + end + + def test_queue_pop_non_block + q = Queue.new + assert_raise_with_message(ThreadError, /empty/) do + q.pop(true) + end + end + + def test_sized_queue_pop_interrupt + q = SizedQueue.new(1) + t1 = Thread.new { q.pop } + sleep 0.01 until t1.stop? + t1.kill.join + assert_equal(0, q.num_waiting) + end + + def test_sized_queue_pop_non_block + q = SizedQueue.new(1) + assert_raise_with_message(ThreadError, /empty/) do + q.pop(true) + end + end + + def test_sized_queue_push_interrupt + q = SizedQueue.new(1) + q.push(1) + assert_raise_with_message(ThreadError, /full/) do + q.push(2, true) + end + end + + def test_sized_queue_push_non_block + q = SizedQueue.new(1) + q.push(1) + t1 = Thread.new { q.push(2) } + sleep 0.01 until t1.stop? + t1.kill.join + assert_equal(0, q.num_waiting) + end + + def test_thr_kill + bug5343 = '[ruby-core:39634]' + Dir.mktmpdir {|d| + timeout = 30 + total_count = 250 + begin + assert_normal_exit(<<-"_eom", bug5343, {:timeout => timeout, :chdir=>d}) + require "thread" + #{total_count}.times do |i| + open("test_thr_kill_count", "w") {|f| f.puts i } + queue = Queue.new + r, w = IO.pipe + th = Thread.start { + queue.push(nil) + r.read 1 + } + queue.pop + th.kill + th.join + end + _eom + rescue Timeout::Error + count = File.read("#{d}/test_thr_kill_count").to_i + flunk "only #{count}/#{total_count} done in #{timeout} seconds." + end + } + end + + def test_queue_push_return_value + q = Queue.new + retval = q.push(1) + assert_same q, retval + end + + def test_queue_clear_return_value + q = Queue.new + retval = q.clear + assert_same q, retval + end + + def test_sized_queue_clear + # Fill queue, then test that SizedQueue#clear wakes up all waiting threads + sq = SizedQueue.new(2) + 2.times { sq << 1 } + + t1 = Thread.new do + sq << 1 + end + + t2 = Thread.new do + sq << 1 + end + + t3 = Thread.new do + Thread.pass + sq.clear + end + + [t3, t2, t1].each(&:join) + assert_equal sq.length, 2 + end + + def test_sized_queue_push_return_value + q = SizedQueue.new(1) + retval = q.push(1) + assert_same q, retval + end + + def test_sized_queue_clear_return_value + q = SizedQueue.new(1) + retval = q.clear + assert_same q, retval + end + + def test_sized_queue_throttle + q = SizedQueue.new(1) + i = 0 + consumer = Thread.new do + while q.pop + i += 1 + Thread.pass + end + end + nprod = 4 + npush = 100 + + producer = nprod.times.map do + Thread.new do + npush.times { q.push(true) } + end + end + producer.each(&:join) + q.push(nil) + consumer.join + assert_equal(nprod * npush, i) + end + + def test_queue_thread_raise + q = Queue.new + th1 = Thread.new do + begin + q.pop + rescue RuntimeError + sleep + end + end + th2 = Thread.new do + sleep 0.1 + q.pop + end + sleep 0.1 + th1.raise + sleep 0.1 + q << :s + assert_nothing_raised(Timeout::Error) do + timeout(1) { th2.join } + end + ensure + [th1, th2].each do |th| + if th and th.alive? + th.wakeup + th.join + end + end + end + + def test_dup + bug9440 = '[ruby-core:59961] [Bug #9440]' + q = Queue.new + assert_raise(NoMethodError, bug9440) do + q.dup + end + end + + (DumpableQueue = Queue.dup).class_eval {remove_method :marshal_dump} + + def test_dump + bug9674 = '[ruby-core:61677] [Bug #9674]' + q = Queue.new + assert_raise_with_message(TypeError, /#{Queue}/, bug9674) do + Marshal.dump(q) + end + + sq = SizedQueue.new(1) + assert_raise_with_message(TypeError, /#{SizedQueue}/, bug9674) do + Marshal.dump(sq) + end + + q = DumpableQueue.new + assert_raise_with_message(TypeError, /internal Array/, bug9674) do + Marshal.dump(q) + end + end +end diff --git a/jni/ruby/test/thread/test_sync.rb b/jni/ruby/test/thread/test_sync.rb new file mode 100644 index 0000000..9509cac --- /dev/null +++ b/jni/ruby/test/thread/test_sync.rb @@ -0,0 +1,63 @@ +require 'test/unit' +require 'sync' +require 'timeout' + +class SyncTest < Test::Unit::TestCase + class Tester + include Sync_m + end + + def test_sync_lock_and_wakeup + tester = Tester.new + + tester.sync_lock(:EX) + + t = Thread.new { tester.sync_lock(:EX) } + + sleep 0.1 until t.stop? + t.wakeup + sleep 0.1 until t.stop? + + assert_equal(tester.sync_waiting.uniq, tester.sync_waiting) + ensure + t.kill + t.join + end + + def test_sync_upgrade_and_wakeup + tester = Tester.new + tester.sync_lock(:SH) + + t = Thread.new do + tester.sync_lock(:SH) + tester.sync_lock(:EX) + end + + sleep 0.1 until t.stop? + t.wakeup + sleep 0.1 until t.stop? + + tester.sync_upgrade_waiting.each { |ary| + assert(!tester.sync_waiting.include?(ary[0])) + } + assert_equal(tester.sync_waiting.uniq, tester.sync_waiting) + assert_equal(tester.sync_waiting, []) + ensure + t.kill + t.join + end + + def test_sync_lock_and_raise + tester= Tester.new + tester.sync_lock(:EX) + + t = Thread.new { tester.sync_lock(:EX) } + + sleep 0.1 until t.stop? + t.raise + sleep 0.1 while t.alive? + + assert_equal(tester.sync_waiting.uniq, tester.sync_waiting) + assert_equal(tester.sync_waiting, []) + end +end -- cgit v1.2.3