/*

 * 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., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301 USA.

 *

 * Copyright 2014 Red Hat, Inc.

 */

#ifndef __NM_TEST_UTILS_H__

#define __NM_TEST_UTILS_H__

/*******************************************************************************

 * HOWTO run tests.

 *

 * Our tests (make check) include this header-only file nm-test-utils.h.

 *

 * Logging:

 *   In tests, nm-logging redirects to glib logging. By default, glib suppresses all debug

 *   messages unless you set G_MESSAGES_DEBUG. To enable debug logging, you can explicitly set

 *   G_MESSAGES_DEBUG. Otherwise, nm-test will set G_MESSAGES_DEBUG=all in debug mode (see below).

 *   For nm-logging, you can configure the log-level and domains via NMTST_DEBUG environment

 *   variable.

 *

 * Assert-logging:

 *   Some tests assert against logged messages (g_test_expect_message()).

 *   By specifying no-expect-message in NMTST_DEBUG, you can disable assert logging

 *   and g_test_assert_expected_messages() will not fail.

 *

 * NMTST_SEED_RAND environment variable:

 *   Tests that use random numbers from nmtst_get_rand() get seeded randomly at each start.

 *   You can specify the seed by setting NMTST_SEED_RAND. Also, tests will print the seed

 *   to stdout, so that you know the chosen seed.

 *

 *

 * NMTST_DEBUG environment variable:

 *

 * "debug", "no-debug": when at test is run in debug mode, it might behave differently,

 *   depending on the test. See nmtst_is_debug().

 *   Known differences:

 *    - a test might leave the logging level unspecified. In this case, running in

 *      debug mode, will turn on DEBUG logging, otherwise WARN logging only.

 *    - if G_MESSAGES_DEBUG is unset, nm-test will set G_MESSAGES_DEBUG=all

 *      for tests that don't do assert-logging.

 *   Debug mode is determined as follows (highest priority first):

 *    - command line option --debug/--no-debug

 *    - NMTST_DEBUG=debug/no-debug

 *    - setting NMTST_DEBUG implies debugging turned on

 *    - g_test_verbose()

 *

 * "no-expect-message": for tests that would assert against log messages, disable

 *   those asserts.

 *

 * "log-level=LEVEL", "log-domains=DOMAIN": reset the log level and domain for tests.

 *    It only has an effect for nm-logging messages.

 *    This has no effect if the test asserts against logging (unless no-expect-message),

 *    otherwise, changing the logging would break tests.

 *    If you set the level to DEBUG or TRACE, it also sets G_MESSAGES_DEBUG=all (unless

 *    in assert-logging mode and unless G_MESSAGES_DEBUG is already defined).

 *

 * "TRACE", this is shorthand for "log-level=TRACE".

 *

 * "D", this is shorthand for "log-level=TRACE,no-expect-message".

 *

 * "sudo-cmd=PATH": when running root tests as normal user, the test will execute

 *   itself by invoking sudo at PATH.

 *   For example

 *     NMTST_DEBUG="sudo-cmd=$PWD/tools/test-sudo-wrapper.sh" make -C src/platform/tests/ check

 *

 * "slow|quick|thorough": enable/disable long-running tests. This sets nmtst_test_quick().

 *   Whether long-running tests are enabled is determined as follows (highest priority first):

 *     - specifying the value in NMTST_DEBUG has highest priority

 *     - respect g_test_quick(), if the command line contains '-mslow', '-mquick', '-mthorough'.

 *     - use compile time default (CFLAGS=-DNMTST_TEST_QUICK=TRUE)

 *     - enable slow tests by default

 *

 * "p=PATH"|"s=PATH": passes the path to g_test_init() as "-p" and "-s", respectively.

 *   Unfortunately, these options conflict with "--tap" which our makefile passes to the

 *   tests, thus it's only useful outside of `make check`.

 *

 *******************************************************************************/

#include "nm-default.h"

#if defined(NM_ASSERT_NO_MSG) && NM_ASSERT_NO_MSG

