uringmachine 0.3 → 0.5

data/test/test_um.rb

@@ -3,13 +3,37 @@
 require_relative 'helper'
 require 'socket'
 
-class SchedulingTest < UMBaseTest
+class UringMachineTest < Minitest::Test
+  def test_kernel_version
+    v = UringMachine.kernel_version
+    assert_kind_of Integer, v
+    assert_in_range 600..700, v
+  end
+end
+
+class FiberTest < UMBaseTest
+  def test_spin
+    x = nil
+    f = machine.spin do
+      x = :foo
+    end
+
+    assert_kind_of Fiber, f
+    assert_nil x
+
+    machine.snooze
+
+    assert_equal :foo, x
+  end
+end
+
+class ScheduleTest < UMBaseTest
   def test_schedule_and_yield
     buf = []
-    cur = Fiber.current
+    main = Fiber.current
     f = Fiber.new do |x|
       buf << [21, x]
-      machine.schedule(cur, 21)
+      machine.schedule(main, 21)
       buf << 22
       x = machine.yield
       buf << [23, x]
@@ -49,12 +73,11 @@ class SchedulingTest < UMBaseTest
     assert_equal [e], buf
   end
 
-  def test_interrupt
-    cur = Fiber.current
+  def test_schedule_exception2
+    main = Fiber.current
     e = CustomError.new
     f = Fiber.new do
-      machine.interrupt(cur, e)
-      assert_equal 2, machine.pending_count
+      machine.schedule(main, e)
       machine.yield
     end
     
@@ -62,17 +85,11 @@ class SchedulingTest < UMBaseTest
     t0 = monotonic_clock
 
     # the call to schedule means an op is checked out
-    assert_equal 1, machine.pending_count
+    assert_equal 0, machine.pending_count
     begin
       machine.sleep(1)
     rescue Exception => e2
     end
-    # the sleep op has been cancelled, but we still need to process the
-    # cancellation. Calling snooze should take care of that.
-    assert_equal 1, machine.pending_count
-    machine.snooze
-
-    # CQE should have been received, and the op checked in
     assert_equal 0, machine.pending_count
     t1 = monotonic_clock
 
@@ -96,13 +113,7 @@ class SchedulingTest < UMBaseTest
       buf << 5
     end
 
-    # at this point, the sleep cancelled CQE should not yet have been received.
-    # So we still have a pending operation. Snooze should have let the CQE be
-    # received.
-    assert_equal 1, machine.pending_count
-    machine.snooze
     assert_equal 0, machine.pending_count
-
     assert_equal [1, 2, 5], buf
     assert_kind_of TOError, e
   end
@@ -117,7 +128,7 @@ class SchedulingTest < UMBaseTest
     end
 
     assert_equal 1, machine.pending_count
-    machine.snooze
+    machine.sleep(0.01) # wait for cancelled CQEs
     assert_equal 0, machine.pending_count
 
     assert_kind_of RuntimeError, e
@@ -130,7 +141,7 @@ class SchedulingTest < UMBaseTest
     assert_equal 42, v
 
     assert_equal 1, machine.pending_count
-    machine.snooze
+    machine.sleep 0.01 # wait for cancelled CQE
     assert_equal 0, machine.pending_count
   end
 
@@ -152,6 +163,10 @@ class SchedulingTest < UMBaseTest
     rescue => e
     end
 
+    assert_equal 2, machine.pending_count
+    machine.sleep(0.01) # wait for cancelled CQEs
+    assert_equal 0, machine.pending_count
+
     assert_kind_of TO2Error, e
     assert_equal [3], buf
   end
@@ -160,11 +175,41 @@ end
 class SleepTest < UMBaseTest
   def test_sleep
     t0 = monotonic_clock
+    assert_equal 0, machine.pending_count
     res = machine.sleep(0.1)
+    assert_equal 0, machine.pending_count
     t1 = monotonic_clock
     assert_in_range 0.09..0.13, t1 - t0
     assert_equal 0.1, res
   end
