/* GLib testing framework runner

 * Copyright (C) 2007 Sven Herzberg

 * Copyright (C) 2007 Tim Janik

 *

 * 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 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., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include <glib.h>

#include <gstdio.h>

#include <string.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/wait.h>

#include <errno.h>

#include <signal.h>

/* the read buffer size in bytes */

#define READ_BUFFER_SIZE 4096

/* --- prototypes --- */

static int      main_selftest   (int    argc,

                                 char **argv);

static void     parse_args      (gint           *argc_p,

                                 gchar        ***argv_p);

/* --- variables --- */

static GIOChannel  *ioc_report = NULL;

static gboolean     gtester_quiet = FALSE;

static gboolean     gtester_verbose = FALSE;

static gboolean     gtester_list_tests = FALSE;

static gboolean     gtester_selftest = FALSE;

static gboolean     subtest_running = FALSE;

static gint         subtest_exitstatus = 0;

static gboolean     subtest_io_pending = FALSE;

static gboolean     subtest_quiet = TRUE;

static gboolean     subtest_verbose = FALSE;

static gboolean     subtest_mode_fatal = TRUE;

static gboolean     subtest_mode_perf = FALSE;

static gboolean     subtest_mode_quick = TRUE;

static const gchar *subtest_seedstr = NULL;

static gchar       *subtest_last_seed = NULL;

static GSList      *subtest_paths = NULL;

static GSList      *subtest_args = NULL;

static gboolean     testcase_open = FALSE;

static guint        testcase_count = 0;

static guint        testcase_fail_count = 0;

static const gchar *output_filename = NULL;

static guint        log_indent = 0;

static gint         log_fd = -1;

/* --- functions --- */

static const char*

sindent (guint n)

{

  static const char spaces[] = "                                                                                                    ";

  int l = sizeof (spaces) - 1;

  n = MIN (n, l);

  return spaces + l - n;

}

static void G_GNUC_PRINTF (1, 2)

test_log_printfe (const char *format,

                  ...)

{

  char *result;

  int r;

  va_list args;

  va_start (args, format);

  result = g_markup_vprintf_escaped (format, args);

  va_end (args);

  do

    r = write (log_fd, result, strlen (result));

  while (r < 0 && errno == EINTR);

  g_free (result);

}

static void

terminate (void)

{

  kill (getpid(), SIGTERM);

  abort();

}

static void

testcase_close (long double duration,

                gint        exit_status,

                guint       n_forks)

{

  g_return_if_fail (testcase_open > 0);

  test_log_printfe ("%s<duration>%.6Lf</duration>\n", sindent (log_indent), duration);

  test_log_printfe ("%s<status exit-status=\"%d\" n-forks=\"%d\" result=\"%s\"/>\n",

                    sindent (log_indent), exit_status, n_forks,

                    exit_status ? "failed" : "success");

  log_indent -= 2;

  test_log_printfe ("%s</testcase>\n", sindent (log_indent));

  testcase_open--;

  if (gtester_verbose)

    g_print ("%s\n", exit_status ? "FAIL" : "OK");

  if (exit_status && subtest_last_seed)

    g_print ("GTester: last random seed: %s\n", subtest_last_seed);

  if (exit_status)

    testcase_fail_count += 1;

  if (subtest_mode_fatal && testcase_fail_count)

    terminate();

}

static void

test_log_msg (GTestLogMsg *msg)

