/*
 * Copyright (c) 2023 Meta
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <errno.h>
#include <signal.h>
#include <stdio.h>

#include <zephyr/kernel.h>
#include <zephyr/ztest.h>

ZTEST(posix_apis, test_signal_emptyset)
{
	sigset_t set;

	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		set.sig[i] = -1;
	}

	zassert_ok(sigemptyset(&set));

	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], 0u, "set.sig[%d] is not empty: 0x%lx", i, set.sig[i]);
	}
}

ZTEST(posix_apis, test_signal_fillset)
{
	sigset_t set = (sigset_t){0};

	zassert_ok(sigfillset(&set));

	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], -1, "set.sig[%d] is not filled: 0x%lx", i, set.sig[i]);
	}
}

ZTEST(posix_apis, test_signal_addset_oor)
{
	sigset_t set = (sigset_t){0};

	zassert_equal(sigaddset(&set, -1), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");

	zassert_equal(sigaddset(&set, 0), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");

	zassert_equal(sigaddset(&set, _NSIG), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");
}

ZTEST(posix_apis, test_signal_addset)
{
	int signo;
	sigset_t set = (sigset_t){0};
	sigset_t target = (sigset_t){0};

	signo = SIGHUP;
	zassert_ok(sigaddset(&set, signo));
	WRITE_BIT(target.sig[0], signo, 1);
	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], target.sig[i],
			      "set.sig[%d of %d] has content: %lx, expected %lx", i,
			      ARRAY_SIZE(set.sig) - 1, set.sig[i], target.sig[i]);
	}

	signo = SIGSYS;
	zassert_ok(sigaddset(&set, signo));
	WRITE_BIT(target.sig[0], signo, 1);
	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], target.sig[i],
			      "set.sig[%d of %d] has content: %lx, expected %lx", i,
			      ARRAY_SIZE(set.sig) - 1, set.sig[i], target.sig[i]);
	}

	signo = SIGRTMIN; /* >=32, will be in the second sig set for 32bit */
	zassert_ok(sigaddset(&set, signo));
#ifdef CONFIG_64BIT
	WRITE_BIT(target.sig[0], signo, 1);
#else /* 32BIT */
	WRITE_BIT(target.sig[1], (signo)-BITS_PER_LONG, 1);
#endif
	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], target.sig[i],
			      "set.sig[%d of %d] has content: %lx, expected %lx", i,
			      ARRAY_SIZE(set.sig) - 1, set.sig[i], target.sig[i]);
	}

	signo = SIGRTMAX;
	zassert_ok(sigaddset(&set, signo));
	WRITE_BIT(target.sig[signo / BITS_PER_LONG], signo % BITS_PER_LONG, 1);
	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], target.sig[i],
			      "set.sig[%d of %d] has content: %lx, expected %lx", i,
			      ARRAY_SIZE(set.sig) - 1, set.sig[i], target.sig[i]);
	}
}

ZTEST(posix_apis, test_signal_delset_oor)
{
	sigset_t set = (sigset_t){0};

	zassert_equal(sigdelset(&set, -1), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");

	zassert_equal(sigdelset(&set, 0), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");

	zassert_equal(sigdelset(&set, _NSIG), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");
}

ZTEST(posix_apis, test_signal_delset)
{
	int signo;
	sigset_t set = (sigset_t){0};
	sigset_t target = (sigset_t){0};

	signo = SIGHUP;
	zassert_ok(sigdelset(&set, signo));
	WRITE_BIT(target.sig[0], signo, 0);
	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], target.sig[i],
			      "set.sig[%d of %d] has content: %lx, expected %lx", i,
			      ARRAY_SIZE(set.sig) - 1, set.sig[i], target.sig[i]);
	}

	signo = SIGSYS;
	zassert_ok(sigdelset(&set, signo));
	WRITE_BIT(target.sig[0], signo, 0);
	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], target.sig[i],
			      "set.sig[%d of %d] has content: %lx, expected %lx", i,
			      ARRAY_SIZE(set.sig) - 1, set.sig[i], target.sig[i]);
	}

	signo = SIGRTMIN; /* >=32, will be in the second sig set for 32bit */
	zassert_ok(sigdelset(&set, signo));
