ffi-rzmq 0.8.2 → 0.9.0

data/spec/pushpull_spec.rb

@@ -13,55 +13,116 @@ module ZMQ
         @context = ZMQ::Context.new
         @push = @context.socket ZMQ::PUSH
         @pull = @context.socket ZMQ::PULL
-        @link = "tcp://127.0.0.1:#{random_port}"
-        @pull.connect @link
+        @push.setsockopt ZMQ::LINGER, 0
+        @pull.setsockopt ZMQ::LINGER, 0
+        port = connect_to_random_tcp_port(@pull)
+        @link = "tcp://127.0.0.1:#{port}"
         @push.bind    @link
       end
-      
+
       after(:each) do
         @push.close
         @pull.close
+        @context.terminate
       end
-      
+
       it "should receive an exact copy of the sent message using Message objects directly on one pull socket" do
         @push.send_string string
-        received = @pull.recv_string
+        received = ''
+        rc = @pull.recv_string received
         received.should == 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
-        sent_message = Message.new string
-        received_message = Message.new
-
-        @push.send sent_message
-        sleep 0.1 # give it time for delivery
-        @pull.recv received_message, ZMQ::NOBLOCK
-        received_message.copy_out_string.should == string
+
+      if version2?
+        it "should receive an exact string copy of the message sent when receiving in non-blocking mode and using Message objects directly" do
+          sent_message = Message.new string
+          received_message = Message.new
+
+          rc = @push.send sent_message
+          rc.should == 0
+          sleep 0.1 # give it time for delivery
+          rc = @pull.recv received_message, ZMQ::NOBLOCK
+          received_message.copy_out_string.should == string
+        end
+
+      else
+
+        it "should receive an exact string copy of the message sent when receiving in non-blocking mode and using Message objects directly" do
+          sent_message = Message.new string
+          received_message = Message.new
+
+          rc = @push.sendmsg sent_message
+          rc.should == string.size
+          sleep 0.1 # give it time for delivery
+          rc = @pull.recvmsg received_message, ZMQ::DONTWAIT
+          rc.should == string.size
+          received_message.copy_out_string.should == string
+        end
       end
 
-      it "should receive a single message for each message sent on each socket listening, when an equal number pulls to messages" do
-        received = []
-        threads  = []
-        count    = 4
-        @pull.close # close this one since we aren't going to use it below and we don't want it to receive a message
-         
-        count.times do
-          threads << Thread.new do
-            pull = @context.socket ZMQ::PULL
-            rc = pull.connect @link
-            received << pull.recv_string
-            pull.close
+
+      if version2?
+
+        it "should receive a single message for each message sent on each socket listening, when an equal number pulls to messages" do
+          received = []
+          threads  = []
+          count    = 4
+          @pull.close # close this one since we aren't going to use it below and we don't want it to receive a message
+
+          count.times do |i|
+            threads << Thread.new do
+              pull = @context.socket ZMQ::PULL
+              rc = pull.setsockopt ZMQ::LINGER, 0
+              rc = pull.connect @link
+              rc.should == 0
+              buffer = ''
+              rc = pull.recv_string buffer
+              rc.should == 0
+              received << buffer
+              pull.close
+            end
+            sleep 0.01 # give each thread time to spin up
           end
-          sleep 0.001 # give each thread time to spin up
+
+          count.times { @push.send_string(string) }
+
+          threads.each {|t| t.join}
+
+          received.find_all {|r| r == string}.length.should == count
         end
-        
-        count.times { @push.send_string(string) }
 
