kgio 1.0.1

data/test/lib_read_write.rb

@@ -0,0 +1,240 @@
+require 'test/unit'
+require 'io/nonblock'
+$-w = true
+require 'kgio'
+
+module LibReadWriteTest
+  RANDOM_BLOB = File.open("/dev/urandom") { |fp| fp.read(10 * 1024 * 1024) }
+
+  def teardown
+    assert_nothing_raised do
+      @rd.close unless @rd.closed?
+      @wr.close unless @wr.closed?
+    end
+    assert_nothing_raised do
+      Kgio.wait_readable = Kgio.wait_writable = nil
+    end
+  end
+
+  def test_read_eof
+    @wr.close
+    assert_nil @rd.kgio_read(5)
+  end
+
+  def test_tryread_eof
+    @wr.close
+    assert_nil @rd.kgio_tryread(5)
+  end
+
+  def test_write_closed
+    @rd.close
+    assert_raises(Errno::EPIPE, Errno::ECONNRESET) {
+      loop { @wr.kgio_write "HI" }
+    }
+  end
+
+  def test_trywrite_closed
+    @rd.close
+    assert_raises(Errno::EPIPE, Errno::ECONNRESET) {
+      loop { @wr.kgio_trywrite "HI" }
+    }
+  end
+
+  def test_write_conv
+    assert_equal nil, @wr.kgio_write(10)
+    assert_equal "10", @rd.kgio_read(2)
+  end
+
+  def test_trywrite_conv
+    assert_equal nil, @wr.kgio_trywrite(10)
+    assert_equal "10", @rd.kgio_tryread(2)
+  end
+
+  def test_tryread_empty
+    assert_equal Kgio::WaitReadable, @rd.kgio_tryread(1)
+  end
+
+  def test_read_too_much
+    assert_equal nil, @wr.kgio_write("hi")
+    assert_equal "hi", @rd.kgio_read(4)
+  end
+
+  def test_tryread_too_much
+    assert_equal nil, @wr.kgio_trywrite("hi")
+    assert_equal "hi", @rd.kgio_tryread(4)
+  end
+
+  def test_read_short
+    assert_equal nil, @wr.kgio_write("hi")
+    assert_equal "h", @rd.kgio_read(1)
+    assert_equal "i", @rd.kgio_read(1)
+  end
+
+  def test_tryread_short
+    assert_equal nil, @wr.kgio_trywrite("hi")
+    assert_equal "h", @rd.kgio_tryread(1)
+    assert_equal "i", @rd.kgio_tryread(1)
+  end
+
+  def test_read_extra_buf
+    tmp = ""
+    tmp_object_id = tmp.object_id
+    assert_equal nil, @wr.kgio_write("hi")
+    rv = @rd.kgio_read(2, tmp)
+    assert_equal "hi", rv
+    assert_equal rv.object_id, tmp.object_id
+    assert_equal tmp_object_id, rv.object_id
+  end
+
+  def test_trywrite_return_wait_writable
+    tmp = []
+    tmp << @wr.kgio_trywrite("HI") until tmp[-1] == Kgio::WaitWritable
+    assert_equal Kgio::WaitWritable, tmp.pop
+    assert tmp.size > 0
+    penultimate = tmp.pop
+    assert(penultimate == "I" || penultimate == nil)
+    assert tmp.size > 0
+    tmp.each { |count| assert_equal nil, count }
+  end
+
+  def test_tryread_extra_buf_eagain_clears_buffer
+    tmp = "hello world"
+    rv = @rd.kgio_tryread(2, tmp)
+    assert_equal Kgio::WaitReadable, rv
+    assert_equal "", tmp
+  end
+
+  def test_tryread_extra_buf_eof_clears_buffer
+    tmp = "hello world"
+    @wr.close
+    assert_nil @rd.kgio_tryread(2, tmp)
+    assert_equal "", tmp
+  end
+
+  def test_monster_trywrite
+    buf = RANDOM_BLOB.dup
+    rv = @wr.kgio_trywrite(buf)
+    assert_kind_of String, rv
+    assert rv.size < buf.size
+    @rd.nonblock = false
+    assert_equal(buf, @rd.read(buf.size - rv.size) + rv)
+  end
+
+  def test_monster_write
+    buf = RANDOM_BLOB.dup
+    thr = Thread.new { @wr.kgio_write(buf) }
+    @rd.nonblock = false
+    readed = @rd.read(buf.size)
+    thr.join
+    assert_nil thr.value
+    assert_equal buf, readed
+  end
+
+  def test_monster_write_wait_writable
+    @wr.instance_variable_set :@nr, 0
+    def @wr.wait_writable
+      @nr += 1
+      IO.select(nil, [self])
+    end
+    Kgio.wait_writable = :wait_writable
+    buf = "." * 1024 * 1024 * 10
+    thr = Thread.new { @wr.kgio_write(buf) }
+    readed = @rd.read(buf.size)
+    thr.join
+    assert_nil thr.value
+    assert_equal buf, readed
+    assert @wr.instance_variable_get(:@nr) > 0
+  end
+
+  def test_wait_readable_ruby_default
+    assert_nothing_raised { Kgio.wait_readable = nil }
+    elapsed = 0
+    foo = nil
+    t0 = Time.now
+    thr = Thread.new { sleep 1; @wr.write "HELLO" }
+    assert_nothing_raised do
+      foo = @rd.kgio_read(5)
+      elapsed = Time.now - t0
+    end
+    assert elapsed >= 1.0, "elapsed: #{elapsed}"
+    assert_equal "HELLO", foo
+    thr.join
+    assert_equal 5, thr.value
+  end
+
+  def test_wait_writable_ruby_default
+    buf = "." * 512
+    nr = 0
+    begin
+      nr += @wr.write_nonblock(buf)
+    rescue Errno::EAGAIN
+      break
+    end while true
+    assert_nothing_raised { Kgio.wait_writable = nil }
+    elapsed = 0
+    foo = nil
+    t0 = Time.now
+    thr = Thread.new { sleep 1; @rd.readpartial(nr) }
+    assert_nothing_raised do
+      foo = @wr.kgio_write("HELLO")
+      elapsed = Time.now - t0
+    end
+    assert_nil foo
+    if @wr.stat.pipe?
+      assert elapsed >= 1.0, "elapsed: #{elapsed}"
+    end
+    assert(String === foo || foo == nil)
+    assert_kind_of String, thr.value
+  end
+
+  def test_wait_readable_method
+    def @rd.moo
+      defined?(@z) ? raise(RuntimeError, "Hello") : @z = "HI"
+    end
+    assert_nothing_raised { Kgio.wait_readable = :moo }
+    foo = nil
+    begin
+      foo = @rd.kgio_read(5)
+      assert false
+    rescue RuntimeError => e
+      assert_equal("Hello", e.message)
+    end
+    assert_equal "HI", @rd.instance_variable_get(:@z)
+    assert_nil foo
+  end
+
+  def test_tryread_wait_readable_method
+    def @rd.moo
+      raise "Hello"
+    end
+    assert_nothing_raised { Kgio.wait_readable = :moo }
+    assert_equal Kgio::WaitReadable, @rd.kgio_tryread(5)
+  end
+
+  def test_trywrite_wait_readable_method
+    def @wr.moo
+      raise "Hello"
+    end
+    assert_nothing_raised { Kgio.wait_writable = :moo }
+    tmp = []
+    buf = "." * 1024
+    10000.times { tmp << @wr.kgio_trywrite(buf) }
+    assert_equal Kgio::WaitWritable, tmp.pop
+  end
+
+  def test_wait_writable_method
+    def @wr.moo
+      defined?(@z) ? raise(RuntimeError, "Hello") : @z = "HI"
+    end
+    assert_nothing_raised { Kgio.wait_writable = :moo }
+    n = []
+    begin
+      loop { n << @wr.kgio_write("HIHIHIHIHIHI") }
+      assert false
+    rescue RuntimeError => e
+      assert_equal("Hello", e.message)
+    end
+    assert n.size > 0
+    assert_equal "HI", @wr.instance_variable_get(:@z)
+  end
+end

