ffi-rzmq 0.6.0 → 0.7.0

data/lib/ffi-rzmq/wrapper.rb

@@ -5,11 +5,11 @@ module LibC
   # figures out the correct libc for each platform including Windows
   library = ffi_lib(FFI::Library::LIBC).first
 
+  # Size_t not working properly on Windows
+  find_type(:size_t) rescue typedef(:ulong, :size_t)
+
   # memory allocators
   attach_function :malloc, [:size_t], :pointer
-  attach_function :calloc, [:size_t], :pointer
-  attach_function :valloc, [:size_t], :pointer
-  attach_function :realloc, [:pointer, :size_t], :pointer
   attach_function :free, [:pointer], :void
   
   # get a pointer to the free function; used for ZMQ::Message deallocation
@@ -17,17 +17,17 @@ module LibC
 
   # memory movers
   attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
-  attach_function :bcopy, [:pointer, :pointer, :size_t], :void
-
 end # module LibC
 
 module LibZMQ
   extend FFI::Library
-  LINUX = ["libzmq", "/usr/local/lib/libzmq", "/opt/local/lib/libzmq"]
+  LINUX = ["libzmq", "/usr/local/lib/libzmq", "/usr/local/lib/libzmq.so", "/opt/local/lib/libzmq"]
   OSX = ["libzmq", "/usr/local/lib/libzmq", "/opt/local/lib/libzmq"]
   WINDOWS = []
   ffi_lib(LINUX + OSX + WINDOWS)
   
+  # Size_t not working properly on Windows
+  find_type(:size_t) rescue typedef(:ulong, :size_t)
 
   # Misc
   attach_function :zmq_version, [:pointer, :pointer, :pointer], :void
@@ -66,6 +66,8 @@ module LibZMQ
   # thread within the lib may try to call back into the ruby runtime. Failure to
   # release the GIL will result in a hang; the hint *may* allow things to run
   # smoothly for Ruby runtimes hampered by a GIL.
+  #
+  # This is really only honored by the MRI implementation.
   attach_function :zmq_setsockopt, [:pointer, :int, :pointer, :int], :int
   attach_function :zmq_getsockopt, [:pointer, :int, :pointer, :pointer], :int
   attach_function :zmq_bind, [:pointer, :string], :int

data/lib/ffi-rzmq/zmq.rb

@@ -37,6 +37,13 @@ module ZMQ
   SNDBUF = 11
   RCVBUF = 12
   RCVMORE = 13
+  FD = 14
+  EVENTS = 15
+  TYPE = 16
+  LINGER = 17
+  RECONNECT_IVL = 18
+  BACKLOG = 19
+  RECOVERY_IVL_MSEC = 20
 
   #  Send/recv options
   NOBLOCK = 1
@@ -98,13 +105,32 @@ module ZMQ
     # Returns an array of the form [major, minor, patch] to represent the
     # version of libzmq.
     #
-    def version
+    # Class method! Invoke as:  ZMQ::Util.version
+    #
+    def self.version
       major = FFI::MemoryPointer.new :int
       minor = FFI::MemoryPointer.new :int
       patch = FFI::MemoryPointer.new :int
       LibZMQ.zmq_version major, minor, patch
       [major.read_int, minor.read_int, patch.read_int]
     end
+    
+    # Compares the 0mq library API version to a minimal version tuple. Returns
+    # true if it meets the minimum requirement, false otherwise.
+    #
+    # Takes a +tuple+ with 3 elements corresponding to the major, minor and patch
+    # version levels.
+    #
+    # e.g.  Util.minimum_api?([2, 1, 0])
+    #
+    def self.minimum_api? tuple
+      api_version = Util.version
+      
+      # call #to_i to convert nil entries to 0 so the comparison is valid
+      tuple[0].to_i >= api_version[0] &&
+      tuple[1].to_i >= api_version[1] &&
+      tuple[2].to_i >= api_version[2]
+    end
 
 
     private

data/spec/context_spec.rb

@@ -23,17 +23,17 @@ module ZMQ
       end
 
       it "should set the :pointer accessor to non-nil" do
-        ctx = Context.new 1
+        ctx = spec_ctx
         ctx.pointer.should_not be_nil
       end
 
       it "should set the :context accessor to non-nil" do
-        ctx = Context.new 1
+        ctx = spec_ctx
         ctx.context.should_not be_nil
       end
 
       it "should set the :pointer and :context accessors to the same value" do
-        ctx = Context.new 1
+        ctx = spec_ctx
         ctx.pointer.should == ctx.context
       end
       