-        threads.each {|t| t.join}
-        
-        received.find_all {|r| r == string}.length.should == count
-      end
-      
+      else # version3 or 4
+
+        it "should receive a single message for each message sent on each socket listening, when an equal number pulls to messages" do
+          received = []
+          threads  = []
+          count    = 4
+          @pull.close # close this one since we aren't going to use it below and we don't want it to receive a message
+
+          count.times do |i|
+            threads << Thread.new do
+              pull = @context.socket ZMQ::PULL
+              rc = pull.setsockopt ZMQ::LINGER, 0
+              rc = pull.connect @link
+              rc.should == 0
+              buffer = ''
+              rc = pull.recv_string buffer
+              rc.should == string.size
+              received << buffer
+              pull.close
+            end
+            sleep 0.01 # give each thread time to spin up
+          end
+
+          count.times { @push.send_string(string) }
+
+          threads.each {|t| t.join}
+
+          received.find_all {|r| r == string}.length.should == count
+        end
+
+      end # if version...
+
     end # @context ping-pong
   end # describe
 end # module ZMQ

data/spec/reqrep_spec.rb

@@ -15,11 +15,10 @@ module ZMQ
         context = ZMQ::Context.new 1
         @ping = context.socket ZMQ::REQ
         @pong = context.socket ZMQ::REP
-        link = "tcp://127.0.0.1:#{random_port}"
-        @pong.bind link
-        @ping.connect link
+        port = bind_to_random_tcp_port(@pong)
+        @ping.connect "tcp://127.0.0.1:#{port}"
       end
-      
+
       after(:each) do
         @ping.close
         @pong.close
@@ -27,31 +26,67 @@ module ZMQ
 
       it "should receive an exact string copy of the string message sent" do
         @ping.send_string string
-        received_message = @pong.recv_string
+        received_message = ''
+        rc = @pong.recv_string received_message
 
         received_message.should == string
       end
 
-      it "should receive an exact copy of the sent message using Message objects directly" do
-        sent_message = Message.new string
-        received_message = Message.new
+      if version2?
+        it "should receive an exact copy of the sent message using Message objects directly" do
+          sent_message = Message.new string
+          received_message = Message.new
 
-        @ping.send sent_message
-        @pong.recv received_message
+          rc = @ping.send sent_message
+          rc.should == 0
+          rc = @pong.recv received_message
+          rc.should == 0
 
-        received_message.copy_out_string.should == string
-      end
+          received_message.copy_out_string.should == string
+        end
 
-      it "should receive an exact copy of the sent message using Message objects directly in non-blocking mode" do
-        sent_message = Message.new string
-        received_message = Message.new
+        it "should receive an exact copy of the sent message using Message objects directly in non-blocking mode" do
+          sent_message = Message.new string
+          received_message = Message.new
 
-        @ping.send sent_message, ZMQ::NOBLOCK
-        sleep 0.001 # give it time for delivery
-        @pong.recv received_message, ZMQ::NOBLOCK
+          rc = @ping.send sent_message, ZMQ::NOBLOCK
+          rc.should == 0
+          sleep 0.1 # give it time for delivery
+          rc = @pong.recv received_message, ZMQ::NOBLOCK
+          rc.should == 0
+
+          received_message.copy_out_string.should == string
+        end
+
+      else # version3 or 4
+
+        it "should receive an exact copy of the sent message using Message objects directly" do
+          sent_message = Message.new string
+          received_message = Message.new
+
+          rc = @ping.sendmsg sent_message
+          rc.should == string.size
+          rc = @pong.recvmsg received_message
+          rc.should == string.size
+
+          received_message.copy_out_string.should == string
+        end
+
+        it "should receive an exact copy of the sent message using Message objects directly in non-blocking mode" do
+          sent_message = Message.new string
+          received_message = Message.new
+
+          rc = @ping.sendmsg sent_message, ZMQ::DONTWAIT
+          rc.should == string.size
+          sleep 0.001 # give it time for delivery
+          rc = @pong.recvmsg received_message, ZMQ::DONTWAIT
+          rc.should == string.size
+
+          received_message.copy_out_string.should == string
+        end
+
+      end # if version...
 
-        received_message.copy_out_string.should == string
-      end
     end # context ping-pong
 
 

data/spec/socket_spec.rb

@@ -6,6 +6,14 @@ module ZMQ
 
   describe Socket do
 
