diff --git a/Makefile.am b/Makefile.am
index 8b65d210..c7e6bdf8 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -460,7 +460,8 @@ tests_test_reqrep_inproc_LDADD = src/libzmq.la
 tests_test_reqrep_tcp_SOURCES = \
 	tests/test_reqrep_tcp.cpp \
 	tests/testutil.hpp
-tests_test_reqrep_tcp_LDADD = src/libzmq.la
+tests_test_reqrep_tcp_LDADD = src/libzmq.la ${UNITY_LIBS}
+tests_test_reqrep_tcp_CPPFLAGS = ${UNITY_CPPFLAGS}
 
 tests_test_hwm_SOURCES = tests/test_hwm.cpp tests/testutil_unity.hpp
 tests_test_hwm_LDADD = src/libzmq.la ${UNITY_LIBS}
diff --git a/tests/test_reqrep_tcp.cpp b/tests/test_reqrep_tcp.cpp
index 27aa176e..9f308f78 100644
--- a/tests/test_reqrep_tcp.cpp
+++ b/tests/test_reqrep_tcp.cpp
@@ -28,129 +28,104 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
 
-void test_single_connect (const char *address)
+void setUp ()
+{
+    setup_test_context ();
+}
+
+void tearDown ()
+{
+    teardown_test_context ();
+}
+
+const char *bind_address_loopback_ipv4 = "tcp://127.0.0.1:*";
+const char *bind_address_loopback_ipv6 = "tcp://[::1]:*";
+
+const char *get_loopback_bin_address (bool ipv6)
+{
+    if (ipv6 && !is_ipv6_available ()) {
+        TEST_IGNORE_MESSAGE ("ipv6 is not available");
+    }
+
+    return ipv6 ? bind_address_loopback_ipv6 : bind_address_loopback_ipv4;
+}
+
+void test_single_connect (int ipv6)
 {
     size_t len = MAX_SOCKET_STRING;
     char my_endpoint[MAX_SOCKET_STRING];
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
 
-    int ipv6;
-    if (streq (address, "tcp://127.0.0.1:*"))
-        ipv6 = 0;
-    else if (streq (address, "tcp://[::1]:*"))
-        ipv6 = 1;
-    else
-        assert (false);
+    const char *address = get_loopback_bin_address (ipv6);
 
-    if (ipv6 && !is_ipv6_available ()) {
-        zmq_ctx_term (ctx);
-        return;
-    }
+    void *sb = test_context_socket (ZMQ_REP);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb, address));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (sb, ZMQ_LAST_ENDPOINT, my_endpoint, &len));
 
-    void *sb = zmq_socket (ctx, ZMQ_REP);
-    assert (sb);
-    int rc = zmq_setsockopt (sb, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    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_REQ);
-    assert (sc);
-    rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_connect (sc, my_endpoint);
-    assert (rc == 0);
+    void *sc = test_context_socket (ZMQ_REQ);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint));
 
     bounce (sb, sc);
 
-    rc = zmq_disconnect (sc, my_endpoint);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc, my_endpoint));
 
-    rc = zmq_unbind (sb, my_endpoint);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb, my_endpoint));
 
-    rc = zmq_close (sc);
-    assert (rc == 0);
-
-    rc = zmq_close (sb);
-    assert (rc == 0);
-
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+    test_context_socket_close (sc);
+    test_context_socket_close (sb);
 }
 
-void test_multi_connect (const char *address)
+void test_multi_connect (int ipv6)
 {
     size_t len = MAX_SOCKET_STRING;
     char my_endpoint_0[MAX_SOCKET_STRING];
     char my_endpoint_1[MAX_SOCKET_STRING];
     char my_endpoint_2[MAX_SOCKET_STRING];
     char my_endpoint_3[MAX_SOCKET_STRING * 2];
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
 
-    int ipv6;
-    if (streq (address, "tcp://127.0.0.1:*"))
-        ipv6 = 0;
-    else if (streq (address, "tcp://[::1]:*"))
-        ipv6 = 1;
-    else
-        assert (false);
+    const char *address = get_loopback_bin_address (ipv6);
 
-    if (ipv6 && !is_ipv6_available ()) {
-        zmq_ctx_term (ctx);
-        return;
-    }
+    void *sb0 = test_context_socket (ZMQ_REP);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sb0, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb0, address));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (sb0, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len));
 
-    void *sb0 = zmq_socket (ctx, ZMQ_REP);
-    assert (sb0);
-    int rc = zmq_setsockopt (sb0, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_bind (sb0, address);
-    assert (rc == 0);
-    rc = zmq_getsockopt (sb0, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len);
-    assert (rc == 0);
-
-    void *sb1 = zmq_socket (ctx, ZMQ_REP);
-    assert (sb1);
-    rc = zmq_setsockopt (sb1, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_bind (sb1, address);
-    assert (rc == 0);
+    void *sb1 = test_context_socket (ZMQ_REP);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sb1, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb1, address));
     len = MAX_SOCKET_STRING;
