cool.io 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94010c895806ae23b7ac77b906979c31937463f3
-  data.tar.gz: a73e0f356ee9764a3dd8a3a56c29a187a8ab0693
+  metadata.gz: 69788383b1d7d04b499aed3a4c7430bde6af09cb
+  data.tar.gz: a5bd943271281ef7e72c886cf07b33ea98a7ca0a
 SHA512:
-  metadata.gz: e48dd879dd3a8c76408cbf8569e7fefbf329360cc5b7e95a8f1aeaab2ac647cc9e89d4840fa6b8c86c9eb3cad372f57169303911592914751de1cc94e258569e
-  data.tar.gz: 1408f73b5abfcf72c6ca5c153aa9f1b72ac7bc1ed549235435c839883c0c8aa00ea375495a7e450f0803a8f75dc8b3212bfa9973509cc3003b27ddbe46d59451
+  metadata.gz: 02ff98d0fa4b9b90ed484e5db28c88adcbf4dde3e27ee436282b5a2aab3ea0afe2cfe88d79b10cb643c717e1af0e93736b914112b42061ac640f4ae07a001e84
+  data.tar.gz: ec26d9e2759c5b999f82dbf8dcfac2f407aa571bf941df4b0a6761c00787b793d0574429b0be6887316cbe861c7eef661300c50d7a662f69f87618f7be2717e9

data/.gitignore

@@ -24,3 +24,6 @@ tmp
 
 ## PROJECT::SPECIFIC
 conftest.dSYM
+
+*.lock
+.ruby-version

data/CHANGES.md

@@ -1,3 +1,10 @@
+1.3.1
+-----
+
+* Fix several bugs for JRuby support enhancement
+* Fix deadlock bug on Windows environment
+* Use RSpec3
+
 1.3.0
 -----
 

data/ext/cool.io/extconf.rb

@@ -4,25 +4,11 @@ libs = []
 
 $defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
 
-if have_func('rb_thread_blocking_region')
-  $defs << '-DHAVE_RB_THREAD_BLOCKING_REGION'
-end
-
-if have_func('rb_thread_call_without_gvl')
-  $defs << '-DHAVE_RB_THEREAD_CALL_WITHOUT_GVL'
-end
-
-if have_func('rb_thread_alone')
-  $defs << '-DHAVE_RB_THREAD_ALONE'
-end
-
-if have_func('rb_str_set_len')
-  $defs << '-DHAVE_RB_STR_SET_LEN'
-end
-
-if have_library('rt', 'clock_gettime')
-  libs << "-lrt"
-end
+have_func('rb_thread_blocking_region')
+have_func('rb_thread_call_without_gvl')
+have_func('rb_thread_alone')
+have_func('rb_str_set_len')
+have_library('rt', 'clock_gettime')
 
 if have_header('sys/select.h')
   $defs << '-DEV_USE_SELECT'
@@ -44,9 +30,7 @@ if have_header('port.h')
   $defs << '-DEV_USE_PORT'
 end
 
-if have_header('sys/resource.h')
-  $defs << '-DHAVE_SYS_RESOURCE_H'
-end
+have_header('sys/resource.h')
 
 # ncpu detection specifics
 case RUBY_PLATFORM
@@ -64,14 +48,14 @@ dir_config('cool.io_ext')
 create_makefile('cool.io_ext')
 
 # win32 needs to link in "just the right order" for some reason or  ioctlsocket will be mapped to an [inverted] ruby specific version.  See libev mailing list for (not so helpful discussion--true cause I'm not sure, but this overcomes the symptom)
-if RUBY_PLATFORM =~ /mingw|win32/
+if RUBY_PLATFORM =~ /mingw|mswin/
   makefile_contents = File.read 'Makefile'
 
   # "Init_cool could not be found" when loading cool.io.so.
   # I'm not sure why this is needed. But this line causes "1114 A dynamic link library (DLL) initialization routine failed." So I commented out this line.
   #makefile_contents.gsub! 'DLDFLAGS = ', 'DLDFLAGS = -export-all '
 
