/* test-watch.c
*
* Copyright 2025 Christian Hergert
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of the
* License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see .
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "config.h"
#include
#include
#include
#include "dex-watch-private.h"
#define ASSERT_STATUS(f,status) g_assert_cmpint(status, ==, dex_future_get_status(DEX_FUTURE(f)))
static DexFuture *
quit_cb (DexFuture *future,
gpointer user_data)
{
g_main_loop_quit (user_data);
return NULL;
}
static void
test_watch_read_ready (void)
{
int pipefd[2];
DexFuture *watch;
GMainLoop *main_loop;
GError *error = NULL;
const GValue *value;
int revents;
g_assert_cmpint (pipe (pipefd), ==, 0);
/* Watch for read readiness */
watch = dex_watch_new (pipefd[0], G_IO_IN);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_PENDING);
main_loop = g_main_loop_new (NULL, FALSE);
watch = dex_future_then (watch, quit_cb, main_loop, NULL);
/* Write data to make read side ready */
g_assert_cmpint (write (pipefd[1], "test", 4), ==, 4);
g_main_loop_run (main_loop);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_RESOLVED);
value = dex_future_get_value (watch, &error);
g_assert_no_error (error);
g_assert_nonnull (value);
g_assert_true (G_VALUE_HOLDS_INT (value));
revents = g_value_get_int (value);
g_assert_cmpint (revents & G_IO_IN, !=, 0);
close (pipefd[0]);
close (pipefd[1]);
g_main_loop_unref (main_loop);
dex_unref (watch);
}
static void
test_watch_write_ready (void)
{
int pipefd[2];
DexFuture *watch;
GMainLoop *main_loop;
GError *error = NULL;
const GValue *value;
int revents;
g_assert_cmpint (pipe (pipefd), ==, 0);
/* Watch for write readiness (pipe should be writable immediately) */
watch = dex_watch_new (pipefd[1], G_IO_OUT);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_PENDING);
main_loop = g_main_loop_new (NULL, FALSE);
watch = dex_future_then (watch, quit_cb, main_loop, NULL);
g_main_loop_run (main_loop);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_RESOLVED);
value = dex_future_get_value (watch, &error);
g_assert_no_error (error);
g_assert_nonnull (value);
g_assert_true (G_VALUE_HOLDS_INT (value));
revents = g_value_get_int (value);
g_assert_cmpint (revents & G_IO_OUT, !=, 0);
close (pipefd[0]);
close (pipefd[1]);
g_main_loop_unref (main_loop);
dex_unref (watch);
}
static void
test_watch_write_side_closed (void)
{
int pipefd[2];
DexFuture *watch;
GMainLoop *main_loop;
GError *error = NULL;
const GValue *value;
int revents;
g_assert_cmpint (pipe (pipefd), ==, 0);
/* Watch for read readiness and hangup */
watch = dex_watch_new (pipefd[0], G_IO_IN);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_PENDING);
/* Close write side, which should trigger HUP on read side */
close (pipefd[1]);
main_loop = g_main_loop_new (NULL, FALSE);
watch = dex_future_then (watch, quit_cb, main_loop, NULL);
g_main_loop_run (main_loop);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_RESOLVED);
value = dex_future_get_value (watch, &error);
g_assert_no_error (error);
g_assert_nonnull (value);
g_assert_true (G_VALUE_HOLDS_INT (value));
revents = g_value_get_int (value);
g_assert_cmpint (revents & G_IO_HUP, !=, 0);
close (pipefd[0]);
g_main_loop_unref (main_loop);
dex_unref (watch);
}
static void
test_watch_read_waiting_write_closed (void)
{
int pipefd[2];
DexFuture *watch;
GMainLoop *main_loop;
GError *error = NULL;
const GValue *value;
int revents;
g_assert_cmpint (pipe (pipefd), ==, 0);
/* Watch for read readiness only (not explicitly HUP) */
watch = dex_watch_new (pipefd[0], G_IO_IN);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_PENDING);
main_loop = g_main_loop_new (NULL, FALSE);
watch = dex_future_then (watch, quit_cb, main_loop, NULL);
/* Close write side, which should trigger HUP on read side */
close (pipefd[1]);
g_main_loop_run (main_loop);
/* Future should complete even though we only asked for G_IO_IN */
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_RESOLVED);
value = dex_future_get_value (watch, &error);
g_assert_no_error (error);
g_assert_nonnull (value);
g_assert_true (G_VALUE_HOLDS_INT (value));
revents = g_value_get_int (value);
/* When write side closes, read side gets HUP */
g_assert_cmpint (revents & G_IO_HUP, !=, 0);
close (pipefd[0]);
g_main_loop_unref (main_loop);
dex_unref (watch);
}
static void
test_watch_read_side_closed (void)
{
int pipefd[2];
DexFuture *watch;
GMainLoop *main_loop;
GError *error = NULL;
const GValue *value;
int revents;
g_assert_cmpint (pipe (pipefd), ==, 0);
/* Watch for write readiness and hangup */
watch = dex_watch_new (pipefd[1], G_IO_OUT | G_IO_HUP);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_PENDING);
main_loop = g_main_loop_new (NULL, FALSE);
watch = dex_future_then (watch, quit_cb, main_loop, NULL);
/* Close read side, which should trigger HUP on write side */
close (pipefd[0]);
g_main_loop_run (main_loop);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_RESOLVED);
value = dex_future_get_value (watch, &error);
g_assert_no_error (error);
g_assert_nonnull (value);
g_assert_true (G_VALUE_HOLDS_INT (value));
revents = g_value_get_int (value);
/* When read side is closed, write side gets HUP or ERR */
g_assert_true ((revents & G_IO_HUP) != 0 || (revents & G_IO_ERR) != 0);
close (pipefd[1]);
g_main_loop_unref (main_loop);
dex_unref (watch);
}
static void
test_watch_multiple_events (void)
{
int pipefd[2];
DexFuture *watch;
GMainLoop *main_loop;
GError *error = NULL;
const GValue *value;
int revents;
g_assert_cmpint (pipe (pipefd), ==, 0);
/* Watch for both read and write readiness */
watch = dex_watch_new (pipefd[1], G_IO_OUT | G_IO_IN);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_PENDING);
main_loop = g_main_loop_new (NULL, FALSE);
watch = dex_future_then (watch, quit_cb, main_loop, NULL);
/* Write side should be immediately writable */
g_main_loop_run (main_loop);
ASSERT_STATUS (watch, DEX_FUTURE_STATUS_RESOLVED);
value = dex_future_get_value (watch, &error);
g_assert_no_error (error);
g_assert_nonnull (value);
g_assert_true (G_VALUE_HOLDS_INT (value));
revents = g_value_get_int (value);
g_assert_cmpint (revents & G_IO_OUT, !=, 0);
close (pipefd[0]);
close (pipefd[1]);
g_main_loop_unref (main_loop);
dex_unref (watch);
}
int
main (int argc,
char *argv[])
{
dex_init ();
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/Dex/TestSuite/Watch/read_ready", test_watch_read_ready);
g_test_add_func ("/Dex/TestSuite/Watch/write_ready", test_watch_write_ready);
g_test_add_func ("/Dex/TestSuite/Watch/write_side_closed", test_watch_write_side_closed);
g_test_add_func ("/Dex/TestSuite/Watch/read_waiting_write_closed", test_watch_read_waiting_write_closed);
g_test_add_func ("/Dex/TestSuite/Watch/read_side_closed", test_watch_read_side_closed);
g_test_add_func ("/Dex/TestSuite/Watch/multiple_events", test_watch_multiple_events);
return g_test_run ();
}