events_portable.c
test-suites/regression/c/events_portable.c · 189 line(s) · c
/* events_portable.c -- portable smoke test for impl/core/sleela_events.c.
*
* reg_events.c is the full POSIX suite (it links the instrumented allocator
* through GNU ld --wrap). This file needs only a C11 compiler and the OS
* thread API, so CI can compile and run the Windows and macOS branches of
* sleela_events.c too. Build:
*
* cc -std=c11 -Wall -Wextra -Wpedantic -Werror \
* test-suites/regression/c/events_portable.c impl/core/sleela_events.c \
* -o events_portable [-pthread]
*
* (No -Iimpl/core: that directory holds a Windows pthread.h shim that must not
* replace the system header on POSIX.)
*
* Exit status 0 only when every check passes.
*/
#ifndef _WIN32
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#endif
#endif
#include "../../../impl/core/sleela_events.h"
#include <errno.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#ifdef _WIN32
#include <windows.h>
#else
#include <pthread.h>
#include <time.h>
#endif
static int failures;
static int checks;
#define CHECK(cond) do { checks++; if (!(cond)) { failures++; fprintf(stderr, "FAIL %s:%d: %s\n", __FILE__, __LINE__, #cond); } } while (0)
#define CHECK_EQ(want, got) do { long long w_ = (long long)(want), g_ = (long long)(got); checks++; \
if (w_ != g_) { failures++; fprintf(stderr, "FAIL %s:%d: %s == %s (want %lld, got %lld)\n", __FILE__, __LINE__, #want, #got, w_, g_); } } while (0)
static uint64_t now_ms(void) {
#ifdef _WIN32
return (uint64_t)GetTickCount64();
#else
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t)ts.tv_sec * 1000u + (uint64_t)ts.tv_nsec / 1000000u;
#endif
}
static void sleep_ms(unsigned ms) {
#ifdef _WIN32
Sleep(ms);
#else
struct timespec ts;
ts.tv_sec = (time_t)(ms / 1000u);
ts.tv_nsec = (long)(ms % 1000u) * 1000000L;
nanosleep(&ts, NULL);
#endif
}
static void t_platform(void) {
#if defined(_WIN32)
CHECK_EQ(SL_EVENT_WINDOWS, slevent_platform());
CHECK(strcmp(slevent_platform_name(), "windows-events") == 0);
#elif defined(__APPLE__)
CHECK_EQ(SL_EVENT_MACOS, slevent_platform());
CHECK(strcmp(slevent_platform_name(), "macos-signals-events") == 0);
#else
CHECK_EQ(SL_EVENT_LINUX, slevent_platform());
CHECK(strcmp(slevent_platform_name(), "linux-signals-events") == 0);
#endif
CHECK_EQ(1, slevent_platform_is_available(SL_EVENT_AUTO));
CHECK_EQ(1, slevent_platform_is_available(slevent_platform()));
}
static void t_manual_reset_and_timeout(void) {
SLEventHandle h = slevent_create(0), s = slevent_create(1);
uint64_t t0, waited;
CHECK(slevent_valid(h));
CHECK(slevent_valid(s));
CHECK_EQ(ETIMEDOUT, slevent_wait(h, 0));
CHECK_EQ(0, slevent_wait(s, 0));
t0 = now_ms();
CHECK_EQ(ETIMEDOUT, slevent_wait(h, 80));
waited = now_ms() - t0;
CHECK(waited >= 60); /* a timed wait must block, not return at once */
CHECK(waited < 5000);
CHECK_EQ(0, slevent_set(h));
CHECK_EQ(0, slevent_wait(h, 0));
CHECK_EQ(0, slevent_wait(h, 0)); /* manual reset: stays set */
CHECK_EQ(0, slevent_reset(h));
CHECK_EQ(ETIMEDOUT, slevent_wait(h, 0));
CHECK_EQ(0, slevent_close(h));
CHECK_EQ(0, slevent_close(s));
}
static void t_invalid_handles(void) {
SLEventHandle bad[2] = { SL_EVENT_INVALID, 0 };
int i;
for (i = 0; i < 2; i++) {
CHECK(!slevent_valid(bad[i]));
CHECK_EQ(EINVAL, slevent_set(bad[i]));
CHECK_EQ(EINVAL, slevent_reset(bad[i]));
CHECK_EQ(EINVAL, slevent_wait(bad[i], 0));
/* must be rejected, not passed to the OS (on Windows -1 is the
* current-process pseudo-handle, so this used to block forever) */
CHECK_EQ(EINVAL, slevent_wait(bad[i], UINT32_MAX));
CHECK_EQ(EINVAL, slevent_close(bad[i]));
}
}
static SLEventHandle g_event;
static int g_wait_result = -1;
#ifdef _WIN32
static DWORD WINAPI waiter(LPVOID arg) { (void)arg; g_wait_result = slevent_wait(g_event, UINT32_MAX); return 0; }
#else
static void* waiter(void* arg) { (void)arg; g_wait_result = slevent_wait(g_event, UINT32_MAX); return NULL; }
#endif
static void t_set_wakes_a_blocked_waiter(void) {
g_event = slevent_create(0);
CHECK(slevent_valid(g_event));
#ifdef _WIN32
{
HANDLE th = CreateThread(NULL, 0, waiter, NULL, 0, NULL);
CHECK(th != NULL);
sleep_ms(50);
CHECK_EQ(-1, g_wait_result); /* still blocked */
CHECK_EQ(0, slevent_set(g_event));
CHECK_EQ(WAIT_OBJECT_0, WaitForSingleObject(th, 5000));
CloseHandle(th);
}
#else
{
pthread_t th;
CHECK_EQ(0, pthread_create(&th, NULL, waiter, NULL));
sleep_ms(50);
CHECK_EQ(-1, g_wait_result);
CHECK_EQ(0, slevent_set(g_event));
CHECK_EQ(0, pthread_join(th, NULL));
}
#endif
CHECK_EQ(0, g_wait_result);
CHECK_EQ(0, slevent_close(g_event));
}
static void t_signal_handler_survives_repeat_delivery(void) {
int round;
CHECK_EQ(0, slevent_install_signal(SIGINT));
for (round = 0; round < 3; round++) {
CHECK_EQ(0, slevent_signal_pending(SIGINT));
CHECK_EQ(0, raise(SIGINT)); /* a one-shot handler kills the process on round 2 */
CHECK_EQ(1, slevent_signal_pending(SIGINT));
CHECK_EQ(0, slevent_clear_signal(SIGINT));
}
CHECK_EQ(EINVAL, slevent_install_signal(0));
}
static void t_queue_is_bounded_fifo(void) {
SLEvent e;
uint32_t k;
while (slevent_poll(&e) == 1) {}
for (k = 0; k < 64; k++) CHECK_EQ(0, slevent_post(1, k, (intptr_t)k * 10));
CHECK_EQ(EAGAIN, slevent_post(1, 99, 0));
for (k = 0; k < 64; k++) {
CHECK_EQ(1, slevent_poll(&e));
CHECK_EQ(k, e.code);
CHECK_EQ((intptr_t)k * 10, e.value);
}
CHECK_EQ(0, slevent_poll(&e));
CHECK_EQ(EINVAL, slevent_poll(NULL));
}
int main(void) {
t_platform();
t_manual_reset_and_timeout();
t_invalid_handles();
t_set_wakes_a_blocked_waiter();
t_signal_handler_survives_repeat_delivery();
t_queue_is_bounded_fifo();
printf("SUITE events_portable (%s): checks=%d failures=%d\n", slevent_platform_name(), checks, failures);
return failures == 0 ? 0 : 1;
}