/*

 * 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 "libcompat/libcompat.h"

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <math.h>

#include "internal-check.h"

#include "check_error.h"

#include "check_list.h"

#include "check_impl.h"

#include "check_msg.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h>             /* for _POSIX_VERSION */

#endif

#ifndef DEFAULT_TIMEOUT

#define DEFAULT_TIMEOUT 4

#endif

/*

 * When a process exits either normally, with exit(), or

 * by an uncaught signal, The lower 0x377 bits are passed

 * to the parent. Of those, only the lower 8 bits are

 * returned by the WEXITSTATUS() macro.

 */

#define WEXITSTATUS_MASK 0xFF

int check_major_version = CHECK_MAJOR_VERSION;

int check_minor_version = CHECK_MINOR_VERSION;

int check_micro_version = CHECK_MICRO_VERSION;

const char* current_test_name = NULL;

static int non_pass (int val);

static Fixture *fixture_create (SFun fun, int ischecked);

static void tcase_add_fixture (TCase * tc, SFun setup, SFun teardown,

    int ischecked);

static void tr_init (TestResult * tr);

static void suite_free (Suite * s);

static void tcase_free (TCase * tc);

Suite *

suite_create (const char *name)

{

  Suite *s;

  s = (Suite *) emalloc (sizeof (Suite));       /* freed in suite_free */

  if (name == NULL)

    s->name = "";

  else

    s->name = name;

  s->tclst = check_list_create ();

  return s;

}

int

suite_tcase (Suite * s, const char *tcname)

{

  List *l;

  TCase *tc;

  if (s == NULL)

    return 0;

  l = s->tclst;

  for (check_list_front (l); !check_list_at_end (l); check_list_advance (l)) {

    tc = (TCase *) check_list_val (l);

    if (strcmp (tcname, tc->name) == 0)

      return 1;

  }

  return 0;

}

static void

suite_free (Suite * s)

{

  List *l;

  if (s == NULL)

    return;

  l = s->tclst;

  for (check_list_front (l); !check_list_at_end (l); check_list_advance (l)) {

    tcase_free ((TCase *) check_list_val (l));

  }

  check_list_free (s->tclst);

  free (s);

}

TCase *

tcase_create (const char *name)

{

  char *env;

  double timeout_sec = DEFAULT_TIMEOUT;

  TCase *tc = (TCase *) emalloc (sizeof (TCase));       /*freed in tcase_free */

  if (name == NULL)

    tc->name = "";

  else

    tc->name = name;

  env = getenv ("CK_DEFAULT_TIMEOUT");

  if (env != NULL) {

    char *endptr = NULL;

    double tmp = strtod (env, &endptr);

    if (tmp >= 0 && endptr != env && (*endptr) == '\0') {

      timeout_sec = tmp;

    }

  }

  env = getenv ("CK_TIMEOUT_MULTIPLIER");

  if (env != NULL) {

    char *endptr = NULL;

    double tmp = strtod (env, &endptr);

    if (tmp >= 0 && endptr != env && (*endptr) == '\0') {

      timeout_sec = timeout_sec * tmp;

    }

  }

  tc->timeout.tv_sec = (time_t) floor (timeout_sec);

  tc->timeout.tv_nsec =

      (long) ((timeout_sec - floor (timeout_sec)) * (double) NANOS_PER_SECONDS);

  tc->tflst = check_list_create ();

  tc->unch_sflst = check_list_create ();

  tc->ch_sflst = check_list_create ();

  tc->unch_tflst = check_list_create ();

  tc->ch_tflst = check_list_create ();

  tc->tags = check_list_create ();

  return tc;

}

/*

 * Helper function to create a list of tags from

 * a space separated string.

 */

List *

tag_string_to_list (const char *tags_string)

