ffi-rzmq 2.0.1 → 2.0.4

data/spec/multipart_spec.rb

@@ -29,7 +29,7 @@ module ZMQ
           sleep 1
           strings = []
           rc = @receiver.recv_strings(strings)
-          strings.should == data
+          expect(strings).to eq(data)
         end
       end
 
@@ -56,12 +56,12 @@ module ZMQ
           @req.send_strings(req_data)
           strings = []
           rc = @rep.recv_strings(strings)
-          strings.should == req_data
+          expect(strings).to eq(req_data)
 
           @rep.send_strings(rep_data)
           strings = []
           rc = @req.recv_strings(strings)
-          strings.should == rep_data
+          expect(strings).to eq(rep_data)
         end
 
         it "should be delivered between REQ and REP returning an array of messages" do
@@ -71,14 +71,14 @@ module ZMQ
           messages = []
           rc = @rep.recvmsgs(messages)
           messages.each_with_index do |message, index|
-            message.copy_out_string.should == req_data[index]
+            expect(message.copy_out_string).to eq(req_data[index])
           end
 
           @rep.send_strings(rep_data)
           messages = []
           rc = @req.recvmsgs(messages)
           messages.each_with_index do |message, index|
-            message.copy_out_string.should == rep_data[index]
+            expect(message.copy_out_string).to eq(rep_data[index])
           end
         end
       end
@@ -106,12 +106,12 @@ module ZMQ
             @req.send_string(req_data)
             strings = []
             rc = @rep.recv_strings(strings)
-            strings.should == [ @req.identity, "", "hello" ]
+            expect(strings).to eq([ @req.identity, "", "hello" ])
 
             @rep.send_strings(rep_data)
             string = ''
             rc = @req.recv_string(string)
-            string.should == rep_data.last
+            expect(string).to eq(rep_data.last)
           end
 
           it "should be delivered between REQ and REP returning an array of messages with an empty string as the envelope delimiter" do
@@ -120,14 +120,14 @@ module ZMQ
             @req.send_string(req_data)
             msgs = []
             rc = @rep.recvmsgs(msgs)
-            msgs[0].copy_out_string.should == @req.identity
-            msgs[1].copy_out_string.should == ""
-            msgs[2].copy_out_string.should == "hello"
+            expect(msgs[0].copy_out_string).to eq(@req.identity)
+            expect(msgs[1].copy_out_string).to eq("")
+            expect(msgs[2].copy_out_string).to eq("hello")
 
             @rep.send_strings(rep_data)
             msgs = []
             rc = @req.recvmsgs(msgs)
-            msgs[0].copy_out_string.should == rep_data.last
+            expect(msgs[0].copy_out_string).to eq(rep_data.last)
           end
         end
 

data/spec/nonblocking_recv_spec.rb

@@ -13,19 +13,19 @@ module ZMQ
       it "returns -1 when there are no messages to read" do
         array = []
         rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
-        Util.resultcode_ok?(rc).should be_false
+        expect(Util.resultcode_ok?(rc)).to eq(false)
       end
 
       it "gets EAGAIN when there are no messages to read" do
         array = []
         rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
-        ZMQ::Util.errno.should == ZMQ::EAGAIN
+        expect(ZMQ::Util.errno).to eq(ZMQ::EAGAIN)
       end
 
       it "returns the given array unmodified when there are no messages to read" do
         array = []
         rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
-        array.size.should be_zero
+        expect(array.size).to eq(0)
       end
 
     end
@@ -35,26 +35,26 @@ module ZMQ
       it "read the single message and returns a successful result code" do
         poll_it_for_read(@receiver) do
           rc = @sender.send_string('test')
-          Util.resultcode_ok?(rc).should be_true
+          expect(Util.resultcode_ok?(rc)).to eq(true)
         end
         
         array = []
         rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
-        Util.resultcode_ok?(rc).should be_true
-        array.size.should == 1
+        expect(Util.resultcode_ok?(rc)).to eq(true)
+        expect(array.size).to eq(1)
       end
 
       it "read all message parts transmitted and returns a successful result code" do
         poll_it_for_read(@receiver) do
           strings = Array.new(10, 'test')
           rc = @sender.send_strings(strings)
-          Util.resultcode_ok?(rc).should be_true
+          expect(Util.resultcode_ok?(rc)).to eq(true)
         end
 
         array = []
         rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
-        Util.resultcode_ok?(rc).should be_true
-        array.size.should == 10
+        expect(Util.resultcode_ok?(rc)).to eq(true)
+        expect(array.size).to eq(10)
       end
 
     end
@@ -64,26 +64,26 @@ module ZMQ
       it "read the single message and returns a successful result code" do
         poll_it_for_read(@receiver) do
           rc = @sender.send_string('test')
-          Util.resultcode_ok?(rc).should be_true
+          expect(Util.resultcode_ok?(rc)).to eq(true)
         end
 
         array = []
         rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
-        Util.resultcode_ok?(rc).should be_true
-        array.size.should == 1 + 1 # extra 1 for envelope
+        expect(Util.resultcode_ok?(rc)).to eq(true)
+        expect(array.size).to eq(1 + 1) # extra 1 for envelope
       end
 
       it "read all message parts transmitted and returns a successful result code" do
         poll_it_for_read(@receiver) do
           strings = Array.new(10, 'test')
           rc = @sender.send_strings(strings)
-          Util.resultcode_ok?(rc).should be_true
+          expect(Util.resultcode_ok?(rc)).to eq(true)
         end
 
         array = []
         rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
-        Util.resultcode_ok?(rc).should be_true
-        array.size.should == 10 + 1 # add 1 for the envelope
+        expect(Util.resultcode_ok?(rc)).to eq(true)
+        expect(array.size).to eq(10 + 1) # add 1 for the envelope
       end
 
     end

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
-          rc.should == string.size
+          expect(rc).to eq(string.size)
         end
         
         rc = @pull.recvmsg received_message, ZMQ::DONTWAIT
-        rc.should == string.size
-        received_message.copy_out_string.should == string
+        expect(rc).to eq(string.size)
+        expect(received_message.copy_out_string).to eq(string)
       end
 
 
@@ -74,7 +74,7 @@ module ZMQ
           thr = Thread.new do
             buffer = ''
             rc = socket.recv_string buffer
-            rc.should == buffer.size
+            expect(rc).to eq(buffer.size)
             mutex.synchronize { received << buffer }
             socket.close
           end
@@ -85,7 +85,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
 
       it "should receive a single message for each message sent when using a single shared socket protected by a mutex" do
@@ -99,7 +99,7 @@ module ZMQ
             buffer = ''
             rc = 0
             mutex.synchronize { rc = @pull.recv_string buffer }
-            rc.should == buffer.size
+            expect(rc).to eq(buffer.size)
             mutex.synchronize { received << buffer }
           end
         end
@@ -108,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