{

  switch (msg->log_type)

    {

      guint i;

      gchar **strv;

    case G_TEST_LOG_NONE:

      break;

    case G_TEST_LOG_ERROR:

      strv = g_strsplit (msg->strings[0], "\n", -1);

      for (i = 0; strv[i]; i++)

        test_log_printfe ("%s<error>%s</error>\n", sindent (log_indent), strv[i]);

      g_strfreev (strv);

      break;

    case G_TEST_LOG_START_BINARY:

      test_log_printfe ("%s<binary file=\"%s\"/>\n", sindent (log_indent), msg->strings[0]);

      subtest_last_seed = g_strdup (msg->strings[1]);

      test_log_printfe ("%s<random-seed>%s</random-seed>\n", sindent (log_indent), subtest_last_seed);

      break;

    case G_TEST_LOG_LIST_CASE:

      g_print ("%s\n", msg->strings[0]);

      break;

    case G_TEST_LOG_START_CASE:

      testcase_count++;

      if (gtester_verbose)

        {

          gchar *sc = g_strconcat (msg->strings[0], ":", NULL);

          gchar *sleft = g_strdup_printf ("%-68s", sc);

          g_free (sc);

          g_print ("%70s ", sleft);

          g_free (sleft);

        }

      g_return_if_fail (testcase_open == 0);

      testcase_open++;

      test_log_printfe ("%s<testcase path=\"%s\">\n", sindent (log_indent), msg->strings[0]);

      log_indent += 2;

      break;

    case G_TEST_LOG_SKIP_CASE:

      if (FALSE && gtester_verbose) /* enable to debug test case skipping logic */

        {

          gchar *sc = g_strconcat (msg->strings[0], ":", NULL);

          gchar *sleft = g_strdup_printf ("%-68s", sc);

          g_free (sc);

          g_print ("%70s SKIPPED\n", sleft);

          g_free (sleft);

        }

      test_log_printfe ("%s<testcase path=\"%s\" skipped=\"1\"/>\n", sindent (log_indent), msg->strings[0]);

      break;

    case G_TEST_LOG_STOP_CASE:

      testcase_close (msg->nums[2], (int) msg->nums[0], (int) msg->nums[1]);

      break;

    case G_TEST_LOG_MIN_RESULT:

    case G_TEST_LOG_MAX_RESULT:

      test_log_printfe ("%s<performance minimize=\"%d\" maximize=\"%d\" value=\"%.16Lg\">\n",

                        sindent (log_indent), msg->log_type == G_TEST_LOG_MIN_RESULT, msg->log_type == G_TEST_LOG_MAX_RESULT, msg->nums[0]);

      test_log_printfe ("%s%s\n", sindent (log_indent + 2), msg->strings[0]);

      test_log_printfe ("%s</performance>\n", sindent (log_indent));

      break;

    case G_TEST_LOG_MESSAGE:

      test_log_printfe ("%s<message>\n%s\n%s</message>\n", sindent (log_indent), msg->strings[0], sindent (log_indent));

      break;

    }

}

static gboolean

child_report_cb (GIOChannel  *source,

                 GIOCondition condition,

                 gpointer     data)

{

  GTestLogBuffer *tlb = data;

  GIOStatus status = G_IO_STATUS_NORMAL;

  gboolean first_read_eof = FALSE, first_read = TRUE;

  gsize length = 0;

  do

    {

      guint8 buffer[READ_BUFFER_SIZE];

      GError *error = NULL;

      status = g_io_channel_read_chars (source, (gchar*) buffer, sizeof (buffer), &length, &error);

      if (first_read && (condition & G_IO_IN))

        {

          /* on some unixes (MacOS) we need to detect non-blocking fd EOF

           * by an IO_IN select/poll followed by read()==0.

           */

          first_read_eof = length == 0;

        }

      first_read = FALSE;

      if (length)

        {

          GTestLogMsg *msg;

          g_test_log_buffer_push (tlb, length, buffer);

          do

            {

              msg = g_test_log_buffer_pop (tlb);

              if (msg)

                {

                  test_log_msg (msg);

                  g_test_log_msg_free (msg);

                }

            }

          while (msg);

        }

      g_clear_error (&error);

      /* ignore the io channel status, which will report intermediate EOFs for non blocking fds */

      (void) status;

    }

  while (length > 0);

  /* g_print ("LASTIOSTATE: first_read_eof=%d condition=%d\n", first_read_eof, condition); */

  if (first_read_eof || (condition & (G_IO_ERR | G_IO_HUP)))

    {

      /* if there's no data to read and select() reports an error or hangup,

       * the fd must have been closed remotely

       */

      subtest_io_pending = FALSE;

      return FALSE;

    }

  return TRUE; /* keep polling */

}

static void

child_watch_cb (GPid     pid,

		gint     status,

		gpointer data)

{

  g_spawn_close_pid (pid);

  if (WIFEXITED (status)) /* normal exit */

    subtest_exitstatus = WEXITSTATUS (status);

  else /* signal or core dump, etc */

    subtest_exitstatus = 0xffffffff;

  subtest_running = FALSE;

}

static gchar*

queue_gfree (GSList **slistp,

             gchar   *string)

{

  *slistp = g_slist_prepend (*slistp, string);

  return string;

}

static void

unset_cloexec_fdp (gpointer fdp_data)

{

  int r, *fdp = fdp_data;

  do

    r = fcntl (*fdp, F_SETFD, 0 /* FD_CLOEXEC */);

  while (r < 0 && errno == EINTR);

}

static gboolean

launch_test_binary (const char *binary,

                    guint       skip_tests)