+
+  class C; end
+
+  def test_sleep_interrupted
+    t0 = monotonic_clock
+    ret = machine.timeout(0.03, C) do
+      machine.sleep 1
+    end
+    t1 = monotonic_clock
+    assert_in_range 0.02..0.04, t1 - t0
+    assert_kind_of C, ret
+  end
+
+  class D < RuntimeError; end
+
+  def test_sleep_with_timeout
+    t0 = monotonic_clock
+    ret = begin
+      machine.timeout(0.03, D) do
+        machine.sleep 1
+      end
+    rescue => e
+      e
+    end
+    t1 = monotonic_clock
+    assert_in_range 0.02..0.04, t1 - t0
+    assert_kind_of D, ret
+  end
 end
 
 class ReadTest < UMBaseTest
@@ -173,7 +218,9 @@ class ReadTest < UMBaseTest
     w << 'foobar'
 
     buf = +''
+    assert_equal 0, machine.pending_count
     res = machine.read(r.fileno, buf, 3)
+    assert_equal 0, machine.pending_count
     assert_equal 3, res
     assert_equal 'foo', buf
 
@@ -195,6 +242,7 @@ class ReadTest < UMBaseTest
     assert_raises(Errno::EBADF) do
       machine.read(w.fileno, +'', 8192)
     end
+    assert_equal 0, machine.pending_count
   end
 
   def test_read_with_buffer_offset
@@ -230,22 +278,24 @@ end
 
 class ReadEachTest < UMBaseTest
   def test_read_each
+    skip if UringMachine.kernel_version < 607
+
     r, w = IO.pipe
     bufs = []
-
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
 
     f = Fiber.new do
       w << 'foo'
-      machine.snooze
+      machine.sleep 0.02
       w << 'bar'
-      machine.snooze
+      machine.sleep 0.02
       w << 'baz'
-      machine.snooze
+      machine.sleep 0.02
       w.close
       machine.yield
     end
+    
     machine.schedule(f, nil)
 
     machine.read_each(r.fileno, bgid) do |buf|
@@ -258,8 +308,9 @@ class ReadEachTest < UMBaseTest
 
   # send once and close write fd
   def test_read_each_raising_1
-    r, w = IO.pipe
+    skip if UringMachine.kernel_version < 607
 
+    r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
 
@@ -281,8 +332,9 @@ class ReadEachTest < UMBaseTest
 
   # send once and leave write fd open
   def test_read_each_raising_2
-    r, w = IO.pipe
+    skip if UringMachine.kernel_version < 607
 
+    r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
 
@@ -299,17 +351,15 @@ class ReadEachTest < UMBaseTest
     assert_kind_of RuntimeError, e
     assert_equal 'hi', e.message
 
-    # since the write fd is still open, the read_each impl is supposed to cancel
-    # the op, which is done asynchronously.
-    assert_equal 1, machine.pending_count
-    machine.snooze
+    machine.snooze # in case the final CQE has not yet arrived
     assert_equal 0, machine.pending_count
   end
 
   # send twice
   def test_read_each_raising_3
-    r, w = IO.pipe
+    skip if UringMachine.kernel_version < 607
 
+    r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
 
@@ -327,19 +377,55 @@ class ReadEachTest < UMBaseTest
     assert_kind_of RuntimeError, e
     assert_equal 'hi', e.message
 
-    # since the write fd is still open, the read_each impl is supposed to cancel
-    # the op, which is done asynchronously.
-    assert_equal 1, machine.pending_count
-    machine.snooze
+    machine.snooze # in case the final CQE has not yet arrived
     assert_equal 0, machine.pending_count
   end