#undef g_return_if_fail_warning

#undef g_assertion_message_expr

#endif

#include <arpa/inet.h>

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include "nm-utils.h"

/*****************************************************************************/

#define NMTST_G_RETURN_MSG_S(expr) "*: assertion '"NM_ASSERT_G_RETURN_EXPR(expr)"' failed"

#define NMTST_G_RETURN_MSG(expr)   NMTST_G_RETURN_MSG_S(#expr)

/*****************************************************************************/

/* general purpose functions that have no dependency on other nmtst functions */

#define nmtst_assert_error(error, expect_error_domain, expect_error_code, expect_error_pattern) \

	G_STMT_START { \

		GError *_error = (error); \

		GQuark _expect_error_domain = (expect_error_domain); \

		const char *_expect_error_pattern = (expect_error_pattern); \

		\

		if (_expect_error_domain) \

			g_assert_error (_error, _expect_error_domain, (expect_error_code)); \

		else \

			g_assert (_error); \

		g_assert (_error->message); \

		if (   _expect_error_pattern \

		    && !g_pattern_match_simple (_expect_error_pattern, _error->message)) { \

			g_error ("%s:%d: error message does not have expected pattern '%s'. Instead it is '%s' (%s, %d)", \

			         __FILE__, __LINE__, \

			         _expect_error_pattern, _error->message, g_quark_to_string (_error->domain), _error->code); \

		} \

	} G_STMT_END

#define NMTST_WAIT(max_wait_ms, wait) \

	({ \

		gboolean _not_expired = TRUE; \

		const gint64 nmtst_wait_start_us = g_get_monotonic_time (); \

		const gint64 nmtst_wait_duration_us = (max_wait_ms) * 1000L; \

		const gint64 nmtst_wait_end_us = nmtst_wait_start_us + nmtst_wait_duration_us; \

		\

		while (TRUE) { \

			{ wait }; \

			if (g_get_monotonic_time () > nmtst_wait_end_us) { \

				_not_expired = FALSE; \

				break; \

			} \

		} \

		_not_expired; \

	})

#define NMTST_WAIT_ASSERT(max_wait_ms, wait) \

	G_STMT_START { \

		if (!(NMTST_WAIT (max_wait_ms, wait))) \

			g_assert_not_reached (); \

	} G_STMT_END

#define nmtst_assert_success(success, error) \

	G_STMT_START { \

		g_assert_no_error (error); \

		g_assert ((success)); \

	} G_STMT_END

#define nmtst_assert_no_success(success, error) \

	G_STMT_START { \

		g_assert (error); \

		g_assert (!(success)); \

	} G_STMT_END

/*****************************************************************************/

struct __nmtst_internal

{

	GRand *rand0;

	guint32 rand_seed;

	GRand *rand;

	gboolean is_debug;

	gboolean assert_logging;

	gboolean no_expect_message;

	gboolean test_quick;

	gboolean test_tap_log;

	char *sudo_cmd;

	char **orig_argv;

};

extern struct __nmtst_internal __nmtst_internal;

#define NMTST_DEFINE() \

struct __nmtst_internal __nmtst_internal = { 0 }; \

\

__attribute__ ((destructor)) static void \

_nmtst_exit (void) \

{ \

	__nmtst_internal.assert_logging = FALSE; \

	g_test_assert_expected_messages (); \

	nmtst_free (); \

}

static inline gboolean

nmtst_initialized (void)

{

	return !!__nmtst_internal.rand0;

}

#define __NMTST_LOG(cmd, ...) \

	G_STMT_START { \

		g_assert (nmtst_initialized ()); \

		if (!__nmtst_internal.assert_logging || __nmtst_internal.no_expect_message) { \

			cmd (__VA_ARGS__); \

		} else { \

			printf (_NM_UTILS_MACRO_FIRST (__VA_ARGS__) "\n" _NM_UTILS_MACRO_REST (__VA_ARGS__)); \

		} \

	} G_STMT_END