data/test/lib_server_accept.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 'io/nonblock'
+$-w = true
+require 'kgio'
+
+module LibServerAccept
+
+  def teardown
+    @srv.close unless @srv.closed?
+    Kgio.accept_cloexec = true
+    Kgio.accept_nonblock = false
+  end
+
+  def test_tryaccept_success
+    a = client_connect
+    IO.select([@srv])
+    b = @srv.kgio_tryaccept
+    assert_kind_of Kgio::Socket, b
+    assert_equal @host, b.kgio_addr
+  end
+
+  def test_tryaccept_fail
+    assert_equal nil, @srv.kgio_tryaccept
+  end
+
+  def test_blocking_accept
+    t0 = Time.now
+    pid = fork { sleep 1; a = client_connect; sleep }
+    b = @srv.kgio_accept
+    elapsed = Time.now - t0
+    assert_kind_of Kgio::Socket, b
+    assert_equal @host, b.kgio_addr
+    Process.kill(:TERM, pid)
+    Process.waitpid(pid)
+    assert elapsed >= 1, "elapsed: #{elapsed}"
+  end
+
+  def test_blocking_accept_with_nonblock_socket
+    @srv.nonblock = true
+    t0 = Time.now
+    pid = fork { sleep 1; a = client_connect; sleep }
+    b = @srv.kgio_accept
+    elapsed = Time.now - t0
+    assert_kind_of Kgio::Socket, b
+    assert_equal @host, b.kgio_addr
+    Process.kill(:TERM, pid)
+    Process.waitpid(pid)
+    assert elapsed >= 1, "elapsed: #{elapsed}"
+
+    t0 = Time.now
+    pid = fork { sleep 6; a = client_connect; sleep }
+    b = @srv.kgio_accept
+    elapsed = Time.now - t0
+    assert_kind_of Kgio::Socket, b
+    assert_equal @host, b.kgio_addr
+    Process.kill(:TERM, pid)
+    Process.waitpid(pid)
+    assert elapsed >= 6, "elapsed: #{elapsed}"
+
+    t0 = Time.now
+    pid = fork { sleep 1; a = client_connect; sleep }
+    b = @srv.kgio_accept
+    elapsed = Time.now - t0
+    assert_kind_of Kgio::Socket, b
+    assert_equal @host, b.kgio_addr
+    Process.kill(:TERM, pid)
+    Process.waitpid(pid)
+    assert elapsed >= 1, "elapsed: #{elapsed}"
+  end
+end

