Problem: test_poller not using unity

Solution: migrate to unity, and split test cases

Makefile.am

@@ -858,7 +858,8 @@ test_apps += tests/test_poller \
 	tests/test_dgram
 
 tests_test_poller_SOURCES = tests/test_poller.cpp
-tests_test_poller_LDADD = src/libzmq.la
+tests_test_poller_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_poller_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_client_server_SOURCES = tests/test_client_server.cpp
 tests_test_client_server_LDADD = src/libzmq.la ${UNITY_LIBS}

tests/test_poller.cpp

@@ -28,9 +28,23 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
+
+#include <unity.h>
+
+void setUp ()
+{
+    setup_test_context ();
+}
+
+void tearDown ()
+{
+    teardown_test_context ();
+}
 
 // duplicated from fd.hpp
 #ifdef ZMQ_HAVE_WINDOWS
+#define close closesocket
 #if defined _MSC_VER && _MSC_VER <= 1400
 typedef UINT_PTR fd_t;
 enum
@@ -52,362 +66,459 @@ enum
 };
 #endif
 
-void test_null_poller_pointers (void *ctx)
+fd_t get_fd (void *socket)
+{
+    fd_t fd;
+    size_t fd_size = sizeof fd;
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_getsockopt (socket, ZMQ_FD, &fd, &fd_size));
+    return fd;
+}
+
+void test_null_poller_pointers_destroy_direct ()
+{
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_destroy (NULL));
+}
+
+void test_null_poller_pointers_destroy_indirect ()
+{
+    void *null_poller = NULL;
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_destroy (&null_poller));
+}
+
+void test_null_poller_pointers_add_direct ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_add (NULL, socket, NULL, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
+
+void test_null_poller_pointers_add_indirect ()
+{
+    void *null_poller = NULL;
+    void *socket = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EFAULT, zmq_poller_add (&null_poller, socket, NULL, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
+
+void test_null_poller_pointers_modify_direct ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_modify (NULL, socket, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
+
+void test_null_poller_pointers_modify_indirect ()
 {
-    int rc = zmq_poller_destroy (NULL);
-    assert (rc == -1 && errno == EFAULT);
     void *null_poller = NULL;
-    rc = zmq_poller_destroy (&null_poller);
-    assert (rc == -1 && errno == EFAULT);
+    void *socket = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EFAULT, zmq_poller_modify (&null_poller, socket, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
 
-    void *socket = zmq_socket (ctx, ZMQ_PAIR);
-    assert (socket != NULL);
+void test_null_poller_pointers_remove_direct ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_remove (NULL, socket));
+    test_context_socket_close (socket);
+}
 
-    rc = zmq_poller_add (NULL, socket, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_add (&null_poller, socket, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EFAULT);
+void test_null_poller_pointers_remove_indirect ()
+{
+    void *null_poller = NULL;
+    void *socket = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_remove (&null_poller, socket));
+    test_context_socket_close (socket);
+}
 
-    rc = zmq_poller_modify (NULL, socket, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_modify (&null_poller, socket, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EFAULT);
+void test_null_poller_pointers_add_fd_direct ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    const fd_t fd = get_fd (socket);
 
-    rc = zmq_poller_remove (NULL, socket);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_remove (&null_poller, socket);
-    assert (rc == -1 && errno == EFAULT);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_add_fd (NULL, fd, NULL, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
 
-    fd_t fd;
-    size_t fd_size = sizeof fd;
-    rc = zmq_getsockopt (socket, ZMQ_FD, &fd, &fd_size);
-    assert (rc == 0);
+void test_null_poller_pointers_add_fd_indirect ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    const fd_t fd = get_fd (socket);
+    void *null_poller = NULL;
+    TEST_ASSERT_FAILURE_ERRNO (
+      EFAULT, zmq_poller_add_fd (&null_poller, fd, NULL, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
 
-    rc = zmq_poller_add_fd (NULL, fd, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_add_fd (&null_poller, fd, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EFAULT);
+void test_null_poller_pointers_modify_fd_direct ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    const fd_t fd = get_fd (socket);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_modify_fd (NULL, fd, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
 
-    rc = zmq_poller_modify_fd (NULL, fd, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_modify_fd (&null_poller, fd, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EFAULT);
+void test_null_poller_pointers_modify_fd_indirect ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    const fd_t fd = get_fd (socket);
+    void *null_poller = NULL;
+    TEST_ASSERT_FAILURE_ERRNO (
+      EFAULT, zmq_poller_modify_fd (&null_poller, fd, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
 
-    rc = zmq_poller_remove_fd (NULL, fd);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_remove_fd (&null_poller, fd);
-    assert (rc == -1 && errno == EFAULT);
+void test_null_poller_pointers_remove_fd_direct ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    const fd_t fd = get_fd (socket);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_remove_fd (NULL, fd));
+    test_context_socket_close (socket);
+}
 
+void test_null_poller_pointers_remove_fd_indirect ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    const fd_t fd = get_fd (socket);
+    void *null_poller = NULL;
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_remove_fd (&null_poller, fd));
+    test_context_socket_close (socket);
+}
+
+void test_null_poller_pointers_wait_direct ()
+{
     zmq_poller_event_t event;
-    rc = zmq_poller_wait (NULL, &event, 0);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_wait (&null_poller, &event, 0);
-    assert (rc == -1 && errno == EFAULT);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_wait (NULL, &event, 0));
+}
 
-    rc = zmq_poller_wait_all (NULL, &event, 1, 0);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_wait_all (&null_poller, &event, 1, 0);
-    assert (rc == -1 && errno == EFAULT);
+void test_null_poller_pointers_wait_indirect ()
+{
+    zmq_poller_event_t event;
+    void *null_poller = NULL;
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_wait (&null_poller, &event, 0));
+}
 
-    rc = zmq_close (socket);
-    assert (rc == 0);
+void test_null_poller_pointers_wait_all_direct ()
+{
+    zmq_poller_event_t event;
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_wait_all (NULL, &event, 1, 0));
+}
+
+void test_null_poller_pointers_wait_all_indirect ()
+{
+    zmq_poller_event_t event;
+    void *null_poller = NULL;
+    TEST_ASSERT_FAILURE_ERRNO (
+      EFAULT, zmq_poller_wait_all (&null_poller, &event, 1, 0));
 }
 
 void test_null_socket_pointers ()
 {
     void *poller = zmq_poller_new ();
-    assert (poller != NULL);
+    TEST_ASSERT_NOT_NULL (poller);
 
-    int rc = zmq_poller_add (poller, NULL, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == ENOTSOCK);
+    TEST_ASSERT_FAILURE_ERRNO (ENOTSOCK,
+                               zmq_poller_add (poller, NULL, NULL, ZMQ_POLLIN));
 
-    rc = zmq_poller_modify (poller, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == ENOTSOCK);
+    TEST_ASSERT_FAILURE_ERRNO (ENOTSOCK,
+                               zmq_poller_modify (poller, NULL, ZMQ_POLLIN));
 
-    rc = zmq_poller_remove (poller, NULL);
-    assert (rc == -1 && errno == ENOTSOCK);
+    TEST_ASSERT_FAILURE_ERRNO (ENOTSOCK, zmq_poller_remove (poller, NULL));
 
     fd_t null_socket_fd = retired_fd;
 
-    rc = zmq_poller_add_fd (poller, null_socket_fd, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EBADF);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EBADF, zmq_poller_add_fd (poller, null_socket_fd, NULL, ZMQ_POLLIN));
 
-    rc = zmq_poller_modify_fd (poller, null_socket_fd, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EBADF);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EBADF, zmq_poller_modify_fd (poller, null_socket_fd, ZMQ_POLLIN));
 
-    rc = zmq_poller_remove_fd (poller, null_socket_fd);
-    assert (rc == -1 && errno == EBADF);
+    TEST_ASSERT_FAILURE_ERRNO (EBADF,
+                               zmq_poller_remove_fd (poller, null_socket_fd));
 
-    rc = zmq_poller_destroy (&poller);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
 }
 
-void test_null_event_pointers (void *ctx)
+typedef void (*extra_func_t) (void *poller);
+
+void test_with_valid_poller (extra_func_t extra_func)
 {
-    void *socket = zmq_socket (ctx, ZMQ_PAIR);
-    assert (socket != NULL);
+    void *socket = test_context_socket (ZMQ_PAIR);
 
     void *poller = zmq_poller_new ();
-    assert (poller != NULL);
+    TEST_ASSERT_NOT_NULL (poller);
+
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN));
+
+    extra_func (poller);
 
-    int rc = zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
 
-    rc = zmq_poller_wait (poller, NULL, 0);
-    assert (rc == -1 && errno == EFAULT);
+    test_context_socket_close (socket);
+}
+
+void call_poller_wait_null_event_fails (void *poller)
+{
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_wait (poller, NULL, 0));
+}
 
-    rc = zmq_poller_wait_all (poller, NULL, 1, 0);
-    assert (rc == -1 && errno == EFAULT);
+void call_poller_wait_all_null_event_fails_event_count_nonzero (void *poller)
+{
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_wait_all (poller, NULL, 1, 0));
+}
 
