mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
355 lines
6.9 KiB
Ruby
355 lines
6.9 KiB
Ruby
# frozen_string_literal: false
|
|
require "monitor"
|
|
|
|
require "test/unit"
|
|
|
|
class TestMonitor < Test::Unit::TestCase
|
|
Queue = Thread::Queue
|
|
|
|
def setup
|
|
@monitor = Monitor.new
|
|
end
|
|
|
|
def test_enter_in_different_fibers
|
|
@monitor.enter
|
|
Fiber.new {
|
|
assert_equal false, @monitor.try_enter
|
|
}.resume
|
|
end
|
|
|
|
def test_enter
|
|
ary = []
|
|
queue = Queue.new
|
|
th = Thread.start {
|
|
queue.pop
|
|
@monitor.enter
|
|
for i in 6 .. 10
|
|
ary.push(i)
|
|
Thread.pass
|
|
end
|
|
@monitor.exit
|
|
}
|
|
th2 = Thread.start {
|
|
@monitor.enter
|
|
queue.enq(nil)
|
|
for i in 1 .. 5
|
|
ary.push(i)
|
|
Thread.pass
|
|
end
|
|
@monitor.exit
|
|
}
|
|
assert_join_threads([th, th2])
|
|
assert_equal((1..10).to_a, ary)
|
|
end
|
|
|
|
def test_exit
|
|
m = Monitor.new
|
|
m.enter
|
|
assert_equal true, m.mon_owned?
|
|
m.exit
|
|
assert_equal false, m.mon_owned?
|
|
|
|
assert_raise ThreadError do
|
|
m.exit
|
|
end
|
|
|
|
assert_equal false, m.mon_owned?
|
|
|
|
m.enter
|
|
Thread.new{
|
|
assert_raise(ThreadError) do
|
|
m.exit
|
|
end
|
|
}.join
|
|
assert_equal true, m.mon_owned?
|
|
m.exit
|
|
end
|
|
|
|
def test_enter_second_after_killed_thread
|
|
th = Thread.start {
|
|
@monitor.enter
|
|
Thread.current.kill
|
|
@monitor.exit
|
|
}
|
|
th.join
|
|
@monitor.enter
|
|
@monitor.exit
|
|
th2 = Thread.start {
|
|
@monitor.enter
|
|
@monitor.exit
|
|
}
|
|
assert_join_threads([th, th2])
|
|
end
|
|
|
|
def test_synchronize
|
|
ary = []
|
|
queue = Queue.new
|
|
th = Thread.start {
|
|
queue.pop
|
|
@monitor.synchronize do
|
|
for i in 6 .. 10
|
|
ary.push(i)
|
|
Thread.pass
|
|
end
|
|
end
|
|
}
|
|
th2 = Thread.start {
|
|
@monitor.synchronize do
|
|
queue.enq(nil)
|
|
for i in 1 .. 5
|
|
ary.push(i)
|
|
Thread.pass
|
|
end
|
|
end
|
|
}
|
|
assert_join_threads([th, th2])
|
|
assert_equal((1..10).to_a, ary)
|
|
end
|
|
|
|
def test_killed_thread_in_synchronize
|
|
ary = []
|
|
queue = Queue.new
|
|
t1 = Thread.start {
|
|
queue.pop
|
|
@monitor.synchronize {
|
|
ary << :t1
|
|
}
|
|
}
|
|
t2 = Thread.start {
|
|
queue.pop
|
|
@monitor.synchronize {
|
|
ary << :t2
|
|
}
|
|
}
|
|
t3 = Thread.start {
|
|
@monitor.synchronize do
|
|
queue.enq(nil)
|
|
queue.enq(nil)
|
|
assert_equal([], ary)
|
|
t1.kill
|
|
t2.kill
|
|
ary << :main
|
|
end
|
|
assert_equal([:main], ary)
|
|
}
|
|
assert_join_threads([t1, t2, t3])
|
|
end
|
|
|
|
def test_try_enter
|
|
queue1 = Queue.new
|
|
queue2 = Queue.new
|
|
th = Thread.start {
|
|
queue1.deq
|
|
@monitor.enter
|
|
queue2.enq(nil)
|
|
queue1.deq
|
|
@monitor.exit
|
|
queue2.enq(nil)
|
|
}
|
|
th2 = Thread.start {
|
|
assert_equal(true, @monitor.try_enter)
|
|
@monitor.exit
|
|
queue1.enq(nil)
|
|
queue2.deq
|
|
assert_equal(false, @monitor.try_enter)
|
|
queue1.enq(nil)
|
|
queue2.deq
|
|
assert_equal(true, @monitor.try_enter)
|
|
}
|
|
assert_join_threads([th, th2])
|
|
end
|
|
|
|
def test_try_enter_second_after_killed_thread
|
|
th = Thread.start {
|
|
assert_equal(true, @monitor.try_enter)
|
|
Thread.current.kill
|
|
@monitor.exit
|
|
}
|
|
th.join
|
|
assert_equal(true, @monitor.try_enter)
|
|
@monitor.exit
|
|
th2 = Thread.start {
|
|
assert_equal(true, @monitor.try_enter)
|
|
@monitor.exit
|
|
}
|
|
assert_join_threads([th, th2])
|
|
end
|
|
|
|
def test_mon_locked_and_owned
|
|
queue1 = Queue.new
|
|
queue2 = Queue.new
|
|
th = Thread.start {
|
|
@monitor.enter
|
|
queue1.enq(nil)
|
|
queue2.deq
|
|
@monitor.exit
|
|
queue1.enq(nil)
|
|
}
|
|
queue1.deq
|
|
assert(@monitor.mon_locked?)
|
|
assert(!@monitor.mon_owned?)
|
|
|
|
queue2.enq(nil)
|
|
queue1.deq
|
|
assert(!@monitor.mon_locked?)
|
|
|
|
@monitor.enter
|
|
assert @monitor.mon_locked?
|
|
assert @monitor.mon_owned?
|
|
@monitor.exit
|
|
|
|
@monitor.synchronize do
|
|
assert @monitor.mon_locked?
|
|
assert @monitor.mon_owned?
|
|
end
|
|
ensure
|
|
th.join
|
|
end
|
|
|
|
def test_cond
|
|
cond = @monitor.new_cond
|
|
|
|
a = "foo"
|
|
queue1 = Queue.new
|
|
th = Thread.start do
|
|
queue1.deq
|
|
@monitor.synchronize do
|
|
a = "bar"
|
|
cond.signal
|
|
end
|
|
end
|
|
th2 = Thread.start do
|
|
@monitor.synchronize do
|
|
queue1.enq(nil)
|
|
assert_equal("foo", a)
|
|
result1 = cond.wait
|
|
assert_equal(true, result1)
|
|
assert_equal("bar", a)
|
|
end
|
|
end
|
|
assert_join_threads([th, th2])
|
|
end
|
|
|
|
class NewCondTest
|
|
include MonitorMixin
|
|
attr_reader :cond
|
|
def initialize
|
|
@cond = new_cond
|
|
super # mon_initialize
|
|
end
|
|
end
|
|
|
|
def test_new_cond_before_initialize
|
|
assert NewCondTest.new.cond.instance_variable_get(:@monitor) != nil
|
|
end
|
|
|
|
class KeywordInitializeParent
|
|
def initialize(x:)
|
|
end
|
|
end
|
|
|
|
class KeywordInitializeChild < KeywordInitializeParent
|
|
include MonitorMixin
|
|
def initialize
|
|
super(x: 1)
|
|
end
|
|
end
|
|
|
|
def test_initialize_with_keyword_arg
|
|
assert KeywordInitializeChild.new
|
|
end
|
|
|
|
def test_timedwait
|
|
cond = @monitor.new_cond
|
|
b = "foo"
|
|
queue2 = Queue.new
|
|
th = Thread.start do
|
|
queue2.deq
|
|
@monitor.synchronize do
|
|
b = "bar"
|
|
cond.signal
|
|
end
|
|
end
|
|
th2 = Thread.start do
|
|
@monitor.synchronize do
|
|
queue2.enq(nil)
|
|
assert_equal("foo", b)
|
|
result2 = cond.wait(0.1)
|
|
assert_equal(true, result2)
|
|
assert_equal("bar", b)
|
|
end
|
|
end
|
|
assert_join_threads([th, th2])
|
|
|
|
c = "foo"
|
|
queue3 = Queue.new
|
|
th = Thread.start do
|
|
queue3.deq
|
|
@monitor.synchronize do
|
|
c = "bar"
|
|
cond.signal
|
|
end
|
|
end
|
|
th2 = Thread.start do
|
|
@monitor.synchronize do
|
|
assert_equal("foo", c)
|
|
result3 = cond.wait(0.1)
|
|
assert_equal(true, result3) # wait always returns true in Ruby 1.9
|
|
assert_equal("foo", c)
|
|
queue3.enq(nil)
|
|
result4 = cond.wait
|
|
assert_equal(true, result4)
|
|
assert_equal("bar", c)
|
|
end
|
|
end
|
|
assert_join_threads([th, th2])
|
|
|
|
# d = "foo"
|
|
# cumber_thread = Thread.start {
|
|
# loop do
|
|
# @monitor.synchronize do
|
|
# d = "foo"
|
|
# end
|
|
# end
|
|
# }
|
|
# queue3 = Queue.new
|
|
# Thread.start do
|
|
# queue3.pop
|
|
# @monitor.synchronize do
|
|
# d = "bar"
|
|
# cond.signal
|
|
# end
|
|
# end
|
|
# @monitor.synchronize do
|
|
# queue3.enq(nil)
|
|
# assert_equal("foo", d)
|
|
# result5 = cond.wait
|
|
# assert_equal(true, result5)
|
|
# # this thread has priority over cumber_thread
|
|
# assert_equal("bar", d)
|
|
# end
|
|
# cumber_thread.kill
|
|
end
|
|
|
|
def test_wait_interruption
|
|
cond = @monitor.new_cond
|
|
|
|
th = Thread.start {
|
|
@monitor.synchronize do
|
|
begin
|
|
cond.wait(0.1)
|
|
@monitor.mon_owned?
|
|
rescue Interrupt
|
|
@monitor.mon_owned?
|
|
end
|
|
end
|
|
}
|
|
sleep(0.1)
|
|
th.raise(Interrupt)
|
|
|
|
begin
|
|
assert_equal true, th.value
|
|
rescue Interrupt
|
|
end
|
|
end
|
|
end
|