uringmachine 0.19 → 0.20.0

data/test/test_um.rb

@@ -142,6 +142,31 @@ class ScheduleTest < UMBaseTest
     assert_kind_of TOError, e
   end
 
+  def test_timeout_stress
+    skip
+    # GC.stress = true
+    c = 0
+    fs = 100.times.map {
+      machine.spin {
+        q = UM::Queue.new
+        1000.times {
+          machine.sleep rand(0.001..0.005)
+          begin
+            machine.timeout(rand(0.001..0.06), TOError) do
+              machine.shift(q)
+            end
+          rescue => _e
+            c += 1
+            STDOUT << '*' if c % 1000 == 0
+          end
+        }
+      }
+    }
+    machine.join(*fs)
+  ensure
+    GC.stress = false
+  end
+
   def test_timeout_with_raising_block
     e = nil
     begin
@@ -302,7 +327,7 @@ class PeriodicallyTest < UMBaseTest
     rescue Cancel
       cancel = 1
     end
-    5.times { machine.snooze }
+    20.times { machine.snooze }
     assert_equal 0, machine.pending_count
     t1 = monotonic_clock
     assert_in_range 0.05..0.08, t1 - t0
@@ -394,6 +419,51 @@ class ReadTest < UMBaseTest
     assert_equal 3, result
     assert_equal 'baz', sio.read
   end
+
+  def test_read_io_buffer
+    r, w = UM.pipe
+    machine.write(w, 'foobar')
+
+    read_buffer = IO::Buffer.new(3)
+    res = machine.read(r, read_buffer, 3)
+    assert_equal 3, res
+    assert_equal 'foo', read_buffer.get_string(0, 3)
+
+    machine.close(w)
+
+    res = machine.read(r, read_buffer)
+    assert_equal 3, res
+    assert_equal 'bar', read_buffer.get_string(0, 3)
+  end
+
+  def test_read_io_buffer_resize
+    r, w = UM.pipe
+    machine.write(w, 'foobar')
+    machine.close(w)
+
+    read_buffer = IO::Buffer.new(3)
+    res = machine.read(r, read_buffer, 6)
+    assert_equal 6, res
+    assert_equal 6, read_buffer.size
+    assert_equal 'foobar', read_buffer.get_string(0, res)
+
+    r, w = UM.pipe
+    machine.write(w, 'foobar')
+    machine.close(w)
+
+    read_buffer = IO::Buffer.new(3)
+    res = machine.read(r, read_buffer, 128, -1)
+    assert_equal 6, res
+    assert_equal 131, read_buffer.size
+    assert_equal 'foobar', read_buffer.get_string(3, res)
+  end
+
+  def test_read_invalid_buffer
+    r, _w = UM.pipe
+    assert_raises(UM::Error) {
+      machine.read(r, [])
+    }
+  end
 end
 
 class ReadEachTest < UMBaseTest
@@ -561,6 +631,54 @@ class WriteTest < UMBaseTest
     end
     assert_equal 0, machine.pending_count
   end
+
+  def test_write_io_buffer
+    r, w = UM.pipe
+
+    msg = 'Hello world'
+    write_buffer = IO::Buffer.new(msg.bytesize)
+    write_buffer.set_string(msg, 0)
+
+    machine.write(w, write_buffer)
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal msg, str
+  end
+
+  def test_write_io_buffer_with_len
+    r, w = UM.pipe
+    msg = 'Hello world'
+    write_buffer = IO::Buffer.new(msg.bytesize)
+    write_buffer.set_string(msg)
+
+    machine.write(w, write_buffer, 5)
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal 'Hello', str
+
+    r, w = UM.pipe
+    msg = 'Hello world'
+    write_buffer = IO::Buffer.new(msg.bytesize)
+    write_buffer.set_string(msg)
+
+    machine.write(w, write_buffer, -1)
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal 'Hello world', str
+  end
+
+  def test_write_invalid_buffer
+    _r, w = UM.pipe
+    assert_raises(UM::Error) {
+      machine.write(w, [])
+    }
+  end
 end
 
 class WriteAsyncTest < UMBaseTest
@@ -601,6 +719,28 @@ class WriteAsyncTest < UMBaseTest
     machine.snooze
     assert_equal 0, machine.pending_count
   end