+void call_poller_wait_all_null_event_fails_event_count_zero (void *poller)
+{
+#if 0
     //  TODO this causes an assertion, which is not consistent if the number
     //  of events may be 0, the pointer should be allowed to by NULL in that
     //  case too
-#if 0
-    rc = zmq_poller_wait_all (poller, NULL, 0, 0);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait_all (poller, NULL, 0, 0));
 #endif
+}
+
+void test_poller_wait_null_event_fails ()
+{
+    test_with_valid_poller (call_poller_wait_null_event_fails);
+}
 
-    rc = zmq_poller_destroy (&poller);
-    assert (rc == 0);
+void test_poller_wait_all_null_event_fails_event_count_nonzero ()
+{
+    test_with_valid_poller (
+      call_poller_wait_all_null_event_fails_event_count_nonzero);
+}
 
-    rc = zmq_close (socket);
-    assert (rc == 0);
+void test_poller_wait_all_null_event_fails_event_count_zero ()
+{
+    test_with_valid_poller (
+      call_poller_wait_all_null_event_fails_event_count_zero);
 }
 
-void test_add_modify_remove_corner_cases (void *ctx)
+void test_add_modify_remove_corner_cases ()
 {
     void *poller = zmq_poller_new ();
-    assert (poller != NULL);
+    TEST_ASSERT_NOT_NULL (poller);
 
-    void *zeromq_socket = zmq_socket (ctx, ZMQ_PAIR);
-    assert (zeromq_socket != NULL);
+    void *zeromq_socket = test_context_socket (ZMQ_PAIR);
 
-    int rc = zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN));
 
     //  attempt to add the same socket twice
