/*      $OpenBSD: t_wait_noproc.c,v 1.4 2022/12/19 22:44:54 guenther Exp $      */
/* $NetBSD: t_wait_noproc.c,v 1.5 2016/11/09 17:50:19 kamil Exp $ */

/*-
 * Copyright (c) 2016 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "macros.h"

#include <sys/wait.h>
#include <sys/resource.h>

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

#include "atf-c.h"

#ifndef TWAIT_OPTION
#define TWAIT_OPTION 0
#endif

#if TWAIT_OPTION == 0
ATF_TC(wait);
ATF_TC_HEAD(wait, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that wait(2) returns ECHILD for no child");
}

ATF_TC_BODY(wait, tc)
{
        ATF_REQUIRE_ERRNO(ECHILD, wait(NULL) == -1);
}
#endif

ATF_TC(waitpid);
ATF_TC_HEAD(waitpid, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that waitpid(2) returns ECHILD for WAIT_ANY and option %s",
            ___STRING(TWAIT_OPTION));
}

ATF_TC_BODY(waitpid, tc)
{
        ATF_REQUIRE_ERRNO(ECHILD, waitpid(WAIT_ANY, NULL, TWAIT_OPTION) == -1);
}

ATF_TC(waitid);
ATF_TC_HEAD(waitid, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that waitid(2) returns ECHILD for P_ALL and option %s",
            ___STRING(TWAIT_OPTION));
}

ATF_TC_BODY(waitid, tc)
{
        ATF_REQUIRE_ERRNO(ECHILD,
            waitid(P_ALL, 0, NULL,
                WEXITED | TWAIT_OPTION) == -1);
}

ATF_TC(wait3);
ATF_TC_HEAD(wait3, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that wait3(2) returns ECHILD for no child");
}

ATF_TC_BODY(wait3, tc)
{
        ATF_REQUIRE_ERRNO(ECHILD, wait3(NULL, TWAIT_OPTION, NULL) == -1);
}

ATF_TC(wait4);
ATF_TC_HEAD(wait4, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that wait4(2) returns ECHILD for WAIT_ANY and option %s",
            ___STRING(TWAIT_OPTION));
}

ATF_TC_BODY(wait4, tc)
{
        ATF_REQUIRE_ERRNO(ECHILD,
            wait4(WAIT_ANY, NULL, TWAIT_OPTION, NULL) == -1);
}

#ifndef __OpenBSD__
 * Adjusted for OpenBSD, not available
 * ATF_TC(wait6);
 * ATF_TC_HEAD(wait6, tc)
 * {
 *      atf_tc_set_md_var(tc, "descr",
 *          "Test that wait6(2) returns ECHILD for P_ALL and option %s",
 *          ___STRING(TWAIT_OPTION));
 * }
 * 
 * ATF_TC_BODY(wait6, tc)
 * {
 *      ATF_REQUIRE_ERRNO(ECHILD,
 *          wait6(P_ALL, 0, NULL,
 *              WTRAPPED | WEXITED | TWAIT_OPTION, NULL, NULL) == -1);
 * }
 */
#endif

/*
 * Generator of valid combinations of options
 * Usage: i = 0; while ((o = get_options_wait6(i++)) != -1) {}
 */
static int
get_options6(size_t pos)
{
        int rv = 0;
        size_t n;
        /*
         * waitid(2) must specify at least one of WEXITED, WUNTRACED,
         * WSTOPPED, WTRAPPED or WCONTINUED. Single option WNOWAIT
         * isn't valid.
         */
        const int matrix[] = {
                WNOWAIT,        // First in order to blacklist it easily
                WEXITED,
#ifndef __OpenBSD__
                WUNTRACED,
#endif
                WSTOPPED,       // SUS compatibility, equal to WUNTRACED
                WTRAPPED,
                WCONTINUED
        };

        const size_t M = (1 << __arraycount(matrix)) - 1;
        /* Skip empty and sole WNOWAIT option */
        pos+=2;

        if (pos > M)
                return -1;

        for (n = 0; n < __arraycount(matrix); n++) {
                if (pos & __BIT(n))
                        rv |= matrix[n];
        }

        return rv;
}

/*
 * Generator of valid combinations of options
 * Usage: i = 0; while ((o = get_options_wait4(i++)) != -1) {}
 */
