uringmachine 0.20.0 → 0.22.0

data/test/test_um.rb

@@ -11,6 +11,82 @@ class UringMachineTest < Minitest::Test
   end
 end
 
+class SizeTest < Minitest::Test
+  def test_default_size
+    m = UM.new
+    assert_equal 4096, m.size
+  end
+
+  def test_custom_size_value
+    m = UM.new(13)
+    assert_equal 13, m.size
+  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
+
+    assert_equal 0, machine.pending_fibers.size
+    machine.write_async(w, 'foo')
+    machine.write_async(w, 'bar')
+    machine.write_async(w, 'baz')
+    assert_equal 0, machine.pending_fibers.size
+
+    assert_equal 3, machine.metrics[:ops_pending]
+    assert_equal 3, machine.submit
+    assert_equal 0, machine.submit
+    machine.snooze
+    assert_equal 0, machine.metrics[:ops_pending]
+  end
+end
+
 class SpinTest < UMBaseTest
   def test_spin
     x = nil
@@ -35,7 +111,7 @@ end
 
 class SnoozeTest < UMBaseTest
   def test_snooze_while_sleeping_fiber
-    machine.spin do
+    f = machine.spin do
       machine.sleep(0.1)
     end
 
@@ -48,6 +124,9 @@ class SnoozeTest < UMBaseTest
     machine.snooze
     t1 = monotonic_clock
     assert_in_range 0..0.001, t1 - t0
+  ensure
+    machine.schedule(f, nil)
+    machine.join(f)
   end
 end
 
@@ -59,7 +138,7 @@ class ScheduleTest < UMBaseTest
       buf << [21, x]
       machine.schedule(main, 21)
       buf << 22
-      x = machine.yield
+      x = machine.switch
       buf << [23, x]
     end
 
@@ -78,11 +157,10 @@ class ScheduleTest < UMBaseTest
   def test_schedule_exception
     buf = []
     f = Fiber.new do
-      # this should raise
-      machine.yield
+      machine.yield # this should raise
     rescue Exception => e
       buf << e
-      machine.yield
+      machine.switch
     end
 
     machine.schedule(f, nil)
@@ -102,19 +180,19 @@ class ScheduleTest < UMBaseTest
     e = CustomError.new
     f = Fiber.new do
       machine.schedule(main, e)
-      machine.yield
+      machine.switch
     end
 
     machine.schedule(f, nil)
     t0 = monotonic_clock
 
     # the call to schedule means an op is checked out
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     begin
       machine.sleep(1)
     rescue Exception => e2
     end
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     t1 = monotonic_clock
 
     assert_equal e2, e
@@ -137,7 +215,7 @@ class ScheduleTest < UMBaseTest
       buf << 5
     end
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal [1, 2, 5], buf
     assert_kind_of TOError, e
   end
@@ -176,9 +254,9 @@ class ScheduleTest < UMBaseTest
     rescue => e
     end
 
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     machine.sleep(0.01) # wait for cancelled CQEs
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
 
     assert_kind_of RuntimeError, e
     assert_equal 'hi', e.message
@@ -189,9 +267,9 @@ class ScheduleTest < UMBaseTest
 
     assert_equal 42, v
 
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     machine.sleep 0.01 # wait for cancelled CQE
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   def test_timeout_with_no_timeout
@@ -200,9 +278,9 @@ class ScheduleTest < UMBaseTest
 
     assert_equal 3, v
 
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     machine.sleep 0.01 # wait for cancelled CQE
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   class TO2Error < RuntimeError; end
@@ -215,7 +293,7 @@ class ScheduleTest < UMBaseTest
       machine.timeout(0.04, TOError) do
         machine.timeout(0.02, TO2Error) do
           machine.timeout(0.03, TO3Error) do
-            buf << machine.pending_count
+            buf << machine.metrics[:ops_pending]
             machine.sleep(1)
           end
         end
@@ -223,9 +301,9 @@ class ScheduleTest < UMBaseTest
     rescue => e
     end
 
-    assert_equal 2, machine.pending_count
+    assert_equal 2, machine.metrics[:ops_pending]
     machine.sleep(0.01) # wait for cancelled CQEs
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
 
     assert_kind_of TO2Error, e
     assert_equal [3], buf