-  makefile_contents.gsub! 'LIBS = $(LIBRUBYARG_SHARED)', 'LIBS = -lws2_32 $(LIBRUBYARG_SHARED)'
+  makefile_contents.gsub! /LIBS = (.*) (\S*ws2_32\S*)/i, 'LIBS = \\2 \\1'
   File.open('Makefile', 'w') { |f| f.write makefile_contents }
 end
 

data/ext/cool.io/loop.c

@@ -81,7 +81,7 @@ static void Coolio_Loop_free(struct Coolio_Loop *loop)
 
 static VALUE Coolio_Loop_initialize(VALUE self)
 {
-  Coolio_Loop_ev_loop_new(self, INT2NUM(0));
+  return Coolio_Loop_ev_loop_new(self, INT2NUM(0));
 }
 
 /* Wrapper for populating a Coolio_Loop struct with a new event loop */

data/ext/iobuffer/iobuffer.c

@@ -11,7 +11,9 @@
 
 #include <string.h>
 #include <time.h>
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
 #include <errno.h>
 
 /* 1 GiB maximum buffer size */

data/ext/libev/ev.c

@@ -1153,8 +1153,8 @@ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () ==
     int m = x & 0x3ff;
     float r;
 
-    if      (!e     ) r = ldexpf (m        ,    -24);
-    else if (e != 31) r = ldexpf (m + 0x400, e - 25);
+    if      (!e     ) r = ldexpf ((float)m        ,    -24);
+    else if (e != 31) r = ldexpf ((float)m + 0x400, e - 25);
     else if (m      ) r = ECB_NAN;
     else              r = ECB_INFINITY;
 
@@ -2263,7 +2263,7 @@ evpipe_write (EV_P_ EV_ATOMIC_T *flag)
 #ifdef _WIN32
           WSABUF buf;
           DWORD sent;
-          buf.buf = &buf;
+          buf.buf = (CHAR*)&buf;
           buf.len = 1;
           WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
 #else
@@ -3343,6 +3343,7 @@ VALUE ev_backend_poll(void **args)
   struct ev_loop *loop = (struct ev_loop *)args[0];
   ev_tstamp waittime = *(ev_tstamp *)args[1];
   backend_poll (EV_A_ waittime);
+  return Qnil;
 }
 #endif
 /* ######################################## */

data/ext/libev/ev_select.c

@@ -106,6 +106,7 @@ if (__i == ((fd_set *)(set))->fd_count) {\
 } while(0)
 #define EV_WIN_FD_ZERO(set) (((fd_set *)(set))->fd_count=0)
 #define EV_WIN_FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (fd_set *)(set))
+#define EV_WIN_FD_COUNT(set) (((fd_set *)(set))->fd_count)
 /* ######################################## */
 #else
 #define EV_WIN_FD_CLR FD_CLR
@@ -192,6 +193,23 @@ select_poll (EV_P_ ev_tstamp timeout)
   int res;
   int fd_setsize;
 
+#ifdef _WIN32
+  /* POSIX defines the case when the readfds, writefds, and errorfds arguments
+   * are all null pointers.
+   * http://pubs.opengroup.org/onlinepubs/9699919799/functions/select.html
+   *
+   * But Windows doesn't define such case; simply say don't so that
+   * https://msdn.microsoft.com/en-us/library/windows/desktop/ms740141(v=vs.85).aspx
+   * "Any two of the parameters, readfds, writefds, or exceptfds, can be given
+   * as null. At least one must be non-null, and any non-null descriptor set
+   * must contain at least one handle to a socket."
+   * At least on Windows Server 2012 R2 Datacenter with Visual Studio 2013
+   * (Visual C++ 12), it cause WaitForMultipleObjects stuck.
+   */
+  if (EV_WIN_FD_COUNT(vec_ri) == 0 && EV_WIN_FD_COUNT(vec_wi) == 0)
+    return;
+#endif
+
   EV_RELEASE_CB;
   EV_TV_SET (tv, timeout);
 