-    rc = zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EINVAL, zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN));
 
-    rc = zmq_poller_remove (poller, zeromq_socket);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove (poller, zeromq_socket));
 
     //  attempt to remove socket that is not present
-    rc = zmq_poller_remove (poller, zeromq_socket);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_FAILURE_ERRNO (EINVAL,
+                               zmq_poller_remove (poller, zeromq_socket));
 
     //  attempt to modify socket that is not present
-    rc = zmq_poller_modify (poller, zeromq_socket, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EINVAL, zmq_poller_modify (poller, zeromq_socket, ZMQ_POLLIN));
 
     //  add a socket with no events
     //  TODO should this really be legal? it does not make any sense...
-    rc = zmq_poller_add (poller, zeromq_socket, NULL, 0);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_add (poller, zeromq_socket, NULL, 0));
 
     fd_t plain_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
-    rc = zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN));
 
     //  attempt to add the same plain socket twice
-    rc = zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EINVAL, zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN));
 
-    rc = zmq_poller_remove_fd (poller, plain_socket);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove_fd (poller, plain_socket));
 
     //  attempt to remove plain socket that is not present
-    rc = zmq_poller_remove_fd (poller, plain_socket);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_FAILURE_ERRNO (EINVAL,
+                               zmq_poller_remove_fd (poller, plain_socket));
 
     //  attempt to modify plain socket that is not present
