static void test_loop_idle(void)
{
int res = 0;
struct idle_data data = {NULL, 0};
/* Create loop */
data.loop = pomp_loop_new();
CU_ASSERT_PTR_NOT_NULL_FATAL(data.loop);
/* Check register function is called once */
data.n = 0;
res = pomp_loop_idle_add(data.loop, &idle_cb, &data);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_wait_and_process(data.loop, 0);
CU_ASSERT_EQUAL(res, -ETIMEDOUT);
CU_ASSERT_EQUAL(data.n, 1);
res = pomp_loop_wait_and_process(data.loop, 0);
CU_ASSERT_EQUAL(res, -ETIMEDOUT);
CU_ASSERT_EQUAL(data.n, 1);
/* Check register function is called twice */
data.n = 0;
res = pomp_loop_idle_add(data.loop, &idle_cb, &data);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_idle_add(data.loop, &idle_cb, &data);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_wait_and_process(data.loop, 0);
CU_ASSERT_EQUAL(res, -ETIMEDOUT);
CU_ASSERT_EQUAL(data.n, 2);
/* Check register function is not called */
data.n = 0;
res = pomp_loop_idle_add(data.loop, &idle_cb, &data);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_idle_remove(data.loop, &idle_cb, &data);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_wait_and_process(data.loop, 0);
CU_ASSERT_EQUAL(res, -ETIMEDOUT);
CU_ASSERT_EQUAL(data.n, 0);
res = pomp_loop_idle_add(NULL, &idle_cb, &data);
CU_ASSERT_EQUAL(res, -EINVAL);
res = pomp_loop_idle_add(data.loop, NULL, &data);
CU_ASSERT_EQUAL(res, -EINVAL);
res = pomp_loop_idle_remove(NULL, &idle_cb, &data);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Destroy loop */
res = pomp_loop_destroy(data.loop);
CU_ASSERT_EQUAL(res, 0);
}
void muta_connect(libmuta_processing_callback f, void *priv)
{
struct sockaddr_storage addr_storage;
struct sockaddr *addr = NULL;
uint32_t addrlen = 0;
memset(&addr_storage, 0, sizeof(addr_storage));
addr = (struct sockaddr *)&addr_storage;
addrlen = sizeof(addr_storage);
pomp_addr_parse(LIBMUTA_IMAGE_SOCKET, addr, &addrlen);
s_app.ctx = pomp_ctx_new(client_event_cb, f);
s_app.loop = pomp_ctx_get_loop(s_app.ctx);
client_start(addr, addrlen);
s_app.stop = 0;
s_app.priv = priv;
s_app.process = f;
while (!s_app.stop) {
pomp_loop_wait_and_process(s_app.loop, -1);
}
if (s_app.ctx != NULL) {
pomp_ctx_stop(s_app.ctx);
pomp_ctx_destroy(s_app.ctx);
}
}
static void test_loop_wakeup(void)
{
int res = 0, i = 0;
struct pomp_loop *loop = NULL;
HANDLE hthread = NULL;
DWORD threadid = 0;
/* Create loop */
loop = pomp_loop_new();
CU_ASSERT_PTR_NOT_NULL_FATAL(loop);
/* Create a thread that will do the wakeup */
hthread = CreateThread(NULL, 0, &test_loop_wakeup_thread, loop, 0, &threadid);
CU_ASSERT_PTR_NOT_NULL_FATAL(hthread);
for (i = 0; i < 10; i++) {
/* Execute loop until wakeup, shall not timeout */
res = pomp_loop_wait_and_process(loop, 1000);
CU_ASSERT_EQUAL(res, 0);
}
res = WaitForSingleObject(hthread, INFINITE);
CU_ASSERT_EQUAL(res, WAIT_OBJECT_0);
CloseHandle(hthread);
res = pomp_loop_wakeup(NULL);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Destroy loop */
res = pomp_loop_destroy(loop);
CU_ASSERT_EQUAL(res, 0);
}
static void test_loop_wakeup(void)
{
int res = 0, i = 0;
struct pomp_loop *loop = NULL;
pthread_t thread;
/* Create loop */
loop = pomp_loop_new();
CU_ASSERT_PTR_NOT_NULL_FATAL(loop);
/* Create a thread that will do the wakeup */
res = pthread_create(&thread, NULL, &test_loop_wakeup_thread, loop);
CU_ASSERT_EQUAL(res, 0);
for (i = 0; i < 10; i++) {
/* Execute loop until wakeup, shall not timeout */
res = pomp_loop_wait_and_process(loop, 1000);
CU_ASSERT_EQUAL(res, 0);
}
res = pthread_join(thread, NULL);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_wakeup(NULL);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Destroy loop */
res = pomp_loop_destroy(loop);
CU_ASSERT_EQUAL(res, 0);
}
static int test_ipc_entry(pomp_event_cb_t cb,
const struct sockaddr *addr, uint32_t addrlen, int client)
{
int res = 0;
struct test_data data;
struct pomp_ctx *ctx = NULL;
struct pomp_loop *loop = NULL;
struct pomp_timer *timer = NULL;
memset(&data, 0, sizeof(data));
data.pid = getpid();
TEST_IPC_LOG("-> %s", __func__);
/* Setup */
ctx = pomp_ctx_new(cb, &data);
TEST_IPC_CHECK(&data, ctx != NULL);
loop = pomp_ctx_get_loop(ctx);
TEST_IPC_CHECK(&data, loop != NULL);
timer = pomp_timer_new(loop, &test_ipc_timer_cb, &data);
TEST_IPC_CHECK(&data, timer != NULL);
res = pomp_timer_set(timer, 10 * 1000);
TEST_IPC_CHECK(&data, res == 0);
/* Start client/server */
if (client)
res = pomp_ctx_connect(ctx, addr, addrlen);
else
res = pomp_ctx_listen(ctx, addr, addrlen);
TEST_IPC_CHECK(&data, res == 0);
/* Run loop */
while (!data.stop)
pomp_loop_wait_and_process(loop, -1);
/* Cleanup */
res = pomp_timer_destroy(timer);
TEST_IPC_CHECK(&data, res == 0);
res = pomp_ctx_stop(ctx);
TEST_IPC_CHECK(&data, res == 0);
res = pomp_ctx_destroy(ctx);
TEST_IPC_CHECK(&data, res == 0);
TEST_IPC_LOG("<-- %s", __func__);
return data.status;
}
static void test_loop(int is_epoll)
{
int res = 0;
int tfd1 = -1, tfd2 = -1, tfd3 = -1;
int fd = -1;
struct test_data data;
struct pomp_loop *loop = NULL;
memset(&data, 0, sizeof(data));
/* Create loop */
loop = pomp_loop_new();
CU_ASSERT_PTR_NOT_NULL_FATAL(loop);
/* Create timers for testing */
tfd1 = setup_timerfd(100, 500);
CU_ASSERT_TRUE_FATAL(tfd1 >= 0);
tfd2 = setup_timerfd(50, 500);
CU_ASSERT_TRUE_FATAL(tfd2 >= 0);
tfd3 = setup_timerfd(150, 500);
CU_ASSERT_TRUE_FATAL(tfd3 >= 0);
/* Add timer in loop */
res = pomp_loop_add(loop, tfd1, POMP_FD_EVENT_IN, &timerfd_cb, &data);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_has_fd(loop, tfd1);
CU_ASSERT_EQUAL(res, 1);
res = pomp_loop_has_fd(loop, tfd2);
CU_ASSERT_EQUAL(res, 0);
/* Invalid add (already in loop) */
res = pomp_loop_add(loop, tfd1, POMP_FD_EVENT_IN, &timerfd_cb, &data);
CU_ASSERT_EQUAL(res, -EEXIST);
/* Invalid add (NULL param) */
res = pomp_loop_add(NULL, tfd1, POMP_FD_EVENT_IN, &timerfd_cb, &data);
CU_ASSERT_EQUAL(res, -EINVAL);
res = pomp_loop_add(loop, tfd1, POMP_FD_EVENT_IN, NULL, &data);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid add (invalid events) */
res = pomp_loop_add(loop, tfd1, 0, &timerfd_cb, &data);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid add (invalid fd) */
res = pomp_loop_add(loop, -1, POMP_FD_EVENT_IN, &timerfd_cb, &data);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Update events */
res = pomp_loop_update(loop, tfd1, POMP_FD_EVENT_IN | POMP_FD_EVENT_OUT);
CU_ASSERT_EQUAL(res, 0);
/* Invalid update (NULL param) */
res = pomp_loop_update(NULL, tfd1, POMP_FD_EVENT_IN | POMP_FD_EVENT_OUT);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid update (invalid events) */
res = pomp_loop_update(loop, tfd1, 0);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid update (invalid fd) */
res = pomp_loop_update(loop, -1, POMP_FD_EVENT_IN | POMP_FD_EVENT_OUT);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid remove (fd not registered) */
res = pomp_loop_update(loop, 2, POMP_FD_EVENT_IN | POMP_FD_EVENT_OUT);
CU_ASSERT_EQUAL(res, -ENOENT);
/* Update again events */
res = pomp_loop_update(loop, tfd1, POMP_FD_EVENT_IN);
CU_ASSERT_EQUAL(res, 0);
/* Add 2nd and 3rd timer in loop */
res = pomp_loop_add(loop, tfd2, POMP_FD_EVENT_IN, &timerfd_cb, &data);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_add(loop, tfd3, POMP_FD_EVENT_IN, &timerfd_cb, &data);
CU_ASSERT_EQUAL(res, 0);
/* Get loop fd */
fd = pomp_loop_get_fd(loop);
CU_ASSERT_TRUE((is_epoll && fd >= 0) || (!is_epoll && fd == -ENOSYS));
fd = pomp_loop_get_fd(NULL);
CU_ASSERT_EQUAL(fd, -EINVAL);
/* Run loop with different timeout first one should have all timers) */
res = pomp_loop_wait_and_process(loop, 500);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_wait_and_process(loop, 0);
CU_ASSERT_TRUE(res == -ETIMEDOUT || res == 0);
res = pomp_loop_wait_and_process(loop, -1);
CU_ASSERT_EQUAL(res, 0);
/* Invalid run (NULL param) */
res = pomp_loop_wait_and_process(NULL, 0);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid destroy (NULL param) */
res = pomp_loop_destroy(NULL);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid destroy (busy) */
res = pomp_loop_destroy(loop);
CU_ASSERT_EQUAL(res, -EBUSY);
/* Invalid remove (NULL param) */
res = pomp_loop_remove(NULL, tfd1);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid remove (invalid fd) */
res = pomp_loop_remove(loop, -1);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid remove (fd not registered) */
res = pomp_loop_remove(loop, 2);
CU_ASSERT_EQUAL(res, -ENOENT);
/* Remove timers */
res = pomp_loop_remove(loop, tfd1);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_remove(loop, tfd2);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_remove(loop, tfd3);
CU_ASSERT_EQUAL(res, 0);
/* Close timers */
res = close(tfd1);
CU_ASSERT_EQUAL(res, 0);
res = close(tfd2);
CU_ASSERT_EQUAL(res, 0);
res = close(tfd3);
CU_ASSERT_EQUAL(res, 0);
/* Destroy loop */
res = pomp_loop_destroy(loop);
CU_ASSERT_EQUAL(res, 0);
}
static void test_loop(void)
{
int res = 0;
HANDLE htimer1 = NULL, htimer2 = NULL, htimer3 = NULL;
struct test_data data;
struct pomp_loop *loop = NULL;
struct pomp_fd *pfd = NULL;
memset(&data, 0, sizeof(data));
/* Create loop */
loop = pomp_loop_new();
CU_ASSERT_PTR_NOT_NULL_FATAL(loop);
/* Create timers for testing */
htimer1 = setup_timer_win32(100, 500);
CU_ASSERT_PTR_NOT_NULL_FATAL(htimer1);
htimer2 = setup_timer_win32(50, 500);
CU_ASSERT_PTR_NOT_NULL_FATAL(htimer2);
htimer3 = setup_timer_win32(150, 500);
CU_ASSERT_PTR_NOT_NULL_FATAL(htimer3);
/* Add timer in loop */
pfd = pomp_loop_win32_add_pfd_with_hevt(loop, htimer1, &timer_win32_cb, &data);
CU_ASSERT_PTR_NOT_NULL(pfd);
/* Add 2nd and 3rd timer in loop */
pfd = pomp_loop_win32_add_pfd_with_hevt(loop, htimer2, &timer_win32_cb, &data);
CU_ASSERT_PTR_NOT_NULL(pfd);
pfd = pomp_loop_win32_add_pfd_with_hevt(loop, htimer3, &timer_win32_cb, &data);
CU_ASSERT_PTR_NOT_NULL(pfd);
/* Run loop with different timeout first one should have all timers) */
res = pomp_loop_wait_and_process(loop, 500);
CU_ASSERT_EQUAL(res, 0);
res = pomp_loop_wait_and_process(loop, 0);
CU_ASSERT_TRUE(res == -ETIMEDOUT || res == 0);
res = pomp_loop_wait_and_process(loop, -1);
CU_ASSERT_EQUAL(res, 0);
/* Invalid run (NULL param) */
res = pomp_loop_wait_and_process(NULL, 0);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid destroy (NULL param) */
res = pomp_loop_destroy(NULL);
CU_ASSERT_EQUAL(res, -EINVAL);
/* Invalid destroy (busy) */
res = pomp_loop_destroy(loop);
CU_ASSERT_EQUAL(res, -EBUSY);
/* Remove timers */
pfd = pomp_loop_win32_find_pfd_by_hevt(loop, htimer1);
CU_ASSERT_PTR_NOT_NULL(pfd);
res = pomp_loop_remove_pfd(loop, pfd);
CU_ASSERT_EQUAL(res, 0);
free(pfd);
pfd = pomp_loop_win32_find_pfd_by_hevt(loop, htimer2);
CU_ASSERT_PTR_NOT_NULL(pfd);
res = pomp_loop_remove_pfd(loop, pfd);
CU_ASSERT_EQUAL(res, 0);
free(pfd);
pfd = pomp_loop_win32_find_pfd_by_hevt(loop, htimer3);
CU_ASSERT_PTR_NOT_NULL(pfd);
res = pomp_loop_remove_pfd(loop, pfd);
CU_ASSERT_EQUAL(res, 0);
free(pfd);
/* Close timers */
res = CloseHandle(htimer1);
CU_ASSERT_EQUAL(res, 1);
res = CloseHandle(htimer2);
CU_ASSERT_EQUAL(res, 1);
res = CloseHandle(htimer3);
CU_ASSERT_EQUAL(res, 1);
/* Destroy loop */
res = pomp_loop_destroy(loop);
CU_ASSERT_EQUAL(res, 0);
}