@@ -246,7 +264,7 @@ select_poll (EV_P_ ev_tstamp timeout)
         {
           if (timeout)
             {
-              unsigned long ms = timeout * 1e3;
+              unsigned long ms = (unsigned long)(timeout * 1e3);
               Sleep (ms ? ms : 1);
             }
 

data/lib/cool.io/dns_resolver.rb

@@ -106,9 +106,8 @@ module Coolio
     def send_request
       nameserver = @nameservers.shift
       @nameservers << nameserver # rotate them
-      @socket.connect @nameservers.first, DNS_PORT
       begin
-        @socket.send request_message, 0
+        @socket.send request_message, 0, @nameservers.first, DNS_PORT
       rescue Errno::EHOSTUNREACH # TODO figure out why it has to be wrapper here, when the other wrapper should be wrapping this one!
       end
     end

data/lib/cool.io/io.rb

@@ -102,7 +102,7 @@ module Coolio
     def close
       detach if attached?
       detach_write_watcher
-      @_io.close unless @_io.closed?
+      @_io.close unless closed?
 
       on_close
       nil

data/lib/cool.io/version.rb

@@ -1,5 +1,5 @@
 module Coolio
-  VERSION = "1.3.0"
+  VERSION = "1.3.1"
   
   def self.version
     VERSION

data/spec/async_watcher_spec.rb

@@ -30,7 +30,7 @@ describe Cool.io::AsyncWatcher, :env => :exclude_win do
     end
 
     # ensure children are ready
-    nr_fork.times { rd.sysread(1).should == '.' }
+    nr_fork.times { expect(rd.sysread(1)).to eq('.') }
 
     # send our signals
     nr_signal.times { aw.signal }
@@ -41,15 +41,15 @@ describe Cool.io::AsyncWatcher, :env => :exclude_win do
     children.each do |pid|
       Process.kill(:TERM, pid)
       _, status = Process.waitpid2(pid)
-      status.exitstatus.should == 0
+      expect(status.exitstatus).to eq(0)
     end
 
     # we should've written a line for every signal we sent
     lines = tmp.readlines
-    lines.size.should == nr_signal
+    expect(lines.size).to eq(nr_signal)
 
     # theoretically a bad kernel scheduler could give us fewer...
-    lines.sort.uniq.size.should == nr_fork
+    expect(lines.sort.uniq.size).to eq(nr_fork)
 
     tmp.close!
   end

data/spec/dns_spec.rb

@@ -22,18 +22,22 @@ describe "DNS" do
   end
   
   it "connects to valid domains" do
-    ConnectorThingy.connect(VALID_DOMAIN, 80).attach(@loop)
-    
-    proc do
-      @loop.run
-    end.should raise_error(ItWorked)
+    begin
+      c = ConnectorThingy.connect(VALID_DOMAIN, 80).attach(@loop)
+      
+      expect do
+        @loop.run
+      end.to raise_error(ItWorked)
+    ensure
+      c.close
+    end
   end
   
   it "fires on_resolve_failed for invalid domains" do
     ConnectorThingy.connect(INVALID_DOMAIN, 80).attach(@loop)
     
-    proc do
+    expect do
       @loop.run
-    end.should raise_error(WontResolve)
+    end.to raise_error(WontResolve)
   end
 end

data/spec/iobuffer_spec.rb

@@ -0,0 +1,147 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+
+describe IO::Buffer do
+
+  let :buffer do
+    IO::Buffer.new
+  end
+  
+  it "provides a subset of the methods available in Strings" do
+    expect(buffer << "foo").to eq "foo"
+    expect(buffer << "bar").to eq "bar"
+    expect(buffer.to_str).to eq "foobar"
+    expect(buffer.to_str).to eq "foobar"
+    expect(buffer.size).to eq 6
+  end
+
+  it "provides append and prepend" do
+    expect(buffer.append "bar").to eq "bar"
+    expect(buffer.prepend "foo").to eq "foo"
+    expect(buffer.append "baz").to eq "baz"
+    expect(buffer.to_str).to eq "foobarbaz"
+  end
+  
+  context "#read" do
+    it "can be used to retrieve the contents of a buffer" do
+      expect(buffer << "foo").to eq "foo"
+      expect(buffer.read 2).to eq "fo"
+      expect(buffer << "bar").to eq "bar"
+      expect(buffer.read 2).to eq "ob"
+      expect(buffer << "baz").to eq "baz"
+      expect(buffer.read 3).to eq "arb"
+    end
+  end
+  
+  describe "provides methods for performing non-blocking I/O" do
+    require "tempfile"
+    
+    context "#read_from" do
+      context "using local file", :env => :exclude_win do
+        let :tmp do
+          t = Tempfile.open "read_from"
+          t << "foobar"
+          t.rewind
+          t
+        end
+        
+        it "will read as much data as possible" do
+          expect(buffer.read_from tmp).to eq 6
+          expect(buffer.to_str).to eq "foobar"
+        end
+      end
+      
+      context "using udp socket" do
+        before :each do
+          @receiver = UDPSocket.open
+          @receiver.bind nil, 0
+          
+          @sender = UDPSocket.open
+          @sender.connect "localhost", @receiver.addr[1]
+        end
+        after :each do
+          @receiver.close
+          @sender.close
+        end
+        
+        it "will read as much data as possible" do
+          select [], [@sender]
+          @sender.send "foo", 0
+          select [@receiver]
+          expect(buffer.read_from @receiver).to eq 3
+          expect(buffer.to_str).to eq "foo"
+          
+          select [], [@sender]
+          @sender.send "barbaz", 0
+          select [@receiver]
+          expect(buffer.read_from @receiver).to eq 6
+          expect(buffer.to_str).to eq "foobarbaz"
+        end
+      end
+    end
+    
+    context "#write_to" do
+      context "using local file", :env => :exclude_win do
+        let :tmp do
+          Tempfile.open "write_to"
+        end
+        it "writes the contents of the buffer" do
+          buffer << "foo"
+          expect(buffer.write_to tmp).to eq 3
+          tmp.rewind
+          expect(tmp.read 3).to eq "foo"
+        end
+      end
+      
+      context "using udp socket" do
+        before :each do
+          @receiver = UDPSocket.open
+          @receiver.bind nil, 0
+          
+          @sender = UDPSocket.open
+          @sender.connect "localhost", @receiver.addr[1]
+        end
+        after :each do
+          @receiver.close
+          @sender.close
+        end
+        
+        it "will read as much data as possible" do
+          buffer << "foo"
+          select [], [@sender]
+          expect(buffer.write_to @sender).to eq 3
+          select [@receiver]
+          expect(@receiver.recvfrom_nonblock(3)[0]).to eq "foo"
+        end
+      end
+    end
+  end
+  
+  context "#clear" do
+    it "clear all data" do
+      buffer << "foo"
+      expect(buffer.size).to eq 3
+      expect(buffer.empty?).to eq false
+      buffer.clear
+      expect(buffer.size).to eq 0
+      expect(buffer.empty?).to eq true
+    end
+  end
+  
+  context "#read_frame" do
+    it "Read up to and including the given frame marker" do
+      buffer << "foo\nbarbaz"
+      data = ""
+      expect(buffer.read_frame data, "\n".ord).to eq true
+      expect(buffer.empty?).to eq false
+      expect(data).to eq "foo\n"
+      expect(buffer.to_str).to eq "barbaz"
+      
+      expect(buffer.read_frame data, "\n".ord).to eq false
+      expect(buffer.empty?).to eq true
+      expect(data).to eq "foo\nbarbaz"
+      expect(buffer.to_str).to eq ""
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ def unused_port
 end
 
 RSpec.configure do |c|
-  if RUBY_PLATFORM =~ /mingw|win32/
+  if RUBY_PLATFORM =~ /mingw|mswin/
     $stderr.puts "Skip some specs on Windows"
     c.filter_run_excluding :env => :exclude_win
   end

data/spec/stat_watcher_spec.rb

@@ -62,16 +62,16 @@ describe Cool.io::StatWatcher do
   end
 
   it "fire on_change when the file it is watching is modified" do
-    watcher.accessed.should eql(true)
+    expect(watcher.accessed).to eq(true)
   end
 
   it "should pass previous and current file stat info given a stat watcher" do
-    watcher.previous.ino.should eql(watcher.current.ino)
+    expect(watcher.previous.ino).to eq(watcher.current.ino)
   end
 
   it "should raise when the handler does not take 2 parameters" do
     class MyStatWatcher < Cool.io::StatWatcher; def on_change; end; end
-    lambda { watcher.accessed }.should raise_error(ArgumentError)
+    expect { watcher.accessed }.to raise_error(ArgumentError)
   end
 
 end

data/spec/tcp_server_spec.rb

@@ -109,11 +109,11 @@ end
 describe Coolio::TCPServer do
 
   it '#run' do
-    test_run("hello").should == "hello"
+    expect(test_run("hello")).to eq("hello")
   end
 
   it '#run_once' do
-    test_run_once("hello").should == "hello"
+    expect(test_run_once("hello")).to eq("hello")
   end
 
   it '#run_once(timeout)' do
@@ -125,8 +125,101 @@ describe Coolio::TCPServer do
   end
 
   it '#run(timeout)' do
-    test_run_timeout("hello").should == "hello"
+    expect(test_run_timeout("hello")).to eq("hello")
   end
 
+  describe "functionaltest" do
+    let :loop do
+      Coolio::Loop.new
+    end
+    
+    let :port do
+      unused_port
+    end
+    
+    context "#on_connect" do
+      class ServerOnConnect < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_connect
+          @cb.call
+        end
+      end
+      
+      it "connected socket called on_connect" do
+        begin
+          connected = false
+          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { connected = true })
+          loop.attach server
+          s = TCPSocket.open("localhost", port)
+          loop.run_once
+          s.close
+          expect(connected).to eq true
+        ensure
+          server.detach
+        end
+      end
+    end
+    
+    context "#on_close" do
+      class ServerOnClose < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_close
+          @cb.call
+        end
+      end
+      
+      it "closed socket called on_close" do
+        begin
+          closed = false
+          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { closed = true })
+          loop.attach server
+          s = TCPSocket.open("localhost", port)
+          loop.run_once
+          s.close
+          loop.run_once
+          expect(closed).to eq true
+        ensure
+          server.detach
+        end
+      end
+    end
+    
+    context "#on_read" do
+      class Echo < Coolio::Socket
+        def initialize(io, cb)
+          super(io)
+          @cb = cb
+        end
+        def on_read(data)
+          @cb.call data
+          size = write(data + "fff")
+        end
+      end
+      
+      it "server socket received data" do
+        begin
+          data = "aaa"
+          server = Cool.io::TCPServer.new("localhost", port, Echo, proc { |d| data = d })
+          loop.attach server
+          thread = Thread.new { loop.run }
+          s = TCPSocket.open("localhost", port)
+          s.write "zzz"
+          sleep 0.1
+          expect(data).to eq "zzz"
+          expect(s.read 6).to eq "zzzfff"
+        ensure
+          s.close
+          loop.stop
+          server.detach
+          thread.join
+        end
+      end
+    end
+  end
 end
