ffi-rzmq 1.0.3 → 2.0.4

data/spec/nonblocking_recv_spec.rb

@@ -12,20 +12,20 @@ module ZMQ
 
       it "returns -1 when there are no messages to read" do
         array = []
-        rc = @receiver.recvmsgs(array, ZMQ::NonBlocking)
-        Util.resultcode_ok?(rc).should be_false
+        rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
+        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::NonBlocking)
-        ZMQ::Util.errno.should == ZMQ::EAGAIN
+        rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
+        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::NonBlocking)
-        array.size.should be_zero
+        rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
+        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::NonBlocking)
-        Util.resultcode_ok?(rc).should be_true
-        array.size.should == 1
+        rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
+        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::NonBlocking)
-        Util.resultcode_ok?(rc).should be_true
-        array.size.should == 10
+        rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
+        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::NonBlocking)
-        Util.resultcode_ok?(rc).should be_true
-        array.size.should == 1 + 1 # extra 1 for envelope
+        rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
+        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::NonBlocking)
-        Util.resultcode_ok?(rc).should be_true
-        array.size.should == 10 + 1 # add 1 for the envelope
+        rc = @receiver.recvmsgs(array, ZMQ::DONTWAIT)
+        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
-          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

data/spec/socket_spec.rb

@@ -7,11 +7,8 @@ module ZMQ
   describe Socket do
     include APIHelper
 
-    socket_types = if LibZMQ.version2?
-      [ZMQ::REQ, ZMQ::REP, ZMQ::DEALER, ZMQ::ROUTER, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR]
-    elsif LibZMQ.version3?
+    socket_types =
       [ZMQ::REQ, ZMQ::REP, ZMQ::DEALER, ZMQ::ROUTER, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR, ZMQ::XPUB, ZMQ::XSUB]
-    end
 
     context "when initializing" do
       before(:all) { @ctx = Context.new }
@@ -19,21 +16,21 @@ module ZMQ
 
 
       it "should raise an error for a nil context" do
-        lambda { Socket.new(FFI::Pointer.new(0), ZMQ::REQ) }.should raise_exception(ZMQ::ContextError)
+        expect { Socket.new(FFI::Pointer.new(0), ZMQ::REQ) }.to raise_exception(ZMQ::ContextError)
       end
 
       it "works with a Context#pointer as the context_ptr" do
-        lambda do
+        expect do
           s = Socket.new(@ctx.pointer, ZMQ::REQ)
           s.close
-        end.should_not raise_exception
+        end.not_to raise_exception
       end
 
       it "works with a Context instance as the context_ptr" do
-        lambda do
+        expect do
           s = Socket.new(@ctx, ZMQ::SUB)
           s.close
-        end.should_not raise_exception
+        end.not_to raise_exception
       end
 
 
@@ -41,22 +38,22 @@ module ZMQ
 
         it "should not raise an error for a [#{ZMQ::SocketTypeNameMap[socket_type]}] socket type" do
           sock = nil
-          lambda { sock = Socket.new(@ctx.pointer, socket_type) }.should_not raise_error
+          expect { sock = Socket.new(@ctx.pointer, socket_type) }.not_to raise_error
           sock.close
         end
       end # each socket_type
 
       it "should set the :socket accessor to the raw socket allocated by libzmq" do
         socket = double('socket')
-        socket.stub(:null? => false)
-        LibZMQ.should_receive(:zmq_socket).and_return(socket)
+        allow(socket).to receive(:null?).and_return(false)
+        expect(LibZMQ).to receive(:zmq_socket).and_return(socket)
 
         sock = Socket.new(@ctx.pointer, ZMQ::REQ)
-        sock.socket.should == socket
+        expect(sock.socket).to eq(socket)
       end
 
       it "should define a finalizer on this object" do
-        ObjectSpace.should_receive(:define_finalizer).at_least(1)
+        expect(ObjectSpace).to receive(:define_finalizer).at_least(1)
         sock = Socket.new(@ctx.pointer, ZMQ::REQ)
         sock.close
       end
@@ -80,7 +77,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
         raw_socket = sock.socket
 
