Skip to content

L
libzmq
Commit 713f075f authored by Simon Giesecke's avatar Simon Giesecke
Browse files
Options

Problem: test_xpub_manual not yet using unity 

Solution: migrate to unity
parent 407bd3b1
Show whitespace changes
Inline Side-by-side
Showing with 238 additions and 351 deletions
Makefile.am
View file @ 713f075f
...@@ -657,7 +657,8 @@ tests_test_xpub_nodrop_LDADD = src/libzmq.la ${UNITY_LIBS} ...@@ -657,7 +657,8 @@ tests_test_xpub_nodrop_LDADD = src/libzmq.la ${UNITY_LIBS}
tests_test_xpub_nodrop_CPPFLAGS = ${UNITY_CPPFLAGS} tests_test_xpub_nodrop_CPPFLAGS = ${UNITY_CPPFLAGS}
tests_test_xpub_manual_SOURCES = tests/test_xpub_manual.cpp tests_test_xpub_manual_SOURCES = tests/test_xpub_manual.cpp
tests_test_xpub_manual_LDADD = src/libzmq.la tests_test_xpub_manual_LDADD = src/libzmq.la ${UNITY_LIBS}
tests_test_xpub_manual_CPPFLAGS = ${UNITY_CPPFLAGS}
tests_test_xpub_welcome_msg_SOURCES = tests/test_xpub_welcome_msg.cpp tests_test_xpub_welcome_msg_SOURCES = tests/test_xpub_welcome_msg.cpp
tests_test_xpub_welcome_msg_LDADD = src/libzmq.la tests_test_xpub_welcome_msg_LDADD = src/libzmq.la
......
tests/test_xpub_manual.cpp
View file @ 713f075f
...@@ -28,570 +28,430 @@ ...@@ -28,570 +28,430 @@
*/ */
#include "testutil.hpp" #include "testutil.hpp"
#include "testutil_unity.hpp"
int test_basic () void setUp ()
{ {
void *ctx = zmq_ctx_new (); setup_test_context ();
assert (ctx); }
void tearDown ()
{
teardown_test_context ();
}
void test_basic ()
{
// Create a publisher // Create a publisher
void *pub = zmq_socket (ctx, ZMQ_XPUB); void *pub = test_context_socket (ZMQ_XPUB);
assert (pub);
int manual = 1; int manual = 1;
int rc = zmq_setsockopt (pub, ZMQ_XPUB_MANUAL, &manual, 4); TEST_ASSERT_SUCCESS_ERRNO (
assert (rc == 0); zmq_setsockopt (pub, ZMQ_XPUB_MANUAL, &manual, 4));
rc = zmq_bind (pub, "inproc://soname"); TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (pub, "inproc://soname"));
assert (rc == 0);
// Create a subscriber // Create a subscriber
void *sub = zmq_socket (ctx, ZMQ_XSUB); void *sub = test_context_socket (ZMQ_XSUB);
assert (sub); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub, "inproc://soname"));
rc = zmq_connect (sub, "inproc://soname");
assert (rc == 0);
// Subscribe for A // Subscribe for A
char subscription[2] = {1, 'A'}; const char subscription[] = {1, 'A', 0};
rc = zmq_send_const (sub, subscription, 2, 0); send_string_expect_success (sub, subscription, 0);
assert (rc == 2);
char buffer[2];
// Receive subscriptions from subscriber // Receive subscriptions from subscriber
rc = zmq_recv (pub, buffer, 2, 0); recv_string_expect_success (pub, subscription, 0);
assert (rc == 2);
assert (buffer[0] == 1);
assert (buffer[1] == 'A');
// Subscribe socket for B instead // Subscribe socket for B instead
rc = zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "B", 1); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "B", 1));
assert (rc == 0);
// Sending A message and B Message // Sending A message and B Message
rc = zmq_send_const (pub, "A", 1, 0); send_string_expect_success (pub, "A", 0);
assert (rc == 1); send_string_expect_success (pub, "B", 0);
rc = zmq_send_const (pub, "B", 1, 0);
assert (rc == 1);
rc = zmq_recv (sub, buffer, 1, ZMQ_DONTWAIT); recv_string_expect_success (sub, "B", ZMQ_DONTWAIT);
assert (rc == 1);
assert (buffer[0] == 'B');
// Clean up. // Clean up.
rc = zmq_close (pub); test_context_socket_close (pub);
assert (rc == 0); test_context_socket_close (sub);
rc = zmq_close (sub);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
} }
void test_unsubscribe_manual ()
int test_unsubscribe_manual ()
{ {
void *ctx = zmq_ctx_new ();
assert (ctx);
// Create a publisher // Create a publisher
void *pub = zmq_socket (ctx, ZMQ_XPUB); void *pub = test_context_socket (ZMQ_XPUB);
assert (pub); TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (pub, "inproc://soname"));
int rc = zmq_bind (pub, "inproc://soname");
assert (rc == 0);
// set pub socket options // set pub socket options
int manual = 1; int manual = 1;
rc = zmq_setsockopt (pub, ZMQ_XPUB_MANUAL, &manual, 4); TEST_ASSERT_SUCCESS_ERRNO (
assert (rc == 0); zmq_setsockopt (pub, ZMQ_XPUB_MANUAL, &manual, sizeof (manual)));
// Create a subscriber // Create a subscriber
void *sub = zmq_socket (ctx, ZMQ_XSUB); void *sub = test_context_socket (ZMQ_XSUB);
assert (sub); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub, "inproc://soname"));
rc = zmq_connect (sub, "inproc://soname");
assert (rc == 0);
// Subscribe for A // Subscribe for A
char subscription1[2] = {1, 'A'}; const uint8_t subscription1[] = {1, 'A'};
rc = zmq_send_const (sub, subscription1, 2, 0); send_array_expect_success (sub, subscription1, 0);
assert (rc == 2);
// Subscribe for B // Subscribe for B
char subscription2[2] = {1, 'B'}; const uint8_t subscription2[] = {1, 'B'};
rc = zmq_send_const (sub, subscription2, 2, 0); send_array_expect_success (sub, subscription2, 0);
assert (rc == 2);
char buffer[3]; char buffer[3];
// Receive subscription "A" from subscriber // Receive subscription "A" from subscriber
rc = zmq_recv (pub, buffer, 2, 0); recv_array_expect_success (pub, subscription1, 0);
assert (rc == 2);
assert (buffer[0] == 1);
assert (buffer[1] == 'A');
// Subscribe socket for XA instead // Subscribe socket for XA instead
rc = zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "XA", 2); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "XA", 2));
assert (rc == 0);
// Receive subscription "B" from subscriber // Receive subscription "B" from subscriber
rc = zmq_recv (pub, buffer, 2, 0); recv_array_expect_success (pub, subscription2, 0);
assert (rc == 2);
assert (buffer[0] == 1);
assert (buffer[1] == 'B');
// Subscribe socket for XB instead // Subscribe socket for XB instead
rc = zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "XB", 2); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "XB", 2));
assert (rc == 0);
// Unsubscribe from A // Unsubscribe from A
char unsubscription1[2] = {0, 'A'}; const uint8_t unsubscription1[2] = {0, 'A'};
rc = zmq_send_const (sub, unsubscription1, 2, 0); send_array_expect_success (sub, unsubscription1, 0);
assert (rc == 2);
// Receive unsubscription "A" from subscriber // Receive unsubscription "A" from subscriber
rc = zmq_recv (pub, buffer, 2, 0); recv_array_expect_success (pub, unsubscription1, 0);
assert (rc == 2);
assert (buffer[0] == 0);
assert (buffer[1] == 'A');
// Unsubscribe socket from XA instead // Unsubscribe socket from XA instead
rc = zmq_setsockopt (pub, ZMQ_UNSUBSCRIBE, "XA", 2); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (pub, ZMQ_UNSUBSCRIBE, "XA", 2));
assert (rc == 0);
// Sending messages XA, XB // Sending messages XA, XB
rc = zmq_send_const (pub, "XA", 2, 0); send_string_expect_success (pub, "XA", 0);
assert (rc == 2); send_string_expect_success (pub, "XB", 0);
rc = zmq_send_const (pub, "XB", 2, 0);
assert (rc == 2);
// Subscriber should receive XB only // Subscriber should receive XB only
rc = zmq_recv (sub, buffer, 2, ZMQ_DONTWAIT); recv_string_expect_success (sub, "XB", ZMQ_DONTWAIT);
assert (rc == 2);
assert (buffer[0] == 'X');
assert (buffer[1] == 'B');
// Close subscriber // Close subscriber
rc = zmq_close (sub); test_context_socket_close (sub);
assert (rc == 0);
// Receive unsubscription "B" // Receive unsubscription "B"
rc = zmq_recv (pub, buffer, 2, 0); const char unsubscription2[2] = {0, 'B'};
assert (rc == 2); TEST_ASSERT_EQUAL_INT (
assert (buffer[0] == 0); sizeof unsubscription2,
assert (buffer[1] == 'B'); TEST_ASSERT_SUCCESS_ERRNO (zmq_recv (pub, buffer, sizeof buffer, 0)));
TEST_ASSERT_EQUAL_INT8_ARRAY (unsubscription2, buffer,
sizeof unsubscription2);
// Unsubscribe socket from XB instead // Unsubscribe socket from XB instead
rc = zmq_setsockopt (pub, ZMQ_UNSUBSCRIBE, "XB", 2); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (pub, ZMQ_UNSUBSCRIBE, "XB", 2));
assert (rc == 0);
// Clean up. // Clean up.
rc = zmq_close (pub); test_context_socket_close (pub);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
} }
void test_xpub_proxy_unsubscribe_on_disconnect ()
int test_xpub_proxy_unsubscribe_on_disconnect (void)
{ {
const char *topic = "1"; const uint8_t topic_buff[] = {"1"};
const char *payload = "X"; const uint8_t payload_buff[] = {"X"};
size_t len = MAX_SOCKET_STRING;
char my_endpoint_backend[MAX_SOCKET_STRING]; char my_endpoint_backend[MAX_SOCKET_STRING];
char my_endpoint_frontend[MAX_SOCKET_STRING]; char my_endpoint_frontend[MAX_SOCKET_STRING];
int manual = 1; int manual = 1;
void *ctx = zmq_ctx_new ();
assert (ctx);
// proxy frontend // proxy frontend
void *xsub_proxy = zmq_socket (ctx, ZMQ_XSUB); void *xsub_proxy = test_context_socket (ZMQ_XSUB);
assert (xsub_proxy); bind_loopback_ipv4 (xsub_proxy, my_endpoint_frontend,
assert (zmq_bind (xsub_proxy, "tcp://127.0.0.1:*") == 0); sizeof my_endpoint_frontend);
int rc = zmq_getsockopt (xsub_proxy, ZMQ_LAST_ENDPOINT,
my_endpoint_frontend, &len);
assert (rc == 0);
// proxy backend // proxy backend
void *xpub_proxy = zmq_socket (ctx, ZMQ_XPUB); void *xpub_proxy = test_context_socket (ZMQ_XPUB);
assert (xpub_proxy); TEST_ASSERT_SUCCESS_ERRNO (
assert (zmq_setsockopt (xpub_proxy, ZMQ_XPUB_MANUAL, &manual, 4) == 0); zmq_setsockopt (xpub_proxy, ZMQ_XPUB_MANUAL, &manual, 4));
assert (zmq_bind (xpub_proxy, "tcp://127.0.0.1:*") == 0); bind_loopback_ipv4 (xpub_proxy, my_endpoint_backend,
len = MAX_SOCKET_STRING; sizeof my_endpoint_backend);
rc =
zmq_getsockopt (xpub_proxy, ZMQ_LAST_ENDPOINT, my_endpoint_backend, &len);
assert (rc == 0);
// publisher // publisher
void *pub = zmq_socket (ctx, ZMQ_PUB); void *pub = test_context_socket (ZMQ_PUB);
assert (zmq_connect (pub, my_endpoint_frontend) == 0); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (pub, my_endpoint_frontend));
// first subscriber subscribes // first subscriber subscribes
void *sub1 = zmq_socket (ctx, ZMQ_SUB); void *sub1 = test_context_socket (ZMQ_SUB);
assert (sub1); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub1, my_endpoint_backend));
assert (zmq_connect (sub1, my_endpoint_backend) == 0); TEST_ASSERT_SUCCESS_ERRNO (
assert (zmq_setsockopt (sub1, ZMQ_SUBSCRIBE, topic, 1) == 0); zmq_setsockopt (sub1, ZMQ_SUBSCRIBE, topic_buff, 1));
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// proxy reroutes and confirms subscriptions // proxy reroutes and confirms subscriptions
char sub_buff[2]; const uint8_t subscription[2] = {1, *topic_buff};
assert (zmq_recv (xpub_proxy, sub_buff, 2, ZMQ_DONTWAIT) == 2); recv_array_expect_success (xpub_proxy, subscription, ZMQ_DONTWAIT);
assert (sub_buff[0] == 1); TEST_ASSERT_SUCCESS_ERRNO (
assert (sub_buff[1] == *topic); zmq_setsockopt (xpub_proxy, ZMQ_SUBSCRIBE, topic_buff, 1));
assert (zmq_setsockopt (xpub_proxy, ZMQ_SUBSCRIBE, topic, 1) == 0); send_array_expect_success (xsub_proxy, subscription, 0);
assert (zmq_send (xsub_proxy, sub_buff, 2, 0) == 2);
// second subscriber subscribes // second subscriber subscribes
void *sub2 = zmq_socket (ctx, ZMQ_SUB); void *sub2 = test_context_socket (ZMQ_SUB);
assert (sub2); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub2, my_endpoint_backend));
assert (zmq_connect (sub2, my_endpoint_backend) == 0); TEST_ASSERT_SUCCESS_ERRNO (
assert (zmq_setsockopt (sub2, ZMQ_SUBSCRIBE, topic, 1) == 0); zmq_setsockopt (sub2, ZMQ_SUBSCRIBE, topic_buff, 1));
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// proxy reroutes // proxy reroutes
assert (zmq_recv (xpub_proxy, sub_buff, 2, ZMQ_DONTWAIT) == 2); recv_array_expect_success (xpub_proxy, subscription, ZMQ_DONTWAIT);
assert (sub_buff[0] == 1); TEST_ASSERT_SUCCESS_ERRNO (
assert (sub_buff[1] == *topic); zmq_setsockopt (xpub_proxy, ZMQ_SUBSCRIBE, topic_buff, 1));
assert (zmq_setsockopt (xpub_proxy, ZMQ_SUBSCRIBE, topic, 1) == 0); send_array_expect_success (xsub_proxy, subscription, 0);
assert (zmq_send (xsub_proxy, sub_buff, 2, 0) == 2);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// let publisher send a msg // let publisher send a msg
assert (zmq_send (pub, topic, 1, ZMQ_SNDMORE) == 1); send_array_expect_success (pub, topic_buff, ZMQ_SNDMORE);
assert (zmq_send (pub, payload, 1, 0) == 1); send_array_expect_success (pub, payload_buff, 0);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// proxy reroutes data messages to subscribers // proxy reroutes data messages to subscribers
char topic_buff[1]; recv_array_expect_success (xsub_proxy, topic_buff, ZMQ_DONTWAIT);
char data_buff[1]; recv_array_expect_success (xsub_proxy, payload_buff, ZMQ_DONTWAIT);
assert (zmq_recv (xsub_proxy, topic_buff, 1, ZMQ_DONTWAIT) == 1); send_array_expect_success (xpub_proxy, topic_buff, ZMQ_SNDMORE);
assert (topic_buff[0] == *topic); send_array_expect_success (xpub_proxy, payload_buff, 0);
assert (zmq_recv (xsub_proxy, data_buff, 1, ZMQ_DONTWAIT) == 1);
assert (data_buff[0] == *payload);
assert (zmq_send (xpub_proxy, topic_buff, 1, ZMQ_SNDMORE) == 1);
assert (zmq_send (xpub_proxy, data_buff, 1, 0) == 1);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// each subscriber should now get a message // each subscriber should now get a message
assert (zmq_recv (sub2, topic_buff, 1, ZMQ_DONTWAIT) == 1); recv_array_expect_success (sub2, topic_buff, ZMQ_DONTWAIT);
assert (topic_buff[0] == *topic); recv_array_expect_success (sub2, payload_buff, ZMQ_DONTWAIT);
assert (zmq_recv (sub2, data_buff, 1, ZMQ_DONTWAIT) == 1);
assert (data_buff[0] == *payload);
assert (zmq_recv (sub1, topic_buff, 1, ZMQ_DONTWAIT) == 1); recv_array_expect_success (sub1, topic_buff, ZMQ_DONTWAIT);
assert (topic_buff[0] == *topic); recv_array_expect_success (sub1, payload_buff, ZMQ_DONTWAIT);
assert (zmq_recv (sub1, data_buff, 1, ZMQ_DONTWAIT) == 1);
assert (data_buff[0] == *payload);
// Disconnect both subscribers // Disconnect both subscribers
assert (zmq_close (sub1) == 0); test_context_socket_close (sub1);
assert (zmq_close (sub2) == 0); test_context_socket_close (sub2);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// unsubscribe messages are passed from proxy to publisher // unsubscribe messages are passed from proxy to publisher
assert (zmq_recv (xpub_proxy, sub_buff, 2, 0) == 2); const uint8_t unsubscription[] = {0, *topic_buff};
assert (sub_buff[0] == 0); recv_array_expect_success (xpub_proxy, unsubscription, 0);
assert (sub_buff[1] == *topic); TEST_ASSERT_SUCCESS_ERRNO (
assert (zmq_setsockopt (xpub_proxy, ZMQ_UNSUBSCRIBE, topic, 1) == 0); zmq_setsockopt (xpub_proxy, ZMQ_UNSUBSCRIBE, topic_buff, 1));
assert (zmq_send (xsub_proxy, sub_buff, 2, 0) == 2); send_array_expect_success (xsub_proxy, unsubscription, 0);
// should receive another unsubscribe msg // should receive another unsubscribe msg
assert (zmq_recv (xpub_proxy, sub_buff, 2, 0) == 2 recv_array_expect_success (xpub_proxy, unsubscription, 0);
&& "Should receive the second unsubscribe message."); TEST_ASSERT_SUCCESS_ERRNO (
assert (sub_buff[0] == 0); zmq_setsockopt (xpub_proxy, ZMQ_UNSUBSCRIBE, topic_buff, 1));
assert (sub_buff[1] == *topic); send_array_expect_success (xsub_proxy, unsubscription, 0);
assert (zmq_setsockopt (xpub_proxy, ZMQ_UNSUBSCRIBE, topic, 1) == 0);
assert (zmq_send (xsub_proxy, sub_buff, 2, 0) == 2);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// let publisher send a msg // let publisher send a msg
assert (zmq_send (pub, topic, 1, ZMQ_SNDMORE) == 1); send_array_expect_success (pub, topic_buff, ZMQ_SNDMORE);
assert (zmq_send (pub, payload, 1, 0) == 1); send_array_expect_success (pub, payload_buff, 0);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// nothing should come to the proxy // nothing should come to the proxy
assert (zmq_recv (xsub_proxy, topic_buff, 1, ZMQ_DONTWAIT) == -1); char buffer[1];
assert (errno == EAGAIN); TEST_ASSERT_FAILURE_ERRNO (
EAGAIN, zmq_recv (xsub_proxy, buffer, sizeof buffer, ZMQ_DONTWAIT));
assert (zmq_close (pub) == 0);
assert (zmq_close (xpub_proxy) == 0);
assert (zmq_close (xsub_proxy) == 0);
assert (zmq_ctx_term (ctx) == 0);
return 0; test_context_socket_close (pub);
test_context_socket_close (xpub_proxy);
test_context_socket_close (xsub_proxy);
} }
int test_missing_subscriptions (void) void test_missing_subscriptions ()
{ {
const char *topic1 = "1"; const char *topic1 = "1";
const char *topic2 = "2"; const char *topic2 = "2";
const char *payload = "X"; const char *payload = "X";
size_t len = MAX_SOCKET_STRING;
char my_endpoint_backend[MAX_SOCKET_STRING]; char my_endpoint_backend[MAX_SOCKET_STRING];
char my_endpoint_frontend[MAX_SOCKET_STRING]; char my_endpoint_frontend[MAX_SOCKET_STRING];
int manual = 1; int manual = 1;
void *ctx = zmq_ctx_new ();
assert (ctx);
// proxy frontend // proxy frontend
void *xsub_proxy = zmq_socket (ctx, ZMQ_XSUB); void *xsub_proxy = test_context_socket (ZMQ_XSUB);
assert (xsub_proxy); bind_loopback_ipv4 (xsub_proxy, my_endpoint_frontend,
assert (zmq_bind (xsub_proxy, "tcp://127.0.0.1:*") == 0); sizeof my_endpoint_frontend);
int rc = zmq_getsockopt (xsub_proxy, ZMQ_LAST_ENDPOINT,
my_endpoint_frontend, &len);
assert (rc == 0);
// proxy backend // proxy backend
void *xpub_proxy = zmq_socket (ctx, ZMQ_XPUB); void *xpub_proxy = test_context_socket (ZMQ_XPUB);
assert (xpub_proxy); TEST_ASSERT_SUCCESS_ERRNO (
assert (zmq_setsockopt (xpub_proxy, ZMQ_XPUB_MANUAL, &manual, 4) == 0); zmq_setsockopt (xpub_proxy, ZMQ_XPUB_MANUAL, &manual, 4));
assert (zmq_bind (xpub_proxy, "tcp://127.0.0.1:*") == 0); bind_loopback_ipv4 (xpub_proxy, my_endpoint_backend,
len = MAX_SOCKET_STRING; sizeof my_endpoint_backend);
rc =
zmq_getsockopt (xpub_proxy, ZMQ_LAST_ENDPOINT, my_endpoint_backend, &len);
assert (rc == 0);
// publisher // publisher
void *pub = zmq_socket (ctx, ZMQ_PUB); void *pub = test_context_socket (ZMQ_PUB);
assert (zmq_connect (pub, my_endpoint_frontend) == 0); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (pub, my_endpoint_frontend));
// Here's the problem: because subscribers subscribe in quick succession, // Here's the problem: because subscribers subscribe in quick succession,
// the proxy is unable to confirm the first subscription before receiving // the proxy is unable to confirm the first subscription before receiving
// the second. This causes the first subscription to get lost. // the second. This causes the first subscription to get lost.
// first subscriber // first subscriber
void *sub1 = zmq_socket (ctx, ZMQ_SUB); void *sub1 = test_context_socket (ZMQ_SUB);
assert (sub1); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub1, my_endpoint_backend));
assert (zmq_connect (sub1, my_endpoint_backend) == 0); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (sub1, ZMQ_SUBSCRIBE, topic1, 1));
assert (zmq_setsockopt (sub1, ZMQ_SUBSCRIBE, topic1, 1) == 0);
// second subscriber // second subscriber
void *sub2 = zmq_socket (ctx, ZMQ_SUB); void *sub2 = test_context_socket (ZMQ_SUB);
assert (sub2); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub2, my_endpoint_backend));
assert (zmq_connect (sub2, my_endpoint_backend) == 0); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (sub2, ZMQ_SUBSCRIBE, topic2, 1));
assert (zmq_setsockopt (sub2, ZMQ_SUBSCRIBE, topic2, 1) == 0);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// proxy now reroutes and confirms subscriptions // proxy now reroutes and confirms subscriptions
char buffer[2]; const uint8_t subscription1[] = {1, static_cast<uint8_t> (topic1[0])};
assert (zmq_recv (xpub_proxy, buffer, 2, ZMQ_DONTWAIT) == 2); recv_array_expect_success (xpub_proxy, subscription1, ZMQ_DONTWAIT);
assert (buffer[0] == 1); TEST_ASSERT_SUCCESS_ERRNO (
assert (buffer[1] == *topic1); zmq_setsockopt (xpub_proxy, ZMQ_SUBSCRIBE, topic1, 1));
assert (zmq_setsockopt (xpub_proxy, ZMQ_SUBSCRIBE, topic1, 1) == 0); send_array_expect_success (xsub_proxy, subscription1, 0);
assert (zmq_send (xsub_proxy, buffer, 2, 0) == 2);
const uint8_t subscription2[] = {1, static_cast<uint8_t> (topic2[0])};
assert (zmq_recv (xpub_proxy, buffer, 2, ZMQ_DONTWAIT) == 2); recv_array_expect_success (xpub_proxy, subscription2, ZMQ_DONTWAIT);
assert (buffer[0] == 1); TEST_ASSERT_SUCCESS_ERRNO (
assert (buffer[1] == *topic2); zmq_setsockopt (xpub_proxy, ZMQ_SUBSCRIBE, topic2, 1));
assert (zmq_setsockopt (xpub_proxy, ZMQ_SUBSCRIBE, topic2, 1) == 0); send_array_expect_success (xsub_proxy, subscription2, 0);
assert (zmq_send (xsub_proxy, buffer, 2, 0) == 2);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// let publisher send 2 msgs, each with its own topic // let publisher send 2 msgs, each with its own topic_buff
assert (zmq_send (pub, topic1, 1, ZMQ_SNDMORE) == 1); send_string_expect_success (pub, topic1, ZMQ_SNDMORE);
assert (zmq_send (pub, payload, 1, 0) == 1); send_string_expect_success (pub, payload, 0);
assert (zmq_send (pub, topic2, 1, ZMQ_SNDMORE) == 1); send_string_expect_success (pub, topic2, ZMQ_SNDMORE);
assert (zmq_send (pub, payload, 1, 0) == 1); send_string_expect_success (pub, payload, 0);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// proxy reroutes data messages to subscribers // proxy reroutes data messages to subscribers
char topic_buff[1]; recv_string_expect_success (xsub_proxy, topic1, ZMQ_DONTWAIT);
char data_buff[1]; recv_string_expect_success (xsub_proxy, payload, ZMQ_DONTWAIT);
assert (zmq_recv (xsub_proxy, topic_buff, 1, ZMQ_DONTWAIT) == 1); send_string_expect_success (xpub_proxy, topic1, ZMQ_SNDMORE);
assert (topic_buff[0] == *topic1); send_string_expect_success (xpub_proxy, payload, 0);
assert (zmq_recv (xsub_proxy, data_buff, 1, ZMQ_DONTWAIT) == 1);
assert (data_buff[0] == *payload); recv_string_expect_success (xsub_proxy, topic2, ZMQ_DONTWAIT);
assert (zmq_send (xpub_proxy, topic_buff, 1, ZMQ_SNDMORE) == 1); recv_string_expect_success (xsub_proxy, payload, ZMQ_DONTWAIT);
assert (zmq_send (xpub_proxy, data_buff, 1, 0) == 1); send_string_expect_success (xpub_proxy, topic2, ZMQ_SNDMORE);
send_string_expect_success (xpub_proxy, payload, 0);
assert (zmq_recv (xsub_proxy, topic_buff, 1, ZMQ_DONTWAIT) == 1);
assert (topic_buff[0] == *topic2);
assert (zmq_recv (xsub_proxy, data_buff, 1, ZMQ_DONTWAIT) == 1);
assert (data_buff[0] == *payload);
assert (zmq_send (xpub_proxy, topic_buff, 1, ZMQ_SNDMORE) == 1);
assert (zmq_send (xpub_proxy, data_buff, 1, 0) == 1);
// wait // wait
msleep (SETTLE_TIME); msleep (SETTLE_TIME);
// each subscriber should now get a message // each subscriber should now get a message
assert (zmq_recv (sub2, topic_buff, 1, ZMQ_DONTWAIT) == 1); recv_string_expect_success (sub2, topic2, ZMQ_DONTWAIT);
assert (topic_buff[0] == *topic2); recv_string_expect_success (sub2, payload, ZMQ_DONTWAIT);
assert (zmq_recv (sub2, data_buff, 1, ZMQ_DONTWAIT) == 1);
assert (data_buff[0] == *payload);
assert (zmq_recv (sub1, topic_buff, 1, ZMQ_DONTWAIT) == 1); recv_string_expect_success (sub1, topic1, ZMQ_DONTWAIT);
assert (topic_buff[0] == *topic1); recv_string_expect_success (sub1, payload, ZMQ_DONTWAIT);
assert (zmq_recv (sub1, data_buff, 1, ZMQ_DONTWAIT) == 1);
assert (data_buff[0] == *payload);
// Clean up // Clean up
assert (zmq_close (sub1) == 0); test_context_socket_close (sub1);
assert (zmq_close (sub2) == 0); test_context_socket_close (sub2);
assert (zmq_close (pub) == 0); test_context_socket_close (pub);
assert (zmq_close (xpub_proxy) == 0); test_context_socket_close (xpub_proxy);
assert (zmq_close (xsub_proxy) == 0); test_context_socket_close (xsub_proxy);
assert (zmq_ctx_term (ctx) == 0);
return 0;
} }
void test_unsubscribe_cleanup ()
int test_unsubscribe_cleanup (void)
{ {
size_t len = MAX_SOCKET_STRING;
char my_endpoint[MAX_SOCKET_STRING]; char my_endpoint[MAX_SOCKET_STRING];
void *ctx = zmq_ctx_new ();
assert (ctx);
// Create a publisher // Create a publisher
void *pub = zmq_socket (ctx, ZMQ_XPUB); void *pub = test_context_socket (ZMQ_XPUB);
assert (pub);
int manual = 1; int manual = 1;
int rc = zmq_setsockopt (pub, ZMQ_XPUB_MANUAL, &manual, 4); TEST_ASSERT_SUCCESS_ERRNO (
assert (rc == 0); zmq_setsockopt (pub, ZMQ_XPUB_MANUAL, &manual, 4));
rc = zmq_bind (pub, "tcp://127.0.0.1:*"); bind_loopback_ipv4 (pub, my_endpoint, sizeof my_endpoint);
assert (rc == 0);
rc = zmq_getsockopt (pub, ZMQ_LAST_ENDPOINT, my_endpoint, &len);
assert (rc == 0);
// Create a subscriber // Create a subscriber
void *sub = zmq_socket (ctx, ZMQ_XSUB); void *sub = test_context_socket (ZMQ_XSUB);
assert (sub); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub, my_endpoint));
rc = zmq_connect (sub, my_endpoint);
assert (rc == 0);
// Subscribe for A // Subscribe for A
char subscription[2] = {1, 'A'}; const uint8_t subscription1[2] = {1, 'A'};
rc = zmq_send_const (sub, subscription, 2, 0); send_array_expect_success (sub, subscription1, 0);
assert (rc == 2);
char buffer[2];
// Receive subscriptions from subscriber // Receive subscriptions from subscriber
rc = zmq_recv (pub, buffer, 2, 0); recv_array_expect_success (pub, subscription1, 0);
assert (rc == 2); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "XA", 2));
assert (buffer[0] == 1);
assert (buffer[1] == 'A');
rc = zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "XA", 2);
assert (rc == 0);
// send 2 messages // send 2 messages
rc = zmq_send_const (pub, "XA", 2, 0); send_string_expect_success (pub, "XA", 0);
assert (rc == 2); send_string_expect_success (pub, "XB", 0);
rc = zmq_send_const (pub, "XB", 2, 0);
assert (rc == 2);
// receive the single message // receive the single message
rc = zmq_recv (sub, buffer, 2, 0); recv_string_expect_success (sub, "XA", 0);
assert (rc == 2);
assert (buffer[0] == 'X');
assert (buffer[1] == 'A');
// should be nothing left in the queue // should be nothing left in the queue
rc = zmq_recv (sub, buffer, 2, ZMQ_DONTWAIT); char buffer[2];
assert (rc == -1); TEST_ASSERT_FAILURE_ERRNO (
EAGAIN, zmq_recv (sub, buffer, sizeof buffer, ZMQ_DONTWAIT));
// close the socket // close the socket
rc = zmq_close (sub); test_context_socket_close (sub);
assert (rc == 0);
// closing the socket will result in an unsubscribe event // closing the socket will result in an unsubscribe event
rc = zmq_recv (pub, buffer, 2, 0); const uint8_t unsubscription[2] = {0, 'A'};
assert (rc == 2); recv_array_expect_success (pub, unsubscription, 0);
assert (buffer[0] == 0);
assert (buffer[1] == 'A');
// this doesn't really do anything // this doesn't really do anything
// there is no last_pipe set it will just fail silently // there is no last_pipe set it will just fail silently
rc = zmq_setsockopt (pub, ZMQ_UNSUBSCRIBE, "XA", 2); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (pub, ZMQ_UNSUBSCRIBE, "XA", 2));
assert (rc == 0);
// reconnect // reconnect
sub = zmq_socket (ctx, ZMQ_XSUB); sub = test_context_socket (ZMQ_XSUB);
rc = zmq_connect (sub, my_endpoint); TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sub, my_endpoint));
assert (rc == 0);
// send a subscription for B // send a subscription for B
subscription[0] = 1; const uint8_t subscription2[2] = {1, 'B'};
subscription[1] = 'B'; send_array_expect_success (sub, subscription2, 0);
rc = zmq_send (sub, subscription, 2, 0);
assert (rc == 2);
// receive the subscription, overwrite it to XB // receive the subscription, overwrite it to XB
rc = zmq_recv (pub, buffer, 2, 0); recv_array_expect_success (pub, subscription2, 0);
assert (rc == 2); TEST_ASSERT_SUCCESS_ERRNO (zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "XB", 2));
assert (buffer[0] == 1);
assert (buffer[1] == 'B');
rc = zmq_setsockopt (pub, ZMQ_SUBSCRIBE, "XB", 2);
assert (rc == 0);
// send 2 messages // send 2 messages
rc = zmq_send_const (pub, "XA", 2, 0); send_string_expect_success (pub, "XA", 0);
assert (rc == 2); send_string_expect_success (pub, "XB", 0);
rc = zmq_send_const (pub, "XB", 2, 0);
assert (rc == 2);
// receive the single message // receive the single message
rc = zmq_recv (sub, buffer, 2, 0); recv_string_expect_success (sub, "XB", 0);
assert (rc == 2);
assert (buffer[0] == 'X');
assert (buffer[1] == 'B'); // this assertion will fail
// should be nothing left in the queue // should be nothing left in the queue
rc = zmq_recv (sub, buffer, 2, ZMQ_DONTWAIT); TEST_ASSERT_FAILURE_ERRNO (
assert (rc == -1); EAGAIN, zmq_recv (sub, buffer, sizeof buffer, ZMQ_DONTWAIT));
// Clean up. // Clean up.
rc = zmq_close (pub); test_context_socket_close (pub);
assert (rc == 0); test_context_socket_close (sub);
rc = zmq_close (sub);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
} }
int main ()
int main (void)
{ {
setup_test_environment (); setup_test_environment ();
test_basic ();
test_unsubscribe_manual ();
test_xpub_proxy_unsubscribe_on_disconnect ();
test_missing_subscriptions ();
test_unsubscribe_cleanup ();
return 0; UNITY_BEGIN ();
RUN_TEST (test_basic);
RUN_TEST (test_unsubscribe_manual);
RUN_TEST (test_xpub_proxy_unsubscribe_on_disconnect);
RUN_TEST (test_missing_subscriptions);
RUN_TEST (test_unsubscribe_cleanup);
return UNITY_END ();
} }
tests/testutil_unity.hpp
View file @ 713f075f
...@@ -118,6 +118,32 @@ void recv_string_expect_success (void *socket_, const char *str_, int flags_) ...@@ -118,6 +118,32 @@ void recv_string_expect_success (void *socket_, const char *str_, int flags_)
TEST_ASSERT_EQUAL_STRING_LEN (str_, buffer, len); TEST_ASSERT_EQUAL_STRING_LEN (str_, buffer, len);
} }
template <size_t SIZE>
void send_array_expect_success (void *socket_,
const uint8_t (&array_)[SIZE],
int flags_)
{
const int rc = zmq_send (socket_, array_, SIZE, flags_);
TEST_ASSERT_EQUAL_INT (static_cast<int> (SIZE), rc);
}
template <size_t SIZE>
void recv_array_expect_success (void *socket_,
const uint8_t (&array_)[SIZE],
int flags_)
{
char buffer[255];
TEST_ASSERT_LESS_OR_EQUAL_MESSAGE (sizeof (buffer), SIZE,
"recv_string_expect_success cannot be "
"used for strings longer than 255 "
"characters");
const int rc = TEST_ASSERT_SUCCESS_ERRNO (
zmq_recv (socket_, buffer, sizeof (buffer), flags_));
TEST_ASSERT_EQUAL_INT (static_cast<int> (SIZE), rc);
TEST_ASSERT_EQUAL_UINT8_ARRAY (array_, buffer, SIZE);
}
// do not call from tests directly, use setup_test_context, get_test_context and teardown_test_context only // do not call from tests directly, use setup_test_context, get_test_context and teardown_test_context only
void *internal_manage_test_context (bool init_, bool clear_) void *internal_manage_test_context (bool init_, bool clear_)
{ {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment