Fresh start

3 files changed, 564 insertions, 0 deletions

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