Merge pull request #2994 from sigiesec/migrate-to-unity

Migrate further tests to unity, and split up into individual test cases

Makefile.am

@@ -429,7 +429,7 @@ test_apps = \
 	tests/test_reconnect_ivl \
 	tests/test_socket_null
 
-UNITY_CPPFLAGS = -I$(top_srcdir)/external/unity
+UNITY_CPPFLAGS = -I$(top_srcdir)/external/unity -DUNITY_USE_COMMAND_LINE_ARGS -DUNITY_EXCLUDE_FLOAT
 UNITY_LIBS = $(top_builddir)/external/unity/libunity.a
 noinst_LIBRARIES = external/unity/libunity.a
 external_unity_libunity_a_SOURCES = external/unity/unity.c \
@@ -545,7 +545,8 @@ tests_test_iov_SOURCES = tests/test_iov.cpp
 tests_test_iov_LDADD = src/libzmq.la
 
 tests_test_ctx_destroy_SOURCES = tests/test_ctx_destroy.cpp
-tests_test_ctx_destroy_LDADD = src/libzmq.la
+tests_test_ctx_destroy_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_ctx_destroy_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_security_null_SOURCES = tests/test_security_null.cpp
 tests_test_security_null_LDADD = src/libzmq.la
@@ -668,7 +669,8 @@ tests_test_socket_null_LDADD = src/libzmq.la ${UNITY_LIBS}
 tests_test_socket_null_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_reconnect_ivl_SOURCES = tests/test_reconnect_ivl.cpp
-tests_test_reconnect_ivl_LDADD = src/libzmq.la
+tests_test_reconnect_ivl_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_reconnect_ivl_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 if HAVE_CURVE
 
@@ -857,14 +859,16 @@ test_apps += tests/test_poller \
 	tests/test_app_meta
 
 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_client_server_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_thread_safe_SOURCES = tests/test_thread_safe.cpp
-tests_test_thread_safe_LDADD = src/libzmq.la
+tests_test_thread_safe_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_thread_safe_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_timers_SOURCES = tests/test_timers.cpp
 tests_test_timers_LDADD = src/libzmq.la

tests/CMakeLists.txt

@@ -154,6 +154,7 @@ add_library (unity
     "${CMAKE_CURRENT_LIST_DIR}/../external/unity/unity_internals.h")
 set_target_properties (unity PROPERTIES
     PUBLIC_HEADER "${CMAKE_CURRENT_LIST_DIR}/../external/unity/unity.h")
+target_compile_definitions (unity PUBLIC "UNITY_USE_COMMAND_LINE_ARGS" "UNITY_EXCLUDE_FLOAT")
 target_include_directories (unity
     PUBLIC "${CMAKE_CURRENT_LIST_DIR}/../external/unity")
 

tests/test_ctx_destroy.cpp

@@ -28,6 +28,17 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
+
+#include <unity.h>
+
+void setUp ()
+{
+}
+
+void tearDown ()
+{
+}
 
 static void receiver (void *socket)
 {
@@ -38,40 +49,28 @@ static void receiver (void *socket)
 
 void test_ctx_destroy ()
 {
-    int rc;
-
     //  Set up our context and sockets
     void *ctx = zmq_ctx_new ();
-    assert (ctx);
+    TEST_ASSERT_NOT_NULL (ctx);
 
     void *socket = zmq_socket (ctx, ZMQ_PULL);
-    assert (socket);
+    TEST_ASSERT_NOT_NULL (socket);
 
     // Close the socket
-    rc = zmq_close (socket);
-    assert (rc == 0);
-
-    // Test error - API has multiple ways to kill Contexts
-    rc = zmq_ctx_term (NULL);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_term (NULL);
-    assert (rc == -1 && errno == EFAULT);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_close (socket));
 
     // Destroy the context
-    rc = zmq_ctx_destroy (ctx);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_ctx_destroy (ctx));
 }
 
 void test_ctx_shutdown ()
 {
-    int rc;
-
     //  Set up our context and sockets
     void *ctx = zmq_ctx_new ();
-    assert (ctx);
+    TEST_ASSERT_NOT_NULL (ctx);
 
     void *socket = zmq_socket (ctx, ZMQ_PULL);
-    assert (socket);
+    TEST_ASSERT_NOT_NULL (socket);
 
     // Spawn a thread to receive on socket
     void *receiver_thread = zmq_threadstart (&receiver, socket);
@@ -79,32 +78,49 @@ void test_ctx_shutdown ()
     // Wait for thread to start up and block
     msleep (SETTLE_TIME);
 
-    // Test error - Shutdown context
-    rc = zmq_ctx_shutdown (NULL);
-    assert (rc == -1 && errno == EFAULT);
-
     // Shutdown context, if we used destroy here we would deadlock.
-    rc = zmq_ctx_shutdown (ctx);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_ctx_shutdown (ctx));
 
     // Wait for thread to finish
     zmq_threadclose (receiver_thread);
 
     // Close the socket.