/* split the string inplace at specific delimiters, allowing escaping with '\\'.

 * Returns a zero terminated array of pointers into @str.

 *

 * The caller must g_free() the returned argv array.

 **/

static inline char **

nmtst_str_split (char *str, const char *delimiters)

{

	const char *d;

	GArray *result = g_array_sized_new (TRUE, FALSE, sizeof (char *), 3);

	g_assert (str);

	g_assert (delimiters && !strchr (delimiters, '\\'));

	while (*str) {

		gsize i = 0, j = 0;

		while (TRUE) {

			char c = str[i];

			if (c == '\0') {

				str[j++] = 0;

				break;

			} else if (c == '\\') {

				str[j++] = str[++i];

				if (!str[i])

					break;

			} else {

				for (d = delimiters; *d; d++) {

					if (c == *d) {

						str[j++] = 0;

						i++;

						goto BREAK_INNER_LOOPS;

					}

				}

				str[j++] = c;

			}

			i++;

		}

BREAK_INNER_LOOPS:

		g_array_append_val (result, str);

		str = &str[i];

	}

	return (char **) g_array_free (result, FALSE);

}

/* free instances allocated by nmtst (especially nmtst_init()) on shutdown

 * to release memory. After nmtst_free(), the test is uninitialized again. */

static inline void

nmtst_free (void)

{

	if (!nmtst_initialized ())

		return;

	g_rand_free (__nmtst_internal.rand0);

	if (__nmtst_internal.rand)

		g_rand_free (__nmtst_internal.rand);

	g_free (__nmtst_internal.sudo_cmd);

	g_strfreev (__nmtst_internal.orig_argv);

	memset (&__nmtst_internal, 0, sizeof (__nmtst_internal));

}

static inline void

_nmtst_log_handler (const gchar   *log_domain,

                    GLogLevelFlags log_level,

                    const gchar   *message,

                    gpointer       user_data)

{

	g_print ("%s\n", message);

}

static inline void

__nmtst_init (int *argc, char ***argv, gboolean assert_logging, const char *log_level, const char *log_domains, gboolean *out_set_logging)

