uringmachine 0.19.1 → 0.21.0

data/test/test_um.rb

@@ -11,6 +11,80 @@ class UringMachineTest < Minitest::Test
   end
 end
 
+class EntriesTest < Minitest::Test
+  def test_default_entries
+    m = UM.new
+    assert_equal 4096, m.entries
+  end
+
+  def test_custom_entries_value
+    m = UM.new(13)
+    assert_equal 13, m.entries
+  end
+end
+
+class SQPOLLTest < Minitest::Test
+  def test_sqpoll_timeout
+    m = UM.new(10, 0.05)
+
+    r, w = UM.pipe
+
+    buf = nil
+    t = Thread.new { buf = IO.new(r).readpartial(3) }
+
+    # let SQPOLL worker thread timeout
+    sleep(0.06)
+
+    # SQE is prepared but not submitted
+    m.write_async(w, 'foo')
+
+    # thread should timeout
+    ret = t.join(0.03)
+    assert_nil buf
+  ensure
+    t.kill rescue nil
+  end
+
+  def test_sqpoll_timeout_with_submit
+    m = UM.new(10, 0.05)
+
+    r, w = UM.pipe
+
+    buf = nil
+    t = Thread.new { buf = IO.new(r).readpartial(3) }
+
+    # let SQPOLL worker thread timeout
+    sleep(0.06)
+
+    # SQE is prepared but not submitted
+    m.write_async(w, 'foo')
+    ret = m.submit
+    assert_equal 1, ret
+
+    # thread should timeout
+    ret = t.join(0.1)
+    assert_equal 'foo', buf
+  ensure
+    t.kill rescue nil
+  end
+end
+
+class SubmitTest < UMBaseTest
+  def test_submit
+    _r, w = UM.pipe
+
+    machine.write_async(w, 'foo')
+    machine.write_async(w, 'bar')
+    machine.write_async(w, 'baz')
+
+    assert_equal 3, machine.pending_count
+    assert_equal 3, machine.submit
+    assert_equal 0, machine.submit
+    machine.snooze
+    assert_equal 0, machine.pending_count
+  end
+end
+
 class SpinTest < UMBaseTest
   def test_spin
     x = nil
@@ -164,7 +238,7 @@ class ScheduleTest < UMBaseTest
     }
     machine.join(*fs)
   ensure
-    GC.stress = false    
+    GC.stress = false
   end
 
   def test_timeout_with_raising_block
@@ -327,16 +401,36 @@ class PeriodicallyTest < UMBaseTest
     rescue Cancel
       cancel = 1
     end
-    5.times { machine.snooze }
-    assert_equal 0, machine.pending_count
+    assert_equal 1, cancel
     t1 = monotonic_clock
     assert_in_range 0.05..0.08, t1 - t0
     assert_in_range 4..6, count
-    assert_equal 1, cancel
 
   end
 end
 
+class StatsTest < UMBaseTest
+  def test_op_counts
+    _r, w = IO.pipe
+
+    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.total_op_count
+    machine.write_async(w.fileno, 'foo')
+    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.total_op_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal 1, machine.total_op_count
+
+    machine.write_async(w.fileno, 'foo')
+    assert_equal 1, machine.pending_count
+    assert_equal 2, machine.total_op_count
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal 2, machine.total_op_count
+  end
+end
+
 class ReadTest < UMBaseTest
   def test_read
     r, w = IO.pipe
@@ -419,6 +513,64 @@ class ReadTest < UMBaseTest
     assert_equal 3, result
     assert_equal 'baz', sio.read
   end
