uringmachine 0.31.0 → 0.33.0

data/test/{test_connection.rb → test_io.rb}

@@ -5,13 +5,13 @@ require 'securerandom'
 require 'openssl'
 require 'localhost/authority'
 
-class ConnectionBaseTest < UMBaseTest
+class IOBaseTest < UMBaseTest
   attr_reader :conn
 
   def setup
     super
     @rfd, @wfd = UM.pipe
-    @conn = UM::Connection.new(@machine, @rfd)
+    @conn = UM::IO.new(@machine, @rfd)
   end
 
   def teardown
@@ -22,7 +22,7 @@ class ConnectionBaseTest < UMBaseTest
   end
 end
 
-class ConnectionTest < ConnectionBaseTest
+class IOTest < IOBaseTest
   def buffer_metrics
     machine.metrics.fetch_values(
       :buffers_allocated,
@@ -33,7 +33,7 @@ class ConnectionTest < ConnectionBaseTest
     )
   end
 
-  def test_connection_basic_usage
+  def test_io_basic_usage
     assert_equal [0, 0, 0, 0, 0], buffer_metrics
     machine.write(@wfd, "foobar")
     machine.close(@wfd)
@@ -53,9 +53,9 @@ class ConnectionTest < ConnectionBaseTest
     assert_equal 0, machine.metrics[:ops_pending]
   end
 
-  def test_connection_clear
+  def test_io_clear
     rfd, wfd = UM.pipe
-    conn = UM::Connection.new(machine, rfd)
+    conn = UM::IO.new(machine, rfd)
 
     assert_equal [0, 0, 0, 0, 0], buffer_metrics
     machine.write(wfd, "foobar")
@@ -77,9 +77,9 @@ class ConnectionTest < ConnectionBaseTest
     machine.close(wfd) rescue nil
   end
 
-  def test_connection_big_read
+  def test_io_big_read
     s1, s2 = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
-    conn = UM::Connection.new(machine, s2)
+    conn = UM::IO.new(machine, s2)
 
     msg = '1234567' * 20000
 
@@ -96,9 +96,9 @@ class ConnectionTest < ConnectionBaseTest
     machine.join(f)
   end
 
-  def test_connection_buffer_reuse
+  def test_io_buffer_reuse
     s1, s2 = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
-    conn = UM::Connection.new(machine, s2)
+    conn = UM::IO.new(machine, s2)
 
     msg = '1234567' * 20000
 
@@ -131,7 +131,7 @@ class ConnectionTest < ConnectionBaseTest
     machine.join(f)
   end
 
-  def test_connection_read_line
+  def test_io_read_line
     machine.write(@wfd, "foo\nbar\r\nbaz")
     machine.close(@wfd)
 
@@ -145,7 +145,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_equal "baz", conn.read(-6)
   end
 
-  def test_connection_read_line_segmented
+  def test_io_read_line_segmented
     machine.write(@wfd, "foo\n")
     assert_equal 'foo', conn.read_line(0)
 
@@ -163,7 +163,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_nil conn.read_line(0)
   end
 
-  def test_connection_read_line_maxlen
+  def test_io_read_line_maxlen
     machine.write(@wfd, "foobar\r\n")
 
     assert_nil conn.read_line(3)
@@ -188,7 +188,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_equal [16, 0, 256, 16384 * 16, 16384 * 16 - 17], buffer_metrics
   end
 
-  def test_connection_read
+  def test_io_read
     machine.write(@wfd, "foobarbazblahzzz")
     machine.close(@wfd)
 
@@ -198,7 +198,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_nil conn.read(4)
   end
 
-  def test_connection_read_zero_len
+  def test_io_read_zero_len
     machine.write(@wfd, "foobar")
 
     assert_equal 'foobar', conn.read(0)
@@ -209,7 +209,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_nil conn.read(0)
   end
 
-  def test_connection_read_negative_len
+  def test_io_read_negative_len
     machine.write(@wfd, "foobar")
 
     assert_equal 'foo', conn.read(-3)
