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

Migrate test_reqrep_tcp to unity

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}

tests/test_reqrep_tcp.cpp

@@ -28,129 +28,78 @@
 */
 
 #include "testutil.hpp"
+#include "testutil_unity.hpp"
 
-void test_single_connect (const char *address)
+void setUp ()
+{
+    setup_test_context ();
+}
+
+void tearDown ()
+{
+    teardown_test_context ();
+}
+
+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);
-
-    if (ipv6 && !is_ipv6_available ()) {
-        zmq_ctx_term (ctx);
-        return;
-    }
-
-    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 *sb = test_context_socket (ZMQ_REP);
+    bind_loopback (sb, ipv6, my_endpoint, len);
+
+    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);
+    // the sockets are disconnected and unbound explicitly in this test case
+    // to check that this can be done successfully with the expected
+    // endpoints/addresses
 
-    rc = zmq_unbind (sb, my_endpoint);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_disconnect (sc, my_endpoint));
 
-    rc = zmq_close (sc);
-    assert (rc == 0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_unbind (sb, my_endpoint));
 
-    rc = zmq_close (sb);
-    assert (rc == 0);
+    test_context_socket_close (sc);
+    test_context_socket_close (sb);
+}
 
-    rc = zmq_ctx_term (ctx);
-    assert (rc == 0);
+void make_connect_address (char *connect_address,
+                           const int ipv6,
+                           const int port,
+                           const char *bind_address)
+{
+    sprintf (connect_address, "tcp://%s:%i;%s", ipv6 ? "[::1]" : "127.0.0.1",
+             port, strrchr (bind_address, '/') + 1);
 }
 
-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);
-
-    if (ipv6 && !is_ipv6_available ()) {
-        zmq_ctx_term (ctx);
-        return;
-    }
-
-    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);
-    len = MAX_SOCKET_STRING;
-    rc = zmq_getsockopt (sb1, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len);
-    assert (rc == 0);
-
-    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);
-    len = MAX_SOCKET_STRING;
-    rc = zmq_getsockopt (sb2, ZMQ_LAST_ENDPOINT, my_endpoint_2, &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_0);
-    assert (rc == 0);
-    rc = zmq_connect (sc, my_endpoint_1);
-    assert (rc == 0);
-    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);
+
+    void *sb0 = test_context_socket (ZMQ_REP);
+    bind_loopback (sb0, ipv6, my_endpoint_0, len);
+
+    void *sb1 = test_context_socket (ZMQ_REP);
+    bind_loopback (sb1, ipv6, my_endpoint_1, len);
+
+    void *sb2 = test_context_socket (ZMQ_REP);
+    bind_loopback (sb2, ipv6, my_endpoint_2, len);
+
+    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));
+    make_connect_address (my_endpoint_3, ipv6, 5564, my_endpoint_2);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc, my_endpoint_3));
 
     bounce (sb0, sc);
     bounce (sb1, sc);
@@ -160,39 +109,23 @@ 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);
-
-    rc = zmq_unbind (sb0, my_endpoint_0);
-    assert (rc == 0);
-
-    rc = zmq_unbind (sb1, my_endpoint_1);
-    assert (rc == 0);
+    /// see comment on zmq_disconnect/zmq_unbind in test_single_connect
 