@@ -235,9 +313,9 @@ end
 class SleepTest < UMBaseTest
   def test_sleep
     t0 = monotonic_clock
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     res = machine.sleep(0.1)
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     t1 = monotonic_clock
     assert_in_range 0.09..0.13, t1 - t0
     assert_equal 0.1, res
@@ -294,7 +372,7 @@ class PeriodicallyTest < UMBaseTest
     cancel = 0
 
     t0 = monotonic_clock
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     begin
       machine.periodically(0.01) do
         count += 1
@@ -304,7 +382,7 @@ class PeriodicallyTest < UMBaseTest
       cancel = 1
     end
     machine.snooze
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     t1 = monotonic_clock
     assert_in_range 0.05..0.09, t1 - t0
     assert_equal 5, count
@@ -316,7 +394,7 @@ class PeriodicallyTest < UMBaseTest
     cancel = 0
 
     t0 = monotonic_clock
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     begin
       machine.timeout(0.05, Cancel) do
         machine.periodically(0.01) do
@@ -327,25 +405,45 @@ class PeriodicallyTest < UMBaseTest
     rescue Cancel
       cancel = 1
     end
-    20.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.metrics[:ops_pending]
+    assert_equal 0, machine.metrics[:total_ops]
+    machine.write_async(w.fileno, 'foo')
+    assert_equal 1, machine.metrics[:ops_pending]
+    assert_equal 1, machine.metrics[:total_ops]
+    machine.snooze
+    assert_equal 0, machine.metrics[:ops_pending]
+    assert_equal 1, machine.metrics[:total_ops]
+
+    machine.write_async(w.fileno, 'foo')
+    assert_equal 1, machine.metrics[:ops_pending]
+    assert_equal 2, machine.metrics[:total_ops]
+    machine.snooze
+    assert_equal 0, machine.metrics[:ops_pending]
+    assert_equal 2, machine.metrics[:total_ops]
+  end
+end
+
 class ReadTest < UMBaseTest
   def test_read
     r, w = IO.pipe
     w << 'foobar'
 
     buf = +''
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     res = machine.read(r.fileno, buf, 3)
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 3, res
     assert_equal 'foo', buf
 
@@ -367,7 +465,7 @@ class ReadTest < UMBaseTest
     assert_raises(Errno::EBADF) do
       machine.read(w.fileno, +'', 8192)
     end
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   def test_read_with_buffer_offset
@@ -464,6 +562,20 @@ class ReadTest < UMBaseTest
       machine.read(r, [])
     }
   end
+
+  def test_read_with_file_offset
+    fn = "/tmp/um_#{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)
+    FileUtils.rm(fn) rescue nil
+  end
 end
 
 class ReadEachTest < UMBaseTest
@@ -483,7 +595,7 @@ class ReadEachTest < UMBaseTest
       w << 'baz'
       machine.sleep 0.02
       w.close
-      machine.yield
+      machine.switch
     end
 
     machine.schedule(f, nil)
@@ -493,7 +605,7 @@ class ReadEachTest < UMBaseTest
     end
 
     assert_equal ['foo', 'bar', 'baz'], bufs
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   # send once and close write fd
@@ -517,7 +629,7 @@ class ReadEachTest < UMBaseTest
 
     assert_kind_of RuntimeError, e
     assert_equal 'hi', e.message
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   # send once and leave write fd open
@@ -542,7 +654,7 @@ class ReadEachTest < UMBaseTest
     assert_equal 'hi', e.message
 
     machine.snooze # in case the final CQE has not yet arrived
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   # send twice
@@ -568,7 +680,7 @@ class ReadEachTest < UMBaseTest
     assert_equal 'hi', e.message
 
     machine.snooze # in case the final CQE has not yet arrived
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   def test_read_each_break
@@ -592,7 +704,7 @@ class ReadEachTest < UMBaseTest
 
     assert_equal ['foo'], bufs
     machine.snooze # in case the final CQE has not yet arrived
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   ensure
     t&.kill
   end
@@ -613,23 +725,43 @@ 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 0, machine.metrics[:ops_pending]
+    res = machine.write(w.fileno, 'foo')
+    assert_equal 3, res
+    assert_equal 0, machine.metrics[:ops_pending]
     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
 
   def test_write_bad_fd
     r, _w = IO.pipe
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_raises(Errno::EBADF) do
       machine.write(r.fileno, 'foo')
     end
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
+  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
@@ -679,45 +811,58 @@ class WriteTest < UMBaseTest
       machine.write(w, [])
     }
   end
