uringmachine 0.21.0 → 0.22.0

data/test/test_fiber_scheduler.rb

@@ -4,6 +4,8 @@ require_relative 'helper'
 require 'uringmachine/fiber_scheduler'
 require 'securerandom'
 require 'socket'
+require 'net/http'
+require 'json'
 
 class MethodCallAuditor
   attr_reader :calls
@@ -19,7 +21,7 @@ class MethodCallAuditor
     res = @target.send(sym, *args, &block)
     @calls << ({ sym:, args:, res:})
     res
-  rescue => e
+  rescue Exception => e
     @calls << ({ sym:, args:, res: e})
     raise
   end
@@ -39,7 +41,7 @@ class FiberSchedulerTest < UMBaseTest
 
   def teardown
     Fiber.set_scheduler(nil)
-    GC.start
+    super
   end
 
   def test_fiber_scheduler_initialize_without_machine
@@ -101,7 +103,7 @@ class FiberSchedulerTest < UMBaseTest
       kernel_sleep: 2,
       io_write: 2,
       io_read: 3,
-      blocking_operation_wait: 1,
+      io_close: 1,
       join: 1
     }, @scheduler.calls.map { it[:sym] }.tally)
   ensure
@@ -127,6 +129,9 @@ class FiberSchedulerTest < UMBaseTest
       io_read: 1,
       join: 1
     }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    i.close rescue nil
+    o.close rescue nil
   end
 
   def test_io_write_with_timeout
@@ -149,10 +154,34 @@ class FiberSchedulerTest < UMBaseTest
       io_write: 1,
       join: 1
     }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    i.close rescue nil