-    rc = zmq_getsockopt (sb1, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (sb1, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len));
 
-    void *sb2 = zmq_socket (ctx, ZMQ_REP);
-    assert (sb2);
-    rc = zmq_setsockopt (sb2, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_bind (sb2, address);
-    assert (rc == 0);
+    void *sb2 = test_context_socket (ZMQ_REP);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sb2, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb2, address));
     len = MAX_SOCKET_STRING;
-    rc = zmq_getsockopt (sb2, ZMQ_LAST_ENDPOINT, my_endpoint_2, &len);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (sb2, ZMQ_LAST_ENDPOINT, my_endpoint_2, &len));
 
-    void *sc = zmq_socket (ctx, ZMQ_REQ);
-    assert (sc);
-    rc = zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_connect (sc, my_endpoint_0);
-    assert (rc == 0);
-    rc = zmq_connect (sc, my_endpoint_1);
-    assert (rc == 0);
+    void *sc = test_context_socket (ZMQ_REQ);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sc, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint_0));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint_1));
     if (!ipv6)
         sprintf (my_endpoint_3, "tcp://127.0.0.1:5564;%s",
                  strrchr (my_endpoint_2, '/') + 1);
     else
         sprintf (my_endpoint_3, "tcp://[::1]:5564;%s",
                  strrchr (my_endpoint_2, '/') + 1);
-    rc = zmq_connect (sc, my_endpoint_3);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint_3));
 
     bounce (sb0, sc);
     bounce (sb1, sc);
@@ -160,39 +135,21 @@ void test_multi_connect (const char *address)
     bounce (sb2, sc);
     bounce (sb0, sc);
 
-    rc = zmq_disconnect (sc, my_endpoint_0);
-    assert (rc == 0);
-    rc = zmq_disconnect (sc, my_endpoint_3);
-    assert (rc == 0);
-    rc = zmq_disconnect (sc, my_endpoint_1);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc, my_endpoint_0));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc, my_endpoint_3));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc, my_endpoint_1));
 
-    rc = zmq_unbind (sb0, my_endpoint_0);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb0, my_endpoint_0));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb1, my_endpoint_1));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb2, my_endpoint_2));
 
-    rc = zmq_unbind (sb1, my_endpoint_1);
-    assert (rc == 0);
-
-    rc = zmq_unbind (sb2, my_endpoint_2);
-    assert (rc == 0);
-
-    rc = zmq_close (sc);
-    assert (rc == 0);
-
-    rc = zmq_close (sb0);
-    assert (rc == 0);
-
-    rc = zmq_close (sb1);
-    assert (rc == 0);
-
-    rc = zmq_close (sb2);
-    assert (rc == 0);
-
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+    test_context_socket_close (sc);
+    test_context_socket_close (sb0);
+    test_context_socket_close (sb1);
+    test_context_socket_close (sb2);
 }
 
-void test_multi_connect_same_port (const char *address)
+void test_multi_connect_same_port (int ipv6)
 {
     size_t len = MAX_SOCKET_STRING;
     char my_endpoint_0[MAX_SOCKET_STRING];
@@ -201,82 +158,59 @@ void test_multi_connect_same_port (const char *address)
     char my_endpoint_3[MAX_SOCKET_STRING * 2];
     char my_endpoint_4[MAX_SOCKET_STRING * 2];
     char my_endpoint_5[MAX_SOCKET_STRING * 2];
-    void *ctx = zmq_ctx_new ();
-    assert (ctx);
 
-    int ipv6;
-    if (streq (address, "tcp://127.0.0.1:*"))
-        ipv6 = 0;
-    else if (streq (address, "tcp://[::1]:*"))
-        ipv6 = 1;
-    else
-        assert (false);
+    const char *address = get_loopback_bin_address (ipv6);
 
-    if (ipv6 && !is_ipv6_available ()) {
-        zmq_ctx_term (ctx);
-        return;
-    }
+    void *sb0 = test_context_socket (ZMQ_REP);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sb0, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb0, address));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (sb0, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len));
 
-    void *sb0 = zmq_socket (ctx, ZMQ_REP);
-    assert (sb0);
-    int rc = zmq_setsockopt (sb0, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_bind (sb0, address);
-    assert (rc == 0);
-    rc = zmq_getsockopt (sb0, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len);
-    assert (rc == 0);
-
-    void *sb1 = zmq_socket (ctx, ZMQ_REP);
-    assert (sb1);
-    rc = zmq_setsockopt (sb1, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    rc = zmq_bind (sb1, address);
-    assert (rc == 0);
+    void *sb1 = test_context_socket (ZMQ_REP);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sb1, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (sb1, address));
     len = MAX_SOCKET_STRING;
-    rc = zmq_getsockopt (sb1, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_getsockopt (sb1, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len));
 
-    void *sc0 = zmq_socket (ctx, ZMQ_REQ);
-    assert (sc0);
-    rc = zmq_setsockopt (sc0, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
+    void *sc0 = test_context_socket (ZMQ_REQ);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sc0, ZMQ_IPV6, &ipv6, sizeof (int)));
     if (!ipv6)
         sprintf (my_endpoint_2, "tcp://127.0.0.1:5564;%s",
                  strrchr (my_endpoint_0, '/') + 1);
     else
         sprintf (my_endpoint_2, "tcp://[::1]:5564;%s",
                  strrchr (my_endpoint_0, '/') + 1);