+
+  def test_write_with_file_offset
+    fn = "/tmp/um_#{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)
+    FileUtils.rm(fn) rescue nil
+  end
 end
 
 class WriteAsyncTest < UMBaseTest
   def test_write_async
     r, w = IO.pipe
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     machine.write_async(w.fileno, 'foo')
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
 
-    machine.snooze
-    assert_equal 0, machine.pending_count
+    machine.snooze while machine.metrics[:ops_pending] > 0
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 'foo', r.readpartial(3)
   end
 
   def test_write_async_dynamic_string
     r, w = IO.pipe
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     str = "foo#{123}#{'bar' * 48}"
     len = str.bytesize
     machine.write_async(w.fileno, str)
     str = nil
-    GC.start
-    assert_equal 1, machine.pending_count
+    # GC.start
+    assert_equal 1, machine.metrics[:ops_pending]
 
-    machine.snooze
-    assert_equal 0, machine.pending_count
+    machine.snooze while machine.metrics[:ops_pending] > 0
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal "foo#{123}#{'bar' * 48}", r.readpartial(len)
   end
 
   def test_write_async_bad_fd
     r, _w = IO.pipe
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     machine.write_async(r.fileno, 'foo')
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     machine.snooze
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   def test_write_async_io_buffer
@@ -728,7 +873,7 @@ class WriteAsyncTest < UMBaseTest
     write_buffer.set_string(msg)
 
     machine.write_async(w, write_buffer)
-    3.times { machine.snooze }
+    machine.snooze while machine.metrics[:ops_pending] > 0
     machine.close(w)
 
     str = +''
@@ -741,6 +886,33 @@ class WriteAsyncTest < UMBaseTest
 
     assert_raises(UM::Error) { machine.write_async(w, []) }
   end
+
+  def test_write_async_with_len
+    r, w = IO.pipe
+
+    assert_equal 0, machine.metrics[:ops_pending]
+    machine.write_async(w.fileno, 'foobar', 4)
+
+    assert_equal 1, machine.metrics[:ops_pending]
+    machine.snooze while machine.metrics[:ops_pending] > 0
+    assert_equal 0, machine.metrics[:ops_pending]
+    assert_equal 'foob', r.readpartial(6)
+  end
+
+  def test_write_async_with_file_offset
+    fn = "/tmp/um_#{SecureRandom.hex}"
+    IO.write(fn, 'foobar')
+
+    fd = machine.open(fn, UM::O_WRONLY)
+    machine.write_async(fd, 'baz', -1, 2)
+
+    assert_equal 1, machine.metrics[:ops_pending]
+    machine.snooze while machine.metrics[:ops_pending] > 0
+    assert_equal 'fobazr', IO.read(fn)
+  ensure
+    machine.close(fd)
+    FileUtils.rm(fn) rescue nil
+  end
 end
 
 class CloseTest < UMBaseTest
@@ -749,9 +921,9 @@ class CloseTest < UMBaseTest
     machine.write(w.fileno, 'foo')
     assert_equal 'foo', r.readpartial(3)
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     machine.close(w.fileno)
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal '', r.read
 
     assert_raises(Errno::EBADF) { machine.close(w.fileno) }
@@ -771,18 +943,18 @@ class CloseAsyncTest < UMBaseTest
     machine.write(w.fileno, 'foo')
     assert_equal 'foo', r.readpartial(3)
 
-    assert_equal 0, machine.pending_count
-    machine.close_async(w.fileno)
-    assert_equal 1, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
+    machine.close_async(w.fileno) # fire and forget
+    assert_equal 1, machine.metrics[:ops_pending]
     machine.snooze
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal '', r.read
   end
 end
 
 class ShutdownTest < UMBaseTest
   def test_shutdown
-    c_fd, s_fd = make_socket_pair
+    c_fd, s_fd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
     res = @machine.send(c_fd, 'abc', 3, 0)
     assert_equal 3, res
 
@@ -814,7 +986,7 @@ end
 
 class ShutdownAsyncTest < UMBaseTest
   def test_shutdown_async
