ffi-rzmq 1.0.3 → 2.0.7

data/spec/poll_spec.rb

@@ -8,7 +8,7 @@ module ZMQ
       include APIHelper
 
       it "should allocate a PollItems instance" do
-        PollItems.should_receive(:new)
+        expect(PollItems).to receive(:new)
         Poller.new
       end
 
@@ -23,30 +23,30 @@ module ZMQ
       let(:fd) { 1 }
 
       it "returns false when given a nil pollable" do
-        poller.register(nil, ZMQ::POLLIN).should be_false
+        expect(poller.register(nil, ZMQ::POLLIN)).to be_falsy
       end
 
       it "returns false when given 0 for +events+ (e.g. no registration)" do
-        poller.register(pollable, 0).should be_false
+        expect(poller.register(pollable, 0)).to be_falsy
       end
 
       it "returns the default registered event value when given a valid pollable" do
-        poller.register(pollable).should == (ZMQ::POLLIN | ZMQ::POLLOUT)
+        expect(poller.register(pollable)).to eq(ZMQ::POLLIN | ZMQ::POLLOUT)
       end
 
       it "returns the registered event value when given a pollable responding to socket (ZMQ::Socket)" do
-        pollable.should_receive(:socket).and_return(socket)
-        poller.register(pollable, ZMQ::POLLIN).should == ZMQ::POLLIN
+        expect(pollable).to receive(:socket).and_return(socket)
+        expect(poller.register(pollable, ZMQ::POLLIN)).to eq ZMQ::POLLIN
       end
 
       it "returns the registered event value when given a pollable responding to file descriptor (IO, BasicSocket)" do
-        pollable.should_receive(:posix_fileno).and_return(fd)
-        poller.register(pollable, ZMQ::POLLIN).should == ZMQ::POLLIN
+        expect(pollable).to receive(:posix_fileno).and_return(fd)
+        expect(poller.register(pollable, ZMQ::POLLIN)).to eq(ZMQ::POLLIN)
       end
 
       it "returns the registered event value when given a pollable responding to io (SSLSocket)" do
-        pollable.should_receive(:io).and_return(io)
-        poller.register(pollable, ZMQ::POLLIN).should == ZMQ::POLLIN
+        expect(pollable).to receive(:io).and_return(io)
+        expect(poller.register(pollable, ZMQ::POLLIN)).to eq(ZMQ::POLLIN)
       end
 
     end
@@ -60,49 +60,49 @@ module ZMQ
       let(:fd) { 1 }
 
       it "returns true when deregistered pollable from event" do
-        pollable.should_receive(:socket).at_least(:once).and_return(socket)
+        expect(pollable).to  receive(:socket).at_least(:once).and_return(socket)
         poller.register(pollable)
-        poller.deregister(pollable, ZMQ::POLLIN).should be_true
+        expect(poller.deregister(pollable, ZMQ::POLLIN)).to eq(true)
       end
 
       it "returns false when pollable not registered" do
-        poller.deregister(pollable, ZMQ::POLLIN).should be_false
+        expect(poller.deregister(pollable, ZMQ::POLLIN)).to eq(false)
       end
 
       it "returns false when pollable not registered for deregistered event" do
-        pollable.should_receive(:socket).at_least(:once).and_return(socket)
+        expect(pollable).to receive(:socket).at_least(:once).and_return(socket)
         poller.register(pollable, ZMQ::POLLOUT)
-        poller.deregister(pollable, ZMQ::POLLIN).should be_false
+        expect(poller.deregister(pollable, ZMQ::POLLIN)).to eq(false)
       end
 
       it "deletes pollable when no events left" do
         poller.register(pollable, ZMQ::POLLIN)
-        poller.deregister(pollable, ZMQ::POLLIN).should be_true
-        poller.size.should == 0
+        expect(poller.deregister(pollable, ZMQ::POLLIN)).to eq(true)
+        expect(poller.size).to eq 0
       end
 
       it "deletes closed pollable responding to socket (ZMQ::Socket)" do
-        pollable.should_receive(:socket).and_return(socket)
+        expect(pollable).to receive(:socket).and_return(socket)
         poller.register(pollable)
-        pollable.should_receive(:socket).and_return(nil)
-        poller.deregister(pollable, ZMQ::POLLIN).should be_true
-        poller.size.should == 0
+        expect(pollable).to receive(:socket).and_return(nil)
+        expect(poller.deregister(pollable, ZMQ::POLLIN)).to eq(true)
+        expect(poller.size).to eq 0
       end
 
       it "deletes closed pollable responding to fileno (IO, BasicSocket)" do