-    rc = zmq_close (socket);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_close (socket));
 
     // Destory the context, will now not hang as we have closed the socket.
-    rc = zmq_ctx_destroy (ctx);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_ctx_destroy (ctx));
+}
+
+void test_zmq_ctx_term_null_fails ()
+{
+    int rc = zmq_ctx_term (NULL);
+    TEST_ASSERT_EQUAL_INT (-1, rc);
+    TEST_ASSERT_EQUAL_INT (EFAULT, errno);
+}
+
+void test_zmq_term_null_fails ()
+{
+    int rc = zmq_term (NULL);
+    TEST_ASSERT_EQUAL_INT (-1, rc);
+    TEST_ASSERT_EQUAL_INT (EFAULT, errno);
+}
+
+void test_zmq_ctx_shutdown_null_fails ()
+{
+    int rc = zmq_ctx_shutdown (NULL);
+    TEST_ASSERT_EQUAL_INT (-1, rc);
+    TEST_ASSERT_EQUAL_INT (EFAULT, errno);
 }
 
 int main (void)
 {
     setup_test_environment ();
 
-    test_ctx_destroy ();
-    test_ctx_shutdown ();
-
-    return 0;
+    UNITY_BEGIN ();
+    RUN_TEST (test_ctx_destroy);
+    RUN_TEST (test_ctx_shutdown);
+    RUN_TEST (test_zmq_ctx_term_null_fails);
+    RUN_TEST (test_zmq_term_null_fails);
+    RUN_TEST (test_zmq_ctx_shutdown_null_fails);
+    return UNITY_END ();
 }

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,563 @@ 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 ()
 {
-    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_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 ()
+{
+    void *null_poller = NULL;
+    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 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);
+}
 
-    void *socket = zmq_socket (ctx, ZMQ_PAIR);
-    assert (socket != NULL);
+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_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_add_fd_direct ()
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+    const fd_t fd = get_fd (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);
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_add_fd (NULL, fd, NULL, ZMQ_POLLIN));
+    test_context_socket_close (socket);
+}
 
-    rc = zmq_poller_remove (NULL, socket);
-    assert (rc == -1 && errno == EFAULT);
-    rc = zmq_poller_remove (&null_poller, socket);
-    assert (rc == -1 && errno == EFAULT);
+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);
+}
 
-    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_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_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_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_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_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);
+}
 
-    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_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;
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_wait (NULL, &event, 0));
+}
 
+void test_null_poller_pointers_wait_indirect ()
+{
     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);
+    void *null_poller = NULL;
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_wait (&null_poller, &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_all_direct ()
+{
+    zmq_poller_event_t event;
+    TEST_ASSERT_FAILURE_ERRNO (EFAULT,
+                               zmq_poller_wait_all (NULL, &event, 1, 0));
+}
 
-    rc = zmq_close (socket);
-    assert (rc == 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_poller_socket_func_t) (void *poller, void *socket);
+
+void test_with_empty_poller (extra_poller_socket_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);
+
+    extra_func (poller, socket);
+
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
+
+    test_context_socket_close (socket);
+}
+
+typedef void (*extra_poller_func_t) (void *poller);
+
+void test_with_valid_poller (extra_poller_func_t extra_func)
+{
+    void *socket = test_context_socket (ZMQ_PAIR);
+
+    void *poller = zmq_poller_new ();
+    TEST_ASSERT_NOT_NULL (poller);
+
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN));
 
