rbczmq 1.7.1 → 1.7.2

data/ext/zeromq/tests/test_ctx_destroy.cpp

@@ -0,0 +1,90 @@
+/*
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "testutil.hpp"
+
+static void receiver (void *socket)
+{
+    char buffer[16];
+    int rc = zmq_recv (socket, &buffer, sizeof (buffer), 0);
+    assert(rc == -1);
+}
+
+void test_ctx_destroy()
+{
+    int rc;
+    
+    //  Set up our context and sockets
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+    
+    void *socket = zmq_socket (ctx, ZMQ_PULL);
+    assert (socket);
+
+    // Close the socket
+    rc = zmq_close (socket);
+    assert (rc == 0);
+    
+    // Destroy the context
+    rc = zmq_ctx_destroy (ctx);
+    assert (rc == 0);
+}
+
+void test_ctx_shutdown()
+{
+    int rc;
+    
+    //  Set up our context and sockets
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+    
+    void *socket = zmq_socket (ctx, ZMQ_PULL);
+    assert (socket);
+
+    // Spawn a thread to receive on socket
+    void *receiver_thread = zmq_threadstart (&receiver, socket);
+
+    // Wait for thread to start up and block
+    zmq_sleep (1);
+
+    // Shutdown context, if we used destroy here we would deadlock.
+    rc = zmq_ctx_shutdown (ctx);
+    assert (rc == 0);
+
+    // Wait for thread to finish
+    zmq_threadclose (receiver_thread);
+
+    // Close the socket.
+    rc = zmq_close (socket);
+    assert (rc == 0);
+
+    // Destory the context, will now not hang as we have closed the socket.
+    rc = zmq_ctx_destroy (ctx);
+    assert (rc == 0);
+}
+
+int main (void)
+{
+    setup_test_environment();
+
+    test_ctx_destroy();
+    test_ctx_shutdown();
+
+    return 0;
+}

data/ext/zeromq/tests/test_ctx_options.cpp

@@ -0,0 +1,52 @@
+/*
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "testutil.hpp"
+
+int main (void)
+{
+    setup_test_environment();
+    int rc;
+    
+    //  Set up our context and sockets
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+    
+    assert (zmq_ctx_get (ctx, ZMQ_MAX_SOCKETS) == ZMQ_MAX_SOCKETS_DFLT);
+    assert (zmq_ctx_get (ctx, ZMQ_IO_THREADS) == ZMQ_IO_THREADS_DFLT);
+    assert (zmq_ctx_get (ctx, ZMQ_IPV6) == 0);
+    
+    rc = zmq_ctx_set (ctx, ZMQ_IPV6, true);
+    assert (zmq_ctx_get (ctx, ZMQ_IPV6) == true);
+    
+    void *router = zmq_socket (ctx, ZMQ_ROUTER);
+    int ipv6;
+    size_t optsize = sizeof (int);
+    rc = zmq_getsockopt (router, ZMQ_IPV6, &ipv6, &optsize);
+    assert (rc == 0);
+    assert (ipv6);
+
+    rc = zmq_close (router);
+    assert (rc == 0);
+    
+    rc = zmq_ctx_term (ctx);
+    assert (rc == 0);
+
+    return 0;
+}

data/ext/zeromq/tests/test_disconnect_inproc.cpp

@@ -1,7 +1,23 @@
-#include <zmq.h>
-#include <inttypes.h>
-#include <string.h>
-#include <assert.h>
+/*
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "testutil.hpp"
 
 /// Initialize a zeromq message with a given null-terminated string
 #define ZMQ_PREPARE_STRING(msg, data, size) \
@@ -13,6 +29,7 @@ int publicationsReceived = 0;
 bool isSubscribed = false;
 
 int main(int argc, char** argv) {
+    setup_test_environment();
     void* context = zmq_ctx_new();
     void* pubSocket;
     void* subSocket;
@@ -22,34 +39,32 @@ int main(int argc, char** argv) {
     zmq_setsockopt(subSocket, ZMQ_SUBSCRIBE, "foo", 3)  && printf("zmq_setsockopt: %s\n",zmq_strerror(errno));
   
     zmq_bind(pubSocket, "inproc://someInProcDescriptor") && printf("zmq_bind: %s\n", zmq_strerror(errno));
-    //zmq_bind(pubSocket, "tcp://*:30010") && printf("zmq_bind: %s\n", zmq_strerror(errno));
+    //zmq_bind(pubSocket, "tcp://127.0.0.1:30010") && printf("zmq_bind: %s\n", zmq_strerror(errno));
   
-    int32_t more;
+    int more;
     size_t more_size = sizeof(more);
     int iteration = 0;
   
-    while(1) {
+    while (1) {
         zmq_pollitem_t items [] = {
-            { subSocket,    0, ZMQ_POLLIN, 0 }, // read publications
-            { pubSocket,    0, ZMQ_POLLIN, 0 }, // read subscriptions
+            { subSocket, 0, ZMQ_POLLIN, 0 }, // read publications
+            { pubSocket, 0, ZMQ_POLLIN, 0 }, // read subscriptions
         };
-        zmq_poll(items, 2, 500);
+        int rc = zmq_poll (items, 2, 100);
     
-        if (items[1].revents & ZMQ_POLLIN) {
+        if (items [1].revents & ZMQ_POLLIN) {
             while (1) {
                 zmq_msg_t msg;
                 zmq_msg_init (&msg);
                 zmq_msg_recv (&msg, pubSocket, 0);
-                int msgSize = zmq_msg_size(&msg);
                 char* buffer = (char*)zmq_msg_data(&msg);
 
                 if (buffer[0] == 0) {
                     assert(isSubscribed);
-                    printf("unsubscribing from '%s'\n", strndup(buffer + 1, msgSize - 1));
                     isSubscribed = false;
-                } else {
+                } 
+                else {
                     assert(!isSubscribed);
-                    printf("subscribing on '%s'\n", strndup(buffer + 1, msgSize - 1));
                     isSubscribed = true;
                 }
 
@@ -66,11 +81,6 @@ int main(int argc, char** argv) {
                 zmq_msg_t msg;
                 zmq_msg_init (&msg);
                 zmq_msg_recv (&msg, subSocket, 0);
-                int msgSize = zmq_msg_size(&msg);
-                char* buffer = (char*)zmq_msg_data(&msg);
-        
-                printf("received on subscriber '%s'\n", strndup(buffer, msgSize));
-        
                 zmq_getsockopt (subSocket, ZMQ_RCVMORE, &more, &more_size);
                 zmq_msg_close (&msg);
         
@@ -80,41 +90,36 @@ int main(int argc, char** argv) {
                 }
             }
         }
-
         if (iteration == 1) {
             zmq_connect(subSocket, "inproc://someInProcDescriptor") && printf("zmq_connect: %s\n", zmq_strerror(errno));
             //zmq_connect(subSocket, "tcp://127.0.0.1:30010") && printf("zmq_connect: %s\n", zmq_strerror(errno));
         }
-    
         if (iteration == 4) {
             zmq_disconnect(subSocket, "inproc://someInProcDescriptor") && printf("zmq_disconnect(%d): %s\n", errno, zmq_strerror(errno));
             //zmq_disconnect(subSocket, "tcp://127.0.0.1:30010") && printf("zmq_disconnect: %s\n", zmq_strerror(errno));
         }
-    
-        if (iteration == 10) {
+        if (iteration > 4 && rc == 0)
             break;
-        }
-    
+        
         zmq_msg_t channelEnvlp;
         ZMQ_PREPARE_STRING(channelEnvlp, "foo", 3);
-        zmq_sendmsg(pubSocket, &channelEnvlp, ZMQ_SNDMORE) >= 0 || printf("zmq_sendmsg: %s\n",zmq_strerror(errno));
+        zmq_msg_send (&channelEnvlp, pubSocket, ZMQ_SNDMORE) >= 0 || printf("zmq_msg_send: %s\n",zmq_strerror(errno));
         zmq_msg_close(&channelEnvlp) && printf("zmq_msg_close: %s\n",zmq_strerror(errno));
 
         zmq_msg_t message;
         ZMQ_PREPARE_STRING(message, "this is foo!", 12);
-        zmq_sendmsg(pubSocket, &message, 0) >= 0 || printf("zmq_sendmsg: %s\n",zmq_strerror(errno));
+        zmq_msg_send (&message, pubSocket, 0) >= 0 || printf("zmq_msg_send: %s\n",zmq_strerror(errno));
         zmq_msg_close(&message) && printf("zmq_msg_close: %s\n",zmq_strerror(errno));
 
         iteration++;
     }
-  
     assert(publicationsReceived == 3);
     assert(!isSubscribed);
 
     zmq_close(pubSocket) && printf("zmq_close: %s", zmq_strerror(errno));
     zmq_close(subSocket) && printf("zmq_close: %s", zmq_strerror(errno));
   
-    zmq_ctx_destroy(context);
+    zmq_ctx_term(context);
     return 0;
 }
 

data/ext/zeromq/tests/test_fork.cpp

@@ -0,0 +1,81 @@
+/*
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
+
+    This file is part of 0MQ.
+
+    0MQ is free software; you can redistribute it and/or modify it under
+    the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    0MQ is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "testutil.hpp"
+
+const char *address = "tcp://127.0.0.1:6571";
+
+#define NUM_MESSAGES 5
+
+int main (void)
+{
+    setup_test_environment ();
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+    
+    //  Create and bind pull socket to receive messages
+    void *pull = zmq_socket (ctx, ZMQ_PULL);
+    assert (pull);
+    int rc = zmq_bind (pull, address);
+    assert (rc == 0);
+
+    int pid = fork ();
+    if (pid == 0) {
+        //  Child process
+        //  Immediately close parent sockets and context
+        zmq_close (pull);
+        zmq_term (ctx);
+
+        //  Create new context, socket, connect and send some messages
+        void *child_ctx = zmq_ctx_new ();
+        assert (child_ctx);
+        void *push = zmq_socket (child_ctx, ZMQ_PUSH);
+        assert (push);
+        rc = zmq_connect (push, address);
+        assert (rc == 0);
+        int count;
+        for (count = 0; count < NUM_MESSAGES; count++)
+            zmq_send (push, "Hello", 5, 0);
+        
+        zmq_close (push);
+        zmq_ctx_destroy (child_ctx);
+        exit (0);
+    } 
+    else {
+        //  Parent process
+        int count;
+        for (count = 0; count < NUM_MESSAGES; count++) {
+            char buffer [5];
+            int num_bytes = zmq_recv (pull, buffer, 5, 0);
+            assert (num_bytes == 5);
+        }
+        int child_status;
+        while (true) {
+            rc = waitpid (pid, &child_status, 0);
+            if (rc == -1 && errno == EINTR) 
+                continue;
+            assert (rc > 0);
+            //  Verify the status code of the child was zero
+            assert (WEXITSTATUS (child_status) == 0);
+            break;
+        }
+        exit (0);
+    }
+    return 0;
+}

data/ext/zeromq/tests/test_hwm.cpp

@@ -1,6 +1,5 @@
 /*
-    Copyright (c) 2010-2011 250bpm s.r.o.
-    Copyright (c) 2010-2011 Other contributors as noted in the AUTHORS file
+    Copyright (c) 2007-2013 Contributors as noted in the AUTHORS file
 
     This file is part of 0MQ.
 
@@ -18,66 +17,283 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-
-#include <stdio.h>
 #include "testutil.hpp"
 
-int main (void)
-{
-    fprintf (stderr, "test_hwm running...\n");
+const int MAX_SENDS = 10000;
 
-    void *ctx = zmq_init (1);
+enum TestType { BIND_FIRST, CONNECT_FIRST };
+
+int test_defaults ()
+{
+    void *ctx = zmq_ctx_new ();
     assert (ctx);
+    int rc;
 
-    //  Create pair of socket, each with high watermark of 2. Thus the total
-    //  buffer space should be 4 messages.
-    void *sb = zmq_socket (ctx, ZMQ_PULL);
-    assert (sb);
-    int hwm = 2;
-    int rc = zmq_setsockopt (sb, ZMQ_RCVHWM, &hwm, sizeof (hwm));
+    // Set up bind socket
+    void *bind_socket = zmq_socket (ctx, ZMQ_PULL);
+    assert (bind_socket);
+    rc = zmq_bind (bind_socket, "inproc://a");
     assert (rc == 0);
-    rc = zmq_bind (sb, "inproc://a");
+
+    // Set up connect socket
+    void *connect_socket = zmq_socket (ctx, ZMQ_PUSH);
+    assert (connect_socket);
+    rc = zmq_connect (connect_socket, "inproc://a");
+    assert (rc == 0);
+
+    // Send until we block
+    int send_count = 0;
+    while (send_count < MAX_SENDS && zmq_send (connect_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
+        ++send_count;
+
+    // Now receive all sent messages
+    int recv_count = 0;
+    while (zmq_recv (bind_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
+        ++recv_count;
+
+    assert (send_count == recv_count);
+
+    // Clean up
+    rc = zmq_close (connect_socket);
     assert (rc == 0);
 
-    void *sc = zmq_socket (ctx, ZMQ_PUSH);
-    assert (sc);
-    rc = zmq_setsockopt (sc, ZMQ_SNDHWM, &hwm, sizeof (hwm));
+    rc = zmq_close (bind_socket);
     assert (rc == 0);
-    rc = zmq_connect (sc, "inproc://a");
+
+    rc = zmq_ctx_term (ctx);
     assert (rc == 0);
 
-    //  Try to send 10 messages. Only 4 should succeed.
-    for (int i = 0; i < 10; i++)
+    return send_count;
+}
+
+int count_msg (int send_hwm, int recv_hwm, TestType testType)
+{
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+    int rc;
+
+    void *bind_socket;
+    void *connect_socket;
+    if (testType == BIND_FIRST)
     {
-        int rc = zmq_send (sc, NULL, 0, ZMQ_DONTWAIT);
-        if (i < 4)
-            assert (rc == 0);
-        else
-            assert (rc < 0 && errno == EAGAIN);
+        // Set up bind socket
+        bind_socket = zmq_socket (ctx, ZMQ_PULL);
+        assert (bind_socket);
+        rc = zmq_setsockopt (bind_socket, ZMQ_RCVHWM, &recv_hwm, sizeof (recv_hwm));
+        assert (rc == 0);
+        rc = zmq_bind (bind_socket, "inproc://a");
+        assert (rc == 0);
+
+        // Set up connect socket
+        connect_socket = zmq_socket (ctx, ZMQ_PUSH);
+        assert (connect_socket);
+        rc = zmq_setsockopt (connect_socket, ZMQ_SNDHWM, &send_hwm, sizeof (send_hwm));
+        assert (rc == 0);
+        rc = zmq_connect (connect_socket, "inproc://a");
+        assert (rc == 0);
     }
+    else
+    {
+        // Set up connect socket
+        connect_socket = zmq_socket (ctx, ZMQ_PUSH);
+        assert (connect_socket);
+        rc = zmq_setsockopt (connect_socket, ZMQ_SNDHWM, &send_hwm, sizeof (send_hwm));
+        assert (rc == 0);
+        rc = zmq_connect (connect_socket, "inproc://a");
+        assert (rc == 0);
 
-    // There should be now 4 messages pending, consume them.
-    for (int i = 0; i != 4; i++) {
-        rc = zmq_recv (sb, NULL, 0, 0);
+        // Set up bind socket
+        bind_socket = zmq_socket (ctx, ZMQ_PULL);
+        assert (bind_socket);
+        rc = zmq_setsockopt (bind_socket, ZMQ_RCVHWM, &recv_hwm, sizeof (recv_hwm));
+        assert (rc == 0);
+        rc = zmq_bind (bind_socket, "inproc://a");
         assert (rc == 0);
     }
 
+    // Send until we block
+    int send_count = 0;
+    while (send_count < MAX_SENDS && zmq_send (connect_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
+        ++send_count;
+
+    // Now receive all sent messages
+    int recv_count = 0;
+    while (zmq_recv (bind_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
+        ++recv_count;
+
+    assert (send_count == recv_count);
+
     // Now it should be possible to send one more.
-    rc = zmq_send (sc, NULL, 0, 0);
+    rc = zmq_send (connect_socket, NULL, 0, 0);
     assert (rc == 0);
 
     //  Consume the remaining message.
-    rc = zmq_recv (sb, NULL, 0, 0);
+    rc = zmq_recv (bind_socket, NULL, 0, 0);
+    assert (rc == 0);
+
+    // Clean up
+    rc = zmq_close (connect_socket);
+    assert (rc == 0);
+
+    rc = zmq_close (bind_socket);
+    assert (rc == 0);
+
+    rc = zmq_ctx_term (ctx);
+    assert (rc == 0);
+
+    return send_count;
+}
+
+int test_inproc_bind_first (int send_hwm, int recv_hwm)
+{
+    return count_msg(send_hwm, recv_hwm, BIND_FIRST);
+}
+
+int test_inproc_connect_first (int send_hwm, int recv_hwm)
+{
+    return count_msg(send_hwm, recv_hwm, CONNECT_FIRST);
+}
+
+int test_inproc_connect_and_close_first (int send_hwm, int recv_hwm)
+{
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+    int rc;
+
+    // Set up connect socket
+    void *connect_socket = zmq_socket (ctx, ZMQ_PUSH);
+    assert (connect_socket);
+    rc = zmq_setsockopt (connect_socket, ZMQ_SNDHWM, &send_hwm, sizeof (send_hwm));
+    assert (rc == 0);
+    rc = zmq_connect (connect_socket, "inproc://a");
+    assert (rc == 0);
+
+    // Send until we block
+    int send_count = 0;
+    while (send_count < MAX_SENDS && zmq_send (connect_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
+        ++send_count;
+
+    // Close connect
+    rc = zmq_close (connect_socket);
+    assert (rc == 0);
+
+    // Set up bind socket
+    void *bind_socket = zmq_socket (ctx, ZMQ_PULL);
+    assert (bind_socket);
+    rc = zmq_setsockopt (bind_socket, ZMQ_RCVHWM, &recv_hwm, sizeof (recv_hwm));
     assert (rc == 0);
+    rc = zmq_bind (bind_socket, "inproc://a");
+    assert (rc == 0);
+
+    // Now receive all sent messages
+    int recv_count = 0;
+    while (zmq_recv (bind_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
+        ++recv_count;
+
+    assert (send_count == recv_count);
 
-    rc = zmq_close (sc);
+    // Clean up
+    rc = zmq_close (bind_socket);
     assert (rc == 0);
 
-    rc = zmq_close (sb);
+    rc = zmq_ctx_term (ctx);
     assert (rc == 0);
 
-    rc = zmq_term (ctx);
+    return send_count;
+}
+
+int test_inproc_bind_and_close_first (int send_hwm, int recv_hwm)
+{
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+    int rc;
+
+    // Set up bind socket
+    void *bind_socket = zmq_socket (ctx, ZMQ_PUSH);
+    assert (bind_socket);
+    rc = zmq_setsockopt (bind_socket, ZMQ_SNDHWM, &send_hwm, sizeof (send_hwm));
+    assert (rc == 0);
+    rc = zmq_bind (bind_socket, "inproc://a");
     assert (rc == 0);
 
-	return 0;
+    // Send until we block
+    int send_count = 0;
+    while (send_count < MAX_SENDS && zmq_send (bind_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
+        ++send_count;
+
+    // Close bind
+    rc = zmq_close (bind_socket);
+    assert (rc == 0);
+
+    /* Can't currently do connect without then wiring up a bind as things hang, this needs top be fixed.
+    // Set up connect socket
+    void *connect_socket = zmq_socket (ctx, ZMQ_PULL);
+    assert (connect_socket);
+    rc = zmq_setsockopt (connect_socket, ZMQ_RCVHWM, &recv_hwm, sizeof (recv_hwm));
+    assert (rc == 0);
+    rc = zmq_connect (connect_socket, "inproc://a");
+    assert (rc == 0);
+
+    // Now receive all sent messages
+    int recv_count = 0;
+    while (zmq_recv (connect_socket, NULL, 0, ZMQ_DONTWAIT) == 0)
+        ++recv_count;
+
+    assert (send_count == recv_count);
+    */
+
+    // Clean up
+    //rc = zmq_close (connect_socket);
+    //assert (rc == 0);
+
+    rc = zmq_ctx_term (ctx);
+    assert (rc == 0);
+
+    return send_count;
+}
+
+int main (void)
+{
+    setup_test_environment();
+    
+    int count;
+
+    // Default values are 1000 on send and 1000 one receive, so 2000 total
+    count = test_defaults ();
+    assert (count == 2000);
+
+    // Infinite send and receive buffer
+    count = test_inproc_bind_first (0, 0);
+    assert (count == MAX_SENDS);
+    count = test_inproc_connect_first (0, 0);
+    assert (count == MAX_SENDS);
+
+    // Infinite send buffer
+    count = test_inproc_bind_first (1, 0);
+    assert (count == MAX_SENDS);
+    count = test_inproc_connect_first (1, 0);
+    assert (count == MAX_SENDS);
+
+    // Infinite receive buffer
+    count = test_inproc_bind_first (0, 1);
+    assert (count == MAX_SENDS);
+    count = test_inproc_connect_first (0, 1);
+    assert (count == MAX_SENDS);
+
+    // Send and recv buffers hwm 1, so total that can be queued is 2
+    count = test_inproc_bind_first (1, 1);
+    assert (count == 2);
+    count = test_inproc_connect_first (1, 1);
+    assert (count == 2);
+
+    // Send hwm of 1, send before bind so total that can be queued is 1
+    count = test_inproc_connect_and_close_first (1, 0);
+    assert (count == 1);
+
+    // Send hwm of 1, send from bind side before connect so total that can be queued should be 1,
+    // however currently all messages get thrown away before the connect.  BUG?
+    count = test_inproc_bind_and_close_first (1, 0);
+    //assert (count == 1);
+
+    return 0;
 }