/* GLib testing utilities

 * Copyright (C) 2007 Imendio AB

 * Authors: Tim Janik, Sven Herzberg

 *

 * 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, see <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include "gtestutils.h"

#include "gfileutils.h"

#include <sys/types.h>

#ifdef G_OS_UNIX

#include <sys/wait.h>

#include <sys/time.h>

#include <fcntl.h>

#include <unistd.h>

#include <glib/gstdio.h>

#endif

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#ifdef HAVE_SYS_RESOURCE_H

#include <sys/resource.h>

#endif

#ifdef G_OS_WIN32

#include <io.h>

#include <windows.h>

#endif

#include <errno.h>

#include <signal.h>

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif /* HAVE_SYS_SELECT_H */

#include "gmain.h"

#include "gpattern.h"

#include "grand.h"

#include "gstrfuncs.h"

#include "gtimer.h"

#include "gslice.h"

#include "gspawn.h"

#include "glib-private.h"

/**

 * SECTION:testing

 * @title: Testing

 * @short_description: a test framework

 * @see_also: [gtester][gtester], [gtester-report][gtester-report]

 *

 * GLib provides a framework for writing and maintaining unit tests

 * in parallel to the code they are testing. The API is designed according

 * to established concepts found in the other test frameworks (JUnit, NUnit,

 * RUnit), which in turn is based on smalltalk unit testing concepts.

 *

 * - Test case: Tests (test methods) are grouped together with their

 *   fixture into test cases.

 *

 * - Fixture: A test fixture consists of fixture data and setup and

 *   teardown methods to establish the environment for the test

 *   functions. We use fresh fixtures, i.e. fixtures are newly set

 *   up and torn down around each test invocation to avoid dependencies

 *   between tests.

 *

 * - Test suite: Test cases can be grouped into test suites, to allow

 *   subsets of the available tests to be run. Test suites can be

 *   grouped into other test suites as well.

 *

 * The API is designed to handle creation and registration of test suites

 * and test cases implicitly. A simple call like

 * |[ 

 *   g_test_add_func ("/misc/assertions", test_assertions);

 * ]|

 * creates a test suite called "misc" with a single test case named

 * "assertions", which consists of running the test_assertions function.

 *

 * In addition to the traditional g_assert(), the test framework provides

 * an extended set of assertions for comparisons: g_assert_cmpfloat(),

 * g_assert_cmpint(), g_assert_cmpuint(), g_assert_cmphex(),

 * g_assert_cmpstr(), and g_assert_cmpmem(). The advantage of these

 * variants over plain g_assert() is that the assertion messages can be

 * more elaborate, and include the values of the compared entities.

 *

 * A full example of creating a test suite with two tests using fixtures:

 * |[

 * #include <glib.h>

 * #include <locale.h>

 *

 * typedef struct {

 *   MyObject *obj;

 *   OtherObject *helper;

 * } MyObjectFixture;

 *

 * static void

 * my_object_fixture_set_up (MyObjectFixture *fixture,

 *                           gconstpointer user_data)

 * {

 *   fixture->obj = my_object_new ();

 *   my_object_set_prop1 (fixture->obj, "some-value");

 *   my_object_do_some_complex_setup (fixture->obj, user_data);

 *

 *   fixture->helper = other_object_new ();

 * }

 *

 * static void

 * my_object_fixture_tear_down (MyObjectFixture *fixture,

 *                              gconstpointer user_data)

 * {

 *   g_clear_object (&fixture->helper);

 *   g_clear_object (&fixture->obj);

 * }

 *

 * static void

 * test_my_object_test1 (MyObjectFixture *fixture,

 *                       gconstpointer user_data)

 * {

 *   g_assert_cmpstr (my_object_get_property (fixture->obj), ==, "initial-value");

 * }

 *

 * static void

 * test_my_object_test2 (MyObjectFixture *fixture,

 *                       gconstpointer user_data)

 * {

 *   my_object_do_some_work_using_helper (fixture->obj, fixture->helper);

 *   g_assert_cmpstr (my_object_get_property (fixture->obj), ==, "updated-value");

 * }

 *

 * int

 * main (int argc, char *argv[])

 * {

 *   setlocale (LC_ALL, "");

 *

 *   g_test_init (&argc, &argv, NULL);

 *   g_test_bug_base ("http://bugzilla.gnome.org/show_bug.cgi?id=");

 *

 *   // Define the tests.

 *   g_test_add ("/my-object/test1", MyObjectFixture, "some-user-data",

 *               my_object_fixture_set_up, test_my_object_test1,

 *               my_object_fixture_tear_down);

 *   g_test_add ("/my-object/test2", MyObjectFixture, "some-user-data",

 *               my_object_fixture_set_up, test_my_object_test2,

 *               my_object_fixture_tear_down);

 *

 *   return g_test_run ();

 * }

 * ]|

 *

 * ### Integrating GTest in your project

 *

 * If you are using the [Meson](http://mesonbuild.com) build system, you will

 * typically use the provided `test()` primitive to call the test binaries,

 * e.g.:

 *

 * |[

 *   test(

 *     'foo',

 *     executable('foo', 'foo.c', dependencies: deps),

 *     env: [

 *       'G_TEST_SRCDIR=@0@'.format(meson.current_source_dir()),

 *       'G_TEST_BUILDDIR=@0@'.format(meson.current_build_dir()),

 *     ],

 *   )

 *

 *   test(

 *     'bar',

 *     executable('bar', 'bar.c', dependencies: deps),

 *     env: [

 *       'G_TEST_SRCDIR=@0@'.format(meson.current_source_dir()),

 *       'G_TEST_BUILDDIR=@0@'.format(meson.current_build_dir()),

 *     ],

 *   )

 * ]|

 *

 * If you are using Autotools, you're strongly encouraged to use the Automake

 * [TAP](https://testanything.org/) harness; GLib provides template files for

 * easily integrating with it:

 *

 *   - [glib-tap.mk](https://git.gnome.org/browse/glib/tree/glib-tap.mk)

 *   - [tap-test](https://git.gnome.org/browse/glib/tree/tap-test)

 *   - [tap-driver.sh](https://git.gnome.org/browse/glib/tree/tap-driver.sh)

 *

 * You can copy these files in your own project's root directory, and then

 * set up your `Makefile.am` file to reference them, for instance:

 *

 * |[

 * include $(top_srcdir)/glib-tap.mk

 *

 * # test binaries

 * test_programs = \

 *   foo \

 *   bar

 *

 * # data distributed in the tarball

 * dist_test_data = \

 *   foo.data.txt \

 *   bar.data.txt

 *

 * # data not distributed in the tarball

 * test_data = \

 *   blah.data.txt

 * ]|

 *

 * Make sure to distribute the TAP files, using something like the following

 * in your top-level `Makefile.am`:

 *

 * |[

 * EXTRA_DIST += \

 *   tap-driver.sh \

 *   tap-test

 * ]|

 *

 * `glib-tap.mk` will be distributed implicitly due to being included in a

 * `Makefile.am`. All three files should be added to version control.

 *

 * If you don't have access to the Autotools TAP harness, you can use the

 * [gtester][gtester] and [gtester-report][gtester-report] tools, and use

 * the [glib.mk](https://git.gnome.org/browse/glib/tree/glib.mk) Automake

 * template provided by GLib.

 */

