ffi-rzmq 0.9.3 → 0.9.6

data/spec/poll_spec.rb

@@ -51,31 +51,112 @@ module ZMQ
     
     
     context "#delete" do
-      let(:poller) { Poller.new }
-      let(:socket) { mock('socket') }
-      let(:context) { Context.new }
+      before(:all) do
+        @context = Context.new
+      end
+      
+      before(:each) do
+        @socket = @context.socket(XREQ)
+        @socket.setsockopt(LINGER, 0)
+        @poller = Poller.new
+      end
+      
+      after(:each) do
+        @socket.close
+      end
+      
+      after(:all) do
+        @context.terminate
+      end
       
       it "should return false for an unregistered socket (i.e. not found)" do
-        poller.delete(socket).should be_false
+        @poller.delete(@socket).should be_false
       end
       
       it "returns true for a sucessfully deleted socket when only 1 is registered" do
-        socket1 = context.socket ZMQ::REP
+        socket1 = @context.socket(REP)
+        socket1.setsockopt(LINGER, 0)
 
-        poller.register socket1
-        poller.delete(socket1).should be_true
+        @poller.register socket1
+        @poller.delete(socket1).should be_true
+        socket1.close
       end
       
       it "returns true for a sucessfully deleted socket when more than 1 is registered" do
-        socket1 = context.socket ZMQ::REP
-        socket2 = context.socket ZMQ::REP
+        socket1 = @context.socket(REP)
+        socket2 = @context.socket(REP)
+        socket1.setsockopt(LINGER, 0)
+        socket2.setsockopt(LINGER, 0)
 
-        poller.register socket1
-        poller.register socket2
-        poller.delete(socket2).should be_true
+        @poller.register socket1
+        @poller.register socket2
+        @poller.delete(socket2).should be_true
+        socket1.close
+        socket2.close
       end
       
     end
+    
+    
+    context "poll" do
+      include APIHelper
+      
+      before(:all) do
+      end
+      
+      before(:each) do
+        # Must recreate context for each test otherwise some poll tests fail.
+        # This is likely due to a race condition in event handling when reusing
+        # the same inproc inside the same context over and over. Making a new
+        # context solves it.
+        @context = Context.new
+        endpoint = "inproc://poll_test"
+        @socket = @context.socket(DEALER)
+        @socket2 = @context.socket(ROUTER)
+        @socket.setsockopt(LINGER, 0)
+        @socket2.setsockopt(LINGER, 0)
+        @socket.bind(endpoint)
+        connect_to_inproc(@socket2, endpoint)
+
+        @poller = Poller.new
+      end
+      
+      after(:each) do
+        @socket.close
+        @socket2.close
+        @context.terminate
+      end
+      
+      it "returns 0 when there are no sockets to poll" do
+        rc = @poller.poll(100)
+        rc.should be_zero
+      end
+      
+      it "returns 0 when there is a single socket to poll and no events" do
+        @poller.register(@socket, 0)
+        rc = @poller.poll(100)
+        rc.should be_zero
+      end
+      
+      it "returns 1 when there is a read event on a socket" do
+        @poller.register_readable(@socket2)
+        
+        @socket.send_string('test')
+        rc = @poller.poll(1000)
+        rc.should == 1
+      end
+      
+      it "returns 1 when there is a read event on one socket and the second socket has been removed from polling" do
+        @poller.register_readable(@socket2)
+        @poller.register_writable(@socket)
+        
+        @socket.send_string('test')
+        @poller.deregister_writable(@socket)
+
+        rc = @poller.poll(1000)
+        rc.should == 1
+      end
+    end # poll
 
 
   end # describe Poll

data/spec/pushpull_spec.rb

@@ -2,23 +2,26 @@
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
 module ZMQ
-  describe Context do
+  describe Socket do
     context "when running basic push pull" do
       include APIHelper
 
       let(:string) { "booga-booga" }
-
+      
       before(:each) do
-        $stdout.flush
-        @context = ZMQ::Context.new
+        # Use new context for each iteration to avoid inproc race. See
+        # poll_spec.rb for more details.
+        @context = Context.new
+        poller_setup
+
         @push = @context.socket ZMQ::PUSH
         @pull = @context.socket ZMQ::PULL
         @push.setsockopt ZMQ::LINGER, 0
         @pull.setsockopt ZMQ::LINGER, 0
-        port = connect_to_random_tcp_port(@pull)
-        @link = "tcp://127.0.0.1:#{port}"
-        #@link = "inproc://push_pull_test" # can't connect to inproc *before* bind
-        @push.bind    @link
+        
+        @link = "inproc://push_pull_test"
+        @push.bind @link
+        connect_to_inproc(@pull, @link)
       end
 
       after(:each) do
@@ -35,126 +38,77 @@ module ZMQ
         received.should == string
       end
 
-      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
+      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
 
+        poll_it_for_read(@pull) do
           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
+          LibZMQ.version2? ? rc.should == 0 : rc.should == 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
       end
 
 