+
+  def test_read_each_break
+    skip if UringMachine.kernel_version < 607
+
+    r, w = IO.pipe
+    bgid = machine.setup_buffer_ring(4096, 1024)
+
+    t = Thread.new do
+      sleep 0.1
+      w << 'foo'
+      sleep 0.1
+      w.close
+    end
+    
+    bufs = []
+    machine.read_each(r.fileno, bgid) do |b|
+      bufs << b
+      break
+    end
+
+    assert_equal ['foo'], bufs
+    machine.snooze # in case the final CQE has not yet arrived
+    assert_equal 0, machine.pending_count
+  ensure
+    t&.kill
+  end
+
+  def test_read_each_bad_file
+    skip if UringMachine.kernel_version < 607
+
+    _r, w = IO.pipe
+    bgid = machine.setup_buffer_ring(4096, 1024)
+
+    assert_raises(Errno::EBADF) do
+      machine.read_each(w.fileno, bgid)
+    end
+  end
 end
 
 class WriteTest < UMBaseTest
   def test_write
     r, w = IO.pipe
 
+    assert_equal 0, machine.pending_count
     machine.write(w.fileno, 'foo')
+    assert_equal 0, machine.pending_count
     assert_equal 'foo', r.readpartial(3)
 
     machine.write(w.fileno, 'bar', 2)
@@ -349,16 +435,33 @@ class WriteTest < UMBaseTest
   def test_write_bad_fd
     r, _w = IO.pipe
 
+    assert_equal 0, machine.pending_count
     assert_raises(Errno::EBADF) do
       machine.write(r.fileno, 'foo')
     end
+    assert_equal 0, machine.pending_count
+  end
+end
+
+class Closetest < UMBaseTest
+  def test_close
+    r, w = IO.pipe
+    machine.write(w.fileno, 'foo')
+    assert_equal 'foo', r.readpartial(3)
+
+    assert_equal 0, machine.pending_count
+    machine.close(w.fileno)
+    assert_equal 0, machine.pending_count
+    assert_equal '', r.read
+
+    assert_raises(Errno::EBADF) { machine.close(w.fileno) }
   end
 end
 
 class AcceptTest < UMBaseTest
   def setup
     super
-    @port = 9000 + rand(1000)
+    @port = assign_port
     @server = TCPServer.open('127.0.0.1', @port)
   end
 
@@ -370,7 +473,9 @@ class AcceptTest < UMBaseTest
   def test_accept
     conn = TCPSocket.new('127.0.0.1', @port)
     
+    assert_equal 0, machine.pending_count
     fd = machine.accept(@server.fileno)
+    assert_equal 0, machine.pending_count
     assert_kind_of Integer, fd
     assert fd > 0
 
@@ -384,7 +489,7 @@ end
 class AcceptEachTest < UMBaseTest
   def setup
     super
-    @port = 9000 + rand(1000)
+    @port = assign_port
     @server = TCPServer.open('127.0.0.1', @port)
   end
 
@@ -394,21 +499,555 @@ class AcceptEachTest < UMBaseTest
   end
 
   def test_accept_each
-    conns = 3.times.map { TCPSocket.new('127.0.0.1', @port) }
+    conns = []
+    t = Thread.new do
+      sleep 0.05
+      3.times { conns << TCPSocket.new('127.0.0.1', @port) }
+    end
 
     count = 0
     machine.accept_each(@server.fileno) do |fd|
-      machine.write(fd, (count += 1).to_s)
+      count += 1
       break if count == 3
     end
 
     assert_equal 3, count
-    assert_equal 1, machine.pending_count
-    machine.snooze
     assert_equal 0, machine.pending_count
