diff options
Diffstat (limited to 'tests/sender-receiver.c')
| -rw-r--r-- | tests/sender-receiver.c | 218 |
1 files changed, 111 insertions, 107 deletions
diff --git a/tests/sender-receiver.c b/tests/sender-receiver.c index 75a10be..19a989d 100644 --- a/tests/sender-receiver.c +++ b/tests/sender-receiver.c @@ -6,26 +6,36 @@ * SPDX-License-Identifier: MIT */ -#include <glib.h> +#define _GNU_SOURCE +#include "test.h" #include <icipc.h> #include <unistd.h> +#include <pthread.h> struct event_data { const uint8_t * expected_data; size_t expected_size; int connections; int n_events; - GMutex mutex; - GCond cond; + pthread_mutex_t mutex; + pthread_cond_t cond; }; +static inline char *new_address() +{ + char *address = NULL; + (void) asprintf(&address, "icipc-test-%d-%d", getpid(), rand()); + test_ptr_notnull(address); + return address; +} + static void wait_for_event (struct event_data *data, int n_events) { - g_mutex_lock (&data->mutex); + pthread_mutex_lock (&data->mutex); while (data->n_events < n_events) - g_cond_wait (&data->cond, &data->mutex); - g_mutex_unlock (&data->mutex); + pthread_cond_wait (&data->cond, &data->mutex); + pthread_mutex_unlock (&data->mutex); } static void @@ -33,9 +43,9 @@ sender_state_callback (struct icipc_receiver *self, int sender_fd, enum icipc_receiver_sender_state sender_state, void *p) { struct event_data *data = p; - g_assert_nonnull (data); + test_ptr_notnull (data); - g_mutex_lock (&data->mutex); + pthread_mutex_lock (&data->mutex); switch (sender_state) { case ICIPC_RECEIVER_SENDER_STATE_CONNECTED: data->connections++; @@ -44,57 +54,58 @@ sender_state_callback (struct icipc_receiver *self, int sender_fd, data->connections--; break; default: - g_assert_not_reached (); + test_fail_if_reached (); break; } data->n_events++; - g_cond_signal (&data->cond); - g_mutex_unlock (&data->mutex); + pthread_cond_signal (&data->cond); + pthread_mutex_unlock (&data->mutex); } static void reply_callback (struct icipc_sender *self, const uint8_t *buffer, size_t size, void *p) { struct event_data *data = p; - g_assert_nonnull (data); - g_assert_nonnull (buffer); + test_ptr_notnull (data); + test_ptr_notnull (buffer); - g_mutex_lock (&data->mutex); - g_assert_cmpmem (buffer, size, data->expected_data, data->expected_size); + pthread_mutex_lock (&data->mutex); + test_cmpint(size, ==, data->expected_size); + test_cmpint(memcmp(buffer, data->expected_data, size), ==, 0); data->n_events++; - g_cond_signal (&data->cond); - g_mutex_unlock (&data->mutex); + pthread_cond_signal (&data->cond); + pthread_mutex_unlock (&data->mutex); } static void test_icipc_receiver_basic () { - g_autofree gchar *address = g_strdup_printf ("%s/icipc-test-%d-%d", - g_get_tmp_dir(), getpid(), g_random_int ()); + char *address = new_address(); struct icipc_receiver *r = icipc_receiver_new (address, 16, NULL, NULL, 0); - g_assert_nonnull (r); + test_ptr_notnull (r); /* start and stop */ - g_assert_false (icipc_receiver_is_running (r)); - g_assert_true (icipc_receiver_start (r)); - g_assert_true (icipc_receiver_is_running (r)); + test_bool_false (icipc_receiver_is_running (r)); + test_bool_true (icipc_receiver_start (r)); + test_bool_true (icipc_receiver_is_running (r)); icipc_receiver_stop (r); - g_assert_false (icipc_receiver_is_running (r)); + test_bool_false (icipc_receiver_is_running (r)); /* clean up */ icipc_receiver_free (r); + free(address); } static void test_icipc_sender_basic () { - g_autofree gchar *address = g_strdup_printf ("%s/icipc-test-%d-%d", - g_get_tmp_dir(), getpid(), g_random_int ()); + char *address = new_address(); struct icipc_sender *s = icipc_sender_new (address, 16, NULL, NULL, 0); - g_assert_nonnull (s); + test_ptr_notnull (s); /* clean up */ icipc_sender_free (s); + free(address); } static void @@ -104,73 +115,71 @@ test_icipc_sender_connect () .sender_state = sender_state_callback, .handle_message = NULL, }; - struct event_data data; - g_mutex_init (&data.mutex); - g_cond_init (&data.cond); - data.n_events = 0; - data.connections = 0; + struct event_data data = {0}; - g_autofree gchar *address = g_strdup_printf ("%s/icipc-test-%d-%d", - g_get_tmp_dir(), getpid(), g_random_int ()); + pthread_mutex_init (&data.mutex, NULL); + pthread_cond_init (&data.cond, NULL); + + char *address = new_address(); struct icipc_receiver *r = icipc_receiver_new (address, 16, &events, &data, 0); - g_assert_nonnull (r); + test_ptr_notnull (r); struct icipc_sender *s = icipc_sender_new (address, 16, NULL, NULL, 0); - g_assert_nonnull (s); + test_ptr_notnull (s); /* start receiver */ - g_assert_true (icipc_receiver_start (r)); + test_bool_true (icipc_receiver_start (r)); /* connect sender */ - g_assert_true (icipc_sender_connect (s)); - g_assert_true (icipc_sender_is_connected (s)); + test_bool_true (icipc_sender_connect (s)); + test_bool_true (icipc_sender_is_connected (s)); wait_for_event (&data, 1); - g_assert_cmpint (data.connections, ==, 1); + test_cmpint (data.connections, ==, 1); /* disconnect sender */ icipc_sender_disconnect (s); - g_assert_false (icipc_sender_is_connected (s)); + test_bool_false (icipc_sender_is_connected (s)); wait_for_event (&data, 2); - g_assert_cmpint (data.connections, ==, 0); + test_cmpint (data.connections, ==, 0); /* stop receiver */ icipc_receiver_stop (r); /* clean up */ - g_cond_clear (&data.cond); - g_mutex_clear (&data.mutex); + pthread_cond_destroy (&data.cond); + pthread_mutex_destroy (&data.mutex); icipc_sender_free (s); icipc_receiver_free (r); + free(address); } static void lost_connection_handler (struct icipc_sender *self, int receiver_fd, void *p) { struct event_data *data = p; - g_assert_nonnull (data); + test_ptr_notnull (data); - g_mutex_lock (&data->mutex); + pthread_mutex_lock (&data->mutex); data->n_events++; - g_cond_signal (&data->cond); - g_mutex_unlock (&data->mutex); + pthread_cond_signal (&data->cond); + pthread_mutex_unlock (&data->mutex); } static void test_icipc_sender_lost_connection () { - struct event_data data; - g_mutex_init (&data.mutex); - g_cond_init (&data.cond); + struct event_data data = {0}; + pthread_mutex_init (&data.mutex, NULL); + pthread_cond_init (&data.cond, NULL); - g_autofree gchar *address = g_strdup_printf ("%s/icipc-test-%d-%d", - g_get_tmp_dir(), getpid(), g_random_int ()); + char *address = new_address(); struct icipc_receiver *r = icipc_receiver_new (address, 16, NULL, NULL, 0); - g_assert_nonnull (r); + test_ptr_notnull (r); struct icipc_sender *s = icipc_sender_new (address, 16, lost_connection_handler, &data, 0); - g_assert_nonnull (s); + test_ptr_notnull (s); /* connect sender */ - g_assert_true (icipc_sender_connect (s)); - g_assert_true (icipc_sender_is_connected (s)); + test_bool_true (icipc_sender_connect (s)); + test_bool_true (icipc_sender_is_connected (s)); /* destroy receiver and make sure the lost connection handler is triggered */ data.n_events = 0; @@ -178,108 +187,107 @@ test_icipc_sender_lost_connection () wait_for_event (&data, 1); /* make sure the connection was lost */ - g_assert_false (icipc_sender_is_connected (s)); + test_bool_false (icipc_sender_is_connected (s)); /* create a new receiver */ struct icipc_receiver *r2 = icipc_receiver_new (address, 16, NULL, NULL, 0); - g_assert_nonnull (r2); + test_ptr_notnull (r2); /* re-connect sender with new receiver */ - g_assert_true (icipc_sender_connect (s)); - g_assert_true (icipc_sender_is_connected (s)); + test_bool_true (icipc_sender_connect (s)); + test_bool_true (icipc_sender_is_connected (s)); /* clean up */ - g_cond_clear (&data.cond); - g_mutex_clear (&data.mutex); + pthread_cond_destroy (&data.cond); + pthread_mutex_destroy (&data.mutex); icipc_sender_free (s); icipc_receiver_free (r2); + free(address); } static void test_icipc_sender_send () { - g_autofree gchar *address = g_strdup_printf ("%s/icipc-test-%d-%d", - g_get_tmp_dir(), getpid(), g_random_int ()); + char *address = new_address(); struct icipc_receiver *r = icipc_receiver_new (address, 2, NULL, NULL, 0); - g_assert_nonnull (r); + test_ptr_notnull (r); struct icipc_sender *s = icipc_sender_new (address, 2, NULL, NULL, 0); - g_assert_nonnull (s); - struct event_data data; - g_mutex_init (&data.mutex); - g_cond_init (&data.cond); - data.n_events = 0; + test_ptr_notnull (s); + struct event_data data = {0}; + pthread_mutex_init (&data.mutex, NULL); + pthread_cond_init (&data.cond, NULL); /* start receiver */ - g_assert_true (icipc_receiver_start (r)); + test_bool_true (icipc_receiver_start (r)); /* connect */ - g_assert_true (icipc_sender_connect (s)); - g_assert_true (icipc_sender_is_connected (s)); + test_bool_true (icipc_sender_connect (s)); + test_bool_true (icipc_sender_is_connected (s)); /* send 1 byte message (should not realloc) */ data.n_events = 0; data.expected_data = (const uint8_t *)"h"; data.expected_size = 1; - g_assert_true (icipc_sender_send (s, (const uint8_t *)"h", 1, reply_callback, &data)); + test_bool_true (icipc_sender_send (s, (const uint8_t *)"h", 1, reply_callback, &data)); wait_for_event (&data, 1); /* send 2 bytes message (should realloc once to 4) */ data.n_events = 0; data.expected_data = (const uint8_t *)"hi"; data.expected_size = 2; - g_assert_true (icipc_sender_send (s, (const uint8_t *)"hi", 2, reply_callback, &data)); + test_bool_true (icipc_sender_send (s, (const uint8_t *)"hi", 2, reply_callback, &data)); wait_for_event (&data, 1); /* send 3 bytes message (should not realloc) */ data.n_events = 0; data.expected_data = (const uint8_t *)"hii"; data.expected_size = 3; - g_assert_true (icipc_sender_send (s, (const uint8_t *)"hii", 3, reply_callback, &data)); + test_bool_true (icipc_sender_send (s, (const uint8_t *)"hii", 3, reply_callback, &data)); wait_for_event (&data, 1); /* send 28 bytes message (should realloc 3 times: first to 8, then to 16 and finally to 32) */ data.n_events = 0; data.expected_data = (const uint8_t *)"bigger than 16 bytes message"; data.expected_size = 28; - g_assert_true (icipc_sender_send (s, (const uint8_t *)"bigger than 16 bytes message", 28, reply_callback, &data)); + test_bool_true (icipc_sender_send (s, (const uint8_t *)"bigger than 16 bytes message", 28, reply_callback, &data)); wait_for_event (&data, 1); /* don't allow empty messages */ data.n_events = 0; - g_assert_false (icipc_sender_send (s, (const uint8_t *)"", 0, NULL, NULL)); + test_bool_false (icipc_sender_send (s, (const uint8_t *)"", 0, NULL, NULL)); /* stop receiver */ icipc_receiver_stop (r); /* clean up */ - g_cond_clear (&data.cond); - g_mutex_clear (&data.mutex); + pthread_cond_destroy (&data.cond); + pthread_mutex_destroy (&data.mutex); icipc_sender_free (s); icipc_receiver_free (r); + free(address); } static void test_icipc_multiple_senders_send () { - g_autofree gchar *address = g_strdup_printf ("%s/icipc-test-%d-%d", - g_get_tmp_dir(), getpid(), g_random_int ()); + char *address = new_address(); struct icipc_receiver *r = icipc_receiver_new (address, 16, NULL, NULL, 0); - g_assert_nonnull (r); + test_ptr_notnull (r); struct icipc_sender *senders[50]; struct event_data data; - g_mutex_init (&data.mutex); - g_cond_init (&data.cond); + pthread_mutex_init (&data.mutex, NULL); + pthread_cond_init (&data.cond, NULL); data.n_events = 0; /* start receiver */ - g_assert_true (icipc_receiver_start (r)); + test_bool_true (icipc_receiver_start (r)); /* create and connect 50 senders */ for (int i = 0; i < 50; i++) { senders[i] = icipc_sender_new (address, 16, NULL, NULL, 0); - g_assert_nonnull (senders[i]); - g_assert_true (icipc_sender_connect (senders[i])); - g_assert_true (icipc_sender_is_connected (senders[i])); + test_ptr_notnull (senders[i]); + test_bool_true (icipc_sender_connect (senders[i])); + test_bool_true (icipc_sender_is_connected (senders[i])); } /* send 50 messages (1 per sender) */ @@ -287,33 +295,29 @@ test_icipc_multiple_senders_send () data.expected_data = (const uint8_t *)"hello"; data.expected_size = 5; for (int i = 0; i < 50; i++) - g_assert_true (icipc_sender_send (senders[i], (const uint8_t *)"hello", 5, reply_callback, &data)); + test_bool_true (icipc_sender_send (senders[i], (const uint8_t *)"hello", 5, reply_callback, &data)); wait_for_event (&data, 50); /* stop receiver */ icipc_receiver_stop (r); /* clean up */ - g_cond_clear (&data.cond); - g_mutex_clear (&data.mutex); + pthread_cond_destroy (&data.cond); + pthread_mutex_destroy (&data.mutex); for (int i = 0; i < 50; i++) icipc_sender_free (senders[i]); icipc_receiver_free (r); + free(address); } -gint -main (gint argc, gchar *argv[]) +int +main (int argc, char *argv[]) { - g_test_init (&argc, &argv, NULL); - - g_test_add_func ("/icipc/receiver-basic", test_icipc_receiver_basic); - g_test_add_func ("/icipc/sender-basic", test_icipc_sender_basic); - g_test_add_func ("/icipc/sender-connect", test_icipc_sender_connect); - g_test_add_func ("/icipc/sender-lost-connection", - test_icipc_sender_lost_connection); - g_test_add_func ("/icipc/sender-send", test_icipc_sender_send); - g_test_add_func ("/icipc/multiple-senders-send", - test_icipc_multiple_senders_send); - - return g_test_run (); + test_icipc_receiver_basic(); + test_icipc_sender_basic(); + test_icipc_sender_connect(); + test_icipc_sender_lost_connection(); + test_icipc_sender_send(); + test_icipc_multiple_senders_send(); + return TEST_PASS; } |