errno errors reported in tests

Till now when a test failed the value or errno haven't
been reported. This patch fixes the problem.

Signed-off-by: Martin Sustrik <sustrik@250bpm.com>

23 files changed, 392 insertions, 370 deletions

diff --git a/tests/backlog.cpp b/tests/backlog.cpp
index f215ec5..629503c 100644
--- a/tests/backlog.cpp
+++ b/tests/backlog.cpp
@@ -35,13 +35,13 @@ extern "C"
         void *push;
 
         push = xs_socket (ctx_, XS_PUSH);
-        assert (push);
+        errno_assert (push);
         rc = xs_connect (push, "ipc:///tmp/test-backlog");
-        assert (rc >= 0);
+        errno_assert (rc >= 0);
         rc = xs_send (push, NULL, 0, 0);
-        assert (rc == 0);
+        errno_assert (rc == 0);
         rc = xs_close (push);
-        assert (rc == 0);
+        errno_assert (rc == 0);
     }
 #endif
     static void tcp_worker (void *ctx_)
@@ -50,14 +50,14 @@ extern "C"
         void *push;
 
         push = xs_socket (ctx_, XS_PUSH);
-        assert (push);
+        errno_assert (push);
         rc = xs_connect (push, "tcp://127.0.0.1:5560");
-        assert (rc >= 0);
+        errno_assert (rc >= 0);
 
         rc = xs_send (push, NULL, 0, 0);
-        assert (rc == 0);
+        errno_assert (rc == 0);
         rc = xs_close (push);
-        assert (rc == 0);
+        errno_assert (rc == 0);
     }
 }
 #endif
@@ -77,29 +77,28 @@ int XS_TEST_MAIN ()
     //  Test the exhaustion on IPC backlog.
 #if !defined XS_HAVE_WINDOWS && !defined XS_HAVE_OPENVMS
     ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
 
     pull = xs_socket (ctx, XS_PULL);
-    assert (pull);
+    errno_assert (pull);
     backlog = BACKLOG;
     rc = xs_setsockopt (pull, XS_BACKLOG, &backlog, sizeof (backlog));
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_bind (pull, "ipc:///tmp/test-backlog");
-    assert (rc >= 0);
+    errno_assert (rc >= 0);
 
-    
     for (i = 0; i < PARALLEL_CONNECTS; i++)
         threads [i] = thread_create (ipc_worker, ctx);
 
     for (i = 0; i < PARALLEL_CONNECTS; i++) {
         rc = xs_recv (pull, NULL, 0, 0);
-        assert (rc == 0);
+        errno_assert (rc == 0);
     }
     
     rc = xs_close (pull);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     for (i = 0; i < PARALLEL_CONNECTS; i++)
         thread_join (threads [i]);
@@ -108,28 +107,28 @@ int XS_TEST_MAIN ()
     //  Test the exhaustion on TCP backlog.
 
     ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
 
     pull = xs_socket (ctx, XS_PULL);
-    assert (pull);
+    errno_assert (pull);
     backlog = BACKLOG;
     rc = xs_setsockopt (pull, XS_BACKLOG, &backlog, sizeof (backlog));
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_bind (pull, "tcp://127.0.0.1:5560");
-    assert (rc >= 0);
+    errno_assert (rc >= 0);
 
     for (i = 0; i < PARALLEL_CONNECTS; i++)
         threads [i] = thread_create (tcp_worker, ctx);
 
     for (i = 0; i < PARALLEL_CONNECTS; i++) {
         rc = xs_recv (pull, NULL, 0, 0);
-        assert (rc == 0);
+        errno_assert (rc == 0);
     }
     
     rc = xs_close (pull);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     for (i = 0; i < PARALLEL_CONNECTS; i++)
         thread_join (threads [i]);