-    rc = zmq_poller_modify_fd (poller, plain_socket, ZMQ_POLLIN);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EINVAL, zmq_poller_modify_fd (poller, plain_socket, ZMQ_POLLIN));
 
-    rc = zmq_poller_destroy (&poller);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
 
-    rc = zmq_close (zeromq_socket);
-    assert (rc == 0);
+    test_context_socket_close (zeromq_socket);
 
-    rc = close (plain_socket);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (close (plain_socket));
 }
 
 void test_wait_corner_cases (void)
 {
     void *poller = zmq_poller_new ();
-    assert (poller != NULL);
+    TEST_ASSERT_NOT_NULL (poller);
 
     zmq_poller_event_t event;
-    int rc = zmq_poller_wait (poller, &event, 0);
-    assert (rc == -1 && errno == EAGAIN);
+    // waiting on poller with no registered sockets should report error
+    TEST_ASSERT_FAILURE_ERRNO (EAGAIN, zmq_poller_wait (poller, &event, 0));
 
-    //  this can never return since no socket was registered, and should yield an error
-    rc = zmq_poller_wait (poller, &event, -1);
-    assert (rc == -1 && errno == EFAULT);
+    //  this would never be able to return since no socket was registered, and should yield an error
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_wait (poller, &event, -1));
 
-    rc = zmq_poller_wait_all (poller, &event, -1, 0);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_FAILURE_ERRNO (EINVAL,
+                               zmq_poller_wait_all (poller, &event, -1, 0));
 
-    rc = zmq_poller_wait_all (poller, &event, 0, 0);
-    assert (rc == -1 && errno == EAGAIN);
+    TEST_ASSERT_FAILURE_ERRNO (EAGAIN,
+                               zmq_poller_wait_all (poller, &event, 0, 0));
 
-    //  this can never return since no socket was registered, and should yield an error
-    rc = zmq_poller_wait_all (poller, &event, 0, -1);
-    assert (rc == -1 && errno == EFAULT);
+    //  this would never be able to return since no socket was registered, and should yield an error
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_wait_all (poller, &event, 0, -1));
 
-    rc = zmq_poller_destroy (&poller);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
 }
 
-int main (void)
+void test_x ()
 {
     size_t len = MAX_SOCKET_STRING;
     char my_endpoint_0[MAX_SOCKET_STRING];
     char my_endpoint_1[MAX_SOCKET_STRING];
 
-    setup_test_environment ();
-
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
-
     //  Create few sockets
-    void *vent = zmq_socket (ctx, ZMQ_PUSH);
-    assert (vent);
-    int rc = zmq_bind (vent, "tcp://127.0.0.1:*");
-    assert (rc == 0);
-    rc = zmq_getsockopt (vent, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len);
-    assert (rc == 0);
+    void *vent = test_context_socket (ZMQ_PUSH);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (vent, "tcp://127.0.0.1:*"));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (vent, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len));
 
-    void *sink = zmq_socket (ctx, ZMQ_PULL);
-    assert (sink);
-    rc = zmq_connect (sink, my_endpoint_0);
-    assert (rc == 0);
+    void *sink = test_context_socket (ZMQ_PULL);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sink, my_endpoint_0));
 
-    void *bowl = zmq_socket (ctx, ZMQ_PULL);
-    assert (bowl);
+    void *bowl = test_context_socket (ZMQ_PULL);
 
 #if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
-    void *server = zmq_socket (ctx, ZMQ_SERVER);
-    assert (server);
-    rc = zmq_bind (server, "tcp://127.0.0.1:*");
-    assert (rc == 0);
+    void *server = test_context_socket (ZMQ_SERVER);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (server, "tcp://127.0.0.1:*"));
+
     len = MAX_SOCKET_STRING;
-    rc = zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len));
 
-    void *client = zmq_socket (ctx, ZMQ_CLIENT);
-    assert (client);
+    void *client = test_context_socket (ZMQ_CLIENT);
 #endif
 
     //  Set up poller
     void *poller = zmq_poller_new ();
     zmq_poller_event_t event;
 