-      if version2?
-
-        it "should receive a single message for each message sent on each socket listening, when an equal number pulls to messages and a unique socket per thread" 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
-          mutex = Mutex.new
-
-          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
-              mutex.synchronize { 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
+      it "should receive a single message for each message sent on each socket listening, when an equal number of sockets pulls messages and where each socket is unique per thread" do
+        received = []
+        threads  = []
+        sockets = []
+        count    = 4
+        mutex = Mutex.new
+        
+        # make sure all sockets are connected before we do our load-balancing test
+        (count - 1).times do
+          socket = @context.socket ZMQ::PULL
+          socket.setsockopt ZMQ::LINGER, 0
+          connect_to_inproc(socket, @link)
+          sockets << socket
         end
-
-        it "should receive a single message for each message sent on each socket listening, when an equal number pulls to messages and a single shared socket protected by a mutex" 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
-          pull = @context.socket ZMQ::PULL
-          rc = pull.setsockopt ZMQ::LINGER, 0
-          rc = pull.connect @link
-          rc.should == 0
-          mutex = Mutex.new
-
-          count.times do |i|
-            threads << Thread.new do
-              buffer = ''
-              rc = 0
-              mutex.synchronize { rc = pull.recv_string buffer }
-              rc.should == 0
-              mutex.synchronize { received << buffer }
-            end
-            sleep 0.01 # give each thread time to spin up
+        sockets << @pull
+
+        sockets.each do |socket|
+          threads << Thread.new do
+            buffer = ''
+            rc = socket.recv_string buffer
+            version2? ? (rc.should == 0) : (rc.should == buffer.size)
+            mutex.synchronize { received << buffer }
+            socket.close
           end
+        end
 
-          count.times { @push.send_string(string) }
+        count.times { @push.send_string(string) }
 
-          threads.each {|t| t.join}
-          pull.close
+        threads.each {|t| t.join}
 
-          received.find_all {|r| r == string}.length.should == count
-        end
+        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
+      it "should receive a single message for each message sent when using a single shared socket protected by a mutex" do
+        received = []
+        threads  = []
+        count    = 4
+        mutex = Mutex.new
+
+        count.times do |i|
+          threads << Thread.new do
+            buffer = ''
+            rc = 0
+            mutex.synchronize { rc = @pull.recv_string buffer }
+            version2? ? (rc.should == 0) : (rc.should == buffer.size)
+            mutex.synchronize { received << buffer }
           end
+        end
 
-          count.times { @push.send_string(string) }
-
-          threads.each {|t| t.join}
+        count.times { @push.send_string(string) }
 
-          received.find_all {|r| r == string}.length.should == count
-        end
+        threads.each {|t| t.join}
 
-      end # if version...
+        received.find_all {|r| r == string}.length.should == count
+      end
 
     end # @context ping-pong
   end # describe

data/spec/reqrep_spec.rb

@@ -4,88 +4,77 @@ require File.join(File.dirname(__FILE__), %w[spec_helper])
 module ZMQ
 
 
-  describe Context do
+  describe Socket do
 
     context "when running ping pong" do
       include APIHelper
 
       let(:string) { "booga-booga" }
 
+      # reset sockets each time because we only send 1 message which leaves
+      # the REQ socket in a bad state. It cannot send again unless we were to
+      # send a reply with the REP and read it.
       before(:each) do
-        context = ZMQ::Context.new 1
-        @ping = context.socket ZMQ::REQ
-        @pong = context.socket ZMQ::REP
-        port = bind_to_random_tcp_port(@pong)
-        @ping.connect "tcp://127.0.0.1:#{port}"
+        @context = ZMQ::Context.new
+        poller_setup
+
+        endpoint = "inproc://reqrep_test"
+        @ping = @context.socket ZMQ::REQ
+        @pong = @context.socket ZMQ::REP
+        @pong.bind(endpoint)
+        connect_to_inproc(@ping, endpoint)
       end
 
       after(:each) do
         @ping.close
         @pong.close
+        @context.terminate
       end
-
-      it "should receive an exact string copy of the string message sent" do
+      
+      def send_ping(string)
         @ping.send_string string
         received_message = ''
         rc = @pong.recv_string received_message
+        [rc, received_message]
+      end
 
+      it "should receive an exact string copy of the string message sent" do
+        rc, received_message = send_ping(string)
         received_message.should == 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
+      end
 
-      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
-
-          rc = @ping.send sent_message
-          rc.should == 0
-          rc = @pong.recv received_message
-          rc.should == 0
-
-          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.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
+      it "should receive an exact copy of the sent message using Message objects directly" do
+        received_message = Message.new
 
-          received_message.copy_out_string.should == string
-        end
+        rc = @ping.sendmsg(Message.new(string))
+        LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
+        rc = @pong.recvmsg received_message
+        LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
 
-        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
+        received_message.copy_out_string.should == string
+      end
 
-          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
+      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
 
-          received_message.copy_out_string.should == string
+        poll_it_for_read(@pong) do
+          rc = @ping.sendmsg(Message.new(string), ZMQ::NonBlocking)
+          LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
         end
+        
+        rc = @pong.recvmsg received_message, ZMQ::NonBlocking
+        LibZMQ.version2? ? rc.should == 0 : rc.should == string.size
 
-      end # if version...
+        received_message.copy_out_string.should == string
+      end
 
     end # context ping-pong