#ifdef CONFIG_64BIT
	WRITE_BIT(target.sig[0], signo, 0);
#else /* 32BIT */
	WRITE_BIT(target.sig[1], (signo)-BITS_PER_LONG, 0);
#endif
	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], target.sig[i],
			      "set.sig[%d of %d] has content: %lx, expected %lx", i,
			      ARRAY_SIZE(set.sig) - 1, set.sig[i], target.sig[i]);
	}

	signo = SIGRTMAX;
	zassert_ok(sigdelset(&set, signo));
	WRITE_BIT(target.sig[signo / BITS_PER_LONG], signo % BITS_PER_LONG, 0);
	for (int i = 0; i < ARRAY_SIZE(set.sig); i++) {
		zassert_equal(set.sig[i], target.sig[i],
			      "set.sig[%d of %d] has content: %lx, expected %lx", i,
			      ARRAY_SIZE(set.sig) - 1, set.sig[i], target.sig[i]);
	}
}

ZTEST(posix_apis, test_signal_ismember_oor)
{
	sigset_t set = {0};

	zassert_equal(sigismember(&set, -1), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");

	zassert_equal(sigismember(&set, 0), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");

	zassert_equal(sigismember(&set, _NSIG), -1, "rc should be -1");
	zassert_equal(errno, EINVAL, "errno should be %s", "EINVAL");
}

ZTEST(posix_apis, test_signal_ismember)
{
	sigset_t set = (sigset_t){0};

#ifdef CONFIG_64BIT
	set.sig[0] = BIT(SIGHUP) | BIT(SIGSYS) | BIT(SIGRTMIN);
#else /* 32BIT */
	set.sig[0] = BIT(SIGHUP) | BIT(SIGSYS);
	set.sig[1] = BIT((SIGRTMIN)-BITS_PER_LONG);
#endif
	WRITE_BIT(set.sig[SIGRTMAX / BITS_PER_LONG], SIGRTMAX % BITS_PER_LONG, 1);

	zassert_equal(sigismember(&set, SIGHUP), 1, "%s expected to be member", "SIGHUP");
	zassert_equal(sigismember(&set, SIGSYS), 1, "%s expected to be member", "SIGSYS");
	zassert_equal(sigismember(&set, SIGRTMIN), 1, "%s expected to be member", "SIGRTMIN");
	zassert_equal(sigismember(&set, SIGRTMAX), 1, "%s expected to be member", "SIGRTMAX");

	zassert_equal(sigismember(&set, SIGKILL), 0, "%s not expected to be member", "SIGKILL");
	zassert_equal(sigismember(&set, SIGTERM), 0, "%s not expected to be member", "SIGTERM");
}

ZTEST(posix_apis, test_signal_strsignal)
{
	/* Using -INT_MAX here because compiler resolves INT_MIN to (-2147483647 - 1) */
	char buf[sizeof("RT signal -" STRINGIFY(INT_MAX))] = {0};

	zassert_mem_equal(strsignal(-1), "Invalid signal", sizeof("Invalid signal"));
	zassert_mem_equal(strsignal(0), "Invalid signal", sizeof("Invalid signal"));
	zassert_mem_equal(strsignal(_NSIG), "Invalid signal", sizeof("Invalid signal"));

	zassert_mem_equal(strsignal(30), "Signal 30", sizeof("Signal 30"));
	snprintf(buf, sizeof(buf), "RT signal %d", SIGRTMIN - SIGRTMIN);
	zassert_mem_equal(strsignal(SIGRTMIN), buf, strlen(buf));
	snprintf(buf, sizeof(buf), "RT signal %d", SIGRTMAX - SIGRTMIN);
	zassert_mem_equal(strsignal(SIGRTMAX), buf, strlen(buf));

#ifdef CONFIG_POSIX_SIGNAL_STRING_DESC
	zassert_mem_equal(strsignal(SIGHUP), "Hangup", sizeof("Hangup"));
	zassert_mem_equal(strsignal(SIGSYS), "Bad system call", sizeof("Bad system call"));
#else
	zassert_mem_equal(strsignal(SIGHUP), "Signal 1", sizeof("Signal 1"));
	zassert_mem_equal(strsignal(SIGSYS), "Signal 31", sizeof("Signal 31"));
#endif
}