/* GLib testing utilities

 * Copyright (C) 2007 Imendio AB

 * Authors: Tim Janik, Sven Herzberg

 * Portions copyright (c) 2009 Nokia Corporation.  All rights reserved.

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

#include "gtestutils.h"

#include "galias.h"

#include <sys/types.h>

#ifdef G_OS_UNIX

#include <sys/wait.h>

#include <sys/time.h>

#include <fcntl.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef G_OS_WIN32

#include <io.h>

#endif

#include <errno.h>

#include <signal.h>

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif /* HAVE_SYS_SELECT_H */

#ifdef __SYMBIAN32__

#include "glib_wsd.h"

#endif /* __SYMBIAN32__ */

/* --- structures --- */

struct GTestCase

{

  gchar  *name;

  guint   fixture_size;

  void   (*fixture_setup)    (void*, gconstpointer);

  void   (*fixture_test)     (void*, gconstpointer);

  void   (*fixture_teardown) (void*, gconstpointer);

  gpointer test_data;

};

struct GTestSuite

{

  gchar  *name;

  GSList *suites;

  GSList *cases;

};

typedef struct DestroyEntry DestroyEntry;

struct DestroyEntry

{

  DestroyEntry *next;

  GDestroyNotify destroy_func;

  gpointer       destroy_data;

};

/* --- prototypes --- */

static void     test_run_seed                   (const gchar *rseed);

static void     test_trap_clear                 (void);

static guint8*  g_test_log_dump                 (GTestLogMsg *msg,

                                                 guint       *len);

static void     gtest_default_log_handler       (const gchar    *log_domain,

                                                 GLogLevelFlags  log_level,

                                                 const gchar    *message,

                                                 gpointer        unused_data);

/* --- variables --- */

#if (EMULATOR)

PLS(test_log_fd,gtestutils,int)

PLS(test_mode_fatal,gtestutils,gboolean)

PLS(g_test_run_once,gtestutils,gboolean)

PLS(test_run_list,gtestutils,gboolean)

PLS(test_run_seedstr,gtestutils,gchar*)

PLS(test_run_rand,gtestutils,GRand*)

PLS(test_run_name,gtestutils,gchar*)

PLS(test_run_forks,gtestutils,guint)

PLS(test_run_count,gtestutils,guint)

PLS(test_skip_count,gtestutils,guint)

PLS(test_user_timer,gtestutils,GTimer*)

PLS(test_user_stamp,gtestutils,double)

PLS(test_paths,gtestutils,GSList*)

PLS(test_suite_root,gtestutils,GTestSuite*)

PLS(test_trap_last_status,gtestutils,int)

PLS(test_trap_last_pid,gtestutils,int)

PLS(test_trap_last_stdout,gtestutils,char*)

PLS(test_trap_last_stderr,gtestutils,char*)

PLS(test_uri_base,gtestutils,char*)

PLS(test_debug_log,gtestutils,gboolean)

PLS(test_destroy_queue,gtestutils,DestroyEntry*)

PLS(mutable_test_config_vars,gtestutils,GTestConfig)

PLS(g_test_config_vars,gtestutils,const GTestConfig* const)

#define test_log_fd (*FUNCTION_NAME(test_log_fd,gtestutils)())

#define test_mode_fatal (*FUNCTION_NAME(test_mode_fatal,gtestutils)())

#define g_test_run_once (*FUNCTION_NAME(g_test_run_once,gtestutils)())

#define test_run_list (*FUNCTION_NAME(test_run_list,gtestutils)())

#define test_run_seedstr (*FUNCTION_NAME(test_run_seedstr,gtestutils)())

#define test_run_rand (*FUNCTION_NAME(test_run_rand,gtestutils)())

#define test_run_name (*FUNCTION_NAME(test_run_name,gtestutils)())

#define test_run_forks (*FUNCTION_NAME(test_run_forks,gtestutils)())

#define test_run_count (*FUNCTION_NAME(test_run_count,gtestutils)())

#define test_skip_count (*FUNCTION_NAME(test_skip_count,gtestutils)())

#define test_user_timer (*FUNCTION_NAME(test_user_timer,gtestutils)())

#define test_user_stamp (*FUNCTION_NAME(test_user_stamp,gtestutils)())

#define test_paths (*FUNCTION_NAME(test_paths,gtestutils)())

#define test_suite_root (*FUNCTION_NAME(test_suite_root,gtestutils)())

#define test_trap_last_status (*FUNCTION_NAME(test_trap_last_status,gtestutils)())

#define test_trap_last_pid (*FUNCTION_NAME(test_trap_last_pid,gtestutils)())