-

data/spec/tcp_socket_spec.rb

@@ -1,27 +1,185 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe Coolio::TCPSocket do
-
+  let :loop do
+    Coolio::Loop.new
+  end
+  
   before :each do
-    @server = TCPServer.new('127.0.0.1', 0)
-    @host = @server.addr[3]
-    @port = @server.addr[1]
+    @echo = TCPServer.new("127.0.0.1", 0)
+    @host = @echo.addr[3]
+    @port = @echo.addr[1]
+    @running = true
+    @echo_thread = Thread.new do
+      socks = [@echo]
+      begin
+        serv socks
+      ensure
+        socks.each do |s|
+          s.close
+        end
+      end
+      Thread.pass
+    end
   end
-
+  
+  def serv(socks)
+    while @running
+      selected = select(socks, [], [], 0.1)
+      next if selected.nil?
+      selected[0].each do |s|
+        if s == @echo
+          socks.push s.accept
+          next
+        end
+        begin
+          unless s.eof?
+            s.write(s.read_nonblock 1)
+          end
+        rescue SystemCallError, EOFError, IOError, SocketError
+        end
+      end
+    end
+  end
+  
+  def shutdown
+    if @running
+      @running = false
+      @echo_thread.join
+    end
+  end
+  
   after :each do
-    @server.close
+    shutdown
   end
 