+    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?
+      [ZMQ::REQ, ZMQ::REP, ZMQ::DEALER, ZMQ::ROUTER, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR, ZMQ::XPUB, ZMQ::XSUB]
+    elsif LibZMQ.version4?
+      [ZMQ::REQ, ZMQ::REP, 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 }
       after(:all) { @ctx.terminate }
@@ -15,9 +23,24 @@ module ZMQ
         lambda { Socket.new(FFI::Pointer.new(0), ZMQ::REQ) }.should raise_exception(ZMQ::ContextError)
       end
 
-      [ZMQ::REQ, ZMQ::REP, ZMQ::DEALER, ZMQ::ROUTER, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR].each do |socket_type|
+      it "works with a Context#pointer as the context_ptr" do
+        lambda do
+          s = Socket.new(@ctx.pointer, ZMQ::REQ)
+          s.close
+        end.should_not raise_exception(ZMQ::ContextError)
+      end
+
+      it "works with a Context instance as the context_ptr" do
+        lambda do
+          s = Socket.new(@ctx, ZMQ::SUB)
+          s.close
+        end.should_not raise_exception(ZMQ::ContextError)
+      end
+
 
-        it "should not raise an error for a #{ZMQ::SocketTypeNameMap[socket_type]} socket type" do
+      socket_types.each do |socket_type|
+
+        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
           sock.close
@@ -39,8 +62,8 @@ module ZMQ
         sock.close
       end
     end # context initializing
-    
-    
+
+
     context "calling close" do
       before(:all) { @ctx = Context.new }
       after(:all) { @ctx.terminate }
@@ -57,49 +80,57 @@ module ZMQ
     end # context calling close
 
 
-    context "identity=" do
-      before(:all) { @ctx = Context.new }
-      after(:all) { @ctx.terminate }
+    if version2? || version3?
 
-      it "should raise an exception for identities in excess of 255 bytes" do
-        sock = Socket.new @ctx.pointer, ZMQ::REQ
+      context "identity=" do
+        before(:all) { @ctx = Context.new }
+        after(:all) { @ctx.terminate }
 
-        lambda { sock.identity = ('a' * 256) }.should raise_exception(ZMQ::SocketError)
-        sock.close
-      end
+        it "fails to set identity for identities in excess of 255 bytes" do
+          sock = Socket.new @ctx.pointer, ZMQ::REQ
 
-      it "should raise an exception for identities of length 0" do
-        sock = Socket.new @ctx.pointer, ZMQ::REQ
+          sock.identity = ('a' * 256)
+          sock.identity.should == ''
+          sock.close
+        end
 
-        lambda { sock.identity = '' }.should raise_exception(ZMQ::SocketError)
-        sock.close
-      end
+        it "fails to set identity for identities of length 0" do
+          sock = Socket.new @ctx.pointer, ZMQ::REQ
 
-      it "should NOT raise an exception for identities of 1 byte" do
-        sock = Socket.new @ctx.pointer, ZMQ::REQ
+          sock.identity = ''
+          sock.identity.should == ''
+          sock.close
+        end
 
-        lambda { sock.identity = 'a' }.should_not raise_exception(ZMQ::SocketError)
-        sock.close
-      end
+        it "sets the identity for identities of 1 byte" do
+          sock = Socket.new @ctx.pointer, ZMQ::REQ
 
-      it "should NOT raise an exception for identities of 255 bytes" do
-        sock = Socket.new @ctx.pointer, ZMQ::REQ
+          sock.identity = 'a'
+          sock.identity.should == 'a'
+          sock.close
+        end
 
-        lambda { sock.identity = ('a' * 255) }.should_not raise_exception(ZMQ::SocketError)
-        sock.close
-      end
+        it "set the identity identities of 255 bytes" do
+          sock = Socket.new @ctx.pointer, ZMQ::REQ
 