{

  GTestLogBuffer *tlb;

  GSList *slist, *free_list = NULL;

  GError *error = NULL;

  int argc = 0;

  const gchar **argv;

  GPid pid = 0;

  gint report_pipe[2] = { -1, -1 };

  guint child_report_cb_id = 0;

  gboolean loop_pending;

  gint i = 0;

  if (pipe (report_pipe) < 0)

    {

      if (subtest_mode_fatal)

        g_error ("Failed to open pipe for test binary: %s: %s", binary, g_strerror (errno));

      else

        g_warning ("Failed to open pipe for test binary: %s: %s", binary, g_strerror (errno));

      return FALSE;

    }

  /* setup argc */

  for (slist = subtest_args; slist; slist = slist->next)

    argc++;

  /* argc++; */

  if (subtest_quiet)

    argc++;

  if (subtest_verbose)

    argc++;

  if (!subtest_mode_fatal)

    argc++;

  if (subtest_mode_quick)

    argc++;

  else

    argc++;

  if (subtest_mode_perf)

    argc++;

  if (gtester_list_tests)

    argc++;

  if (subtest_seedstr)

    argc++;

  argc++;

  if (skip_tests)

    argc++;

  for (slist = subtest_paths; slist; slist = slist->next)

    argc++;

  /* setup argv */

  argv = g_malloc ((argc + 2) * sizeof(gchar *));

  argv[i++] = binary;

  for (slist = subtest_args; slist; slist = slist->next)

    argv[i++] = (gchar*) slist->data;

  /* argv[i++] = "--debug-log"; */

  if (subtest_quiet)

    argv[i++] = "--quiet";

  if (subtest_verbose)

    argv[i++] = "--verbose";

  if (!subtest_mode_fatal)

    argv[i++] = "--keep-going";

  if (subtest_mode_quick)

    argv[i++] = "-m=quick";

  else

    argv[i++] = "-m=slow";

  if (subtest_mode_perf)

    argv[i++] = "-m=perf";

  if (gtester_list_tests)

    argv[i++] = "-l";

  if (subtest_seedstr)

    argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--seed=%s", subtest_seedstr));

  argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--GTestLogFD=%u", report_pipe[1]));

  if (skip_tests)

    argv[i++] = queue_gfree (&free_list, g_strdup_printf ("--GTestSkipCount=%u", skip_tests));

  for (slist = subtest_paths; slist; slist = slist->next)

    argv[i++] = queue_gfree (&free_list, g_strdup_printf ("-p=%s", (gchar*) slist->data));

  argv[i++] = NULL;

  g_spawn_async_with_pipes (NULL, /* g_get_current_dir() */

                            (gchar**) argv,

                            NULL, /* envp */

                            G_SPAWN_DO_NOT_REAP_CHILD, /* G_SPAWN_SEARCH_PATH */

                            unset_cloexec_fdp, &report_pipe[1], /* pre-exec callback */

                            &pid,

                            NULL,       /* standard_input */

                            NULL,       /* standard_output */

                            NULL,       /* standard_error */

                            &error);

  g_slist_foreach (free_list, (void(*)(void*,void*)) g_free, NULL);

  g_slist_free (free_list);

  free_list = NULL;

  close (report_pipe[1]);

  if (!gtester_quiet)

    g_print ("(pid=%lu)\n", (unsigned long) pid);

  if (error)

    {

      close (report_pipe[0]);

      if (subtest_mode_fatal)

        g_error ("Failed to execute test binary: %s: %s", argv[0], error->message);

      else

        g_warning ("Failed to execute test binary: %s: %s", argv[0], error->message);

      g_clear_error (&error);

      g_free (argv);

      return FALSE;

    }

  g_free (argv);

  subtest_running = TRUE;

  subtest_io_pending = TRUE;

  tlb = g_test_log_buffer_new();

  if (report_pipe[0] >= 0)

    {

      ioc_report = g_io_channel_unix_new (report_pipe[0]);

      g_io_channel_set_flags (ioc_report, G_IO_FLAG_NONBLOCK, NULL);

      g_io_channel_set_encoding (ioc_report, NULL, NULL);

      g_io_channel_set_buffered (ioc_report, FALSE);

      child_report_cb_id = g_io_add_watch_full (ioc_report, G_PRIORITY_DEFAULT - 1, G_IO_IN | G_IO_ERR | G_IO_HUP, child_report_cb, tlb, NULL);

      g_io_channel_unref (ioc_report);

    }

  g_child_watch_add_full (G_PRIORITY_DEFAULT + 1, pid, child_watch_cb, NULL, NULL);

  loop_pending = g_main_context_pending (NULL);

  while (subtest_running ||     /* FALSE once child exits */

         subtest_io_pending ||  /* FALSE once ioc_report closes */

         loop_pending)          /* TRUE while idler, etc are running */

    {

      /* g_print ("LOOPSTATE: subtest_running=%d subtest_io_pending=%d\n", subtest_running, subtest_io_pending); */

      /* check for unexpected hangs that are not signalled on report_pipe */

      if (!subtest_running &&   /* child exited */

          subtest_io_pending && /* no EOF detected on report_pipe */

          !loop_pending)        /* no IO events pending however */

        break;

      g_main_context_iteration (NULL, TRUE);

      loop_pending = g_main_context_pending (NULL);

    }

  g_source_remove (child_report_cb_id);

  close (report_pipe[0]);

  g_test_log_buffer_free (tlb);

  return TRUE;

}