+
+  def test_write_async_io_buffer
+    r, w = UM.pipe
+
+    msg = 'Hello world'
+    write_buffer = IO::Buffer.new(msg.bytesize)
+    write_buffer.set_string(msg)
+
+    machine.write_async(w, write_buffer)
+    3.times { machine.snooze }
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal msg, str
+  end
+
+  def test_write_async_invalid_buffer
+    _r, w = UM.pipe
+
+    assert_raises(UM::Error) { machine.write_async(w, []) }
+  end
 end
 
 class CloseTest < UMBaseTest
@@ -618,7 +758,7 @@ class CloseTest < UMBaseTest
   end
 
   def test_close_bad_fd
-    r, w = IO.pipe
+    _r, w = IO.pipe
     machine.close(w.fileno)
 
     assert_raises(Errno::EBADF) { machine.close(w.fileno) }
@@ -877,6 +1017,78 @@ class SendTest < UMBaseTest
   ensure
     t&.kill
   end
+
+
+  def test_send_io_buffer
+    @port = assign_port
+    @server = TCPServer.open('127.0.0.1', @port)
+
+    t = Thread.new do
+      conn = @server.accept
+      str = conn.readpartial(42)
+      conn.write("You said: #{str} (#{str.bytesize})")
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    buffer = IO::Buffer.new(6)
+    buffer.set_string('foobar')
+    res = machine.send(fd, buffer, 6, 0)
+    assert_equal 6, res
+
+    buf = +''
+    res = machine.read(fd, buf, 42)
+    assert_equal 20, res
+    assert_equal 'You said: foobar (6)', buf
+  ensure
+    t&.kill
+    @server&.close
+  end
+
+  def test_send_io_buffer_negative_len
+    t = Thread.new do
+      conn = @server.accept
+      str = conn.readpartial(42)
+      conn.write("You said: #{str} (#{str.bytesize})")
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    buffer = IO::Buffer.new(6)
+    buffer.set_string('foobar')
+    res = machine.send(fd, buffer, -1, 0)
+    assert_equal 6, res
+
+    buf = +''
+    res = machine.read(fd, buf, 42)
+    assert_equal 20, res
+    assert_equal 'You said: foobar (6)', buf
+  ensure
+    t&.kill
+  end
+
+  def test_send_invalid_buffer
+    t = Thread.new do
+      conn = @server.accept
+      str = conn.readpartial(42)
+      conn.write("You said: #{str} (#{str.bytesize})")
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    assert_raises(UM::Error) { machine.send(fd, [], -1, 0) }
+  ensure
+    t&.kill
+  end
 end
 
 class RecvTest < UMBaseTest
@@ -909,6 +1121,25 @@ class RecvTest < UMBaseTest
   ensure
     t&.kill
   end
+
+  def test_recv_io_buffer
+    t = Thread.new do
+      conn = @server.accept
+      conn.write('foobar')
+      sleep
+    end
+
+    fd = machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    res = machine.connect(fd, '127.0.0.1', @port)
+    assert_equal 0, res
+
+    buf = IO::Buffer.new(12)
+    res = machine.recv(fd, buf, 12, 0)
+    assert_equal 6, res
+    assert_equal 'foobar', buf.get_string(0, 6)
+  ensure
+    t&.kill
+  end
 end
 
 class RecvEachTest < UMBaseTest
@@ -1094,6 +1325,25 @@ class SynchronizeTest < UMBaseTest
     assert_equal [11, 12, 13, 21, 22, 23], buf
     assert_equal 0, machine.pending_count
   end
+
+  def test_synchronize_multi
+    mutex = UM::Mutex.new
+    buf = []
+    fibers = (1..8).map { |i|
+      machine.spin do
+        machine.synchronize(mutex) do
+          buf << (i * 10) + 1
+          machine.sleep(0.01)
+          buf << (i * 10) + 2
+        end
+        machine.snooze
+        buf << (i * 10) + 3
+      end
+    }
+
+    machine.join(*fibers)
+    assert_equal [11, 12, 21, 13, 22, 31, 23, 32, 41, 33, 42, 51, 43, 52, 61, 53, 62, 71, 63, 72, 81, 73, 82, 83], buf
+  end
 end
 
 class QueueTest < UMBaseTest
