uringmachine 0.21.0 → 0.22.0

data/test/test_um.rb

@@ -11,15 +11,15 @@ class UringMachineTest < Minitest::Test
   end
 end
 
-class EntriesTest < Minitest::Test
-  def test_default_entries
+class SizeTest < Minitest::Test
+  def test_default_size
     m = UM.new
-    assert_equal 4096, m.entries
+    assert_equal 4096, m.size
   end
 
-  def test_custom_entries_value
+  def test_custom_size_value
     m = UM.new(13)
-    assert_equal 13, m.entries
+    assert_equal 13, m.size
   end
 end
 
@@ -73,15 +73,17 @@ 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.pending_count
+    assert_equal 3, machine.metrics[:ops_pending]
     assert_equal 3, machine.submit
     assert_equal 0, machine.submit
     machine.snooze
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
   end
 end
 
@@ -109,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
 
@@ -122,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
 
@@ -133,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
 
@@ -152,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)
@@ -176,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
@@ -211,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
@@ -250,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
@@ -263,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
@@ -274,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
@@ -289,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
@@ -297,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
@@ -309,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
@@ -368,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
@@ -378,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
@@ -390,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
@@ -413,21 +417,21 @@ class StatsTest < UMBaseTest
   def test_op_counts
     _r, w = IO.pipe
 
-    assert_equal 0, machine.pending_count
-    assert_equal 0, machine.total_op_count
+    assert_equal 0, machine.metrics[:ops_pending]
+    assert_equal 0, machine.metrics[:total_ops]
     machine.write_async(w.fileno, 'foo')
-    assert_equal 1, machine.pending_count
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:ops_pending]
+    assert_equal 1, machine.metrics[:total_ops]
     machine.snooze
-    assert_equal 0, machine.pending_count
-    assert_equal 1, machine.total_op_count
+    assert_equal 0, machine.metrics[:ops_pending]
+    assert_equal 1, machine.metrics[:total_ops]
 
     machine.write_async(w.fileno, 'foo')
-    assert_equal 1, machine.pending_count
-    assert_equal 2, machine.total_op_count
+    assert_equal 1, machine.metrics[:ops_pending]
+    assert_equal 2, machine.metrics[:total_ops]
     machine.snooze
-    assert_equal 0, machine.pending_count
-    assert_equal 2, machine.total_op_count
+    assert_equal 0, machine.metrics[:ops_pending]
+    assert_equal 2, machine.metrics[:total_ops]
   end
 end
 
@@ -437,9 +441,9 @@ class ReadTest < UMBaseTest
     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
 
@@ -461,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
@@ -560,7 +564,7 @@ class ReadTest < UMBaseTest
   end
 
   def test_read_with_file_offset
-    fn = "/tmp/#{SecureRandom.hex}"
+    fn = "/tmp/um_#{SecureRandom.hex}"
     IO.write(fn, 'foobar')
 
     fd = machine.open(fn, UM::O_RDONLY)
@@ -570,6 +574,7 @@ class ReadTest < UMBaseTest
     assert_equal 'obar', buffer
   ensure
     machine.close(fd)
+    FileUtils.rm(fn) rescue nil
   end
 end
 
@@ -590,7 +595,7 @@ class ReadEachTest < UMBaseTest
       w << 'baz'
       machine.sleep 0.02
       w.close
-      machine.yield
+      machine.switch
     end
 
     machine.schedule(f, nil)
@@ -600,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
@@ -624,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
@@ -649,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
@@ -675,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
@@ -699,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
@@ -720,10 +725,10 @@ class WriteTest < UMBaseTest
   def test_write
     r, w = IO.pipe
 
-    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.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 'foo', r.readpartial(3)
 
     res = machine.write(w.fileno, 'bar', 2)
@@ -734,11 +739,11 @@ class WriteTest < UMBaseTest
   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
@@ -808,7 +813,7 @@ class WriteTest < UMBaseTest
   end
 
   def test_write_with_file_offset
-    fn = "/tmp/#{SecureRandom.hex}"
+    fn = "/tmp/um_#{SecureRandom.hex}"
     IO.write(fn, 'foobar')
 
     fd = machine.open(fn, UM::O_WRONLY)
@@ -817,47 +822,47 @@ class WriteTest < UMBaseTest
     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 while machine.pending_count > 0
-    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 while machine.pending_count > 0
-    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
@@ -868,7 +873,7 @@ class WriteAsyncTest < UMBaseTest
     write_buffer.set_string(msg)
 
     machine.write_async(w, write_buffer)
-    machine.snooze while machine.pending_count > 0
+    machine.snooze while machine.metrics[:ops_pending] > 0
     machine.close(w)
 
     str = +''
@@ -885,27 +890,28 @@ class WriteAsyncTest < UMBaseTest
   def test_write_async_with_len
     r, w = IO.pipe
 
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     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 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/#{SecureRandom.hex}"
+    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.pending_count
-    machine.snooze while machine.pending_count > 0
+    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
 
@@ -915,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) }
@@ -937,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
 
@@ -980,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
 
@@ -1024,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
 
@@ -1063,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
@@ -1098,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
 
@@ -1128,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 = +''
@@ -1143,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
 
@@ -1361,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)
@@ -1378,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
 
@@ -1399,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
@@ -1453,12 +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
     m = UM::Mutex.new
-
     buf = []
 
     f1 = Fiber.new do
@@ -1468,7 +1473,7 @@ class SynchronizeTest < UMBaseTest
         buf << 12
       end
       buf << 13
-      machine.yield
+      machine.switch
     end
 
     f2 = Fiber.new do
@@ -1478,7 +1483,7 @@ class SynchronizeTest < UMBaseTest
         buf << 22
       end
       buf << 23
-      machine.yield
+      machine.switch
     end
 
     machine.schedule(f1, nil)
@@ -1486,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
@@ -1537,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)
@@ -1563,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)
 
@@ -1588,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)
 
@@ -1701,38 +1706,40 @@ class QueueTest < UMBaseTest
 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
 
@@ -1756,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 }
@@ -2167,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
@@ -2241,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