diff --git a/tests/emptyctx.cpp b/tests/emptyctx.cpp
index 1448254..0c95446 100644
--- a/tests/emptyctx.cpp
+++ b/tests/emptyctx.cpp
@@ -27,9 +27,9 @@ int XS_TEST_MAIN ()
     //  This is a very simple test to check whether everything works OK when
     //  context is terminated even before I/O threads were launched.
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
     int rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     return 0 ;
 }
diff --git a/tests/invalid_rep.cpp b/tests/invalid_rep.cpp
index 93118b6..c65b600 100644
--- a/tests/invalid_rep.cpp
+++ b/tests/invalid_rep.cpp
@@ -27,24 +27,24 @@ int XS_TEST_MAIN ()
 
     //  Create REQ/XREP wiring.
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
     void *xrep_socket = xs_socket (ctx, XS_XREP);
-    assert (xrep_socket);
+    errno_assert (xrep_socket);
     void *req_socket = xs_socket (ctx, XS_REQ);
-    assert (req_socket);
+    errno_assert (req_socket);
     int linger = 0;
     int rc = xs_setsockopt (xrep_socket, XS_LINGER, &linger, sizeof (int));
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_setsockopt (req_socket, XS_LINGER, &linger, sizeof (int));
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_bind (xrep_socket, "inproc://hi");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     rc = xs_connect (req_socket, "inproc://hi");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     //  Initial request.
     rc = xs_send (req_socket, "r", 1, 0);
-    assert (rc == 1);
+    errno_assert (rc == 1);
 
     //  Receive the request.
     char addr [32];
@@ -52,36 +52,36 @@ int XS_TEST_MAIN ()
     char bottom [1];
     char body [1];
     addr_size = xs_recv (xrep_socket, addr, sizeof (addr), 0);
-    assert (addr_size >= 0);
+    errno_assert (addr_size >= 0);
     rc = xs_recv (xrep_socket, bottom, sizeof (bottom), 0);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_recv (xrep_socket, body, sizeof (body), 0);
-    assert (rc == 1);
+    errno_assert (rc == 1);
 
     //  Send invalid reply.
     rc = xs_send (xrep_socket, addr, addr_size, 0);
-    assert (rc == addr_size);
+    errno_assert (rc == addr_size);
 
     //  Send valid reply.
     rc = xs_send (xrep_socket, addr, addr_size, XS_SNDMORE);
-    assert (rc == addr_size);
+    errno_assert (rc == addr_size);
     rc = xs_send (xrep_socket, bottom, 0, XS_SNDMORE);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_send (xrep_socket, "b", 1, 0);
-    assert (rc == 1);
+    errno_assert (rc == 1);
 
     //  Check whether we've got the valid reply.
     rc = xs_recv (req_socket, body, sizeof (body), 0);
-    assert (rc == 1);
+    errno_assert (rc == 1);
 	assert (body [0] == 'b');
 
     //  Tear down the wiring.
     rc = xs_close (xrep_socket);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_close (req_socket);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     return 0;
 }
diff --git a/tests/libzmq21.cpp b/tests/libzmq21.cpp
index ecf271b..ea02f7d 100644
--- a/tests/libzmq21.cpp
+++ b/tests/libzmq21.cpp
@@ -50,14 +50,14 @@ int XS_TEST_MAIN ()
 
     //  Create the basic infrastructure.
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
     void *pub = xs_socket (ctx, XS_PUB);