-    rc = zmq_connect (sc0, my_endpoint_2);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc0, my_endpoint_2));
     if (!ipv6)
         sprintf (my_endpoint_3, "tcp://127.0.0.1:5565;%s",
                  strrchr (my_endpoint_1, '/') + 1);
     else
         sprintf (my_endpoint_3, "tcp://[::1]:5565;%s",
                  strrchr (my_endpoint_1, '/') + 1);
-    rc = zmq_connect (sc0, my_endpoint_3);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc0, my_endpoint_3));
 
-    void *sc1 = zmq_socket (ctx, ZMQ_REQ);
-    assert (sc1);
-    rc = zmq_setsockopt (sc1, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
+    void *sc1 = test_context_socket (ZMQ_REQ);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sc1, ZMQ_IPV6, &ipv6, sizeof (int)));
     if (!ipv6)
         sprintf (my_endpoint_4, "tcp://127.0.0.1:5565;%s",
                  strrchr (my_endpoint_0, '/') + 1);
     else
         sprintf (my_endpoint_4, "tcp://[::1]:5565;%s",
                  strrchr (my_endpoint_0, '/') + 1);
-    rc = zmq_connect (sc1, my_endpoint_4);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc1, my_endpoint_4));
     if (!ipv6)
         sprintf (my_endpoint_5, "tcp://127.0.0.1:5564;%s",
                  strrchr (my_endpoint_1, '/') + 1);
     else
         sprintf (my_endpoint_5, "tcp://[::1]:5564;%s",
                  strrchr (my_endpoint_1, '/') + 1);
-    rc = zmq_connect (sc1, my_endpoint_5);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc1, my_endpoint_5));
 
     bounce (sb0, sc0);
     bounce (sb1, sc0);
@@ -285,52 +219,61 @@ void test_multi_connect_same_port (const char *address)
     bounce (sb0, sc0);
     bounce (sb1, sc0);
 
-    rc = zmq_disconnect (sc1, my_endpoint_4);
-    assert (rc == 0);
-    rc = zmq_disconnect (sc1, my_endpoint_5);
-    assert (rc == 0);
-    rc = zmq_disconnect (sc0, my_endpoint_2);
-    assert (rc == 0);
-    rc = zmq_disconnect (sc0, my_endpoint_3);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc1, my_endpoint_4));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc1, my_endpoint_5));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc0, my_endpoint_2));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc0, my_endpoint_3));
 
-    rc = zmq_unbind (sb0, my_endpoint_0);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb0, my_endpoint_0));
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb1, my_endpoint_1));
 
-    rc = zmq_unbind (sb1, my_endpoint_1);
-    assert (rc == 0);
+    test_context_socket_close (sc0);
+    test_context_socket_close (sc1);
+    test_context_socket_close (sb0);
+    test_context_socket_close (sb1);
+}
 
-    rc = zmq_close (sc0);
-    assert (rc == 0);
+void test_single_connect_ipv4 ()
+{
+    test_single_connect (false);
+}
 
-    rc = zmq_close (sc1);
-    assert (rc == 0);
+void test_multi_connect_ipv4 ()
+{
+    test_multi_connect (false);
+}
 
-    rc = zmq_close (sb0);
-    assert (rc == 0);
+void test_multi_connect_same_port_ipv4 ()
+{
+    test_multi_connect_same_port (false);
+}
 
-    rc = zmq_close (sb1);
-    assert (rc == 0);
+void test_single_connect_ipv6 ()
+{
+    test_single_connect (true);
+}
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+void test_multi_connect_ipv6 ()
+{
+    test_multi_connect (true);
+}
+
+void test_multi_connect_same_port_ipv6 ()
+{
+    test_multi_connect_same_port (true);
 }
 
 int main (void)
 {
     setup_test_environment ();
 
-    test_single_connect ("tcp://127.0.0.1:*");
+    UNITY_BEGIN ();
+    RUN_TEST (test_single_connect_ipv4);
+    RUN_TEST (test_multi_connect_ipv4);
+    RUN_TEST (test_multi_connect_same_port_ipv4);
+    RUN_TEST (test_single_connect_ipv6);
+    RUN_TEST (test_multi_connect_ipv6);
+    RUN_TEST (test_multi_connect_same_port_ipv6);
 
-    test_multi_connect ("tcp://127.0.0.1:*");
-
-    test_multi_connect_same_port ("tcp://127.0.0.1:*");
-
-    test_single_connect ("tcp://[::1]:*");
-
-    test_multi_connect ("tcp://[::1]:*");
-
-    test_multi_connect_same_port ("tcp://[::1]:*");
-
-    return 0;
+    return UNITY_END ();
 }