{

	const char *nmtst_debug;

	gboolean is_debug = FALSE;

	char *c_log_level = NULL, *c_log_domains = NULL;

	char *sudo_cmd = NULL;

	GArray *debug_messages = g_array_new (TRUE, FALSE, sizeof (char *));

	int i;

	gboolean no_expect_message = FALSE;

	gboolean _out_set_logging;

	gboolean test_quick = FALSE;

	gboolean test_quick_set = FALSE;

	gboolean test_quick_argv = FALSE;

	gs_unref_ptrarray GPtrArray *p_tests = NULL;

	gs_unref_ptrarray GPtrArray *s_tests = NULL;

	if (!out_set_logging)

		out_set_logging = &_out_set_logging;

	*out_set_logging = FALSE;

	g_assert (!nmtst_initialized ());

	g_assert (!((!!argc) ^ (!!argv)));

	g_assert (!argc || (g_strv_length (*argv) == *argc));

	g_assert (!assert_logging || (!log_level && !log_domains));

#ifdef __NETWORKMANAGER_UTILS_H__

	if (!nm_utils_get_testing_initialized ())

		_nm_utils_set_testing (_NM_UTILS_TEST_GENERAL);

#endif

	if (argc)

		__nmtst_internal.orig_argv = g_strdupv (*argv);

	__nmtst_internal.assert_logging = !!assert_logging;

	nm_g_type_init ();

	is_debug = g_test_verbose ();

	nmtst_debug = g_getenv ("NMTST_DEBUG");

	if (nmtst_debug) {

		char **d_argv, **i_argv, *nmtst_debug_copy;

		/* By setting then NMTST_DEBUG variable, @is_debug is set automatically.

		 * This can be reverted with no-debug (on command line or environment variable). */

		is_debug = TRUE;

		nmtst_debug_copy = g_strdup (nmtst_debug);

		d_argv = nmtst_str_split (nmtst_debug_copy, ",; \t\r\n");

		for (i_argv = d_argv; *i_argv; i_argv++) {

			const char *debug = *i_argv;

			if (!g_ascii_strcasecmp (debug, "debug"))

				is_debug = TRUE;

			else if (!g_ascii_strcasecmp (debug, "no-debug")) {

				/* when specifying the NMTST_DEBUG variable, we set is_debug to true. Use this flag to disable this

				 * (e.g. for only setting the log-level, but not is_debug). */

				is_debug = FALSE;

			} else if (!g_ascii_strncasecmp (debug, "log-level=", strlen ("log-level="))) {

				g_free (c_log_level);

				log_level = c_log_level = g_strdup (&debug[strlen ("log-level=")]);

			} else if (!g_ascii_strcasecmp (debug, "D")) {

				/* shorthand for "log-level=TRACE,no-expect-message" */

				g_free (c_log_level);

				log_level = c_log_level = g_strdup ("TRACE");

				no_expect_message = TRUE;

			} else if (!g_ascii_strcasecmp (debug, "TRACE")) {

				g_free (c_log_level);

				log_level = c_log_level = g_strdup ("TRACE");

			} else if (!g_ascii_strncasecmp (debug, "log-domains=", strlen ("log-domains="))) {

				g_free (c_log_domains);

				log_domains = c_log_domains = g_strdup (&debug[strlen ("log-domains=")]);

			} else if (!g_ascii_strncasecmp (debug, "sudo-cmd=", strlen ("sudo-cmd="))) {

				g_free (sudo_cmd);

				sudo_cmd = g_strdup (&debug[strlen ("sudo-cmd=")]);

			} else if (!g_ascii_strcasecmp (debug, "no-expect-message")) {

				no_expect_message = TRUE;

			} else if (!g_ascii_strncasecmp (debug, "p=", strlen ("p="))) {

				if (!p_tests)

					p_tests = g_ptr_array_new_with_free_func (g_free);

				g_ptr_array_add (p_tests, g_strdup (&debug[strlen ("p=")]));

			} else if (!g_ascii_strncasecmp (debug, "s=", strlen ("s="))) {

				if (!s_tests)

					s_tests = g_ptr_array_new_with_free_func (g_free);

				g_ptr_array_add (s_tests, g_strdup (&debug[strlen ("s=")]));

			} else if (!g_ascii_strcasecmp (debug, "slow") || !g_ascii_strcasecmp (debug, "thorough")) {

				test_quick = FALSE;

				test_quick_set = TRUE;

			} else if (!g_ascii_strcasecmp (debug, "quick")) {

				test_quick = TRUE;

				test_quick_set = TRUE;

			} else {

				char *msg = g_strdup_printf (">>> nmtst: ignore unrecognized NMTST_DEBUG option \"%s\"", debug);

				g_array_append_val (debug_messages, msg);

			}

		}

		g_free (d_argv);

		g_free (nmtst_debug_copy);

	}

	if (__nmtst_internal.orig_argv) {

		char **a = __nmtst_internal.orig_argv;

		for (; *a; a++) {

			if (!g_ascii_strcasecmp (*a, "--debug"))

				is_debug = TRUE;

			else if (!g_ascii_strcasecmp (*a, "--no-debug"))

				is_debug = FALSE;

			else if (   !strcmp (*a, "-m=slow")

			         || !strcmp (*a, "-m=thorough")

			         || !strcmp (*a, "-m=quick")

			         || (!strcmp (*a, "-m") && *(a+1)

			                                && (   !strcmp (*(a+1), "quick")

			                                    || !strcmp (*(a+1), "slow")

			                                    || !strcmp (*(a+1), "thorough"))))

				test_quick_argv = TRUE;

			else if (strcmp (*a, "--tap") == 0)

				__nmtst_internal.test_tap_log = TRUE;

		}

	}

	if (!argc || g_test_initialized ()) {

		if (p_tests || s_tests) {

			char *msg = g_strdup_printf (">>> nmtst: ignore -p and -s options for test which calls g_test_init() itself");

			g_array_append_val (debug_messages, msg);

		}

	} else {

		/* We're intentionally assigning a value to static variables

		 * s_tests_x and p_tests_x without using it afterwards, just

		 * so that valgrind doesn't complain about the leak. */

		NM_PRAGMA_WARNING_DISABLE("-Wunused-but-set-variable")

		/* g_test_init() is a variadic function, so we cannot pass it

		 * (variadic) arguments. If you need to pass additional parameters,

		 * call nmtst_init() with argc==NULL and call g_test_init() yourself. */

		/* g_test_init() sets g_log_set_always_fatal() for G_LOG_LEVEL_WARNING

		 * and G_LOG_LEVEL_CRITICAL. So, beware that the test will fail if you

		 * have any WARN or ERR log messages -- unless you g_test_expect_message(). */

		GPtrArray *arg_array = g_ptr_array_new ();

		gs_free char **arg_array_c = NULL;

		int arg_array_n, j;

		static char **s_tests_x, **p_tests_x;

		if (*argc) {

			for (i = 0; i < *argc; i++)

				g_ptr_array_add (arg_array, (*argv)[i]);

		} else

			g_ptr_array_add (arg_array, "./test");

		if (test_quick_set && !test_quick_argv)

			g_ptr_array_add (arg_array, "-m=quick");

		if (!__nmtst_internal.test_tap_log) {

			for (i = 0; p_tests && i < p_tests->len; i++) {

				g_ptr_array_add (arg_array, "-p");

				g_ptr_array_add (arg_array, p_tests->pdata[i]);

			}

			for (i = 0; s_tests && i < s_tests->len; i++) {

				g_ptr_array_add (arg_array, "-s");

				g_ptr_array_add (arg_array, s_tests->pdata[i]);

			}

		} else if (p_tests || s_tests) {

			char *msg = g_strdup_printf (">>> nmtst: ignore -p and -s options for tap-tests");

			g_array_append_val (debug_messages, msg);

		}

		g_ptr_array_add (arg_array, NULL);

		arg_array_n = arg_array->len - 1;

		arg_array_c = (char **) g_ptr_array_free (arg_array, FALSE);

		g_test_init (&arg_array_n, &arg_array_c, NULL);

		if (*argc > 1) {

			/* collaps argc/argv by removing the arguments detected

			 * by g_test_init(). */

			for (i = 1, j = 1; i < *argc; i++) {

				if ((*argv)[i] == arg_array_c[j])

					j++;

				else

					(*argv)[i] = NULL;

			}

			for (i = 1, j = 1; i < *argc; i++) {

				if ((*argv)[i]) {

					(*argv)[j++] = (*argv)[i];

					if (i >= j)

						(*argv)[i] = NULL;

				}

			}

			*argc = j;

		}

		/* we must "leak" the test paths because they are not cloned by g_test_init(). */

		if (!__nmtst_internal.test_tap_log) {

			if (p_tests) {

				p_tests_x = (char **) g_ptr_array_free (p_tests, FALSE);

				p_tests = NULL;

			}

			if (s_tests) {

				s_tests_x = (char **) g_ptr_array_free (s_tests, FALSE);

				s_tests = NULL;

			}

		}

		NM_PRAGMA_WARNING_REENABLE

	}

	if (test_quick_set)

		__nmtst_internal.test_quick = test_quick;

	else if (test_quick_argv)

		__nmtst_internal.test_quick = g_test_quick ();

	else {

#ifdef NMTST_TEST_QUICK

		__nmtst_internal.test_quick = NMTST_TEST_QUICK;

#else

		__nmtst_internal.test_quick = FALSE;

#endif

	}

	__nmtst_internal.is_debug = is_debug;

	__nmtst_internal.rand0 = g_rand_new_with_seed (0);

	__nmtst_internal.sudo_cmd = sudo_cmd;

	__nmtst_internal.no_expect_message = no_expect_message;

	if (!log_level && log_domains) {

		/* if the log level is not specified (but the domain is), we assume

		 * the caller wants to set it depending on is_debug */

		log_level = is_debug ? "DEBUG" : "WARN";

	}

	if (!__nmtst_internal.assert_logging) {

		gboolean success = TRUE;

#ifdef _NMTST_INSIDE_CORE

		success = nm_logging_setup (log_level, log_domains, NULL, NULL);

		*out_set_logging = TRUE;

#endif

		g_assert (success);

#if GLIB_CHECK_VERSION(2,34,0)

		if (__nmtst_internal.no_expect_message)

			g_log_set_always_fatal (G_LOG_FATAL_MASK);

#else

		/* g_test_expect_message() is a NOP, so allow any messages */

		g_log_set_always_fatal (G_LOG_FATAL_MASK);

#endif

	} else if (__nmtst_internal.no_expect_message) {

		/* We have a test that would be assert_logging, but the user specified no_expect_message.

		 * This transforms g_test_expect_message() into a NOP, but we also have to relax

		 * g_log_set_always_fatal(), which was set by g_test_init(). */

		g_log_set_always_fatal (G_LOG_FATAL_MASK);

#ifdef _NMTST_INSIDE_CORE

		if (c_log_domains || c_log_level) {

			/* Normally, tests with assert_logging do not overwrite the logging level/domains because

			 * the logging statements are part of the assertions. But if the test is run with

			 * no-expect-message *and* the logging is set explicitly via environment variables,

			 * we still reset the logging. */

			gboolean success;

			success = nm_logging_setup (log_level, log_domains, NULL, NULL);

			*out_set_logging = TRUE;

			g_assert (success);

		}

#endif

	} else {

#if GLIB_CHECK_VERSION(2,34,0)

		/* We were called not to set logging levels. This means, that the user

		 * expects to assert against (all) messages. Any uncought message is fatal. */

		g_log_set_always_fatal (G_LOG_LEVEL_MASK);

#else

		/* g_test_expect_message() is a NOP, so allow any messages */

		g_log_set_always_fatal (G_LOG_FATAL_MASK);

#endif

	}

	if ((!__nmtst_internal.assert_logging || (__nmtst_internal.assert_logging && __nmtst_internal.no_expect_message)) &&

	    (is_debug || (c_log_level && (!g_ascii_strcasecmp (c_log_level, "DEBUG") || !g_ascii_strcasecmp (c_log_level, "TRACE")))) &&

	    !g_getenv ("G_MESSAGES_DEBUG"))

	{

		/* if we are @is_debug or @log_level=="DEBUG" and

		 * G_MESSAGES_DEBUG is unset, we set G_MESSAGES_DEBUG=all.

		 * To disable this default behaviour, set G_MESSAGES_DEBUG='' */

		/* Note that g_setenv is not thread safe, but you should anyway call

		 * nmtst_init() at the very start. */

		g_setenv ("G_MESSAGES_DEBUG", "all", TRUE);

	}

	/* Delay messages until we setup logging. */

	for (i = 0; i < debug_messages->len; i++)

		__NMTST_LOG (g_message, "%s", g_array_index (debug_messages, const char *, i));

	g_strfreev ((char **) g_array_free (debug_messages, FALSE));

	g_free (c_log_level);

	g_free (c_log_domains);

#ifdef __NETWORKMANAGER_UTILS_H__

	/* ensure that monotonic timestamp is called (because it initially logs a line) */

	nm_utils_get_monotonic_timestamp_s ();

#endif

#ifdef NM_UTILS_H

	{

		gs_free_error GError *error = NULL;

		if (!nm_utils_init (&error))

			g_assert_not_reached ();

		g_assert_no_error (error);

	}

#endif

	g_log_set_handler (G_LOG_DOMAIN,

	                   G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL | G_LOG_FLAG_RECURSION,

	                   _nmtst_log_handler,

	                   NULL);

}