-    assert (pub);
+    errno_assert (pub);
     int protocol = 1;
     int rc = xs_setsockopt (pub, XS_PROTOCOL, &protocol, sizeof (protocol));
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_bind (pub, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     int oldsub = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
     struct sockaddr_in address;
@@ -65,7 +65,7 @@ int XS_TEST_MAIN ()
     address.sin_addr.s_addr = inet_addr ("127.0.0.1");
     address.sin_port = htons (5560);
     rc = connect (oldsub, (struct sockaddr*) &address, sizeof (address));
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     //  Wait a while to allow connection to be accepted on the publisher side.
     sleep (1);
@@ -73,46 +73,46 @@ int XS_TEST_MAIN ()
     //  Send a message and check whether it arrives although there was no
     //  subscription sent.
     rc = xs_send (pub, "ABC", 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
     char buf [5];
     rc = recv (oldsub, buf, sizeof (buf), 0);
-    assert (rc == 5);
+    errno_assert (rc == 5);
     assert (!memcmp (buf, "\x04\0ABC", 5));
 
     //  Tear down the infrastructure.
     rc = xs_close (pub);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 #if defined XS_HAVE_WINDOWS
     rc = closesocket (oldsub);
     assert (rc != SOCKET_ERROR);
 #else
     rc = close (oldsub);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 #endif
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     //  Second, test the 0MQ/2.1-style publisher with up-to-date subscriber.
     
     //  Create the basic infrastructure.
     ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
     void *sub = xs_socket (ctx, XS_SUB);
-    assert (sub);
+    errno_assert (sub);
     protocol = 1;
     rc = xs_setsockopt (sub, XS_PROTOCOL, &protocol, sizeof (protocol));
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_setsockopt (sub, XS_SUBSCRIBE, "", 0);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_bind (sub, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     int oldpub = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
     address.sin_family = AF_INET;
     address.sin_addr.s_addr = inet_addr ("127.0.0.1");
     address.sin_port = htons (5560);
     rc = connect (oldpub, (struct sockaddr*) &address, sizeof (address));
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     //  Wait a while to allow connection to be accepted on the subscriber side.
     sleep (1);
@@ -125,13 +125,13 @@ int XS_TEST_MAIN ()
     #elif XS_HAVE_OPENVMS
 	    int nonblock = 1;
 	    rc = ioctl (oldpub, FIONBIO, &nonblock);
-        assert (rc != -1);
+        errno_assert (rc != -1);
     #else
 	    int flags = fcntl (oldpub, F_GETFL, 0);
 	    if (flags == -1)
             flags = 0;
 	    rc = fcntl (oldpub, F_SETFL, flags | O_NONBLOCK);
-        assert (rc != -1);
+        errno_assert (rc != -1);
     #endif
 
     //  Check that subscription haven't arrived at the publisher side.
@@ -139,33 +139,33 @@ int XS_TEST_MAIN ()
 #if defined XS_HAVE_WINDOWS
     assert (rc == SOCKET_ERROR && WSAGetLastError () == WSAEWOULDBLOCK);
 #else
-    assert (rc == -1 && (errno == EAGAIN || errno == EWOULDBLOCK));
+    errno_assert (rc == -1 && (errno == EAGAIN || errno == EWOULDBLOCK));
 #endif
 
     //  Pass one message through.
     rc = send (oldpub, "\x04\0ABC", 5, 0);
-    assert (rc == 5);
+    errno_assert (rc == 5);
     rc = xs_recv (sub, buf, sizeof (buf), 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
 
     //  Pass one message with usused flags set (0MQ/2.1 bug).
     rc = send (oldpub, "\x04\xfe" "ABC", 5, 0);
-    assert (rc == 5);
+    errno_assert (rc == 5);
     rc = xs_recv (sub, buf, sizeof (buf), 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
 
     //  Tear down the infrastructure.
     rc = xs_close (sub);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 #if defined XS_HAVE_WINDOWS
     rc = closesocket (oldpub);
     assert (rc != SOCKET_ERROR);
 #else
     rc = close (oldpub);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 #endif
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
 #if defined XS_HAVE_WINDOWS
     WSACleanup ();
diff --git a/tests/linger.cpp b/tests/linger.cpp
index 1b1d341..592cf09 100644
--- a/tests/linger.cpp
+++ b/tests/linger.cpp
@@ -26,31 +26,31 @@ int XS_TEST_MAIN ()
 
     //  Create socket.
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
     void *s = xs_socket (ctx, XS_PUSH);
-    assert (s);
+    errno_assert (s);
 
     //  Set linger to 0.1 second.
     int linger = 100;
     int rc = xs_setsockopt (s, XS_LINGER, &linger, sizeof (int));
+    errno_assert (rc == 0);
 
     //  Connect to non-existent endpoing.
-    assert (rc == 0);
     rc = xs_connect (s, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     //  Send a message.
     rc = xs_send (s, "r", 1, 0);
-    assert (rc == 1);
+    errno_assert (rc == 1);
 
     //  Close the socket.
     rc = xs_close (s);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     //  Terminate the context. This should take 0.1 second.
     void *watch = xs_stopwatch_start ();
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     int ms = (int) xs_stopwatch_stop (watch) / 1000;
     time_assert (ms, linger);
 
diff --git a/tests/max_sockets.cpp b/tests/max_sockets.cpp
index 5890d0f..c09f205 100644
--- a/tests/max_sockets.cpp
+++ b/tests/max_sockets.cpp
@@ -26,25 +26,25 @@ int XS_TEST_MAIN ()
 
     //  Create context and set MAX_SOCKETS to 1.
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
     int max_sockets = 1;
     int rc = xs_setctxopt (ctx, XS_MAX_SOCKETS, &max_sockets,
         sizeof (max_sockets));
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     //  First socket should be created OK.
     void *s1 = xs_socket (ctx, XS_PUSH);
-    assert (s1);
+    errno_assert (s1);
 
     //  Creation of second socket should fail.
     void *s2 = xs_socket (ctx, XS_PUSH);
-    assert (!s2 && errno == EMFILE);
+    errno_assert (!s2 && errno == EMFILE);
 
     //  Clean up.
     rc = xs_close (s1);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     return 0;
 }
diff --git a/tests/msg_flags.cpp b/tests/msg_flags.cpp
index 3f3b3b1..e83e4d2 100644
--- a/tests/msg_flags.cpp
+++ b/tests/msg_flags.cpp
@@ -26,57 +26,57 @@ int XS_TEST_MAIN ()
 
     //  Create the infrastructure
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
     void *sb = xs_socket (ctx, XS_XREP);
-    assert (sb);
+    errno_assert (sb);
     int rc = xs_bind (sb, "inproc://a");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     void *sc = xs_socket (ctx, XS_XREQ);
-    assert (sc);
+    errno_assert (sc);
     rc = xs_connect (sc, "inproc://a");
-    assert (rc != -1);
+    errno_assert (rc != -1);
    
     //  Send 2-part message.
     rc = xs_send (sc, "A", 1, XS_SNDMORE);
-    assert (rc == 1);
+    errno_assert (rc == 1);
     rc = xs_send (sc, "B", 1, 0);
-    assert (rc == 1);
+    errno_assert (rc == 1);
 
     //  Identity comes first.
     xs_msg_t msg;
     rc = xs_msg_init (&msg);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_recvmsg (sb, &msg, 0);
-    assert (rc >= 0);
+    errno_assert (rc >= 0);
     int more;
     size_t more_size = sizeof (more);
     rc = xs_getmsgopt (&msg, XS_MORE, &more, &more_size);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     assert (more == 1);
 
     //  Then the first part of the message body.
     rc = xs_recvmsg (sb, &msg, 0);
-    assert (rc == 1);
+    errno_assert (rc == 1);
     more_size = sizeof (more);
     rc = xs_getmsgopt (&msg, XS_MORE, &more, &more_size);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     assert (more == 1);
 
     //  And finally, the second part of the message body.
     rc = xs_recvmsg (sb, &msg, 0);
-    assert (rc == 1);
+    errno_assert (rc == 1);
     more_size = sizeof (more);
     rc = xs_getmsgopt (&msg, XS_MORE, &more, &more_size);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     assert (more == 0);
 
     //  Deallocate the infrastructure.
     rc = xs_close (sc);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_close (sb);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     return 0 ;
 }
 
diff --git a/tests/pair_inproc.cpp b/tests/pair_inproc.cpp
index 456a371..575381b 100644
--- a/tests/pair_inproc.cpp
+++ b/tests/pair_inproc.cpp
@@ -25,28 +25,28 @@ int XS_TEST_MAIN ()
     fprintf (stderr, "pair_inproc test running...\n");
 
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
 
     void *sb = xs_socket (ctx, XS_PAIR);
-    assert (sb);
+    errno_assert (sb);
     int rc = xs_bind (sb, "inproc://a");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     void *sc = xs_socket (ctx, XS_PAIR);
-    assert (sc);
+    errno_assert (sc);
     rc = xs_connect (sc, "inproc://a");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     
     bounce (sb, sc);
 
     rc = xs_close (sc);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     rc = xs_close (sb);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     return 0 ;
 }
diff --git a/tests/pair_ipc.cpp b/tests/pair_ipc.cpp
index ef39bfc..38ab4d9 100644
--- a/tests/pair_ipc.cpp
+++ b/tests/pair_ipc.cpp
@@ -32,28 +32,28 @@ int XS_TEST_MAIN ()
     fprintf (stderr, "pair_ipc test running...\n");
 
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
 
     void *sb = xs_socket (ctx, XS_PAIR);
-    assert (sb);
+    errno_assert (sb);
     int rc = xs_bind (sb, "ipc:///tmp/tester");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     void *sc = xs_socket (ctx, XS_PAIR);
-    assert (sc);
+    errno_assert (sc);
     rc = xs_connect (sc, "ipc:///tmp/tester");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     
     bounce (sb, sc);
 
     rc = xs_close (sc);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     rc = xs_close (sb);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     return 0 ;
 }
diff --git a/tests/pair_tcp.cpp b/tests/pair_tcp.cpp
index d406523..51184a5 100644
--- a/tests/pair_tcp.cpp
+++ b/tests/pair_tcp.cpp
@@ -26,39 +26,39 @@ int XS_TEST_MAIN ()
     fprintf (stderr, "pair_tcp test running...\n");
 
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
 
     void *sb = xs_socket (ctx, XS_PAIR);
-    assert (sb);
+    errno_assert (sb);
     int rc = xs_bind (sb, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     void *sc = xs_socket (ctx, XS_PAIR);
-    assert (sc);
+    errno_assert (sc);
     rc = xs_connect (sc, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     
     bounce (sb, sc);
 
     //  Now let's try to open one more connection to the bound socket.
     //  The connection should be silently rejected rather than causing error.
     void *sc2 = xs_socket (ctx, XS_PAIR);
-    assert (sc2);
+    errno_assert (sc2);
     rc = xs_connect (sc2, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     sleep (1);
 
     rc = xs_close (sc2);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     rc = xs_close (sc);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     rc = xs_close (sb);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     return 0 ;
 }
diff --git a/tests/polltimeo.cpp b/tests/polltimeo.cpp
index f425593..9538d8d 100644
--- a/tests/polltimeo.cpp
+++ b/tests/polltimeo.cpp
@@ -28,12 +28,12 @@ extern "C"
         //  for 1 more second, so that async connect has time to succeed.
         sleep (1);
         void *sc = xs_socket (ctx_, XS_PUSH);
-        assert (sc);
+        errno_assert (sc);
         int rc = xs_connect (sc, "inproc://timeout_test");
-        assert (rc != -1);
+        errno_assert (rc != -1);
         sleep (1);
         rc = xs_close (sc);
-        assert (rc == 0);
+        errno_assert (rc == 0);
     }
 }
 
@@ -42,13 +42,13 @@ int XS_TEST_MAIN ()
     fprintf (stderr, "polltimeo test running...\n");
 
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
 
     //  Create a disconnected socket.
     void *sb = xs_socket (ctx, XS_PULL);
-    assert (sb);
+    errno_assert (sb);
     int rc = xs_bind (sb, "inproc://timeout_test");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     //  Check whether timeout is honoured.
     xs_pollitem_t pi;
@@ -56,7 +56,7 @@ int XS_TEST_MAIN ()
     pi.events = XS_POLLIN;
     void *watch = xs_stopwatch_start ();
     rc = xs_poll (&pi, 1, 500);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     unsigned long elapsed = xs_stopwatch_stop (watch) / 1000;
     time_assert (elapsed, 500);
 
@@ -65,16 +65,16 @@ int XS_TEST_MAIN ()
     assert (thread);
     watch = xs_stopwatch_start ();
     rc = xs_poll (&pi, 1, 2000);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     elapsed = xs_stopwatch_stop (watch) / 1000;
     time_assert (elapsed, 2000);
     thread_join (thread);
 
     //  Clean-up.
     rc = xs_close (sb);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     return 0 ;
 }
diff --git a/tests/reconnect.cpp b/tests/reconnect.cpp
index ebbaf32..9aa6e20 100644
--- a/tests/reconnect.cpp
+++ b/tests/reconnect.cpp
@@ -26,67 +26,67 @@ int XS_TEST_MAIN ()
 
     //  Create the basic infrastructure.
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
     void *push = xs_socket (ctx, XS_PUSH);
-    assert (push);
+    errno_assert (push);
     void *pull = xs_socket (ctx, XS_PULL);
-    assert (push);
+    errno_assert (push);
 
     //  Connect before bind was done at the peer and send one message.
     int rc = xs_connect (push, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     rc = xs_send (push, "ABC", 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
 
     //  Wait a while for few attempts to reconnect to happen.
     sleep (1);
 
     //  Bind the peer and get the message.
     rc = xs_bind (pull, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     unsigned char buf [3];
     rc = xs_recv (pull, buf, sizeof (buf), 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
 
     //  Clean up.
     rc = xs_close (push);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_close (pull);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
 #if !defined XS_HAVE_WINDOWS && !defined XS_HAVE_OPENVMS
 
     //  Now, let's test the same scenario with IPC.
     push = xs_socket (ctx, XS_PUSH);
-    assert (push);
+    errno_assert (push);
     pull = xs_socket (ctx, XS_PULL);
-    assert (push);
+    errno_assert (push);
 
     //  Connect before bind was done at the peer and send one message.
     rc = xs_connect (push, "ipc:///tmp/tester");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     rc = xs_send (push, "ABC", 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
 
     //  Wait a while for few attempts to reconnect to happen.
     sleep (1);
 
     //  Bind the peer and get the message.
     rc = xs_bind (pull, "ipc:///tmp/tester");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     rc = xs_recv (pull, buf, sizeof (buf), 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
 
     //  Clean up.
     rc = xs_close (push);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_close (pull);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
 #endif
 
     rc = xs_term (ctx);
-    assert (rc == 0);
+    errno_assert (rc == 0);
 
     return 0 ;
 }
diff --git a/tests/reqrep_device.cpp b/tests/reqrep_device.cpp
index 732f4dc..0fb09d6 100644
--- a/tests/reqrep_device.cpp
+++ b/tests/reqrep_device.cpp
@@ -26,112 +26,112 @@ int XS_TEST_MAIN ()
     fprintf (stderr, "reqrep_device test running...\n");
 
     void *ctx = xs_init ();
-    assert (ctx);
+    errno_assert (ctx);
 
     //  Create a req/rep device.
     void *xreq = xs_socket (ctx, XS_XREQ);
-    assert (xreq);
+    errno_assert (xreq);
     int rc = xs_bind (xreq, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
     void *xrep = xs_socket (ctx, XS_XREP);
-    assert (xrep);
+    errno_assert (xrep);
     rc = xs_bind (xrep, "tcp://127.0.0.1:5561");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     //  Create a worker.
     void *rep = xs_socket (ctx, XS_REP);
-    assert (rep);
+    errno_assert (rep);
     rc = xs_connect (rep, "tcp://127.0.0.1:5560");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     //  Create a client.
     void *req = xs_socket (ctx, XS_REQ);
-    assert (req);
+    errno_assert (req);
     rc = xs_connect (req, "tcp://127.0.0.1:5561");
-    assert (rc != -1);
+    errno_assert (rc != -1);
 
     //  Send a request.
     rc = xs_send (req, "ABC", 3, XS_SNDMORE);
-    assert (rc == 3);
+    errno_assert (rc == 3);
     rc = xs_send (req, "DEF", 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
 
     //  Pass the request through the device.
     for (int i = 0; i != 4; i++) {
         xs_msg_t msg;
         rc = xs_msg_init (&msg);
-        assert (rc == 0);
+        errno_assert (rc == 0);
         rc = xs_recvmsg (xrep, &msg, 0);
-        assert (rc >= 0);
+        errno_assert (rc >= 0);
         int rcvmore;
         size_t sz = sizeof (rcvmore);
         rc = xs_getsockopt (xrep, XS_RCVMORE, &rcvmore, &sz);
-        assert (rc == 0);
+        errno_assert (rc == 0);
         rc = xs_sendmsg (xreq, &msg, rcvmore ? XS_SNDMORE : 0);
-        assert (rc >= 0);
+        errno_assert (rc >= 0);
     }
 
     //  Receive the request.
     char buff [3];
     rc = xs_recv (rep, buff, 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
     assert (memcmp (buff, "ABC", 3) == 0);
     int rcvmore;
     size_t sz = sizeof (rcvmore);
     rc = xs_getsockopt (rep, XS_RCVMORE, &rcvmore, &sz);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     assert (rcvmore);
     rc = xs_recv (rep, buff, 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
     assert (memcmp (buff, "DEF", 3) == 0);
     rc = xs_getsockopt (rep, XS_RCVMORE, &rcvmore, &sz);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     assert (!rcvmore);
 
     //  Send the reply.
     rc = xs_send (rep, "GHI", 3, XS_SNDMORE);
-    assert (rc == 3);
+    errno_assert (rc == 3);
     rc = xs_send (rep, "JKL", 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
 
     //  Pass the reply through the device.
     for (int i = 0; i != 4; i++) {
         xs_msg_t msg;
         rc = xs_msg_init (&msg);
-        assert (rc == 0);
+        errno_assert (rc == 0);
         rc = xs_recvmsg (xreq, &msg, 0);
-        assert (rc >= 0);
+        errno_assert (rc >= 0);
         rc = xs_getsockopt (xreq, XS_RCVMORE, &rcvmore, &sz);
-        assert (rc == 0);
+        errno_assert (rc == 0);
         rc = xs_sendmsg (xrep, &msg, rcvmore ? XS_SNDMORE : 0);
-        assert (rc >= 0);
+        errno_assert (rc >= 0);
     }
 
     //  Receive the reply.
     rc = xs_recv (req, buff, 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
     assert (memcmp (buff, "GHI", 3) == 0);
     rc = xs_getsockopt (req, XS_RCVMORE, &rcvmore, &sz);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     assert (rcvmore);
     rc = xs_recv (req, buff, 3, 0);
-    assert (rc == 3);
+    errno_assert (rc == 3);
     assert (memcmp (buff, "JKL", 3) == 0);
     rc = xs_getsockopt (req, XS_RCVMORE, &rcvmore, &sz);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     assert (!rcvmore);
 
     //  Clean up.
     rc = xs_close (req);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_close (rep);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_close (xrep);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_close (xreq);
-    assert (rc == 0);
+    errno_assert (rc == 0);
     rc = xs_term (ctx);
-    a