#define test_trap_last_stdout (*FUNCTION_NAME(test_trap_last_stdout,gtestutils)())

#define test_trap_last_stderr (*FUNCTION_NAME(test_trap_last_stderr,gtestutils)())

#define test_uri_base (*FUNCTION_NAME(test_uri_base,gtestutils)())

#define test_debug_log (*FUNCTION_NAME(test_debug_log,gtestutils)())

#define test_destroy_queue (*FUNCTION_NAME(test_destroy_queue,gtestutils)())

#define mutable_test_config_vars (*FUNCTION_NAME(mutable_test_config_vars,gtestutils)())

#define g_test_config_vars (*FUNCTION_NAME(g_test_config_vars,gtestutils)())

#else

static int         test_log_fd = -1;

static gboolean    test_mode_fatal = TRUE;

static gboolean    g_test_run_once = TRUE;

static gboolean    test_run_list = FALSE;

static gchar      *test_run_seedstr = NULL;

static GRand      *test_run_rand = NULL;

static gchar      *test_run_name = "";

static guint       test_run_forks = 0;

static guint       test_run_count = 0;

static guint       test_skip_count = 0;

static GTimer     *test_user_timer = NULL;

static double      test_user_stamp = 0;

static GSList     *test_paths = NULL;

static GTestSuite *test_suite_root = NULL;

static int         test_trap_last_status = 0;

static int         test_trap_last_pid = 0;

static char       *test_trap_last_stdout = NULL;

static char       *test_trap_last_stderr = NULL;

static char       *test_uri_base = NULL;

static gboolean    test_debug_log = FALSE;

static DestroyEntry *test_destroy_queue = NULL;

static GTestConfig mutable_test_config_vars = {

  FALSE,        /* test_initialized */

  TRUE,         /* test_quick */

  FALSE,        /* test_perf */

  FALSE,        /* test_verbose */

  FALSE,        /* test_quiet */

};

const GTestConfig * const g_test_config_vars = &mutable_test_config_vars ;

#endif//EMULATOR

#ifdef __SYMBIAN32__

EXPORT_C const GTestConfig * const *_g_test_config_vars(void)

	{

	return &g_test_config_vars;

	}

#endif//__SYMBIAN32__

/* --- functions --- */

EXPORT_C const char*

g_test_log_type_name (GTestLogType log_type)

{

  switch (log_type)

    {

    case G_TEST_LOG_NONE:               return "none";

    case G_TEST_LOG_ERROR:              return "error";

    case G_TEST_LOG_START_BINARY:       return "binary";

    case G_TEST_LOG_LIST_CASE:          return "list";

    case G_TEST_LOG_SKIP_CASE:          return "skip";

    case G_TEST_LOG_START_CASE:         return "start";

    case G_TEST_LOG_STOP_CASE:          return "stop";

    case G_TEST_LOG_MIN_RESULT:         return "minperf";

    case G_TEST_LOG_MAX_RESULT:         return "maxperf";

    case G_TEST_LOG_MESSAGE:            return "message";

    }

  return "???";

}

static void

g_test_log_send (guint         n_bytes,

                 const guint8 *buffer)

{

  if (test_log_fd >= 0)

    {

      int r;

      do

        r = write (test_log_fd, buffer, n_bytes);

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

    }

  if (test_debug_log)

    {

      GTestLogBuffer *lbuffer = g_test_log_buffer_new ();

      GTestLogMsg *msg;

      guint ui;

      g_test_log_buffer_push (lbuffer, n_bytes, buffer);

      msg = g_test_log_buffer_pop (lbuffer);

      g_warn_if_fail (msg != NULL);

      g_warn_if_fail (lbuffer->data->len == 0);

      g_test_log_buffer_free (lbuffer);

      /* print message */

      g_printerr ("{*LOG(%s)", g_test_log_type_name (msg->log_type));

      for (ui = 0; ui < msg->n_strings; ui++)

        g_printerr (":{%s}", msg->strings[ui]);

      if (msg->n_nums)

        {

          g_printerr (":(");

          for (ui = 0; ui < msg->n_nums; ui++)

            g_printerr ("%s%.16Lg", ui ? ";" : "", msg->nums[ui]);

          g_printerr (")");

        }

      g_printerr (":LOG*}\n");

      g_test_log_msg_free (msg);

    }

}

static void

g_test_log (GTestLogType lbit,

            const gchar *string1,

            const gchar *string2,

            guint        n_args,

            long double *largs)

