ffi-rzmq 2.0.0 → 2.0.7

data/spec/message_spec.rb

@@ -9,12 +9,12 @@ module ZMQ
     context "when initializing with an argument" do
 
       it "calls zmq_msg_init_data()" do
-        LibZMQ.should_receive(:zmq_msg_init_data)
+        expect(LibZMQ).to receive(:zmq_msg_init_data)
         message = Message.new "text"
       end
 
       it "should *not* define a finalizer on this object" do
-        ObjectSpace.should_not_receive(:define_finalizer)
+        expect(ObjectSpace).not_to receive(:define_finalizer)
         Message.new "text"
       end
     end # context initializing with arg
@@ -22,12 +22,12 @@ module ZMQ
     context "when initializing *without* an argument" do
 
       it "calls zmq_msg_init()" do
-        LibZMQ.should_receive(:zmq_msg_init).and_return(0)
+        expect(LibZMQ).to receive(:zmq_msg_init).and_return(0)
         message = Message.new
       end
 
       it "should *not* define a finalizer on this object" do
-        ObjectSpace.should_not_receive(:define_finalizer)
+        expect(ObjectSpace).not_to receive(:define_finalizer)
         Message.new "text"
       end
     end # context initializing with arg
@@ -37,14 +37,14 @@ module ZMQ
       it "calls zmq_msg_init_data()" do
         message = Message.new "text"
 
-        LibZMQ.should_receive(:zmq_msg_init_data)
+        expect(LibZMQ).to receive(:zmq_msg_init_data)
         message.copy_in_string("new text")
       end
 
       it "correctly finds the length of binary data by ignoring encoding" do
         message = Message.new
         message.copy_in_string("\x83\x6e\x04\x00\x00\x44\xd1\x81")
-        message.size.should == 8
+        expect(message.size).to eq(8)
       end
     end
 
@@ -54,7 +54,7 @@ module ZMQ
         message = Message.new "text"
         copy = Message.new
 
-        LibZMQ.should_receive(:zmq_msg_copy)
+        expect(LibZMQ).to receive(:zmq_msg_copy)
         copy.copy(message)
       end
     end # context copy
@@ -65,7 +65,7 @@ module ZMQ
         message = Message.new "text"
         copy = Message.new
 
-        LibZMQ.should_receive(:zmq_msg_move)
+        expect(LibZMQ).to receive(:zmq_msg_move)
         copy.move(message)
       end
     end # context move
@@ -75,7 +75,7 @@ module ZMQ
       it "calls zmq_msg_size()" do
         message = Message.new "text"
 
-        LibZMQ.should_receive(:zmq_msg_size)
+        expect(LibZMQ).to receive(:zmq_msg_size)
         message.size
       end
     end # context size
@@ -85,7 +85,7 @@ module ZMQ
       it "calls zmq_msg_data()" do
         message = Message.new "text"
 
-        LibZMQ.should_receive(:zmq_msg_data)
+        expect(LibZMQ).to receive(:zmq_msg_data)
         message.data
       end
     end # context data
@@ -95,7 +95,7 @@ module ZMQ
       it "calls zmq_msg_close() the first time" do
         message = Message.new "text"
 
-        LibZMQ.should_receive(:zmq_msg_close)
+        expect(LibZMQ).to receive(:zmq_msg_close)
         message.close
       end
 
@@ -103,7 +103,7 @@ module ZMQ
         message = Message.new "text"
         message.close
 
-        LibZMQ.should_not_receive(:zmq_msg_close)
+        expect(LibZMQ).not_to receive(:zmq_msg_close)
         message.close
       end
     end # context close
@@ -116,7 +116,7 @@ module ZMQ
     context "when initializing with an argument" do
 
       it "should define a finalizer on this object" do
-        ObjectSpace.should_receive(:define_finalizer)
+        expect(ObjectSpace).to receive(:define_finalizer)
         ManagedMessage.new "text"
       end
     end # context initializing

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

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))
-        rc.should == string.size
+        expect(rc).to eq(string.size)
         rc = @pong.recvmsg received_message
-        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
@@ -67,13 +67,13 @@ module ZMQ
 
         poll_it_for_read(@pong) do
           rc = @ping.sendmsg(Message.new(string), ZMQ::DONTWAIT)
-          rc.should == string.size
+          expect(rc).to eq(string.size)
         end
         
         rc = @pong.recvmsg received_message, ZMQ::DONTWAIT
-        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
 
     end # context ping-pong