/**

 * g_test_initialized:

 *

 * Returns %TRUE if g_test_init() has been called.

 *

 * Returns: %TRUE if g_test_init() has been called.

 *

 * Since: 2.36

 */

/**

 * g_test_quick:

 *

 * Returns %TRUE if tests are run in quick mode.

 * Exactly one of g_test_quick() and g_test_slow() is active in any run;

 * there is no "medium speed".

 *

 * By default, tests are run in quick mode. In tests that use

 * g_test_init(), the options `-m quick`, `-m slow` and `-m thorough`

 * can be used to change this.

 *

 * Returns: %TRUE if in quick mode

 */

/**

 * g_test_slow:

 *

 * Returns %TRUE if tests are run in slow mode.

 * Exactly one of g_test_quick() and g_test_slow() is active in any run;

 * there is no "medium speed".

 *

 * By default, tests are run in quick mode. In tests that use

 * g_test_init(), the options `-m quick`, `-m slow` and `-m thorough`

 * can be used to change this.

 *

 * Returns: the opposite of g_test_quick()

 */

/**

 * g_test_thorough:

 *

 * Returns %TRUE if tests are run in thorough mode, equivalent to

 * g_test_slow().

 *

 * By default, tests are run in quick mode. In tests that use

 * g_test_init(), the options `-m quick`, `-m slow` and `-m thorough`

 * can be used to change this.

 *

 * Returns: the same thing as g_test_slow()

 */