+
+  def test_read_io_buffer
+    r, w = UM.pipe
+    machine.write(w, 'foobar')
+
+    read_buffer = IO::Buffer.new(3)
+    res = machine.read(r, read_buffer, 3)
+    assert_equal 3, res
+    assert_equal 'foo', read_buffer.get_string(0, 3)
+
+    machine.close(w)
+
+    res = machine.read(r, read_buffer)
+    assert_equal 3, res
+    assert_equal 'bar', read_buffer.get_string(0, 3)
+  end
+
+  def test_read_io_buffer_resize
+    r, w = UM.pipe
+    machine.write(w, 'foobar')
+    machine.close(w)
+
+    read_buffer = IO::Buffer.new(3)
+    res = machine.read(r, read_buffer, 6)
+    assert_equal 6, res
+    assert_equal 6, read_buffer.size
+    assert_equal 'foobar', read_buffer.get_string(0, res)
+
+    r, w = UM.pipe
+    machine.write(w, 'foobar')
+    machine.close(w)
+
+    read_buffer = IO::Buffer.new(3)
+    res = machine.read(r, read_buffer, 128, -1)
+    assert_equal 6, res
+    assert_equal 131, read_buffer.size
+    assert_equal 'foobar', read_buffer.get_string(3, res)
+  end
+
+  def test_read_invalid_buffer
+    r, _w = UM.pipe
+    assert_raises(UM::Error) {
+      machine.read(r, [])
+    }
+  end
+
+  def test_read_with_file_offset
+    fn = "/tmp/#{SecureRandom.hex}"
+    IO.write(fn, 'foobar')
+
+    fd = machine.open(fn, UM::O_RDONLY)
+    buffer = +''
+    result = machine.read(fd, buffer, 100, 0, 2)
+    assert_equal 4, result
+    assert_equal 'obar', buffer
+  ensure
+    machine.close(fd)
+  end
 end
 
 class ReadEachTest < UMBaseTest
@@ -569,11 +721,13 @@ class WriteTest < UMBaseTest
     r, w = IO.pipe
 
     assert_equal 0, machine.pending_count
-    machine.write(w.fileno, 'foo')
+    res = machine.write(w.fileno, 'foo')
+    assert_equal 3, res
     assert_equal 0, machine.pending_count
     assert_equal 'foo', r.readpartial(3)
 
-    machine.write(w.fileno, 'bar', 2)
+    res = machine.write(w.fileno, 'bar', 2)
+    assert_equal 2, res
     assert_equal 'ba', r.readpartial(3)
   end
 
@@ -586,6 +740,85 @@ class WriteTest < UMBaseTest
     end
     assert_equal 0, machine.pending_count
   end
+
+  def test_write_zero_length
+    r, w = IO.pipe
+
+    res = machine.write(w.fileno, '')
+    assert_equal 0, res
+
+    res = machine.write(w.fileno, 'bar', 0)
+    assert_equal 0, res
+
+    buf = IO::Buffer.new(3)
+    buf.set_string('baz')
+    res = machine.write(w.fileno, buf, 0, 0)
+    assert_equal 0, res
+
+    w.close
+    assert_equal '', r.read
+  end
+
+  def test_write_io_buffer
+    r, w = UM.pipe
+
+    msg = 'Hello world'
+    write_buffer = IO::Buffer.new(msg.bytesize)
+    write_buffer.set_string(msg, 0)
+
+    machine.write(w, write_buffer)
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal msg, str
+  end
+
+  def test_write_io_buffer_with_len
+    r, w = UM.pipe
+    msg = 'Hello world'
+    write_buffer = IO::Buffer.new(msg.bytesize)
+    write_buffer.set_string(msg)
+
+    machine.write(w, write_buffer, 5)
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal 'Hello', str
+
+    r, w = UM.pipe
+    msg = 'Hello world'
+    write_buffer = IO::Buffer.new(msg.bytesize)
+    write_buffer.set_string(msg)
+
+    machine.write(w, write_buffer, -1)
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal 'Hello world', str
+  end
+
+  def test_write_invalid_buffer
+    _r, w = UM.pipe
+    assert_raises(UM::Error) {
+      machine.write(w, [])
+    }
+  end
+
+  def test_write_with_file_offset
+    fn = "/tmp/#{SecureRandom.hex}"
+    IO.write(fn, 'foobar')
+
+    fd = machine.open(fn, UM::O_WRONLY)
+    result = machine.write(fd, 'baz', -1, 2)
+    assert_equal 3, result
+    assert_equal 'fobazr', IO.read(fn)
+  ensure
+    machine.close(fd)
+  end
+
 end
 
 class WriteAsyncTest < UMBaseTest
@@ -596,7 +829,7 @@ class WriteAsyncTest < UMBaseTest
     machine.write_async(w.fileno, 'foo')
     assert_equal 1, machine.pending_count
 
-    machine.snooze
+    machine.snooze while machine.pending_count > 0
     assert_equal 0, machine.pending_count
     assert_equal 'foo', r.readpartial(3)
   end
@@ -612,7 +845,7 @@ class WriteAsyncTest < UMBaseTest
     GC.start
     assert_equal 1, machine.pending_count
 
-    machine.snooze
+    machine.snooze while machine.pending_count > 0
     assert_equal 0, machine.pending_count
     assert_equal "foo#{123}#{'bar' * 48}", r.readpartial(len)
   end
