3party/libzmq
0
0
Fork 0
mirror of https://github.com/zeromq/libzmq.git synced 2025-01-14 01:37:56 +08:00
Code Issues Projects Releases Wiki Activity

Problem: test_poller not using unity

Browse Source 
Solution: migrate to unity, and split test cases
This commit is contained in:
Simon Giesecke 2018-03-15 14:46:17 +01:00
parent 991b2336e4
commit 10dae6e830
3 changed files with 354 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile.am
View File

@ -858,7 +858,8 @@ test_apps += tests/test_poller \
tests/test_dgram
tests_test_poller_SOURCES = tests/test_poller.cpp
tests_test_poller_LDADD = src/libzmq.la
tests_test_poller_LDADD = src/libzmq.la ${UNITY_LIBS}
tests_test_poller_CPPFLAGS = ${UNITY_CPPFLAGS}
tests_test_client_server_SOURCES = tests/test_client_server.cpp
tests_test_client_server_LDADD = src/libzmq.la ${UNITY_LIBS}

579
tests/test_poller.cpp
View File

@ -28,9 +28,23 @@
*/
#include "testutil.hpp"
#include "testutil_unity.hpp"
#include <unity.h>
void setUp ()
{
setup_test_context ();
}
void tearDown ()
{
teardown_test_context ();
}
// duplicated from fd.hpp
#ifdef ZMQ_HAVE_WINDOWS
#define close closesocket
#if defined _MSC_VER && _MSC_VER <= 1400
typedef UINT_PTR fd_t;
enum
@ -52,362 +66,459 @@ enum
};
#endif
void test_null_poller_pointers (void *ctx)
fd_t get_fd (void *socket)
{
int 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);
void *socket = zmq_socket (ctx, ZMQ_PAIR);
assert (socket != NULL);
rc = zmq_poller_add (NULL, socket, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_add (&null_poller, socket, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_modify (NULL, socket, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_modify (&null_poller, socket, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_remove (NULL, socket);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_remove (&null_poller, socket);
assert (rc == -1 && errno == EFAULT);
fd_t fd;
size_t fd_size = sizeof fd;
rc = zmq_getsockopt (socket, ZMQ_FD, &fd, &fd_size);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_getsockopt (socket, ZMQ_FD, &fd, &fd_size));
return fd;
}
rc = zmq_poller_add_fd (NULL, fd, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_add_fd (&null_poller, fd, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
void test_null_poller_pointers_destroy_direct ()
{
TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_destroy (NULL));
}
rc = zmq_poller_modify_fd (NULL, fd, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_modify_fd (&null_poller, fd, ZMQ_POLLIN);
assert (rc == -1 && errno == EFAULT);
void test_null_poller_pointers_destroy_indirect ()
{
void *null_poller = NULL;
TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_destroy (&null_poller));
}
rc = zmq_poller_remove_fd (NULL, fd);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_remove_fd (&null_poller, fd);
assert (rc == -1 && errno == EFAULT);
void test_null_poller_pointers_add_direct ()
{
void *socket = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_add (NULL, socket, NULL, ZMQ_POLLIN));
test_context_socket_close (socket);
}
void test_null_poller_pointers_add_indirect ()
{
void *null_poller = NULL;
void *socket = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_FAILURE_ERRNO (
EFAULT, zmq_poller_add (&null_poller, socket, NULL, ZMQ_POLLIN));
test_context_socket_close (socket);
}
void test_null_poller_pointers_modify_direct ()
{
void *socket = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_modify (NULL, socket, ZMQ_POLLIN));
test_context_socket_close (socket);
}
void test_null_poller_pointers_modify_indirect ()
{
void *null_poller = NULL;
void *socket = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_FAILURE_ERRNO (
EFAULT, zmq_poller_modify (&null_poller, socket, ZMQ_POLLIN));
test_context_socket_close (socket);
}
void test_null_poller_pointers_remove_direct ()
{
void *socket = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_remove (NULL, socket));
test_context_socket_close (socket);
}
void test_null_poller_pointers_remove_indirect ()
{
void *null_poller = NULL;
void *socket = test_context_socket (ZMQ_PAIR);
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_remove (&null_poller, socket));
test_context_socket_close (socket);
}
void test_null_poller_pointers_add_fd_direct ()
{
void *socket = test_context_socket (ZMQ_PAIR);
const fd_t fd = get_fd (socket);
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_add_fd (NULL, fd, NULL, ZMQ_POLLIN));
test_context_socket_close (socket);
}
void test_null_poller_pointers_add_fd_indirect ()
{
void *socket = test_context_socket (ZMQ_PAIR);
const fd_t fd = get_fd (socket);
void *null_poller = NULL;
TEST_ASSERT_FAILURE_ERRNO (
EFAULT, zmq_poller_add_fd (&null_poller, fd, NULL, ZMQ_POLLIN));
test_context_socket_close (socket);
}
void test_null_poller_pointers_modify_fd_direct ()
{
void *socket = test_context_socket (ZMQ_PAIR);
const fd_t fd = get_fd (socket);
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_modify_fd (NULL, fd, ZMQ_POLLIN));
test_context_socket_close (socket);
}
void test_null_poller_pointers_modify_fd_indirect ()
{
void *socket = test_context_socket (ZMQ_PAIR);
const fd_t fd = get_fd (socket);
void *null_poller = NULL;
TEST_ASSERT_FAILURE_ERRNO (
EFAULT, zmq_poller_modify_fd (&null_poller, fd, ZMQ_POLLIN));
test_context_socket_close (socket);
}
void test_null_poller_pointers_remove_fd_direct ()
{
void *socket = test_context_socket (ZMQ_PAIR);
const fd_t fd = get_fd (socket);
TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_remove_fd (NULL, fd));
test_context_socket_close (socket);
}
void test_null_poller_pointers_remove_fd_indirect ()
{
void *socket = test_context_socket (ZMQ_PAIR);
const fd_t fd = get_fd (socket);
void *null_poller = NULL;
TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_remove_fd (&null_poller, fd));
test_context_socket_close (socket);
}
void test_null_poller_pointers_wait_direct ()
{
zmq_poller_event_t event;
rc = zmq_poller_wait (NULL, &event, 0);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait (&null_poller, &event, 0);
assert (rc == -1 && errno == EFAULT);
TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_wait (NULL, &event, 0));
}
rc = zmq_poller_wait_all (NULL, &event, 1, 0);
assert (rc == -1 && errno == EFAULT);
rc = zmq_poller_wait_all (&null_poller, &event, 1, 0);
assert (rc == -1 && errno == EFAULT);
void test_null_poller_pointers_wait_indirect ()
{
zmq_poller_event_t event;
void *null_poller = NULL;
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_wait (&null_poller, &event, 0));
}
rc = zmq_close (socket);
assert (rc == 0);
void test_null_poller_pointers_wait_all_direct ()
{
zmq_poller_event_t event;
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_wait_all (NULL, &event, 1, 0));
}
void test_null_poller_pointers_wait_all_indirect ()
{
zmq_poller_event_t event;
void *null_poller = NULL;
TEST_ASSERT_FAILURE_ERRNO (
EFAULT, zmq_poller_wait_all (&null_poller, &event, 1, 0));
}
void test_null_socket_pointers ()
{
void *poller = zmq_poller_new ();
assert (poller != NULL);
TEST_ASSERT_NOT_NULL (poller);
int rc = zmq_poller_add (poller, NULL, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == ENOTSOCK);
TEST_ASSERT_FAILURE_ERRNO (ENOTSOCK,
zmq_poller_add (poller, NULL, NULL, ZMQ_POLLIN));
rc = zmq_poller_modify (poller, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == ENOTSOCK);
TEST_ASSERT_FAILURE_ERRNO (ENOTSOCK,
zmq_poller_modify (poller, NULL, ZMQ_POLLIN));
rc = zmq_poller_remove (poller, NULL);
assert (rc == -1 && errno == ENOTSOCK);
TEST_ASSERT_FAILURE_ERRNO (ENOTSOCK, zmq_poller_remove (poller, NULL));
fd_t null_socket_fd = retired_fd;
rc = zmq_poller_add_fd (poller, null_socket_fd, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EBADF);
TEST_ASSERT_FAILURE_ERRNO (
EBADF, zmq_poller_add_fd (poller, null_socket_fd, NULL, ZMQ_POLLIN));
rc = zmq_poller_modify_fd (poller, null_socket_fd, ZMQ_POLLIN);
assert (rc == -1 && errno == EBADF);
TEST_ASSERT_FAILURE_ERRNO (
EBADF, zmq_poller_modify_fd (poller, null_socket_fd, ZMQ_POLLIN));
rc = zmq_poller_remove_fd (poller, null_socket_fd);
assert (rc == -1 && errno == EBADF);
TEST_ASSERT_FAILURE_ERRNO (EBADF,
zmq_poller_remove_fd (poller, null_socket_fd));
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
}
void test_null_event_pointers (void *ctx)
typedef void (*extra_func_t) (void *poller);
void test_with_valid_poller (extra_func_t extra_func)
{
void *socket = zmq_socket (ctx, ZMQ_PAIR);
assert (socket != NULL);
void *socket = test_context_socket (ZMQ_PAIR);
void *poller = zmq_poller_new ();
assert (poller != NULL);
TEST_ASSERT_NOT_NULL (poller);
int rc = zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_add (poller, socket, NULL, ZMQ_POLLIN));
rc = zmq_poller_wait (poller, NULL, 0);
assert (rc == -1 && errno == EFAULT);
extra_func (poller);
rc = zmq_poller_wait_all (poller, NULL, 1, 0);
assert (rc == -1 && errno == EFAULT);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
test_context_socket_close (socket);
}
void call_poller_wait_null_event_fails (void *poller)
{
TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_wait (poller, NULL, 0));
}
void call_poller_wait_all_null_event_fails_event_count_nonzero (void *poller)
{
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_wait_all (poller, NULL, 1, 0));
}
void call_poller_wait_all_null_event_fails_event_count_zero (void *poller)
{
#if 0
// 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);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait_all (poller, NULL, 0, 0));
#endif
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
rc = zmq_close (socket);
assert (rc == 0);
}
void test_add_modify_remove_corner_cases (void *ctx)
void test_poller_wait_null_event_fails ()
{
test_with_valid_poller (call_poller_wait_null_event_fails);
}
void test_poller_wait_all_null_event_fails_event_count_nonzero ()
{
test_with_valid_poller (
call_poller_wait_all_null_event_fails_event_count_nonzero);
}
void test_poller_wait_all_null_event_fails_event_count_zero ()
{
test_with_valid_poller (
call_poller_wait_all_null_event_fails_event_count_zero);
}
void test_add_modify_remove_corner_cases ()
{
void *poller = zmq_poller_new ();
assert (poller != NULL);
TEST_ASSERT_NOT_NULL (poller);
void *zeromq_socket = zmq_socket (ctx, ZMQ_PAIR);
assert (zeromq_socket != NULL);
void *zeromq_socket = test_context_socket (ZMQ_PAIR);
int rc = zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN));
// attempt to add the same socket twice
rc = zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EINVAL);
TEST_ASSERT_FAILURE_ERRNO (
EINVAL, zmq_poller_add (poller, zeromq_socket, NULL, ZMQ_POLLIN));
rc = zmq_poller_remove (poller, zeromq_socket);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove (poller, zeromq_socket));
// attempt to remove socket that is not present
rc = zmq_poller_remove (poller, zeromq_socket);
assert (rc == -1 && errno == EINVAL);
TEST_ASSERT_FAILURE_ERRNO (EINVAL,
zmq_poller_remove (poller, zeromq_socket));
// attempt to modify socket that is not present
rc = zmq_poller_modify (poller, zeromq_socket, ZMQ_POLLIN);
assert (rc == -1 && errno == EINVAL);
TEST_ASSERT_FAILURE_ERRNO (
EINVAL, zmq_poller_modify (poller, zeromq_socket, ZMQ_POLLIN));
// add a socket with no events
// TODO should this really be legal? it does not make any sense...
rc = zmq_poller_add (poller, zeromq_socket, NULL, 0);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_add (poller, zeromq_socket, NULL, 0));
fd_t plain_socket = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
rc = zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN));
// attempt to add the same plain socket twice
rc = zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN);
assert (rc == -1 && errno == EINVAL);
TEST_ASSERT_FAILURE_ERRNO (
EINVAL, zmq_poller_add_fd (poller, plain_socket, NULL, ZMQ_POLLIN));
rc = zmq_poller_remove_fd (poller, plain_socket);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove_fd (poller, plain_socket));
// attempt to remove plain socket that is not present
rc = zmq_poller_remove_fd (poller, plain_socket);
assert (rc == -1 && errno == EINVAL);
TEST_ASSERT_FAILURE_ERRNO (EINVAL,
zmq_poller_remove_fd (poller, plain_socket));
// attempt to modify plain socket that is not present
rc = zmq_poller_modify_fd (poller, plain_socket, ZMQ_POLLIN);
assert (rc == -1 && errno == EINVAL);
TEST_ASSERT_FAILURE_ERRNO (
EINVAL, zmq_poller_modify_fd (poller, plain_socket, ZMQ_POLLIN));
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
rc = zmq_close (zeromq_socket);
assert (rc == 0);
test_context_socket_close (zeromq_socket);
rc = close (plain_socket);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (close (plain_socket));
}
void test_wait_corner_cases (void)
{
void *poller = zmq_poller_new ();
assert (poller != NULL);
TEST_ASSERT_NOT_NULL (poller);
zmq_poller_event_t event;
int rc = zmq_poller_wait (poller, &event, 0);
assert (rc == -1 && errno == EAGAIN);
// waiting on poller with no registered sockets should report error
TEST_ASSERT_FAILURE_ERRNO (EAGAIN, zmq_poller_wait (poller, &event, 0));
// 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);
// this would never be able to return since no socket was registered, and should yield an error
TEST_ASSERT_FAILURE_ERRNO (EFAULT, zmq_poller_wait (poller, &event, -1));
rc = zmq_poller_wait_all (poller, &event, -1, 0);
assert (rc == -1 && errno == EINVAL);
TEST_ASSERT_FAILURE_ERRNO (EINVAL,
zmq_poller_wait_all (poller, &event, -1, 0));
rc = zmq_poller_wait_all (poller, &event, 0, 0);
assert (rc == -1 && errno == EAGAIN);
TEST_ASSERT_FAILURE_ERRNO (EAGAIN,
zmq_poller_wait_all (poller, &event, 0, 0));
// 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);
// this would never be able to return since no socket was registered, and should yield an error
TEST_ASSERT_FAILURE_ERRNO (EFAULT,
zmq_poller_wait_all (poller, &event, 0, -1));
rc = zmq_poller_destroy (&poller);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
}
int main (void)
void test_x ()
{
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 *vent = test_context_socket (ZMQ_PUSH);
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (vent, "tcp://127.0.0.1:*"));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_getsockopt (vent, ZMQ_LAST_ENDPOINT, my_endpoint_0, &len));
void *sink = zmq_socket (ctx, ZMQ_PULL);
assert (sink);
rc = zmq_connect (sink, my_endpoint_0);
assert (rc == 0);
void *sink = test_context_socket (ZMQ_PULL);
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (sink, my_endpoint_0));
void *bowl = zmq_socket (ctx, ZMQ_PULL);
assert (bowl);
void *bowl = test_context_socket (ZMQ_PULL);
#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 *server = test_context_socket (ZMQ_SERVER);
TEST_ASSERT_SUCCESS_ERRNO (zmq_bind (server, "tcp://127.0.0.1:*"));
void *client = zmq_socket (ctx, ZMQ_CLIENT);
assert (client);
len = MAX_SOCKET_STRING;
TEST_ASSERT_SUCCESS_ERRNO (
zmq_getsockopt (server, ZMQ_LAST_ENDPOINT, my_endpoint_1, &len));
void *client = test_context_socket (ZMQ_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);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_add (poller, sink, sink, ZMQ_POLLIN));
// Send a message
char data[1] = {'H'};
rc = zmq_send_const (vent, data, 1, 0);
assert (rc == 1);
const char *vent_sink_msg = "H";
send_string_expect_success (vent, vent_sink_msg, 0);
// 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);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait (poller, &event, -1));
TEST_ASSERT_EQUAL_PTR (sink, event.socket);
TEST_ASSERT_EQUAL_PTR (sink, event.user_data);
recv_string_expect_success (sink, vent_sink_msg, 0);
// We expect timed out
rc = zmq_poller_wait (poller, &event, 0);
assert (rc == -1);
assert (errno == EAGAIN);
TEST_ASSERT_FAILURE_ERRNO (EAGAIN, zmq_poller_wait (poller, &event, 0));
// Stop polling sink
rc = zmq_poller_remove (poller, sink);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove (poller, sink));
// Check we can poll an FD
rc = zmq_connect (bowl, my_endpoint_0);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (bowl, my_endpoint_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);
TEST_ASSERT_SUCCESS_ERRNO (zmq_getsockopt (bowl, ZMQ_FD, &fd, &fd_size));
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_add_fd (poller, fd, bowl, ZMQ_POLLIN));
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait (poller, &event, 500));
TEST_ASSERT_NULL (event.socket);
TEST_ASSERT_EQUAL (fd, event.fd);
TEST_ASSERT_EQUAL_PTR (bowl, event.user_data);
TEST_ASSERT_SUCCESS_ERRNO (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);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_add (poller, server, NULL, ZMQ_POLLIN));
TEST_ASSERT_SUCCESS_ERRNO (zmq_connect (client, my_endpoint_1));
const char *client_server_msg = "I";
send_string_expect_success (client, client_server_msg, 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait (poller, &event, 500));
TEST_ASSERT_EQUAL_PTR (server, event.socket);
TEST_ASSERT_NULL (event.user_data);
recv_string_expect_success (server, client_server_msg, 0);
// 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);
TEST_ASSERT_SUCCESS_ERRNO (
zmq_poller_modify (poller, server, ZMQ_POLLOUT | ZMQ_POLLIN));
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_wait (poller, &event, 0));
TEST_ASSERT_EQUAL_PTR (server, event.socket);
TEST_ASSERT_NULL (event.user_data);
TEST_ASSERT_EQUAL_INT (ZMQ_POLLOUT, event.events);
// Stop polling server
rc = zmq_poller_remove (poller, server);
assert (rc == 0);
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_remove (poller, server));
#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);
test_context_socket_close (sink);
test_context_socket_close (vent);
test_context_socket_close (bowl);
#if defined(ZMQ_SERVER) && defined(ZMQ_CLIENT)
rc = zmq_close (server);
assert (rc == 0);
rc = zmq_close (client);
assert (rc == 0);
test_context_socket_close (server);
test_context_socket_close (client);
#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;
TEST_ASSERT_SUCCESS_ERRNO (zmq_poller_destroy (&poller));
}
int main (void)
{
setup_test_environment ();
UNITY_BEGIN ();
RUN_TEST (test_null_poller_pointers_destroy_direct);
RUN_TEST (test_null_poller_pointers_destroy_indirect);
RUN_TEST (test_null_poller_pointers_add_direct);
RUN_TEST (test_null_poller_pointers_add_indirect);
RUN_TEST (test_null_poller_pointers_modify_direct);
RUN_TEST (test_null_poller_pointers_modify_indirect);
RUN_TEST (test_null_poller_pointers_remove_direct);
RUN_TEST (test_null_poller_pointers_remove_indirect);
RUN_TEST (test_null_poller_pointers_add_fd_direct);
RUN_TEST (test_null_poller_pointers_add_fd_indirect);
RUN_TEST (test_null_poller_pointers_modify_fd_direct);
RUN_TEST (test_null_poller_pointers_modify_fd_indirect);
RUN_TEST (test_null_poller_pointers_remove_fd_direct);
RUN_TEST (test_null_poller_pointers_remove_fd_indirect);
RUN_TEST (test_null_poller_pointers_wait_direct);
RUN_TEST (test_null_poller_pointers_wait_indirect);
RUN_TEST (test_null_poller_pointers_wait_all_direct);
RUN_TEST (test_null_poller_pointers_wait_all_indirect);
RUN_TEST (test_null_socket_pointers);
RUN_TEST (test_poller_wait_null_event_fails);
RUN_TEST (test_poller_wait_all_null_event_fails_event_count_nonzero);
RUN_TEST (test_poller_wait_all_null_event_fails_event_count_zero);
RUN_TEST (test_add_modify_remove_corner_cases);
RUN_TEST (test_wait_corner_cases);
RUN_TEST (test_x);
return UNITY_END ();
}

7
tests/testutil_unity.hpp
View File

@ -63,6 +63,13 @@ int test_assert_success_message_errno_helper (int rc,
#define TEST_ASSERT_SUCCESS_ERRNO(expr) \
test_assert_success_message_errno_helper (expr, NULL, #expr)
#define TEST_ASSERT_FAILURE_ERRNO(error_code, expr) \
{ \
int rc = (expr); \
TEST_ASSERT_EQUAL_INT (-1, rc); \
TEST_ASSERT_EQUAL_INT (error_code, errno); \
}
void send_string_expect_success (void *socket, const char *str, int flags)
{
const size_t len = str ? strlen (str) : 0;