From 76073fe5fad8799e5850805f2f090af2cb62c741 Mon Sep 17 00:00:00 2001 From: Berke Güzel Date: Tue, 13 Oct 2026 23:41:31 +0300 Subject: Simplify the public event and CPU API Applications now need far less ceremony: hello.c is a 20-line loop that handles REFRESH, CLOSE and QUIT and draws into the surface's own pixels. - Fold GEOMETRY, STATE and FOCUS into one WINDOW event carrying size, scale and state; unchanged values send nothing. - Guarantee REFRESH once a window has a size and after every resize, never at size zero. - Merge DROP_HOVER into DROP with over/leave/data actions and give drag and drop actions enums. - Keep event strings valid until the next wait and drop yasl_event_release; empty or failed waits report NONE. - Replace copy-in presentation with a lent pixel buffer: yasl_cpu_pixels and yasl_cpu_present. - Remove yasl_poll_event, yasl_cpu_read_pixels, unused event fields and comments that restated names. - Wayland: resize floating windows in request_size instead of reporting it unsupported, and stop marking new GPU surfaces as Vulkan so yasl_vulkan_create_surface no longer fails with NATIVE_WINDOW_IN_USE. Also includes the in-progress public API refactor that was uncommitted in the tree (removal of the app/loop layer, new surface, GL and Vulkan entry points). Co-Authored-By: Claude Opus 5.5 --- tests/common/test_loop.c | 76 ++++++++++++++++++++++++------------------------ 1 file changed, 38 insertions(+), 38 deletions(-) (limited to 'tests/common/test_loop.c') diff --git a/tests/common/test_loop.c b/tests/common/test_loop.c index f982e5e..5c49691 100644 --- a/tests/common/test_loop.c +++ b/tests/common/test_loop.c @@ -1,6 +1,6 @@ #define _GNU_SOURCE #define _DARWIN_C_SOURCE -#include "yasl/loop.h" +#include "common/private_loop.h" #include #include @@ -29,7 +29,7 @@ static void on_alarm(int signo) } struct post_log { - struct yasl_loop *loop; + struct yasl_private_loop *loop; char order[8]; int count; }; @@ -46,7 +46,7 @@ static void post_a(void *ud) { struct post_log *log = ud; log->order[log->count++] = 'a'; - assert(yasl_loop_post(log->loop, post_c, log)); + assert(yasl_private_loop_post(log->loop, post_c, log)); } static void post_b(void *ud) @@ -57,28 +57,28 @@ static void post_b(void *ud) static void test_post_order(void) { - struct yasl_loop *l = yasl_loop_create(); + struct yasl_private_loop *l = yasl_private_loop_create(); assert(l); - assert(!yasl_loop_post(NULL, post_b, NULL)); - assert(!yasl_loop_post(l, NULL, NULL)); + assert(!yasl_private_loop_post(NULL, post_b, NULL)); + assert(!yasl_private_loop_post(l, NULL, NULL)); struct post_log log = {.loop = l}; - assert(yasl_loop_post(l, post_a, &log)); - assert(yasl_loop_post(l, post_b, &log)); - assert(yasl_loop_step(l, 0) >= 1); + assert(yasl_private_loop_post(l, post_a, &log)); + assert(yasl_private_loop_post(l, post_b, &log)); + assert(yasl_private_loop_step(l, 0) >= 1); /* A post made while posts run waits for a later step. */ assert(log.count == 2 && memcmp(log.order, "ab", 2) == 0); - assert(yasl_loop_step(l, 0) >= 1); + assert(yasl_private_loop_step(l, 0) >= 1); assert(log.count == 3 && log.order[2] == 'c'); /* Destroy drops posts that never ran. */ - assert(yasl_loop_post(l, post_b, &log)); - yasl_loop_destroy(l); + assert(yasl_private_loop_post(l, post_b, &log)); + yasl_private_loop_destroy(l); assert(log.count == 3); } struct thread_ctx { - struct yasl_loop *loop; + struct yasl_private_loop *loop; bool kick; int signo; _Atomic bool ran; @@ -97,35 +97,35 @@ static void *wake_thread(void *ud) if (ctx->signo) kill(getpid(), ctx->signo); else if (ctx->kick) - yasl_loop_kick(ctx->loop); + yasl_private_loop_kick(ctx->loop); else - assert(yasl_loop_post(ctx->loop, mark_ran, ctx)); + assert(yasl_private_loop_post(ctx->loop, mark_ran, ctx)); return NULL; } static void test_cross_thread(void) { - struct yasl_loop *l = yasl_loop_create(); + struct yasl_private_loop *l = yasl_private_loop_create(); assert(l); struct thread_ctx post = {.loop = l}; pthread_t t; assert(pthread_create(&t, NULL, wake_thread, &post) == 0); while (!post.ran) - assert(yasl_loop_step(l, -1) >= 0); + assert(yasl_private_loop_step(l, -1) >= 0); pthread_join(t, NULL); /* A kick ends an indefinite wait without running anything. */ struct thread_ctx kick = {.loop = l, .kick = true}; assert(pthread_create(&t, NULL, wake_thread, &kick) == 0); - assert(yasl_loop_step(l, -1) >= 1); + assert(yasl_private_loop_step(l, -1) >= 1); pthread_join(t, NULL); - yasl_loop_destroy(l); + yasl_private_loop_destroy(l); } struct signal_log { - struct yasl_loop *loop; + struct yasl_private_loop *loop; int seen[NSIG]; int total; bool unwatch; @@ -138,7 +138,7 @@ static void on_signal(void *ud, int signo) log->seen[signo]++; log->total++; if (log->unwatch) - yasl_loop_unwatch_signals(log->loop); + yasl_private_loop_unwatch_signals(log->loop); } static volatile sig_atomic_t previous_handler_hits; @@ -149,10 +149,10 @@ static void previous_handler(int signo) previous_handler_hits++; } -static void step_until(struct yasl_loop *l, const int *counter, int want) +static void step_until(struct yasl_private_loop *l, const int *counter, int want) { while (*counter < want) - assert(yasl_loop_step(l, -1) >= 0); + assert(yasl_private_loop_step(l, -1) >= 0); } static void test_signals(void) @@ -161,30 +161,30 @@ static void test_signals(void) sigemptyset(&prev.sa_mask); assert(sigaction(SIGUSR2, &prev, NULL) == 0); - struct yasl_loop *l = yasl_loop_create(); - struct yasl_loop *other = yasl_loop_create(); + struct yasl_private_loop *l = yasl_private_loop_create(); + struct yasl_private_loop *other = yasl_private_loop_create(); assert(l && other); struct signal_log log = {.loop = l}; const int bad[] = {SIGKILL}; errno = 0; - assert(!yasl_loop_watch_signals(l, bad, 1, on_signal, &log) && errno == EINVAL); + assert(!yasl_private_loop_watch_signals(l, bad, 1, on_signal, &log) && errno == EINVAL); const int sigs[] = {SIGUSR1, SIGUSR2, SIGCHLD}; errno = 0; - assert(!yasl_loop_watch_signals(l, sigs, 0, on_signal, &log) && errno == EINVAL); + assert(!yasl_private_loop_watch_signals(l, sigs, 0, on_signal, &log) && errno == EINVAL); errno = 0; - assert(!yasl_loop_watch_signals(l, sigs, 3, NULL, &log) && errno == EINVAL); - assert(yasl_loop_watch_signals(l, sigs, 3, on_signal, &log)); + assert(!yasl_private_loop_watch_signals(l, sigs, 3, NULL, &log) && errno == EINVAL); + assert(yasl_private_loop_watch_signals(l, sigs, 3, on_signal, &log)); /* One signal belongs to one loop at a time. */ errno = 0; - assert(!yasl_loop_watch_signals(other, sigs, 1, on_signal, &log) && errno == EBUSY); + assert(!yasl_private_loop_watch_signals(other, sigs, 1, on_signal, &log) && errno == EBUSY); /* Deliveries before the callback runs coalesce per signal. */ raise(SIGUSR1); raise(SIGUSR1); raise(SIGUSR2); - assert(yasl_loop_step(l, 0) >= 1); + assert(yasl_private_loop_step(l, 0) >= 1); assert(log.seen[SIGUSR1] == 1 && log.seen[SIGUSR2] == 1); assert(previous_handler_hits == 0); @@ -205,11 +205,11 @@ static void test_signals(void) /* Replacing the watch restores the signals it drops. */ const int only_usr1[] = {SIGUSR1}; - assert(yasl_loop_watch_signals(l, only_usr1, 1, on_signal, &log)); + assert(yasl_private_loop_watch_signals(l, only_usr1, 1, on_signal, &log)); raise(SIGUSR2); assert(previous_handler_hits == 1); - assert(yasl_loop_watch_signals(other, (const int[]){SIGUSR2}, 1, on_signal, &log)); - yasl_loop_unwatch_signals(other); + assert(yasl_private_loop_watch_signals(other, (const int[]){SIGUSR2}, 1, on_signal, &log)); + yasl_private_loop_unwatch_signals(other); assert(previous_handler_hits == 1); raise(SIGUSR2); assert(previous_handler_hits == 2); @@ -221,15 +221,15 @@ static void test_signals(void) struct sigaction now; assert(sigaction(SIGUSR1, NULL, &now) == 0); assert(now.sa_handler == SIG_DFL); - yasl_loop_unwatch_signals(l); + yasl_private_loop_unwatch_signals(l); /* Destroy unwatches. */ log.unwatch = false; - assert(yasl_loop_watch_signals(l, only_usr1, 1, on_signal, &log)); - yasl_loop_destroy(l); + assert(yasl_private_loop_watch_signals(l, only_usr1, 1, on_signal, &log)); + yasl_private_loop_destroy(l); assert(sigaction(SIGUSR1, NULL, &now) == 0); assert(now.sa_handler == SIG_DFL); - yasl_loop_destroy(other); + yasl_private_loop_destroy(other); struct sigaction dfl = {.sa_handler = SIG_DFL}; sigemptyset(&dfl.sa_mask); -- cgit v1.2.3