@@ -626,6 +859,54 @@ class WriteAsyncTest < UMBaseTest
     machine.snooze
     assert_equal 0, machine.pending_count
   end
+
+  def test_write_async_io_buffer
+    r, w = UM.pipe
+
+    msg = 'Hello world'
+    write_buffer = IO::Buffer.new(msg.bytesize)
+    write_buffer.set_string(msg)
+
+    machine.write_async(w, write_buffer)
+    machine.snooze while machine.pending_count > 0
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal msg, str
+  end
+
+  def test_write_async_invalid_buffer
+    _r, w = UM.pipe
+
+    assert_raises(UM::Error) { machine.write_async(w, []) }
+  end
+
+  def test_write_async_with_len
+    r, w = IO.pipe
+
+    assert_equal 0, machine.pending_count
+    machine.write_async(w.fileno, 'foobar', 4)
+
+    assert_equal 1, machine.pending_count
+    machine.snooze while machine.pending_count > 0
+    assert_equal 0, machine.pending_count
+    assert_equal 'foob', r.readpartial(6)
+  end
+
+  def test_write_async_with_file_offset
+    fn = "/tmp/#{SecureRandom.hex}"
+    IO.write(fn, 'foobar')
+
+    fd = machine.open(fn, UM::O_WRONLY)
+    machine.write_async(fd, 'baz', -1, 2)
+
+    assert_equal 1, machine.pending_count
+    machine.snooze while machine.pending_count > 0
+    assert_equal 'fobazr', IO.read(fn)
+  ensure
+    machine.close(fd)
+  end
 end
 
 class CloseTest < UMBaseTest
@@ -643,7 +924,7 @@ class CloseTest < UMBaseTest
   end
 
   def test_close_bad_fd
-    r, w = IO.pipe
+    _r, w = IO.pipe
     machine.close(w.fileno)
 
     assert_raises(Errno::EBADF) { machine.close(w.fileno) }
@@ -902,6 +1183,78 @@ class SendTest < UMBaseTest
   ensure
     t&.kill
   end
+
+
+  def test_send_io_buffer
+    @port = assign_port
+    @server = TCPServer.open('127.0.0.1', @port)
+
+    t = Thread.new do
+      conn = @server.accept
+      str = conn.readpartial(42)
+      conn.write("You said: #{str} (#{str.bytesize})")
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    buffer = IO::Buffer.new(6)
+    buffer.set_string('foobar')
+    res = machine.send(fd, buffer, 6, 0)
+    assert_equal 6, res
+
+    buf = +''
+    res = machine.read(fd, buf, 42)
+    assert_equal 20, res
+    assert_equal 'You said: foobar (6)', buf
+  ensure
+    t&.kill
+    @server&.close
+  end
+
+  def test_send_io_buffer_negative_len
+    t = Thread.new do
+      conn = @server.accept
+      str = conn.readpartial(42)
+      conn.write("You said: #{str} (#{str.bytesize})")
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    buffer = IO::Buffer.new(6)
+    buffer.set_string('foobar')
+    res = machine.send(fd, buffer, -1, 0)
+    assert_equal 6, res
+
+    buf = +''
+    res = machine.read(fd, buf, 42)
+    assert_equal 20, res
+    assert_equal 'You said: foobar (6)', buf
+  ensure
+    t&.kill
+  end
+
+  def test_send_invalid_buffer
+    t = Thread.new do
+      conn = @server.accept
+      str = conn.readpartial(42)
+      conn.write("You said: #{str} (#{str.bytesize})")
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    assert_raises(UM::Error) { machine.send(fd, [], -1, 0) }
+  ensure
+    t&.kill
+  end
 end
 
 class RecvTest < UMBaseTest
@@ -934,6 +1287,25 @@ class RecvTest < UMBaseTest
   ensure
     t&.kill
   end
+
+  def test_recv_io_buffer
+    t = Thread.new do
+      conn = @server.accept
+      conn.write('foobar')
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    buf = IO::Buffer.new(12)
+    res = machine.recv(fd, buf, 12, 0)
+    assert_equal 6, res
+    assert_equal 'foobar', buf.get_string(0, 6)
+  ensure
+    t&.kill
+  end
 end
 
 class RecvEachTest < UMBaseTest
@@ -1070,8 +1442,6 @@ end
 
 class SynchronizeTest < UMBaseTest
   def test_synchronize_single
-    skip if !machine.respond_to?(:synchronize)
-
     m = UM::Mutex.new
 
     buf = []
@@ -1087,7 +1457,6 @@ class SynchronizeTest < UMBaseTest
   end
 
   def test_synchronize_pair
