generic-library/libzmq
1
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2024-12-12 10:33:52 +01:00
Code Issues Projects Releases Wiki Activity

Problem: test_reqrep_tcp not yet using unity

Browse Source 
Solution: migrate to unity
This commit is contained in:
Simon Giesecke 2018-03-21 13:54:23 +01:00
parent 15b3dccf47
commit c84c3a525a
2 changed files with 144 additions and 200 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}

341
tests/test_reqrep_tcp.cpp
View File

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