-      it "should convert numeric identities to strings" do
-        sock = Socket.new @ctx.pointer, ZMQ::REQ
+          sock.identity = ('a' * 255)
+          sock.identity.should == ('a' * 255)
+          sock.close
+        end
 
-        sock.identity = 7
-        sock.identity.should == '7'
-        sock.close
-      end
-    end # context identity=
+        it "should convert numeric identities to strings" do
+          sock = Socket.new @ctx.pointer, ZMQ::REQ
+
+          sock.identity = 7
+          sock.identity.should == '7'
+          sock.close
+        end
+      end # context identity=
 
+    end # version2? || version3?
 
-    [ZMQ::REQ, ZMQ::REP, ZMQ::DEALER, ZMQ::ROUTER, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR].each do |socket_type|
+
+    socket_types.each do |socket_type|
 
       context "#setsockopt for a #{ZMQ::SocketTypeNameMap[socket_type]} socket" do
         before(:all) { @ctx = Context.new }
@@ -114,14 +145,116 @@ module ZMQ
         end
 
 
+        if version2? || version3?
+
+          context "using option ZMQ::IDENTITY" do
+            it "should set the identity given any string under 255 characters" do
+              length = 4
+              (1..255).each do |length|
+                identity = 'a' * length
+                socket.setsockopt ZMQ::IDENTITY, identity
+
+                array = []
+                rc = socket.getsockopt(ZMQ::IDENTITY, array)
+                rc.should == 0
+                array[0].should == identity
+              end
+            end
+
+            it "returns -1 given a string 256 characters or longer" do
+              identity = 'a' * 256
+              array = []
+              rc = socket.setsockopt(ZMQ::IDENTITY, identity)
+              rc.should == -1
+            end
+          end # context using option ZMQ::IDENTITY
+
+        end # version2? || version3?
+
+
+        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
+
+        end # version2?
+
+
         context "using option ZMQ::SUBSCRIBE" do
           if ZMQ::SUB == socket_type
-            it "should *not* raise a ZMQ::SocketError" do
-              lambda { socket.setsockopt(ZMQ::SUBSCRIBE, "topic.string") }.should_not raise_error(SocketError)
+            it "returns 0 for a SUB socket" do
+              rc = socket.setsockopt(ZMQ::SUBSCRIBE, "topic.string")
+              rc.should == 0
             end
           else
-            it "should raise a ZMQ::SocketError" do
-              lambda { socket.setsockopt(ZMQ::SUBSCRIBE, "topic.string") }.should raise_error(SocketError)
+            it "returns -1 for non-SUB sockets" do
+              rc = socket.setsockopt(ZMQ::SUBSCRIBE, "topic.string")
+              rc.should == -1
             end
           end
         end # context using option ZMQ::SUBSCRIBE
@@ -129,94 +262,47 @@ module ZMQ
 
         context "using option ZMQ::UNSUBSCRIBE" do
           if ZMQ::SUB == socket_type
-            it "should *not* raise a ZMQ::SocketError given a topic string that was previously subscribed" do
+            it "returns 0 given a topic string that was previously subscribed" do
               socket.setsockopt ZMQ::SUBSCRIBE, "topic.string"
-              lambda { socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string") }.should_not raise_error(SocketError)
+              rc = socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string")
+              rc.should == 0
             end
 
-#            it "should raise a ZMQ::SocketError given a topic string that was never subscribed" do
-#              socket.setsockopt ZMQ::SUBSCRIBE, "topic.string"
-#              lambda { socket.setsockopt(ZMQ::UNSUBSCRIBE, "unknown") }.should raise_error(SocketError)
-#            end
           else
-            it "should raise a ZMQ::SocketError" do
-              lambda { socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string") }.should raise_error(SocketError)
+            it "returns -1 for non-SUB sockets" do
+              rc = socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string")
+              rc.should == -1
             end
           end
         end # context using option ZMQ::UNSUBSCRIBE
 
 
-        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
-            socket.getsockopt(ZMQ::HWM).should == hwm
-          end
-
-          it "should convert a negative value to a positive value" do
-            hwm = -4
-            socket.setsockopt ZMQ::HWM, hwm
-            socket.getsockopt(ZMQ::HWM).should == hwm.abs
-          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
-            socket.getsockopt(ZMQ::SWAP).should == swap
-          end
-
-          it "should raise a SocketError given a negative value" do
-            swap = -10_000
-            lambda { socket.setsockopt(ZMQ::SWAP, swap) }.should raise_error(SocketError)
-          end
-        end # context using option ZMQ::SWP
-
-
         context "using option ZMQ::AFFINITY" do
           it "should set the affinity value given a positive value" do
             affinity = 3
             socket.setsockopt ZMQ::AFFINITY, affinity
-            socket.getsockopt(ZMQ::AFFINITY).should == affinity
-          end
-
-          it "should set the affinity value as a positive value given a negative value" do
-            affinity = -3
-            socket.setsockopt ZMQ::AFFINITY, affinity
-            socket.getsockopt(ZMQ::AFFINITY).should == affinity.abs
+            array = []
+            rc = socket.getsockopt(ZMQ::AFFINITY, array)
+            rc.should == 0
+            array[0].should == affinity
           end
         end # context using option ZMQ::AFFINITY
 
 
-        context "using option ZMQ::IDENTITY" do
-          it "should set the identity given any string under 255 characters" do
-            length = 4
-            (1..255).each do |length|
-              identity = 'a' * length
-              socket.setsockopt ZMQ::IDENTITY, identity
-              socket.getsockopt(ZMQ::IDENTITY).should == identity
-            end
-          end
-
-          it "should raise a SocketError given a string 256 characters or longer" do
-            identity = 'a' * 256
-            lambda { socket.setsockopt(ZMQ::IDENTITY, identity) }.should raise_error(SocketError)
-          end
-        end # context using option ZMQ::IDENTITY
-
-
         context "using option ZMQ::RATE" do
           it "should set the multicast send rate given a positive value" do
             rate = 200
             socket.setsockopt ZMQ::RATE, rate
-            socket.getsockopt(ZMQ::RATE).should == rate
+            array = []
+            rc = socket.getsockopt(ZMQ::RATE, array)
+            rc.should == 0
+            array[0].should == rate
           end
 
-          it "should raise a SocketError given a negative value" do
+          it "returns -1 given a negative value" do
             rate = -200
-            lambda { socket.setsockopt ZMQ::RATE, rate }.should raise_error(SocketError)
+            rc = socket.setsockopt ZMQ::RATE, rate
+            rc.should == -1
           end
         end # context using option ZMQ::RATE
 
@@ -225,40 +311,28 @@ module ZMQ
           it "should set the multicast recovery buffer measured in seconds given a positive value" do
             rate = 200
             socket.setsockopt ZMQ::RECOVERY_IVL, rate
-            socket.getsockopt(ZMQ::RECOVERY_IVL).should == rate
+            array = []
+            rc = socket.getsockopt(ZMQ::RECOVERY_IVL, array)
+            rc.should == 0
+            array[0].should == rate
           end
 
-          it "should raise a SocketError given a negative value" do
+          it "returns -1 given a negative value" do
             rate = -200
-            lambda { socket.setsockopt ZMQ::RECOVERY_IVL, rate }.should raise_error(SocketError)
+            rc = socket.setsockopt ZMQ::RECOVERY_IVL, rate
+            rc.should == -1
           end
         end # context using option ZMQ::RECOVERY_IVL
 
 
-        context "using option ZMQ::MCAST_LOOP" do
-          it "should enable the multicast loopback given a true value" do
-            socket.setsockopt ZMQ::MCAST_LOOP, true
-            socket.getsockopt(ZMQ::MCAST_LOOP).should be_true
-          end
-
-          it "should disable the multicast loopback given a false value" do
-            socket.setsockopt ZMQ::MCAST_LOOP, false
-            socket.getsockopt(ZMQ::MCAST_LOOP).should be_false
-          end
-        end # context using option ZMQ::MCAST_LOOP
-
-
         context "using option ZMQ::SNDBUF" do
           it "should set the OS send buffer given a positive value" do
             size = 100
             socket.setsockopt ZMQ::SNDBUF, size
-            socket.getsockopt(ZMQ::SNDBUF).should == size
-          end
-
-          it "should set the OS send buffer to a positive value given a false value" do
-            size = -100
-            socket.setsockopt ZMQ::SNDBUF, size
-            socket.getsockopt(ZMQ::SNDBUF).should == size.abs
+            array = []
+            rc = socket.getsockopt(ZMQ::SNDBUF, array)
+            rc.should == 0
+            array[0].should == size
           end
         end # context using option ZMQ::SNDBUF
 
@@ -267,13 +341,10 @@ module ZMQ
           it "should set the OS receive buffer given a positive value" do
             size = 100
             socket.setsockopt ZMQ::RCVBUF, size
-            socket.getsockopt(ZMQ::RCVBUF).should == size
-          end
-
-          it "should set the OS receive buffer to a positive value given a false value" do
-            size = -100
-            socket.setsockopt ZMQ::RCVBUF, size
-            socket.getsockopt(ZMQ::RCVBUF).should == size.abs
+            array = []
+            rc = socket.getsockopt(ZMQ::RCVBUF, array)
+            rc.should == 0
+            array[0].should == size
           end
         end # context using option ZMQ::RCVBUF
 
@@ -282,18 +353,27 @@ module ZMQ
           it "should set the socket message linger option measured in milliseconds given a positive value" do
             value = 200
             socket.setsockopt ZMQ::LINGER, value
-            socket.getsockopt(ZMQ::LINGER).should == value
+            array = []
+            rc = socket.getsockopt(ZMQ::LINGER, array)
+            rc.should == 0
+            array[0].should == value
           end
 
           it "should set the socket message linger option to 0 for dropping packets" do
             value = 0
             socket.setsockopt ZMQ::LINGER, value
-            socket.getsockopt(ZMQ::LINGER).should == value
+            array = []
+            rc = socket.getsockopt(ZMQ::LINGER, array)
+            rc.should == 0
+            array[0].should == value
           end
 
           it "should default to a value of -1" do
             value = -1
-            socket.getsockopt(ZMQ::LINGER).should == value
+            array = []
+            rc = socket.getsockopt(ZMQ::LINGER, array)
+            rc.should == 0
+            array[0].should == value
           end
         end # context using option ZMQ::LINGER
 
@@ -302,12 +382,18 @@ module ZMQ
           it "should set the time interval for reconnecting disconnected sockets measured in milliseconds given a positive value" do
             value = 200
             socket.setsockopt ZMQ::RECONNECT_IVL, value
-            socket.getsockopt(ZMQ::RECONNECT_IVL).should == value
+            array = []
+            rc = socket.getsockopt(ZMQ::RECONNECT_IVL, array)
+            rc.should == 0
+            array[0].should == value
           end
 
           it "should default to a value of 100" do
             value = 100
-            socket.getsockopt(ZMQ::RECONNECT_IVL).should == value
+            array = []
+            rc = socket.getsockopt(ZMQ::RECONNECT_IVL, array)
+            rc.should == 0
+            array[0].should == value
           end
         end # context using option ZMQ::RECONNECT_IVL
 
@@ -316,28 +402,20 @@ module ZMQ
           it "should set the maximum number of pending socket connections given a positive value" do
             value = 200
             socket.setsockopt ZMQ::BACKLOG, value
-            socket.getsockopt(ZMQ::BACKLOG).should == value
+            array = []
+            rc = socket.getsockopt(ZMQ::BACKLOG, array)
+            rc.should == 0
+            array[0].should == value
           end
 
           it "should default to a value of 100" do
             value = 100
-            socket.getsockopt(ZMQ::BACKLOG).should == value
+            array = []
+            rc = socket.getsockopt(ZMQ::BACKLOG, array)
+            rc.should == 0
+            array[0].should == value
           end
         end # context using option ZMQ::BACKLOG
-
-
-        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
-            socket.getsockopt(ZMQ::RECOVERY_IVL_MSEC).should == value
-          end
-
-          it "should default to a value of -1" do
-            value = -1
-            socket.getsockopt(ZMQ::RECOVERY_IVL_MSEC).should == value
-          end
-        end # context using option ZMQ::RECOVERY_IVL_MSEC
       end # context #setsockopt
 
 
@@ -353,48 +431,70 @@ module ZMQ
           socket.close
         end
 
-        context "using option ZMQ::FD" do
-          it "should return an FD as a positive integer" do
-            socket.getsockopt(ZMQ::FD).should be_a(Fixnum)
-          end
+        if RUBY_PLATFORM =~ /linux|darwin/
+          # this spec doesn't work on Windows; hints welcome
 
-          it "should return a valid FD" do
-            # Use FFI to wrap the C library function +getsockopt+ so that we can execute it
-            # on the 0mq file descriptor. If it returns 0, then it succeeded and the FD
-            # is valid!
-            module LibSocket
-              extend FFI::Library
-              # figures out the correct libc for each platform including Windows
-              library = ffi_lib(FFI::Library::LIBC).first
-              attach_function :getsockopt, [:int, :int, :int, :pointer, :pointer], :int
-            end # module LibC
-            
-            if RUBY_PLATFORM =~ /linux/ || (RUBY_PLATFORM == 'java' && `uname` =~ /linux/i)
-              so_rcvbuf =  8 
-              sol_socket = 1
-            else #OSX
-              so_rcvbuf =  0x1002
-              sol_socket = 0xffff
+          context "using option ZMQ::FD" do
+            it "should return an FD as a positive integer" do
+              array = []
+              rc = socket.getsockopt(ZMQ::FD, array)
+              rc.should == 0
+              array[0].should be_a(Fixnum)
             end
 
-            socklen_size = FFI::MemoryPointer.new :uint32
-            socklen_size.write_int 8
-            rcvbuf = FFI::MemoryPointer.new :int64
-            fd = socket.getsockopt(ZMQ::FD)
-            
-            LibSocket.getsockopt(fd, sol_socket, so_rcvbuf, rcvbuf, socklen_size).should be_zero
+            it "returns a valid FD that is accepted by the system poll() function" do
+              # Use FFI to wrap the C library function +poll+ so that we can execute it
+              # on the 0mq file descriptor. If it returns 0, then it succeeded and the FD
+              # is valid!
+              module LibSocket
+                extend FFI::Library
+                # figures out the correct libc for each platform including Windows
+                library = ffi_lib(FFI::Library::LIBC).first
+
+                find_type(:nfds_t) rescue typedef(:uint32, :nfds_t)
+
+                attach_function :poll, [:pointer, :nfds_t, :int], :int
+
+                class PollFD < FFI::Struct
+                  layout :fd,    :int,
+                  :events, :short,
+                  :revents, :short
+                end
+              end # module LibSocket
+
+              array = []
+              rc = socket.getsockopt(ZMQ::FD, array)
+              rc.should be_zero
+              fd = array[0]
+
+              # setup the BSD poll_fd struct
+              pollfd = LibSocket::PollFD.new
+              pollfd[:fd] = fd
+              pollfd[:events] = 0
+              pollfd[:revents] = 0
+
+              rc = LibSocket.poll(pollfd, 1, 0)
+              rc.should be_zero
+            end
           end
-        end
+
+        end # posix platform
 
         context "using option ZMQ::EVENTS" do
           it "should return a mask of events as a Fixnum" do
-            socket.getsockopt(ZMQ::EVENTS).should be_a(Fixnum)
+            array = []
+            rc = socket.getsockopt(ZMQ::EVENTS, array)
+            rc.should == 0
+            array[0].should be_a(Fixnum)
           end
         end
 
         context "using option ZMQ::TYPE" do
           it "should return the socket type" do
-            socket.getsockopt(ZMQ::TYPE).should == socket_type
+            array = []
+            rc = socket.getsockopt(ZMQ::TYPE, array)
+            rc.should == 0
+            array[0].should == socket_type
           end
         end
       end # context #getsockopt
@@ -402,38 +502,87 @@ module ZMQ
     end # each socket_type
 
 
-    describe "Events mapping to POLLIN and POLLOUT" do
+    describe "Mapping socket EVENTS to POLLIN and POLLOUT" do
       include APIHelper
+      
+      shared_examples_for "pubsub sockets where" do
+        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
+        end
+
+        it "PUB socket always has POLLOUT set" do
+          events = []
+          rc = @pub.getsockopt(ZMQ::EVENTS, events)
+          rc.should == 0
+          events[0].should == ZMQ::POLLOUT
+        end
 
-      before(:all) do
-        @ctx = Context.new
-        addr = "tcp://127.0.0.1:#{random_port}"
+        it "PUB socket never has POLLIN set" do
+          events = []
+          rc = @pub.getsockopt(ZMQ::EVENTS, events)
+          rc.should == 0
+          events[0].should_not == ZMQ::POLLIN
+        end
 
-        @sub = @ctx.socket ZMQ::SUB
-        @sub.setsockopt ZMQ::SUBSCRIBE, ''
+        it "SUB socket never has POLLOUT set" do
+          events = []
+          rc = @sub.getsockopt(ZMQ::EVENTS, events)
+          rc.should == 0
+          events[0].should_not == ZMQ::POLLOUT
+        end
+      end # shared example for pubsub
 
-        @pub = @ctx.socket ZMQ::PUB
-        @pub.connect addr
+      context "when SUB binds and PUB connects" do
 
-        @sub.bind addr
+        before(:each) do
+          @ctx = Context.new
 
-        @pub.send_string('test')
-        sleep 0.1
-      end
-      after(:all) do
+          @sub = @ctx.socket ZMQ::SUB
+          rc = @sub.setsockopt ZMQ::SUBSCRIBE, ''
+
+          @pub = @ctx.socket ZMQ::PUB
+          port = bind_to_random_tcp_port(@sub)
+          rc = @pub.connect "tcp://127.0.0.1:#{port}"
+          sleep 0.5
+
+          rc = @pub.send_string('test')
+          sleep 0.2
+        end
+
+        it_behaves_like "pubsub sockets where"
+      end # context SUB binds PUB connects
+
+      context "when SUB connects and PUB binds" do
+
+        before(:each) do
+          @ctx = Context.new
+
+          @sub = @ctx.socket ZMQ::SUB
+          rc = @sub.setsockopt ZMQ::SUBSCRIBE, ''
+
+          @pub = @ctx.socket ZMQ::PUB
+          port = bind_to_random_tcp_port(@pub)
+          rc = @sub.connect "tcp://127.0.0.1:#{port}"
+          sleep 0.5
+
+          rc = @pub.send_string('test')
+          sleep 0.2
+        end
+
+        it_behaves_like "pubsub sockets where"
+      end # context SUB binds PUB connects
+
+
+      after(:each) do
         @sub.close
         @pub.close
         # must call close on *every* socket before calling terminate otherwise it blocks indefinitely
         @ctx.terminate
       end
 
-      it "should have only POLLIN set for a sub socket that received a message" do
-        #@sub.getsockopt(ZMQ::EVENTS).should == ZMQ::POLLIN
-      end
-
-      it "should have only POLLOUT set for a sub socket that received a message" do
-        #@pub.getsockopt(ZMQ::EVENTS).should == ZMQ::POLLOUT
-      end
     end # describe 'events mapping to pollin and pollout'
 
   end # describe Socket