-    c_fd, s_fd = make_socket_pair
+    c_fd, s_fd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
     res = @machine.send(c_fd, 'abc', 3, 0)
     assert_equal 3, res
 
@@ -858,9 +1030,9 @@ class AcceptTest < UMBaseTest
   def test_accept
     conn = TCPSocket.new('127.0.0.1', @port)
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     fd = machine.accept(@server.fileno)
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_kind_of Integer, fd
     assert fd > 0
 
@@ -897,7 +1069,7 @@ class AcceptEachTest < UMBaseTest
     end
 
     assert_equal 3, count
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   ensure
     t&.kill
   end
@@ -932,9 +1104,9 @@ end
 
 class SocketTest < UMBaseTest
   def test_socket
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     fd = machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0);
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_kind_of Integer, fd
     assert fd > 0
 
@@ -962,9 +1134,9 @@ class ConnectTest < UMBaseTest
     end
 
     fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     res = machine.connect(fd, '127.0.0.1', @port)
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 0, res
 
     buf = +''
@@ -977,9 +1149,9 @@ class ConnectTest < UMBaseTest
 
   def test_connect_with_bad_addr
     fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0);
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_raises(Errno::ENETUNREACH) { machine.connect(fd, 'a.b.c.d', @port) }
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 end
 
@@ -1195,11 +1367,11 @@ class BindTest < UMBaseTest
   end
 
   def test_bind
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     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
+    assert_equal 0, machine.metrics[:ops_pending]
 
     peer = UDPSocket.new
     peer.connect('127.0.0.1', @port)
@@ -1212,13 +1384,13 @@ class BindTest < UMBaseTest
   end
 
   def test_bind_invalid_args
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
 
     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
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 end
 
@@ -1233,7 +1405,7 @@ class ListenTest < UMBaseTest
     machine.bind(fd, '127.0.0.1', @port)
     res = machine.listen(fd, 5)
     assert_equal 0, res
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
 
     conn = nil
     t = Thread.new do
@@ -1276,8 +1448,6 @@ end
 
 class SynchronizeTest < UMBaseTest
   def test_synchronize_single
-    skip if !machine.respond_to?(:synchronize)
-
     m = UM::Mutex.new
 
     buf = []
@@ -1289,13 +1459,11 @@ class SynchronizeTest < UMBaseTest
     end
 
     assert_equal [1, 2], buf
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   def test_synchronize_pair
-    skip if !machine.respond_to?(:synchronize)
     m = UM::Mutex.new
-
     buf = []
 
     f1 = Fiber.new do
@@ -1305,7 +1473,7 @@ class SynchronizeTest < UMBaseTest
         buf << 12
       end
       buf << 13
-      machine.yield
+      machine.switch
     end
 
     f2 = Fiber.new do
@@ -1315,7 +1483,7 @@ class SynchronizeTest < UMBaseTest
         buf << 22
       end
       buf << 23
-      machine.yield
+      machine.switch
     end
 
     machine.schedule(f1, nil)
@@ -1323,7 +1491,7 @@ class SynchronizeTest < UMBaseTest
 
     machine.sleep(0.03)
     assert_equal [11, 12, 13, 21, 22, 23], buf
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 
   def test_synchronize_multi
@@ -1348,8 +1516,6 @@ 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)
@@ -1363,8 +1529,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_2
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1378,12 +1542,12 @@ class QueueTest < UMBaseTest
 
     machine.snooze
     assert_equal [], buf
-    assert_equal 2, machine.pending_count
+    assert_equal 2, machine.metrics[:ops_pending]
 
     machine.push(q, :foo)
     assert_equal 1, q.count
     machine.snooze
-    assert_equal 1, machine.pending_count
+    assert_equal 1, machine.metrics[:ops_pending]
     assert_equal [[1, :foo]], buf
 
     machine.push(q, :bar)
@@ -1395,8 +1559,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_3
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1406,13 +1568,13 @@ class QueueTest < UMBaseTest
 
     f1 = Fiber.new do
       buf << [1, machine.pop(q)]
-      machine.yield
+      machine.switch
     end
     machine.schedule(f1, nil)
 
     f2 = Fiber.new do
       buf << [2, machine.pop(q)]