-    skip if !machine.respond_to?(:synchronize)
     m = UM::Mutex.new
 
     buf = []
@@ -1119,12 +1488,29 @@ class SynchronizeTest < UMBaseTest
     assert_equal [11, 12, 13, 21, 22, 23], buf
     assert_equal 0, machine.pending_count
   end
+
+  def test_synchronize_multi
+    mutex = UM::Mutex.new
+    buf = []
+    fibers = (1..8).map { |i|
+      machine.spin do
+        machine.synchronize(mutex) do
+          buf << (i * 10) + 1
+          machine.sleep(0.01)
+          buf << (i * 10) + 2
+        end
+        machine.snooze
+        buf << (i * 10) + 3
+      end
+    }
+
+    machine.join(*fibers)
+    assert_equal [11, 12, 21, 13, 22, 31, 23, 32, 41, 33, 42, 51, 43, 52, 61, 53, 62, 71, 63, 72, 81, 73, 82, 83], buf
+  end
 end
 
 class QueueTest < UMBaseTest
   def test_push_pop_1
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     assert_equal 0, q.count
     machine.push(q, :foo)
@@ -1138,8 +1524,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_2
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1170,8 +1554,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_3
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1198,8 +1580,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_4
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1227,8 +1607,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_shift_1
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
 
     machine.push(q, :foo)
@@ -1241,8 +1619,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_shift_shift_1
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
 
     machine.unshift(q, :foo)
@@ -1254,6 +1630,15 @@ class QueueTest < UMBaseTest
     assert_equal :foo, machine.shift(q)
   end
 
+  def test_shift_exception_value
+    q = UM::Queue.new
+    machine.unshift(q, Exception.new("foo"))
+
+    e = machine.shift(q)
+    assert_kind_of Exception, e
+    assert_equal "foo", e.message
+  end
+
   def test_cross_thread_push_shift
     q = UM::Queue.new
 
@@ -1277,6 +1662,42 @@ class QueueTest < UMBaseTest
 
     assert_equal [0, 1, 2], items
   end
+
+  def test_cross_thread_cross_queue_comms
+    worker_queue = UM::Queue.new
+
+    buf = []
+    t1 = Thread.new {
+      m = UM.new
+      (1..10).each {
+        q = UM::Queue.new
+        m.push(worker_queue, [q, it])
+        res = m.shift(q)
+        buf << res
+      }
+    }
+
+    t2 = Thread.new {
+      m = UM.new
+      loop do
+        q, v = m.shift(worker_queue)
+        break if q == :STOP
+
+        res = v * 10
+        m.push(q, res)
+      end
+    }
+
+    t1.join
+    q = UM::Queue.new
+    machine.push(worker_queue, :STOP)
+    t2.join
+
+    assert_equal (1..10).map { it * 10 }, buf
+  ensure
+    t1.kill rescue nil
+    t2.kill rescue nil
+  end
 end
 
 class OpenTest < UMBaseTest
@@ -1335,12 +1756,67 @@ class PipeTest < UMBaseTest
   end
 end
 
+class PidfdTest < UMBaseTest
+  def test_pidfd_open
+    pid = fork { exit 13 }
+    fd = UM.pidfd_open(pid)
+    assert_kind_of Integer, fd
+
+    pid2, status = machine.waitid(P_PIDFD, fd, UM::WEXITED)
+    assert_equal pid, pid2
+    assert_equal 13, status
+  ensure
+    machine.close(fd) rescue nil
+    Process.wait(pid) rescue nil
+  end
+
+  def test_pidfd_open_invalid_pid
+    assert_raises(SystemCallError) { UM.pidfd_open(Process.pid + 1) }
+  end
+
+  def test_pidfd_send_signal
+    fd = UM.pidfd_open(Process.pid)
+    buf = []
+    trap('SIGUSR1') { buf << :SIGUSR1 }
+
+    ret = UM.pidfd_send_signal(fd, UM::SIGUSR1)
+    assert_equal fd, ret
+    sleep 0.01
+
+    assert_equal [:SIGUSR1], buf
+  ensure
+    machine.close(fd) rescue nil
+  end
+
+  def test_pidfd_send_signal_test
+    fd = UM.pidfd_open(Process.pid)
+    buf = []
+    trap('SIGUSR1') { buf << :SIGUSR1 }
+
+    ret = UM.pidfd_send_signal(fd, 0)
+    assert_equal fd, ret
+    sleep 0.01
+    assert_equal [], buf
+
+    pid = fork { exit 13 }
+    fd2 = UM.pidfd_open(pid)
+    assert_kind_of Integer, fd2
+
+    Process.wait(pid)
+    assert_raises(SystemCallError) { UM.pidfd_send_signal(fd2, 0) }
+  ensure
+    machine.close(fd) rescue nil
+    machine.close(fd2) rescue nil
+    Process.wait(pid) rescue nil
+  end
+end
+
 class PollTest < UMBaseTest
   def test_poll
     rfd, wfd = UM.pipe
 
     events = []