-    rc = zmq_unbind (sb2, my_endpoint_2);
-    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_close (sc);
-    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_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 +134,28 @@ 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);
-
-    if (ipv6 && !is_ipv6_available ()) {
-        zmq_ctx_term (ctx);
-        return;
-    }
-
-    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);
-    len = MAX_SOCKET_STRING;
-    rc = zmq_getsockopt (sb1, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len);
-    assert (rc == 0);
-
-    void *sc0 = zmq_socket (ctx, ZMQ_REQ);
-    assert (sc0);
-    rc = zmq_setsockopt (sc0, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    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);
-    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);
-
-    void *sc1 = zmq_socket (ctx, ZMQ_REQ);
-    assert (sc1);
-    rc = zmq_setsockopt (sc1, ZMQ_IPV6, &ipv6, sizeof (int));
-    assert (rc == 0);
-    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);
-    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);
+
+    void *sb0 = test_context_socket (ZMQ_REP);
+    bind_loopback (sb0, ipv6, my_endpoint_0, len);
+
+    void *sb1 = test_context_socket (ZMQ_REP);
+    bind_loopback (sb1, ipv6, my_endpoint_1, len);
+
+    void *sc0 = test_context_socket (ZMQ_REQ);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sc0, ZMQ_IPV6, &ipv6, sizeof (int)));
+    make_connect_address (my_endpoint_2, ipv6, 5564, my_endpoint_0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc0, my_endpoint_2));
+    make_connect_address (my_endpoint_3, ipv6, 5565, my_endpoint_1);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc0, my_endpoint_3));
+
+    void *sc1 = test_context_socket (ZMQ_REQ);
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (sc1, ZMQ_IPV6, &ipv6, sizeof (int)));
+    make_connect_address (my_endpoint_4, ipv6, 5565, my_endpoint_0);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc1, my_endpoint_4));
+    make_connect_address (my_endpoint_5, ipv6, 5564, my_endpoint_1);
+    TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sc1, my_endpoint_5));
 
     bounce (sb0, sc0);
     bounce (sb1, sc0);
@@ -285,52 +164,63 @@ 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);
-
-    rc = zmq_unbind (sb0, my_endpoint_0);
-    assert (rc == 0);
+    /// see comment on zmq_disconnect/zmq_unbind in test_single_connect
 
-    rc = zmq_unbind (sb1, my_endpoint_1);
-    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_close (sc0);
-    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_close (sc1);
-    assert (rc == 0);
-
-    rc = zmq_close (sb0);
-    assert (rc == 0);
-
-    rc = zmq_close (sb1);
-    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_ctx_term (ctx);
-    assert (rc == 0);
+void test_single_connect_ipv4 ()
+{
+    test_single_connect (false);
 }
 
-int main (void)
+void test_multi_connect_ipv4 ()
 {
-    setup_test_environment ();
+    test_multi_connect (false);
+}
 
-    test_single_connect ("tcp://127.0.0.1:*");
+void test_multi_connect_same_port_ipv4 ()
+{
+    test_multi_connect_same_port (false);
+}
 
-    test_multi_connect ("tcp://127.0.0.1:*");
+void test_single_connect_ipv6 ()
+{
+    test_single_connect (true);
+}
 
-    test_multi_connect_same_port ("tcp://127.0.0.1:*");
+void test_multi_connect_ipv6 ()
+{
+    test_multi_connect (true);
+}
 
-    test_single_connect ("tcp://[::1]:*");
+void test_multi_connect_same_port_ipv6 ()
+{
+    test_multi_connect_same_port (true);
+}
 
-    test_multi_connect ("tcp://[::1]:*");
+int main (void)
+{
+    setup_test_environment ();
 
-    test_multi_connect_same_port ("tcp://[::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);
 
-    return 0;
+    return UNITY_END ();
 }

tests/testutil_unity.hpp

@@ -192,9 +192,21 @@ void *test_context_socket_close (void *socket)
     return socket;
 }
 
-void bind_loopback_ipv4 (void *socket, char *my_endpoint, size_t len)
+void bind_loopback (void *socket, int ipv6, char *my_endpoint, size_t len)
 {
-    TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (socket, "tcp://127.0.0.1:*"));
+    if (ipv6 && !is_ipv6_available ()) {
+        TEST_IGNORE_MESSAGE ("ipv6 is not available");
+    }
+
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_setsockopt (socket, ZMQ_IPV6, &ipv6, sizeof (int)));
+    TEST_ASSERT_SUCCESS_ERRNO (
+      zmq_bind (socket, ipv6 ? "tcp://[::1]:*" : "tcp://127.0.0.1:*"));
     TEST_ASSERT_SUCCESS_ERRNO (
       zmq_getsockopt (socket, ZMQ_LAST_ENDPOINT, my_endpoint, &len));
 }
+
+void bind_loopback_ipv4 (void *socket, char *my_endpoint, size_t len)
+{
+    bind_loopback (socket, false, my_endpoint, len);
+}