@@ -46,13 +46,13 @@ module ZMQ
 
     context "when terminating" do
       it "should call zmq_term to terminate the library's context" do
-        ctx = Context.new 1
+        ctx = Context.new # can't use a shared context here because we are terminating it!
         LibZMQ.should_receive(:zmq_term).with(ctx.pointer).and_return(0)
         ctx.terminate
       end
 
       it "should raise a ZMQ::ContextError exception when it fails" do
-        ctx = Context.new 1
+        ctx = Context.new # can't use a shared context here because we are terminating it!
         LibZMQ.stub(:zmq_term => 1)
         lambda { ctx.terminate }.should raise_error(ZMQ::ContextError)
       end
@@ -61,44 +61,17 @@ module ZMQ
 
     context "when allocating a socket" do
       it "should return a ZMQ::Socket" do
-        ctx = Context.new 1
+        ctx = spec_ctx
         ctx.socket(ZMQ::REQ).should be_kind_of(ZMQ::Socket)
       end
 
       it "should raise a ZMQ::SocketError exception when allocation fails" do
-        ctx = Context.new 1
+        ctx = spec_ctx
         Socket.stub(:new => nil)
         lambda { ctx.socket(ZMQ::REQ) }.should raise_error(ZMQ::SocketError)
       end
     end # context socket
 
-
-#    context "when allocating a device" do
-#      let(:ctx) { Context.new 1 }
-#      let(:sock1) { ctx.socket ZMQ::REQ }
-#      let(:sock2) { ctx.socket ZMQ::REP }
-#
-#      it "should return a ZMQ::Forwarder" do
-#        device = ctx.device ZMQ::FORWARDER, sock1, sock2
-#        device.should be_kind_of(ZMQ::Forwarder)
-#      end
-#
-#      it "should return a ZMQ::Queue" do
-#        device = ctx.device ZMQ::QUEUE, sock1, sock2
-#        device.should be_kind_of(ZMQ::Queue)
-#      end
-#
-#      it "should return a ZMQ::Streamer" do
-#        device = ctx.device ZMQ::STREAMER, sock1, sock2
-#        device.should be_kind_of(ZMQ::Streamer)
-#      end
-#
-#      it "should raise an exception when the requested device is unknown" do
-#        lambda { ctx.device(-1, sock1, sock2) }.should raise_error(ZMQ::DeviceError)
-#      end
-#    end # context device
-
-
   end # describe Context
 
 

data/spec/pushpull_spec.rb

@@ -10,14 +10,19 @@ module ZMQ
 
       before(:each) do
         $stdout.flush
-        @context = ZMQ::Context.new 1
+        @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.bind    @link
       end
-
+      
+      after(:each) do
+        @push.close
+        @pull.close
+      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
@@ -34,32 +39,24 @@ module ZMQ
         received_message.copy_out_string.should == string
       end
 
-      it "should receive an exact string copy of the message sent when sending in non-blocking mode and using Message objects directly" do
-        sent_message = Message.new string
-        received_message = Message.new
-
-        @push.send sent_message, ZMQ::NOBLOCK
-        sleep 0.1 # give it time for delivery
-        @pull.recv received_message, ZMQ::NOBLOCK
-        received_message.copy_out_string.should == string
-      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 {
-          threads << Thread.new {
+        count.times do
+          threads << Thread.new do
             pull = @context.socket ZMQ::PULL
-            pull.connect @link
+            rc = pull.connect @link
             received << pull.recv_string
             pull.close
-          }
-        }
-        
-        count.times { @push.send_string(string); sleep 0.001 }
+          end
+          sleep 0.001 # 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

data/spec/reqrep_spec.rb

@@ -19,6 +19,11 @@ module ZMQ
         @pong.bind link
         @ping.connect link
       end
+      
+      after(:each) do
+        @ping.close
+        @pong.close
+      end
 
       it "should receive an exact string copy of the string message sent" do
         @ping.send_string string

data/spec/socket_spec.rb

@@ -7,105 +7,94 @@ module ZMQ
   describe Socket do
 
     context "when initializing" do
+      before(:all) { @ctx = Context.new }
+      after(:all) { @ctx.terminate }
 
-      let(:ctx) { Context.new 1 }
 
       it "should raise an error for a nil context" do
         lambda { Socket.new(FFI::Pointer::NULL, ZMQ::REQ) }.should raise_exception(ZMQ::ContextError)
       end
 
