void test_null_event_pointers (void *ctx)
{
void *socket = zmq_socket (ctx, ZMQ_PAIR);
assert (socket != NULL);
void *poller = zmq_poller_new ();
assert (poller != NULL);
int rc = zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN);
assert (rc == 0);
rc = zmq_poller_wait (poller, NULL, 0);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait_all (poller, NULL, 1, 0);
assert (rc == -1 && errno == EFAULT);
// TODO this causes an assertion, which is not consistent if the number
// of events may be 0, the pointer should be allowed to by NULL in that
// case too
#if 0
rc = zmq_poller_wait_all (poller, NULL, 0, 0);
assert (rc == 0);
#endif
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
rc = zmq_close (socket);
assert (rc == 0);
}
void test_wait_corner_cases (void)
{
void *poller = zmq_poller_new ();
assert (poller != NULL);
zmq_poller_event_t event;
int rc = zmq_poller_wait(poller, &event, 0);
assert (rc == -1 && errno == EAGAIN);
// this can never return since no socket was registered, and should yield an error
rc = zmq_poller_wait(poller, &event, -1);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait_all (poller, &event, -1, 0);
assert (rc == -1 && errno == EINVAL);
rc = zmq_poller_wait_all (poller, &event, 0, 0);
assert (rc == -1 && errno == EAGAIN);
// this can never return since no socket was registered, and should yield an error
rc = zmq_poller_wait_all (poller, &event, 0, -1);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
}
void run_poller (void *data_)
{
struct poller_test_data_t *poller_test_data =
(struct poller_test_data_t *) data_;
void *socket =
zmq_socket (poller_test_data->ctx, poller_test_data->socket_type);
TEST_ASSERT_NOT_NULL (socket);
void *poller = zmq_poller_new ();
TEST_ASSERT_NOT_NULL (poller);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN));
zmq_atomic_counter_set (poller_test_data->counter, 1);
zmq_poller_event_t event;
TEST_ASSERT_FAILURE_ERRNO (ETERM, zmq_poller_wait (poller, &event, -1));
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
// Close the socket
TEST_ASSERT_SUCCESS_ERRNO (zmq_close (socket));
}
void *
zpoller_wait (zpoller_t *self, int timeout)
{
assert (self);
self->expired = false;
if (zsys_interrupted && !self->nonstop) {
self->terminated = true;
return NULL;
}
else
self->terminated = false;
#ifdef ZMQ_HAVE_POLLER
zmq_poller_event_t event;
if (!zmq_poller_wait (self->zmq_poller, &event, timeout * ZMQ_POLL_MSEC))
return event.user_data;
else
if (errno == ETIMEDOUT || errno == EAGAIN)
self->expired = true;
else
if (zsys_interrupted && !self->nonstop)
self->terminated = true;
return NULL;
#else
if (self->need_rebuild)
s_rebuild_poll_set (self);
int rc = zmq_poll (self->poll_set, (int) self->poll_size, timeout * ZMQ_POLL_MSEC);
if (rc > 0) {
uint reader = 0;
for (reader = 0; reader < self->poll_size; reader++)
if (self->poll_set [reader].revents & ZMQ_POLLIN)
return self->poll_readers [reader];
}
else
if (rc == -1 || (zsys_interrupted && !self->nonstop))
self->terminated = true;
else
if (rc == 0)
self->expired = true;
return NULL;
#endif
}
int main (void)
{
setup_test_environment ();
void *ctx = zmq_ctx_new ();
assert (ctx);
// Create few sockets
void *vent = zmq_socket (ctx, ZMQ_PUSH);
assert (vent);
int rc = zmq_bind (vent, "tcp://127.0.0.1:55556");
assert (rc == 0);
void *sink = zmq_socket (ctx, ZMQ_PULL);
assert (sink);
rc = zmq_connect (sink, "tcp://127.0.0.1:55556");
assert (rc == 0);
void *bowl = zmq_socket (ctx, ZMQ_PULL);
assert (bowl);
#if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
void *server = zmq_socket (ctx, ZMQ_SERVER);
assert (server);
rc = zmq_bind (server, "tcp://127.0.0.1:55557");
assert (rc == 0);
void *client = zmq_socket (ctx, ZMQ_CLIENT);
assert (client);
#endif
// Set up poller
void* poller = zmq_poller_new ();
zmq_poller_event_t event;
// waiting on poller with no registered sockets should report error
rc = zmq_poller_wait(poller, &event, 0);
assert (rc == -1);
assert (errno == ETIMEDOUT);
// register sink
rc = zmq_poller_add (poller, sink, sink, ZMQ_POLLIN);
assert (rc == 0);
// Send a message
char data[1] = {'H'};
rc = zmq_send_const (vent, data, 1, 0);
assert (rc == 1);
// We expect a message only on the sink
rc = zmq_poller_wait (poller, &event, -1);
assert (rc == 0);
assert (event.socket == sink);
assert (event.user_data == sink);
rc = zmq_recv (sink, data, 1, 0);
assert (rc == 1);
// We expect timed out
rc = zmq_poller_wait (poller, &event, 0);
assert (rc == -1);
assert (errno == ETIMEDOUT);
// Stop polling sink
rc = zmq_poller_remove (poller, sink);
assert (rc == 0);
// Check we can poll an FD
rc = zmq_connect (bowl, "tcp://127.0.0.1:55556");
assert (rc == 0);
#if defined _WIN32
SOCKET fd;
size_t fd_size = sizeof (SOCKET);
#else
int fd;
size_t fd_size = sizeof (int);
#endif
rc = zmq_getsockopt (bowl, ZMQ_FD, &fd, &fd_size);
assert (rc == 0);
rc = zmq_poller_add_fd (poller, fd, bowl, ZMQ_POLLIN);
assert (rc == 0);
rc = zmq_poller_wait (poller, &event, 500);
assert (rc == 0);
assert (event.socket == NULL);
assert (event.fd == fd);
assert (event.user_data == bowl);
zmq_poller_remove_fd (poller, fd);
#if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
// Polling on thread safe sockets
rc = zmq_poller_add (poller, server, NULL, ZMQ_POLLIN);
assert (rc == 0);
rc = zmq_connect (client, "tcp://127.0.0.1:55557");
assert (rc == 0);
rc = zmq_send_const (client, data, 1, 0);
assert (rc == 1);
rc = zmq_poller_wait (poller, &event, 500);
assert (rc == 0);
assert (event.socket == server);
assert (event.user_data == NULL);
rc = zmq_recv (server, data, 1, 0);
assert (rc == 1);
// Polling on pollout
rc = zmq_poller_modify (poller, server, ZMQ_POLLOUT | ZMQ_POLLIN);
assert (rc == 0);
rc = zmq_poller_wait (poller, &event, 0);
assert (rc == 0);
assert (event.socket == server);
assert (event.user_data == NULL);
assert (event.events == ZMQ_POLLOUT);
#endif
// Destory sockets, poller and ctx
rc = zmq_close (sink);
assert (rc == 0);
rc = zmq_close (vent);
assert (rc == 0);
rc = zmq_close (bowl);
assert (rc == 0);
#if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
rc = zmq_close (server);
assert (rc == 0);
rc = zmq_close (client);
assert (rc == 0);
#endif
// Test error - null poller pointers
rc = zmq_poller_destroy (NULL);
assert (rc == -1 && errno == EFAULT);
void *null_poller = NULL;
rc = zmq_poller_destroy (&null_poller);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_destroy (&poller);
assert(rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
}
int main (void)
{
setup_test_environment ();
void *ctx = zmq_ctx_new ();
assert (ctx);
// Create few sockets
void *vent = zmq_socket (ctx, ZMQ_PUSH);
assert (vent);
int rc = zmq_bind (vent, "tcp://127.0.0.1:55556");
assert (rc == 0);
void *sink = zmq_socket (ctx, ZMQ_PULL);
assert (sink);
rc = zmq_connect (sink, "tcp://127.0.0.1:55556");
assert (rc == 0);
void *bowl = zmq_socket (ctx, ZMQ_PULL);
assert (bowl);
void *server = zmq_socket (ctx, ZMQ_SERVER);
assert (server);
rc = zmq_bind (server, "tcp://127.0.0.1:55557");
assert (rc == 0);
void *client = zmq_socket (ctx, ZMQ_CLIENT);
assert (client);
// Set up poller
void* poller = zmq_poller_new ();
rc = zmq_poller_add_socket (poller, sink, sink);
assert (rc == 0);
// Send a message
char data[1] = {'H'};
rc = zmq_send_const (vent, data, 1, 0);
assert (rc == 1);
// We expect a message only on the sink
zmq_poller_event_t event;
rc = zmq_poller_wait (poller, &event, -1);
assert (rc == 0);
assert (event.socket == sink);
assert (event.user_data == sink);
rc = zmq_recv (sink, data, 1, 0);
assert (rc == 1);
// Stop polling sink
rc = zmq_poller_remove_socket (poller, sink);
assert (rc == 0);
// Check we can poll an FD
rc = zmq_connect (bowl, "tcp://127.0.0.1:55556");
assert (rc == 0);
#if defined _WIN32
SOCKET fd;
size_t fd_size = sizeof (SOCKET);
#else
int fd;
size_t fd_size = sizeof (int);
#endif
rc = zmq_getsockopt (bowl, ZMQ_FD, &fd, &fd_size);
assert (rc == 0);
rc = zmq_poller_add_fd (poller, fd, bowl);
assert (rc == 0);
rc = zmq_poller_wait (poller, &event, 500);
assert (rc == 0);
assert (event.socket == NULL);
assert (event.fd == fd);
assert (event.user_data == bowl);
zmq_poller_remove_fd (poller, fd);
// Polling on thread safe sockets
zmq_poller_add_socket (poller, server, NULL);
rc = zmq_connect (client, "tcp://127.0.0.1:55557");
assert (rc == 0);
rc = zmq_send_const (client, data, 1, 0);
assert (rc == 1);
rc = zmq_poller_wait (poller, &event, 500);
assert (rc == 0);
assert (event.socket == server);
assert (event.user_data == NULL);
rc = zmq_recv (server, data, 1, 0);
assert (rc == 1);
// Destory poller, sockets and ctx
rc = zmq_poller_close (poller);
assert (rc == 0);
rc = zmq_close (sink);
assert (rc == 0);
rc = zmq_close (vent);
assert (rc == 0);
rc = zmq_close (bowl);
assert (rc == 0);
rc = zmq_close (server);
assert (rc == 0);
rc = zmq_close (client);
assert (rc == 0);
rc = zmq_ctx_shutdown (ctx);
assert (rc == 0);
return 0;
}
int main (void)
{
size_t len = MAX_SOCKET_STRING;
char my_endpoint_0[MAX_SOCKET_STRING];
char my_endpoint_1[MAX_SOCKET_STRING];
setup_test_environment ();
void *ctx = zmq_ctx_new ();
assert (ctx);
// Create few sockets
void *vent = zmq_socket (ctx, ZMQ_PUSH);
assert (vent);
int rc = zmq_bind (vent, "tcp://127.0.0.1:*");
assert (rc == 0);
rc = zmq_getsockopt (vent, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len);
assert (rc == 0);
void *sink = zmq_socket (ctx, ZMQ_PULL);
assert (sink);
rc = zmq_connect (sink, my_endpoint_0);
assert (rc == 0);
void *bowl = zmq_socket (ctx, ZMQ_PULL);
assert (bowl);
#if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
void *server = zmq_socket (ctx, ZMQ_SERVER);
assert (server);
rc = zmq_bind (server, "tcp://127.0.0.1:*");
assert (rc == 0);
len = MAX_SOCKET_STRING;
rc = zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len);
assert (rc == 0);
void *client = zmq_socket (ctx, ZMQ_CLIENT);
assert (client);
#endif
// Set up poller
void *poller = zmq_poller_new ();
zmq_poller_event_t event;
// waiting on poller with no registered sockets should report error
rc = zmq_poller_wait (poller, &event, 0);
assert (rc == -1);
assert (errno == EAGAIN);
// register sink
rc = zmq_poller_add (poller, sink, sink, ZMQ_POLLIN);
assert (rc == 0);
// Send a message
char data[1] = {'H'};
rc = zmq_send_const (vent, data, 1, 0);
assert (rc == 1);
// We expect a message only on the sink
rc = zmq_poller_wait (poller, &event, -1);
assert (rc == 0);
assert (event.socket == sink);
assert (event.user_data == sink);
rc = zmq_recv (sink, data, 1, 0);
assert (rc == 1);
// We expect timed out
rc = zmq_poller_wait (poller, &event, 0);
assert (rc == -1);
assert (errno == EAGAIN);
// Stop polling sink
rc = zmq_poller_remove (poller, sink);
assert (rc == 0);
// Check we can poll an FD
rc = zmq_connect (bowl, my_endpoint_0);
assert (rc == 0);
fd_t fd;
size_t fd_size = sizeof (fd);
rc = zmq_getsockopt (bowl, ZMQ_FD, &fd, &fd_size);
assert (rc == 0);
rc = zmq_poller_add_fd (poller, fd, bowl, ZMQ_POLLIN);
assert (rc == 0);
rc = zmq_poller_wait (poller, &event, 500);
assert (rc == 0);
assert (event.socket == NULL);
assert (event.fd == fd);
assert (event.user_data == bowl);
zmq_poller_remove_fd (poller, fd);
#if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
// Polling on thread safe sockets
rc = zmq_poller_add (poller, server, NULL, ZMQ_POLLIN);
assert (rc == 0);
rc = zmq_connect (client, my_endpoint_1);
assert (rc == 0);
rc = zmq_send_const (client, data, 1, 0);
assert (rc == 1);
rc = zmq_poller_wait (poller, &event, 500);
assert (rc == 0);
assert (event.socket == server);
assert (event.user_data == NULL);
rc = zmq_recv (server, data, 1, 0);
assert (rc == 1);
// Polling on pollout
rc = zmq_poller_modify (poller, server, ZMQ_POLLOUT | ZMQ_POLLIN);
assert (rc == 0);
rc = zmq_poller_wait (poller, &event, 0);
assert (rc == 0);
assert (event.socket == server);
assert (event.user_data == NULL);
assert (event.events == ZMQ_POLLOUT);
// Stop polling server
rc = zmq_poller_remove (poller, server);
assert (rc == 0);
#endif
// Destroy sockets, poller and ctx
rc = zmq_close (sink);
assert (rc == 0);
rc = zmq_close (vent);
assert (rc == 0);
rc = zmq_close (bowl);
assert (rc == 0);
#if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
rc = zmq_close (server);
assert (rc == 0);
rc = zmq_close (client);
assert (rc == 0);
#endif
test_null_poller_pointers (ctx);
test_null_socket_pointers ();
test_null_event_pointers (ctx);
test_add_modify_remove_corner_cases (ctx);
test_wait_corner_cases ();
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
rc = zmq_ctx_term (ctx);
assert (rc == 0);
return 0;
}