data/test/test_connect_fd_leak.rb

@@ -0,0 +1,23 @@
+require 'test/unit'
+require 'io/nonblock'
+$-w = true
+require 'kgio'
+
+class TestConnectFDLeak < Test::Unit::TestCase
+
+  def teardown
+    Kgio.wait_readable = Kgio.wait_writable = nil
+  end
+
+  def test_unix_socket
+    nr = 0
+    path = "/non/existent/path"
+    assert(! File.exist?(path), "#{path} should not exist")
+    assert_nothing_raised do
+      begin
+        sock = Kgio::UNIXSocket.new(path)
+      rescue Errno::ENOENT
+      end while (nr += 1) < 10000
+    end
+  end
+end

data/test/test_pipe_popen.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'io/nonblock'
+$-w = true
+require 'kgio'
+
+class TestPipePopen < Test::Unit::TestCase
+  def test_popen
+    io = Kgio::Pipe.popen("sleep 1 && echo HI")
+    assert_equal Kgio::WaitReadable, io.kgio_tryread(2)
+    sleep 1.5
+    assert_equal "HI\n", io.kgio_read(3)
+    assert_nil io.kgio_read(5)
+  end
+end

data/test/test_pipe_read_write.rb

@@ -0,0 +1,9 @@
+require './test/lib_read_write.rb'
+
+class TestKgioPipe < Test::Unit::TestCase
+  def setup
+    @rd, @wr = Kgio::Pipe.new
+  end
+
+  include LibReadWriteTest
+end