#ifndef _NMTST_INSIDE_CORE

static inline void

nmtst_init (int *argc, char ***argv, gboolean assert_logging)

{

	__nmtst_init (argc, argv, assert_logging, NULL, NULL, NULL);

}

#endif

static inline gboolean

nmtst_is_debug (void)

{

	g_assert (nmtst_initialized ());

	return __nmtst_internal.is_debug;

}

static inline gboolean

nmtst_test_quick (void)

{

	g_assert (nmtst_initialized ());

	return __nmtst_internal.test_quick;

}

#if GLIB_CHECK_VERSION(2,34,0)

#undef g_test_expect_message

#define g_test_expect_message(...) \

	G_STMT_START { \

		g_assert (nmtst_initialized ()); \

		if (__nmtst_internal.assert_logging && __nmtst_internal.no_expect_message) { \

			g_debug ("nmtst: assert-logging: g_test_expect_message %s", G_STRINGIFY ((__VA_ARGS__))); \

		} else { \

			G_GNUC_BEGIN_IGNORE_DEPRECATIONS \

			g_test_expect_message (__VA_ARGS__); \

			G_GNUC_END_IGNORE_DEPRECATIONS \

		} \

	} G_STMT_END

#undef g_test_assert_expected_messages_internal

#define g_test_assert_expected_messages_internal(domain, file, line, func) \

	G_STMT_START { \

		const char *_domain = (domain); \

		const char *_file = (file); \

		const char *_func = (func); \

		int _line = (line); \

		\

		if (__nmtst_internal.assert_logging && __nmtst_internal.no_expect_message) \

			g_debug ("nmtst: assert-logging: g_test_assert_expected_messages(%s, %s:%d, %s)", _domain?:"", _file?:"", _line, _func?:""); \

		\

		G_GNUC_BEGIN_IGNORE_DEPRECATIONS \

		g_test_assert_expected_messages_internal (_domain, _file, _line, _func); \

		G_GNUC_END_IGNORE_DEPRECATIONS \

	} G_STMT_END