-    int rc = zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN);
-    assert (rc == 0);
+    extra_func (poller);
 
-    rc = zmq_poller_wait (poller, NULL, 0);
-    assert (rc == -1 && errno == EFAULT);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
 
-    rc = zmq_poller_wait_all (poller, NULL, 1, 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));
+}
 
+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
-
-    rc = zmq_poller_destroy (&poller);
-    assert (rc == 0);
-
-    rc = zmq_close (socket);
-    assert (rc == 0);
 }
 
-void test_add_modify_remove_corner_cases (void *ctx)
-{
-    void *poller = zmq_poller_new ();
-    assert (poller != NULL);
+#define TEST_CASE_FUNC_PARAM(name, func)                                       \
+    void test_##name () { func (name); }
 
-    void *zeromq_socket = zmq_socket (ctx, ZMQ_PAIR);
-    assert (zeromq_socket != NULL);
+TEST_CASE_FUNC_PARAM (call_poller_wait_null_event_fails, test_with_valid_poller)
+TEST_CASE_FUNC_PARAM (call_poller_wait_all_null_event_fails_event_count_nonzero,
+                      test_with_valid_poller)
+TEST_CASE_FUNC_PARAM (call_poller_wait_all_null_event_fails_event_count_zero,
+                      test_with_valid_poller)
 
-    int rc = zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN);
-    assert (rc == 0);
+void call_poller_add_twice_fails (void *poller, void *socket)
+{
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_add (poller, 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, socket, NULL, ZMQ_POLLIN));
 
-    rc = zmq_poller_remove (poller, zeromq_socket);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove (poller, socket));
+}
 
+void call_poller_remove_unregistered_fails (void *poller, void *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, socket));
+}
 
+void call_poller_modify_unregistered_fails (void *poller, void *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, socket, ZMQ_POLLIN));
+}
 
+void call_poller_add_no_events (void *poller, void *socket)
+{
     //  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, socket, NULL, 0));
+}
 
+void call_poller_add_fd_twice_fails (void *poller, void * /*zeromq_socket*/)
+{
     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);
-
-    rc = zmq_poller_remove_fd (poller, plain_socket);
-    assert (rc == 0);
+    TEST_ASSERT_FAILURE_ERRNO (
+      EINVAL, zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN));
 
-    //  attempt to remove plain socket that is not present
-    rc = zmq_poller_remove_fd (poller, plain_socket);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_SUCCESS_ERRNO (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_SUCCESS_ERRNO (close (plain_socket));
+}
 
-    rc = zmq_poller_destroy (&poller);
-    assert (rc == 0);
+void call_poller_remove_fd_unregistered_fails (void *poller,
+                                               void * /*zeromq_socket*/)
+{
+    fd_t plain_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
-    rc = zmq_close (zeromq_socket);
-    assert (rc == 0);
+    //  attempt to remove plain socket that is not present
+    TEST_ASSERT_FAILURE_ERRNO (EINVAL,
+                               zmq_poller_remove_fd (poller, plain_socket));
 
-    rc = close (plain_socket);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (close (plain_socket));
 }
 
-void test_wait_corner_cases (void)
+void call_poller_modify_fd_unregistered_fails (void *poller,
+                                               void * /*zeromq_socket*/)
 {
-    void *poller = zmq_poller_new ();
-    assert (poller != NULL);
-
-    zmq_poller_event_t event;
-    int rc = zmq_poller_wait (poller, &event, 0);
-    assert (rc == -1 && errno == EAGAIN);
+    fd_t plain_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
-    //  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);
+    //  attempt to remove plain socket that is not present
+    TEST_ASSERT_FAILURE_ERRNO (
+      EINVAL, zmq_poller_modify_fd (poller, plain_socket, ZMQ_POLLIN));
 
-    rc = zmq_poller_wait_all (poller, &event, -1, 0);
-    assert (rc == -1 && errno == EINVAL);
+    TEST_ASSERT_SUCCESS_ERRNO (close (plain_socket));
+}
 