static int
get_options4(size_t pos)
{
        int rv = 0;
        size_t n;

        const int special[] = {
                0,
#ifndef __OpenBSD__
                WALLSIG,
                WALTSIG,
                __WALL,         // Linux compatibility, equal to WALLSIG
                __WCLONE        // Linux compatibility, equal to WALTSIG
#endif
        };

        const int matrix[] = {
#ifndef __OpenBSD__
                WNOWAIT,
                WEXITED,
#endif
                WUNTRACED,
#ifndef __OpenBSD__
                WSTOPPED,       // SUS compatibility, equal to WUNTRACED
                WTRAPPED,
#endif
                WCONTINUED
        };

        const size_t M = (1 << __arraycount(special)) - 1;

        if (pos < __arraycount(special))
                return special[pos];

        pos -= __arraycount(special);

        ++pos; /* Don't start with empty mask */

        if (pos > M)
                return -1;

        for (n = 0; n < __arraycount(special); n++) {
                if (pos & __BIT(n))
                        rv |= matrix[n];
        }

        return rv;
}

ATF_TC(waitpid_options);
ATF_TC_HEAD(waitpid_options, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that waitpid(2) returns ECHILD for WAIT_ANY and valid "
            "combination of options with%s WNOHANG",
            TWAIT_OPTION == 0 ? "out" : "");
}

ATF_TC_BODY(waitpid_options, tc)
{
        size_t i = 0;
        int o;

        while((o = get_options4(i++)) != -1) {
                printf("Testing waitpid(2) with options %x\n", o);

                ATF_REQUIRE_ERRNO(ECHILD,
                    waitpid(WAIT_ANY, NULL, o | TWAIT_OPTION) == -1);
        }
}

ATF_TC(waitid_options);
ATF_TC_HEAD(waitid_options, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that waitid(2) returns ECHILD for P_ALL and valid "
            "combination of options with%s WNOHANG",
            TWAIT_OPTION == 0 ? "out" : "");
}

ATF_TC_BODY(waitid_options, tc)
{
        size_t i = 0;
        int o;

        while((o = get_options6(i++)) != -1) {
                printf("Testing waitid(2) with options %x\n", o);

                ATF_REQUIRE_ERRNO(ECHILD,
                    waitid(P_ALL, 0, NULL, o | TWAIT_OPTION) == -1);
        }
}

ATF_TC(wait3_options);
ATF_TC_HEAD(wait3_options, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that wait3(2) returns ECHILD for no child");
}

ATF_TC_BODY(wait3_options, tc)
{
        size_t i = 0;
        int o;

        while((o = get_options4(i++)) != -1) {
                printf("Testing wait3(2) with options %x\n", o);

                ATF_REQUIRE_ERRNO(ECHILD,
                    wait3(NULL, o | TWAIT_OPTION, NULL) == -1);
        }
}

ATF_TC(wait4_options);
ATF_TC_HEAD(wait4_options, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that wait4(2) returns ECHILD for WAIT_ANY and option %s",
            ___STRING(TWAIT_OPTION));
}

ATF_TC_BODY(wait4_options, tc)
{
        size_t i = 0;
        int o;

        while((o = get_options4(i++)) != -1) {
                printf("Testing wait4(2) with options %x\n", o);

                ATF_REQUIRE_ERRNO(ECHILD,
                    wait4(WAIT_ANY, NULL, o | TWAIT_OPTION, NULL) == -1);
        }
}

#ifndef __OpenBSD__
ATF_TC(wait6_options);
ATF_TC_HEAD(wait6_options, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test that wait6(2) returns ECHILD for P_ALL and option %s",
            ___STRING(TWAIT_OPTION));
}

ATF_TC_BODY(wait6_options, tc)
{
        size_t i = 0;
        int o;

        while((o = get_options6(i++)) != -1) {
                printf("Testing wait6(2) with options %x\n", o);

                ATF_REQUIRE_ERRNO(ECHILD,
                    wait6(P_ALL, 0, NULL, o | TWAIT_OPTION, NULL, NULL) == -1);
        }
}
#endif

ATF_TP_ADD_TCS(tp)
{

#if TWAIT_OPTION == 0
        ATF_TP_ADD_TC(tp, wait);
#endif
        ATF_TP_ADD_TC(tp, waitpid);
        ATF_TP_ADD_TC(tp, waitid);
        ATF_TP_ADD_TC(tp, wait3);
        ATF_TP_ADD_TC(tp, wait4);
#ifndef __OpenBSD__
        ATF_TP_ADD_TC(tp, wait6);
#endif

        ATF_TP_ADD_TC(tp, waitpid_options);
        ATF_TP_ADD_TC(tp, waitid_options);
        ATF_TP_ADD_TC(tp, wait3_options);
        ATF_TP_ADD_TC(tp, wait4_options);
#ifndef __OpenBSD__
        ATF_TP_ADD_TC(tp, wait6_options);
#endif

        return atf_no_error();
}