/*
 * Check: a unit test framework for C
 * Copyright (C) 2001, 2002 Arien Malec
 *
 * 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 Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 */

#include "../lib/libcompat.h"

#include <sys/types.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <signal.h>
#include <setjmp.h>

#include "check.h"
#include "check_error.h"
#include "check_list.h"
#include "check_impl.h"
#include "check_msg.h"
#include "check_log.h"

enum rinfo
{
    CK_R_SIG,
    CK_R_PASS,
    CK_R_EXIT,
    CK_R_FAIL_TEST,
    CK_R_FAIL_FIXTURE
};

enum tf_type
{
    CK_FORK_TEST,
    CK_NOFORK_TEST,
    CK_NOFORK_FIXTURE
};


/* all functions are defined in the same order they are declared.
   functions that depend on forking are gathered all together.
   non-static functions are at the end of the file. */
static void srunner_run_init(SRunner * sr, enum print_output print_mode);
static void srunner_run_end(SRunner * sr, enum print_output print_mode);
static void srunner_iterate_suites(SRunner * sr,
                                   const char *sname, const char *tcname,
				   const char *include_tags,
				   const char *exclude_tags,
                                   enum print_output print_mode);
static void srunner_iterate_tcase_tfuns(SRunner * sr, TCase * tc);
static void srunner_add_failure(SRunner * sr, TestResult * tf);
static TestResult * srunner_run_setup(List * func_list,
    enum fork_status fork_usage, const char * test_name,
    const char * setup_name);
static int srunner_run_unchecked_setup(SRunner * sr, TCase * tc);
static TestResult *tcase_run_checked_setup(SRunner * sr, TCase * tc);
static void srunner_run_teardown(List * fixture_list, enum fork_status fork_usage);
static void srunner_run_unchecked_teardown(SRunner * sr, TCase * tc);
static void tcase_run_checked_teardown(TCase * tc);
static void srunner_run_tcase(SRunner * sr, TCase * tc);
static TestResult *tcase_run_tfun_nofork(SRunner * sr, TCase * tc, TF * tf,
                                         int i);
static TestResult *receive_result_info_nofork(const char *tcname,
                                              const char *tname, int iter,
                                              int duration);
static void set_nofork_info(TestResult * tr);
static char *pass_msg(void);

#if defined(HAVE_FORK) && HAVE_FORK==1
static TestResult *tcase_run_tfun_fork(SRunner * sr, TCase * tc, TF * tf,
                                       int i);
static TestResult *receive_result_info_fork(const char *tcname,
                                            const char *tname, int iter,
                                            int status, int expected_signal,
                                            signed char allowed_exit_value);
static void set_fork_info(TestResult * tr, int status, int expected_signal,
                          signed char allowed_exit_value);
static char *signal_msg(int sig);
static char *signal_error_msg(int signal_received, int signal_expected);
static char *exit_msg(int exitstatus);
static int waserror(int status, int expected_signal);

static int alarm_received;
static pid_t group_pid;
static struct sigaction sigint_old_action;
static struct sigaction sigterm_old_action;

static void CK_ATTRIBUTE_UNUSED sig_handler(int sig_nr)
{
    switch (sig_nr)
    {
        case SIGALRM:
            alarm_received = 1;
            killpg(group_pid, SIGKILL);
            break;
        case SIGTERM:
        case SIGINT:
        {
            pid_t own_group_pid;
            int child_sig = SIGTERM;

            if (sig_nr == SIGINT)
            {
                child_sig = SIGKILL;
                sigaction(SIGINT, &sigint_old_action, NULL);
            }
            else
            {
                sigaction(SIGTERM, &sigterm_old_action, NULL);
            }

            killpg(group_pid, child_sig);

            /* POSIX says that calling killpg(0)
             * does not necessarily mean to call it on the callers
             * group pid! */
            own_group_pid = getpgrp();
            killpg(own_group_pid, sig_nr);
            break;
        }
        default:
            eprintf("Unhandled signal: %d", __FILE__, __LINE__, sig_nr);
            break;
    }
}
#endif /* HAVE_FORK */

#define MSG_LEN 100