-    rc = zmq_poller_wait_all (poller, &event, 0, 0);
-    assert (rc == -1 && errno == EAGAIN);
+TEST_CASE_FUNC_PARAM (call_poller_add_twice_fails, test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_remove_unregistered_fails,
+                      test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_modify_unregistered_fails,
+                      test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_add_no_events, test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_add_fd_twice_fails, test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_remove_fd_unregistered_fails,
+                      test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_modify_fd_unregistered_fails,
+                      test_with_empty_poller)
+
+void call_poller_wait_empty_with_timeout_fails (void *poller, void * /*socket*/)
+{
+    zmq_poller_event_t event;
+    // 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_all (poller, &event, 0, -1);
-    assert (rc == -1 && errno == EFAULT);
+void call_poller_wait_empty_without_timeout_fails (void *poller,
+                                                   void * /*socket*/)
+{
+    zmq_poller_event_t event;
+    //  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_destroy (&poller);
-    assert (rc == 0);
+void call_poller_wait_all_empty_negative_count_fails (void *poller,
+                                                      void * /*socket*/)
+{
+    zmq_poller_event_t event;
+    TEST_ASSERT_FAILURE_ERRNO (EINVAL,
+                               zmq_poller_wait_all (poller, &event, -1, 0));
 }
 
-int main (void)
+void call_poller_wait_all_empty_without_timeout_fails (void *poller,
+                                                       void * /*socket*/)
 {
-    size_t len = MAX_SOCKET_STRING;
-    char my_endpoint_0[MAX_SOCKET_STRING];
-    char my_endpoint_1[MAX_SOCKET_STRING];
+    zmq_poller_event_t event;
+    TEST_ASSERT_FAILURE_ERRNO (EAGAIN,
+                               zmq_poller_wait_all (poller, &event, 0, 0));
+}
 
-    setup_test_environment ();
+void call_poller_wait_all_empty_with_timeout_fails (void *poller,
+                                                    void * /*socket*/)
+{
+    zmq_poller_event_t event;
+    //  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));
+}
 
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
+TEST_CASE_FUNC_PARAM (call_poller_wait_empty_with_timeout_fails,
+                      test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_wait_empty_without_timeout_fails,
+                      test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_wait_all_empty_negative_count_fails,
+                      test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_wait_all_empty_without_timeout_fails,
+                      test_with_empty_poller)
+TEST_CASE_FUNC_PARAM (call_poller_wait_all_empty_with_timeout_fails,
+                      test_with_empty_poller)
+
+void bind_loopback_ipv4 (void *socket, char *my_endpoint, size_t len)
+{
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (socket, "tcp://127.0.0.1:*"));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (socket, ZMQ_LAST_ENDPOINT, my_endpoint, &len));
+}
 
+void test_poll_basic ()
+{
     //  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);
 
-    void *sink = zmq_socket (ctx, ZMQ_PULL);
-    assert (sink);
-    rc = zmq_connect (sink, my_endpoint_0);
-    assert (rc == 0);
-
-    void *bowl = zmq_socket (ctx, ZMQ_PULL);
-    assert (bowl);
+    size_t len = MAX_SOCKET_STRING;
+    char my_endpoint[MAX_SOCKET_STRING];
+    bind_loopback_ipv4 (vent, my_endpoint, len);
 
-#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);
-    len = MAX_SOCKET_STRING;
-    rc = zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len);
-    assert (rc == 0);
-
-    void *client = zmq_socket (ctx, ZMQ_CLIENT);
-    assert (client);
-#endif
+    void *sink = test_context_socket (ZMQ_PULL);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sink, my_endpoint));
 
     //  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);