{

  List *list;

  char *tags;

  char *tag;

  list = check_list_create ();

  if (NULL == tags_string) {

    return list;

  }

  tags = strdup (tags_string);

  tag = strtok (tags, " ");

  while (tag) {

    check_list_add_end (list, strdup (tag));

    tag = strtok (NULL, " ");

  }

  free (tags);

  return list;

}

void

tcase_set_tags (TCase * tc, const char *tags_orig)

{

  /* replace any pre-existing list */

  if (tc->tags) {

    check_list_apply (tc->tags, free);

    check_list_free (tc->tags);

  }

  tc->tags = tag_string_to_list (tags_orig);

}

static void

tcase_free (TCase * tc)

{

  check_list_apply (tc->tflst, free);

  check_list_apply (tc->unch_sflst, free);

  check_list_apply (tc->ch_sflst, free);

  check_list_apply (tc->unch_tflst, free);

  check_list_apply (tc->ch_tflst, free);

  check_list_apply (tc->tags, free);

  check_list_free (tc->tflst);

  check_list_free (tc->unch_sflst);

  check_list_free (tc->ch_sflst);

  check_list_free (tc->unch_tflst);

  check_list_free (tc->ch_tflst);

  check_list_free (tc->tags);

  free (tc);

}

unsigned int

tcase_matching_tag (TCase * tc, List * check_for)

{

  if (NULL == check_for) {

    return 0;

  }

  for (check_list_front (check_for); !check_list_at_end (check_for);

      check_list_advance (check_for)) {

    for (check_list_front (tc->tags); !check_list_at_end (tc->tags);

        check_list_advance (tc->tags)) {

      if (0 == strcmp ((const char *) check_list_val (tc->tags),

              (const char *) check_list_val (check_for))) {

        return 1;

      }

    }

  }

  return 0;

}

void

suite_add_tcase (Suite * s, TCase * tc)

{

  if (s == NULL || tc == NULL || check_list_contains (s->tclst, tc)) {

    return;

  }

  check_list_add_end (s->tclst, tc);

}

void

_tcase_add_test (TCase * tc, TFun fn, const char *name, int _signal,

    int allowed_exit_value, int start, int end)

{

  TF *tf;

  if (tc == NULL || fn == NULL || name == NULL)

    return;

  tf = (TF *) emalloc (sizeof (TF));    /* freed in tcase_free */

  tf->fn = fn;

  tf->loop_start = start;

  tf->loop_end = end;

  tf->signal = _signal;         /* 0 means no signal expected */

  tf->allowed_exit_value = (WEXITSTATUS_MASK & allowed_exit_value);     /* 0 is default successful exit */

  tf->name = name;

  check_list_add_end (tc->tflst, tf);

}

static Fixture *

fixture_create (SFun fun, int ischecked)

{

  Fixture *f;

  f = (Fixture *) emalloc (sizeof (Fixture));

  f->fun = fun;

  f->ischecked = ischecked;

  return f;

}

void

tcase_add_unchecked_fixture (TCase * tc, SFun setup, SFun teardown)

{

  tcase_add_fixture (tc, setup, teardown, 0);

}

void

tcase_add_checked_fixture (TCase * tc, SFun setup, SFun teardown)

{

  tcase_add_fixture (tc, setup, teardown, 1);

}

static void

tcase_add_fixture (TCase * tc, SFun setup, SFun teardown, int ischecked)

{

  if (setup) {

    if (ischecked)

      check_list_add_end (tc->ch_sflst, fixture_create (setup, ischecked));

    else

      check_list_add_end (tc->unch_sflst, fixture_create (setup, ischecked));

  }

  /* Add teardowns at front so they are run in reverse order. */

  if (teardown) {

    if (ischecked)

      check_list_add_front (tc->ch_tflst, fixture_create (teardown, ischecked));

    else

      check_list_add_front (tc->unch_tflst,

          fixture_create (teardown, ischecked));

  }

}

void

tcase_set_timeout (TCase * tc, double timeout)