/**

 * g_test_perf:

 *

 * Returns %TRUE if tests are run in performance mode.

 *

 * By default, tests are run in quick mode. In tests that use

 * g_test_init(), the option `-m perf` enables performance tests, while

 * `-m quick` disables them.

 *

 * Returns: %TRUE if in performance mode

 */

/**

 * g_test_undefined:

 *

 * Returns %TRUE if tests may provoke assertions and other formally-undefined

 * behaviour, to verify that appropriate warnings are given. It might, in some

 * cases, be useful to turn this off with if running tests under valgrind;

 * in tests that use g_test_init(), the option `-m no-undefined` disables

 * those tests, while `-m undefined` explicitly enables them (the default

 * behaviour).

 *

 * Returns: %TRUE if tests may provoke programming errors

 */

/**

 * g_test_verbose:

 *

 * Returns %TRUE if tests are run in verbose mode.

 * In tests that use g_test_init(), the option `--verbose` enables this,

 * while `-q` or `--quiet` disables it.

 * The default is neither g_test_verbose() nor g_test_quiet().

 *

 * Returns: %TRUE if in verbose mode

 */

/**

 * g_test_quiet:

 *

 * Returns %TRUE if tests are run in quiet mode.

 * In tests that use g_test_init(), the option `-q` or `--quiet` enables

 * this, while `--verbose` disables it.

 * The default is neither g_test_verbose() nor g_test_quiet().

 *

 * Returns: %TRUE if in quiet mode

 */

/**

 * g_test_queue_unref:

 * @gobject: the object to unref

 *

 * Enqueue an object to be released with g_object_unref() during

 * the next teardown phase. This is equivalent to calling

 * g_test_queue_destroy() with a destroy callback of g_object_unref().

 *

 * Since: 2.16

 */

/**

 * GTestTrapFlags:

 * @G_TEST_TRAP_SILENCE_STDOUT: Redirect stdout of the test child to

 *     `/dev/null` so it cannot be observed on the console during test

 *     runs. The actual output is still captured though to allow later

 *     tests with g_test_trap_assert_stdout().

 * @G_TEST_TRAP_SILENCE_STDERR: Redirect stderr of the test child to

 *     `/dev/null` so it cannot be observed on the console during test

 *     runs. The actual output is still captured though to allow later

 *     tests with g_test_trap_assert_stderr().

 * @G_TEST_TRAP_INHERIT_STDIN: If this flag is given, stdin of the

 *     child process is shared with stdin of its parent process.

 *     It is redirected to `/dev/null` otherwise.

 *

 * Test traps are guards around forked tests.

 * These flags determine what traps to set.

 *

 * Deprecated: #GTestTrapFlags is used only with g_test_trap_fork(),

 * which is deprecated. g_test_trap_subprocess() uses

 * #GTestSubprocessFlags.

 */

/**

 * GTestSubprocessFlags:

 * @G_TEST_SUBPROCESS_INHERIT_STDIN: If this flag is given, the child

 *     process will inherit the parent's stdin. Otherwise, the child's

 *     stdin is redirected to `/dev/null`.

 * @G_TEST_SUBPROCESS_INHERIT_STDOUT: If this flag is given, the child

 *     process will inherit the parent's stdout. Otherwise, the child's

 *     stdout will not be visible, but it will be captured to allow

 *     later tests with g_test_trap_assert_stdout().

 * @G_TEST_SUBPROCESS_INHERIT_STDERR: If this flag is given, the child

 *     process will inherit the parent's stderr. Otherwise, the child's

 *     stderr will not be visible, but it will be captured to allow

 *     later tests with g_test_trap_assert_stderr().

 *

 * Flags to pass to g_test_trap_subprocess() to control input and output.

 *

 * Note that in contrast with g_test_trap_fork(), the default is to

 * not show stdout and stderr.

 */

