summaryrefslogtreecommitdiff
path: root/test/thread
diff options
context:
space:
mode:
Diffstat (limited to 'test/thread')
-rw-r--r--test/thread/test_cv.rb191
-rw-r--r--test/thread/test_queue.rb178
-rw-r--r--test/thread/test_sync.rb57
3 files changed, 0 insertions, 426 deletions
diff --git a/test/thread/test_cv.rb b/test/thread/test_cv.rb
deleted file mode 100644
index 9a9b407a5b..0000000000
--- a/test/thread/test_cv.rb
+++ /dev/null
@@ -1,191 +0,0 @@
-require 'test/unit'
-require 'thread'
-require 'tmpdir'
-require_relative '../ruby/envutil'
-
-class TestConditionVariable < Test::Unit::TestCase
- 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
- nr_threads.times do |i|
- threads[i].join
- 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
-end
diff --git a/test/thread/test_queue.rb b/test/thread/test_queue.rb
deleted file mode 100644
index 6b4f10c4d2..0000000000
--- a/test/thread/test_queue.rb
+++ /dev/null
@@ -1,178 +0,0 @@
-require 'test/unit'
-require 'thread'
-require 'tmpdir'
-require_relative '../ruby/envutil'
-
-class TestQueue < Test::Unit::TestCase
- 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)
- 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_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_push_interrupt
- 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_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_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(TimeoutError) do
- timeout(1) { th2.join }
- end
- end
-end
diff --git a/test/thread/test_sync.rb b/test/thread/test_sync.rb
deleted file mode 100644
index 870a8e2d39..0000000000
--- a/test/thread/test_sync.rb
+++ /dev/null
@@ -1,57 +0,0 @@
-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)
- 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, [])
- 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
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-20 07:16:51 +0000