{

  gboolean fail = lbit == G_TEST_LOG_STOP_CASE && largs[0] != 0;

  GTestLogMsg msg;

  gchar *astrings[3] = { NULL, NULL, NULL };

  guint8 *dbuffer;

  guint32 dbufferlen;

  switch (lbit)

    {

    case G_TEST_LOG_START_BINARY:

      if (g_test_verbose())

        g_print ("GTest: random seed: %s\n", string2);

      break;

    case G_TEST_LOG_STOP_CASE:

      if (g_test_verbose())

        g_print ("GTest: result: %s\n", fail ? "FAIL" : "OK");

      else if (!g_test_quiet())

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

      if (fail && test_mode_fatal)

        abort();

      break;

    case G_TEST_LOG_MIN_RESULT:

      if (g_test_verbose())

        g_print ("(MINPERF:%s)\n", string1);

      break;

    case G_TEST_LOG_MAX_RESULT:

      if (g_test_verbose())

        g_print ("(MAXPERF:%s)\n", string1);

      break;

    case G_TEST_LOG_MESSAGE:

      if (g_test_verbose())

        g_print ("(MSG: %s)\n", string1);

      break;

    default: ;

    }

  msg.log_type = lbit;

  msg.n_strings = (string1 != NULL) + (string1 && string2);

  msg.strings = astrings;

  astrings[0] = (gchar*) string1;

  astrings[1] = astrings[0] ? (gchar*) string2 : NULL;

  msg.n_nums = n_args;

  msg.nums = largs;

  dbuffer = g_test_log_dump (&msg, &dbufferlen);

  g_test_log_send (dbufferlen, dbuffer);

  g_free (dbuffer);

  switch (lbit)

    {

    case G_TEST_LOG_START_CASE:

      if (g_test_verbose())

        g_print ("GTest: run: %s\n", string1);

      else if (!g_test_quiet())

        g_print ("%s: ", string1);

      break;

    default: ;

    }

}

/* We intentionally parse the command line without GOptionContext

 * because otherwise you would never be able to test it.

 */

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], "--keep-going") == 0 ||

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

        {

          test_mode_fatal = FALSE;

          argv[i] = NULL;

        }

      else if (strcmp (argv[i], "--debug-log") == 0)

        {

          test_debug_log = TRUE;

          argv[i] = NULL;

        }

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

        {

          gchar *equal = argv[i] + 12;

          if (*equal == '=')

            test_log_fd = g_ascii_strtoull (equal + 1, NULL, 0);

          else if (i + 1 < argc)

            {

              argv[i++] = NULL;

              test_log_fd = g_ascii_strtoull (argv[i], NULL, 0);

            }

          argv[i] = NULL;

        }

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

        {

          gchar *equal = argv[i] + 16;

          if (*equal == '=')

            test_skip_count = g_ascii_strtoull (equal + 1, NULL, 0);

          else if (i + 1 < argc)

            {

              argv[i++] = NULL;

              test_skip_count = g_ascii_strtoull (argv[i], NULL, 0);

            }

          argv[i] = NULL;

        }

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

        {

          gchar *equal = argv[i] + 2;

          if (*equal == '=')

            test_paths = g_slist_prepend (test_paths, equal + 1);

          else if (i + 1 < argc)

            {

              argv[i++] = NULL;

              test_paths = g_slist_prepend (test_paths, argv[i]);

            }

          argv[i] = NULL;

        }

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

        {

          gchar *equal = argv[i] + 2;

          const gchar *mode = "";

          if (*equal == '=')

            mode = equal + 1;

          else if (i + 1 < argc)

            {

              argv[i++] = NULL;

              mode = argv[i];

            }

          if (strcmp (mode, "perf") == 0)

            mutable_test_config_vars.test_perf = TRUE;

          else if (strcmp (mode, "slow") == 0)

            mutable_test_config_vars.test_quick = FALSE;

          else if (strcmp (mode, "thorough") == 0)

            mutable_test_config_vars.test_quick = FALSE;

          else if (strcmp (mode, "quick") == 0)

            {

              mutable_test_config_vars.test_quick = TRUE;

              mutable_test_config_vars.test_perf = FALSE;

            }

          else

            g_error ("unknown test mode: -m %s", mode);

          argv[i] = NULL;

        }

      else if (strcmp ("-q", argv[i]) == 0 || strcmp ("--quiet", argv[i]) == 0)

        {

          mutable_test_config_vars.test_quiet = TRUE;

          mutable_test_config_vars.test_verbose = FALSE;

          argv[i] = NULL;

        }

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

        {

          mutable_test_config_vars.test_quiet = FALSE;

          mutable_test_config_vars.test_verbose = TRUE;

          argv[i] = NULL;

        }

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

        {

          test_run_list = TRUE;

          argv[i] = NULL;

        }

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

        {

          gchar *equal = argv[i] + 6;

          if (*equal == '=')

            test_run_seedstr = equal + 1;

          else if (i + 1 < argc)

            {

              argv[i++] = NULL;

              test_run_seedstr = argv[i];

            }

          argv[i] = NULL;

        }

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

        {

          printf ("Usage:\n"

                  "  %s [OPTION...]\n\n"

                  "Help Options:\n"

                  "  -?, --help                     Show help options\n"

                  "Test Options:\n"

                  "  -l                             List test cases available in a test executable\n"

                  "  -seed=RANDOMSEED               Provide a random seed to reproduce test\n"

                  "                                 runs using random numbers\n"

                  "  --verbose                      Run tests verbosely\n"

                  "  -q, --quiet                    Run tests quietly\n"

                  "  -p TESTPATH                    execute all tests matching TESTPATH\n"

                  "  -m {perf|slow|thorough|quick}  Execute tests according modes\n"

                  "  --debug-log                    debug test logging output\n"

                  "  -k, --keep-going               gtester-specific argument\n"

                  "  --GTestLogFD=N                 gtester-specific argument\n"

                  "  --GTestSkipCount=N             gtester-specific argument\n",

                  argv[0]);

          exit (0);

        }

    }

  /* collapse argv */

  e = 1;

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

    if (argv[i])

      {

        argv[e++] = argv[i];

        if (i >= e)

          argv[i] = NULL;

      }

  *argc_p = e;

}