/**

 * g_test_trap_assert_passed:

 *

 * Assert that the last test subprocess passed.

 * See g_test_trap_subprocess().

 *

 * Since: 2.16

 */

/**

 * g_test_trap_assert_failed:

 *

 * Assert that the last test subprocess failed.

 * See g_test_trap_subprocess().

 *

 * This is sometimes used to test situations that are formally considered to

 * be undefined behaviour, like inputs that fail a g_return_if_fail()

 * check. In these situations you should skip the entire test, including the

 * call to g_test_trap_subprocess(), unless g_test_undefined() returns %TRUE

 * to indicate that undefined behaviour may be tested.

 *

 * Since: 2.16

 */

/**

 * g_test_trap_assert_stdout:

 * @soutpattern: a glob-style [pattern][glib-Glob-style-pattern-matching]

 *

 * Assert that the stdout output of the last test subprocess matches

 * @soutpattern. See g_test_trap_subprocess().

 *

 * Since: 2.16

 */

/**

 * g_test_trap_assert_stdout_unmatched:

 * @soutpattern: a glob-style [pattern][glib-Glob-style-pattern-matching]

 *

 * Assert that the stdout output of the last test subprocess

 * does not match @soutpattern. See g_test_trap_subprocess().

 *

 * Since: 2.16

 */

/**

 * g_test_trap_assert_stderr:

 * @serrpattern: a glob-style [pattern][glib-Glob-style-pattern-matching]

 *

 * Assert that the stderr output of the last test subprocess

 * matches @serrpattern. See  g_test_trap_subprocess().

 *

 * This is sometimes used to test situations that are formally

 * considered to be undefined behaviour, like code that hits a

 * g_assert() or g_error(). In these situations you should skip the

 * entire test, including the call to g_test_trap_subprocess(), unless

 * g_test_undefined() returns %TRUE to indicate that undefined

 * behaviour may be tested.

 *

 * Since: 2.16

 */

/**

 * g_test_trap_assert_stderr_unmatched:

 * @serrpattern: a glob-style [pattern][glib-Glob-style-pattern-matching]

 *

 * Assert that the stderr output of the last test subprocess

 * does not match @serrpattern. See g_test_trap_subprocess().

 *

 * Since: 2.16

 */

/**

 * g_test_rand_bit:

 *

 * Get a reproducible random bit (0 or 1), see g_test_rand_int()

 * for details on test case random numbers.

 *

 * Since: 2.16

 */

/**

 * g_assert:

 * @expr: the expression to check

 *

 * Debugging macro to terminate the application if the assertion

 * fails. If the assertion fails (i.e. the expression is not true),

 * an error message is logged and the application is terminated.

 *

 * The macro can be turned off in final releases of code by defining

 * `G_DISABLE_ASSERT` when compiling the application, so code must

 * not depend on any side effects from @expr.

 */

/**

 * g_assert_not_reached:

 *

 * Debugging macro to terminate the application if it is ever

 * reached. If it is reached, an error message is logged and the

 * application is terminated.

 *

 * The macro can be turned off in final releases of code by defining

 * `G_DISABLE_ASSERT` when compiling the application.

 */

/**

 * g_assert_true:

 * @expr: the expression to check

 *

 * Debugging macro to check that an expression is true.

 *

 * If the assertion fails (i.e. the expression is not true),

 * an error message is logged and the application is either

 * terminated or the testcase marked as failed.

 *

 * See g_test_set_nonfatal_assertions().

 *

 * Since: 2.38

 */

/**

 * g_assert_false:

 * @expr: the expression to check

 *

 * Debugging macro to check an expression is false.

 *

 * If the assertion fails (i.e. the expression is not false),

 * an error message is logged and the application is either

 * terminated or the testcase marked as failed.

 *

 * See g_test_set_nonfatal_assertions().

 *

 * Since: 2.38

 */