-        pollable.should_receive(:posix_fileno).and_return(fd)
+        expect(pollable).to receive(:posix_fileno).and_return(fd)
         poller.register(pollable)
-        pollable.should_receive(:closed?).and_return(true)
-        poller.deregister(pollable, ZMQ::POLLIN).should be_true
-        poller.size.should == 0
+        expect(pollable).to receive(:closed?).and_return(true)
+        expect(poller.deregister(pollable, ZMQ::POLLIN)).to eq(true)
+        expect(poller.size).to eq 0
       end
 
       it "deletes closed pollable responding to io (SSLSocket)" do
-        pollable.should_receive(:io).at_least(:once).and_return(io)
+        expect(pollable).to receive(:io).at_least(:once).and_return(io)
         poller.register(pollable)
-        io.should_receive(:closed?).and_return(true)
-        poller.deregister(pollable, ZMQ::POLLIN).should be_true
-        poller.size.should == 0
+        expect(io).to receive(:closed?).and_return(true)
+        expect(poller.deregister(pollable, ZMQ::POLLIN)).to eq(true)
+        expect(poller.size).to eq 0
       end
 
     end
@@ -123,7 +123,7 @@ module ZMQ
       end
 
       it "should return false for an unregistered socket (i.e. not found)" do
-        @poller.delete(@socket).should be_false
+        expect(@poller.delete(@socket)).to eq(false)
       end
 
       it "returns true for a sucessfully deleted socket when only 1 is registered" do
@@ -131,7 +131,7 @@ module ZMQ
         socket1.setsockopt(LINGER, 0)
 
         @poller.register socket1
-        @poller.delete(socket1).should be_true
+        expect(@poller.delete(socket1)).to eq(true)
         socket1.close
       end
 
@@ -143,7 +143,7 @@ module ZMQ
 
         @poller.register socket1
         @poller.register socket2
-        @poller.delete(socket2).should be_true
+        expect(@poller.delete(socket2)).to eq(true)
         socket1.close
         socket2.close
       end
@@ -154,7 +154,7 @@ module ZMQ
 
         @poller.register socket1
         socket1.close
-        @poller.delete(socket1).should be_true
+        expect(@poller.delete(socket1)).to eq(true)
       end
 
     end
@@ -177,12 +177,12 @@ module ZMQ
       after(:each) { @sockets.each(&:close) }
 
       it "returns 0 when there are no sockets to poll" do
-        @poller.poll(100).should be_zero
+        expect(@poller.poll(100)).to eq 0
       end
 
       it "returns 0 when there is a single socket to poll and no events" do
         @poller.register(@sockets.first, 0)
-        @poller.poll(100).should be_zero
+        expect(@poller.poll(100)).to eq 0
       end
 
       it "returns 1 when there is a read event on a socket" do
@@ -190,7 +190,7 @@ module ZMQ
         @poller.register_readable(last)
 
         first.send_string('test')
-        @poller.poll(1000).should == 1
+        expect(@poller.poll(1000)).to eq 1
       end
 
       it "returns 1 when there is a read event on one socket and the second socket has been removed from polling" do
@@ -200,7 +200,7 @@ module ZMQ
 
         first.send_string('test')
         @poller.deregister_writable(first)
-        @poller.poll(1000).should == 1
+        expect(@poller.poll(1000)).to eq 1
       end
 
       it "works with BasiSocket" do
@@ -214,12 +214,12 @@ module ZMQ
 
         client.send("message", 0)
 
-        @poller.poll.should == 2
-        @poller.readables.should == [s]
-        @poller.writables.should == [client]
+        expect(@poller.poll).to eq 2
+        expect(@poller.readables).to eq [s]
+        expect(@poller.writables).to eq [client]
 
         msg = s.read_nonblock(7)
-        msg.should == "message"
+        expect(msg).to eq "message"
       end
 
       it "works with IO objects" do
@@ -229,12 +229,12 @@ module ZMQ
 
         w.write("message")
 
-        @poller.poll.should == 2
-        @poller.readables.should == [r]
-        @poller.writables.should == [w]
+        expect(@poller.poll).to eq 2
+        expect(@poller.readables).to eq [r]
+        expect(@poller.writables).to eq [w]
 
         msg = r.read(7)
-        msg.should == "message"
+        expect(msg).to eq "message"
       end
 
       it "works with SSLSocket" do
@@ -262,12 +262,12 @@ module ZMQ
 
         client.write("message")
 