-      it "should not raise an error for a ZMQ::REQ socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::REQ) }.should_not raise_error
-      end
-
-      it "should not raise an error for a ZMQ::REP socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::REP) }.should_not raise_error
-      end
-
-      it "should not raise an error for a ZMQ::PUB socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::PUB) }.should_not raise_error
-      end
-
-      it "should not raise an error for a ZMQ::SUB socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::SUB) }.should_not raise_error
-      end
-
-      it "should not raise an error for a ZMQ::PAIR socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::PAIR) }.should_not raise_error
-      end
-
-      it "should not raise an error for a ZMQ::XREQ socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::XREQ) }.should_not raise_error
-      end
-
-      it "should not raise an error for a ZMQ::XREP socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::XREP) }.should_not raise_error
-      end
+      [ZMQ::REQ, ZMQ::REP, ZMQ::XREQ, ZMQ::XREP, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR].each do |socket_type|
 
-      it "should not raise an error for a ZMQ::PUSH socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::PUSH) }.should_not raise_error
-      end
-
-      it "should not raise an error for a ZMQ::PULL socket type" do
-        lambda { Socket.new(ctx.pointer, ZMQ::PULL) }.should_not raise_error
-      end
-
-      it "should raise an error for an unknown socket type" do
-        lambda { Socket.new(ctx.pointer, 80) }.should raise_exception(ZMQ::SocketError)
-      end
+        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
+        end
+      end # each socket_type
 
       it "should set the :socket accessor to the raw socket allocated by libzmq" do
-        socket = mock('socket')#.as_null_object
+        socket = mock('socket')
         socket.stub!(:null? => false)
         LibZMQ.should_receive(:zmq_socket).and_return(socket)
 
-        sock = Socket.new(ctx.pointer, ZMQ::REQ)
+        sock = Socket.new(@ctx.pointer, ZMQ::REQ)
         sock.socket.should == socket
       end
 
       it "should define a finalizer on this object" do
-        pending # need to wait for 0mq 2.1 or later to fix this
-        ObjectSpace.should_receive(:define_finalizer)
-        ctx = Context.new 1
+        ObjectSpace.should_receive(:define_finalizer).at_least(1)
+        sock = Socket.new(@ctx.pointer, ZMQ::REQ)
+        sock.close
       end
     end # context initializing
+    
+    
+    context "calling close" do
+      before(:all) { @ctx = Context.new }
+      after(:all) { @ctx.terminate }
+
+      it "should call LibZMQ.close only once" do
+        sock = Socket.new @ctx.pointer, ZMQ::REQ
+        raw_socket = sock.socket
+
+        LibZMQ.should_receive(:close).with(raw_socket)
+        sock.close
+        sock.close
+        LibZMQ.close raw_socket # *really close it otherwise the context will block indefinitely
+      end
+    end # context calling close
 
 
     context "identity=" do
+      before(:all) { @ctx = Context.new }
+      after(:all) { @ctx.terminate }
+
       it "should raise an exception for identities in excess of 255 bytes" do
-        ctx = Context.new 1
-        sock = Socket.new ctx.pointer, ZMQ::REQ
+        sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         lambda { sock.identity = ('a' * 256) }.should raise_exception(ZMQ::SocketError)
+        sock.close
       end
 
       it "should raise an exception for identities of length 0" do
-        ctx = Context.new 1
-        sock = Socket.new ctx.pointer, ZMQ::REQ
+        sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         lambda { sock.identity = '' }.should raise_exception(ZMQ::SocketError)
+        sock.close
       end
 
       it "should NOT raise an exception for identities of 1 byte" do
-        ctx = Context.new 1
-        sock = Socket.new ctx.pointer, ZMQ::REQ
+        sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         lambda { sock.identity = 'a' }.should_not raise_exception(ZMQ::SocketError)
+        sock.close
       end
 
       it "should NOT raise an exception for identities of 255 bytes" do
-        ctx = Context.new 1
-        sock = Socket.new ctx.pointer, ZMQ::REQ
+        sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         lambda { sock.identity = ('a' * 255) }.should_not raise_exception(ZMQ::SocketError)
+        sock.close
       end
 
       it "should convert numeric identities to strings" do
-        ctx = Context.new 1
-        sock = Socket.new ctx.pointer, ZMQ::REQ
+        sock = Socket.new @ctx.pointer, ZMQ::REQ
 
         sock.identity = 7
         sock.identity.should == '7'
+        sock.close
       end
     end # context identity=
 
@@ -113,9 +102,15 @@ module ZMQ
     [ZMQ::REQ, ZMQ::REP, ZMQ::XREQ, ZMQ::XREP, ZMQ::PUB, ZMQ::SUB, ZMQ::PUSH, ZMQ::PULL, ZMQ::PAIR].each do |socket_type|
 
       context "#setsockopt for a #{ZMQ::SocketTypeNameMap[socket_type]} socket" do