+    zmq_poller_event_t event;
+    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));
+
+    //  Clean up
+    test_context_socket_close (vent);
+    test_context_socket_close (sink);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
+}
+
+void test_poll_fd ()
+{
+    //  Create sockets
+    void *vent = test_context_socket (ZMQ_PUSH);
+
+    size_t len = MAX_SOCKET_STRING;
+    char my_endpoint[MAX_SOCKET_STRING];
+    bind_loopback_ipv4 (vent, my_endpoint, len);
+
+    void *bowl = test_context_socket (ZMQ_PULL);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (bowl, my_endpoint));
+
+    //  Set up poller
+    void *poller = zmq_poller_new ();
 
     //  Check we can poll an FD
-    rc = zmq_connect (bowl, my_endpoint_0);
-    assert (rc == 0);
+    const fd_t fd = get_fd (bowl);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_poller_add_fd (poller, fd, bowl, ZMQ_POLLIN));
 
-    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);
+    zmq_poller_event_t event;
+    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));
 
+    //  Clean up
+    test_context_socket_close (vent);
+    test_context_socket_close (bowl);
+
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
+}
+
+void test_poll_client_server ()
+{
 #if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
+    //  Create sockets
+    void *server = test_context_socket (ZMQ_SERVER);
+
+    size_t len = MAX_SOCKET_STRING;
+    char my_endpoint[MAX_SOCKET_STRING];
+    bind_loopback_ipv4 (server, my_endpoint, len);
+
+    void *client = test_context_socket (ZMQ_CLIENT);
+
+    //  Set up poller
+    void *poller = zmq_poller_new ();
+
     //  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));
+
+    const char *client_server_msg = "I";
+    send_string_expect_success (client, client_server_msg, 0);
+
+    zmq_poller_event_t event;
+    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);
-#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);
-#if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
-    rc = zmq_close (server);
-    assert (rc == 0);
-    rc = zmq_close (client);
-    assert (rc == 0);
-#endif
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove (poller, server));
 
-    test_null_poller_pointers (ctx);
-    test_null_socket_pointers ();
-    test_null_event_pointers (ctx);
+    //  Clean up
+    test_context_socket_close (server);
+    test_context_socket_close (client);
 
-    test_add_modify_remove_corner_cases (ctx);
-    test_wait_corner_cases ();
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
+#endif
+}
 
-    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_call_poller_wait_null_event_fails);
+    RUN_TEST (test_call_poller_wait_all_null_event_fails_event_count_nonzero);
+    RUN_TEST (test_call_poller_wait_all_null_event_fails_event_count_zero);
+
+    RUN_TEST (test_call_poller_add_twice_fails);
+    RUN_TEST (test_call_poller_remove_unregistered_fails);
+    RUN_TEST (test_call_poller_modify_unregistered_fails);
+    RUN_TEST (test_call_poller_add_no_events);
+    RUN_TEST (test_call_poller_add_fd_twice_fails);
+    RUN_TEST (test_call_poller_remove_fd_unregistered_fails);
+    RUN_TEST (test_call_poller_modify_fd_unregistered_fails);
+
+    RUN_TEST (test_call_poller_wait_empty_with_timeout_fails);
+    RUN_TEST (test_call_poller_wait_empty_without_timeout_fails);
+    RUN_TEST (test_call_poller_wait_all_empty_negative_count_fails);
+    RUN_TEST (test_call_poller_wait_all_empty_without_timeout_fails);
+    RUN_TEST (test_call_poller_wait_all_empty_with_timeout_fails);
+
+    RUN_TEST (test_poll_basic);
+    RUN_TEST (test_poll_fd);
+    RUN_TEST (test_poll_client_server);
+
+    return UNITY_END ();
 }

tests/test_reconnect_ivl.cpp

@@ -28,52 +28,54 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
 
+#include <unity.h>
 
-#ifndef ZMQ_HAVE_WINDOWS
-void test_reconnect_ivl_ipc (void)
+void setUp ()
 {
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
+    setup_test_context ();
+}
 
-    void *sb = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sb);
-    int rc = zmq_bind (sb, "ipc:///tmp/test_reconnect_ivl");
-    assert (rc == 0);
+void tearDown ()
+{
+    teardown_test_context ();
+}
 