-    // waiting on poller with no registered sockets should report error
-    rc = zmq_poller_wait (poller, &event, 0);
-    assert (rc == -1);
-    assert (errno == EAGAIN);
-
     // register sink
-    rc = zmq_poller_add (poller, sink, sink, ZMQ_POLLIN);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_add (poller, sink, sink, ZMQ_POLLIN));
 
     //  Send a message
-    char data[1] = {'H'};
-    rc = zmq_send_const (vent, data, 1, 0);
-    assert (rc == 1);
+    const char *vent_sink_msg = "H";
+    send_string_expect_success (vent, vent_sink_msg, 0);
 
     //  We expect a message only on the sink
-    rc = zmq_poller_wait (poller, &event, -1);
-    assert (rc == 0);
-    assert (event.socket == sink);
-    assert (event.user_data == sink);
-    rc = zmq_recv (sink, data, 1, 0);
-    assert (rc == 1);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait (poller, &event, -1));
+    TEST_ASSERT_EQUAL_PTR (sink, event.socket);
+    TEST_ASSERT_EQUAL_PTR (sink, event.user_data);
+    recv_string_expect_success (sink, vent_sink_msg, 0);
 
     //  We expect timed out
-    rc = zmq_poller_wait (poller, &event, 0);
-    assert (rc == -1);
-    assert (errno == EAGAIN);
+    TEST_ASSERT_FAILURE_ERRNO (EAGAIN, zmq_poller_wait (poller, &event, 0));
 
     //  Stop polling sink
-    rc = zmq_poller_remove (poller, sink);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove (poller, sink));
 
     //  Check we can poll an FD
-    rc = zmq_connect (bowl, my_endpoint_0);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (bowl, my_endpoint_0));
 
     fd_t fd;
     size_t fd_size = sizeof (fd);
 
-    rc = zmq_getsockopt (bowl, ZMQ_FD, &fd, &fd_size);
-    assert (rc == 0);
-    rc = zmq_poller_add_fd (poller, fd, bowl, ZMQ_POLLIN);
-    assert (rc == 0);
-    rc = zmq_poller_wait (poller, &event, 500);
-    assert (rc == 0);
-    assert (event.socket == NULL);
-    assert (event.fd == fd);
-    assert (event.user_data == bowl);
-    zmq_poller_remove_fd (poller, fd);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_getsockopt (bowl, ZMQ_FD, &fd, &fd_size));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_add_fd (poller, fd, bowl, ZMQ_POLLIN));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait (poller, &event, 500));
+    TEST_ASSERT_NULL (event.socket);
+    TEST_ASSERT_EQUAL (fd, event.fd);
+    TEST_ASSERT_EQUAL_PTR (bowl, event.user_data);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove_fd (poller, fd));
 
 #if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
     //  Polling on thread safe sockets
-    rc = zmq_poller_add (poller, server, NULL, ZMQ_POLLIN);
-    assert (rc == 0);
-    rc = zmq_connect (client, my_endpoint_1);
-    assert (rc == 0);
-    rc = zmq_send_const (client, data, 1, 0);
-    assert (rc == 1);
-    rc = zmq_poller_wait (poller, &event, 500);
-    assert (rc == 0);
-    assert (event.socket == server);
-    assert (event.user_data == NULL);
-    rc = zmq_recv (server, data, 1, 0);
-    assert (rc == 1);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_add (poller, server, NULL, ZMQ_POLLIN));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, my_endpoint_1));
+
+    const char *client_server_msg = "I";
+    send_string_expect_success (client, client_server_msg, 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait (poller, &event, 500));
+    TEST_ASSERT_EQUAL_PTR (server, event.socket);
+    TEST_ASSERT_NULL (event.user_data);
+    recv_string_expect_success (server, client_server_msg, 0);
 
     //  Polling on pollout