{

#if defined(HAVE_FORK)

  if (timeout >= 0) {

    char *env = getenv ("CK_TIMEOUT_MULTIPLIER");

    if (env != NULL) {

      char *endptr = NULL;

      double tmp = strtod (env, &endptr);

      if (tmp >= 0 && endptr != env && (*endptr) == '\0') {

        timeout = timeout * tmp;

      }

    }

    tc->timeout.tv_sec = (time_t) floor (timeout);

    tc->timeout.tv_nsec =

        (long) ((timeout - floor (timeout)) * (double) NANOS_PER_SECONDS);

  }

#else

  (void) tc;

  (void) timeout;

  eprintf

      ("This version does not support timeouts, as fork is not supported",

      __FILE__, __LINE__);

  /* Ignoring, as Check is not compiled with fork support. */

#endif /* HAVE_FORK */

}

void

tcase_fn_start (const char *fname, const char *file, int line)

{

  send_ctx_info (CK_CTX_TEST);

  send_loc_info (file, line);

  current_test_name = fname;

}

const char *

tcase_name ()

{

  return current_test_name;

}

void

_mark_point (const char *file, int line)

{

  send_loc_info (file, line);

}

void

_ck_assert_failed (const char *file, int line, const char *expr, ...)

{

  const char *msg;

  va_list ap;

  char buf[BUFSIZ];

  const char *to_send;

  send_loc_info (file, line);

  va_start (ap, expr);

  msg = (const char *) va_arg (ap, char *);

  /*

   * If a message was passed, format it with vsnprintf.

   * Otherwise, print the expression as is.

   */

  if (msg != NULL) {

    vsnprintf (buf, BUFSIZ, msg, ap);

    to_send = buf;

  } else {

    to_send = expr;

  }

  va_end (ap);

  send_failure_info (to_send);

  if (cur_fork_status () == CK_FORK) {

#if defined(HAVE_FORK) && HAVE_FORK==1

    _exit (1);

#endif /* HAVE_FORK */

  } else {

    longjmp (error_jmp_buffer, 1);

  }

}

SRunner *

srunner_create (Suite * s)

{

  SRunner *sr = (SRunner *) emalloc (sizeof (SRunner)); /* freed in srunner_free */

  sr->slst = check_list_create ();

  if (s != NULL)

    check_list_add_end (sr->slst, s);

  sr->stats = (TestStats *) emalloc (sizeof (TestStats));       /* freed in srunner_free */

  sr->stats->n_checked = sr->stats->n_failed = sr->stats->n_errors = 0;

  sr->resultlst = check_list_create ();

  sr->log_fname = NULL;

  sr->xml_fname = NULL;

  sr->tap_fname = NULL;

  sr->loglst = NULL;

#if defined(HAVE_FORK)

  sr->fstat = CK_FORK_GETENV;

#else

  /*

   * Overriding the default of running tests in fork mode,

   * as this system does not have fork()

   */

  sr->fstat = CK_NOFORK;

#endif /* HAVE_FORK */

  return sr;

}

void

srunner_add_suite (SRunner * sr, Suite * s)

{

  if (s == NULL)

    return;

  check_list_add_end (sr->slst, s);

}

void

srunner_free (SRunner * sr)

{

  List *l;

  TestResult *tr;

  if (sr == NULL)

    return;

  free (sr->stats);

  l = sr->slst;

  for (check_list_front (l); !check_list_at_end (l); check_list_advance (l)) {

    suite_free ((Suite *) check_list_val (l));

  }

  check_list_free (sr->slst);

  l = sr->resultlst;

  for (check_list_front (l); !check_list_at_end (l); check_list_advance (l)) {

    tr = (TestResult *) check_list_val (l);

    tr_free (tr);

  }

  check_list_free (sr->resultlst);

  free (sr);

}

int

srunner_ntests_failed (SRunner * sr)

{

  return sr->stats->n_failed + sr->stats->n_errors;

}

int

srunner_ntests_run (SRunner * sr)