@@ -1310,12 +1560,67 @@ class PipeTest < UMBaseTest
   end
 end
 
+class PidfdTest < UMBaseTest
+  def test_pidfd_open
+    pid = fork { exit 13 }
+    fd = UM.pidfd_open(pid)
+    assert_kind_of Integer, fd
+
+    pid2, status = machine.waitid(P_PIDFD, fd, UM::WEXITED)
+    assert_equal pid, pid2
+    assert_equal 13, status
+  ensure
+    machine.close(fd) rescue nil
+    Process.wait(pid) rescue nil
+  end
+
+  def test_pidfd_open_invalid_pid
+    assert_raises(SystemCallError) { UM.pidfd_open(Process.pid + 1) }
+  end
+
+  def test_pidfd_send_signal
+    fd = UM.pidfd_open(Process.pid)
+    buf = []
+    trap('SIGUSR1') { buf << :SIGUSR1 }
+
+    ret = UM.pidfd_send_signal(fd, UM::SIGUSR1)
+    assert_equal fd, ret
+    sleep 0.01
+
+    assert_equal [:SIGUSR1], buf
+  ensure
+    machine.close(fd) rescue nil
+  end
+
+  def test_pidfd_send_signal_test
+    fd = UM.pidfd_open(Process.pid)
+    buf = []
+    trap('SIGUSR1') { buf << :SIGUSR1 }
+
+    ret = UM.pidfd_send_signal(fd, 0)
+    assert_equal fd, ret
+    sleep 0.01
+    assert_equal [], buf
+
+    pid = fork { exit 13 }
+    fd2 = UM.pidfd_open(pid)
+    assert_kind_of Integer, fd2
+
+    Process.wait(pid)
+    assert_raises(SystemCallError) { UM.pidfd_send_signal(fd2, 0) }
+  ensure
+    machine.close(fd) rescue nil
+    machine.close(fd2) rescue nil
+    Process.wait(pid) rescue nil
+  end
+end
+
 class PollTest < UMBaseTest
   def test_poll
     rfd, wfd = UM.pipe
 
     events = []
-    f1 = machine.spin do
+    machine.spin do
       events << :pre
       events << machine.poll(rfd, UM::POLLIN)
       events << :post
@@ -1341,38 +1646,81 @@ class PollTest < UMBaseTest
   end
 end
 
-class WaitTest < UMBaseTest
-  def test_waitpid
-    skip if UM.kernel_version < 607
-
+class WaitidTest < UMBaseTest
+  def test_waitid
     msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    child_pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
 
-    rfd, wfd = UM.pipe
-    pid = fork do
+    pid, status = machine.waitid(UM::P_PID, child_pid, UM::WEXITED)
+    assert_equal child_pid, pid
+    assert_equal 42, status
+  ensure
+    Process.wait(child_pid) rescue nil
+  end
+
+  def test_waitid_invalid_pid
+    assert_raises(Errno::ECHILD) {
+      machine.waitid(UM::P_PID, Process.pid + 1, UM::WEXITED)
+    }
+  end
+
+  def test_waitid_invalid_idtype
+    assert_raises(Errno::EINVAL) {
+      machine.waitid(1234, 0, UM::WEXITED)
+    }
+  end
+
+  def test_waitid_invalid_options
+    assert_raises(Errno::EINVAL) {
+      machine.waitid(P_ALL, 0, 1234)
+    }
+  end
+
+  def test_waitid_P_ALL
+    msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    child_pid = fork do
       m = UM.new
       m.write(wfd, msg)
       m.close(wfd)
       exit 42
     end
 
-    ret = machine.waitpid(pid, UM::WEXITED)
-    assert_kind_of Array, ret
-    assert_equal [pid, 42], ret
+    pid, status = machine.waitid(UM::P_ALL, 0, UM::WEXITED)
+    assert_equal child_pid, pid
+    assert_equal 42, status
+  ensure
+    Process.wait(child_pid) rescue nil
+  end
 
-    buf = +''
-    ret = machine.read(rfd, buf, 8192)
-    assert_equal msg.bytesize, ret
-    assert_equal msg, buf
+  def test_waitid_P_PGID
+    msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    child_pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
+
+    pid, status = machine.waitid(UM::P_PGID, Process.getpgrp, UM::WEXITED)
+    assert_equal child_pid, pid
+    assert_equal 42, status
   ensure