data/test/test_socketpair_read_write.rb

@@ -0,0 +1,9 @@
+require './test/lib_read_write.rb'
+
+class TestKgioUNIXSocketPair < Test::Unit::TestCase
+  def setup
+    @rd, @wr = Kgio::UNIXSocket.pair
+  end
+
+  include LibReadWriteTest
+end

data/test/test_tcp_client_read_server_write.rb

@@ -0,0 +1,13 @@
+require './test/lib_read_write'
+
+class TesTcpClientReadServerWrite < Test::Unit::TestCase
+  def setup
+    @host = ENV["TEST_HOST"] || '127.0.0.1'
+    @srv = Kgio::TCPServer.new(@host, 0)
+    @port = @srv.addr[1]
+    @wr = Kgio::TCPSocket.new(@host, @port)
+    @rd = @srv.kgio_accept
+  end
+
+  include LibReadWriteTest
+end

data/test/test_tcp_connect.rb

@@ -0,0 +1,73 @@
+require 'test/unit'
+require 'io/nonblock'
+$-w = true
+require 'kgio'
+
+class SubSocket < Kgio::Socket
+  attr_accessor :foo
+  def wait_writable
+    @foo = "waited"
+  end
+end
+
+class TestKgioTcpConnect < Test::Unit::TestCase
+
+  def setup
+    @host = ENV["TEST_HOST"] || '127.0.0.1'
+    @srv = Kgio::TCPServer.new(@host, 0)
+    @port = @srv.addr[1]
+    @addr = Socket.pack_sockaddr_in(@port, @host)
+  end
+
+  def teardown
+    @srv.close unless @srv.closed?
+    Kgio.accept_cloexec = true
+    Kgio.accept_nonblock = false
+    Kgio.wait_readable = Kgio.wait_writable = nil
+  end
+
+  def test_new
+    sock = Kgio::Socket.new(@addr)
+    assert_kind_of Kgio::Socket, sock
+    ready = IO.select(nil, [ sock ])
+    assert_equal sock, ready[1][0]
+    assert_equal nil, sock.kgio_write("HELLO")
+  end
+
+  def test_start
+    sock = Kgio::Socket.start(@addr)
+    assert_kind_of Kgio::Socket, sock
+    ready = IO.select(nil, [ sock ])
+    assert_equal sock, ready[1][0]
+    assert_equal nil, sock.kgio_write("HELLO")
+  end
+
+  def test_tcp_socket_new_invalid
+    assert_raises(ArgumentError) { Kgio::TCPSocket.new('example.com', 80) }
+    assert_raises(ArgumentError) { Kgio::TCPSocket.new('999.999.999.999', 80) }
+  end
+
+  def test_tcp_socket_new
+    sock = Kgio::TCPSocket.new(@host, @port)
+    assert_instance_of Kgio::TCPSocket, sock
+    ready = IO.select(nil, [ sock ])
+    assert_equal sock, ready[1][0]
+    assert_equal nil, sock.kgio_write("HELLO")
+  end
+
+  def test_socket_start
+    Kgio::wait_writable = :wait_writable
+    sock = SubSocket.start(@addr)
+    assert_nil sock.foo
+    ready = IO.select(nil, [ sock ])
+    assert_equal sock, ready[1][0]
+    assert_equal nil, sock.kgio_write("HELLO")
+  end
+
+  def test_wait_writable_set
+    Kgio::wait_writable = :wait_writable
+    sock = SubSocket.new(@addr)
+    assert_equal "waited", sock.foo
+    assert_equal nil, sock.kgio_write("HELLO")
+  end
+end