{

  return sr->stats->n_checked;

}

TestResult **

srunner_failures (SRunner * sr)

{

  int i = 0;

  TestResult **trarray;

  List *rlst;

  trarray =

      (TestResult **) emalloc (sizeof (trarray[0]) *

      srunner_ntests_failed (sr));

  rlst = sr->resultlst;

  for (check_list_front (rlst); !check_list_at_end (rlst);

      check_list_advance (rlst)) {

    TestResult *tr = (TestResult *) check_list_val (rlst);

    if (non_pass (tr->rtype))

      trarray[i++] = tr;

  }

  return trarray;

}

TestResult **

srunner_results (SRunner * sr)

{

  int i = 0;

  TestResult **trarray;

  List *rlst;

  trarray =

      (TestResult **) emalloc (sizeof (trarray[0]) * srunner_ntests_run (sr));

  rlst = sr->resultlst;

  for (check_list_front (rlst); !check_list_at_end (rlst);

      check_list_advance (rlst)) {

    trarray[i++] = (TestResult *) check_list_val (rlst);

  }

  return trarray;

}

static int

non_pass (int val)

{

  return val != CK_PASS;

}

TestResult *

tr_create (void)

{

  TestResult *tr;

  tr = (TestResult *) emalloc (sizeof (TestResult));

  tr_init (tr);

  return tr;

}

static void

tr_init (TestResult * tr)

{

  tr->ctx = CK_CTX_INVALID;

  tr->line = -1;

  tr->rtype = CK_TEST_RESULT_INVALID;

  tr->msg = NULL;

  tr->file = NULL;

  tr->tcname = NULL;

  tr->tname = NULL;

  tr->duration = -1;

}

void

tr_free (TestResult * tr)

{

  free (tr->file);

  free (tr->msg);

  free (tr);

}

const char *

tr_msg (TestResult * tr)

{

  return tr->msg;

}

int

tr_lno (TestResult * tr)

{

  return tr->line;

}

const char *

tr_lfile (TestResult * tr)

{

  return tr->file;

}

int

tr_rtype (TestResult * tr)

{

  return tr->rtype;

}

enum ck_result_ctx

tr_ctx (TestResult * tr)

{

  return tr->ctx;

}

const char *

tr_tcname (TestResult * tr)

{

  return tr->tcname;

}

static enum fork_status _fstat = CK_FORK;

void

set_fork_status (enum fork_status fstat)

{

  if (fstat == CK_FORK || fstat == CK_NOFORK || fstat == CK_FORK_GETENV)

    _fstat = fstat;

  else

    eprintf ("Bad status in set_fork_status", __FILE__, __LINE__);

}

enum fork_status

cur_fork_status (void)

{

  return _fstat;

}

/**

 * Not all systems support the same clockid_t's. This call checks

 * if the CLOCK_MONOTONIC clockid_t is valid. If so, that is returned,

 * otherwise, CLOCK_REALTIME is returned.

 *

 * The clockid_t that was found to work on the first call is

 * cached for subsequent calls.

 */

clockid_t

check_get_clockid ()

{

  static clockid_t clockid = -1;

  if (clockid == -1) {

/*

 * Only check if we have librt available. Otherwise, the clockid

 * will be ignored anyway, as the clock_gettime() and

 * timer_create() functions will be re-implemented in libcompat.

 * Worse, if librt and alarm() are unavailable, this check

 * will result in an assert(0).

 */

#if defined(HAVE_POSIX_TIMERS) && defined(HAVE_MONOTONIC_CLOCK)

    timer_t timerid;

    if (timer_create (CLOCK_MONOTONIC, NULL, &timerid) == 0) {

      timer_delete (timerid);

      clockid = CLOCK_MONOTONIC;

    } else {

      clockid = CLOCK_REALTIME;

    }

#else

    clockid = CLOCK_MONOTONIC;

#endif

  }

  return clockid;

}