1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
ruby--ruby/test/monitor/test_monitor.rb

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