#endif

/*****************************************************************************/

typedef struct _NmtstTestData NmtstTestData;

typedef void (*NmtstTestHandler) (const NmtstTestData *test_data);

struct _NmtstTestData {

	union {

		const char *testpath;

		char *_testpath;

	};

	gsize n_args;

	gpointer *args;

	NmtstTestHandler _func_setup;

	GTestDataFunc _func_test;

	NmtstTestHandler _func_teardown;

};

static inline void

_nmtst_test_data_unpack (const NmtstTestData *test_data, gsize n_args, ...)

{

	gsize i;

	va_list ap;

	gpointer *p;

	g_assert (test_data);

	g_assert_cmpint (n_args, ==, test_data->n_args);

	va_start (ap, n_args);

	for (i = 0; i < n_args; i++) {

		p = va_arg (ap, gpointer *);

		if (p)

			*p = test_data->args[i];

	}

	va_end (ap);

}

#define nmtst_test_data_unpack(test_data, ...) _nmtst_test_data_unpack(test_data, NM_NARG (__VA_ARGS__), ##__VA_ARGS__)

static inline void

_nmtst_test_data_free (gpointer data)

{

	NmtstTestData *test_data = data;

	g_assert (test_data);

	g_free (test_data->_testpath);

	g_free (test_data);

}