-        LibZMQ.should_receive(:close).with(raw_socket)
+        expect(LibZMQ).to receive(:close).with(raw_socket)
         sock.close
         sock.close
         LibZMQ.close raw_socket # *really close it otherwise the context will block indefinitely
@@ -97,7 +94,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = ('a' * 256)
-        sock.identity.should == ''
+        expect(sock.identity).to eq('')
         sock.close
       end
 
@@ -105,7 +102,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = ''
-        sock.identity.should == ''
+        expect(sock.identity).to eq('')
         sock.close
       end
 
@@ -113,7 +110,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = 'a'
-        sock.identity.should == 'a'
+        expect(sock.identity).to eq('a')
         sock.close
       end
 
@@ -121,7 +118,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = ('a' * 255)
-        sock.identity.should == ('a' * 255)
+        expect(sock.identity).to eq('a' * 255)
         sock.close
       end
 
@@ -129,7 +126,7 @@ module ZMQ
         sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = 7
-        sock.identity.should == '7'
+        expect(sock.identity).to eq('7')
         sock.close
       end
     end # context identity=
@@ -160,8 +157,8 @@ module ZMQ
 
               array = []
               rc = socket.getsockopt(ZMQ::IDENTITY, array)
-              rc.should == 0
-              array[0].should == identity
+              expect(rc).to eq(0)
+              expect(array[0]).to eq(identity)
             end
           end
 
@@ -169,138 +166,63 @@ module ZMQ
             identity = 'a' * 256
             array = []
             rc = socket.setsockopt(ZMQ::IDENTITY, identity)
-            rc.should == -1
+            expect(rc).to eq(-1)
           end
         end # context using option ZMQ::IDENTITY
 
+        context "using option ZMQ::IPV4ONLY" do
+          it "should enable use of IPV6 sockets when set to 0" do
+            value = 0
+            socket.setsockopt ZMQ::IPV4ONLY, value
+            array = []
+            rc = socket.getsockopt(ZMQ::IPV4ONLY, array)
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
+          end
 
-        if version2?
-
-          context "using option ZMQ::HWM" do
-            it "should set the high water mark given a positive value" do
-              hwm = 4
-              socket.setsockopt ZMQ::HWM, hwm
-              array = []
-              rc = socket.getsockopt(ZMQ::HWM, array)
-              rc.should == 0
-              array[0].should == hwm
-            end
-          end # context using option ZMQ::HWM
-
-
-          context "using option ZMQ::SWAP" do
-            it "should set the swap value given a positive value" do
-              swap = 10_000
-              socket.setsockopt ZMQ::SWAP, swap
-              array = []
-              rc = socket.getsockopt(ZMQ::SWAP, array)
-              rc.should == 0
-              array[0].should == swap
-            end
-
-            it "returns -1 given a negative value" do
-              swap = -10_000
-              rc = socket.setsockopt(ZMQ::SWAP, swap)
-              rc.should == -1
-            end
-          end # context using option ZMQ::SWP
-
-
-          context "using option ZMQ::MCAST_LOOP" do
-            it "should enable the multicast loopback given a 1 (true) value" do
-              socket.setsockopt ZMQ::MCAST_LOOP, 1
-              array = []
-              rc = socket.getsockopt(ZMQ::MCAST_LOOP, array)
-              rc.should == 0
-              array[0].should be_true
-            end
-
-            it "should disable the multicast loopback given a 0 (false) value" do
-              socket.setsockopt ZMQ::MCAST_LOOP, 0
-              array = []
-              rc = socket.getsockopt(ZMQ::MCAST_LOOP, array)
-              rc.should == 0
-              array[0].should be_false
-            end
-          end # context using option ZMQ::MCAST_LOOP
-
-
-          context "using option ZMQ::RECOVERY_IVL_MSEC" do
-            it "should set the time interval for saving messages measured in milliseconds given a positive value" do
-              value = 200
-              socket.setsockopt ZMQ::RECOVERY_IVL_MSEC, value
-              array = []
-              rc = socket.getsockopt(ZMQ::RECOVERY_IVL_MSEC, array)
-              rc.should == 0
-              array[0].should == value
-            end
-
-            it "should default to a value of -1" do
-              value = -1
-              array = []
-              rc = socket.getsockopt(ZMQ::RECOVERY_IVL_MSEC, array)
-              rc.should == 0
-              array[0].should == value
-            end
-          end # context using option ZMQ::RECOVERY_IVL_MSEC
-
-        else # version3 or higher
-
-          context "using option ZMQ::IPV4ONLY" do
-            it "should enable use of IPV6 sockets when set to 0" do
-              value = 0
-              socket.setsockopt ZMQ::IPV4ONLY, value
-              array = []
-              rc = socket.getsockopt(ZMQ::IPV4ONLY, array)
-              rc.should == 0
-              array[0].should == value
-            end
-
-            it "should default to a value of 1" do
-              value = 1
-              array = []
-              rc = socket.getsockopt(ZMQ::IPV4ONLY, array)
-              rc.should == 0
-              array[0].should == value
-            end
-
-            it "returns -1 given a negative value" do
-              value = -1
-              rc = socket.setsockopt ZMQ::IPV4ONLY, value
-              rc.should == -1
-            end
+          it "should default to a value of 1" do
+            value = 1
+            array = []
+            rc = socket.getsockopt(ZMQ::IPV4ONLY, array)
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
+          end
 
