io_splice 2.2.0 → 2.2.0.18.g3025

data/io_splice.gemspec

@@ -1,38 +1,26 @@
 # -*- encoding: binary -*-
-
 ENV["VERSION"] or abort "VERSION= must be specified"
 manifest = File.readlines('.manifest').map! { |x| x.chomp! }
-test_files = manifest.grep(%r{\Atest/test_.*\.rb\z})
+require 'wrongdoc'
+extend Wrongdoc::Gemspec
+name, summary, title = readme_metadata
 
 Gem::Specification.new do |s|
   s.name = %q{io_splice}
-  s.version = ENV["VERSION"]
-
-  s.authors = ["io_splice hackers"]
+  s.version = ENV["VERSION"].dup
+  s.authors = ["Ruby io_splice hackers"]
   s.date = Time.now.utc.strftime('%Y-%m-%d')
-  s.description = File.read("README").split(/\n\n/)[1]
+  s.description = readme_description
   s.email = %q{ruby.io.splice@librelist.com}
   s.extensions = %w(ext/io_splice/extconf.rb)
-
-  s.extra_rdoc_files = File.readlines('.document').map! do |x|
-    x.chomp!
-    if File.directory?(x)
-      manifest.grep(%r{\A#{x}/})
-    elsif File.file?(x)
-      x
-    else
-      nil
-    end
-  end.flatten.compact
-
+  s.extra_rdoc_files = extra_rdoc_files(manifest)
   s.files = manifest
-  s.homepage = %q{http://bogomips.org/ruby_io_splice/}
-  s.summary = %q{zero-copy pipe I/O for Linux and Ruby}
-  s.rdoc_options = [ "-Na", "-t", "io_splice - #{s.summary}" ]
-  s.require_paths = %w(lib)
+  s.homepage = Wrongdoc.config[:rdoc_url]
+  s.summary = summary
+  s.rdoc_options = rdoc_options
   s.rubyforge_project = %q{qrp}
-
-  s.test_files = test_files
+  s.test_files = Dir['test/test_*.rb']
+  s.add_development_dependency('wrongdoc', '~> 1.5')
 
   # s.licenses = %w(LGPL) # accessor not compatible with older RubyGems
 end

data/lib/io/splice.rb

@@ -1,120 +1,114 @@
 # -*- encoding: binary -*-
 require 'io_splice_ext'
 
-class IO
+module IO::Splice
 
-  module Splice
+  # the version of IO::Splice, currently 2.2.0
+  VERSION = '2.2.0'
 
-    # the version of IO::Splice, currently 2.2.0
-    VERSION = '2.2.0'
-
-    # The maximum default capacity of the pipe in bytes.
-    # Under stock Linux, this is 65536 bytes as of 2.6.11, and 4096 before
-    # We detect this at runtime as it is easy to recompile the kernel
-    # and set a new value.
-    # Starting with Linux 2.6.35, pipe capacity will be tunable
-    # and this will only represent the default capacity of a
-    # newly-created pipe.
-    PIPE_CAPA = begin
-      rd, wr = IO.pipe
-      buf = ' ' * PIPE_BUF
-      n = 0
-      begin
-        n += wr.write_nonblock(buf)
-      rescue Errno::EAGAIN
-        break
-      end while true
-      wr.close
-      rd.close
-      n
-    end
+  # The maximum default capacity of the pipe in bytes.
+  # Under stock Linux, this is 65536 bytes as of 2.6.11, and 4096 before
+  # We detect this at runtime as it is easy to recompile the kernel
+  # and set a new value.
+  # Starting with Linux 2.6.35, pipe capacity will be tunable
+  # and this will only represent the default capacity of a
+  # newly-created pipe.
+  PIPE_CAPA = begin
+    rd, wr = IO.pipe
+    buf = ' ' * PIPE_BUF
+    n = 0
+    begin
+      n += wr.write_nonblock(buf)
+    rescue Errno::EAGAIN
+      break
+    end while true
+    wr.close
+    rd.close
+    n
+  end
 
-    # copies the contents of the IO object given by +src+ to +dst+
-    # If len is specified, then only len bytes are copied.  Otherwise
-    # the copy will be until EOF is reached on the +src+.
-    # +src+ and +dst+ must be IO objects or respond to +to_io+
-    def Splice.copy_stream(src, dst, len = nil, src_offset = nil)
-      close = []
-      src.kind_of?(String) and close << (src = File.open(src, 'rb'))
-      dst.kind_of?(String) and close << (dst = File.open(dst, 'wb'))
-      src, dst = src.to_io, dst.to_io
-      rv = len
-      src.sysseek(src_offset) if src_offset
-      select_args = selectable(src, dst)
+  # copies the contents of the IO object given by +src+ to +dst+
+  # If +len+ is specified, then only +len+ bytes are copied and
+  # +EOFError+ is raised if fewer than +len+ bytes could be copied.
+  # Otherwise the copy will be until EOF is reached on the +src+.
+  # +src+ and +dst+ must be IO objects or respond to +to_io+
+  def self.copy_stream(src, dst, len = nil, src_offset = nil)
+    close = []
+    src.kind_of?(String) and close << (src = File.open(src))
+    dst.kind_of?(String) and close << (dst = File.open(dst, "w"))
+    src, dst = src.to_io, dst.to_io
+    rv = len
+    src.sysseek(src_offset) if src_offset
+    select_args = selectable(src, dst)
 
-      if src.stat.pipe? || dst.stat.pipe?
-        if len
-          len -= full(src, dst, len, select_args) until len == 0
-        else
-          rv = 0
-          begin
-            rv += partial(src, dst, PIPE_CAPA, select_args)
-          rescue EOFError
-            break
-          end while true
+    if src.stat.pipe? || dst.stat.pipe?
+      if len
+        len -= full(src, dst, len, select_args) until len == 0
+      else
+        rv = 0
+        while n = partial(src, dst, PIPE_CAPA, select_args)
+          rv += n
+        end
+      end
+    else
+      r, w = tmp = IO.pipe
+      close.concat(tmp)
+      if len
+        while len != 0 && n = partial(src, w, len, select_args)
+          len -= full(r, dst, n, select_args)
         end
       else
-        r, w = tmp = IO.pipe
-        close.concat(tmp)
-        if len
-          while len != 0
-            nr = partial(src, w, len, select_args)
-            len -= full(r, dst, nr, select_args)
-          end
-        else
-          rv = 0
-          begin
-            nr = partial(src, w, PIPE_CAPA, select_args)
-            rv += full(r, dst, nr, select_args)
-          rescue EOFError
-            break
-          end while true
+        rv = 0
+        while n = partial(src, w, PIPE_CAPA, select_args)
+          rv += full(r, dst, n, select_args)
         end
       end
-
-      rv
-      ensure
-        close.each { |io| io.close }
     end
 
-    # splice the full amount specified from +src+ to +dst+
-    # Either +dst+ or +src+ must be a pipe.  +dst+ and +src+
-    # may BOTH be pipes in Linux 2.6.31 or later.
-    # This will block and wait for IO completion of +len+
-    # bytes.  Returns the nubmer of bytes actually spliced (always +len+)
-    # The +_select_args+ parameter is reserved for internal use and
-    # may be removed in future versions.  Do not write code that
-    # depends on +_select_args+.
-    def Splice.full(src, dst, len, _select_args = selectable(src, dst))
-      nr = len
-      nr -= partial(src, dst, nr, _select_args) until nr == 0
-      len
-    end
+    rv
+    ensure
+      close.each { |io| io.close }
+  end
 
-    # splice up to +len+ bytes from +src+ to +dst+.
-    # Either +dst+ or +src+ must be a pipe.  +dst+ and +src+
-    # may BOTH be pipes in Linux 2.6.31 or later.
-    # Returns the number of bytes actually spliced.
-    # Like IO#readpartial, this never returns Errno::EAGAIN
-    # The +_select_args+ parameter is reserved for internal use and
-    # may be removed in future versions.  Do not write code that
-    # depends on +_select_args+.
-    def Splice.partial(src, dst, len, _select_args = selectable(src, dst))
-      begin
-        IO.splice(src, nil, dst, nil, len, F_MOVE)
-      rescue Errno::EAGAIN
-        IO.select(*_select_args)
-        retry
-      end
+  # splice the full amount specified from +src+ to +dst+
+  # Either +dst+ or +src+ must be a pipe.  +dst+ and +src+
+  # may BOTH be pipes in Linux 2.6.31 or later.
+  # This will block and wait for IO completion of +len+
+  # Raises +EOFError+ if end of file is reached.
+  # bytes.  Returns the number of bytes actually spliced (always +len+)
+  # The +_select_args+ parameter is reserved for internal use and
+  # may be removed in future versions.  Do not write code that
+  # depends on +_select_args+.
+  def self.full(src, dst, len, _select_args = selectable(src, dst))
+    nr = len
+    while nr > 0
+      n = partial(src, dst, nr, _select_args) or
+                                     raise EOFError, "end of file reached"
+      nr -= n
     end
+    len
+  end
 
-    # returns an array suitable for splat-ing to IO.select for blocking I/O
-    def Splice.selectable(src, dst)
-      rv = []
-      src.stat.pipe? or rv[0] = [ src ]
-      dst.stat.pipe? or rv[1] = [ dst ]
-      rv
-    end
+  # splice up to +len+ bytes from +src+ to +dst+.
+  # Either +dst+ or +src+ must be a pipe.  +dst+ and +src+
+  # may BOTH be pipes in Linux 2.6.31 or later.
+  # Returns the number of bytes actually spliced.
+  # Like IO#readpartial, this never returns Errno::EAGAIN
+  # The +_select_args+ parameter is reserved for internal use and
+  # may be removed in future versions.  Do not write code that
+  # depends on +_select_args+.
+  def self.partial(src, dst, len, _select_args = selectable(src, dst))
+    begin
+      rv = IO.trysplice(src, nil, dst, nil, len, F_MOVE)
+    end while rv == :EAGAIN and IO.select(*_select_args)
+    rv
+  end
 
+  # returns an array suitable for splat-ing to IO.select for blocking I/O
+  def self.selectable(src, dst)
+    rv = []
+    src.stat.pipe? or rv[0] = [ src ]
+    dst.stat.pipe? or rv[1] = [ dst ]
+    rv
   end
 end

data/pkg.mk

@@ -0,0 +1,168 @@
+RUBY = ruby
+RAKE = rake
+RSYNC = rsync
+WRONGDOC = wrongdoc
+
+GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
+	@./GIT-VERSION-GEN
+-include GIT-VERSION-FILE
+-include local.mk
+DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts RbConfig::CONFIG["DLEXT"]')
+RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
+RUBY_ENGINE := $(shell $(RUBY) -e 'puts((RUBY_ENGINE rescue "ruby"))')
+lib := lib
+
+ifeq ($(shell test -f script/isolate_for_tests && echo t),t)
+isolate_libs := tmp/isolate/$(RUBY_ENGINE)-$(RUBY_VERSION)/isolate.mk
+$(isolate_libs): script/isolate_for_tests
+	@$(RUBY) script/isolate_for_tests
+-include $(isolate_libs)
+lib := $(lib):$(ISOLATE_LIBS)
+endif
+
+ext := $(firstword $(wildcard ext/*))
+ifneq ($(ext),)
+ext_pfx := tmp/ext/$(RUBY_ENGINE)-$(RUBY_VERSION)
+ext_h := $(wildcard $(ext)/*/*.h $(ext)/*.h)
+ext_src := $(wildcard $(ext)/*.c $(ext_h))
+ext_pfx_src := $(addprefix $(ext_pfx)/,$(ext_src))
+ext_d := $(ext_pfx)/$(ext)/.d
+$(ext)/extconf.rb: $(wildcard $(ext)/*.h)
+	@>> $@
+$(ext_d):
+	@mkdir -p $(@D)
+	@> $@
+$(ext_pfx)/$(ext)/%: $(ext)/% $(ext_d)
+	install -m 644 $< $@
+$(ext_pfx)/$(ext)/Makefile: $(ext)/extconf.rb $(ext_d) $(ext_h)
+	$(RM) -f $(@D)/*.o
+	cd $(@D) && $(RUBY) $(CURDIR)/$(ext)/extconf.rb
+ext_sfx := _ext.$(DLEXT)
+ext_dl := $(ext_pfx)/$(ext)/$(notdir $(ext)_ext.$(DLEXT))
+$(ext_dl): $(ext_src) $(ext_pfx_src) $(ext_pfx)/$(ext)/Makefile
+	@echo $^ == $@
+	$(MAKE) -C $(@D)
+lib := $(lib):$(ext_pfx)/$(ext)
+build: $(ext_dl)
+endif
+
+pkg_extra := GIT-VERSION-FILE NEWS ChangeLog LATEST
+ChangeLog: GIT-VERSION-FILE .wrongdoc.yml
+	$(WRONGDOC) prepare
+
+manifest:
+	$(RM) .manifest
+	$(MAKE) .manifest
+
+.manifest: ChangeLog
+	(git ls-files && for i in $@ $(pkg_extra); do echo $$i; done) | \
+		LC_ALL=C sort > $@+
+	cmp $@+ $@ || mv $@+ $@
+	$(RM) $@+
+
+doc:: .document .wrongdoc.yml
+	find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
+	-find ext -type f -name '*.rbc' -exec rm -f '{}' ';'
+	$(RM) -r doc
+	$(WRONGDOC) all
+	install -m644 COPYING doc/COPYING
+	install -m644 $(shell grep '^[A-Z]' .document) doc/
+
+ifneq ($(VERSION),)
+pkggem := pkg/$(rfpackage)-$(VERSION).gem
+pkgtgz := pkg/$(rfpackage)-$(VERSION).tgz
+release_notes := release_notes-$(VERSION)
+release_changes := release_changes-$(VERSION)
+
+release-notes: $(release_notes)
+release-changes: $(release_changes)
+$(release_changes):
+	$(WRONGDOC) release_changes > $@+
+	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
+$(release_notes):
+	$(WRONGDOC) release_notes > $@+
+	$(VISUAL) $@+ && test -s $@+ && mv $@+ $@
+
+# ensures we're actually on the tagged $(VERSION), only used for release
+verify:
+	test x"$(shell umask)" = x0022
+	git rev-parse --verify refs/tags/v$(VERSION)^{}
+	git diff-index --quiet HEAD^0
+	test $$(git rev-parse --verify HEAD^0) = \
+	     $$(git rev-parse --verify refs/tags/v$(VERSION)^{})
+
+fix-perms:
+	-git ls-tree -r HEAD | awk '/^100644 / {print $$NF}' | xargs chmod 644
+	-git ls-tree -r HEAD | awk '/^100755 / {print $$NF}' | xargs chmod 755
+
+gem: $(pkggem)
+
+install-gem: $(pkggem)
+	gem install $(CURDIR)/$<
+
+$(pkggem): manifest fix-perms
+	gem build $(rfpackage).gemspec
+	mkdir -p pkg
+	mv $(@F) $@
+
+$(pkgtgz): distdir = $(basename $@)
+$(pkgtgz): HEAD = v$(VERSION)
+$(pkgtgz): manifest fix-perms
+	@test -n "$(distdir)"
+	$(RM) -r $(distdir)
+	mkdir -p $(distdir)
+	tar cf - $$(cat .manifest) | (cd $(distdir) && tar xf -)
+	cd pkg && tar cf - $(basename $(@F)) | gzip -9 > $(@F)+
+	mv $@+ $@
+
+package: $(pkgtgz) $(pkggem)
+
+test-release:: verify package $(release_notes) $(release_changes)
+	# make tgz release on RubyForge
+	@echo rubyforge add_release -f \
+	  -n $(release_notes) -a $(release_changes) \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkgtgz)
+	@echo gem push $(pkggem)
+	@echo rubyforge add_file \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkggem)
+release:: verify package $(release_notes) $(release_changes)
+	# make tgz release on RubyForge
+	rubyforge add_release -f -n $(release_notes) -a $(release_changes) \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkgtgz)
+	# push gem to RubyGems.org
+	gem push $(pkggem)
+	# in case of gem downloads from RubyForge releases page
+	rubyforge add_file \
+	  $(rfproject) $(rfpackage) $(VERSION) $(pkggem)
+else
+gem install-gem: GIT-VERSION-FILE
+	$(MAKE) $@ VERSION=$(GIT_VERSION)
+endif
+
+all:: test
+test_units := $(wildcard test/test_*.rb)
+test: test-unit
+test-unit: $(test_units)
+$(test_units): build
+	$(RUBY) -I $(lib) $@
+
+# this requires GNU coreutils variants
+ifneq ($(RSYNC_DEST),)
+publish_doc:
+	-git set-file-times
+	$(MAKE) doc
+	find doc/images -type f | \
+		TZ=UTC xargs touch -d '1970-01-01 00:00:06' doc/rdoc.css
+	$(MAKE) doc_gz
+	$(RSYNC) -av doc/ $(RSYNC_DEST)/
+	git ls-files | xargs touch
+endif
+
+# Create gzip variants of the same timestamp as the original so nginx
+# "gzip_static on" can serve the gzipped versions directly.
+doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.\(gif\|jpg\|png\|gz\)$$')
+doc_gz:
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+
+.PHONY: all .FORCE-GIT-VERSION-FILE doc test $(test_units) manifest

data/test/test_io_splice.rb

@@ -7,48 +7,6 @@ require 'timeout'
 $-w = true
 require 'io/splice'
 
-# unused_port provides an unused port on +addr+ usable for TCP that is
-# guaranteed to be unused across all unicorn builds on that system.  It
-# prevents race conditions by using a lock file other unicorn builds
-# will see.  This is required if you perform several builds in parallel
-# with a continuous integration system or run tests in parallel via
-# gmake.  This is NOT guaranteed to be race-free if you run other
-# processes that bind to random ports for testing (but the window
-# for a race condition is very small).
-def unused_port(addr = '127.0.0.1')
-  retries = 100
-  base = 5000
-  port = sock = nil
-  begin
-    begin
-      port = base + rand(32768 - base)
-      while port == 8080
-        port = base + rand(32768 - base)
-      end
-
-      sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-      sock.bind(Socket.pack_sockaddr_in(port, addr))
-      sock.listen(5)
-    rescue Errno::EADDRINUSE, Errno::EACCES
-      sock.close rescue nil
-      retry if (retries -= 1) >= 0
-    end
-
-    # since we'll end up closing the random port we just got, there's a race
-    # condition could allow the random port we just chose to reselect itself
-    # when running tests in parallel with gmake.  Create a lock file while
-    # we have the port here to ensure that does not happen .
-    lock_path = "#{Dir::tmpdir}/unicorn_test.#{addr}:#{port}.lock"
-    lock = File.open(lock_path, File::WRONLY|File::CREAT|File::EXCL, 0600)
-    at_exit { File.unlink(lock_path) rescue nil }
-  rescue Errno::EEXIST
-    sock.close rescue nil
-    retry
-  end
-  sock.close rescue nil
-  port
-end
-
 class Test_IO_Splice < Test::Unit::TestCase
 
   def test_splice
@@ -83,6 +41,38 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_equal str, rd.sysread(size)
   end
 
+  def test_splice_io_noflags
+    str = 'abcde'
+    size = 5
+    rd, wr = IO.pipe
+    tmp = Tempfile.new('ruby_io_splice')
+
+    assert_nothing_raised {
+      tmp.syswrite(str)
+      tmp.sysseek(0)
+    }
+
+    nr = IO.splice(tmp, nil, wr, nil, size)
+    assert_equal size, nr
+    assert_equal str, rd.sysread(size)
+  end
+
+  def test_trysplice_io_noflags
+    str = 'abcde'
+    size = 5
+    rd, wr = IO.pipe
+    tmp = Tempfile.new('ruby_io_splice')
+
+    assert_nothing_raised {
+      tmp.syswrite(str)
+      tmp.sysseek(0)
+    }
+
+    nr = IO.trysplice(tmp, nil, wr, nil, size)
+    assert_equal size, nr
+    assert_equal str, rd.sysread(size)
+  end
+
   def test_splice_io_ish
     str = 'abcde'
     size = 5
@@ -141,6 +131,20 @@ class Test_IO_Splice < Test::Unit::TestCase
     }
   end
 
+  def test_trysplice_nonblock
+    rd, wr = IO.pipe
+    tmp = Tempfile.new('ruby_io_splice')
+    assert_equal :EAGAIN,
+           IO.trysplice(rd, nil, tmp, 0, 5, IO::Splice::F_NONBLOCK)
+  end
+
+  def test_trysplice_nonblock_noargs
+    rd, wr = IO.pipe
+    tmp = Tempfile.new('ruby_io_splice')
+    assert_equal :EAGAIN, IO.trysplice(rd, nil, tmp, 0, 5)
+    assert_equal :EAGAIN, IO.trysplice(rd, nil, tmp, 0, 5, IO::Splice::F_MORE)
+  end
+
   def test_splice_eof
     rd, wr = IO.pipe
     tmp = Tempfile.new('ruby_io_splice')
@@ -154,9 +158,20 @@ class Test_IO_Splice < Test::Unit::TestCase
     }
   end
 
+  def test_trysplice_eof
+    rd, wr = IO.pipe
+    tmp = Tempfile.new('ruby_io_splice')
+    wr.syswrite 'abc'
+    wr.close
+
+    nr = IO.trysplice(rd, nil, tmp, 0, 5, IO::Splice::F_NONBLOCK)
+    assert_equal 3, nr
+    assert_nil IO.trysplice(rd, nil, tmp, 0, 5, IO::Splice::F_NONBLOCK)
+  end
+
   def test_splice_nonblock_socket
-    port = unused_port
-    server = TCPServer.new('127.0.0.1', port)
+    server = TCPServer.new('127.0.0.1', 0)
+    port = server.addr[1]
     rp, wp = IO.pipe
     rs = TCPSocket.new('127.0.0.1', port)
     rs.nonblock = true
@@ -178,6 +193,19 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_equal str, rda.sysread(5)
   end
 
+  def test_trytee
+    str = 'abcde'
+    size = 5
+    rda, wra = IO.pipe
+    rdb, wrb = IO.pipe
+
+    assert_nothing_raised { wra.syswrite(str) }
+    nr = IO.trytee(rda, wrb, size, 0)
+    assert_equal 5, nr
+    assert_equal str, rdb.sysread(5)
+    assert_equal str, rda.sysread(5)
+  end
+
   def test_tee_eof
     rda, wra = IO.pipe
     rdb, wrb = IO.pipe
@@ -185,6 +213,13 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_raises(EOFError) { IO.tee(rda.fileno, wrb.fileno, 4096, 0) }
   end
 
+  def test_trytee_eof
+    rda, wra = IO.pipe
+    rdb, wrb = IO.pipe
+    wra.close
+    assert_nil IO.trytee(rda, wrb, 4096)
+  end
+
   def test_tee_nonblock
     rda, wra = IO.pipe
     rdb, wrb = IO.pipe
@@ -193,6 +228,12 @@ class Test_IO_Splice < Test::Unit::TestCase
     }
   end
 
+  def test_trytee_nonblock
+    rda, wra = IO.pipe
+    rdb, wrb = IO.pipe
+    assert_equal :EAGAIN, IO.trytee(rda, wrb, 4096)
+  end
+
   def test_tee_io
     str = 'abcde'
     size = 5
@@ -214,6 +255,14 @@ class Test_IO_Splice < Test::Unit::TestCase
     assert_equal data.join(''), r.readpartial(16384)
   end
 
+  def test_vmsplice_noflags
+    data = %w(hello world how are you today)
+    r, w = IO.pipe
+    n = IO.vmsplice(w, data)
+    assert_equal data.join('').size, n
+    assert_equal data.join(''), r.readpartial(16384)
+  end
+
   def test_vmsplice_string
     r, w = IO.pipe
     assert_equal 5, IO.vmsplice(w, 'hello', 0)
@@ -344,8 +393,8 @@ class Test_IO_Splice < Test::Unit::TestCase
   end
 
   def test_copy_stream_nonblock_src
-    port = unused_port
-    server = TCPServer.new('127.0.0.1', port)
+    server = TCPServer.new('127.0.0.1', 0)
+    port = server.addr[1]
     rp, wp = IO.pipe
     rs = TCPSocket.new('127.0.0.1', port)
     rs.nonblock = true
@@ -359,8 +408,8 @@ class Test_IO_Splice < Test::Unit::TestCase
   end
 
   def test_copy_stream_nonblock_dst
-    port = unused_port
-    server = TCPServer.new('127.0.0.1', port)
+    server = TCPServer.new('127.0.0.1', 0)
+    port = server.addr[1]
     rp, wp = IO.pipe
     rs = TCPSocket.new('127.0.0.1', port)
     rs.nonblock = true
@@ -395,10 +444,10 @@ class Test_IO_Splice < Test::Unit::TestCase
 
   def test_pipe_size
     r, w = IO.pipe
-    assert Integer, r.pipe_size
+    assert_kind_of Integer, r.pipe_size
     assert(r.pipe_size >= 512)
     assert_nothing_raised { w.pipe_size = 8192 }
-    assert 8192, r.pipe_size
+    assert_equal 8192, r.pipe_size
 
     w.write('*' * 4097)
     assert_raises(Errno::EBUSY) { r.pipe_size = 4096 }