static inline void

_nmtst_test_run (gconstpointer data)

{

	const NmtstTestData *test_data = data;

	if (test_data->_func_setup)

		test_data->_func_setup (test_data);

	test_data->_func_test (test_data);

	if (test_data->_func_teardown)

		test_data->_func_teardown (test_data);

}

static inline void

_nmtst_add_test_func_full (const char *testpath, GTestDataFunc func_test, NmtstTestHandler func_setup, NmtstTestHandler func_teardown, gsize n_args, ...)

{

	gsize i;

	NmtstTestData *data;

	va_list ap;

	g_assert (testpath && testpath[0]);

	g_assert (func_test);

	data = g_malloc0 (sizeof (NmtstTestData) + (sizeof (gpointer) * (n_args + 1)));

	data->_testpath = g_strdup (testpath);

	data->_func_test = func_test;

	data->_func_setup = func_setup;

	data->_func_teardown = func_teardown;

	data->n_args = n_args;

	data->args = (gpointer) &data[1];

	va_start (ap, n_args);

	for (i = 0; i < n_args; i++)

		data->args[i] = va_arg (ap, gpointer);

	data->args[i] = NULL;

	va_end (ap);

	g_test_add_data_func_full (testpath,

	                           data,

	                           _nmtst_test_run,

	                           _nmtst_test_data_free);

}