-      machine.yield
+      machine.switch
     end
     machine.schedule(f2, nil)
 
@@ -1423,8 +1585,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_pop_4
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
     buf = []
 
@@ -1433,13 +1593,13 @@ class QueueTest < UMBaseTest
 
     f1 = Fiber.new do
       buf << [1, machine.pop(q)]
-      machine.yield
+      machine.switch
     end
     machine.schedule(f1, nil)
 
     f2 = Fiber.new do
       buf << [2, machine.pop(q)]
-      machine.yield
+      machine.switch
     end
     machine.schedule(f2, nil)
 
@@ -1452,8 +1612,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_push_shift_1
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
 
     machine.push(q, :foo)
@@ -1466,8 +1624,6 @@ class QueueTest < UMBaseTest
   end
 
   def test_shift_shift_1
-    skip if !machine.respond_to?(:synchronize)
-
     q = UM::Queue.new
 
     machine.unshift(q, :foo)
@@ -1479,6 +1635,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
 
@@ -1502,41 +1667,79 @@ 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
-  PATH = '/tmp/um_open_test'
-
   def setup
     super
-    FileUtils.rm(PATH, force: true)
+    @fn = "/tmp/um_#{SecureRandom.hex}"
+  end
+
+  def teardown
+    FileUtils.rm(@fn) rescue nil
   end
 
   def test_open
-    fd = machine.open(PATH, UM::O_CREAT | UM::O_WRONLY)
+    fd = machine.open(@fn, UM::O_CREAT | UM::O_WRONLY)
     assert_kind_of Integer, fd
-    assert File.file?(PATH)
+    assert File.file?(@fn)
 
     machine.write(fd, 'foo')
     machine.close(fd)
 
-    assert_equal 'foo', IO.read(PATH)
+    assert_equal 'foo', IO.read(@fn)
   end
 
   def test_open_with_block
-    res = machine.open(PATH, UM::O_CREAT | UM::O_WRONLY) do |fd|
+    res = machine.open(@fn, 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)
+    assert_equal 'bar', IO.read(@fn)
   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) {} }
+    assert_raises(Errno::ENOENT) { machine.open(@fn, UM::O_RDONLY) }
+    assert_raises(Errno::ENOENT) { machine.open(@fn, UM::O_RDONLY) {} }
   end
 end
 
@@ -1560,6 +1763,26 @@ class PipeTest < UMBaseTest
   end
 end
 
+class SocketpairTest < UMBaseTest
+  def test_socketpair
+    rfd, wfd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
+    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 PidfdTest < UMBaseTest
   def test_pidfd_open
     pid = fork { exit 13 }
@@ -1646,6 +1869,85 @@ class PollTest < UMBaseTest
   end
 end
 
+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'
@@ -1892,7 +2194,7 @@ end
 class SendBundleTest < UMBaseTest
   def setup
     super
-    @client_fd, @server_fd = make_socket_pair
+    @client_fd, @server_fd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
   end
 
   def test_send_bundle_splat
@@ -1966,3 +2268,153 @@ class NonBlockTest < UMBaseTest
     assert_equal true, UM.io_nonblock?(r)
   end
 end
