summaryrefslogtreecommitdiffstats
path: root/tests/sender-receiver.c
diff options
context:
space:
mode:
Diffstat (limited to 'tests/sender-receiver.c')
-rw-r--r--tests/sender-receiver.c218
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;
}