static void srunner_run_init(SRunner * sr, enum print_output print_mode)
{
    set_fork_status(srunner_fork_status(sr));
    setup_messaging();
    srunner_init_logging(sr, print_mode);
    log_srunner_start(sr);
}

static void srunner_run_end(SRunner * sr,
                            enum print_output CK_ATTRIBUTE_UNUSED print_mode)
{
    log_srunner_end(sr);
    srunner_end_logging(sr);
    teardown_messaging();
    set_fork_status(CK_FORK);
}

static void srunner_iterate_suites(SRunner * sr,
                                   const char *sname, const char *tcname,
				   const char *include_tags,
				   const char *exclude_tags,
                                   enum print_output CK_ATTRIBUTE_UNUSED
                                   print_mode)
{
    List *include_tag_lst;
    List *exclude_tag_lst;
    List *slst;
    List *tcl;
    TCase *tc;

    slst = sr->slst;

    include_tag_lst = tag_string_to_list(include_tags);
    exclude_tag_lst = tag_string_to_list(exclude_tags);

    for(check_list_front(slst); !check_list_at_end(slst);
        check_list_advance(slst))
    {
        Suite *s = (Suite *)check_list_val(slst);

        if(((sname != NULL) && (strcmp(sname, s->name) != 0))
           || ((tcname != NULL) && (!suite_tcase(s, tcname))))
            continue;

        log_suite_start(sr, s);

        tcl = s->tclst;

        for(check_list_front(tcl); !check_list_at_end(tcl);
            check_list_advance(tcl))
        {
            tc = (TCase *)check_list_val(tcl);

            if((tcname != NULL) && (strcmp(tcname, tc->name) != 0))
            {
                continue;
            }
	    if (include_tags != NULL)
	    {
		if (!tcase_matching_tag(tc, include_tag_lst))
		{
		    continue;
		}
	    }
	    if (exclude_tags != NULL)
	    {
		if (tcase_matching_tag(tc, exclude_tag_lst))
		{
		    continue;
		}
	    }

            srunner_run_tcase(sr, tc);
        }

        log_suite_end(sr, s);
    }

    check_list_apply(include_tag_lst, free);
    check_list_apply(exclude_tag_lst, free);
    check_list_free(include_tag_lst);
    check_list_free(exclude_tag_lst);
}

static void srunner_iterate_tcase_tfuns(SRunner * sr, TCase * tc)
{
    List *tfl;
    TF *tfun;
    TestResult *tr = NULL;

    tfl = tc->tflst;

    for(check_list_front(tfl); !check_list_at_end(tfl);
        check_list_advance(tfl))
    {
        int i;

        tfun = (TF *)check_list_val(tfl);

        for(i = tfun->loop_start; i < tfun->loop_end; i++)
        {
            log_test_start(sr, tc, tfun);
            switch (srunner_fork_status(sr))
            {
                case CK_FORK:
#if defined(HAVE_FORK) && HAVE_FORK==1
                    tr = tcase_run_tfun_fork(sr, tc, tfun, i);
#else /* HAVE_FORK */
                    eprintf("This version does not support fork", __FILE__,
                            __LINE__);
#endif /* HAVE_FORK */
                    break;
                case CK_NOFORK:
                    tr = tcase_run_tfun_nofork(sr, tc, tfun, i);
                    break;
                case CK_FORK_GETENV:
                default:
                    eprintf("Bad fork status in SRunner", __FILE__, __LINE__);
            }

            if(NULL != tr)
            {
                srunner_add_failure(sr, tr);
                log_test_end(sr, tr);
            }
        }
    }
}

static void srunner_add_failure(SRunner * sr, TestResult * tr)
{
    check_list_add_end(sr->resultlst, tr);
    sr->stats->n_checked++;     /* count checks during setup, test, and teardown */
    if(tr->rtype == CK_FAILURE)
        sr->stats->n_failed++;
    else if(tr->rtype == CK_ERROR)
        sr->stats->n_errors++;

}