+
+class MetricsTest < UMBaseTest
+  def test_metrics_empty
+    assert_equal({
+      size:             4096,
+      total_ops:        0,
+      total_switches:   0,
+      total_waits:      0,
+      ops_pending:      0,
+      ops_unsubmitted:  0,
+      ops_runqueue:     0,
+      ops_free:         0,
+      ops_transient:    0
+    }, machine.metrics)
+  end
+
+  def test_metrics_size
+    m = UM.new(13)
+    assert_equal 13, m.metrics[:size]
+  end
+
+  def test_metrics_total_counters
+    r, w = UM.pipe
+    machine.write(w, 'foo')
+    assert_equal 1, machine.metrics[:total_ops]
+    assert_equal 1, machine.metrics[:total_switches]
+    assert_equal 1, machine.metrics[:total_waits]
+    machine.write_async(w, 'bar')
+    assert_equal 2, machine.metrics[:total_ops]
+    assert_equal 1, machine.metrics[:total_switches]
+    assert_equal 1, machine.metrics[:total_waits]
+    machine.snooze
+    assert_equal 2, machine.metrics[:total_ops]
+    assert_equal 2, machine.metrics[:total_switches]
+    assert_equal 2, machine.metrics[:total_waits]
+    machine.close(w)
+    assert_equal 3, machine.metrics[:total_ops]
+    assert_equal 3, machine.metrics[:total_switches]
+    assert_equal 3, machine.metrics[:total_waits]
+  ensure
+    machine.close(r) rescue nil
+    machine.close(w) rescue nil
+  end
+
+  def test_metrics_total_switches
+    f1 = machine.spin { 3.times { machine.snooze } }
+    f2 = machine.spin { machine.sleep(0.01) }
+    assert_equal 0, machine.metrics[:total_switches]
+    machine.snooze
+    assert_equal 3, machine.metrics[:total_switches]
+    machine.snooze
+    assert_equal 5, machine.metrics[:total_switches]
+    machine.join(f2)
+    assert_equal 9, machine.metrics[:total_switches]
+  ensure
+    machine.join(f1, f2)
+  end
+
+  def test_metrics_total_waits
+    r, w = UM.pipe
+
+    machine.sleep(0.001)
+    assert_equal 1, machine.metrics[:total_waits]
+
+    machine.write_async(w, 'foo')
+    assert_equal 1, machine.metrics[:total_waits]
+
+    res = machine.read(r, +'', 3)
+    assert_equal 2, machine.metrics[:total_waits]
+    assert_equal 3, res
+
+    machine.close_async(w)
+    assert_equal 2, machine.metrics[:total_waits]
+
+    machine.snooze
+    assert_equal 3, machine.metrics[:total_waits]
+  ensure
+    machine.close(r) rescue nil
+    machine.close(w) rescue nil
+  end
+
+  def ops_metrics
+    machine.metrics.values_at(
+      :ops_pending,
+      :ops_unsubmitted,
+      :ops_runqueue,
+      :ops_free,
+      :ops_transient
+    )
+  end
+
+  def test_metrics_ops
+    r, w = UM.pipe
+
+    f = machine.spin { machine.sleep(0.001) }
+    assert_equal [0, 0, 1, 0, 0], ops_metrics
+    machine.snooze
+    assert_equal [1, 1, 0, 2, 0], ops_metrics
+    machine.submit
+    assert_equal [1, 0, 0, 2, 0], ops_metrics
+    machine.join(f)
+    assert_equal [0, 0, 0, 2, 0], ops_metrics
+
+    machine.write_async(w, 'foo')
+    assert_equal [1, 1, 0, 1, 1], ops_metrics
+    machine.submit
+    assert_equal [1, 0, 0, 1, 1], ops_metrics
+    machine.snooze
+    assert_equal [0, 0, 0, 2, 0], ops_metrics
+
+    machine.write_async(w, 'foo')
+    assert_equal [1, 1, 0, 1, 1], ops_metrics
+    machine.snooze
+    assert_equal [0, 0, 0, 2, 0], ops_metrics
+  ensure
+    machine.join(f)
+  end
+end
+
+class ProfileModeTest < UMBaseTest
+  def test_profile_mode_empty
+    assert_equal false, machine.profile?
+    assert_equal([
+      :size, :total_ops, :total_switches, :total_waits, :ops_pending,
+      :ops_unsubmitted, :ops_runqueue, :ops_free, :ops_transient
+    ], machine.metrics.keys)
+
+    machine.profile(true)
+    assert_equal true, machine.profile?
+    assert_equal([
+      :size, :total_ops, :total_switches, :total_waits, :ops_pending,
+      :ops_unsubmitted, :ops_runqueue, :ops_free, :ops_transient,
+      :time_total_cpu, :time_total_wait,
+    ], machine.metrics.keys)
+
+    machine.profile(false)
+    assert_equal false, machine.profile?
+    assert_equal([
+      :size, :total_ops, :total_switches, :total_waits, :ops_pending,
+      :ops_unsubmitted, :ops_runqueue, :ops_free, :ops_transient
+    ], machine.metrics.keys)
+  end
+
+  def test_profile_mode_total_times
+    machine.profile(true)
+    machine.sleep(0.01)
+    assert_in_range 0.0..0.0005, machine.metrics[:time_total_cpu]
+    assert_in_range 0.01..0.015, machine.metrics[:time_total_wait]
+  end
+end