nio4r 0.3.3-java → 0.4.0-java

data/.travis.yml

@@ -1,6 +1,5 @@
 rvm:
   - 1.8.7
-  - 1.9.2
   - 1.9.3
   - ree
   - ruby-head

data/CHANGES.md

@@ -1,3 +1,7 @@
+0.4.0
+-----
+* OpenSSL::SSL::SSLSocket support
+
 0.3.3
 -----
 * NIO::Selector#select_each removed

data/Gemfile

@@ -1,4 +1,6 @@
 source :rubygems
 
+gem 'jruby-openssl' if defined? JRUBY_VERSION
+
 # Specify your gem's dependencies in nio4r.gemspec
 gemspec

data/ext/libev/ev.c

@@ -3101,7 +3101,15 @@ other and thus cannot be composed.
 And thus we are left with no choice but to patch the internals of libev in
 order to release a mutex at just the precise moment.
 
-Let this be a lesson to the all: CALLBACKS FUCKING BLOW
+This is a great example of a situation where granular locking and unlocking
+of the GVL is practically required. The goal is to get as close to the
+system call as possible, and to keep the GVL unlocked for the shortest
+amount of time possible.
+
+Perhaps Ruby could benefit from such an API, e.g:
+
+rb_thread_unsafe_dangerous_crazy_blocking_region_begin(...);
+rb_thread_unsafe_dangerous_crazy_blocking_region_end(...);
 
 #######################################################################
 */

data/ext/nio4r/org/nio4r/Nio4r.java

@@ -130,6 +130,12 @@ public class Nio4r implements Library {
             Ruby runtime = context.getRuntime();
             return this.selector.isOpen() ? runtime.getFalse() : runtime.getTrue();
         }
+        
+        @JRubyMethod(name = "empty?")
+        public IRubyObject isEmpty(ThreadContext context) {
+            Ruby runtime = context.getRuntime();
+            return this.selector.keys().isEmpty() ? runtime.getTrue() : runtime.getFalse();
+        }
 
         @JRubyMethod
         public IRubyObject register(ThreadContext context, IRubyObject io, IRubyObject interests) {

data/ext/nio4r/selector.c

@@ -28,6 +28,7 @@ static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self);
 static VALUE NIO_Selector_wakeup(VALUE self);
 static VALUE NIO_Selector_close(VALUE self);
 static VALUE NIO_Selector_closed(VALUE self);
+static VALUE NIO_Selector_is_empty(VALUE self);
 
 /* Internal functions */
 static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args);
@@ -60,6 +61,7 @@ void Init_NIO_Selector()
     rb_define_method(cNIO_Selector, "wakeup", NIO_Selector_wakeup, 0);
     rb_define_method(cNIO_Selector, "close", NIO_Selector_close, 0);
     rb_define_method(cNIO_Selector, "closed?", NIO_Selector_closed, 0);
+    rb_define_method(cNIO_Selector, "empty?", NIO_Selector_is_empty, 0);
 
     cNIO_Monitor = rb_define_class_under(mNIO, "Monitor",  rb_cObject);
 }
@@ -393,6 +395,15 @@ static VALUE NIO_Selector_closed(VALUE self)
     return selector->closed ? Qtrue : Qfalse;
 }
 