-    f1 = machine.spin do
+    machine.spin do
       events << :pre
       events << machine.poll(rfd, UM::POLLIN)
       events << :post
@@ -1366,38 +1842,160 @@ class PollTest < UMBaseTest
   end
 end
 
-class WaitTest < UMBaseTest
-  def test_waitpid
-    skip if UM.kernel_version < 607
+class SelectTest < UMBaseTest
+  def test_select
+    rfd1, wfd1 = UM.pipe
+    rfd2, wfd2 = UM.pipe
+
+    events = []
+    machine.spin do
+      events << 1
+      events << machine.select([rfd1, rfd2], [], [])
+      events << 2
+      events << machine.select([rfd1, rfd2], [], [])
+      events << 3
+      machine.snooze
+      events << machine.select([], [wfd1, wfd2], [])
+      events << 4
+    end
+
+    machine.snooze
+    assert_equal [1], events
+
+    machine.write(wfd1, 'foo')
+    machine.snooze
+    assert_equal [1, [[rfd1], [], []], 2], events
+
+    machine.write(wfd2, 'foo')
+
+    machine.snooze
+    assert_equal [1, [[rfd1], [], []], 2, [[rfd1, rfd2], [], []], 3], events
+
+    machine.snooze
+
+    assert_equal [
+      1, [[rfd1], [], []],
+      2, [[rfd1, rfd2], [], []],
+      3, [[], [wfd1, wfd2], []],
+      4
+    ], events
+
+    machine.close(rfd1)
+    machine.close(rfd2)
+  end
+
+  def test_select_single
+    rfd1, wfd1 = UM.pipe
+
+    events = []
+    machine.spin do
+      events << 1
+      events << machine.select([rfd1], [], [])
+      events << 2
+      machine.snooze
+      events << machine.select([], [wfd1], [])
+      events << 3
+    end
+
+    machine.snooze
+    assert_equal [1], events
+
+    machine.write(wfd1, 'foo')
+    machine.snooze
+    assert_equal [1, [[rfd1], [], []], 2], events
+
+    3.times { machine.snooze }
+    assert_equal [1, [[rfd1], [], []], 2, [[], [wfd1], []], 3], events
+
+    machine.close(rfd1)
+    machine.close(wfd1)
+  end
+
+  def test_select_empty
+    ret = machine.select([], [], [])
+    assert_equal [[], [], []], ret
+  end
+
+  def test_select_bad_fd
+    assert_raises(Errno::EBADF) { machine.select([9876, 9877], [], []) }
+  end
+end
 
+class WaitidTest < UMBaseTest
+  def test_waitid
     msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    child_pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
 
-    rfd, wfd = UM.pipe
-    pid = fork do
+    pid, status = machine.waitid(UM::P_PID, child_pid, UM::WEXITED)
+    assert_equal child_pid, pid
+    assert_equal 42, status
+  ensure
+    Process.wait(child_pid) rescue nil
+  end
+
+  def test_waitid_invalid_pid
+    assert_raises(Errno::ECHILD) {
+      machine.waitid(UM::P_PID, Process.pid + 1, UM::WEXITED)
+    }
+  end
+
+  def test_waitid_invalid_idtype
+    assert_raises(Errno::EINVAL) {
+      machine.waitid(1234, 0, UM::WEXITED)
+    }
+  end
+
+  def test_waitid_invalid_options
+    assert_raises(Errno::EINVAL) {
+      machine.waitid(P_ALL, 0, 1234)
+    }
+  end
+
+  def test_waitid_P_ALL
+    msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    child_pid = fork do
       m = UM.new
       m.write(wfd, msg)
       m.close(wfd)
       exit 42
     end
 
-    ret = machine.waitpid(pid, UM::WEXITED)
-    assert_kind_of Array, ret
-    assert_equal [pid, 42], ret
+    pid, status = machine.waitid(UM::P_ALL, 0, UM::WEXITED)
+    assert_equal child_pid, pid
+    assert_equal 42, status
+  ensure
+    Process.wait(child_pid) rescue nil
+  end
 
