1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
# frozen_string_literal: false
require 'test/unit'
require 'timeout'
class TestTimeout < Test::Unit::TestCase
def test_non_timing_out_code_is_successful
assert_nothing_raised do
assert_equal :ok, Timeout.timeout(1){ :ok }
end
end
def test_included
c = Class.new do
include Timeout
def test
timeout(1) { :ok }
end
end
assert_nothing_raised do
assert_equal :ok, c.new.test
end
end
def test_yield_param
assert_equal [5, :ok], Timeout.timeout(5){|s| [s, :ok] }
end
def test_queue
q = Thread::Queue.new
assert_raise(Timeout::Error, "[ruby-dev:32935]") {
Timeout.timeout(0.01) { q.pop }
}
end
def test_timeout
assert_raise(Timeout::Error) do
Timeout.timeout(0.1) {
nil while true
}
end
end
def test_cannot_convert_into_time_interval
bug3168 = '[ruby-dev:41010]'
def (n = Object.new).zero?; false; end
assert_raise(TypeError, bug3168) {Timeout.timeout(n) { sleep 0.1 }}
end
def test_skip_rescue
bug8730 = '[Bug #8730]'
e = nil
assert_raise_with_message(Timeout::Error, /execution expired/, bug8730) do
Timeout.timeout 0.01 do
begin
sleep 3
rescue Exception => e
flunk "should not see any exception but saw #{e.inspect}"
end
end
end
assert_nil(e, bug8730)
end
def test_rescue_exit
exc = Class.new(RuntimeError)
e = nil
assert_nothing_raised(exc) do
Timeout.timeout 0.01, exc do
begin
sleep 3
rescue exc => e
end
end
end
assert_raise_with_message(exc, 'execution expired') {raise e if e}
end
def test_custom_exception
bug9354 = '[ruby-core:59511] [Bug #9354]'
err = Class.new(StandardError) do
def initialize(msg) super end
end
assert_nothing_raised(ArgumentError, bug9354) do
assert_equal(:ok, Timeout.timeout(100, err) {:ok})
end
assert_raise_with_message(err, 'execution expired') do
Timeout.timeout 0.01, err do
sleep 3
end
end
assert_raise_with_message(err, /connection to ruby-lang.org expired/) do
Timeout.timeout 0.01, err, "connection to ruby-lang.org expired" do
sleep 3
end
end
end
def test_exit_exception
assert_raise_with_message(Timeout::Error, "boon") do
Timeout.timeout(10, Timeout::Error) do
raise Timeout::Error, "boon"
end
end
end
def test_raise_with_message
bug17812 = '[ruby-core:103502] [Bug #17812]: Timeout::Error doesn\'t let two-argument raise() set a new message'
exc = Timeout::Error.new('foo')
assert_raise_with_message(Timeout::Error, 'bar', bug17812) do
raise exc, 'bar'
end
end
def test_enumerator_next
bug9380 = '[ruby-dev:47872] [Bug #9380]: timeout in Enumerator#next'
e = (o=Object.new).to_enum
def o.each
sleep
end
assert_raise_with_message(Timeout::Error, 'execution expired', bug9380) do
Timeout.timeout(0.01) {e.next}
end
end
def test_handle_interrupt
bug11344 = '[ruby-dev:49179] [Bug #11344]'
ok = false
assert_raise(Timeout::Error) {
Thread.handle_interrupt(Timeout::Error => :never) {
Timeout.timeout(0.01) {
sleep 0.2
ok = true
Thread.handle_interrupt(Timeout::Error => :on_blocking) {
sleep 0.2
}
}
}
}
assert(ok, bug11344)
end
def test_fork
omit 'fork not supported' unless Process.respond_to?(:fork)
r, w = IO.pipe
pid = fork do
r.close
begin
r = Timeout.timeout(0.01) { sleep 5 }
w.write r.inspect
rescue Timeout::Error
w.write 'timeout'
ensure
w.close
end
end
w.close
Process.wait pid
assert_equal 'timeout', r.read
r.close
end
def test_threadgroup
assert_separately(%w[-rtimeout], <<-'end;')
tg = ThreadGroup.new
thr = Thread.new do
tg.add(Thread.current)
Timeout.timeout(10){}
end
thr.join
assert_equal [].to_s, tg.list.to_s
end;
end
# https://github.com/ruby/timeout/issues/24
def test_handling_enclosed_threadgroup
assert_separately(%w[-rtimeout], <<-'end;')
Thread.new {
t = Thread.current
group = ThreadGroup.new
group.add(t)
group.enclose
assert_equal 42, Timeout.timeout(1) { 42 }
}.join
end;
end
end
|