+/* True if there are monitors on the loop */
+static VALUE NIO_Selector_is_empty(VALUE self)
+{
+    VALUE selectables = rb_ivar_get(self, rb_intern("selectables"));
+    
+    return rb_funcall(selectables, rb_intern("empty?"), 0) == Qtrue ? Qtrue : Qfalse;
+}
+
+
 /* Called whenever a timeout fires on the event loop */
 static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
 {

data/lib/nio/selector.rb

@@ -49,16 +49,13 @@ module NIO
         @selectables.each do |io, monitor|
           readers << io if monitor.interests == :r || monitor.interests == :rw
           writers << io if monitor.interests == :w || monitor.interests == :rw
+          monitor.readiness = nil
         end
 
         ready_readers, ready_writers = Kernel.select readers, writers, [], timeout
         return unless ready_readers # timeout or wakeup
-
-        if block_given?
-          result = 0
-        else
-          result = []
-        end
+        
+        selected_monitors = Set.new
 
         ready_readers.each do |io|
           if io == @wakeup
@@ -76,34 +73,29 @@ module NIO
           else
             monitor = @selectables[io]
             monitor.readiness = :r
-
-            if block_given?
-              yield monitor
-              result += 1
-            else
-              result << monitor
-            end
+            selected_monitors << monitor
           end
         end
-
-        ready_readwriters = ready_readers & ready_writers
-        ready_writers = ready_writers - ready_readwriters
-
-        [[ready_writers, :w], [ready_readwriters, :rw]].each do |ios, readiness|
-          ios.each do |io|
-            monitor = @selectables[io]
-            monitor.readiness = readiness
-
-            if block_given?
-              yield monitor
-              result += 1
-            else
-              result << monitor
-            end
+        
+        ready_writers.each do |io|
+          monitor = @selectables[io]
+          monitor.readiness = case monitor.readiness
+          when :r
+            :rw
+          else
+            :w
           end
+          selected_monitors << monitor
+        end
+        
+        if block_given?
+          selected_monitors.each do |m|
+            yield m
+          end
+          selected_monitors.size
+        else
+          selected_monitors
         end
-
-        result
       end
     end
 
@@ -132,5 +124,9 @@ module NIO
 
     # Is this selector closed?
     def closed?; @closed end
+    
+    def empty?
+      @selectables.empty?
+    end
   end
 end

data/lib/nio/version.rb

@@ -1,3 +1,3 @@
 module NIO
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

data/nio4r.gemspec

@@ -14,8 +14,13 @@ Gem::Specification.new do |gem|
   gem.name          = "nio4r"
   gem.require_paths = ["lib"]
   gem.version       = NIO::VERSION
-  gem.platform      = 'java'
-  #gem.extensions    = ["ext/nio4r/extconf.rb"]
+
+  if defined? JRUBY_VERSION
+    gem.files << "lib/nio4r_ext.jar"
+    gem.platform = "java"
+  else
+    gem.extensions = ["ext/nio4r/extconf.rb"]
+  end
 
   gem.add_development_dependency "rake-compiler"
   gem.add_development_dependency "rake"

data/spec/nio/selectables/pipe_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe "IO.pipe" do
+  let(:pair) { IO.pipe }
+
+  let :unreadable_subject do
+    pair.first
+  end
+  let :readable_subject do
+    pipe, peer = pair
+    peer << "data"
+    pipe
+  end
+
+  let :writable_subject do
+    pair.last
+  end
+  let :unwritable_subject do
+    reader, pipe = IO.pipe
+
+    begin
+      pipe.write_nonblock "JUNK IN THE TUBES"
+      _, writers = select [], [pipe], [], 0
+    rescue Errno::EPIPE
+      break
+    end while writers and writers.include? pipe
+
+    pipe
+  end
+
+  it_behaves_like "an NIO selectable"
+  it_behaves_like "an NIO selectable stream"
+end

data/spec/nio/selectables/ssl_socket_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'openssl'
+
+describe OpenSSL::SSL::SSLSocket, :if => RUBY_VERSION >= "1.9.0" do
+  let(:tcp_port) { 34567 }
+
+  let(:ssl_key) { OpenSSL::PKey::RSA.new(1024) }
+
+  let(:ssl_cert) do
+    name = OpenSSL::X509::Name.new([%w[CN localhost]])
+    OpenSSL::X509::Certificate.new.tap do |cert|
+      cert.version = 2
+      cert.serial = 1
+      cert.issuer = name
+      cert.subject = name
+      cert.not_before = Time.now
+      cert.not_after = Time.now + (365 * 24 *60 *60)
+      cert.public_key = ssl_key.public_key
+
+      cert.sign(ssl_key, OpenSSL::Digest::SHA1.new)
+    end
+  end
+
+  let(:ssl_server_context) do
+    OpenSSL::SSL::SSLContext.new.tap do |ctx|
+      ctx.cert = ssl_cert
+      ctx.key = ssl_key
+    end
+  end
+
+  let :readable_subject do
+    server = TCPServer.new("localhost", tcp_port)
+    client = TCPSocket.open("localhost", tcp_port)
+    peer = server.accept
+
+    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
+    ssl_peer.sync_close = true
+
+    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
+    ssl_client.sync_close = true
+
+    # SSLSocket#connect and #accept are blocking calls.
+    thread = Thread.new { ssl_client.connect }
+
+    ssl_peer.accept
+    ssl_peer << "data"
+
+    thread.join
+    pending "Failed to produce a readable SSL socket" unless select([ssl_client], [], [], 0)
+
+    ssl_client
+  end
+
+  let :unreadable_subject do
+    server = TCPServer.new("localhost", tcp_port + 1)
+    client = TCPSocket.new("localhost", tcp_port + 1)
+    peer = server.accept
+
+    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
+    ssl_peer.sync_close = true
+
+    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
+    ssl_client.sync_close = true
+
+    # SSLSocket#connect and #accept are blocking calls.
+    thread = Thread.new { ssl_client.connect }
+    ssl_peer.accept
+    thread.join
+
+    pending "Failed to produce an unreadable socket" if select([ssl_client], [], [], 0)
+    ssl_client
+  end
+
+  let :writable_subject do
+    server = TCPServer.new("localhost", tcp_port + 2)
+    client = TCPSocket.new("localhost", tcp_port + 2)
+    peer = server.accept
+
+    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
+    ssl_peer.sync_close = true
+
+    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
+    ssl_client.sync_close = true
+
+    # SSLSocket#connect and #accept are blocking calls.
+    thread = Thread.new { ssl_client.connect }
+
+    ssl_peer.accept
+    thread.join
+
+    ssl_client
+  end
+
+  let :unwritable_subject do
+    server = TCPServer.new("localhost", tcp_port + 3)
+    client = TCPSocket.open("localhost", tcp_port + 3)
+    peer = server.accept
+
+    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
+    ssl_peer.sync_close = true
+
+    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
+    ssl_client.sync_close = true
+
+    # SSLSocket#connect and #accept are blocking calls.
+    thread = Thread.new { ssl_client.connect }
+
+    ssl_peer.accept
+    thread.join
+
+    begin
+      _, writers = select [], [ssl_client], [], 0
+      count = ssl_client.write_nonblock "X" * 1024
+      count.should_not == 0
+    rescue IO::WaitReadable, IO::WaitWritable
+      pending "SSL will report writable but not accept writes"
+      raise if(writers.include? ssl_client)
+    end while writers and writers.include? ssl_client
+
+    # I think the kernel might manage to drain its buffer a bit even after
+    # the socket first goes unwritable. Attempt to sleep past this and then
+    # attempt to write again
+    sleep 0.1
+
+    # Once more for good measure!
+    begin
+#        ssl_client.write_nonblock "X" * 1024
+      loop { ssl_client.write_nonblock "X" * 1024 }
+    rescue OpenSSL::SSL::SSLError
+    end
+
+    # Sanity check to make sure we actually produced an unwritable socket
+#      if select([], [ssl_client], [], 0)
+#        pending "Failed to produce an unwritable socket"
+#      end
+
+    ssl_client
+  end
+
+  let :pair do
+    pending "figure out why newly created sockets are selecting readable immediately"
+
+    server = TCPServer.new("localhost", tcp_port + 4)
+    client = TCPSocket.open("localhost", tcp_port + 4)
+    peer = server.accept
+
+    ssl_peer = OpenSSL::SSL::SSLSocket.new(peer, ssl_server_context)
+    ssl_peer.sync_close = true
+
+    ssl_client = OpenSSL::SSL::SSLSocket.new(client)
+    ssl_client.sync_close = true
+
+    # SSLSocket#connect and #accept are blocking calls.
+    thread = Thread.new { ssl_client.connect }
+    ssl_peer.accept
+
+    [thread.value, ssl_peer]
+  end
+
+  it_behaves_like "an NIO selectable"
+  it_behaves_like "an NIO selectable stream"
+end

data/spec/nio/selectables/tcp_socket_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe TCPSocket do
+  port_offset = 0
+  let(:tcp_port) { 12345 + (port_offset += 1) }
+  
+  let :readable_subject do
+    server = TCPServer.new("localhost", tcp_port)
+    sock = TCPSocket.open("localhost", tcp_port)
+    peer = server.accept
+    peer << "data"
+    sock
+  end
+
+  let :unreadable_subject do
+    TCPServer.new("localhost", tcp_port)
+    sock = TCPSocket.new("localhost", tcp_port)
+
+    # Sanity check to make sure we actually produced an unreadable socket
+    if select([sock], [], [], 0)
+      pending "Failed to produce an unreadable socket"
+    end
+
+    sock
+  end
+
+  let :writable_subject do
+    TCPServer.new("localhost", tcp_port)
+    TCPSocket.new("localhost", tcp_port)
+  end
+
+  let :unwritable_subject do
+    server = TCPServer.new("localhost", tcp_port)
+    sock = TCPSocket.open("localhost", tcp_port)
+    peer = server.accept
+
+    begin
+      sock.write_nonblock "X" * 1024
+      _, writers = select [], [sock], [], 0
+    end while writers and writers.include? sock
+
+    # I think the kernel might manage to drain its buffer a bit even after
+    # the socket first goes unwritable. Attempt to sleep past this and then
+    # attempt to write again
+    sleep 0.1
+
+    # Once more for good measure!
+    begin
+      sock.write_nonblock "X" * 1024
+    rescue Errno::EWOULDBLOCK
+    end
+
+    # Sanity check to make sure we actually produced an unwritable socket
+    if select([], [sock], [], 0)
+      pending "Failed to produce an unwritable socket"
+    end
+
+    sock
+  end
+
+  let :pair do
+    server = TCPServer.new("localhost", tcp_port)
+    client = TCPSocket.open("localhost", tcp_port)
+    [client, server.accept]
+  end
+
+  it_behaves_like "an NIO selectable"
+  it_behaves_like "an NIO selectable stream"
+  it_behaves_like "an NIO bidirectional stream"
+  
+  context :connect do
+    it "selects writable when connected" do
+      selector = NIO::Selector.new
+      server = TCPServer.new('127.0.0.1', tcp_port)
+
+      client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      monitor = selector.register(client, :w)
+
+      expect do
+        client.connect_nonblock Socket.sockaddr_in(tcp_port, '127.0.0.1')
+      end.to raise_exception Errno::EINPROGRESS
+
+      selector.select(0).should include monitor
+      result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
+      result.unpack('i').first.should be_zero
+    end
+  end
+end

data/spec/nio/selectables/udp_socket_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe UDPSocket do
+  let(:udp_port) { 23456 }
+
+  let :readable_subject do
+    sock = UDPSocket.new
+    sock.bind('localhost', udp_port)
+
+    peer = UDPSocket.new
+    peer.send("hi there", 0, 'localhost', udp_port)
+
+    sock
+  end
+
+  let :unreadable_subject do
+    sock = UDPSocket.new
+    sock.bind('localhost', udp_port + 1)
+    sock
+  end
+
+  let :writable_subject do
+    pending "come up with a writable UDPSocket example"
+  end
+
+  let :unwritable_subject do
+    pending "come up with a UDPSocket that's blocked on writing"
+  end
+
+  it_behaves_like "an NIO selectable"
+end

data/spec/nio/selector_spec.rb

@@ -34,6 +34,14 @@ describe NIO::Selector do
     subject.should_not be_registered(reader)
     monitor.should be_closed
   end
+  
+  it "reports if it is empty" do
+    subject.should be_empty
+    
+    monitor = subject.register(reader, :r)
+    
+    subject.should_not be_empty
+  end
 
   # This spec might seem a bit silly, but this actually something the
   # Java NIO API specifically precludes that we need to work around

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
 require 'rubygems'
 require 'bundler/setup'
-require 'nio'
+require 'nio'
+require 'support/selectable_examples'

data/spec/support/selectable_examples.rb

@@ -0,0 +1,56 @@
+shared_context "an NIO selectable" do
+  let(:selector) { NIO::Selector.new }
+
+  it "selects readable objects" do
+    monitor = selector.register(readable_subject, :r)
+    ready = selector.select(0)
+    ready.should be_an Enumerable
+    ready.should include monitor
+  end
+
+  it "does not select unreadable objects" do
+    monitor = selector.register(unreadable_subject, :r)
+    selector.select(0).should be_nil
+  end
+
+  it "selects writable objects" do
+    monitor = selector.register(writable_subject, :w)
+    ready = selector.select(0)
+    ready.should be_an Enumerable
+    ready.should include monitor
+  end
+
+  it "does not select unwritable objects" do
+    monitor = selector.register(unwritable_subject, :w)
+    selector.select(0).should be_nil
+  end
+end
+
+shared_context "an NIO selectable stream" do
+  let(:selector) { NIO::Selector.new }
+  let(:stream)   { pair.first }
+  let(:peer)     { pair.last }
+
+  it "selects readable when the other end closes" do
+    monitor = selector.register(stream, :r)
+    selector.select(0).should be_nil
+
+    peer.close
+    #Wait and give the TCP session time to close
+    selector.select(0.1).should include monitor
+  end
+end
+
+shared_context "an NIO bidirectional stream" do
+  let(:selector) { NIO::Selector.new }
+  let(:stream)   { pair.first }
+  let(:peer)     { pair.last }
+
+  it "selects readable and writable" do
+    monitor = selector.register(readable_subject, :rw)
+    selector.select(0) do |m|
+      m.readiness.should == :rw
+    end
+  end
+  
+end

metadata

@@ -2,14 +2,14 @@
 name: nio4r
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.3.3
+  version: 0.4.0
 platform: java
 authors:
 - Tony Arcieri
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-03-08 00:00:00.000000000Z
+date: 2012-06-19 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -86,15 +86,19 @@ files:
 - lib/nio/monitor.rb
 - lib/nio/selector.rb
 - lib/nio/version.rb
-- lib/nio4r_ext.jar
 - nio4r.gemspec
 - spec/nio/acceptables_spec.rb
 - spec/nio/monitor_spec.rb
-- spec/nio/selectables_spec.rb
+- spec/nio/selectables/pipe_spec.rb
+- spec/nio/selectables/ssl_socket_spec.rb
+- spec/nio/selectables/tcp_socket_spec.rb
+- spec/nio/selectables/udp_socket_spec.rb
 - spec/nio/selector_spec.rb
 - spec/spec_helper.rb
+- spec/support/selectable_examples.rb
 - tasks/extension.rake
 - tasks/rspec.rake
+- lib/nio4r_ext.jar
 homepage: https://github.com/tarcieri/nio4r
 licenses: []
 post_install_message:
@@ -122,7 +126,11 @@ summary: NIO provides a high performance selector API for monitoring IO objects
 test_files:
 - spec/nio/acceptables_spec.rb
 - spec/nio/monitor_spec.rb
-- spec/nio/selectables_spec.rb
+- spec/nio/selectables/pipe_spec.rb
+- spec/nio/selectables/ssl_socket_spec.rb
+- spec/nio/selectables/tcp_socket_spec.rb
+- spec/nio/selectables/udp_socket_spec.rb
 - spec/nio/selector_spec.rb
 - spec/spec_helper.rb
+- spec/support/selectable_examples.rb
 ...

data/spec/nio/selectables_spec.rb

@@ -1,182 +0,0 @@
-describe "NIO selectables" do
-  let(:selector) { NIO::Selector.new }
-
-  shared_context "an NIO selectable" do
-    it "selects readable objects" do
-      monitor = selector.register(readable_subject, :r)
-      selector.select(0).should include monitor
-    end
-
-    it "does not select unreadable objects" do
-      monitor = selector.register(unreadable_subject, :r)
-      selector.select(0).should be_nil
-    end
-
-    it "selects writable objects" do
-      monitor = selector.register(writable_subject, :w)
-      selector.select(0).should include monitor
-    end
-
-    it "does not select unwritable objects" do
-      monitor = selector.register(unwritable_subject, :w)
-      selector.select(0).should be_nil
-    end
-  end
-
-  shared_context "an NIO selectable stream" do
-    let(:stream) { pair.first }
-    let(:peer)   { pair.last }
-
-    it "selects readable when the other end closes" do
-      monitor = selector.register(stream, :r)
-      selector.select(0).should be_nil
-
-      peer.close
-      selector.select(0).should include monitor
-    end
-  end
-
-  describe "IO.pipe" do
-    let(:pair) { IO.pipe }
-
-    let :unreadable_subject do
-      pair.first
-    end
-    let :readable_subject do
-      pipe, peer = pair
-      peer << "data"
-      pipe
-    end
-
-    let :writable_subject do
-      pair.last
-    end
-    let :unwritable_subject do
-      reader, pipe = IO.pipe
-
-      begin
-        pipe.write_nonblock "JUNK IN THE TUBES"
-        _, writers = select [], [pipe], [], 0
-      rescue Errno::EPIPE
-        break
-      end while writers and writers.include? pipe
-
-      pipe
-    end
-
-    it_behaves_like "an NIO selectable"
-    it_behaves_like "an NIO selectable stream"
-  end
-
-  describe TCPSocket do
-    let(:tcp_port) { 12345 }
-
-    let :readable_subject do
-      server = TCPServer.new("localhost", tcp_port)
-      sock = TCPSocket.open("localhost", tcp_port)
-      peer = server.accept
-      peer << "data"
-      sock
-    end
-
-    let :unreadable_subject do
-      TCPServer.new("localhost", tcp_port + 1)
-      sock = TCPSocket.new("localhost", tcp_port + 1)
-
-      # Sanity check to make sure we actually produced an unreadable socket
-      if select([sock], [], [], 0)
-        pending "Failed to produce an unreadable socket"
-      end
-
-      sock
-    end
-
-    let :writable_subject do
-      TCPServer.new("localhost", tcp_port + 2)
-      TCPSocket.new("localhost", tcp_port + 2)
-    end
-
-    let :unwritable_subject do
-      server = TCPServer.new("localhost", tcp_port + 3)
-      sock = TCPSocket.open("localhost", tcp_port + 3)
-      peer = server.accept
-
-      begin
-        sock.write_nonblock "X" * 1024
-        _, writers = select [], [sock], [], 0
-      end while writers and writers.include? sock
-
-      # I think the kernel might manage to drain its buffer a bit even after
-      # the socket first goes unwritable. Attempt to sleep past this and then
-      # attempt to write again
-      sleep 0.1
-
-      # Once more for good measure!
-      begin
-        sock.write_nonblock "X" * 1024
-      rescue Errno::EWOULDBLOCK
-      end
-
-      # Sanity check to make sure we actually produced an unwritable socket
-      if select([], [sock], [], 0)
-        pending "Failed to produce an unwritable socket"
-      end
-
-      sock
-    end
-
-    let :pair do
-      server = TCPServer.new("localhost", tcp_port + 4)
-      client = TCPSocket.open("localhost", tcp_port + 4)
-      [client, server.accept]
-    end
-
-    it_behaves_like "an NIO selectable"
-    it_behaves_like "an NIO selectable stream"
-
-    it "selects writable when connected" do
-      server = TCPServer.new('127.0.0.1', tcp_port + 5)
-
-      client = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
-      monitor = selector.register(client, :w)
-
-      expect do
-        client.connect_nonblock Socket.sockaddr_in(tcp_port + 5, '127.0.0.1')
-      end.to raise_exception Errno::EINPROGRESS
-
-      selector.select(0).should include monitor
-      result = client.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_ERROR)
-      result.unpack('i').first.should be_zero
-    end
-  end
-
-  describe UDPSocket do
-    let(:udp_port) { 23456 }
-
-    let :readable_subject do
-      sock = UDPSocket.new
-      sock.bind('localhost', udp_port)
-
-      peer = UDPSocket.new
-      peer.send("hi there", 0, 'localhost', udp_port)
-
-      sock
-    end
-
-    let :unreadable_subject do
-      sock = UDPSocket.new
-      sock.bind('localhost', udp_port + 1)
-      sock
-    end
-
-    let :writable_subject do
-      pending "come up with a writable UDPSocket example"
-    end
-
-    let :unwritable_subject do
-      pending "come up with a UDPSocket that's blocked on writing"
-    end
-
-    it_behaves_like "an NIO selectable"
-  end
-end