uringmachine 0.1

data/test/test_iou.rb

@@ -0,0 +1,876 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+require 'socket'
+
+class IOURingTest < IOURingBaseTest
+  def test_close
+    ring2 = IOU::Ring.new
+    refute ring2.closed?
+
+    ring2.close
+    assert ring2.closed?
+  end
+
+  def test_pending_ops
+    assert_equal({}, ring.pending_ops)
+
+    id = ring.prep_timeout(interval: 1)
+    spec = ring.pending_ops[id].spec
+    assert_equal id, spec[:id]
+    assert_equal :timeout, spec[:op]
+    assert_equal 1, spec[:interval]
+
+    ring.prep_cancel(id)
+    ring.submit
+    ring.process_completions(true)
+
+    assert_nil ring.pending_ops[id]
+  end
+end
+
+class PrepTimeoutTest < IOURingBaseTest
+  def test_prep_timeout
+    interval = 0.03
+
+    t0 = monotonic_clock
+    id = ring.prep_timeout(interval: interval)
+    assert_equal 1, id
+
+    ring.submit
+    c = ring.wait_for_completion
+    elapsed = monotonic_clock - t0
+    assert_in_range interval..(interval + 0.02), elapsed
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :timeout, c[:op]
+    assert_equal interval, c[:interval]
+    assert_equal (-Errno::ETIME::Errno), c[:result]
+  end
+
+  def test_prep_timeout_invalid_args
+    assert_raises(ArgumentError) { ring.prep_timeout() }
+    assert_raises(ArgumentError) { ring.prep_timeout(foo: 1) }
+    assert_raises(ArgumentError) { ring.prep_timeout(1) }
+  end
+end
+
+class PrepCancelTest < IOURingBaseTest
+  def test_prep_cancel
+    interval = 15
+    timeout_id = ring.prep_timeout(interval: interval)
+    assert_equal 1, timeout_id
+
+    cancel_id = ring.prep_cancel(timeout_id)
+    assert_equal 2, cancel_id
+
+    ring.submit
+    c = ring.wait_for_completion
+    assert_equal cancel_id, c[:id]
+    assert_equal 0, c[:result]
+
+    c = ring.wait_for_completion
+    assert_equal timeout_id, c[:id]
+    assert_equal :timeout, c[:op]
+    assert_equal interval, c[:interval]
+    assert_equal (-Errno::ECANCELED::Errno), c[:result]
+  end
+
+  def test_prep_cancel_kw
+    interval = 15
+    timeout_id = ring.prep_timeout(interval: interval)
+    assert_equal 1, timeout_id
+
+    cancel_id = ring.prep_cancel(id: timeout_id)
+    assert_equal 2, cancel_id
+
+    ring.submit
+    c = ring.wait_for_completion
+    assert_equal cancel_id, c[:id]
+    assert_equal 0, c[:result]
+
+    c = ring.wait_for_completion
+    assert_equal timeout_id, c[:id]
+    assert_equal :timeout, c[:op]
+    assert_equal interval, c[:interval]
+    assert_equal (-Errno::ECANCELED::Errno), c[:result]
+  end
+
+  def test_prep_cancel_invalid_args
+    assert_raises(ArgumentError) { ring.prep_cancel() }
+    assert_raises(ArgumentError) { ring.prep_cancel('foo') }
+    assert_raises(ArgumentError) { ring.prep_cancel({}) }
+    assert_raises(TypeError) { ring.prep_cancel(id: 'bar') }
+  end
+
+  def test_prep_cancel_invalid_id
+    cancel_id = ring.prep_cancel(id: 42)
+    assert_equal 1, cancel_id
+
+    ring.submit
+    c = ring.wait_for_completion
+    assert_equal cancel_id, c[:id]
+    assert_equal (-Errno::ENOENT::Errno), c[:result]
+  end
+end
+
+class PrepTimeoutMultishotTest < IOURingBaseTest
+  def test_prep_timeout_multishot
+    interval = 0.03
+    count = 0
+    cancelled = false
+
+    t0 = monotonic_clock
+    id = ring.prep_timeout(interval: interval, multishot: true) do |c|
+      case c[:result]
+      when (-Errno::ETIME::Errno)
+        count += 1
+      when (-Errno::ECANCELED::Errno)
+        cancelled = true
+      end
+    end
+    ring.submit
+
+    ring.process_completions(true)
+    elapsed = monotonic_clock - t0
+    assert_in_range interval..(interval + 0.02), elapsed
+    assert_equal 1, count
+
+    t0 = monotonic_clock
+    ring.process_completions(true)
+    elapsed = monotonic_clock - t0
+    assert_in_range (interval - 0.01)..(interval + 0.02), elapsed
+    assert_equal 2, count
+
+    t0 = monotonic_clock
+    ring.process_completions(true)
+    elapsed = monotonic_clock - t0
+    assert_in_range (interval - 0.01)..(interval + 0.02), elapsed
+    assert_equal 3, count
+
+    ring.prep_cancel(id)
+    ring.submit
+    ring.process_completions(true)
+    assert_equal true, cancelled
+    assert_equal 3, count
+    assert_nil ring.pending_ops[id]
+  end
+end
+
+class PrepWriteTest < IOURingBaseTest
+  def test_prep_write
+    r, w = IO.pipe
+    s = 'foobar'
+
+    id = ring.prep_write(fd: w.fileno, buffer: s)
+    assert_equal 1, id
+
+    ring.submit
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :write, c[:op]
+    assert_equal w.fileno, c[:fd]
+    assert_equal s.bytesize, c[:result]
+
+    w.close
+    assert_equal s, r.read
+  end
+
+  def test_prep_write_with_len
+    r, w = IO.pipe
+    s = 'foobar'
+
+    id = ring.prep_write(fd: w.fileno, buffer: s, len: 3)
+    assert_equal 1, id
+
+    ring.submit
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :write, c[:op]
+    assert_equal w.fileno, c[:fd]
+    assert_equal 3, c[:result]
+
+    w.close
+    assert_equal s[0..2], r.read
+  end
+
+  def test_prep_write_invalid_args
+    assert_raises(ArgumentError) { ring.prep_write() }
+    assert_raises(ArgumentError) { ring.prep_write(foo: 1) }
+    assert_raises(ArgumentError) { ring.prep_write(fd: 'bar') }
+    assert_raises(ArgumentError) { ring.prep_write({}) }
+  end
+
+  def test_prep_write_invalid_fd
+    r, _w = IO.pipe
+    s = 'foobar'
+
+    id = ring.prep_write(fd: r.fileno, buffer: s)
+    assert_equal 1, id
+
+    ring.submit
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :write, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal (-Errno::EBADF::Errno), c[:result]
+  end
+end
+
+class PrepNopTest < IOURingBaseTest
+  def test_prep_nop
+    id = ring.prep_nop
+    assert_equal 1, id
+
+    ring.submit
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_nil c[:op]
+    assert_equal 0, c[:result]
+  end
+
+  def test_nop_as_signal
+    s1 = Queue.new
+    s2 = Queue.new
+    s3 = Queue.new
+    s4 = Queue.new
+
+    signaller = Thread.new do
+      s1.pop
+      id = ring.prep_nop
+      ring.submit
+      s2 << id
+    end
+
+    waiter = Thread.new do
+      s3.pop
+      s4 << ring.wait_for_completion
+    end
+
+    s3 << 'go'
+    s1 << 'go'
+    id = s2.pop
+    c = s4.pop
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_nil c[:op]
+    assert_equal 0, c[:result]    
+  ensure
+    signaller&.kill rescue nil
+    waiter&.kill rescue nil
+  end
+end
+
+class ProcessCompletionsTest < IOURingBaseTest
+  def test_process_completions_no_wait
+    ret = ring.process_completions
+    assert_equal 0, ret
+
+    (1..3).each do |i|
+      id = ring.prep_nop
+      assert_equal i, id
+    end
+
+    ring.submit
+    sleep 0.001
+
+    ret = ring.process_completions
+    assert_equal 3, ret
+  end
+
+  def test_process_completions_wait
+    (1..3).each do |i|
+      id = ring.prep_nop
+      assert_equal i, id
+    end
+
+    ring.submit
+    ret = ring.process_completions(true)
+    assert_equal 3, ret
+  end
+
+  def test_process_completions_with_block
+    r, w = IO.pipe
+
+    ring.prep_write(fd: w.fileno, buffer: 'foo')
+    ring.prep_write(fd: w.fileno, buffer: 'bar')
+    ring.prep_write(fd: w.fileno, buffer: 'baz')
+    ring.submit
+    sleep 0.01
+
+    completions = []
+
+    ret = ring.process_completions do |c|
+      completions << c
+    end
+
+    assert_equal 3, ret
+    assert_equal 3, completions.size
+    assert_equal [1, 2, 3], completions.map { _1[:id] }
+    assert_equal [:write], completions.map { _1[:op] }.uniq
+    assert_equal 9, completions.inject(0) { |t, c| t + c[:result] }
+
+    w.close
+    assert_equal 'foobarbaz', r.read
+  end
+
+  def test_process_completions_op_with_block
+    cc = []
+
+    ring.prep_timeout(interval: 0.01) { cc << 1 }
+    ring.prep_timeout(interval: 0.02) { cc << 2 }
+    ring.submit
+
+    ret = ring.process_completions
+    assert_equal 0, ret
+    assert_equal [], cc
+
+    sleep 0.02
+    ret = ring.process_completions(true)
+
+    assert_equal 2, ret
+    assert_equal [1, 2], cc
+  end
+
+  def test_process_completions_op_with_block_no_submit
+    cc = []
+
+    ring.prep_timeout(interval: 0.01) { cc << 1 }
+    ring.prep_timeout(interval: 0.02) { cc << 2 }
+
+    ret = ring.process_completions
+    assert_equal 0, ret
+    assert_equal [], cc
+
+    sleep 0.02
+    ret = ring.process_completions(true)
+    assert_equal 2, ret
+    assert_equal [1, 2], cc
+  end
+end
+
+class PrepReadTest < IOURingBaseTest
+  def test_prep_read
+    r, w = IO.pipe
+    s = 'foobar'
+
+    id = ring.prep_read(fd: r.fileno, buffer: +'', len: 8192)
+    assert_equal 1, id
+    ring.submit
+
+    w << s
+
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal s.bytesize, c[:result]
+    assert_equal s, c[:buffer]
+  end
+
+  def test_prep_read_empty
+    r, w = IO.pipe
+
+    id = ring.prep_read(fd: r.fileno, buffer: +'', len: 8192)
+    assert_equal 1, id
+    ring.submit
+
+    w.close
+
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal 0, c[:result]
+    assert_equal '', c[:buffer]
+  end
+
+  def test_prep_read_invalid_args
+    assert_raises(ArgumentError) { ring.prep_read() }
+    assert_raises(ArgumentError) { ring.prep_read(foo: 1) }
+    assert_raises(ArgumentError) { ring.prep_read(fd: 'bar', buffer: +'') }
+    assert_raises(ArgumentError) { ring.prep_read({}) }
+  end
+
+  def test_prep_read_bad_fd
+    _r, w = IO.pipe
+
+    id = ring.prep_read(fd: w.fileno, buffer: +'', len: 8192)
+    assert_equal 1, id
+
+    ring.submit
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal w.fileno, c[:fd]
+    assert_equal (-Errno::EBADF::Errno), c[:result]
+  end
+
+  def test_prep_read_with_block
+    r, w = IO.pipe
+    w << 'foobar'
+
+    cc = nil
+    id = ring.prep_read(fd: r.fileno, buffer: +'', len: 3) do |c|
+      cc = c
+    end
+
+    ring.submit
+    ring.process_completions
+
+    assert_kind_of Hash, cc
+    assert_equal id, cc[:id]
+    assert_equal :read, cc[:op]
+    assert_equal r.fileno, cc[:fd]
+    assert_equal 3, cc[:result]
+    assert_equal 'foo', cc[:buffer]
+
+    id = ring.prep_read(fd: r.fileno, buffer: +'', len: 5) do |c|
+      cc = c
+    end
+    assert_equal 'foo', cc[:buffer]
+
+    ring.submit
+    ring.process_completions
+
+    assert_kind_of Hash, cc
+    assert_equal id, cc[:id]
+    assert_equal :read, cc[:op]
+    assert_equal r.fileno, cc[:fd]
+    assert_equal 3, cc[:result]
+    assert_equal 'bar', cc[:buffer]
+  end
+
+  def test_prep_read_with_buffer_offset
+    buffer = +'foo'
+
+    r, w = IO.pipe
+    w << 'bar'
+
+    id = ring.prep_read(fd: r.fileno, buffer: buffer, len: 100, buffer_offset: buffer.bytesize)
+    ring.submit
+    cc = ring.wait_for_completion
+
+    assert_kind_of Hash, cc
+    assert_equal id, cc[:id]
+    assert_equal :read, cc[:op]
+    assert_equal r.fileno, cc[:fd]
+    assert_equal 3, cc[:result]
+    assert_equal 'foobar', buffer
+  end
+
+  def test_prep_read_with_negative_buffer_offset
+    buffer = +'foo'
+
+    r, w = IO.pipe
+    w << 'bar'
+
+    id = ring.prep_read(fd: r.fileno, buffer: buffer, len: 100, buffer_offset: -1)
+    ring.submit
+    cc = ring.wait_for_completion
+
+    assert_kind_of Hash, cc
+    assert_equal id, cc[:id]
+    assert_equal :read, cc[:op]
+    assert_equal r.fileno, cc[:fd]
+    assert_equal 3, cc[:result]
+    assert_equal 'foobar', buffer
+
+
+
+    buffer = +'foogrr'
+
+    r, w = IO.pipe
+    w << 'bar'
+
+    id = ring.prep_read(fd: r.fileno, buffer: buffer, len: 100, buffer_offset: -4)
+    ring.submit
+    cc = ring.wait_for_completion
+
+    assert_kind_of Hash, cc
+    assert_equal id, cc[:id]
+    assert_equal :read, cc[:op]
+    assert_equal r.fileno, cc[:fd]
+    assert_equal 3, cc[:result]
+    assert_equal 'foobar', buffer
+  end
+end
+
+class PrepCloseTest < IOURingBaseTest
+  def test_prep_close
+    _r, w = IO.pipe
+    fd = w.fileno
+
+    id = ring.prep_close(fd: fd)
+    assert_equal 1, id
+    ring.submit
+
+    c = ring.wait_for_completion
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :close, c[:op]
+    assert_equal fd, c[:fd]
+    assert_equal 0, c[:result]
+
+    assert_raises(Errno::EBADF) { w << 'fail' }
+
+    id = ring.prep_close(fd: fd)
+    assert_equal 2, id
+    ring.submit
+
+    c = ring.wait_for_completion
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :close, c[:op]
+    assert_equal fd, c[:fd]
+    assert_equal (-Errno::EBADF::Errno), c[:result]
+
+  end
+
+  def test_prep_close_invalid_args
+    assert_raises(ArgumentError) { ring.prep_close() }
+    assert_raises(ArgumentError) { ring.prep_close({}) }
+    assert_raises(ArgumentError) { ring.prep_close(foo: 1) }
+    assert_raises(TypeError) { ring.prep_close(fd: 'bar') }
+  end
+
+  def test_prep_close_invalid_fd
+    id = ring.prep_close(fd: 9999)
+    assert_equal 1, id
+
+    ring.submit
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :close, c[:op]
+    assert_equal 9999, c[:fd]
+    assert_equal (-Errno::EBADF::Errno), c[:result]
+  end
+end
+
+class PrepAcceptTest < IOURingBaseTest
+  def setup
+    super
+    @port = 9000 + rand(1000)
+    @server = TCPServer.open('127.0.0.1', @port)
+  end
+
+  def teardown
+    @server.close
+    super
+  end
+
+  def test_prep_accept
+    id = ring.prep_accept(fd: @server.fileno)
+    ring.submit
+
+    t = Thread.new do
+      TCPSocket.new('127.0.0.1', @port)
+    end
+
+    c = ring.wait_for_completion
+    assert_equal id, c[:id]
+    assert_equal :accept, c[:op]
+    fd = c[:result]
+    assert fd > 0
+  ensure
+    t&.kill rescue nil
+  end
+
+  def test_prep_accept_invalid_args
+    assert_raises(ArgumentError) { ring.prep_accept() }
+    assert_raises(ArgumentError) { ring.prep_accept(foo: 1) }
+    assert_raises(TypeError) { ring.prep_accept(fd: 'bar') }
+    assert_raises(ArgumentError) { ring.prep_accept({}) }
+  end
+
+  def test_prep_accept_bad_fd
+    id = ring.prep_accept(fd: STDIN.fileno)
+    assert_equal 1, id
+
+    ring.submit
+    c = ring.wait_for_completion
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :accept, c[:op]
+    assert_equal STDIN.fileno, c[:fd]
+    assert_equal (-Errno::ENOTSOCK::Errno), c[:result]
+  end
+
+  def test_prep_accept_multishot
+    id = ring.prep_accept(fd: @server.fileno, multishot: true)
+    ring.submit
+
+    tt = []
+
+    connect = -> {
+      tt << Thread.new do
+        TCPSocket.new('127.0.0.1', @port)
+      end
+    }
+
+    fds = []
+
+    3.times do |i|
+      connect.call
+      c = ring.wait_for_completion
+      assert_equal id, c[:id]
+      assert_equal :accept, c[:op]
+      fd = c[:result]
+      assert fd > 0
+      assert ring.pending_ops[id]
+
+      fds << fd
+    end
+
+    assert_equal 3, fds.uniq.size
+
+    ring.prep_cancel(id)
+    ring.process_completions
+
+    assert_nil ring.pending_ops[id]
+  ensure
+    tt.each { |t| t&.kill rescue nil }
+  end
+end
+
+class EmitTest < IOURingBaseTest
+  def test_emit
+    o = { foo: 'bar' }
+    id = ring.emit(o)
+    assert_equal 1, id
+
+    c = ring.wait_for_completion
+    assert_equal o, c
+    assert_equal id, c[:id]
+    assert_equal :emit, c[:op]
+    assert_equal 0, c[:result]
+  end
+end
+
+class ProcessCompletionsLoopTest < IOURingBaseTest
+  def test_loop_stop
+    ring.emit(signal: :stop)
+
+    cc = []
+    ring.process_completions_loop do |c|
+      p c
+      cc << c
+    end
+
+    assert_equal [], cc
+  end
+
+  def test_loop
+    ring.emit(value: 1)
+    ring.emit(value: 2)
+    ring.emit(value: 3)
+    ring.emit(signal: :stop)
+    ring.emit(value: 4)
+
+    cc = []
+    ring.process_completions_loop do |c|
+      cc << c
+    end
+    assert_equal (1..3).to_a, cc.map { _1[:value] }
+
+    c = ring.wait_for_completion
+    assert_equal 4, c[:value]
+  end
+end
+
+class PrepReadMultishotTest < IOURingBaseTest
+  def test_prep_read_multishot_invalid_args
+    assert_raises(ArgumentError) { ring.prep_read(multishot: true, buffer_group: 1) }
+    assert_raises(ArgumentError) { ring.prep_read(multishot: true, foo: 1) }
+    assert_raises(ArgumentError) { ring.prep_read(multishot: true, fd: 'bar', buffer: +'') }
+    assert_raises(ArgumentError) { ring.prep_read(multishot: true) }
+  end
+
+  def test_prep_read_multishot
+    r, w = IO.pipe
+
+    bgid = ring.setup_buffer_ring(size: 4096, count: 1024)
+    assert_equal 0, bgid
+
+    id = ring.prep_read(fd: r.fileno, multishot: true, buffer_group: bgid)
+    assert_equal 1, id
+    ring.submit
+
+    w << 'foo'
+    c = ring.wait_for_completion
+
+    # make sure the OS supports this op (the liburing docs are not clear)
+    skip if c[:result] == (-Errno::EINVAL::Errno)
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal 3, c[:result]
+    assert_equal 'foo', c[:buffer]
+    assert_equal Encoding::ASCII_8BIT, c[:buffer].encoding
+    refute_nil ring.pending_ops[id]
+
+    w << 'bar'
+    c = ring.wait_for_completion
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal 3, c[:result]
+    assert_equal 'bar', c[:buffer]
+    refute_nil ring.pending_ops[id]
+
+    w.close
+    c = ring.wait_for_completion
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal 0, c[:result]
+    assert_nil ring.pending_ops[id]
+  end
+
+  def test_prep_read_multishot_utf8
+    r, w = IO.pipe
+
+    bgid = ring.setup_buffer_ring(size: 4096, count: 1024)
+    assert_equal 0, bgid
+
+    id = ring.prep_read(fd: r.fileno, multishot: true, utf8: true, buffer_group: bgid)
+    assert_equal 1, id
+    ring.submit
+
+    w << 'foo'
+    c = ring.wait_for_completion
+
+    # make sure the OS supports this op (the liburing docs are not clear)
+    skip if c[:result] == (-Errno::EINVAL::Errno)
+
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal 3, c[:result]
+    assert_equal 'foo', c[:buffer]
+    assert_equal Encoding::UTF_8, c[:buffer].encoding
+    refute_nil ring.pending_ops[id]
+
+    w << 'bar'
+    c = ring.wait_for_completion
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal 3, c[:result]
+    assert_equal 'bar', c[:buffer]
+    refute_nil ring.pending_ops[id]
+
+    w.close
+    c = ring.wait_for_completion
+    assert_kind_of Hash, c
+    assert_equal id, c[:id]
+    assert_equal :read, c[:op]
+    assert_equal r.fileno, c[:fd]
+    assert_equal 0, c[:result]
+    assert_nil ring.pending_ops[id]
+  end
+end
+
+class OpCtxTest < IOURingBaseTest
+  def test_ctx_spec
+    id = ring.emit(foo: :bar)
+    assert_equal({ foo: :bar, id: 1, op: :emit }, ring.pending_ops[id].spec)
+  end
+
+  def test_ctx_type
+    id = ring.emit(v: 1)
+    assert_equal 1, id
+    assert_equal :emit, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_timeout(interval: 1)
+    assert_equal 2, id
+    assert_equal :timeout, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_read(fd: STDIN.fileno, buffer: +'', len: 42)
+    assert_equal 3, id
+    assert_equal :read, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_write(fd: STDOUT.fileno, buffer: '')
+    assert_equal 4, id
+    assert_equal :write, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_accept(fd: STDIN.fileno)
+    assert_equal 5, id
+    assert_equal :accept, ring.pending_ops[id].spec[:op]
+
+    id = ring.prep_close(fd: STDIN.fileno)
+    assert_equal 6, id
+    assert_equal :close, ring.pending_ops[id].spec[:op]
+  end
+end
+
+class LinkTest < IOURingBaseTest
+  def test_linked_submissions
+    r, w = IO.pipe
+    id1 = ring.prep_write(fd: w.fileno, buffer: 'foo', link: true)
+    id2 = ring.prep_write(fd: w.fileno, buffer: 'bar')
+
+    ret = ring.submit
+    assert_equal 2, ret
+
+    ret = ring.process_completions(true)
+    assert_equal 2, ret
+
+    w.close
+    assert_equal 'foobar', r.read
+  end
+end
+
+class RactorTest < Minitest::Test
+  def test_ractor
+    # Ractor is still experimental in Ruby 3.x.x
+    old_warning_status = Warning[:experimental]
+    Warning[:experimental] = false
+
+    r, w = IO.pipe
+
+    w << 'foobar'
+
+    ractor = Ractor.new(r.fileno) do |fd|
+      ring = IOU::Ring.new
+      id = ring.prep_read(fd: fd, buffer: +'', len: 42)
+      ring.submit
+      c = ring.wait_for_completion
+      [id, c]
+    end
+
+    id, c = ractor.take
+    assert_equal 1, id
+    assert_kind_of Hash, c
+    assert_equal :read, c[:op]
+    assert_equal 'foobar', c[:buffer]
+
+  ensure
+    Warning[:experimental] = old_warning_status
+  end
+end