-    Process.wait(pid) rescue Errno::ECHILD
+    Process.wait(child_pid) rescue nil
   end
 
-  def test_waitpid_any
-    skip if UM.kernel_version < 607
+  def test_waitid_status
+    skip if !machine.respond_to?(:waitid_status)
 
     msg = 'hello from child'
-
-    rfd, wfd = UM.pipe
+    _rfd, wfd = UM.pipe
     pid = fork do
       m = UM.new
       m.write(wfd, msg)
@@ -1380,23 +1728,76 @@ class WaitTest < UMBaseTest
       exit 42
     end
 
-    ret = machine.waitpid(0, UM::WEXITED)
-    assert_kind_of Array, ret
-    assert_equal [pid, 42], ret
+    status = machine.waitid_status(UM::P_PID, pid, UM::WEXITED)
+    assert_kind_of Process::Status, status
+    assert_equal pid, status.pid
+    assert_equal 42, status.exitstatus
+  ensure
+    Process.wait(pid) rescue nil
+  end
 
-    buf = +''
-    ret = machine.read(rfd, buf, 8192)
-    assert_equal msg.bytesize, ret
-    assert_equal msg, buf
+  def test_waitid_status_invalid_pid
+    skip if !machine.respond_to?(:waitid_status)
+
+    assert_raises(Errno::ECHILD) {
+      machine.waitid_status(UM::P_PID, Process.pid + 1, UM::WEXITED)
+    }
+  end
+
+  def test_waitid_status_invalid_idtype
+    skip if !machine.respond_to?(:waitid_status)
 
+    assert_raises(Errno::EINVAL) {
+      machine.waitid_status(1234, 0, UM::WEXITED)
+    }
+  end
+
+  def test_waitid_status_invalid_options
+    skip if !machine.respond_to?(:waitid_status)
+
+    assert_raises(Errno::EINVAL) {
+      machine.waitid_status(P_ALL, 0, 1234)
+    }
+  end
+
+  def test_waitid_status_P_ALL
+    skip if !machine.respond_to?(:waitid_status)
+
+    msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
+
+    status = machine.waitid_status(UM::P_ALL, 0, UM::WEXITED)
+    assert_kind_of Process::Status, status
+    assert_equal pid, status.pid
+    assert_equal 42, status.exitstatus
   ensure
-    Process.wait(pid) rescue Errno::ECHILD
+    Process.wait(pid) rescue nil
   end
 
-  def test_waitpid_bad_pid
-    skip if UM.kernel_version < 607
+  def test_waitid_status_P_PGID
+    skip if !machine.respond_to?(:waitid_status)
+
+    msg = 'hello from child'
+    _rfd, wfd = UM.pipe
+    pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
 
-    assert_raises(Errno::ECHILD) { machine.waitpid(1, UM::WEXITED) }
+    status = machine.waitid_status(UM::P_PGID, Process.getpgrp, UM::WEXITED)
+    assert_kind_of Process::Status, status
+    assert_equal pid, status.pid
+    assert_equal 42, status.exitstatus
+  ensure
+    Process.wait(pid) rescue nil
   end
 end
 
@@ -1484,7 +1885,7 @@ class ForkTest < UMBaseTest
     assert_equal 3, ret
     assert_equal 'foo', buf
   ensure
-    Process.wait(child_pid) rescue Errno::ECHILD
+    Process.wait(child_pid) rescue nil
   end
 end
 
@@ -1548,3 +1949,20 @@ class SendBundleTest < UMBaseTest
     assert_equal strs.map(&:to_s).join, buf
   end
 end
+
+class NonBlockTest < UMBaseTest
+  def test_io_nonblock?
+    assert_equal false, UM.io_nonblock?(STDIN)
+  end
+
+  def test_io_set_nonblock
+    r, _w = IO.pipe
+    assert_equal true, UM.io_nonblock?(r)
+
+    UM.io_set_nonblock(r, false)
+    assert_equal false, UM.io_nonblock?(r)
+
+    UM.io_set_nonblock(r, true)
+    assert_equal true, UM.io_nonblock?(r)
+  end
+end