generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2025-03-04 19:13:35 +01:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
Migrate test_reqrep_tcp to unity
This commit is contained in:
Luca Boccassi 2018-03-21 15:43:26 +00:00 committed by GitHub
commit 45681798b7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 139 additions and 236 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile.am
View File

@ -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}

356
tests/test_reqrep_tcp.cpp
View File

@ -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);
void *sb = test_context_socket (ZMQ_REP);
bind_loopback (sb, ipv6, my_endpoint, len);
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 *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);
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 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 (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);
void *sb0 = test_context_socket (ZMQ_REP);
bind_loopback (sb0, ipv6, my_endpoint_0, len);
if (ipv6 && !is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb1 = test_context_socket (ZMQ_REP);
bind_loopback (sb1, ipv6, my_endpoint_1, 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 *sb2 = test_context_socket (ZMQ_REP);
bind_loopback (sb2, ipv6, my_endpoint_2, len);
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 *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);
/// see comment on zmq_disconnect/zmq_unbind in test_single_connect
rc = zmq_unbind (sb0, my_endpoint_0);
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 (sb1, my_endpoint_1);
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 (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 +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);
void *sb0 = test_context_socket (ZMQ_REP);
bind_loopback (sb0, ipv6, my_endpoint_0, len);
if (ipv6 && !is_ipv6_available ()) {
zmq_ctx_term (ctx);
return;
}
void *sb1 = test_context_socket (ZMQ_REP);
bind_loopback (sb1, ipv6, my_endpoint_1, 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 *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 *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 *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);
/// see comment on zmq_disconnect/zmq_unbind in test_single_connect
rc = zmq_unbind (sb0, my_endpoint_0);
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 (sb1, my_endpoint_1);
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 (sc0);
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 (sc1);
assert (rc == 0);
void test_single_connect_ipv4 ()
{
test_single_connect (false);
}
rc = zmq_close (sb0);
assert (rc == 0);
void test_multi_connect_ipv4 ()
{
test_multi_connect (false);
}
rc = zmq_close (sb1);
assert (rc == 0);
void test_multi_connect_same_port_ipv4 ()
{
test_multi_connect_same_port (false);
}
rc = zmq_ctx_term (ctx);
assert (rc == 0);
void test_single_connect_ipv6 ()
{
test_single_connect (true);
}
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 ();
}

16
tests/testutil_unity.hpp
View File

@ -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);
}