/**

 * g_assert_null:

 * @expr: the expression to check

 *

 * Debugging macro to check an expression is %NULL.

 *

 * If the assertion fails (i.e. the expression is not %NULL),

 * an error message is logged and the application is either

 * terminated or the testcase marked as failed.

 *

 * See g_test_set_nonfatal_assertions().

 *

 * Since: 2.38

 */

/**

 * g_assert_nonnull:

 * @expr: the expression to check

 *

 * Debugging macro to check an expression is not %NULL.

 *

 * If the assertion fails (i.e. the expression is %NULL),

 * an error message is logged and the application is either

 * terminated or the testcase marked as failed.

 *

 * See g_test_set_nonfatal_assertions().

 *

 * Since: 2.40

 */

/**

 * g_assert_cmpstr:

 * @s1: a string (may be %NULL)

 * @cmp: The comparison operator to use.

 *     One of ==, !=, <, >, <=, >=.

 * @s2: another string (may be %NULL)

 *

 * Debugging macro to compare two strings. If the comparison fails,

 * an error message is logged and the application is either terminated

 * or the testcase marked as failed.

 * The strings are compared using g_strcmp0().

 *

 * The effect of `g_assert_cmpstr (s1, op, s2)` is

 * the same as `g_assert_true (g_strcmp0 (s1, s2) op 0)`.

 * The advantage of this macro is that it can produce a message that

 * includes the actual values of @s1 and @s2.

 *

 * |[ 

 *   g_assert_cmpstr (mystring, ==, "fubar");

 * ]|

 *

 * Since: 2.16

 */

/**

 * g_assert_cmpint:

 * @n1: an integer

 * @cmp: The comparison operator to use.

 *     One of ==, !=, <, >, <=, >=.

 * @n2: another integer

 *

 * Debugging macro to compare two integers.

 *

 * The effect of `g_assert_cmpint (n1, op, n2)` is

 * the same as `g_assert_true (n1 op n2)`. The advantage

 * of this macro is that it can produce a message that includes the

 * actual values of @n1 and @n2.

 *

 * Since: 2.16

 */

/**

 * g_assert_cmpuint:

 * @n1: an unsigned integer

 * @cmp: The comparison operator to use.

 *     One of ==, !=, <, >, <=, >=.

 * @n2: another unsigned integer

 *

 * Debugging macro to compare two unsigned integers.

 *

 * The effect of `g_assert_cmpuint (n1, op, n2)` is

 * the same as `g_assert_true (n1 op n2)`. The advantage

 * of this macro is that it can produce a message that includes the

 * actual values of @n1 and @n2.

 *

 * Since: 2.16

 */

/**

 * g_assert_cmphex:

 * @n1: an unsigned integer

 * @cmp: The comparison operator to use.

 *     One of ==, !=, <, >, <=, >=.

 * @n2: another unsigned integer

 *

 * Debugging macro to compare to unsigned integers.

 *

 * This is a variant of g_assert_cmpuint() that displays the numbers

 * in hexadecimal notation in the message.

 *

 * Since: 2.16

 */

/**

 * g_assert_cmpfloat:

 * @n1: an floating point number

 * @cmp: The comparison operator to use.

 *     One of ==, !=, <, >, <=, >=.

 * @n2: another floating point number

 *

 * Debugging macro to compare two floating point numbers.

 *

 * The effect of `g_assert_cmpfloat (n1, op, n2)` is

 * the same as `g_assert_true (n1 op n2)`. The advantage

 * of this macro is that it can produce a message that includes the

 * actual values of @n1 and @n2.

 *

 * Since: 2.16

 */

/**

 * g_assert_cmpmem:

 * @m1: pointer to a buffer

 * @l1: length of @m1

 * @m2: pointer to another buffer

 * @l2: length of @m2

 *

 * Debugging macro to compare memory regions. If the comparison fails,

 * an error message is logged and the application is either terminated

 * or the testcase marked as failed.

 *

 * The effect of `g_assert_cmpmem (m1, l1, m2, l2)` is

 * the same as `g_assert_true (l1 == l2 && memcmp (m1, m2, l1) == 0)`.

 * The advantage of this macro is that it can produce a message that

 * includes the actual values of @l1 and @l2.

 *

 * |[

 *   g_assert_cmpmem (buf->data, buf->len, expected, sizeof (expected));

 * ]|

 *

 * Since: 2.46

 */