#if (EMULATOR)

PLS_ARRAY(seedstr,g_test_init,char)

#define seedstr (FUNCTION_NAME(seedstr,g_test_init)())

#endif//EMULATOR

/**

 * g_test_init:

 * @argc: Address of the @argc parameter of the main() function.

 *        Changed if any arguments were handled.

 * @argv: Address of the @argv parameter of main().

 *        Any parameters understood by g_test_init() stripped before return.

 * @Varargs: Reserved for future extension. Currently, you must pass %NULL.

 *

 * Initialize the GLib testing framework, e.g. by seeding the

 * test random number generator, the name for g_get_prgname()

 * and parsing test related command line args.

 * So far, the following arguments are understood:

 * <variablelist>

 *   <varlistentry>

 *     <term><option>-l</option></term>

 *     <listitem><para>

 *       list test cases available in a test executable.

 *     </para></listitem>

 *   </varlistentry>

 *   <varlistentry>

 *     <term><option>--seed=<replaceable>RANDOMSEED</replaceable></option></term>

 *     <listitem><para>

 *       provide a random seed to reproduce test runs using random numbers.

 *     </para></listitem>

 *     </varlistentry>

 *     <varlistentry>

 *       <term><option>--verbose</option></term>

 *       <listitem><para>run tests verbosely.</para></listitem>

 *     </varlistentry>

 *     <varlistentry>

 *       <term><option>-q</option>, <option>--quiet</option></term>

 *       <listitem><para>run tests quietly.</para></listitem>

 *     </varlistentry>

 *     <varlistentry>

 *       <term><option>-p <replaceable>TESTPATH</replaceable></option></term>

 *       <listitem><para>

 *         execute all tests matching <replaceable>TESTPATH</replaceable>.

 *       </para></listitem>

 *     </varlistentry>

 *     <varlistentry>

 *       <term><option>-m {perf|slow|thorough|quick}</option></term>

 *       <listitem><para>

 *         execute tests according to these test modes:

 *         <variablelist>

 *           <varlistentry>

 *             <term>perf</term>

 *             <listitem><para>

 *               performance tests, may take long and report results.

 *             </para></listitem>

 *           </varlistentry>

 *           <varlistentry>

 *             <term>slow, thorough</term>

 *             <listitem><para>

 *               slow and thorough tests, may take quite long and 

 *               maximize coverage.

 *             </para></listitem>

 *           </varlistentry>

 *           <varlistentry>

 *             <term>quick</term>

 *             <listitem><para>

 *               quick tests, should run really quickly and give good coverage.

 *             </para></listitem>

 *           </varlistentry>

 *         </variablelist>

 *       </para></listitem>

 *     </varlistentry>

 *     <varlistentry>

 *       <term><option>--debug-log</option></term>

 *       <listitem><para>debug test logging output.</para></listitem>

 *     </varlistentry>

 *     <varlistentry>

 *       <term><option>-k</option>, <option>--keep-going</option></term>

 *       <listitem><para>gtester-specific argument.</para></listitem>

 *     </varlistentry>

 *     <varlistentry>