-    rc = zmq_poller_modify (poller, server, ZMQ_POLLOUT | ZMQ_POLLIN);
-    assert (rc == 0);
-    rc = zmq_poller_wait (poller, &event, 0);
-    assert (rc == 0);
-    assert (event.socket == server);
-    assert (event.user_data == NULL);
-    assert (event.events == ZMQ_POLLOUT);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_modify (poller, server, ZMQ_POLLOUT | ZMQ_POLLIN));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait (poller, &event, 0));
+    TEST_ASSERT_EQUAL_PTR (server, event.socket);
+    TEST_ASSERT_NULL (event.user_data);
+    TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, event.events);
 
     //  Stop polling server
-    rc = zmq_poller_remove (poller, server);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove (poller, server));
 #endif
 
     //  Destroy sockets, poller and ctx
-    rc = zmq_close (sink);
-    assert (rc == 0);
-    rc = zmq_close (vent);
-    assert (rc == 0);
-    rc = zmq_close (bowl);
-    assert (rc == 0);
+    test_context_socket_close (sink);
+    test_context_socket_close (vent);
+    test_context_socket_close (bowl);
 #if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
-    rc = zmq_close (server);
-    assert (rc == 0);
-    rc = zmq_close (client);
-    assert (rc == 0);
+    test_context_socket_close (server);
+    test_context_socket_close (client);
 #endif
 
-    test_null_poller_pointers (ctx);
-    test_null_socket_pointers ();
-    test_null_event_pointers (ctx);
-
-    test_add_modify_remove_corner_cases (ctx);
-    test_wait_corner_cases ();
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
+}
 
-    rc = zmq_poller_destroy (&poller);
-    assert (rc == 0);
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+int main (void)
+{
+    setup_test_environment ();
 
-    return 0;
+    UNITY_BEGIN ();
+    RUN_TEST (test_null_poller_pointers_destroy_direct);
+    RUN_TEST (test_null_poller_pointers_destroy_indirect);
+    RUN_TEST (test_null_poller_pointers_add_direct);
+    RUN_TEST (test_null_poller_pointers_add_indirect);
+    RUN_TEST (test_null_poller_pointers_modify_direct);
+    RUN_TEST (test_null_poller_pointers_modify_indirect);
+    RUN_TEST (test_null_poller_pointers_remove_direct);
+    RUN_TEST (test_null_poller_pointers_remove_indirect);
+    RUN_TEST (test_null_poller_pointers_add_fd_direct);
+    RUN_TEST (test_null_poller_pointers_add_fd_indirect);
+    RUN_TEST (test_null_poller_pointers_modify_fd_direct);
+    RUN_TEST (test_null_poller_pointers_modify_fd_indirect);
+    RUN_TEST (test_null_poller_pointers_remove_fd_direct);
+    RUN_TEST (test_null_poller_pointers_remove_fd_indirect);
+    RUN_TEST (test_null_poller_pointers_wait_direct);
+    RUN_TEST (test_null_poller_pointers_wait_indirect);
+    RUN_TEST (test_null_poller_pointers_wait_all_direct);
+    RUN_TEST (test_null_poller_pointers_wait_all_indirect);
+
+    RUN_TEST (test_null_socket_pointers);
+
+    RUN_TEST (test_poller_wait_null_event_fails);
+    RUN_TEST (test_poller_wait_all_null_event_fails_event_count_nonzero);
+    RUN_TEST (test_poller_wait_all_null_event_fails_event_count_zero);
+
+    RUN_TEST (test_add_modify_remove_corner_cases);
+    RUN_TEST (test_wait_corner_cases);
+
+    RUN_TEST (test_x);
+
+    return UNITY_END ();
 }

tests/testutil_unity.hpp

@@ -63,6 +63,13 @@ int test_assert_success_message_errno_helper (int rc,
 #define TEST_ASSERT_SUCCESS_ERRNO(expr)                                        \
     test_assert_success_message_errno_helper (expr, NULL, #expr)
 
+#define TEST_ASSERT_FAILURE_ERRNO(error_code, expr)                            \
+    {                                                                          \
+        int rc = (expr);                                                       \
+        TEST_ASSERT_EQUAL_INT (-1, rc);                                        \
+        TEST_ASSERT_EQUAL_INT (error_code, errno);                             \
+    }
+
 void send_string_expect_success (void *socket, const char *str, int flags)
 {
     const size_t len = str ? strlen (str) : 0;