static void

launch_test (const char *binary)

{

  gboolean success = TRUE;

  GTimer *btimer = g_timer_new();

  gboolean need_restart;

  testcase_count = 0;

  testcase_fail_count = 0;

  if (!gtester_quiet)

    g_print ("TEST: %s... ", binary);

 retry:

  test_log_printfe ("%s<testbinary path=\"%s\">\n", sindent (log_indent), binary);

  log_indent += 2;

  g_timer_start (btimer);

  subtest_exitstatus = 0;

  success &= launch_test_binary (binary, testcase_count);

  success &= subtest_exitstatus == 0;

  need_restart = testcase_open != 0;

  if (testcase_open)

    testcase_close (0, -256, 0);

  g_timer_stop (btimer);

  test_log_printfe ("%s<duration>%.6f</duration>\n", sindent (log_indent), g_timer_elapsed (btimer, NULL));

  log_indent -= 2;

  test_log_printfe ("%s</testbinary>\n", sindent (log_indent));

  g_free (subtest_last_seed);

  subtest_last_seed = NULL;

  if (need_restart)

    {

      /* restart test binary, skipping processed test cases */

      goto retry;

    }

  if (!gtester_quiet)

    g_print ("%s: %s\n", testcase_fail_count || !success ? "FAIL" : "PASS", binary);

  g_timer_destroy (btimer);

  if (subtest_mode_fatal && !success)

    terminate();

}

static void

usage (gboolean just_version)

{

  if (just_version)

    {

      g_print ("gtester version %d.%d.%d\n", GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION);

      return;

    }

  g_print ("Usage: gtester [OPTIONS] testprogram...\n");

  /*        12345678901234567890123456789012345678901234567890123456789012345678901234567890 */

  g_print ("Options:\n");

  g_print ("  -h, --help                  show this help message\n");

  g_print ("  -v, --version               print version informations\n");

  g_print ("  --g-fatal-warnings          make warnings fatal (abort)\n");

  g_print ("  -k, --keep-going            continue running after tests failed\n");

  g_print ("  -l                          list paths of available test cases\n");

  g_print ("  -m=perf, -m=slow, -m=quick -m=thorough\n");

  g_print ("                              run test cases in mode perf, slow/thorough or quick (default)\n");

  g_print ("  -p=TESTPATH                 only start test cases matching TESTPATH\n");

  g_print ("  --seed=SEEDSTRING           start all tests with random number seed SEEDSTRING\n");

  g_print ("  -o=LOGFILE                  write the test log to LOGFILE\n");

  g_print ("  -q, --quiet                 suppress per test binary output\n");

  g_print ("  --verbose                   report success per testcase\n");

}

static void

parse_args (gint    *argc_p,

            gchar ***argv_p)

{

  guint argc = *argc_p;

  gchar **argv = *argv_p;

  guint i, e;

  /* parse known args */

  for (i = 1; i < argc; i++)

    {

      if (strcmp (argv[i], "--g-fatal-warnings") == 0)

        {

          GLogLevelFlags fatal_mask = (GLogLevelFlags) g_log_set_always_fatal ((GLogLevelFlags) G_LOG_FATAL_MASK);

          fatal_mask = (GLogLevelFlags) (fatal_mask | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL);

          g_log_set_always_fatal (fatal_mask);

          argv[i] = NULL;

        }

      else if (strcmp (argv[i], "--gtester-selftest") == 0)

        {

          gtester_selftest = TRUE;

          argv[i] = NULL;

          break;        /* stop parsing regular gtester arguments */

        }

      else if (strcmp (argv[i], "-h") == 0 || strcmp (argv[i], "--help") == 0)

        {

          usage (FALSE);

          exit (0);

          argv[i] = NULL;

        }

      else if (strcmp (argv[i], "-v") == 0 || strcmp (argv[i], "--version") == 0)

        {

          usage (TRUE);

          exit (0);

          argv[i] = NULL;

        }

      else if (strcmp (argv[i], "--keep-going") == 0 ||

               strcmp (argv[i], "-k") == 0)

        {

          subtest_mode_fatal = FALSE;

          argv[i] = NULL;

        }

      else if (strcmp ("-p", argv[i]) == 0 || strncmp ("-p=", argv[i], 3) == 0)

        {

          gchar *equal = argv[i] + 2;

          if (*equal == '=')

            subtest_paths = g_slist_prepend (subtest_paths, equal + 1);

          else if (i + 1 < argc)

            {

              argv[i++] = NULL;