/**

 * g_assert_no_error:

 * @err: a #GError, possibly %NULL

 *

 * Debugging macro to check that a #GError is not set.

 *

 * The effect of `g_assert_no_error (err)` is

 * the same as `g_assert_true (err == NULL)`. The advantage

 * of this macro is that it can produce a message that includes

 * the error message and code.

 *

 * Since: 2.20

 */

/**

 * g_assert_error:

 * @err: a #GError, possibly %NULL

 * @dom: the expected error domain (a #GQuark)

 * @c: the expected error code

 *

 * Debugging macro to check that a method has returned

 * the correct #GError.

 *

 * The effect of `g_assert_error (err, dom, c)` is

 * the same as `g_assert_true (err != NULL && err->domain

 * == dom && err->code == c)`. The advantage of this

 * macro is that it can produce a message that includes the incorrect

 * error message and code.

 *

 * This can only be used to test for a specific error. If you want to

 * test that @err is set, but don't care what it's set to, just use

 * `g_assert (err != NULL)`

 *

 * Since: 2.20

 */

/**

 * GTestCase:

 *

 * An opaque structure representing a test case.

 */

/**

 * GTestSuite:

 *

 * An opaque structure representing a test suite.

 */

/* Global variable for storing assertion messages; this is the counterpart to

 * glibc's (private) __abort_msg variable, and allows developers and crash

 * analysis systems like Apport and ABRT to fish out assertion messages from

 * core dumps, instead of having to catch them on screen output.

 */

GLIB_VAR char *__glib_assert_msg;

char *__glib_assert_msg = NULL;

/* --- constants --- */

#define G_TEST_STATUS_TIMED_OUT 1024

/* --- 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);

static const char * const g_test_result_names[] = {

  "OK",

  "SKIP",

  "FAIL",

  "TODO"

};

/* --- variables --- */

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 GSList    **test_filename_free_list;

static guint       test_run_forks = 0;

static guint       test_run_count = 0;

static guint       test_count = 0;

static guint       test_skipped_count = 0;

static GTestResult test_run_success = G_TEST_RUN_FAILURE;

static gchar      *test_run_msg = NULL;

static guint       test_startup_skip_count = 0;

static GTimer     *test_user_timer = NULL;

static double      test_user_stamp = 0;

static GSList     *test_paths = NULL;

static GSList     *test_paths_skipped = NULL;

static GTestSuite *test_suite_root = NULL;

static int         test_trap_last_status = 0;  /* unmodified platform-specific status */

static GPid        test_trap_last_pid = 0;

static char       *test_trap_last_subprocess = NULL;

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 gboolean    test_tap_log = FALSE;

static gboolean    test_nonfatal_assertions = FALSE;

static DestroyEntry *test_destroy_queue = NULL;

static char       *test_argv0 = NULL;

static char       *test_argv0_dirname;

static const char *test_disted_files_dir;

static const char *test_built_files_dir;

static char       *test_initial_cwd = NULL;

static gboolean    test_in_forked_child = FALSE;

static gboolean    test_in_subprocess = FALSE;

static GTestConfig mutable_test_config_vars = {

  FALSE,        /* test_initialized */

  TRUE,         /* test_quick */

  FALSE,        /* test_perf */

  FALSE,        /* test_verbose */

  FALSE,        /* test_quiet */

  TRUE,         /* test_undefined */

};

const GTestConfig * const g_test_config_vars = &mutable_test_config_vars;

static gboolean  no_g_set_prgname = FALSE;

/* --- functions --- */

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";

    case G_TEST_LOG_START_SUITE:        return "start suite";

    case G_TEST_LOG_STOP_SUITE:         return "stop suite";

    }

  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++)

            {

              if ((long double) (long) msg->nums[ui] == msg->nums[ui])

                g_printerr ("%s%ld", ui ? ";" : "", (long) msg->nums[ui]);

              else

                g_printerr ("%s%.16g", ui ? ";" : "", (double) 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,