-  describe '#close' do
-
-    it 'detaches all watchers on #close before loop#run' do
-      reactor = Coolio::Loop.new
+  context "#close" do
+    it "detaches all watchers on #close before loop#run" do
       client = Coolio::TCPSocket.connect(@host, @port)
-      reactor.attach(client)
+      loop.attach client
       client.close
-      reactor.watchers.size.should == 0
+      expect(loop.watchers.size).to eq 0
     end
   end
 
-end
+  context "#on_connect" do
+    class OnConnect < Cool.io::TCPSocket
+      attr :connected
+      def on_connect
+        @connected = true
+      end
+    end
+    
+    it "connected client called on_connect" do
+      begin
+        c = OnConnect.connect(@host, @port)
+        loop.attach c
+        loop.run_once
+        expect(c.connected).to eq true
+      ensure
+        c.close
+      end
+    end
+  end
 
+  context "#on_connect_failed" do
+    class OnConnectFailed < Cool.io::TCPSocket
+      attr :connect_failed
+      def on_connect_failed
+        @connect_failed = true
+      end
+    end
+    
+    it "try to connect dead host" do
+      serv = TCPServer.new(0)
+      dead_host = serv.addr[3]
+      dead_port = serv.addr[1]
+      serv.close
+      
+      c = OnConnectFailed.connect(dead_host, dead_port)
+      loop.attach c
+      loop.run_once # on_connect_failed
+      expect(c.connect_failed).to eq true
+    end
+  end
+
+  context "#on_close" do
+    class Closed < StandardError; end
+    class OnClose < Cool.io::TCPSocket
+      def on_close
+        raise Closed
+      end
+    end
+    
+    let :client do
+      OnClose.connect(@host, @port)
+    end
+    
+    before :each do
+      loop.attach client
+      loop.run_once # on_connect
+      client.write "0"
+    end
+    
+    it "disconnect from client" do
+      expect { client.close }.to raise_error(Closed)
+    end
+
+    it "disconnect from server" do
+      shutdown
+      expect { loop.run }.to raise_error(Closed)
+    end
+  end
+  
+  context "#on_read" do
+    class Finished < StandardError; end
+    class OnRead < Cool.io::TCPSocket
+      attr :read_data, :times
+      def on_connect
+        @read_data = ""
+        @times = 0
+      end
+      def on_read(data)
+        @read_data += data
+        @times += 1
+        if @times < 5
+          write "#{@times}"
+        else
+          close
+          raise Finished
+        end
+      end
+    end
+    
+    it "receive 5 times" do
+      c = OnRead.connect(@host, @port)
+      loop.attach c
+      loop.run_once # on_connect
+      c.write "0"
+      expect { loop.run }.to raise_error(Finished)
+      
+      expect(c.times).to eq 5
+      expect(c.read_data).to eq "01234"
+    end
+  end
+  
+  context "#on_write_complete" do
+    class WriteComplete < StandardError; end
+    class OnWriteComplete < Cool.io::TCPSocket
+      attr :called
+      def on_write_complete
+        @called = true
+        close
+        raise WriteComplete
+      end
+    end
+    
+    it "on_write_complete is called" do
+      c = OnWriteComplete.connect(@host, @port)
+      loop.attach c
+      loop.run_once # on_connect
+      c.write "aaa"
+      expect { loop.run }.to raise_error(WriteComplete)
+    end
+  end
+end