static TestResult * srunner_run_setup(List * fixture_list, enum fork_status fork_usage,
    const char * test_name, const char * setup_name)
{
    TestResult *tr = NULL;
    Fixture *setup_fixture;

    if(fork_usage == CK_FORK)
    {
        send_ctx_info(CK_CTX_SETUP);
    }

    for(check_list_front(fixture_list); !check_list_at_end(fixture_list);
        check_list_advance(fixture_list))
    {
        setup_fixture = (Fixture *)check_list_val(fixture_list);

        if(fork_usage == CK_NOFORK)
        {
            send_ctx_info(CK_CTX_SETUP);

            if(0 == setjmp(error_jmp_buffer))
            {
                setup_fixture->fun();
            }

            /* Stop the setup and return the failure in nofork mode. */
            tr = receive_result_info_nofork(test_name, setup_name, 0, -1);
            if(tr->rtype != CK_PASS)
            {
                break;
            }

            free(tr->file);
            free(tr->msg);
            free(tr);
            tr = NULL;
        }
        else
        {
            setup_fixture->fun();
        }
    }

    return tr;
}

static int srunner_run_unchecked_setup(SRunner * sr, TCase * tc)
{
    TestResult *tr = NULL;
    int rval = 1;

    set_fork_status(CK_NOFORK);
    tr = srunner_run_setup(tc->unch_sflst, CK_NOFORK, tc->name, "unchecked_setup");
    set_fork_status(srunner_fork_status(sr));

    if(tr != NULL && tr->rtype != CK_PASS)
    {
        srunner_add_failure(sr, tr);
        rval = 0;
    }

    return rval;
}

static TestResult *tcase_run_checked_setup(SRunner * sr, TCase * tc)
{
    TestResult *tr = srunner_run_setup(tc->ch_sflst, srunner_fork_status(sr),
        tc->name, "checked_setup");

    return tr;
}

static void srunner_run_teardown(List * fixture_list, enum fork_status fork_usage)
{
    Fixture * fixture;

    for(check_list_front(fixture_list); !check_list_at_end(fixture_list);
        check_list_advance(fixture_list))
    {
        fixture = (Fixture *)check_list_val(fixture_list);
        send_ctx_info(CK_CTX_TEARDOWN);

        if(fork_usage == CK_NOFORK)
        {
            if(0 == setjmp(error_jmp_buffer))
            {
                fixture->fun();
            }
            else
            {
                /* Abort the remaining teardowns */
                break;
            }
        }
        else
        {
            fixture->fun();
        }
    }
}

static void srunner_run_unchecked_teardown(SRunner * sr, TCase * tc)
{
    srunner_run_teardown(tc->unch_tflst, srunner_fork_status(sr));
}

static void tcase_run_checked_teardown(TCase * tc)
{
    srunner_run_teardown(tc->ch_tflst, CK_NOFORK);
}

static void srunner_run_tcase(SRunner * sr, TCase * tc)
{
    if(srunner_run_unchecked_setup(sr, tc))
    {
        srunner_iterate_tcase_tfuns(sr, tc);
        srunner_run_unchecked_teardown(sr, tc);
    }
}

static TestResult *tcase_run_tfun_nofork(SRunner * sr, TCase * tc, TF * tfun,
                                         int i)
{
    TestResult *tr;
    struct timespec ts_start = {0, 0}, ts_end = {0, 0};

    tr = tcase_run_checked_setup(sr, tc);
    if(tr == NULL)
    {
        clock_gettime(check_get_clockid(), &ts_start);
        if(0 == setjmp(error_jmp_buffer))
        {
            tfun->fn(i);
        }
        clock_gettime(check_get_clockid(), &ts_end);
        tcase_run_checked_teardown(tc);
        return receive_result_info_nofork(tc->name, tfun->name, i,
                                          DIFF_IN_USEC(ts_start, ts_end));
    }

    return tr;
}

static TestResult *receive_result_info_nofork(const char *tcname,
                                              const char *tname,
                                              int iter, int duration)
{
    TestResult *tr;

    tr = receive_test_result(0);
    if(tr == NULL)
    {
        eprintf("Failed to receive test result", __FILE__, __LINE__);
    }
    else
    {
        tr->tcname = tcname;
        tr->tname = tname;
        tr->iter = iter;
        tr->duration = duration;
        set_nofork_info(tr);
    }

    return tr;
}