+        before(:all) { @ctx = Context.new }
+        after(:all) { @ctx.terminate }
+
         let(:socket) do
-          ctx = Context.new
-          Socket.new ctx.pointer, socket_type
+          Socket.new @ctx.pointer, socket_type
+        end
+
+        after(:each) do
+          socket.close
         end
 
 
@@ -139,10 +134,10 @@ module ZMQ
               lambda { socket.setsockopt(ZMQ::UNSUBSCRIBE, "topic.string") }.should_not raise_error(SocketError)
             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
+#            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)
@@ -166,18 +161,18 @@ module ZMQ
         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::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
@@ -193,52 +188,53 @@ module ZMQ
             socket.getsockopt(ZMQ::AFFINITY).should == affinity.abs
           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
-#          end
-#
-#          it "should raise a SocketError given a negative value" do
-#            rate = -200
-#            lambda { socket.setsockopt ZMQ::RATE, rate }.should raise_error(SocketError)
-#          end
-#        end # context using option ZMQ::RATE
-#        
-#        
-#        context "using option ZMQ::RECOVERY_IVL" do
-#          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
-#          end
-#
-#          it "should raise a SocketError given a negative value" do
-#            rate = -200
-#            lambda { socket.setsockopt ZMQ::RECOVERY_IVL, rate }.should raise_error(SocketError)
-#          end
-#        end # context using option ZMQ::RECOVERY_IVL
-        
-        
+
+
+        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
+          end
+
+          it "should raise a SocketError given a negative value" do
+            rate = -200
+            lambda { socket.setsockopt ZMQ::RATE, rate }.should raise_error(SocketError)
+          end
+        end # context using option ZMQ::RATE
+
+
+        context "using option ZMQ::RECOVERY_IVL" do
+          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
+          end
+
+          it "should raise a SocketError given a negative value" do
+            rate = -200
+            lambda { socket.setsockopt ZMQ::RECOVERY_IVL, rate }.should raise_error(SocketError)
+          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
@@ -250,8 +246,8 @@ module ZMQ
             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
@@ -265,8 +261,8 @@ module ZMQ
             socket.getsockopt(ZMQ::SNDBUF).should == size.abs
           end
         end # context using option ZMQ::SNDBUF
-        
-        
+
+
         context "using option ZMQ::RCVBUF" do
           it "should set the OS receive buffer given a positive value" do
             size = 100
@@ -280,11 +276,155 @@ module ZMQ
             socket.getsockopt(ZMQ::RCVBUF).should == size.abs
           end
         end # context using option ZMQ::RCVBUF
+
+
+        context "using option ZMQ::LINGER" do
+          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
+          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
+          end
+
+          it "should default to a value of -1" do
+            value = -1
+            socket.getsockopt(ZMQ::LINGER).should == value
+          end
+        end # context using option ZMQ::LINGER
+
+
+        context "using option ZMQ::RECONNECT_IVL" do
+          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
+          end
+
+          it "should default to a value of 100" do
+            value = 100
+            socket.getsockopt(ZMQ::RECONNECT_IVL).should == value
+          end
+        end # context using option ZMQ::RECONNECT_IVL
+
+
+        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
+            socket.getsockopt(ZMQ::BACKLOG).should == value
+          end
+
+          it "should default to a value of 100" do
+            value = 100
+            socket.getsockopt(ZMQ::BACKLOG).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
 
+
+      context "#getsockopt for a #{ZMQ::SocketTypeNameMap[socket_type]} socket" do
+        before(:all) { @ctx = Context.new }
+        after(:all) { @ctx.terminate }
+
+        let(:socket) do
+          Socket.new @ctx.pointer, socket_type
+        end
+
+        after(:each) do
+          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
+
+          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
+            
+            # these 2 hex constants were taken from OSX; may differ on other platforms
+            so_rcvbuf = 0x1002
+            sol_socket = 0xffff
+            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
+          end
+        end
+
+        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)
+          end
+        end
+      end # context #getsockopt
+
     end # each socket_type
 
 
+    describe "Events mapping to POLLIN and POLLOUT" do
+      include APIHelper
+
+      before(:all) do
+        @ctx = Context.new
+        addr = "tcp://127.0.0.1:#{random_port}"
+
+        @sub = @ctx.socket ZMQ::SUB
+        @sub.setsockopt ZMQ::SUBSCRIBE, ''
+
+        @pub = @ctx.socket ZMQ::PUB
+        @pub.connect addr
+
+        @sub.bind addr
+
+        @pub.send_string('test')
+        sleep 0.1
+      end
+      after(:all) 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