-        @poller.poll.should == 2
-        @poller.readables.should == [s]
-        @poller.writables.should == [client]
+        expect(@poller.poll).to eq 2
+        expect(@poller.readables).to eq [s]
+        expect(@poller.writables).to eq [client]
 
         msg = s.read(7)
-        msg.should == "message"
+        expect(msg).to eq "message"
       end
     end
 

data/spec/pushpull_spec.rb

@@ -35,7 +35,7 @@ module ZMQ
         received = ''
         rc = @pull.recv_string received
         assert_ok(rc)
-        received.should == string
+        expect(received).to eq(string)
       end
 
       it "should receive an exact string copy of the message sent when receiving in non-blocking mode and using Message objects directly" do
@@ -44,12 +44,12 @@ module ZMQ
 
         poll_it_for_read(@pull) do
           rc = @push.sendmsg sent_message
-          LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
+          expect(rc).to eq(string.size)
         end
         
-        rc = @pull.recvmsg received_message, ZMQ::NonBlocking
-        LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
-        received_message.copy_out_string.should == string
+        rc = @pull.recvmsg received_message, ZMQ::DONTWAIT
+        expect(rc).to eq(string.size)
+        expect(received_message.copy_out_string).to eq(string)
       end
 
 
@@ -71,20 +71,21 @@ module ZMQ
         sockets << @pull
 
         sockets.each do |socket|
-          threads << Thread.new do
+          thr = Thread.new do
             buffer = ''
             rc = socket.recv_string buffer
-            version2? ? (rc.should == 0) : (rc.should == buffer.size)
+            expect(rc).to eq(buffer.size)
             mutex.synchronize { received << buffer }
             socket.close
           end
+          threads << thr
         end
-
+        
         count.times { @push.send_string(string) }
 
         threads.each {|t| t.join}
 
-        received.find_all {|r| r == string}.length.should == count
+        expect(received.find_all {|r| r == string}.length).to eq(count)
       end
 
       it "should receive a single message for each message sent when using a single shared socket protected by a mutex" do
@@ -98,7 +99,7 @@ module ZMQ
             buffer = ''
             rc = 0
             mutex.synchronize { rc = @pull.recv_string buffer }
-            version2? ? (rc.should == 0) : (rc.should == buffer.size)
+            expect(rc).to eq(buffer.size)
             mutex.synchronize { received << buffer }
           end
         end
@@ -107,7 +108,7 @@ module ZMQ
 
         threads.each {|t| t.join}
 
-        received.find_all {|r| r == string}.length.should == count
+        expect(received.find_all {|r| r == string}.length).to eq(count)
       end
 
     end # @context ping-pong

data/spec/reqrep_spec.rb

@@ -40,25 +40,25 @@ module ZMQ
 
       it "should receive an exact string copy of the string message sent" do
         rc, received_message = send_ping(string)
-        received_message.should == string
+        expect(received_message).to eq(string)
       end
       
       it "should generate a EFSM error when sending via the REQ socket twice in a row without an intervening receive operation" do
         send_ping(string)
         rc = @ping.send_string(string)
-        rc.should == -1
-        Util.errno.should == ZMQ::EFSM
+        expect(rc).to eq(-1)
+        expect(Util.errno).to eq(ZMQ::EFSM)
       end
 
       it "should receive an exact copy of the sent message using Message objects directly" do
         received_message = Message.new
 
         rc = @ping.sendmsg(Message.new(string))
-        LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
+        expect(rc).to eq(string.size)
         rc = @pong.recvmsg received_message
-        LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
+        expect(rc).to eq(string.size)
 
-        received_message.copy_out_string.should == string
+        expect(received_message.copy_out_string).to eq(string)
       end
 
       it "should receive an exact copy of the sent message using Message objects directly in non-blocking mode" do
@@ -66,14 +66,14 @@ module ZMQ
         received_message = Message.new
 
         poll_it_for_read(@pong) do
-          rc = @ping.sendmsg(Message.new(string), ZMQ::NonBlocking)
-          LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
+          rc = @ping.sendmsg(Message.new(string), ZMQ::DONTWAIT)
+          expect(rc).to eq(string.size)
         end
         
-        rc = @pong.recvmsg received_message, ZMQ::NonBlocking
-        LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
+        rc = @pong.recvmsg received_message, ZMQ::DONTWAIT
+        expect(rc).to eq(string.size)
 
-        received_message.copy_out_string.should == string
+        expect(received_message.copy_out_string).to eq(string)
       end
 
     end # context ping-pong