static void set_nofork_info(TestResult * tr)
{
    if(tr->msg == NULL)
    {
        tr->rtype = CK_PASS;
        tr->msg = pass_msg();
    }
    else
    {
        tr->rtype = CK_FAILURE;
    }
}

static char *pass_msg(void)
{
    return strdup("Passed");
}

#if defined(HAVE_FORK) && HAVE_FORK==1
static TestResult *tcase_run_tfun_fork(SRunner * sr, TCase * tc, TF * tfun,
                                       int i)
{
    pid_t pid_w;
    pid_t pid;
    int status = 0;
    struct timespec ts_start = { 0, 0 }, ts_end ={ 0, 0 };

    timer_t timerid;
    struct itimerspec timer_spec;
    TestResult *tr;


    pid = fork();
    if(pid == -1)
        eprintf("Error in call to fork:", __FILE__, __LINE__ - 2);
    if(pid == 0)
    {
        setpgid(0, 0);
        group_pid = getpgrp();
        tr = tcase_run_checked_setup(sr, tc);
        free(tr);
        clock_gettime(check_get_clockid(), &ts_start);
        tfun->fn(i);
        clock_gettime(check_get_clockid(), &ts_end);
        tcase_run_checked_teardown(tc);
        send_duration_info(DIFF_IN_USEC(ts_start, ts_end));
        exit(EXIT_SUCCESS);
    }
    else
    {
        group_pid = pid;
    }

    alarm_received = 0;

    if(timer_create(check_get_clockid(),
                    NULL /* fire SIGALRM if timer expires */,
                    &timerid) == 0)
    {
        /* Set the timer to fire once */
        timer_spec.it_value = tc->timeout;
        timer_spec.it_interval.tv_sec = 0;
        timer_spec.it_interval.tv_nsec = 0;
        if(timer_settime(timerid, 0, &timer_spec, NULL) == 0)
        {
            do
            {
                pid_w = waitpid(pid, &status, 0);
            }
            while(pid_w == -1);
        }
        else
        {
            eprintf("Error in call to timer_settime:", __FILE__, __LINE__);
        }

        /* If the timer has not fired, disable it */
        timer_delete(timerid);
    }
    else
    {
        eprintf("Error in call to timer_create:", __FILE__, __LINE__);
    }

    killpg(pid, SIGKILL);       /* Kill remaining processes. */

    return receive_result_info_fork(tc->name, tfun->name, i, status,
                                    tfun->signal, tfun->allowed_exit_value);
}

static TestResult *receive_result_info_fork(const char *tcname,
                                            const char *tname,
                                            int iter,
                                            int status, int expected_signal,
                                            signed char allowed_exit_value)
{
    TestResult *tr;

    tr = receive_test_result(waserror(status, expected_signal));
    if(tr == NULL)
    {
        eprintf("Failed to receive test result", __FILE__, __LINE__);
    }
    else
    {
        tr->tcname = tcname;
        tr->tname = tname;
        tr->iter = iter;
        set_fork_info(tr, status, expected_signal, allowed_exit_value);
    }

    return tr;
}