#define nmtst_add_test_func_full(testpath, func_test, func_setup, func_teardown, ...) _nmtst_add_test_func_full(testpath, func_test, func_setup, func_teardown, NM_NARG (__VA_ARGS__), ##__VA_ARGS__)

#define nmtst_add_test_func(testpath, func_test, ...) nmtst_add_test_func_full(testpath, func_test, NULL, NULL, ##__VA_ARGS__)

/*****************************************************************************/

static inline GRand *

nmtst_get_rand0 (void)

{

	g_assert (nmtst_initialized ());

	return __nmtst_internal.rand0;

}

static inline GRand *

nmtst_get_rand (void)

{

	g_assert (nmtst_initialized ());

	if (G_UNLIKELY (!__nmtst_internal.rand)) {

		guint32 seed;

		const char *str;

		if ((str = g_getenv ("NMTST_SEED_RAND"))) {

			gchar *s;

			gint64 i;

			i = g_ascii_strtoll (str, &s, 0);

			g_assert (s[0] == '\0' && i >= 0 && i < G_MAXUINT32);

			seed = i;

			__nmtst_internal.rand = g_rand_new_with_seed (seed);

		} else {

			__nmtst_internal.rand = g_rand_new ();

			seed = g_rand_int (__nmtst_internal.rand);

			g_rand_set_seed (__nmtst_internal.rand, seed);

		}

		__nmtst_internal.rand_seed = seed;

		g_print ("\nnmtst: initialize nmtst_get_rand() with NMTST_SEED_RAND=%u\n", seed);

	}

	return __nmtst_internal.rand;

}

static inline guint32

nmtst_get_rand_int (void)

{

	return g_rand_int (nmtst_get_rand ());

}

static inline gpointer

nmtst_rand_buf (GRand *rand, gpointer buffer, gsize buffer_length)

{

	guint32 v;

	guint8 *b = buffer;

	if (!buffer_length)

		return buffer;

	g_assert (buffer);

	if (!rand)

		rand = nmtst_get_rand ();

	for (; buffer_length >= sizeof (guint32); buffer_length -= sizeof (guint32), b += sizeof (guint32)) {

		v = g_rand_int (rand);

		memcpy (b, &v, sizeof (guint32));

	}

	if (buffer_length > 0) {

		v = g_rand_int (rand);

		do {

			*(b++) = v & 0xFF;

			v >>= 8;

		} while (--buffer_length > 0);

	}

	return buffer;

}

static inline void *

nmtst_rand_perm (GRand *rand, void *dst, const void *src, gsize elmt_size, gsize n_elmt)

{

	gsize i, j;

	char *p_, *pj;

	char *bu;

	g_assert (dst);

	g_assert (elmt_size > 0);

	g_assert (n_elmt < G_MAXINT32);

	if (n_elmt == 0)

		return dst;

	if (src && dst != src)

		memcpy (dst, src, elmt_size * n_elmt);

	if (!rand)

		rand = nmtst_get_rand ();

	bu = g_slice_alloc (elmt_size);

	p_ = dst;

	for (i = n_elmt; i > 1; i--) {

		j = g_rand_int_range (rand, 0, i);

		if (j != 0) {

			pj = &p_[j * elmt_size];

			/* swap */

			memcpy (bu, p_, elmt_size);

			memcpy (p_, pj, elmt_size);

			memcpy (pj, bu, elmt_size);

		}

		p_ += elmt_size;

	}

	g_slice_free1 (elmt_size, bu);

	return dst;

}

static inline GSList *

nmtst_rand_perm_gslist (GRand *rand, GSList *list)