-    buf = +''
-    ret = machine.read(rfd, buf, 8192)
-    assert_equal msg.bytesize, ret
-    assert_equal msg, buf
+  def test_waitid_P_PGID
+    msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    child_pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
+
+    pid, status = machine.waitid(UM::P_PGID, Process.getpgrp, UM::WEXITED)
+    assert_equal child_pid, pid
+    assert_equal 42, status
   ensure
-    Process.wait(pid) rescue Errno::ECHILD
+    Process.wait(child_pid) rescue nil
   end
 
-  def test_waitpid_any
-    skip if UM.kernel_version < 607
+  def test_waitid_status
+    skip if !machine.respond_to?(:waitid_status)
 
     msg = 'hello from child'
-
-    rfd, wfd = UM.pipe
+    _rfd, wfd = UM.pipe
     pid = fork do
       m = UM.new
       m.write(wfd, msg)
@@ -1405,23 +2003,76 @@ class WaitTest < UMBaseTest
       exit 42
     end
 
-    ret = machine.waitpid(0, UM::WEXITED)
-    assert_kind_of Array, ret
-    assert_equal [pid, 42], ret
+    status = machine.waitid_status(UM::P_PID, pid, UM::WEXITED)
+    assert_kind_of Process::Status, status
+    assert_equal pid, status.pid
+    assert_equal 42, status.exitstatus
+  ensure
+    Process.wait(pid) rescue nil
+  end
 
-    buf = +''
-    ret = machine.read(rfd, buf, 8192)
-    assert_equal msg.bytesize, ret
-    assert_equal msg, buf
+  def test_waitid_status_invalid_pid
+    skip if !machine.respond_to?(:waitid_status)
+
+    assert_raises(Errno::ECHILD) {
+      machine.waitid_status(UM::P_PID, Process.pid + 1, UM::WEXITED)
+    }
+  end
+
+  def test_waitid_status_invalid_idtype
+    skip if !machine.respond_to?(:waitid_status)
+
+    assert_raises(Errno::EINVAL) {
+      machine.waitid_status(1234, 0, UM::WEXITED)
+    }
+  end
+
+  def test_waitid_status_invalid_options
+    skip if !machine.respond_to?(:waitid_status)
 
+    assert_raises(Errno::EINVAL) {
+      machine.waitid_status(P_ALL, 0, 1234)
+    }
+  end
+
+  def test_waitid_status_P_ALL
+    skip if !machine.respond_to?(:waitid_status)
+
+    msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
+
+    status = machine.waitid_status(UM::P_ALL, 0, UM::WEXITED)
+    assert_kind_of Process::Status, status
+    assert_equal pid, status.pid
+    assert_equal 42, status.exitstatus
   ensure
-    Process.wait(pid) rescue Errno::ECHILD
+    Process.wait(pid) rescue nil
   end
 
-  def test_waitpid_bad_pid
-    skip if UM.kernel_version < 607
+  def test_waitid_status_P_PGID
+    skip if !machine.respond_to?(:waitid_status)
 
-    assert_raises(Errno::ECHILD) { machine.waitpid(1, UM::WEXITED) }
+    msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
+
+    status = machine.waitid_status(UM::P_PGID, Process.getpgrp, UM::WEXITED)
+    assert_kind_of Process::Status, status
+    assert_equal pid, status.pid
+    assert_equal 42, status.exitstatus
+  ensure
+    Process.wait(pid) rescue nil
   end
 end
 
@@ -1509,7 +2160,7 @@ class ForkTest < UMBaseTest
     assert_equal 3, ret
     assert_equal 'foo', buf
   ensure
-    Process.wait(child_pid) rescue Errno::ECHILD
+    Process.wait(child_pid) rescue nil
   end
 end
 
@@ -1573,3 +2224,20 @@ class SendBundleTest < UMBaseTest
     assert_equal strs.map(&:to_s).join, buf
   end
 end
+
+class NonBlockTest < UMBaseTest
+  def test_io_nonblock?
+    assert_equal false, UM.io_nonblock?(STDIN)
+  end
+
+  def test_io_set_nonblock
+    r, _w = IO.pipe
+    assert_equal true, UM.io_nonblock?(r)
+
+    UM.io_set_nonblock(r, false)
+    assert_equal false, UM.io_nonblock?(r)
+
+    UM.io_set_nonblock(r, true)
+    assert_equal true, UM.io_nonblock?(r)
+  end
+end