-            it "returns -1 given a value > 1" do
-              value = 2
-              rc = socket.setsockopt ZMQ::IPV4ONLY, value
-              rc.should == -1
-            end
-          end # context using option ZMQ::IPV4ONLY
+          it "returns -1 given a negative value" do
+            value = -1
+            rc = socket.setsockopt ZMQ::IPV4ONLY, value
+            expect(rc).to eq(-1)
+          end
 
-          context "using option ZMQ::LAST_ENDPOINT" do
-            it "should return last enpoint" do
-              random_port = bind_to_random_tcp_port(socket, max_tries = 500)
-              array = []
-              rc = socket.getsockopt(ZMQ::LAST_ENDPOINT, array)
-              ZMQ::Util.resultcode_ok?(rc).should == true
-              endpoint_regex = %r{\Atcp://(.*):(\d+)\0\z}
-              array[0].should =~ endpoint_regex
-              Integer(array[0][endpoint_regex, 2]).should == random_port
-            end
+          it "returns -1 given a value > 1" do
+            value = 2
+            rc = socket.setsockopt ZMQ::IPV4ONLY, value
+            expect(rc).to eq(-1)
           end
-        end # version2? if/else block
+        end # context using option ZMQ::IPV4ONLY
 
+        context "using option ZMQ::LAST_ENDPOINT" do
+          it "should return last enpoint" do
+            random_port = bind_to_random_tcp_port(socket, max_tries = 500)
+            array = []
+            rc = socket.getsockopt(ZMQ::LAST_ENDPOINT, array)
+            expect(ZMQ::Util.resultcode_ok?(rc)).to eq(true)
+            endpoint_regex = %r{\Atcp://(.*):(\d+)\0\z}
+            expect(array[0]).to match(endpoint_regex)
+            expect(Integer(array[0][endpoint_regex, 2])).to eq(random_port)
+          end
+        end
 
         context "using option ZMQ::SUBSCRIBE" do
           if ZMQ::SUB == socket_type
             it "returns 0 for a SUB socket" do
               rc = socket.setsockopt(ZMQ::SUBSCRIBE, "topic.string")
-              rc.should == 0
+              expect(rc).to eq(0)
             end
           else
             it "returns -1 for non-SUB sockets" do
               rc = socket.setsockopt(ZMQ::SUBSCRIBE, "topic.string")
-              rc.should == -1
+              expect(rc).to eq(-1)
             end
           end
         end # context using option ZMQ::SUBSCRIBE
@@ -311,13 +233,13 @@ module ZMQ
             it "returns 0 given a topic string that was previously subscribed" do
               socket.setsockopt ZMQ::SUBSCRIBE, "topic.string"
               rc = socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string")
-              rc.should == 0
+              expect(rc).to eq(0)
             end
 
           else
             it "returns -1 for non-SUB sockets" do
               rc = socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string")
-              rc.should == -1
+              expect(rc).to eq(-1)
             end
           end
         end # context using option ZMQ::UNSUBSCRIBE
@@ -329,8 +251,8 @@ module ZMQ
             socket.setsockopt ZMQ::AFFINITY, affinity
             array = []
             rc = socket.getsockopt(ZMQ::AFFINITY, array)
-            rc.should == 0
-            array[0].should == affinity
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(affinity)
           end
         end # context using option ZMQ::AFFINITY
 
@@ -341,14 +263,14 @@ module ZMQ
             socket.setsockopt ZMQ::RATE, rate
             array = []
             rc = socket.getsockopt(ZMQ::RATE, array)
-            rc.should == 0
-            array[0].should == rate
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(rate)
           end
 
           it "returns -1 given a negative value" do
             rate = -200
             rc = socket.setsockopt ZMQ::RATE, rate
-            rc.should == -1
+            expect(rc).to eq(-1)
           end
         end # context using option ZMQ::RATE
 
@@ -359,14 +281,14 @@ module ZMQ
             socket.setsockopt ZMQ::RECOVERY_IVL, rate
             array = []
             rc = socket.getsockopt(ZMQ::RECOVERY_IVL, array)
-            rc.should == 0
-            array[0].should == rate
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(rate)
           end
 
           it "returns -1 given a negative value" do
             rate = -200
             rc = socket.setsockopt ZMQ::RECOVERY_IVL, rate
-            rc.should == -1
+            expect(rc).to eq(-1)
           end
         end # context using option ZMQ::RECOVERY_IVL
 
@@ -377,8 +299,8 @@ module ZMQ
             socket.setsockopt ZMQ::SNDBUF, size
             array = []
             rc = socket.getsockopt(ZMQ::SNDBUF, array)
-            rc.should == 0
-            array[0].should == size
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(size)
           end
         end # context using option ZMQ::SNDBUF
 
@@ -389,8 +311,8 @@ module ZMQ
             socket.setsockopt ZMQ::RCVBUF, size
             array = []
             rc = socket.getsockopt(ZMQ::RCVBUF, array)
-            rc.should == 0
-            array[0].should == size
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(size)
           end
         end # context using option ZMQ::RCVBUF
 
@@ -401,8 +323,8 @@ module ZMQ
             socket.setsockopt ZMQ::LINGER, value
             array = []
             rc = socket.getsockopt(ZMQ::LINGER, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
 
           it "should set the socket message linger option to 0 for dropping packets" do
@@ -410,27 +332,17 @@ module ZMQ
             socket.setsockopt ZMQ::LINGER, value
             array = []
             rc = socket.getsockopt(ZMQ::LINGER, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
 
-          if (ZMQ::SUB == socket_type) && version3? || (defined?(ZMQ::XSUB) && ZMQ::XSUB == socket_type)
             it "should default to a value of 0" do
-              value = 0
-              array = []
-              rc = socket.getsockopt(ZMQ::LINGER, array)
-              rc.should == 0
-              array[0].should == value
-            end
-          else
-            it "should default to a value of -1" do
-              value = -1
+              value = [SUB, XSUB].include?(socket_type) ? 0 : -1
               array = []
               rc = socket.getsockopt(ZMQ::LINGER, array)
-              rc.should == 0
-              array[0].should == value
+              expect(rc).to eq(0)
+              expect(array[0]).to eq(value)
             end
-          end
         end # context using option ZMQ::LINGER
 
 
@@ -440,16 +352,16 @@ module ZMQ
             socket.setsockopt ZMQ::RECONNECT_IVL, value
             array = []
             rc = socket.getsockopt(ZMQ::RECONNECT_IVL, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
 
           it "should default to a value of 100" do
             value = 100
             array = []
             rc = socket.getsockopt(ZMQ::RECONNECT_IVL, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
         end # context using option ZMQ::RECONNECT_IVL
 
@@ -457,19 +369,20 @@ module ZMQ
         context "using option ZMQ::BACKLOG" do
           it "should set the maximum number of pending socket connections given a positive value" do
             value = 200
-            socket.setsockopt ZMQ::BACKLOG, value
+            rc = socket.setsockopt ZMQ::BACKLOG, value
+            expect(rc).to eq(0)
             array = []
             rc = socket.getsockopt(ZMQ::BACKLOG, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
 
           it "should default to a value of 100" do
             value = 100
             array = []
             rc = socket.getsockopt(ZMQ::BACKLOG, array)
-            rc.should == 0
-            array[0].should == value
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(value)
           end
         end # context using option ZMQ::BACKLOG
 
@@ -495,8 +408,8 @@ module ZMQ
             it "should return an FD as a positive integer" do
               array = []
               rc = socket.getsockopt(ZMQ::FD, array)
-              rc.should == 0
-              array[0].should > 0
+              expect(rc).to eq(0)
+              expect(array[0]).to be > 0
             end
 
             it "returns a valid FD that is accepted by the system poll() function" do
@@ -514,14 +427,14 @@ module ZMQ
 
                 class PollFD < FFI::Struct
                   layout :fd,    :int,
-                  :events, :short,
-                  :revents, :short
+                    :events, :short,
+                    :revents, :short
                 end
               end # module LibSocket
 
               array = []
               rc = socket.getsockopt(ZMQ::FD, array)
-              rc.should be_zero
+              expect(rc).to eq(0)
               fd = array[0]
 
               # setup the BSD poll_fd struct
@@ -531,7 +444,7 @@ module ZMQ
               pollfd[:revents] = 0
 
               rc = LibSocket.poll(pollfd, 1, 0)
-              rc.should be_zero
+              expect(rc).to eq(0)
             end
           end
 
@@ -541,8 +454,8 @@ module ZMQ
           it "should return a mask of events as a Fixnum" do
             array = []
             rc = socket.getsockopt(ZMQ::EVENTS, array)
-            rc.should == 0
-            array[0].should be_a(Fixnum)
+            expect(rc).to eq(0)
+            expect(array[0]).to be_a(Fixnum)
           end
         end
 
@@ -550,8 +463,8 @@ module ZMQ
           it "should return the socket type" do
             array = []
             rc = socket.getsockopt(ZMQ::TYPE, array)
-            rc.should == 0
-            array[0].should == socket_type
+            expect(rc).to eq(0)
+            expect(array[0]).to eq(socket_type)
           end
         end
       end # context #getsockopt
@@ -566,29 +479,29 @@ module ZMQ
         it "SUB socket that received a message always has POLLIN set" do
           events = []
           rc = @sub.getsockopt(ZMQ::EVENTS, events)
-          rc.should == 0
-          events[0].should == ZMQ::POLLIN
+          expect(rc).to eq(0)
+          expect(events[0]).to eq ZMQ::POLLIN
         end
 
         it "PUB socket always has POLLOUT set" do
           events = []
           rc = @pub.getsockopt(ZMQ::EVENTS, events)
-          rc.should == 0
-          events[0].should == ZMQ::POLLOUT
+          expect(rc).to eq(0)
+          expect(events[0]).to eq ZMQ::POLLOUT
         end
 
         it "PUB socket never has POLLIN set" do
           events = []
           rc = @pub.getsockopt(ZMQ::EVENTS, events)
-          rc.should == 0
-          events[0].should_not == ZMQ::POLLIN
+          expect(rc).to eq(0)
+          expect(events[0]).not_to eq ZMQ::POLLIN
         end
 
         it "SUB socket never has POLLOUT set" do
           events = []
           rc = @sub.getsockopt(ZMQ::EVENTS, events)
-          rc.should == 0
-          events[0].should_not == ZMQ::POLLOUT
+          expect(rc).to eq(0)
+          expect(events[0]).not_to eq ZMQ::POLLOUT
         end
       end # shared example for pubsub
 
@@ -601,7 +514,7 @@ module ZMQ
           endpoint = "inproc://socket_test"
           @sub = @ctx.socket ZMQ::SUB
           rc = @sub.setsockopt ZMQ::SUBSCRIBE, ''
-          rc.should == 0
+          expect(rc).to eq(0)
 
           @pub = @ctx.socket ZMQ::PUB
           @sub.bind(endpoint)