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
|
require_relative '../../spec_helper'
describe "IO.select" do
before :each do
@rd, @wr = IO.pipe
end
after :each do
@rd.close unless @rd.closed?
@wr.close unless @wr.closed?
end
it "blocks for duration of timeout and returns nil if there are no objects ready for I/O" do
IO.select([@rd], nil, nil, 0.001).should == nil
end
it "returns immediately all objects that are ready for I/O when timeout is 0" do
@wr.syswrite("be ready")
IO.pipe do |_, wr|
result = IO.select [@rd], [wr], nil, 0
result.should == [[@rd], [wr], []]
end
end
it "returns nil after timeout if there are no objects ready for I/O" do
result = IO.select [@rd], nil, nil, 0
result.should == nil
end
it "returns supplied objects when they are ready for I/O" do
main = Thread.current
t = Thread.new {
Thread.pass until main.status == "sleep"
@wr.write "be ready"
}
result = IO.select [@rd], nil, nil, nil
result.should == [[@rd], [], []]
t.join
end
it "leaves out IO objects for which there is no I/O ready" do
@wr.write "be ready"
platform_is :aix do
# In AIX, when a pipe is readable, select(2) returns the write side
# of the pipe as "readable", even though you cannot actually read
# anything from the write side.
result = IO.select [@wr, @rd], nil, nil, nil
result.should == [[@wr, @rd], [], []]
end
platform_is_not :aix do
# Order matters here. We want to see that @wr doesn't expand the size
# of the returned array, so it must be 1st.
result = IO.select [@wr, @rd], nil, nil, nil
result.should == [[@rd], [], []]
end
end
it "returns supplied objects correctly when monitoring the same object in different arrays" do
filename = tmp("IO_select_pipe_file")
io = File.open(filename, 'w+')
result = IO.select [io], [io], nil, 0
result.should == [[io], [io], []]
io.close
rm_r filename
end
it "returns the pipe read end in read set if the pipe write end is closed concurrently" do
main = Thread.current
t = Thread.new {
Thread.pass until main.stop?
@wr.close
}
IO.select([@rd]).should == [[@rd], [], []]
ensure
t.join
end
it "invokes to_io on supplied objects that are not IO and returns the supplied objects" do
# make some data available
@wr.write("foobar")
obj = mock("read_io")
obj.should_receive(:to_io).at_least(1).and_return(@rd)
IO.select([obj]).should == [[obj], [], []]
IO.pipe do |_, wr|
obj = mock("write_io")
obj.should_receive(:to_io).at_least(1).and_return(wr)
IO.select(nil, [obj]).should == [[], [obj], []]
end
end
it "raises TypeError if supplied objects are not IO" do
-> { IO.select([Object.new]) }.should raise_error(TypeError)
-> { IO.select(nil, [Object.new]) }.should raise_error(TypeError)
obj = mock("io")
obj.should_receive(:to_io).any_number_of_times.and_return(nil)
-> { IO.select([obj]) }.should raise_error(TypeError)
-> { IO.select(nil, [obj]) }.should raise_error(TypeError)
end
it "raises a TypeError if the specified timeout value is not Numeric" do
-> { IO.select([@rd], nil, nil, Object.new) }.should raise_error(TypeError)
end
it "raises TypeError if the first three arguments are not Arrays" do
-> { IO.select(Object.new)}.should raise_error(TypeError)
-> { IO.select(nil, Object.new)}.should raise_error(TypeError)
-> { IO.select(nil, nil, Object.new)}.should raise_error(TypeError)
end
it "raises an ArgumentError when passed a negative timeout" do
-> { IO.select(nil, nil, nil, -5)}.should raise_error(ArgumentError)
end
end
describe "IO.select when passed nil for timeout" do
it "sleeps forever and sets the thread status to 'sleep'" do
t = Thread.new do
IO.select(nil, nil, nil, nil)
end
Thread.pass while t.status && t.status != "sleep"
t.join unless t.status
t.status.should == "sleep"
t.kill
t.join
end
end
|