+  ensure
+    t&.kill
+  end
+end
+
+class SocketTest < UMBaseTest
+  def test_socket
+    assert_equal 0, machine.pending_count
+    fd = machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0);
+    assert_equal 0, machine.pending_count
+    assert_kind_of Integer, fd
+    assert fd > 0
+
+    assert_raises(Errno::EDESTADDRREQ) { machine.write(fd, 'foo') }
+  end
+end
+
+class ConnectTest < UMBaseTest
+  def setup
+    super
+    @port = assign_port
+    @server = TCPServer.open('127.0.0.1', @port)
+  end
+
+  def teardown
+    @server&.close
+    super
+  end
+
+  def test_connect
+    t = Thread.new do
+      conn = @server.accept
+      conn.write('foobar')
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    assert_equal 0, machine.pending_count
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, machine.pending_count
+    assert_equal 0, res
+
+    buf = +''
+    res = machine.read(fd, buf, 42)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  ensure
+    t&.kill
+  end
+
+  def test_connect_with_bad_addr
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0);
+    assert_equal 0, machine.pending_count
+    assert_raises(Errno::ENETUNREACH) { machine.connect(fd, 'a.b.c.d', @port) }
+    assert_equal 0, machine.pending_count
+  end
+end
+
+class SendTest < UMBaseTest
+  def setup
+    super
+    @port = assign_port
+    @server = TCPServer.open('127.0.0.1', @port)
+  end
+
+  def teardown
+    @server&.close
+    super
+  end
+
+  def test_send
+    t = Thread.new do
+      conn = @server.accept
+      str = conn.readpartial(42)
+      conn.write("You said: #{str}")
+      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
+
+    res = machine.send(fd, 'foobar', 6, 0)
+    assert_equal 6, res
+
+    buf = +''
+    res = machine.read(fd, buf, 42)
+    assert_equal 16, res
+    assert_equal 'You said: foobar', buf
+  ensure
+    t&.kill
+  end
+end
+
+class RecvTest < UMBaseTest
+  def setup
+    super
+    @port = assign_port
+    @server = TCPServer.open('127.0.0.1', @port)
+  end
+
+  def teardown
+    @server&.close
+    super
+  end
+
+  def test_recv
+    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 = +''
+    res = machine.recv(fd, buf, 42, 0)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  ensure
+    t&.kill
+  end
+end
+
+class RecvEachTest < UMBaseTest
+  def setup
+    super
+    @port = assign_port
+    @server = TCPServer.open('127.0.0.1', @port)
+  end
+
+  def teardown
+    @server&.close
+    super
+  end
+
+  def test_recv_each
+    t = Thread.new do
+      conn = @server.accept
+      conn.write('abc')
+      sleep 0.01
+      conn.write('def')
+      sleep 0.01
+      conn.write('ghi')
+      sleep 0.01
+      conn.close
+      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
+
+    bgid = machine.setup_buffer_ring(4096, 1024)
+    assert_equal 0, bgid
+
+    bgid2 = machine.setup_buffer_ring(4096, 1024)
+    assert_equal 1, bgid2
+
+    bufs = []
+
+    machine.recv_each(fd, bgid, 0) do |buf|
+      bufs << buf
+    end
+    assert_equal ['abc', 'def', 'ghi'], bufs
+  ensure
+    t&.kill
+  end
+end
+
+class BindTest < UMBaseTest
+  def setup
+    super
+    @port = assign_port
+  end
+
+  def test_bind
+    assert_equal 0, machine.pending_count
+    fd = machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0)
+    res = machine.bind(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+    assert_equal 0, machine.pending_count
+
+    peer = UDPSocket.new
+    peer.connect('127.0.0.1', @port)
+    peer.send 'foo', 0
+
+    buf = +''
+    res = machine.recv(fd, buf, 8192, 0)
+    assert_equal 3, res
+    assert_equal 'foo', buf
+  end
+
+  def test_bind_invalid_args
+    assert_equal 0, machine.pending_count
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0)
+    assert_raises(Errno::EACCES) { machine.bind(fd, 'foo.bar.baz', 3) }
+    assert_raises(Errno::EBADF) { machine.bind(-3, '127.0.01', 1234) }
+
+    assert_equal 0, machine.pending_count
+  end
+end
+
+class ListenTest < UMBaseTest
+  def setup
+    super
+    @port = assign_port
+  end
+
+  def test_listen
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    machine.bind(fd, '127.0.0.1', @port)
+    res = machine.listen(fd, 5)
+    assert_equal 0, res
+    assert_equal 0, machine.pending_count
+
+    conn = nil
+    t = Thread.new do
+      sleep 0.01
+      conn = TCPSocket.new('127.0.0.1', @port)
+    end
+
+    conn_fd = machine.accept(fd)
+    t.join
+    assert_kind_of TCPSocket, conn
+
+    machine.send(conn_fd, 'foo', 3, 0)
+
+    buf = conn.readpartial(42)
+    assert_equal 'foo', buf
+  ensure
+    t&.kill
+  end
+end
+
+class ConstTest < UMBaseTest
+  def test_constants
+    assert_equal UM::SOCK_STREAM, UM::SOCK_STREAM
+  end
+end
+
+class GetSetSockOptTest < UMBaseTest
+  def test_getsockopt_setsockopt
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    reuseaddr = machine.getsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR)
+    assert_equal 0, reuseaddr
+
+    res = machine.setsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    assert_equal 0, res
+
+    reuseaddr = machine.getsockopt(fd, UM::SOL_SOCKET, UM::SO_REUSEADDR)
+    assert_equal 1, reuseaddr
+  end
+end
+
+class SynchronizeTest < UMBaseTest
+  def test_synchronize_single
+    skip if !machine.respond_to?(:synchronize)
+
+    m = UM::Mutex.new
+
+    buf = []
+    machine.synchronize(m) do
+      buf << 1
+    end
+    machine.synchronize(m) do
+      buf << 2
+    end
+
+    assert_equal [1, 2], buf
+    assert_equal 0, machine.pending_count
+  end
+
+  def test_synchronize_pair
+    skip if !machine.respond_to?(:synchronize)
+    m = UM::Mutex.new
+
+    buf = []
+
+    f1 = Fiber.new do
+      machine.synchronize(m) do
+        buf << 11
+        machine.sleep(0.01)
+        buf << 12
+      end
+      buf << 13
+      machine.yield
+    end
+
+    f2 = Fiber.new do
+      machine.synchronize(m) do
+        buf << 21
+        machine.sleep(0.01)
+        buf << 22
+      end
+      buf << 23
+      machine.yield
+    end
+
+    machine.schedule(f1, nil)
+    machine.schedule(f2, nil)
+
+    machine.sleep(0.03)
+    assert_equal [11, 12, 13, 21, 22, 23], buf
+    assert_equal 0, machine.pending_count
+  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)
+    machine.push(q, :bar)
+    assert_equal 2, q.count
+
+    assert_equal :bar, machine.pop(q)
+    assert_equal 1, q.count
+    assert_equal :foo, machine.pop(q)
+    assert_equal 0, q.count
+  end
+
+  def test_push_pop_2
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+    buf = []
 