+    o.close rescue nil
+  end
+
+  def test_io_write_ioerror
+    i, o = IO.pipe
+    buf = []
+
+    Fiber.schedule do
+      buf << i.write('!')
+    rescue SystemCallError, IOError => e
+      buf << e
+    end
+    @scheduler.join
+    assert_kind_of IOError, buf.first
+
+    assert_equal({
+      fiber: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    i.close rescue nil
+    o.close rescue nil
   end
 
   def test_fiber_io_pread
-    fn = "/tmp/#{SecureRandom.hex}"
+    fn = "/tmp/um_#{SecureRandom.hex}"
     IO.write(fn, 'foobar')
 
     buf = nil
@@ -170,12 +199,15 @@ class FiberSchedulerTest < UMBaseTest
       fiber: 1,
       blocking_operation_wait: 1,
       io_pread: 1,
+      io_close: 1,
       join: 1
     }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    FileUtils.rm(fn) rescue nil
   end
 
   def test_fiber_scheduler_io_pwrite
-    fn = "/tmp/#{SecureRandom.hex}"
+    fn = "/tmp/um_#{SecureRandom.hex}"
     IO.write(fn, 'foobar')
 
     res = nil
@@ -191,22 +223,25 @@ class FiberSchedulerTest < UMBaseTest
     assert_equal 'fobazr', IO.read(fn)
     assert_equal({
       fiber: 1,
-      blocking_operation_wait: 2,
+      blocking_operation_wait: 1,
       io_pwrite: 1,
+      io_close: 1,
       join: 1
     }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    FileUtils.rm(fn) rescue nil
   end
 
   def test_fiber_scheduler_sleep
     t0 = monotonic_clock
-    assert_equal 0, machine.pending_count
+    assert_equal 0, machine.metrics[:ops_pending]
     Fiber.schedule do
       sleep(0.01)
     end
     Fiber.schedule do
       sleep(0.02)
     end
-    assert_equal 2, machine.pending_count
+    assert_equal 2, machine.metrics[:ops_pending]
     @scheduler.join
     t1 = monotonic_clock
     assert_in_range 0.02..0.025, t1 - t0
@@ -244,7 +279,8 @@ class FiberSchedulerTest < UMBaseTest
   end
 
   def test_fiber_scheduler_process_wait
-    skip if !@scheduler.respond_to?(:process_wait)
+    skip("Missing #process_wait hook (no rb_process_status_new)") \
+      if !@scheduler.respond_to?(:process_wait)
 
     child_pid = nil
     status = nil
@@ -282,7 +318,7 @@ class FiberSchedulerTest < UMBaseTest
     buf = +''
     sent = nil
 
-    assert_equal 0, machine.total_op_count
+    assert_equal 0, machine.metrics[:total_ops]
     Fiber.schedule do
       buf = s1.recv(12)
     end
@@ -292,7 +328,7 @@ class FiberSchedulerTest < UMBaseTest
 
     # In Ruby, sockets are by default non-blocking. The recv will cause io_wait
     # to be invoked, the send should get through without needing to poll.
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
     @scheduler.join
 
     assert_equal 6, sent
@@ -308,48 +344,58 @@ class FiberSchedulerTest < UMBaseTest
   end
 
   def test_fiber_scheduler_io_write_io_read
-    fn = "/tmp/#{SecureRandom.hex}"
+    fn = "/tmp/um_#{SecureRandom.hex}"
     Fiber.schedule do
       IO.write(fn, 'foobar')
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
 
     buf = nil
     Fiber.schedule do
+      sleep 0.001
       buf = IO.read(fn)
     end
-    assert_equal 2, machine.total_op_count
+    assert_equal 2, machine.metrics[:total_ops]
 
     @scheduler.join
     assert_equal 'foobar', buf
     assert_equal({
       fiber: 2,
-      blocking_operation_wait: 3,
+      blocking_operation_wait: 2,
       io_read: 2,
+      io_close: 2,
+      kernel_sleep: 1,
       join: 1
     }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    FileUtils.rm(fn) rescue nil
   end
 
   def test_fiber_scheduler_file_io
-    fn = "/tmp/#{SecureRandom.hex}"
+    fn = "/tmp/um_#{SecureRandom.hex}"
     Fiber.schedule do
       File.open(fn, 'w') { it.write 'foobar' }
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
 
     buf = nil
     Fiber.schedule do
+      sleep 0.001
       File.open(fn, 'r') { buf = it.read }
     end
-    assert_equal 2, machine.total_op_count
+    assert_equal 2, machine.metrics[:total_ops]
     @scheduler.join
     assert_equal 'foobar', buf
     assert_equal({
       fiber: 2,
-      blocking_operation_wait: 3,
+      blocking_operation_wait: 2,
       io_read: 2,
+      io_close: 2,
+      kernel_sleep: 1,
       join: 1
     }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    FileUtils.rm(fn) rescue nil
   end
 
   def test_fiber_scheduler_mutex
@@ -359,24 +405,24 @@ class FiberSchedulerTest < UMBaseTest
     Fiber.schedule do
       buf << 11
       mutex.synchronize {
-        buf << [12, machine.total_op_count]
+        buf << [12, machine.metrics[:total_ops]]
         sleep 0.01
-        buf << [13, machine.total_op_count]
+        buf << [13, machine.metrics[:total_ops]]
       }
       buf << 14
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
 
     Fiber.schedule do
       buf << 21
       mutex.synchronize {
-        buf << [22, machine.total_op_count]
+        buf << [22, machine.metrics[:total_ops]]
         sleep 0.01
-        buf << [23, machine.total_op_count]
+        buf << [23, machine.metrics[:total_ops]]
       }
       buf << 24
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
 
     @scheduler.join
     assert_equal [11, [12, 0], 21, [13, 2], 14, [22, 2], [23, 4], 24], buf
@@ -394,16 +440,16 @@ class FiberSchedulerTest < UMBaseTest
 
     buf = []
     Fiber.schedule do
-      buf << [11, machine.total_op_count]
+      buf << [11, machine.metrics[:total_ops]]
       buf << queue.shift
-      buf << [12, machine.total_op_count]
+      buf << [12, machine.metrics[:total_ops]]
     end
     Fiber.schedule do
-      buf << [21, machine.total_op_count]
+      buf << [21, machine.metrics[:total_ops]]
       queue << :foo
-      buf << [22, machine.total_op_count]
+      buf << [22, machine.metrics[:total_ops]]
     end
-    assert_equal 0, machine.total_op_count
+    assert_equal 0, machine.metrics[:total_ops]
     @scheduler.join
 
     assert_equal [[11, 0], [21, 0], [22, 0], :foo, [12, 1]], buf
@@ -420,14 +466,14 @@ class FiberSchedulerTest < UMBaseTest
 
     buf = []
     Fiber.schedule do
-      buf << [11, machine.total_op_count]
+      buf << [11, machine.metrics[:total_ops]]
       buf << queue.shift(timeout: 0.01)
-      buf << [12, machine.total_op_count]
+      buf << [12, machine.metrics[:total_ops]]
     end
     Fiber.schedule do
-      buf << [21, machine.total_op_count]
+      buf << [21, machine.metrics[:total_ops]]
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
     @scheduler.join
 
     assert_equal [[11, 0], [21, 1], nil, [12, 2]], buf
@@ -447,10 +493,10 @@ class FiberSchedulerTest < UMBaseTest
     end
 
     # No ops are issued, except for a NOP SQE used to wakeup the waiting thread.
-    assert_equal 0, machine.total_op_count
+    assert_equal 0, machine.metrics[:total_ops]
 
     @scheduler.join
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
     assert_equal({
       fiber: 1,
       block: 1,
@@ -460,7 +506,8 @@ class FiberSchedulerTest < UMBaseTest
   end
 
   def test_fiber_scheduler_system
-    skip if !@scheduler.respond_to?(:process_wait)
+    skip("Missing #process_wait hook (no rb_process_status_new)") \
+      if !@scheduler.respond_to?(:process_wait)
 
     buf = []
     Fiber.schedule do
@@ -478,13 +525,14 @@ class FiberSchedulerTest < UMBaseTest
   end
 
   def test_fiber_scheduler_cmd
-    skip if !@scheduler.respond_to?(:process_wait)
+    skip("Missing #process_wait hook (no rb_process_status_new)") \
+      if !@scheduler.respond_to?(:process_wait)
 
     buf = []
     Fiber.schedule do
       buf << `echo 'foo'`
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
     @scheduler.join
     assert_equal ["foo\n"], buf
     assert_equal({
@@ -498,19 +546,20 @@ class FiberSchedulerTest < UMBaseTest
   end
 
   def test_fiber_scheduler_popen
-    skip if !@scheduler.respond_to?(:process_wait)
+    skip("Missing #process_wait hook (no rb_process_status_new)") \
+      if !@scheduler.respond_to?(:process_wait)
 
     buf = []
     Fiber.schedule do
       IO.popen('ruby', 'r+') do |pipe|
-        buf << [11, machine.total_op_count]
+        buf << [11, machine.metrics[:total_ops]]
         pipe.puts 'puts "bar"'
-        buf << [12, machine.total_op_count]
+        buf << [12, machine.metrics[:total_ops]]
         pipe.close_write
-        buf << [13, pipe.gets.chomp, machine.total_op_count]
+        buf << [13, pipe.gets.chomp, machine.metrics[:total_ops]]
       end
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
     @scheduler.join
     assert_equal [[11, 0], [12, 3], [13, "bar", 5]], buf
     assert_equal({
@@ -535,7 +584,7 @@ class FiberSchedulerTest < UMBaseTest
     rescue Exception => e
       exception = e
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
     machine.snooze
     Thread.new {
       r.close
@@ -558,7 +607,7 @@ class FiberSchedulerTest < UMBaseTest
     Fiber.schedule do
       addrs = Addrinfo.getaddrinfo("localhost", 80, Socket::AF_INET, :STREAM)
     end
-    assert_equal 1, machine.total_op_count
+    assert_equal 1, machine.metrics[:total_ops]
     @scheduler.join
     assert_kind_of Array, addrs
     addr = addrs.first
@@ -567,6 +616,7 @@ class FiberSchedulerTest < UMBaseTest
     assert_equal({
       fiber: 1,
       io_read: 2,
+      io_close: 1,
       blocking_operation_wait: 1,
       address_resolve: 1,
       join: 1
@@ -584,7 +634,7 @@ class FiberSchedulerTest < UMBaseTest
       res = e
     end
     @scheduler.join
-    assert_equal 3, machine.total_op_count
+    assert_equal 3, machine.metrics[:total_ops]
     assert_kind_of Timeout::Error, res
     assert_equal({
       fiber: 1,
@@ -638,3 +688,856 @@ class FiberSchedulerTest < UMBaseTest
     assert_equal (1..20).map { it * 10 }, buf.sort
   end
 end
+
+class FiberSchedulerIOClassMethodsTest < UMBaseTest
+  def setup
+    super
+    @raw_scheduler = UM::FiberScheduler.new(@machine)
+    @scheduler = MethodCallAuditor.new(@raw_scheduler)
+    Fiber.set_scheduler(@scheduler)
+    @fn = "/tmp/um_#{SecureRandom.hex}"
+    IO.write(@fn, '===')
+  end
+
+  def teardown
+    FileUtils.rm(@fn) rescue nil
+    Fiber.set_scheduler(nil)
+    super
+  end
+
+  def test_IO_s_binread
+    ret = nil
+    Fiber.schedule do
+      ret = IO.binread(@fn)
+    end
+    @scheduler.join
+    assert_equal '===', ret
+    assert_equal({
+      fiber: 1,
+      io_read: 2,
+      blocking_operation_wait: 1,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_s_binwrite
+    ret = nil
+    Fiber.schedule do
+      ret = IO.binwrite(@fn, '***', 2)
+    end
+    @scheduler.join
+    assert_equal 3, ret
+    assert_equal '==***', IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      blocking_operation_wait: 1,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_s_copy_stream
+    fn2 = "/tmp/um_#{SecureRandom.hex}"
+    ret = nil
+    Fiber.schedule do
+      ret = IO.copy_stream(@fn, fn2)
+    end
+    @scheduler.join
+    assert_equal 3, ret
+    assert_equal '===', IO.read(fn2)
+    assert_equal({
+      fiber: 1,
+      blocking_operation_wait: 3,
+      io_close: 2,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    FileUtils.rm(fn2) rescue nil
+  end
+
+  def test_IO_s_foreach
+    buf = []
+    Fiber.schedule do
+      IO.foreach(@fn) { buf << it }
+    end
+    @scheduler.join
+    assert_equal ['==='], buf
+    assert_equal({
+      fiber: 1,
+      io_read: 3,
+      blocking_operation_wait: 1,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_s_foreach
+    buf = []
+    Fiber.schedule do
+      IO.foreach(@fn) { buf << it }
+    end
+    @scheduler.join
+    assert_equal ['==='], buf
+    assert_equal({
+      fiber: 1,
+      io_read: 3,
+      blocking_operation_wait: 1,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_s_popen
+    ret = nil
+    Fiber.schedule do
+      IO.popen("cat #{@fn}") { ret = it.read }
+    end
+    @scheduler.join
+    assert_equal '===', ret
+    assert_equal({
+      fiber: 1,
+      io_read: 2,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_s_read
+    ret = nil
+    Fiber.schedule do
+      ret = IO.read(@fn)
+    end
+    @scheduler.join
+    assert_equal '===', ret
+    assert_equal({
+      fiber: 1,
+      io_read: 2,
+      blocking_operation_wait: 1,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_s_readlines
+    ret = nil
+    Fiber.schedule do
+      ret = IO.readlines(@fn)
+    end
+    @scheduler.join
+    assert_equal ['==='], ret
+    assert_equal({
+      fiber: 1,
+      io_read: 3,
+      blocking_operation_wait: 1,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_s_select
+    ret = nil
+    io = File.open(@fn, 'r+')
+    Fiber.schedule do
+      ret = IO.select([io], [io], [])
+    end
+    @scheduler.join
+    assert_equal [[io], [io], []], ret
+    assert_equal({
+      fiber: 1,
+      io_select: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    io.close rescue nil
+  end
+
+  def test_IO_s_write
+    ret = nil
+    Fiber.schedule do
+      ret = IO.write(@fn, '***', 2)
+    end
+    @scheduler.join
+    assert_equal 3, ret
+    assert_equal '==***', IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      blocking_operation_wait: 1,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+end
+
+class FiberSchedulerIOInstanceMethodsTest < UMBaseTest
+  def setup
+    super
+    @raw_scheduler = UM::FiberScheduler.new(@machine)
+    @scheduler = MethodCallAuditor.new(@raw_scheduler)
+    Fiber.set_scheduler(@scheduler)
+    @fn = "/tmp/um_#{SecureRandom.hex}"
+    IO.write(@fn, '===')
+    @io = File.open(@fn, 'r+')
+    @io.sync = true
+  end
+
+  def teardown
+    @io.close rescue nil
+      FileUtils.rm(@fn) rescue nil
+    Fiber.set_scheduler(nil)
+    super
+  end
+
+  def test_IO_i_double_left_chevron
+    Fiber.schedule do
+      @io.seek(2)
+      @io << '***'
+    end
+    @scheduler.join
+    assert_equal '==***', IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      io_write: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_close
+    ret = nil
+    Fiber.schedule do
+      ret = @io.close
+    end
+    @scheduler.join
+    assert_nil ret
+    assert_equal({
+      fiber: 1,
+      io_close: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_close_read
+    ret = nil
+    Fiber.schedule do
+      ret = @io.close_read
+    end
+    @scheduler.join
+    assert_nil ret
+    assert_equal({
+      fiber: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_close_write
+    ret = nil
+    Fiber.schedule do
+      ret = @io.close_write
+    end
+    @scheduler.join
+    assert_nil ret
+    assert_equal({
+      fiber: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_each_byte
+    buf = []
+    Fiber.schedule do
+      @io.each_byte { buf << it }
+    end
+    @scheduler.join
+    assert_equal [61, 61, 61], buf
+    assert_equal({
+      fiber: 1,
+      io_read: 2,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_each_char
+    buf = []
+    Fiber.schedule do
+      @io.each_char { buf << it }
+    end
+    @scheduler.join
+    assert_equal ['=', '=', '='], buf
+    assert_equal({
+      fiber: 1,
+      io_read: 2,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_each_line
+    buf = []
+    Fiber.schedule do
+      @io.each_line { buf << it }
+    end
+    @scheduler.join
+    assert_equal ['==='], buf
+    assert_equal({
+      fiber: 1,
+      io_read: 3,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_getbyte
+    ret = nil
+    Fiber.schedule do
+      ret = @io.getbyte
+    end
+    @scheduler.join
+    assert_equal 61, ret
+    assert_equal({
+      fiber: 1,
+      io_read: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_getc
+    ret = nil
+    Fiber.schedule do
+      ret = @io.getc
+    end
+    @scheduler.join
+    assert_equal '=', ret
+    assert_equal({
+      fiber: 1,
+      io_read: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_gets
+    ret = nil
+    Fiber.schedule do
+      ret = @io.gets
+    end
+    @scheduler.join
+    assert_equal '===', ret
+    assert_equal({
+      fiber: 1,
+      io_read: 2,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_pread
+    ret = nil
+    Fiber.schedule do
+      ret = @io.pread(5, 2)
+    end
+    @scheduler.join
+    assert_equal '=', ret
+    assert_equal({
+      fiber: 1,
+      io_pread: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_print
+    ret = nil
+    Fiber.schedule do
+      ret = @io.print(1, 2.0, '3')
+    end
+    @scheduler.join
+    assert_nil ret
+    assert_equal '12.03', IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      io_write: 3,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_printf
+    ret = nil
+    Fiber.schedule do
+      ret = @io.printf('%08x', 4321)
+    end
+    @scheduler.join
+    assert_nil ret
+    assert_equal '000010e1', IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      io_write: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_putc
+    ret = nil
+    Fiber.schedule do
+      ret = @io.putc('B')
+    end
+    @scheduler.join
+    assert_equal 'B', ret
+    assert_equal 'B==', IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      io_write: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_puts
+    ret = nil
+    Fiber.schedule do
+      ret = @io.puts('abc')
+    end
+    @scheduler.join
+    assert_nil ret
+    assert_equal "abc\n", IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      io_write: 2,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_pwrite
+    ret = nil
+    Fiber.schedule do
+      ret = @io.pwrite('abc', 2)
+    end
+    @scheduler.join
+    assert_equal 3, ret
+    assert_equal "==abc", IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      io_pwrite: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_read
+    ret = nil
+    Fiber.schedule do
+      ret = @io.read
+    end
+    @scheduler.join
+    assert_equal "===", ret
+    assert_equal({
+      fiber: 1,
+      io_read: 2,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_readbyte
+    ret = nil
+    Fiber.schedule do
+      ret = @io.readbyte
+    end
+    @scheduler.join
+    assert_equal 61, ret
+    assert_equal({
+      fiber: 1,
+      io_read: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_readchar
+    ret = nil
+    Fiber.schedule do
+      ret = @io.readchar
+    end
+    @scheduler.join
+    assert_equal '=', ret
+    assert_equal({
+      fiber: 1,
+      io_read: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_readline
+    ret = nil
+    Fiber.schedule do
+      ret = @io.readline
+    end
+    @scheduler.join
+    assert_equal '===', ret
+    assert_equal({
+      fiber: 1,
+      io_read: 2,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_readlines
+    ret = nil
+    Fiber.schedule do
+      ret = @io.readlines
+    end
+    @scheduler.join
+    assert_equal ["==="], ret
+    assert_equal({
+      fiber: 1,
+      io_read: 3,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_readpartial
+    ret = nil
+    Fiber.schedule do
+      ret = @io.readpartial(7)
+    end
+    @scheduler.join
+    assert_equal "===", ret
+    assert_equal({
+      fiber: 1,
+      io_read: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_sysread
+    ret = nil
+    Fiber.schedule do
+      ret = @io.sysread(7)
+    end
+    @scheduler.join
+    assert_equal "===", ret
+    assert_equal({
+      fiber: 1,
+      io_read: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_syswrite
+    ret = nil
+    Fiber.schedule do
+      ret = @io.syswrite('2')
+    end
+    @scheduler.join
+    assert_equal 1, ret
+    assert_equal '2==', IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      io_write: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_wait
+    ret = nil
+    Fiber.schedule do
+      ret = @io.wait(IO::READABLE | IO::WRITABLE)
+    end
+    @scheduler.join
+    assert_equal @io, ret
+    assert_equal({
+      fiber: 1,
+      io_wait: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_wait_pipe_read_timeout
+    r, w = IO.pipe
+    ret = nil
+    Fiber.schedule do
+      ret = r.wait(IO::READABLE, 0.05)
+    end
+    @scheduler.join
+    assert_nil ret
+    assert_equal({
+      fiber: 1,
+      io_wait: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    r.close rescue nil
+    w.close rescue nil
+  end
+
+  def test_IO_i_wait_readable
+    ret = nil
+    Fiber.schedule do
+      ret = @io.wait_readable
+    end
+    @scheduler.join
+    assert_equal @io, ret
+    assert_equal({
+      fiber: 1,
+      io_wait: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_wait_writable
+    ret = nil
+    Fiber.schedule do
+      ret = @io.wait_writable
+    end
+    @scheduler.join
+    assert_equal @io, ret
+    assert_equal({
+      fiber: 1,
+      io_wait: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+
+  def test_IO_i_write
+    ret = nil
+    Fiber.schedule do
+      ret = @io.write('abcde')
+    end
+    @scheduler.join
+    assert_equal 5, ret
+    assert_equal 'abcde', IO.read(@fn)
+    assert_equal({
+      fiber: 1,
+      io_write: 1,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+end
+
+class FiberSchedulerQueueTest < UMBaseTest
+  def setup
+    super
+    @raw_scheduler = UM::FiberScheduler.new(@machine)
+    @scheduler = MethodCallAuditor.new(@raw_scheduler)
+    Fiber.set_scheduler(@scheduler)
+    @queue = Queue.new
+  end
+
+  def teardown
+    Fiber.set_scheduler(nil)
+    super
+  end
+
+  I = 5
+  C = 5
+
+  def test_fiber_scheduler_queue_multi_fiber
+    C.times {
+      Fiber.schedule do
+        I.times { sleep 0.0001; @queue << rand(1000) }
+      end
+    }
+    C.times {
+      Fiber.schedule do
+        I.times { @queue.shift; @scheduler.yield;   }
+      end
+    }
+    @scheduler.join
+    assert_equal({
+      fiber: 10,
+      kernel_sleep: 25,
+      yield: 25,
+      block: 25,
+      unblock: 25,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  end
+end
+
+class FiberSchedulerNetHTTPTest < UMBaseTest
+  def setup
+    super
+    @raw_scheduler = UM::FiberScheduler.new(@machine)
+    @scheduler = MethodCallAuditor.new(@raw_scheduler)
+    Fiber.set_scheduler(@scheduler)
+    @uri = URI('https://ipinfo.io/')
+  end
+
+  def teardown
+    Fiber.set_scheduler(nil)
+    super
+  end
+
+  C = 10
+
+  def test_fiber_scheduler_net_http
+    buf = []
+    C.times {
+      Fiber.schedule do
+        buf << JSON.parse(Net::HTTP.get(@uri))
+      end
+    }
+    @scheduler.join
+    assert_equal C, buf.size
+    assert_equal 1, buf.map { it['ip'] }.uniq.compact.size
+    calls = @scheduler.calls.map { it[:sym] }.tally
+    assert_equal C, calls[:fiber]
+    assert_equal C, calls[:io_close]
+    assert_in_range (C * 2)..(C * 4), calls[:io_wait]
+    assert_in_range (C * 7)..(C * 17), calls[:blocking_operation_wait]
+  end
+end
+
+class FiberSchedulerMultiPipeTest < UMBaseTest
+  def setup
+    super
+    @raw_scheduler = UM::FiberScheduler.new(@machine)
+    @scheduler = MethodCallAuditor.new(@raw_scheduler)
+    Fiber.set_scheduler(@scheduler)
+    @uri = URI('https://ipinfo.io/')
+  end
+
+  def teardown
+    Fiber.set_scheduler(nil)
+    super
+  end
+
+  C = 10
+  I = 100
+  SIZE = 1024
+  DATA = '*' * SIZE
+
+  def test_fiber_scheduler_multi_pipe
+    count = 0
+    ios = []
+    C.times do
+      r, w = IO.pipe
+      r.sync = true
+      w.sync = true
+      ios << r << w
+      Fiber.schedule do
+        I.times { w.write(DATA); count += 1 }
+        w.close
+      end
+      Fiber.schedule do
+        I.times { r.read(SIZE); count += 1 }
+      end
+    end
+    @scheduler.join
+    assert_equal 2000, count
+    assert_equal({
+      fiber: 20,
+      io_read: 1000,
+      io_write: 1000,
+      io_close: 10,
+      join: 1
+    }, @scheduler.calls.map { it[:sym] }.tally)
+  ensure
+    ios.each { it.close rescue nil }
+  end
+end
+
+class FiberSchedulerMultiTCPTest < UMBaseTest
+  C = 10
+  W = 10
+  I = 10
+  SIZE = 1024
+  DATA = '*' * SIZE
+
+  def p(o)
+    # UM.debug(o.inspect)
+  end
+
+  def run_server(port)
+    server = TCPServer.new('127.0.0.1', port)
+    p(server:)
+
+    server_fiber = Fiber.schedule { accept_loop(server) }
+
+    fibers = []
+    W.times {
+      fibers << Fiber.schedule { run_client(port) }
+    }
+    @machine.await_fibers(fibers)
+    server.close
+    @machine.await_fibers(server_fiber)
+  rescue Exception => e
+    p test_run_server: e
+    p e.backtrace
+    exit!
+  end
+
+  def accept_loop(server)
+    loop do
+      conn = server.accept
+      p(accept: conn)
+      Fiber.schedule { conn_loop(conn) }
+    end
+  rescue IOError
+    # socket closed
+  rescue Exception => e
+    p accept_loop: e
+    p e.backtrace
+    exit!
+  end
+
+  def conn_loop(conn)
+    loop do
+      msg = conn.recv(SIZE * 2)
+      break if !msg
+
+      conn.send(msg, 0)
+    end
+  rescue Exception => e
+    p conn_loop: e
+    p e.backtrace
+  ensure
+    conn.close rescue nil
+  end
+
+  def run_client(port)
+    client = TCPSocket.new('127.0.0.1', port)
+    p(client:)
+    I.times do
+      client.send(DATA, 0)
+      client.recv(SIZE * 2)
+      @msg_count += 1
+    end
+    p(:client_done)
+  rescue Exception => e
+    p client_loop: e
+    p e.backtrace
+  ensure
+    client.close
+  end
+
+  def run_fiber_scheduler_multi_tcp
+    @msg_count = 0
+    STDOUT.sync = true
+    ios = []
+    fibers = []
+    C.times do |i|
+      port = @port_base + i
+      fibers << Fiber.schedule do
+        run_server(port)
+      end
+    end
+    @machine.await_fibers(fibers)
+    @calls = @scheduler.calls.map { it[:sym] }.tally
+  ensure
+    # p ensure: ios
+    ios.each { it.close rescue nil }
+  end
+
+  def test_fiber_scheduler_multi_tcp
+    Thread.new do
+      @raw_scheduler = UM::FiberScheduler.new(@machine)
+      @scheduler = MethodCallAuditor.new(@raw_scheduler)
+      Fiber.set_scheduler(@scheduler)
+      @port_base = assign_port
+      run_fiber_scheduler_multi_tcp
+    ensure
+      Fiber.set_scheduler(nil)
+    end.join
+
+    assert_equal 1000, @msg_count
+    assert_equal({
+      fiber: 220,
+      io_wait: 2120,
+      io_close: 210,
+      fiber_interrupt: 10,
+      unblock: 10,
+      kernel_sleep: 10
+    }, @calls)
+  end
+end