static void set_fork_info(TestResult * tr, int status, int signal_expected,
                          signed char allowed_exit_value)
{
    int was_sig = WIFSIGNALED(status);
    int was_exit = WIFEXITED(status);
    signed char exit_status = WEXITSTATUS(status);
    int signal_received = WTERMSIG(status);

    if(was_sig)
    {
        if(signal_expected == signal_received)
        {
            if(alarm_received)
            {
                /* Got alarm instead of signal */
                tr->rtype = CK_ERROR;
                if(tr->msg != NULL)
                {
                    free(tr->msg);
                }
                tr->msg = signal_error_msg(signal_received, signal_expected);
            }
            else
            {
                tr->rtype = CK_PASS;
                if(tr->msg != NULL)
                {
                    free(tr->msg);
                }
                tr->msg = pass_msg();
            }
        }
        else if(signal_expected != 0)
        {
            /* signal received, but not the expected one */
            tr->rtype = CK_ERROR;
            if(tr->msg != NULL)
            {
                free(tr->msg);
            }
            tr->msg = signal_error_msg(signal_received, signal_expected);
        }
        else
        {
            /* signal received and none expected */
            tr->rtype = CK_ERROR;
            if(tr->msg != NULL)
            {
                free(tr->msg);
            }
            tr->msg = signal_msg(signal_received);
        }
    }
    else if(signal_expected == 0)
    {
        if(was_exit && exit_status == allowed_exit_value)
        {
            tr->rtype = CK_PASS;
            if(tr->msg != NULL)
            {
                free(tr->msg);
            }
            tr->msg = pass_msg();
        }
        else if(was_exit && exit_status != allowed_exit_value)
        {
            if(tr->msg == NULL)
            {                   /* early exit */
                tr->rtype = CK_ERROR;
                tr->msg = exit_msg(exit_status);
            }
            else
            {
                tr->rtype = CK_FAILURE;
            }
        }
    }
    else
    {                           /* a signal was expected and none raised */
        if(was_exit)
        {
            if(tr->msg != NULL)
            {
                free(tr->msg);
            }
            tr->msg = exit_msg(exit_status);
            if(exit_status == allowed_exit_value)
            {
                tr->rtype = CK_FAILURE; /* normal exit status */
            }
            else
            {
                tr->rtype = CK_FAILURE; /* early exit */
            }
        }
    }
}

static char *signal_msg(int signal)
{
    char *msg = (char *)emalloc(MSG_LEN);       /* free'd by caller */

    if(alarm_received)
    {
        snprintf(msg, MSG_LEN, "Test timeout expired");
    }
    else
    {
        snprintf(msg, MSG_LEN, "Received signal %d (%s)",
                 signal, strsignal(signal));
    }
    return msg;
}

static char *signal_error_msg(int signal_received, int signal_expected)
{
    char *sig_r_str;
    char *sig_e_str;
    char *msg = (char *)emalloc(MSG_LEN);       /* free'd by caller */

    sig_r_str = strdup(strsignal(signal_received));
    sig_e_str = strdup(strsignal(signal_expected));
    if(alarm_received)
    {
        snprintf(msg, MSG_LEN,
                 "Test timeout expired, expected signal %d (%s)",
                 signal_expected, sig_e_str);
    }
    else
    {
        snprintf(msg, MSG_LEN, "Received signal %d (%s), expected %d (%s)",
                 signal_received, sig_r_str, signal_expected, sig_e_str);
    }
    free(sig_r_str);
    free(sig_e_str);
    return msg;
}

static char *exit_msg(int exitval)
{
    char *msg = (char *)emalloc(MSG_LEN);       /* free'd by caller */

    snprintf(msg, MSG_LEN, "Early exit with return value %d", exitval);
    return msg;
}

static int waserror(int status, int signal_expected)
{
    int was_sig = WIFSIGNALED(status);
    int was_exit = WIFEXITED(status);
    int exit_status = WEXITSTATUS(status);
    int signal_received = WTERMSIG(status);

    return ((was_sig && (signal_received != signal_expected)) ||
            (was_exit && exit_status != 0));
}
#endif /* HAVE_FORK */

enum fork_status srunner_fork_status(SRunner * sr)
{
    if(sr->fstat == CK_FORK_GETENV)
    {
        char *env = getenv("CK_FORK");

        if(env == NULL)
#if defined(HAVE_FORK) && HAVE_FORK==1
            return CK_FORK;
#else
            return CK_NOFORK;
#endif
        if(strcmp(env, "no") == 0)
            return CK_NOFORK;
#if defined(HAVE_FORK) && HAVE_FORK==1
        return CK_FORK;
#else /* HAVE_FORK */
        /* Ignoring, as Check is not compiled with fork support. */
        return CK_NOFORK;
#endif /* HAVE_FORK */
    }
    return sr->fstat;
}

void srunner_set_fork_status(SRunner * sr, enum fork_status fstat)
{
#if !defined(HAVE_FORK) || HAVE_FORK==0
    /* If fork() is unavailable, do not allow a fork mode to be set */
    if(fstat != CK_NOFORK)
    {
        /* Overriding, as Check is not compiled with fork support. */
        fstat = CK_NOFORK;
    }
#endif /* ! HAVE_FORK */
    sr->fstat = fstat;
}