-    assert_equal '1', conns[0].readpartial(3)
-    assert_equal '2', conns[1].readpartial(3)
-    assert_equal '3', conns[2].readpartial(3)
+    f1 = Fiber.new do
+      buf << [1, machine.pop(q)]
+      machine.yield
+    end
+
+    machine.schedule(f1, nil)
+
+    f2 = Fiber.new do
+      buf << [2, machine.pop(q)]
+      machine.yield
+    end
+
+    machine.schedule(f2, nil)
+
+    machine.snooze
+    assert_equal [], buf
+
+    machine.push(q, :foo)
+    assert_equal 1, q.count
+    machine.sleep(0.02)
+    assert_equal [[1, :foo]], buf
+
+    machine.push(q, :bar)
+    assert_equal 1, q.count
+
+    machine.sleep(0.02)
+    assert_equal [[1, :foo], [2, :bar]], buf
+    assert_equal 0, q.count
+  end
+
+  def test_push_pop_3
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+    buf = []
+
+    machine.push(q, :foo)
+    machine.push(q, :bar)
+    assert_equal 2, q.count
+
+    f1 = Fiber.new do
+      buf << [1, machine.pop(q)]
+      machine.yield
+    end
+    machine.schedule(f1, nil)
+
+    f2 = Fiber.new do
+      buf << [2, machine.pop(q)]
+      machine.yield
+    end
+    machine.schedule(f2, nil)
+
+    3.times { machine.snooze }
+
+    assert_equal [[1, :bar], [2, :foo]], buf.sort
+    assert_equal 0, q.count
+  end
+
+  def test_push_pop_4
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+    buf = []
+
+    machine.push(q, :foo)
+    assert_equal 1, q.count
+
+    f1 = Fiber.new do
+      buf << [1, machine.pop(q)]
+      machine.yield
+    end
+    machine.schedule(f1, nil)
+
+    f2 = Fiber.new do
+      buf << [2, machine.pop(q)]
+      machine.yield
+    end
+    machine.schedule(f2, nil)
+
+    machine.sleep 0.01
+
+    assert_equal [[1, :foo]], buf
+    machine.push(q, :bar)
+
+    machine.sleep 0.01
+    assert_equal [[1, :foo], [2, :bar]], buf
+  end
+
+  def test_push_shift_1
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+
+    machine.push(q, :foo)
+    machine.push(q, :bar)
+    machine.push(q, :baz)
+
+    assert_equal :foo, machine.shift(q)
+    assert_equal :bar, machine.shift(q)
+    assert_equal :baz, machine.shift(q)
+  end
+
+  def test_shift_shift_1
+    skip if !machine.respond_to?(:synchronize)
+
+    q = UM::Queue.new
+
+    machine.unshift(q, :foo)
+    machine.unshift(q, :bar)
+    machine.unshift(q, :baz)
+
+    assert_equal :baz, machine.shift(q)
+    assert_equal :bar, machine.shift(q)
+    assert_equal :foo, machine.shift(q)
   end
 end