-    void *sc = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sc);
+void test_reconnect_ivl_against_pair_socket (const char *my_endpoint, void *sb)
+{
+    void *sc = test_context_socket (ZMQ_PAIR);
     int interval = -1;
-    rc = zmq_setsockopt (sc, ZMQ_RECONNECT_IVL, &interval, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_connect (sc, "ipc:///tmp/test_reconnect_ivl");
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sc, ZMQ_RECONNECT_IVL, &interval, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint));
 
     bounce (sb, sc);
 
-    rc = zmq_unbind (sb, "ipc:///tmp/test_reconnect_ivl");
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb, my_endpoint));
 
     expect_bounce_fail (sb, sc);
 
-    rc = zmq_bind (sb, "ipc:///tmp/test_reconnect_ivl");
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, my_endpoint));
 
     expect_bounce_fail (sb, sc);
 
-    rc = zmq_connect (sc, "ipc:///tmp/test_reconnect_ivl");
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint));
 
     bounce (sb, sc);
 
-    rc = zmq_close (sc);
-    assert (rc == 0);
+    test_context_socket_close (sc);
+}
 
-    rc = zmq_close (sb);
-    assert (rc == 0);
+#ifndef ZMQ_HAVE_WINDOWS
+void test_reconnect_ivl_ipc (void)
+{
+    const char *ipc_endpoint = "ipc:///tmp/test_reconnect_ivl";
+    void *sb = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, ipc_endpoint));
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+    test_reconnect_ivl_against_pair_socket (ipc_endpoint, sb);
+    test_context_socket_close (sb);
 }
 #endif
 
@@ -81,69 +83,39 @@ void test_reconnect_ivl_tcp (const char *address)
 {
     size_t len = MAX_SOCKET_STRING;
     char my_endpoint[MAX_SOCKET_STRING];
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
-
-    if (streq (address, "tcp://[::1]:*")) {
-        if (is_ipv6_available ()) {
-            zmq_ctx_set (ctx, ZMQ_IPV6, 1);
-        } else {
-            zmq_ctx_term (ctx);
-            return;
-        }
-    }
-
-    void *sb = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sb);
-    int rc = zmq_bind (sb, address);
-    assert (rc == 0);
-    rc = zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
-    assert (rc == 0);
-
-    void *sc = zmq_socket (ctx, ZMQ_PAIR);
-    assert (sc);
-    int interval = -1;
-    rc = zmq_setsockopt (sc, ZMQ_RECONNECT_IVL, &interval, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_connect (sc, my_endpoint);
-    assert (rc == 0);
-
-    bounce (sb, sc);
 
-    rc = zmq_unbind (sb, my_endpoint);
-    assert (rc == 0);
+    void *sb = test_context_socket (ZMQ_PAIR);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, address));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, my_endpoint, &len));
 
-    expect_bounce_fail (sb, sc);
-
-    rc = zmq_bind (sb, my_endpoint);
-    assert (rc == 0);
-
-    expect_bounce_fail (sb, sc);
-
-    rc = zmq_connect (sc, my_endpoint);
-    assert (rc == 0);
-
-    bounce (sb, sc);
-
-    rc = zmq_close (sc);
-    assert (rc == 0);
+    test_reconnect_ivl_against_pair_socket (my_endpoint, sb);
+    test_context_socket_close (sb);
+}
 
-    rc = zmq_close (sb);
-    assert (rc == 0);
+void test_reconnect_ivl_tcp_ipv4 ()
+{
+    test_reconnect_ivl_tcp ("tcp://127.0.0.1:*");
+}
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+void test_reconnect_ivl_tcp_ipv6 ()
+{
+    if (is_ipv6_available ()) {
+        zmq_ctx_set (get_test_context (), ZMQ_IPV6, 1);
+        test_reconnect_ivl_tcp ("tcp://[::1]:*");
+    }
 }
 
 int main (void)
 {
     setup_test_environment ();
 
+    UNITY_BEGIN ();
 #ifndef ZMQ_HAVE_WINDOWS
-    test_reconnect_ivl_ipc ();
+    RUN_TEST (test_reconnect_ivl_ipc);
 #endif
-    test_reconnect_ivl_tcp ("tcp://127.0.0.1:*");
-    test_reconnect_ivl_tcp ("tcp://[::1]:*");
+    RUN_TEST (test_reconnect_ivl_tcp_ipv4);
+    RUN_TEST (test_reconnect_ivl_tcp_ipv6);
 
-    return 0;
+    return UNITY_END ();
 }