data/spec/timer_watcher_spec.rb

@@ -4,15 +4,19 @@ describe Cool.io::TimerWatcher do
 
   interval = 0.010
 
+  let :loop do
+    Cool.io::Loop.new
+  end
+
   it "can have the on_timer callback defined after creation" do
     @watcher = Cool.io::TimerWatcher.new(interval, true)
     nr = '0'
-    @watcher.on_timer { nr.succ! }.should == nil
-    @watcher.attach(Cool.io::Loop.default).should == @watcher
-    nr.should == '0'
+    expect(@watcher.on_timer { nr.succ! }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('0')
     sleep interval
-    Cool.io::Loop.default.run_once
-    nr.should == '1'
+    loop.run_once
+    expect(nr).to eq('1')
   end
 
   it "can be subclassed" do
@@ -24,29 +28,29 @@ describe Cool.io::TimerWatcher do
       end
     end
     @watcher = MyTimerWatcher.new(interval, true)
-    @watcher.attach(Cool.io::Loop.default).should == @watcher
-    MyTimerWatcher::TMP.should == '0'
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(MyTimerWatcher::TMP).to eq('0')
     sleep interval
-    Cool.io::Loop.default.run_once
-    MyTimerWatcher::TMP.should == '1'
+    loop.run_once
+    expect(MyTimerWatcher::TMP).to eq('1')
   end
 
   it "can have the on_timer callback redefined between runs" do
     @watcher = Cool.io::TimerWatcher.new(interval, true)
     nr = '0'
-    @watcher.on_timer { nr.succ! }.should == nil
-    @watcher.attach(Cool.io::Loop.default).should == @watcher
-    nr.should == '0'
+    expect(@watcher.on_timer { nr.succ! }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('0')
     sleep interval
-    Cool.io::Loop.default.run_once
-    nr.should == '1'
+    loop.run_once
+    expect(nr).to eq('1')
     @watcher.detach
-    @watcher.on_timer { nr = :foo }.should == nil
-    @watcher.attach(Cool.io::Loop.default).should == @watcher
-    nr.should == '1'
+    expect(@watcher.on_timer { nr = :foo }).to be_nil
+    expect(@watcher.attach(loop)).to eq(@watcher)
+    expect(nr).to eq('1')
     sleep interval
-    Cool.io::Loop.default.run_once
-    nr.should == :foo
+    loop.run_once
+    expect(nr).to eq(:foo)
   end
 
   after :each do

data/spec/udp_socket_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe "Coolio::UDPSocket" do
+  let :loop do
+    Coolio::Loop.new
+  end
+  
+  before :each do
+    @echo = UDPSocket.open
+    @echo.bind nil, 0
+    @port = @echo.addr[1]
+    
+    @running = true
+    @echo_thread = Thread.new do
+      while @running
+        begin
+          msg, sender = @echo.recvfrom_nonblock(3)
+          @echo.send(msg + "bbb", 0, sender[3], sender[1])
+        rescue IO::WaitReadable
+        end
+        Thread.pass
+      end
+    end
+  end
+  
+  after :each do
+    @running = false
+    @echo_thread.join
+    @echo.close
+  end
+  
+  class Readable < Cool.io::IOWatcher
+    attr :socket, :received
+    def initialize
+      @socket = UDPSocket.new
+      super(@socket)
+    end
+    
+    def on_readable
+      @received = @socket.recvfrom_nonblock(6).first
+    end
+  end
+  
+  it "receive message #on_readable 5 times" do
+    5.times do
+      begin
+        r = Readable.new
+        r.socket.send "aaa", 0, "localhost", @port
+        
+        loop.attach r
+        loop.run_once
+        expect(r.received).to eq "aaabbb"
+      ensure
+        r.detach
+      end
+    end
+  end
+end

data/spec/unix_listener_spec.rb

@@ -5,21 +5,21 @@ describe Cool.io::UNIXListener, :env => :exclude_win do
 
   before :each do
     @tmp = Tempfile.new('coolio_unix_listener_spec')
-    File.unlink(@tmp.path).should == 1
-    File.exist?(@tmp.path).should == false
+    expect(File.unlink(@tmp.path)).to eq(1)
+    expect(File.exist?(@tmp.path)).to eq(false)
   end
 
   it "creates a new UNIXListener" do
     listener = Cool.io::UNIXListener.new(@tmp.path)
-    File.socket?(@tmp.path).should == true
+    expect(File.socket?(@tmp.path)).to eq(true)
   end
 
   it "builds off an existing UNIXServer" do
     unix_server = UNIXServer.new(@tmp.path)
-    File.socket?(@tmp.path).should == true
+    expect(File.socket?(@tmp.path)).to eq(true)
     listener = Cool.io::UNIXListener.new(unix_server)
-    File.socket?(@tmp.path).should == true
-    listener.fileno.should == unix_server.fileno
+    expect(File.socket?(@tmp.path)).to eq(true)
+    expect(listener.fileno).to eq(unix_server.fileno)
   end
 
 end

data/spec/unix_server_spec.rb

@@ -5,23 +5,23 @@ describe Cool.io::UNIXServer, :env => :exclude_win do
 
   before :each do
     @tmp = Tempfile.new('coolio_unix_server_spec')
-    File.unlink(@tmp.path).should == 1
-    File.exist?(@tmp.path).should == false
+    expect(File.unlink(@tmp.path)).to eq(1)
+    expect(File.exist?(@tmp.path)).to eq(false)
   end
 
   it "creates a new Cool.io::UNIXServer" do
     listener = Cool.io::UNIXListener.new(@tmp.path)
     listener.listen(24)
-    File.socket?(@tmp.path).should == true
+    expect(File.socket?(@tmp.path)).to eq(true)
   end
 
   it "builds off an existing ::UNIXServer" do
     unix_server = ::UNIXServer.new(@tmp.path)
-    File.socket?(@tmp.path).should == true
+    expect(File.socket?(@tmp.path)).to eq(true)
     listener = Cool.io::UNIXServer.new(unix_server, Coolio::UNIXSocket)
     listener.listen(24)
-    File.socket?(@tmp.path).should == true
-    listener.fileno.should == unix_server.fileno
+    expect(File.socket?(@tmp.path)).to eq(true)
+    expect(listener.fileno).to eq(unix_server.fileno)
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Tony Arcieri
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-21 00:00:00.000000000 Z
+date: 2015-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -129,11 +129,13 @@ files:
 - lib/coolio.rb
 - spec/async_watcher_spec.rb
 - spec/dns_spec.rb
+- spec/iobuffer_spec.rb
 - spec/spec_helper.rb
 - spec/stat_watcher_spec.rb
 - spec/tcp_server_spec.rb
 - spec/tcp_socket_spec.rb
 - spec/timer_watcher_spec.rb
+- spec/udp_socket_spec.rb
 - spec/unix_listener_spec.rb
 - spec/unix_server_spec.rb
 homepage: http://coolio.github.com
@@ -155,17 +157,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A cool framework for doing high performance I/O in Ruby
 test_files:
 - spec/async_watcher_spec.rb
 - spec/dns_spec.rb
+- spec/iobuffer_spec.rb
 - spec/spec_helper.rb
 - spec/stat_watcher_spec.rb
 - spec/tcp_server_spec.rb
 - spec/tcp_socket_spec.rb
 - spec/timer_watcher_spec.rb
+- spec/udp_socket_spec.rb
 - spec/unix_listener_spec.rb
 - spec/unix_server_spec.rb