+
+class OpenTest < UMBaseTest
+  PATH = '/tmp/um_open_test'
+
+  def setup
+    super
+    FileUtils.rm(PATH, force: true)
+  end
+
+  def test_open
+    fd = machine.open(PATH, UM::O_CREAT | UM::O_WRONLY)
+    assert_kind_of Integer, fd
+    assert File.file?(PATH)
+
+    machine.write(fd, 'foo')
+    machine.close(fd)
+
+    assert_equal 'foo', IO.read(PATH)
+  end
+
+  def test_open_with_block
+    res = machine.open(PATH, UM::O_CREAT | UM::O_WRONLY) do |fd|
+      machine.write(fd, 'bar')
+      fd
+    end
+
+    assert_kind_of Integer, res
+    assert_raises(Errno::EBADF) { machine.close(res) }
+    assert_equal 'bar', IO.read(PATH)
+  end
+
+  def test_open_bad_arg
+    assert_raises(Errno::ENOENT) { machine.open(PATH, UM::O_RDONLY) }
+    assert_raises(Errno::ENOENT) { machine.open(PATH, UM::O_RDONLY) {} }
+  end
+end
+
+class PipeTest < UMBaseTest
+  def test_pipe
+    rfd, wfd = UM.pipe
+    ret = machine.write(wfd, 'foo')
+    assert_equal 3, ret
+    
+    ret = machine.close(wfd)
+    assert_equal wfd, ret
+
+    buf = +''
+    ret = machine.read(rfd, buf, 8192)
+
+    assert_equal 3, ret
+    assert_equal 'foo', buf
+
+    ret = machine.close(rfd)
+    assert_equal rfd, ret
+  end
+end
+
+class WaitTest < UMBaseTest
+  def test_waitpid
+    skip if UM.kernel_version < 607
+
+    msg = 'hello from child'
+
+    rfd, wfd = UM.pipe
+    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
+
+    buf = +''
+    ret = machine.read(rfd, buf, 8192)
+    assert_equal msg.bytesize, ret
+    assert_equal msg, buf
+  end
+
+  def test_waitpid_bad_pid
+    skip if UM.kernel_version < 607
+
+    assert_raises(Errno::ECHILD) { machine.waitpid(1, UM::WEXITED) }    
+  end
+
+end
+