@@ -221,7 +221,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_nil conn.read(-3)
   end
 
-  def test_connection_read_to_delim
+  def test_io_read_to_delim
     machine.write(@wfd, "abc,def,ghi")
     machine.close(@wfd)
 
@@ -233,7 +233,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_equal 'ghi', conn.read_to_delim(',', -3)
   end
 
-  def test_connection_read_to_delim_invalid_delim
+  def test_io_read_to_delim_invalid_delim
     machine.write(@wfd, "abc,def,ghi")
 
     assert_raises(ArgumentError) { conn.read_to_delim(:foo, 0) }
@@ -242,7 +242,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_raises(UM::Error) { conn.read_to_delim('🙂', 0) }
   end
 
-  def test_connection_skip
+  def test_io_skip
     machine.write(@wfd, "foobarbaz")
 
     conn.skip(2)
@@ -252,7 +252,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_equal 'az', conn.read(0)
   end
 
-  def test_connection_big_data
+  def test_io_big_data
     data = SecureRandom.random_bytes(300_000)
     fiber = machine.spin {
       machine.writev(@wfd, data)
@@ -273,7 +273,7 @@ class ConnectionTest < ConnectionBaseTest
     assert_equal data, received.join
   end
 
-  def test_connection_read_each
+  def test_io_read_each
     bufs = []
     f = machine.spin do
       bufs << :ready
@@ -307,13 +307,13 @@ class ConnectionTest < ConnectionBaseTest
   end
 end
 
-class ConnectionWriteTest < UMBaseTest
+class IOWriteTest < UMBaseTest
   attr_reader :conn
 
   def setup
     super
     @s1, @s2 = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
-    @conn = UM::Connection.new(@machine, @s1)
+    @conn = UM::IO.new(@machine, @s1)
   end
 
   def teardown
@@ -323,7 +323,7 @@ class ConnectionWriteTest < UMBaseTest
     super
   end
 
-  def test_connection_write_single_buf
+  def test_io_write_single_buf
     assert_equal 3, conn.write('foo')
 
     buf = +''
@@ -331,7 +331,7 @@ class ConnectionWriteTest < UMBaseTest
     assert_equal 'foo', buf
   end
 
-  def test_connection_write_multi_buf
+  def test_io_write_multi_buf
     assert_equal 6, conn.write('foo', 'bar')
 
     buf = +''
@@ -339,8 +339,8 @@ class ConnectionWriteTest < UMBaseTest
     assert_equal 'foobar', buf
   end
 
-  def test_connection_write_socket_mode
-    conn = machine.connection(@s2, :socket)
+  def test_io_write_socket_mode
+    conn = machine.io(@s2, :socket)
 
     assert_equal 6, conn.write('foo', 'bar')
 
@@ -349,7 +349,7 @@ class ConnectionWriteTest < UMBaseTest
     assert_equal 'foobar', buf
   end
 
-  def test_connection_write_ssl_mode
+  def test_io_write_ssl_mode
     ssl1 = OpenSSL::SSL::SSLSocket.new(IO.for_fd(@s1), Localhost::Authority.fetch.server_context)
     ssl1.sync_close = true
     ssl2 = OpenSSL::SSL::SSLSocket.new(IO.for_fd(@s2), OpenSSL::SSL::SSLContext.new)
@@ -363,8 +363,8 @@ class ConnectionWriteTest < UMBaseTest
     ssl2.connect
     refute_equal 0, @machine.metrics[:total_ops]
 
-    conn1 = machine.connection(ssl1)
-    conn2 = machine.connection(ssl2)
+    conn1 = machine.io(ssl1)
+    conn2 = machine.io(ssl2)
 
     assert_equal 10, conn1.write('foobar', "\n", 'baz')
 
@@ -379,8 +379,8 @@ class ConnectionWriteTest < UMBaseTest
   end
 end
 
-class ConnectionRespTest < ConnectionBaseTest
-  def test_connection_resp_read
+class IORespTest < IOBaseTest
+  def test_io_resp_read
     machine.write(@wfd, "+foo bar\r\n")
     assert_equal "foo bar", conn.resp_read
 
@@ -389,12 +389,12 @@ class ConnectionRespTest < ConnectionBaseTest
 
     machine.write(@wfd, "-foobar\r\n")
     o = conn.resp_read
-    assert_kind_of UM::Connection::RESPError, o
+    assert_kind_of UM::IO::RESPError, o
     assert_equal "foobar", o.message
 
     machine.write(@wfd, "!3\r\nbaz\r\n")
     o = conn.resp_read
-    assert_kind_of UM::Connection::RESPError, o
+    assert_kind_of UM::IO::RESPError, o
     assert_equal "baz", o.message
 
     machine.write(@wfd, ":123\r\n")
@@ -443,7 +443,7 @@ class ConnectionRespTest < ConnectionBaseTest
     assert_equal({ 'a' => 42, 'b' => ['foo', 'bar', 'baz'] }, conn.resp_read)
   end
 
-  def test_connection_resp_read_segmented
+  def test_io_resp_read_segmented
     machine.write(@wfd, "\n")
     assert_equal "", conn.read_line(0)
 
@@ -458,8 +458,8 @@ class ConnectionRespTest < ConnectionBaseTest
     assert_equal "bazbug", conn.resp_read
   end
 
-  def test_connection_resp_write
-    writer = machine.connection(@wfd)
+  def test_io_resp_write
+    writer = machine.io(@wfd)
 
     writer.resp_write(nil);
     assert_equal "_\r\n", conn.read(-100)
@@ -489,8 +489,8 @@ class ConnectionRespTest < ConnectionBaseTest
     assert_equal "%2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n:42\r\n", conn.read(-100)
   end
 
-  def test_connection_resp_encode
-    s = UM::Connection
+  def test_io_resp_encode
+    s = UM::IO
     assert_equal "_\r\n",             s.resp_encode(+'', nil)
     assert_equal "#t\r\n",            s.resp_encode(+'', true)
     assert_equal "#f\r\n",            s.resp_encode(+'', false)
@@ -507,7 +507,7 @@ class ConnectionRespTest < ConnectionBaseTest
   end
 end
 
-class ConnectionStressTest < UMBaseTest
+class IOStressTest < UMBaseTest
   def setup
     super
 
@@ -525,7 +525,7 @@ class ConnectionStressTest < UMBaseTest
 
   def start_connection_fiber(fd)
     machine.spin do
-      conn = UM::Connection.new(machine, fd)
+      conn = UM::IO.new(machine, fd)
       while (msg = conn.read_line(0))
         @received << msg
       end
@@ -537,7 +537,7 @@ class ConnectionStressTest < UMBaseTest
     end
   end
 
-  def test_connection_server_big_lines
+  def test_io_server_big_lines
     server_fibers = []
     server_fibers << machine.spin do
       machine.accept_each(@listen_fd) { |fd|
@@ -580,7 +580,7 @@ class ConnectionStressTest < UMBaseTest
     assert_equal msg * client_count, @received.map { it + "\n" }.join
   end
 
-  def test_connection_server_http
+  def test_io_server_http
     server_fibers = []
     server_fibers << machine.spin do
       machine.accept_each(@listen_fd) { |fd|
@@ -620,10 +620,10 @@ class ConnectionStressTest < UMBaseTest
   end
 end
 
-class ConnectionDevRandomTest < UMBaseTest
-  def test_connection_dev_random_read_line
+class IODevRandomTest < UMBaseTest
+  def test_io_dev_random_read_line
     fd = machine.open('/dev/random', UM::O_RDONLY)
-    conn = UM::Connection.new(machine, fd)
+    conn = UM::IO.new(machine, fd)
 
     n = 100000
     lines = []
@@ -639,11 +639,11 @@ class ConnectionDevRandomTest < UMBaseTest
 
   def read_line_do(n, acc)
     fd = @machine.open('/dev/random', UM::O_RDONLY)
-    conn = UM::Connection.new(@machine, fd)
+    conn = UM::IO.new(@machine, fd)
     n.times { acc << conn.read_line(0) }
   end
 
-  def test_connection_dev_random_read_line_concurrent
+  def test_io_dev_random_read_line_concurrent
     acc = []
     c = 1
     n = 100000
@@ -654,9 +654,9 @@ class ConnectionDevRandomTest < UMBaseTest
     assert_equal c * n, acc.size
   end
 
-  def test_connection_dev_random_read
+  def test_io_dev_random_read
     fd = machine.open('/dev/random', UM::O_RDONLY)
-    conn = UM::Connection.new(machine, fd)
+    conn = UM::IO.new(machine, fd)
 
     n = 256
     size = 65536 * 8
@@ -676,35 +676,35 @@ class ConnectionDevRandomTest < UMBaseTest
   end
 end
 
-class ConnectionModeTest < UMBaseTest
-  def test_connection_default_mode
+class IOModeTest < UMBaseTest
+  def test_io_default_mode
     r, w = UM.pipe
-    conn = UM::Connection.new(machine, r)
+    conn = UM::IO.new(machine, r)
     assert_equal :fd, conn.mode
   ensure
     machine.close(r) rescue nil
     machine.close(w) rescue nil
   end
 
-  def test_connection_default_mode_ssl
+  def test_io_default_mode_ssl
     authority = Localhost::Authority.fetch
     @server_ctx = authority.server_context
     sock1, sock2 = UNIXSocket.pair
 
     s1 = OpenSSL::SSL::SSLSocket.new(sock1, @server_ctx)
-    conn = UM::Connection.new(machine, s1)
+    conn = UM::IO.new(machine, s1)
     assert_equal :ssl, conn.mode
   ensure
     sock1&.close rescue nil
     sock2&.close rescue nil
   end
 
-  def test_connection_socket_mode_non_socket
+  def test_io_socket_mode_non_socket
     r, w = UM.pipe
     machine.write(w, 'foobar')
     machine.close(w)
 
-    conn = UM::Connection.new(machine, r, :socket)
+    conn = UM::IO.new(machine, r, :socket)
     assert_equal :socket, conn.mode
     # assert :socket, conn.mode
     assert_raises(Errno::ENOTSOCK) { conn.read(0) }
@@ -713,12 +713,12 @@ class ConnectionModeTest < UMBaseTest
     machine.close(w) rescue nil
   end
 
-  def test_connection_socket_mode_socket
+  def test_io_socket_mode_socket
     r, w = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
     machine.write(w, 'foobar')
     machine.close(w)
 
-    conn = UM::Connection.new(machine, r, :socket)
+    conn = UM::IO.new(machine, r, :socket)
     assert_equal :socket, conn.mode
     buf = conn.read(0)
     assert_equal 'foobar', buf
@@ -727,7 +727,7 @@ class ConnectionModeTest < UMBaseTest
     machine.close(w) rescue nil
   end
 
-  def test_connection_ssl_mode
+  def test_io_ssl_mode
     authority = Localhost::Authority.fetch
     @server_ctx = authority.server_context
     sock1, sock2 = UNIXSocket.pair
@@ -751,7 +751,7 @@ class ConnectionModeTest < UMBaseTest
     assert_equal 10, @machine.ssl_write(s1, buf, buf.bytesize)
     buf = +''
 
-    conn = UM::Connection.new(machine, s2, :ssl)
+    conn = UM::IO.new(machine, s2, :ssl)
     assert_equal "foobar", conn.read_line(0)
 
     buf = "buh"
@@ -774,8 +774,8 @@ class ConnectionModeTest < UMBaseTest
   end
 end
 
-class ConnectionByteCountsTest < ConnectionBaseTest
-  def test_connection_byte_counts
+class IOByteCountsTest < IOBaseTest
+  def test_io_byte_counts
     machine.write(@wfd, "foobar")
 
     assert_equal 0, conn.consumed

data/test/test_um.rb

@@ -653,8 +653,6 @@ class ReadEachTest < UMBaseTest
   def test_read_each
     r, w = IO.pipe
     bufs = []
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
 
     f = Fiber.new do
       w << 'foo'
@@ -669,7 +667,7 @@ class ReadEachTest < UMBaseTest
 
     machine.schedule(f, nil)
 
-    machine.read_each(r.fileno, bgid) do |buf|
+    machine.read_each(r.fileno) do |buf|
       bufs << buf
     end
 
@@ -681,15 +679,13 @@ class ReadEachTest < UMBaseTest
   # send once and close write fd
   def test_read_each_raising_1
     r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
 
     w << 'foo'
     w.close
 
     e = nil
     begin
-      machine.read_each(r.fileno, bgid) do |buf|
+      machine.read_each(r.fileno) do |buf|
         raise 'hi'
       end
     rescue => e
@@ -704,14 +700,12 @@ class ReadEachTest < UMBaseTest
   # send once and leave write fd open
   def test_read_each_raising_2
     r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
 
     w << 'foo'
 
     e = nil
     begin
-      machine.read_each(r.fileno, bgid) do |buf|
+      machine.read_each(r.fileno) do |buf|
         raise 'hi'
       end
     rescue => e
@@ -728,15 +722,13 @@ class ReadEachTest < UMBaseTest
   # send twice
   def test_read_each_raising_3
     r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
 
     w << 'foo'
     w << 'bar'
 
     e = nil
     begin
-      machine.read_each(r.fileno, bgid) do |buf|
+      machine.read_each(r.fileno) do |buf|
         raise 'hi'
       end
     rescue => e
@@ -752,7 +744,6 @@ class ReadEachTest < UMBaseTest
 
   def test_read_each_break
     r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
 
     t = Thread.new do
       sleep 0.1
@@ -762,7 +753,7 @@ class ReadEachTest < UMBaseTest
     end
 
     bufs = []
-    machine.read_each(r.fileno, bgid) do |b|
+    machine.read_each(r.fileno) do |b|
       bufs << b
       break
     end
@@ -779,13 +770,12 @@ class ReadEachTest < UMBaseTest
 
   def test_read_each_timeout
     r, _w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
 
     bufs = []
     e = nil
     begin
       machine.timeout(0.01, TOError) do
-        machine.read_each(r.fileno, bgid) do |b|
+        machine.read_each(r.fileno) do |b|
           bufs << b
         end
       end
@@ -804,10 +794,9 @@ class ReadEachTest < UMBaseTest
 
   def test_read_each_bad_file
     _r, w = IO.pipe
-    bgid = machine.setup_buffer_ring(4096, 1024)
 
     assert_raises(Errno::EBADF) do
-      machine.read_each(w.fileno, bgid)
+      machine.read_each(w.fileno)
     end
     assert_equal 0, machine.metrics[:ops_pending]
     assert_equal 256, machine.metrics[:ops_free]
@@ -1892,15 +1881,9 @@ class RecvEachTest < UMBaseTest
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, res
 
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
-
-    bgid2 = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 1, bgid2
-
     bufs = []
 
-    machine.recv_each(fd, bgid, 0) do |buf|
+    machine.recv_each(fd, 0) do |buf|
       bufs << buf
     end
     assert_equal ['abc', 'def', 'ghi'], bufs
@@ -1922,14 +1905,11 @@ class RecvEachTest < UMBaseTest
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, res
 
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
-
     bufs = []
     e = nil
     begin
       machine.timeout(0.01, TOError) do
-        machine.recv_each(fd, bgid, 0) do |buf|
+        machine.recv_each(fd, 0) do |buf|
           bufs << buf
         end
       end
@@ -1953,9 +1933,6 @@ class RecvEachTest < UMBaseTest
     res = machine.connect(fd, '127.0.0.1', @port)
     assert_equal 0, res
 
-    bgid = machine.setup_buffer_ring(4096, 1024)
-    assert_equal 0, bgid
-
     bufs = []
     e = nil
 
@@ -1965,7 +1942,7 @@ class RecvEachTest < UMBaseTest
     }
 
     begin
-      machine.recv_each(fd, bgid, 0) do |buf|
+      machine.recv_each(fd, 0) do |buf|
         bufs << buf
       end
     rescue => e
@@ -3097,61 +3074,6 @@ class ForkTest < UMBaseTest
   end
 end
 
-class SendBundleTest < UMBaseTest
-  def setup
-    super
-    @client_fd, @server_fd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
-  end
-
-  def test_send_bundle_splat
-    bgid = machine.setup_buffer_ring(0, 8)
-    assert_equal 0, bgid
-
-    strs = ['foo', 'bar', 'bazzzzz']
-    len = strs.inject(0) { |len, s| len + s.bytesize }
-
-    ret = machine.send_bundle(@client_fd, bgid, *strs)
-    assert_equal len, ret
-
-    buf = +''
-    ret = machine.recv(@server_fd, buf, 8192, 0)
-    assert_equal len, ret
-    assert_equal strs.join, buf
-  end
-
-  def test_send_bundle_array
-    bgid = machine.setup_buffer_ring(0, 8)
-    assert_equal 0, bgid
-
-    strs = ['foo', 'bar', 'bazzzzz']
-    len = strs.inject(0) { |len, s| len + s.bytesize }
-
-    ret = machine.send_bundle(@client_fd, bgid, strs)
-    assert_equal len, ret
-
-    buf = +''
-    ret = machine.recv(@server_fd, buf, 8192, 0)
-    assert_equal len, ret
-    assert_equal strs.join, buf
-  end
-
-  def test_send_bundle_non_strings
-    bgid = machine.setup_buffer_ring(0, 8)
-    assert_equal 0, bgid
-
-    strs = [42, 'bar', false]
-    len = strs.inject(0) { |len, s| len + s.to_s.bytesize }
-
-    ret = machine.send_bundle(@client_fd, bgid, strs)
-    assert_equal len, ret
-
-    buf = +''
-    ret = machine.recv(@server_fd, buf, 8192, 0)
-    assert_equal len, ret
-    assert_equal strs.map(&:to_s).join, buf
-  end
-end
-
 class MetricsTest < UMBaseTest
   def test_metrics_empty
     assert_equal({
@@ -3506,7 +3428,7 @@ class SetChildSubreaperTest < Minitest::Test
   end
 end
 
-class ConnectionMethodTest < UMBaseTest
+class IOMethodTest < UMBaseTest
   def setup
     super
     @rfd, @wfd = UM.pipe
@@ -3519,12 +3441,12 @@ class ConnectionMethodTest < UMBaseTest
     super
   end
 
-  def test_connection_method
+  def test_io_method
     machine.write(@wfd, "foobar")
     machine.close(@wfd)
 
-    conn = machine.connection(@rfd)
-    assert_kind_of UM::Connection, conn
+    conn = machine.io(@rfd)
+    assert_kind_of UM::IO, conn
 
     buf = conn.read(3)
     assert_equal 'foo', buf
@@ -3536,13 +3458,13 @@ class ConnectionMethodTest < UMBaseTest
     conn.clear
   end
 
-  def test_connection_method_with_block
+  def test_io_method_with_block
     machine.write(@wfd, "foobar")
     machine.close(@wfd)
 
     bufs = []
     conn_obj = nil
-    res = machine.connection(@rfd) do |s|
+    res = machine.io(@rfd) do |s|
       conn_obj = s
 
       bufs << s.read(3)
@@ -3551,7 +3473,7 @@ class ConnectionMethodTest < UMBaseTest
       :foo
     end
 
-    assert_kind_of UM::Connection, conn_obj
+    assert_kind_of UM::IO, conn_obj
     assert conn_obj.eof?
     assert_equal ['foo', 'bar'], bufs
     assert_equal :foo, res