tests/test_thread_safe.cpp

@@ -28,41 +28,42 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
+
+#include <unity.h>
+
+void setUp ()
+{
+    setup_test_context ();
+}
+
+void tearDown ()
+{
+    teardown_test_context ();
+}
 
 //  Client threads loop on send/recv until told to exit
 void client_thread (void *client)
 {
-    char data = 0;
     for (int count = 0; count < 15000; count++) {
-        int rc = zmq_send (client, &data, 1, 0);
-        assert (rc == 1);
+        send_string_expect_success (client, "0", 0);
     }
-    data = 1;
-    int rc = zmq_send (client, &data, 1, 0);
-    assert (rc == 1);
+    send_string_expect_success (client, "1", 0);
 }
 
-int main (void)
+void test_thread_safe ()
 {
-    setup_test_environment ();
     size_t len = MAX_SOCKET_STRING;
     char my_endpoint[MAX_SOCKET_STRING];
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
 
-    void *server = zmq_socket (ctx, ZMQ_SERVER);
-    int rc = zmq_bind (server, "tcp://127.0.0.1:*");
-    assert (rc == 0);
-    rc = zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
-    assert (rc == 0);
+    void *server = test_context_socket (ZMQ_SERVER);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (server, "tcp://127.0.0.1:*"));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint, &len));
 
-    void *client = zmq_socket (ctx, ZMQ_CLIENT);
-    int thread_safe;
-    size_t size = sizeof (int);
-    zmq_getsockopt (client, ZMQ_THREAD_SAFE, &thread_safe, &size);
-    assert (thread_safe == 1);
-    rc = zmq_connect (client, my_endpoint);
-    assert (rc == 0);
+    void *client = test_context_socket (ZMQ_CLIENT);
+
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, my_endpoint));
 
     void *t1 = zmq_threadstart (client_thread, client);
     void *t2 = zmq_threadstart (client_thread, client);
@@ -70,21 +71,49 @@ int main (void)
     char data;
     int threads_completed = 0;
     while (threads_completed < 2) {
-        zmq_recv (server, &data, 1, 0);
-        if (data == 1)
+        TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (server, &data, 1, 0));
+        if (data == '1')
             threads_completed++; //  Thread ended
     }
     zmq_threadclose (t1);
     zmq_threadclose (t2);
 
-    rc = zmq_close (server);
-    assert (rc == 0);
+    test_context_socket_close (server);
+    test_context_socket_close (client);
+}
 
-    rc = zmq_close (client);
-    assert (rc == 0);
+void test_getsockopt_thread_safe (void *const socket)
+{
+    int thread_safe;
+    size_t size = sizeof (int);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (socket, ZMQ_THREAD_SAFE, &thread_safe, &size));
+    TEST_ASSERT_EQUAL_INT (1, thread_safe);
+}
+
+void test_client_getsockopt_thread_safe ()
+{
+    void *client = test_context_socket (ZMQ_CLIENT);
+    test_getsockopt_thread_safe (client);
+    test_context_socket_close (client);
+}
+
+void test_server_getsockopt_thread_safe ()
+{
+    void *server = test_context_socket (ZMQ_SERVER);
+    test_getsockopt_thread_safe (server);
+    test_context_socket_close (server);
+}
+
+int main (void)
+{
+    setup_test_environment ();
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+    // TODO this file could be merged with test_client_server
+    UNITY_BEGIN ();
+    RUN_TEST (test_client_getsockopt_thread_safe);
+    RUN_TEST (test_server_getsockopt_thread_safe);
+    RUN_TEST (test_thread_safe);
 
-    return 0;
+    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;