rbczmq 1.7.1 → 1.7.2

data/ext/zeromq/tests/test_invalid_rep.cpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2010-2011 250bpm s.r.o.
-    Copyright (c) 2011 VMware, Inc.
-    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.
 
@@ -19,23 +17,21 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "../include/zmq.h"
-#include <stdio.h>
-
-#undef NDEBUG
-#include <assert.h>
+#include "testutil.hpp"
 
 int main (void)
 {
-    fprintf (stderr, "test_invalid_rep running...\n");
-
+    setup_test_environment();
     //  Create REQ/ROUTER wiring.
-    void *ctx = zmq_init (1);
+    void *ctx = zmq_ctx_new ();
     assert (ctx);
+    
     void *router_socket = zmq_socket (ctx, ZMQ_ROUTER);
     assert (router_socket);
+    
     void *req_socket = zmq_socket (ctx, ZMQ_REQ);
     assert (req_socket);
+    
     int linger = 0;
     int rc = zmq_setsockopt (router_socket, ZMQ_LINGER, &linger, sizeof (int));
     assert (rc == 0);
@@ -77,14 +73,14 @@ int main (void)
     //  Check whether we've got the valid reply.
     rc = zmq_recv (req_socket, body, sizeof (body), 0);
     assert (rc == 1);
-	assert (body [0] == 'b');
+    assert (body [0] == 'b');
 
     //  Tear down the wiring.
     rc = zmq_close (router_socket);
     assert (rc == 0);
     rc = zmq_close (req_socket);
     assert (rc == 0);
-    rc = zmq_term (ctx);
+    rc = zmq_ctx_term (ctx);
     assert (rc == 0);
 
     return 0;

data/ext/zeromq/tests/test_iov.cpp

@@ -0,0 +1,106 @@
+/*
+    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"
+
+// XSI vector I/O
+#if defined ZMQ_HAVE_UIO
+#include <sys/uio.h>
+#else
+struct iovec {
+    void *iov_base;
+    size_t iov_len;
+};
+#endif
+
+void do_check(void* sb, void* sc, unsigned int msgsz)
+{
+    setup_test_environment();
+    int rc;
+    int sum =0;
+    for (int i = 0; i < 10; i++)
+    {
+        zmq_msg_t msg;
+        zmq_msg_init_size(&msg, msgsz);
+        void * data = zmq_msg_data(&msg);
+        memcpy(data,&i, sizeof(int));
+        rc = zmq_msg_send(&msg,sc,i==9 ? 0 :ZMQ_SNDMORE);
+        assert (rc == (int)msgsz);
+        zmq_msg_close(&msg);
+        sum += i;
+    }
+
+    struct iovec ibuffer[32] ;
+    memset(&ibuffer[0], 0, sizeof(ibuffer));
+    
+    size_t count = 10;
+    rc = zmq_recviov(sb,&ibuffer[0],&count,0);
+    assert (rc == 10);
+
+    int rsum=0;
+    for(;count;--count)
+    {
+        int v;
+        memcpy(&v,ibuffer[count-1].iov_base,sizeof(int));
+        rsum += v;
+        assert(ibuffer[count-1].iov_len == msgsz);
+        // free up the memory
+        free(ibuffer[count-1].iov_base);
+    }
+    
+    assert ( sum == rsum );
+
+}
+
+int main (void)
+{
+    void *ctx = zmq_ctx_new ();
+    assert (ctx);
+    int rc;
+   
+    void *sb = zmq_socket (ctx, ZMQ_PULL);
+    assert (sb);
+  
+    rc = zmq_bind (sb, "inproc://a");
+    assert (rc == 0);
+
+    zmq_sleep(1);
+    void *sc = zmq_socket (ctx, ZMQ_PUSH);
+  
+    rc = zmq_connect (sc, "inproc://a");
+    assert (rc == 0);
+
+
+    // message bigger than vsm max
+    do_check(sb,sc,100);
+
+    // message smaller than vsm max
+    do_check(sb,sc,10);
+
+    rc = zmq_close (sc);
+    assert (rc == 0);
+
+    rc = zmq_close (sb);
+    assert (rc == 0);
+
+    rc = zmq_ctx_term (ctx);
+    assert (rc == 0);
+
+    return 0;
+}

data/ext/zeromq/tests/test_issue_566.cpp

@@ -0,0 +1,85 @@
+/*
+    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"
+
+//  Issue 566 describes a problem in libzmq v4.0.0 where a dealer to router
+//  connection would fail randomly. The test works when the two sockets are
+//  on the same context, and failed when they were on separate contexts.
+//  Fixed by https://github.com/zeromq/libzmq/commit/be25cf.
+
+int main (void)
+{
+    setup_test_environment();
+    
+    void *ctx1 = zmq_ctx_new ();
+    assert (ctx1);
+
+    void *ctx2 = zmq_ctx_new ();
+    assert (ctx2);
+
+    void *router = zmq_socket (ctx1, ZMQ_ROUTER);    
+    int on = 1;
+    int rc = zmq_setsockopt (router, ZMQ_ROUTER_MANDATORY, &on, sizeof (on));
+    assert (rc == 0);
+    rc = zmq_bind (router, "tcp://127.0.0.1:5555");
+    assert (rc != -1);
+ 
+    //  Repeat often enough to be sure this works as it should
+    for (int cycle = 0; cycle < 100; cycle++) {
+        //  Create dealer with unique explicit identity
+        //  We assume the router learns this out-of-band
+        void *dealer = zmq_socket (ctx2, ZMQ_DEALER);
+        char identity [10];
+        sprintf (identity, "%09d", cycle);
+        rc = zmq_setsockopt (dealer, ZMQ_IDENTITY, identity, 10);
+        assert (rc == 0);
+        int rcvtimeo = 1000;
+        rc = zmq_setsockopt (dealer, ZMQ_RCVTIMEO, &rcvtimeo, sizeof (int));
+        assert (rc == 0);
+        rc = zmq_connect (dealer, "tcp://127.0.0.1:5555");
+        assert (rc == 0);
+
+        //  Router will try to send to dealer, at short intervals.
+        //  It typically takes 2-5 msec for the connection to establish
+        //  on a loopback interface, but we'll allow up to one second
+        //  before failing the test (e.g. for running on a debugger or
+        //  a very slow system).
+        for (int attempt = 0; attempt < 500; attempt++) {
+            zmq_poll (0, 0, 2);
+            rc = zmq_send (router, identity, 10, ZMQ_SNDMORE);
+            if (rc == -1 && errno == EHOSTUNREACH)
+                continue;
+            assert (rc == 10);
+            rc = zmq_send (router, "HELLO", 5, 0);
+            assert (rc == 5);
+            break;
+        }
+        uint8_t buffer [5];
+        rc = zmq_recv (dealer, buffer, 5, 0);
+        assert (rc == 5);
+        assert (memcmp (buffer, "HELLO", 5) == 0);
+        close_zero_linger (dealer);
+    }
+    zmq_close (router);
+    zmq_ctx_destroy (ctx1);
+    zmq_ctx_destroy (ctx2);
+
+    return 0;
+}

data/ext/zeromq/tests/test_last_endpoint.cpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2007-2012 iMatix Corporation
-    Copyright (c) 2011 250bpm s.r.o.
-    Copyright (c) 2007-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.
 
@@ -19,42 +17,40 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "../include/zmq.h"
-#include <string.h>
-
-#undef NDEBUG
-#include <assert.h>
+#include "testutil.hpp"
 
 static void do_bind_and_verify (void *s, const char *endpoint)
 {
     int rc = zmq_bind (s, endpoint);
     assert (rc == 0);
-
-    char test [255];
-    size_t siz = 255;
-    rc = zmq_getsockopt (s, ZMQ_LAST_ENDPOINT, test, &siz);
-    assert (rc == 0 && strcmp (test, endpoint) == 0);
+    char reported [255];
+    size_t size = 255;
+    rc = zmq_getsockopt (s, ZMQ_LAST_ENDPOINT, reported, &size);
+    assert (rc == 0 && strcmp (reported, endpoint) == 0);
 }
 
 int main (void)
 {
+    setup_test_environment();
     //  Create the infrastructure
-    void *ctx = zmq_init (1);
+    void *ctx = zmq_ctx_new ();
     assert (ctx);
 
     void *sb = zmq_socket (ctx, ZMQ_ROUTER);
     assert (sb);
+    int val = 0;
+    int rc = zmq_setsockopt (sb, ZMQ_LINGER, &val, sizeof (val));
+    assert (rc == 0);
 
     do_bind_and_verify (sb, "tcp://127.0.0.1:5560");
     do_bind_and_verify (sb, "tcp://127.0.0.1:5561");
-    do_bind_and_verify (sb, "ipc:///tmp/testep");
 
-    int rc = zmq_close (sb);
+    rc = zmq_close (sb);
     assert (rc == 0);
     
-    rc = zmq_term (ctx);
+    rc = zmq_ctx_term (ctx);
     assert (rc == 0);
 
-    return 0;
+    return 0 ;
 }
 

data/ext/zeromq/tests/test_linger.cpp

@@ -0,0 +1,93 @@
+/*
+    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/>.
+*/
+
+//  This test case should be moved or added to issues repository, perhaps,
+//  or alternatively we can change policy that issue test cases should be 
+//  added to the main build when they're useful. -- PH 2013/09/02
+
+#include "testutil.hpp"
+
+#define URL "tcp://127.0.0.1:5560"
+
+//  Sender connects a PUSH socket and sends a message of a given size,
+//  closing the socket and terminating the context immediately.
+//  LINGER should prevent this from dropping messages.
+
+static void sender (void *vsize)
+{
+    void *context = zmq_ctx_new ();
+    void *push = zmq_socket (context, ZMQ_PUSH);
+    size_t size = ((size_t *) vsize) [0];
+
+    int rc = zmq_connect (push, URL);
+    assert (rc == 0);
+  
+    zmq_msg_t msg;
+    rc = zmq_msg_init_size (&msg, size);
+    assert (rc == 0);
+
+    char *buf = (char *) zmq_msg_data (&msg);
+    assert (buf != NULL);
+    memset (buf, 'x', size);
+
+    rc = zmq_msg_send (&msg, push, 0);
+    assert ((size_t) rc == size);
+
+    rc = zmq_msg_close (&msg);
+    assert (rc == 0);
+
+    rc = zmq_close (push);
+    assert (rc == 0);
+
+    rc = zmq_ctx_term (context);
+    assert (rc == 0);
+}
+
+int main (void)
+{
+    void *context = zmq_ctx_new ();
+    void *pull = zmq_socket (context, ZMQ_PULL);
+    zmq_msg_t msg;
+    
+    int rc = zmq_bind (pull, URL);
+    assert (rc == 0);
+    
+    //  Symptom of test failure is message never received
+    int rcvtimeo = 100;
+    rc = zmq_setsockopt (pull, ZMQ_RCVTIMEO, &rcvtimeo, sizeof (int));
+    assert (rc == 0);
+    
+    //  Single test case that currently provokes failure in libzmq
+    //  Note that socket will wait as long as receive timeout, before
+    //  returning a "resource unavailable" or an assertion failure in
+    //  poller_base.cpp:31.
+    size_t size = 4000000;
+    
+    //  Start the sender thread and get message
+    void *send_thread = zmq_threadstart (&sender, (void *) &size);
+    zmq_msg_init (&msg);
+    rc = zmq_msg_recv (&msg, pull, 0);
+    assert ((size_t) rc == size);
+    zmq_msg_close (&msg);
+    zmq_threadclose (send_thread);
+    
+    zmq_close (pull);
+    zmq_ctx_term (context);
+    return 0;
+}

data/ext/zeromq/tests/test_monitor.cpp

@@ -1,7 +1,5 @@
 /*
-    Copyright (c) 2007-2012 iMatix Corporation
-    Copyright (c) 2011 250bpm s.r.o.
-    Copyright (c) 2007-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.
 
@@ -19,10 +17,6 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "../include/zmq.h"
-#include "../include/zmq_utils.h"
-#include <pthread.h>
-#include <string.h>
 #include "testutil.hpp"
 
 // REQ socket events handled
@@ -32,167 +26,163 @@ static int req2_socket_events;
 // REP socket events handled
 static int rep_socket_events;
 
-const char *addr;
+std::string addr ;
 
-extern "C"
+static bool read_msg(void* s, zmq_event_t& event, std::string& ep)
 {
-    // REQ socket monitor thread
-    static void *req_socket_monitor (void *ctx)
-    {
-        zmq_event_t event;
-        int rc;
-
-        void *s = zmq_socket (ctx, ZMQ_PAIR);
-        assert (s);
-
-        rc = zmq_connect (s, "inproc://monitor.req");
-        assert (rc == 0);
-        while (true) {
-            zmq_msg_t msg;
-            zmq_msg_init (&msg);
-            rc = zmq_recvmsg (s, &msg, 0);
-            if (rc == -1 && zmq_errno() == ETERM) break;
-            assert (rc != -1);
-            memcpy (&event, zmq_msg_data (&msg), sizeof (event));
-            switch (event.event) {
+    int rc ;
+    zmq_msg_t msg1;  // binary part
+    zmq_msg_init (&msg1);
+    zmq_msg_t msg2;  //  address part
+    zmq_msg_init (&msg2);
+    rc = zmq_msg_recv (&msg1, s, 0);
+    if (rc == -1 && zmq_errno() == ETERM)
+        return true ;
+
+    assert (rc != -1);
+    assert (zmq_msg_more(&msg1) != 0);
+    rc = zmq_msg_recv (&msg2, s, 0);
+    if (rc == -1 && zmq_errno() == ETERM)
+        return true;
+
+    assert (rc != -1);
+    assert (zmq_msg_more(&msg2) == 0);
+    // copy binary data to event struct
+    const char* data = (char*)zmq_msg_data(&msg1);
+    memcpy(&event.event, data, sizeof(event.event));
+    memcpy(&event.value, data+sizeof(event.event), sizeof(event.value));
+    // copy address part
+    ep = std::string((char*)zmq_msg_data(&msg2), zmq_msg_size(&msg2));
+
+    if (event.event == ZMQ_EVENT_MONITOR_STOPPED)
+        return true;
+
+    return false;
+}
+
+
+// REQ socket monitor thread
+static void req_socket_monitor (void *ctx)
+{
+    zmq_event_t event;
+    std::string ep ;
+    int rc;
+
+    void *s = zmq_socket (ctx, ZMQ_PAIR);
+    assert (s);
+
+    rc = zmq_connect (s, "inproc://monitor.req");
+    assert (rc == 0);
+    while (!read_msg(s, event, ep)) {
+        assert (ep == addr);
+        switch (event.event) {
             case ZMQ_EVENT_CONNECTED:
-                assert (event.data.connected.fd > 0);
-                assert (!strcmp (event.data.connected.addr, addr));
+                assert (event.value > 0);
                 req_socket_events |= ZMQ_EVENT_CONNECTED;
                 req2_socket_events |= ZMQ_EVENT_CONNECTED;
                 break;
             case ZMQ_EVENT_CONNECT_DELAYED:
-                assert (event.data.connect_delayed.err != 0);
-                assert (!strcmp (event.data.connect_delayed.addr, addr));
+                assert (event.value != 0);
                 req_socket_events |= ZMQ_EVENT_CONNECT_DELAYED;
                 break;
             case ZMQ_EVENT_CLOSE_FAILED:
-                assert (event.data.close_failed.err != 0);
-                assert (!strcmp (event.data.close_failed.addr, addr));
+                assert (event.value != 0);
                 req_socket_events |= ZMQ_EVENT_CLOSE_FAILED;
                 break;
             case ZMQ_EVENT_CLOSED:
-                assert (event.data.closed.fd != 0);
-                assert (!strcmp (event.data.closed.addr, addr));
+                assert (event.value != 0);
                 req_socket_events |= ZMQ_EVENT_CLOSED;
                 break;
             case ZMQ_EVENT_DISCONNECTED:
-                assert (event.data.disconnected.fd != 0);
-                assert (!strcmp (event.data.disconnected.addr, addr));
+                assert (event.value != 0);
                 req_socket_events |= ZMQ_EVENT_DISCONNECTED;
                 break;
-            }
         }
-        zmq_close (s);
-        return NULL;
     }
+    zmq_close (s);
 }
 
-extern "C"
+// 2nd REQ socket monitor thread
+static void req2_socket_monitor (void *ctx)
 {
-    // 2nd REQ socket monitor thread
-    static void *req2_socket_monitor (void *ctx)
-    {
-        zmq_event_t event;
-        int rc;
-
-        void *s = zmq_socket (ctx, ZMQ_PAIR);
-        assert (s);
-
-        rc = zmq_connect (s, "inproc://monitor.req2");
-        assert (rc == 0);
-        while (true) {
-            zmq_msg_t msg;
-            zmq_msg_init (&msg);
-            rc = zmq_recvmsg (s, &msg, 0);
-            if (rc == -1 && zmq_errno() == ETERM) break;
-            assert (rc != -1);
-            memcpy (&event, zmq_msg_data (&msg), sizeof (event));
-            switch (event.event) {
+    zmq_event_t event;
+    std::string ep ;
+    int rc;
+
+    void *s = zmq_socket (ctx, ZMQ_PAIR);
+    assert (s);
+
+    rc = zmq_connect (s, "inproc://monitor.req2");
+    assert (rc == 0);
+    while (!read_msg(s, event, ep)) {
+        assert (ep == addr);
+        switch (event.event) {
             case ZMQ_EVENT_CONNECTED:
-                assert (event.data.connected.fd > 0);
-                assert (!strcmp (event.data.connected.addr, addr));
+                assert (event.value > 0);
                 req2_socket_events |= ZMQ_EVENT_CONNECTED;
                 break;
             case ZMQ_EVENT_CLOSED:
-                assert (event.data.closed.fd != 0);
-                assert (!strcmp (event.data.closed.addr, addr));
+                assert (event.value != 0);
                 req2_socket_events |= ZMQ_EVENT_CLOSED;
                 break;
-            }
         }
-        zmq_close (s);
-        return NULL;
     }
+    zmq_close (s);
 }
 
-
-extern "C"
+// REP socket monitor thread
+static void rep_socket_monitor (void *ctx)
 {
-    // REP socket monitor thread
-    static void *rep_socket_monitor (void *ctx)
-    {
-        zmq_event_t event;
-        int rc;
-
-        void *s = zmq_socket (ctx, ZMQ_PAIR);
-        assert (s);
-
-        rc = zmq_connect (s, "inproc://monitor.rep");
-        assert (rc == 0);
-        while (true) {
-            zmq_msg_t msg;
-            zmq_msg_init (&msg);
-            rc = zmq_recvmsg (s, &msg, 0);
-            if (rc == -1 && zmq_errno() == ETERM) break;
-            assert (rc != -1);
-            memcpy (&event, zmq_msg_data (&msg), sizeof (event));
-            switch (event.event) {
+    zmq_event_t event;
+    std::string ep ;
+    int rc;
+
+    void *s = zmq_socket (ctx, ZMQ_PAIR);
+    assert (s);
+
+    rc = zmq_connect (s, "inproc://monitor.rep");
+    assert (rc == 0);
+    while (!read_msg(s, event, ep)) {
+        assert (ep == addr);
+        switch (event.event) {
             case ZMQ_EVENT_LISTENING:
-                assert (event.data.listening.fd > 0);
-                assert (!strcmp (event.data.listening.addr, addr));
+                assert (event.value > 0);
                 rep_socket_events |= ZMQ_EVENT_LISTENING;
                 break;
             case ZMQ_EVENT_ACCEPTED:
-                assert (event.data.accepted.fd > 0);
-                assert (!strcmp (event.data.accepted.addr, addr));
+                assert (event.value > 0);
                 rep_socket_events |= ZMQ_EVENT_ACCEPTED;
                 break;
             case ZMQ_EVENT_CLOSE_FAILED:
-                assert (event.data.close_failed.err != 0);
-                assert (!strcmp (event.data.close_failed.addr, addr));
+                assert (event.value != 0);
                 rep_socket_events |= ZMQ_EVENT_CLOSE_FAILED;
                 break;
             case ZMQ_EVENT_CLOSED:
-                assert (event.data.closed.fd != 0);
-                assert (!strcmp (event.data.closed.addr, addr));
+                assert (event.value != 0);
                 rep_socket_events |= ZMQ_EVENT_CLOSED;
                 break;
             case ZMQ_EVENT_DISCONNECTED:
-                assert (event.data.disconnected.fd != 0);
-                assert (!strcmp (event.data.disconnected.addr, addr));
+                assert (event.value != 0);
                 rep_socket_events |= ZMQ_EVENT_DISCONNECTED;
                 break;
-            }
-            zmq_msg_close (&msg);
         }
-        zmq_close (s);
-        return NULL;
     }
+    zmq_close (s);
 }
 
 int main (void)
 {
+    setup_test_environment();
     int rc;
     void *req;
     void *req2;
     void *rep;
-    pthread_t threads [3];
+    void* threads [3];
 
     addr = "tcp://127.0.0.1:5560";
 
     //  Create the infrastructure
-    void *ctx = zmq_init (1);
+    void *ctx = zmq_ctx_new ();
     assert (ctx);
 
     // REP socket
@@ -200,7 +190,7 @@ int main (void)
     assert (rep);
 
     // Assert supported protocols
-    rc =  zmq_socket_monitor (rep, addr, 0);
+    rc =  zmq_socket_monitor (rep, addr.c_str(), 0);
     assert (rc == -1);
     assert (zmq_errno() == EPROTONOSUPPORT);
 
@@ -211,12 +201,8 @@ int main (void)
     // REP socket monitor, all events
     rc = zmq_socket_monitor (rep, "inproc://monitor.rep", ZMQ_EVENT_ALL);
     assert (rc == 0);
-    rc = pthread_create (&threads [0], NULL, rep_socket_monitor, ctx);
-    assert (rc == 0);
-
-    rc = zmq_bind (rep, addr);
-    assert (rc == 0);
-
+    threads [0] = zmq_threadstart(&rep_socket_monitor, ctx);
+    
     // REQ socket
     req = zmq_socket (ctx, ZMQ_REQ);
     assert (req);
@@ -224,12 +210,18 @@ int main (void)
     // REQ socket monitor, all events
     rc = zmq_socket_monitor (req, "inproc://monitor.req", ZMQ_EVENT_ALL);
     assert (rc == 0);
-    rc = pthread_create (&threads [1], NULL, req_socket_monitor, ctx);
+    threads [1] = zmq_threadstart(&req_socket_monitor, ctx);
+    zmq_sleep(1);
+
+    // Bind REQ and REP
+    rc = zmq_bind (rep, addr.c_str());
     assert (rc == 0);
 
-    rc = zmq_connect (req, addr);
+    rc = zmq_connect (req, addr.c_str());
     assert (rc == 0);
 
+    bounce (rep, req);
+    
     // 2nd REQ socket
     req2 = zmq_socket (ctx, ZMQ_REQ);
     assert (req2);
@@ -237,23 +229,17 @@ int main (void)
     // 2nd REQ socket monitor, connected event only
     rc = zmq_socket_monitor (req2, "inproc://monitor.req2", ZMQ_EVENT_CONNECTED);
     assert (rc == 0);
-    rc = pthread_create (&threads [2], NULL, req2_socket_monitor, ctx);
-    assert (rc == 0);
+    threads [2] = zmq_threadstart(&req2_socket_monitor, ctx);
 
-    rc = zmq_connect (req2, addr);
+    rc = zmq_connect (req2, addr.c_str());
     assert (rc == 0);
 
-    bounce (rep, req);
-
-    // Allow a window for socket events as connect can be async
-    zmq_sleep (1);
-
     // Close the REP socket
     rc = zmq_close (rep);
     assert (rc == 0);
 
     // Allow some time for detecting error states
-    zmq_sleep (1);
+    zmq_sleep(1);
 
     //  Close the REQ socket
     rc = zmq_close (req);
@@ -263,10 +249,7 @@ int main (void)
     rc = zmq_close (req2);
     assert (rc == 0);
 
-    // Allow for closed or disconnected events to bubble up
-    zmq_sleep (1);
-
-    zmq_term (ctx);
+    zmq_ctx_term (ctx);
 
     // Expected REP socket events
     assert (rep_socket_events & ZMQ_EVENT_LISTENING);
@@ -282,8 +265,8 @@ int main (void)
     assert (req2_socket_events & ZMQ_EVENT_CONNECTED);
     assert (!(req2_socket_events & ZMQ_EVENT_CLOSED));
 
-    pthread_exit (NULL);
+    for (unsigned int i = 0; i < 3; ++i)
+        zmq_threadclose(threads [i]);
 
     return 0 ;
 }
-