void srunner_run_all(SRunner * sr, enum print_output print_mode)
{
    srunner_run(sr, NULL,       /* All test suites.  */
                NULL,           /* All test cases.   */
                print_mode);
}

void srunner_run_tagged(SRunner * sr, const char *sname, const char *tcname,
			const char *include_tags, const char *exclude_tags,
			enum print_output print_mode)
{
#if defined(HAVE_SIGACTION) && defined(HAVE_FORK)
    static struct sigaction sigalarm_old_action;
    static struct sigaction sigalarm_new_action;
    static struct sigaction sigint_new_action;
    static struct sigaction sigterm_new_action;
#endif /* HAVE_SIGACTION && HAVE_FORK */

    /*  Get the selected test suite and test case from the
       environment.  */
    if(!tcname)
        tcname = getenv("CK_RUN_CASE");
    if(!sname)
	sname = getenv("CK_RUN_SUITE");
    if(!include_tags)
	include_tags = getenv("CK_INCLUDE_TAGS");
    if(!exclude_tags)
	exclude_tags = getenv("CK_EXCLUDE_TAGS");

    if(sr == NULL)
        return;
    if(print_mode >= CK_LAST)
    {
        eprintf("Bad print_mode argument to srunner_run_all: %d",
                __FILE__, __LINE__, print_mode);
    }
#if defined(HAVE_SIGACTION) && defined(HAVE_FORK)
    memset(&sigalarm_new_action, 0, sizeof(sigalarm_new_action));
    sigalarm_new_action.sa_handler = sig_handler;
    sigaction(SIGALRM, &sigalarm_new_action, &sigalarm_old_action);

    memset(&sigint_new_action, 0, sizeof(sigint_new_action));
    sigint_new_action.sa_handler = sig_handler;
    sigaction(SIGINT, &sigint_new_action, &sigint_old_action);

    memset(&sigterm_new_action, 0, sizeof(sigterm_new_action));
    sigterm_new_action.sa_handler = sig_handler;
    sigaction(SIGTERM, &sigterm_new_action, &sigterm_old_action);
#endif /* HAVE_SIGACTION && HAVE_FORK */
    srunner_run_init(sr, print_mode);
    srunner_iterate_suites(sr, sname, tcname, include_tags, exclude_tags,
			   print_mode);
    srunner_run_end(sr, print_mode);
#if defined(HAVE_SIGACTION) && defined(HAVE_FORK)
    sigaction(SIGALRM, &sigalarm_old_action, NULL);
    sigaction(SIGINT, &sigint_old_action, NULL);
    sigaction(SIGTERM, &sigterm_old_action, NULL);
#endif /* HAVE_SIGACTION && HAVE_FORK */
}

void srunner_run(SRunner * sr, const char *sname, const char *tcname,
                 enum print_output print_mode)
{
    srunner_run_tagged(sr, sname, tcname, NULL, NULL, print_mode);
}

pid_t check_fork(void)
{
#if defined(HAVE_FORK) && HAVE_FORK==1
    pid_t pid = fork();

    /* Set the process to a process group to be able to kill it easily. */
    if(pid >= 0)
    {
        setpgid(pid, group_pid);
    }
    return pid;
#else /* HAVE_FORK */
    /* Ignoring, as Check is not compiled with fork support. */
    return -1;
#endif /* HAVE_FORK */
}

void check_waitpid_and_exit(pid_t pid CK_ATTRIBUTE_UNUSED)
{
#if defined(HAVE_FORK) && HAVE_FORK==1
    pid_t pid_w;
    int status;

    if(pid > 0)
    {
        do
        {
            pid_w = waitpid(pid, &status, 0);
        }
        while(pid_w == -1);
        if(waserror(status, 0))
        {
            exit(EXIT_FAILURE);
        }
    }
    exit(EXIT_SUCCESS);
#else /* HAVE_FORK */
    /* Ignoring, as Check is not compiled with fork support. */
    exit(EXIT_FAILURE);
#endif /* HAVE_FORK */
}
