diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/core/nm-test-utils-core.h | 2 | ||||
| -rw-r--r-- | src/libnm-core-impl/tests/test-compare.c | 2 | ||||
| -rw-r--r-- | src/libnm-core-impl/tests/test-crypto.c | 2 | ||||
| -rw-r--r-- | src/libnm-core-impl/tests/test-general.c | 2 | ||||
| -rw-r--r-- | src/libnm-core-impl/tests/test-keyfile.c | 2 | ||||
| -rw-r--r-- | src/libnm-core-impl/tests/test-secrets.c | 2 | ||||
| -rw-r--r-- | src/libnm-core-impl/tests/test-setting.c | 2 | ||||
| -rw-r--r-- | src/libnm-core-impl/tests/test-settings-defaults.c | 2 | ||||
| -rw-r--r-- | src/libnm-glib-aux/nm-test-utils.h | 2824 | ||||
| -rw-r--r-- | src/libnm-glib-aux/tests/test-json-aux.c | 2 | ||||
| -rw-r--r-- | src/libnm-glib-aux/tests/test-shared-general.c | 2 | ||||
| -rw-r--r-- | src/libnm-platform/tests/test-nm-platform.c | 2 |
12 files changed, 2835 insertions, 11 deletions
diff --git a/src/core/nm-test-utils-core.h b/src/core/nm-test-utils-core.h index f145904ef7..e92d380e24 100644 --- a/src/core/nm-test-utils-core.h +++ b/src/core/nm-test-utils-core.h @@ -11,7 +11,7 @@ #define _NMTST_INSIDE_CORE 1 -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" /*****************************************************************************/ diff --git a/src/libnm-core-impl/tests/test-compare.c b/src/libnm-core-impl/tests/test-compare.c index fb82c55910..3716399a9a 100644 --- a/src/libnm-core-impl/tests/test-compare.c +++ b/src/libnm-core-impl/tests/test-compare.c @@ -11,7 +11,7 @@ #include "nm-property-compare.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" static void compare_ints(void) diff --git a/src/libnm-core-impl/tests/test-crypto.c b/src/libnm-core-impl/tests/test-crypto.c index 16082795cb..bdbcd0f3bd 100644 --- a/src/libnm-core-impl/tests/test-crypto.c +++ b/src/libnm-core-impl/tests/test-crypto.c @@ -15,7 +15,7 @@ #include "nm-errors.h" #include "libnm-core-intern/nm-core-internal.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" #define TEST_CERT_DIR NM_BUILD_SRCDIR "/src/libnm-core-impl/tests/certs" diff --git a/src/libnm-core-impl/tests/test-general.c b/src/libnm-core-impl/tests/test-general.c index dc794dfb08..c1465c9a12 100644 --- a/src/libnm-core-impl/tests/test-general.c +++ b/src/libnm-core-impl/tests/test-general.c @@ -64,7 +64,7 @@ #include "test-general-enums.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" /* When passing a "bool" typed argument to a variadic function that * expects a gboolean, the compiler will promote the integer type diff --git a/src/libnm-core-impl/tests/test-keyfile.c b/src/libnm-core-impl/tests/test-keyfile.c index 3b1ee09155..2e5483e6aa 100644 --- a/src/libnm-core-impl/tests/test-keyfile.c +++ b/src/libnm-core-impl/tests/test-keyfile.c @@ -16,7 +16,7 @@ #include "nm-setting-user.h" #include "nm-setting-proxy.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" #define TEST_CERT_DIR NM_BUILD_SRCDIR "/src/libnm-core-impl/tests/certs" #define TEST_WIRED_TLS_CA_CERT TEST_CERT_DIR "/test-ca-cert.pem" diff --git a/src/libnm-core-impl/tests/test-secrets.c b/src/libnm-core-impl/tests/test-secrets.c index e2a58ded3f..e371795c74 100644 --- a/src/libnm-core-impl/tests/test-secrets.c +++ b/src/libnm-core-impl/tests/test-secrets.c @@ -20,7 +20,7 @@ #include "nm-utils.h" #include "libnm-core-intern/nm-core-internal.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" #define TEST_CERT_DIR NM_BUILD_SRCDIR "/src/libnm-core-impl/tests/certs" #define TEST_NEED_SECRETS_EAP_TLS_CA_CERT TEST_CERT_DIR "/test_ca_cert.pem" diff --git a/src/libnm-core-impl/tests/test-setting.c b/src/libnm-core-impl/tests/test-setting.c index 0b622ec877..ea68a02683 100644 --- a/src/libnm-core-impl/tests/test-setting.c +++ b/src/libnm-core-impl/tests/test-setting.c @@ -28,7 +28,7 @@ #include "nm-errors.h" #include "libnm-core-intern/nm-keyfile-internal.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" #define TEST_CERT_DIR NM_BUILD_SRCDIR "/src/libnm-core-impl/tests/certs" diff --git a/src/libnm-core-impl/tests/test-settings-defaults.c b/src/libnm-core-impl/tests/test-settings-defaults.c index e04a55ec7a..b9db71074a 100644 --- a/src/libnm-core-impl/tests/test-settings-defaults.c +++ b/src/libnm-core-impl/tests/test-settings-defaults.c @@ -20,7 +20,7 @@ #include "nm-setting-wireless.h" #include "nm-setting-wireless-security.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" static void test_defaults(GType type, const char *name) diff --git a/src/libnm-glib-aux/nm-test-utils.h b/src/libnm-glib-aux/nm-test-utils.h new file mode 100644 index 0000000000..cf884f9c41 --- /dev/null +++ b/src/libnm-glib-aux/nm-test-utils.h @@ -0,0 +1,2824 @@ +/* SPDX-License-Identifier: LGPL-2.1-or-later */ +/* + * Copyright (C) 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. + * + * You should always include this header *as last*. Reason is, that depending on + * previous includes, functionality will be enabled. + * + * 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 at each start. + * You can specify the seed by setting NMTST_SEED_RAND to a particular number or empty ("") + * for a random one. If NMTST_SEED_RAND is not set (default) a stable seed gets chosen. + * Tests will print the seed to stdout, so that you know which one was chosen or generated. + * + * + * 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`. + * + *******************************************************************************/ + +#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> + +/*****************************************************************************/ + +#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; \ + gint64 _nmtst_wait_remaining_us = nmtst_wait_duration_us; \ + int _nmtst_wait_iteration = 0; \ + \ + while (TRUE) { \ + _nm_unused const gint64 nmtst_wait_remaining_us = _nmtst_wait_remaining_us; \ + _nm_unused int nmtst_wait_iteration = _nmtst_wait_iteration++; \ + \ + {wait}; \ + _nmtst_wait_remaining_us = (nmtst_wait_end_us - g_get_monotonic_time()); \ + if (_nmtst_wait_remaining_us <= 0) { \ + _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_nonnull(command) \ + ({ \ + typeof(*(command)) *_ptr = (command); \ + \ + g_assert(_ptr && (TRUE || (command))); \ + _ptr; \ + }) + +#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 + +/*****************************************************************************/ + +/* Our nm-error error numbers use negative values to signal failure. + * A non-negative value signals success. Hence, the correct way for checking + * is always (r < 0) vs. (r >= 0). Never (r == 0). + * + * For assertions in tests, we also want to assert that no positive values + * are returned. For a lot of functions, positive return values are unexpected + * and a bug. This macro evaluates @r to success or failure, while asserting + * that @r is not positive. */ +#define NMTST_NM_ERR_SUCCESS(r) \ + ({ \ + const int _r = (r); \ + \ + if (_r >= 0) \ + g_assert_cmpint(_r, ==, 0); \ + (_r >= 0); \ + }) + +/*****************************************************************************/ + +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 char * log_domain, + GLogLevelFlags log_level, + const char * 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 uncaught message on >debug level is fatal. */ + g_log_set_always_fatal(G_LOG_LEVEL_MASK & ~G_LOG_LEVEL_DEBUG); +#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); + } + + /* "tc" is in /sbin, which might not be in $PATH of a regular user. Unconditionally + * add "/bin" and "/sbin" to $PATH for all tests. */ + { + static char *path_new; + const char * path_old; + + g_assert(!path_new); + + path_old = g_getenv("PATH"); + path_new = g_strjoin("", + path_old ?: "", + (nm_str_is_empty(path_old) ? "" : ":"), + "/bin:/sbin", + NULL); + g_setenv("PATH", path_new, 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_sec(); +#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 + +#define NMTST_EXPECT(domain, level, msg) g_test_expect_message(domain, level, msg) + +#define NMTST_EXPECT_LIBNM(level, msg) NMTST_EXPECT("nm", level, msg) + +#define NMTST_EXPECT_LIBNM_WARNING(msg) NMTST_EXPECT_LIBNM(G_LOG_LEVEL_WARNING, msg) +#define NMTST_EXPECT_LIBNM_CRITICAL(msg) NMTST_EXPECT_LIBNM(G_LOG_LEVEL_CRITICAL, msg) + +/*****************************************************************************/ + +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 = g_getenv("NMTST_SEED_RAND"); + + if (!str) { + /* No NMTST_SEED_RAND. Pick a stable one. */ + seed = 0; + __nmtst_internal.rand = g_rand_new_with_seed(seed); + } else if (str[0] == '\0') { + /* NMTST_SEED_RAND is set but empty. Pick a random one. */ + __nmtst_internal.rand = g_rand_new(); + + seed = g_rand_int(__nmtst_internal.rand); + g_rand_set_seed(__nmtst_internal.rand, seed); + } else { + /* NMTST_SEED_RAND is set. Use it as a seed. */ + char * 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); + } + __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_uint32(void) +{ + return g_rand_int(nmtst_get_rand()); +} + +static inline guint64 +nmtst_get_rand_uint64(void) +{ + GRand *rand = nmtst_get_rand(); + + return (((guint64) g_rand_int(rand))) | (((guint64) g_rand_int(rand)) << 32); +} + +static inline guint +nmtst_get_rand_uint(void) +{ + G_STATIC_ASSERT_EXPR((sizeof(guint) == sizeof(guint32) || (sizeof(guint) == sizeof(guint64)))); + if (sizeof(guint32) == sizeof(guint)) + return nmtst_get_rand_uint32(); + return nmtst_get_rand_uint64(); +} + +static inline gsize +nmtst_get_rand_size(void) +{ + G_STATIC_ASSERT_EXPR((sizeof(gsize) == sizeof(guint32) || (sizeof(gsize) == sizeof(guint64)))); + if (sizeof(gsize) == sizeof(guint32)) + return nmtst_get_rand_uint32(); + return nmtst_get_rand_uint64(); +} + +static inline gboolean +nmtst_get_rand_bool(void) +{ + return nmtst_get_rand_uint32() % 2; +} + +static inline gboolean +nmtst_get_rand_one_case_in(guint32 num) +{ + /* num=1 doesn't make much sense, because it will always return %TRUE. + * Still accept it, it might be that @num is calculated, so 1 might be + * a valid edge case. */ + g_assert(num > 0); + + return (nmtst_get_rand_uint32() % num) == 0; +} + +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; +} + +#define _nmtst_rand_select(uniq, v0, ...) \ + ({ \ + typeof(v0) NM_UNIQ_T(UNIQ, uniq)[1 + NM_NARG(__VA_ARGS__)] = {(v0), __VA_ARGS__}; \ + \ + NM_UNIQ_T(UNIQ, uniq)[nmtst_get_rand_uint32() % G_N_ELEMENTS(NM_UNIQ_T(UNIQ, uniq))]; \ + }) + +#define nmtst_rand_select(...) _nmtst_rand_select(NM_UNIQ, __VA_ARGS__) + +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 const char ** +nmtst_rand_perm_strv(const char *const *strv) +{ + const char **res; + gsize n; + + if (!strv) + return NULL; + + /* this returns a (scrambled) SHALLOW copy of the strv array! */ + + n = NM_PTRARRAY_LEN(strv); + res = (const char **) (nm_utils_strv_dup(strv, n, FALSE) ?: g_new0(char *, 1)); + nmtst_rand_perm(NULL, res, res, sizeof(char *), n); + return res; +} + +static inline GSList * +nmtst_rand_perm_gslist(GRand *rand, GSList *list) +{ + GSList *result; + guint l; + + if (!rand) + rand = nmtst_get_rand(); + + /* no need for an efficient implementation :) */ + + result = 0; + for (l = g_slist_length(list); l > 0; l--) { + GSList *tmp; + + tmp = g_slist_nth(list, g_rand_int(rand) % l); + g_assert(tmp); + + list = g_slist_remove_link(list, tmp); + result = g_slist_concat(tmp, result); + } + g_assert(!list); + return result; +} + +static inline void +nmtst_stable_rand(guint64 seed, gpointer buf, gsize len) +{ + const guint64 C = 1442695040888963407llu; + const guint64 A = 6364136223846793005llu; + guint8 * b; + union { + guint8 a[sizeof(guint64)]; + guint64 n; + } n; + + /* We want a stable random generator that is in our control and does not + * depend on glibc/glib versions. + * Use a linear congruential generator (x[n+1] = (A * x[n] + C) % M) + * https://en.wikipedia.org/wiki/Linear_congruential_generator + * + * We choose (Knuth’s LCG MMIX) + * A = 6364136223846793005llu + * C = 1442695040888963407llu + * M = 2^64 + */ + + g_assert(len == 0 || buf); + + n.n = seed; + b = buf; + for (; len > 0; len--, b++) { + n.n = (A * n.n + C); + + /* let's combine the 64 bits randomness in one byte. By xor-ing, it's + * also independent of endianness. */ + b[0] = n.a[0] ^ n.a[1] ^ n.a[2] ^ n.a[3] ^ n.a[4] ^ n.a[5] ^ n.a[6] ^ n.a[7]; + } +} + +/*****************************************************************************/ + +/** + * nmtst_get_rand_word_length: + * @rand: (allow-none): #GRand instance or %NULL to use the singleton. + * + * Returns: a random integer >= 0, that most frequently is somewhere between + * 0 and 16, but (with decreasing) probability, it can be larger. This can + * be used when we generate random input for unit tests. + */ +static inline guint +nmtst_get_rand_word_length(GRand *rand) +{ + guint n; + + if (!rand) + rand = nmtst_get_rand(); + + n = 0; + while (TRUE) { + guint32 rnd = g_rand_int(rand); + guint probability; + + /* The following python code implements a random sample with this + * distribution: + * + * def random_histogram(n_tries, scale = None): + * def probability(n_tok): + * import math + * return max(2, math.floor(100 / (2*(n_tok+1)))) + * def n_tokens(): + * import random + * n_tok = 0 + * while True: + * if random.randint(0, 0xFFFFFFFF) % probability(n_tok) == 0: + * return n_tok + * n_tok += 1 + * hist = [] + * i = 0; + * while i < n_tries: + * n_tok = n_tokens() + * while n_tok >= len(hist): + * hist.append(0) + * hist[n_tok] = hist[n_tok] + 1 + * i += 1 + * if scale is not None: + * hist = list([round(x / n_tries * scale) for x in hist]) + * return hist + * + * For example, random_histogram(n_tries = 1000000, scale = 1000) may give + * + * IDX: [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29] + * SEEN: [20, 39, 59, 73, 80, 91, 92, 90, 91, 73, 73, 54, 55, 36, 24, 16, 16, 8, 4, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] + * + * which give a sense of the probability with this individual results are returned. + */ + probability = NM_MAX(2u, (100u / (2u * (n + 1u)))); + if ((rnd % probability) == 0) + return n; + n++; + } +} + +/*****************************************************************************/ + +static inline gboolean +nmtst_g_source_assert_not_called(gpointer user_data) +{ + g_assert_not_reached(); + return G_SOURCE_CONTINUE; +} + +static inline gboolean +nmtst_g_source_nop(gpointer user_data) +{ + g_assert(!user_data); + return G_SOURCE_CONTINUE; +} + +static inline gboolean +nmtst_g_source_set_boolean_true(gpointer user_data) +{ + gboolean *ptr = user_data; + + g_assert(ptr); + g_assert(!*ptr); + *ptr = TRUE; + return G_SOURCE_CONTINUE; +} + +/*****************************************************************************/ + +static inline gboolean +_nmtst_main_loop_run_timeout(gpointer user_data) +{ + GMainLoop **p_loop = user_data; + + g_assert(p_loop && *p_loop); + g_main_loop_quit(g_steal_pointer(p_loop)); + return G_SOURCE_REMOVE; +} + +static inline gboolean +nmtst_main_loop_run(GMainLoop *loop, guint timeout_msec) +{ + nm_auto_unref_gsource GSource *source = NULL; + GMainLoop * loopx = loop; + + if (timeout_msec > 0) { + source = g_timeout_source_new(timeout_msec); + g_source_set_callback(source, _nmtst_main_loop_run_timeout, &loopx, NULL); + g_source_attach(source, g_main_loop_get_context(loop)); + } + + g_main_loop_run(loop); + + if (source) + g_source_destroy(source); + + /* if the timeout was reached, return FALSE. */ + return loopx != NULL; +} + +#define nmtst_main_loop_run_assert(loop, timeout_msec) \ + G_STMT_START \ + { \ + if (!nmtst_main_loop_run((loop), (timeout_msec))) \ + g_assert_not_reached(); \ + } \ + G_STMT_END + +static inline void +_nmtst_main_loop_quit_on_notify(GObject *object, GParamSpec *pspec, gpointer user_data) +{ + GMainLoop *loop = user_data; + + g_assert(G_IS_OBJECT(object)); + g_assert(loop); + + g_main_loop_quit(loop); +} +#define nmtst_main_loop_quit_on_notify ((GCallback) _nmtst_main_loop_quit_on_notify) + +#define nmtst_main_context_iterate_until_full(context, timeout_msec, poll_msec, condition) \ + ({ \ + nm_auto_destroy_and_unref_gsource GSource *_source_timeout = NULL; \ + nm_auto_destroy_and_unref_gsource GSource *_source_poll = NULL; \ + GMainContext * _context = (context); \ + gboolean _had_timeout = FALSE; \ + typeof(timeout_msec) _timeout_msec0 = (timeout_msec); \ + typeof(poll_msec) _poll_msec0 = (poll_msec); \ + gint64 _timeout_msec = _timeout_msec0; \ + guint _poll_msec = _poll_msec0; \ + \ + g_assert_cmpint(_timeout_msec0, ==, _timeout_msec); \ + g_assert_cmpint(_poll_msec0, ==, _poll_msec); \ + \ + _source_timeout = g_timeout_source_new(NM_CLAMP(_timeout_msec, 0, (gint64) G_MAXUINT)); \ + g_source_set_callback(_source_timeout, \ + nmtst_g_source_set_boolean_true, \ + &_had_timeout, \ + NULL); \ + g_source_attach(_source_timeout, _context); \ + \ + if (_poll_msec > 0) { \ + _source_poll = g_timeout_source_new(_poll_msec); \ + g_source_set_callback(_source_poll, nmtst_g_source_nop, NULL, NULL); \ + g_source_attach(_source_poll, _context); \ + } \ + \ + while (TRUE) { \ + if (condition) \ + break; \ + g_main_context_iteration(_context, TRUE); \ + if (_had_timeout) \ + break; \ + } \ + \ + !_had_timeout; \ + }) + +#define nmtst_main_context_iterate_until(context, timeout_msec, condition) \ + nmtst_main_context_iterate_until_full((context), (timeout_msec), 0, condition) + +#define nmtst_main_context_iterate_until_assert_full(context, timeout_msec, poll_msec, condition) \ + G_STMT_START \ + { \ + if (!nmtst_main_context_iterate_until_full((context), \ + (timeout_msec), \ + (poll_msec), \ + condition)) \ + g_assert(FALSE &&#condition); \ + } \ + G_STMT_END + +#define nmtst_main_context_iterate_until_assert(context, timeout_msec, condition) \ + nmtst_main_context_iterate_until_assert_full((context), (timeout_msec), 0, condition) + +/*****************************************************************************/ + +static inline void +nmtst_main_context_assert_no_dispatch(GMainContext *context, guint timeout_msec) +{ + nm_auto_destroy_and_unref_gsource GSource *source = NULL; + gboolean timeout_hit = FALSE; + + source = g_timeout_source_new(timeout_msec); + g_source_set_callback(source, nmtst_g_source_set_boolean_true, &timeout_hit, NULL); + g_source_attach(source, context); + + while (g_main_context_iteration(context, TRUE)) { + if (timeout_hit) + return; + g_assert_not_reached(); + } +} + +/*****************************************************************************/ + +typedef struct { + GMainLoop *_main_loop; + union { + GSList * _list; + const void *const is_waiting; + }; +} NMTstContextBusyWatcherData; + +static inline void +_nmtst_context_busy_watcher_add_cb(gpointer data, GObject *where_the_object_was) +{ + NMTstContextBusyWatcherData *watcher_data = data; + GSList * l; + + g_assert(watcher_data); + + l = g_slist_find(watcher_data->_list, where_the_object_was); + g_assert(l); + + watcher_data->_list = g_slist_delete_link(watcher_data->_list, l); + if (!watcher_data->_list) + g_main_loop_quit(watcher_data->_main_loop); +} + +static inline void +nmtst_context_busy_watcher_add(NMTstContextBusyWatcherData *watcher_data, GObject *object) +{ + g_assert(watcher_data); + g_assert(G_IS_OBJECT(object)); + + if (!watcher_data->_main_loop) { + watcher_data->_main_loop = g_main_loop_new(g_main_context_get_thread_default(), FALSE); + g_assert(!watcher_data->_list); + } else { + g_assert(g_main_loop_get_context(watcher_data->_main_loop) + == (g_main_context_get_thread_default() ?: g_main_context_default())); + } + + g_object_weak_ref(object, _nmtst_context_busy_watcher_add_cb, watcher_data); + watcher_data->_list = g_slist_prepend(watcher_data->_list, object); +} + +static inline void +nmtst_context_busy_watcher_wait(NMTstContextBusyWatcherData *watcher_data) +{ + g_assert(watcher_data); + + if (!watcher_data->_main_loop) { + g_assert(!watcher_data->_list); + return; + } + + if (watcher_data->_list) { + if (!nmtst_main_loop_run(watcher_data->_main_loop, 5000)) + g_error("timeout running mainloop waiting for GObject to destruct"); + } + + g_assert(!watcher_data->_list); + nm_clear_pointer(&watcher_data->_main_loop, g_main_loop_unref); +} + +/*****************************************************************************/ + +static inline const char * +nmtst_get_sudo_cmd(void) +{ + g_assert(nmtst_initialized()); + return __nmtst_internal.sudo_cmd; +} + +static inline void +nmtst_reexec_sudo(void) +{ + char * str; + char **argv; + int i; + int errsv; + + g_assert(nmtst_initialized()); + g_assert(__nmtst_internal.orig_argv); + + if (!__nmtst_internal.sudo_cmd) + return; + + str = g_strjoinv(" ", __nmtst_internal.orig_argv); + __NMTST_LOG(g_message, ">> exec %s %s", __nmtst_internal.sudo_cmd, str); + + argv = g_new0(char *, 1 + g_strv_length(__nmtst_internal.orig_argv) + 1); + argv[0] = __nmtst_internal.sudo_cmd; + for (i = 0; __nmtst_internal.orig_argv[i]; i++) + argv[i + 1] = __nmtst_internal.orig_argv[i]; + + execvp(__nmtst_internal.sudo_cmd, argv); + + errsv = errno; + g_error(">> exec %s failed: %d - %s", + __nmtst_internal.sudo_cmd, + errsv, + nm_strerror_native(errsv)); +} + +/*****************************************************************************/ + +static inline gsize +nmtst_find_all_indexes(gpointer *elements, + gsize n_elements, + gpointer *needles, + gsize n_needles, + gboolean (*equal_fcn)(gpointer element, gpointer needle, gpointer user_data), + gpointer user_data, + gssize * out_idx) +{ + gsize i, j, k; + gsize found = 0; + + for (i = 0; i < n_needles; i++) { + gssize idx = -1; + + for (j = 0; j < n_elements; j++) { + /* no duplicates */ + for (k = 0; k < i; k++) { + if (out_idx[k] == j) + goto next; + } + + if (equal_fcn(elements[j], needles[i], user_data)) { + idx = j; + break; + } +next:; + } + + out_idx[i] = idx; + if (idx >= 0) + found++; + } + + return found; +} + +/*****************************************************************************/ + +#define __define_nmtst_static(NUM, SIZE) \ + static inline const char *nmtst_static_##SIZE##_##NUM(const char *str) \ + { \ + gsize l; \ + static _nm_thread_local char buf[SIZE]; \ + \ + if (!str) \ + return NULL; \ + l = g_strlcpy(buf, str, sizeof(buf)); \ + g_assert(l < sizeof(buf)); \ + return buf; \ + } +__define_nmtst_static(01, 1024) __define_nmtst_static(02, 1024) __define_nmtst_static(03, 1024) +#undef __define_nmtst_static + +#if defined(__NM_UTILS_H__) || defined(NM_UTILS_H) + + #define NMTST_UUID_INIT(uuid) \ + gs_free char * _nmtst_hidden_##uuid = nm_utils_uuid_generate(); \ + const char *const uuid = _nmtst_hidden_##uuid + + static inline const char *nmtst_uuid_generate(void) +{ + static _nm_thread_local char u[37]; + gs_free char * m = NULL; + + m = nm_utils_uuid_generate(); + g_assert(m && strlen(m) == sizeof(u) - 1); + memcpy(u, m, sizeof(u)); + return u; +} + +#endif + +#define nmtst_assert_str_has_substr(str, substr) \ + G_STMT_START \ + { \ + const char *__str = (str); \ + const char *__substr = (substr); \ + \ + g_assert(__str); \ + g_assert(__substr); \ + if (strstr(__str, __substr) == NULL) \ + g_error("%s:%d: Expects \"%s\" but got \"%s\"", __FILE__, __LINE__, __substr, __str); \ + } \ + G_STMT_END + +static inline in_addr_t +nmtst_inet4_from_string(const char *str) +{ + in_addr_t addr; + int success; + + if (!str) + return 0; + + success = inet_pton(AF_INET, str, &addr); + + g_assert(success == 1); + + return addr; +} + +static inline const struct in6_addr * +nmtst_inet6_from_string(const char *str) +{ + static _nm_thread_local struct in6_addr addr; + int success; + + if (!str) + addr = in6addr_any; + else { + success = inet_pton(AF_INET6, str, &addr); + g_assert(success == 1); + } + + return &addr; +} + +static inline gconstpointer +nmtst_inet_from_string(int addr_family, const char *str) +{ + if (addr_family == AF_INET) { + static in_addr_t a; + + a = nmtst_inet4_from_string(str); + return &a; + } + if (addr_family == AF_INET6) + return nmtst_inet6_from_string(str); + + g_assert_not_reached(); + return NULL; +} + +static inline const char * +nmtst_inet_to_string(int addr_family, gconstpointer addr) +{ + static _nm_thread_local char buf[NM_CONST_MAX(INET6_ADDRSTRLEN, INET_ADDRSTRLEN)]; + + g_assert(NM_IN_SET(addr_family, AF_INET, AF_INET6)); + g_assert(addr); + + if (inet_ntop(addr_family, addr, buf, sizeof(buf)) != buf) + g_assert_not_reached(); + + return buf; +} + +static inline const char * +nmtst_inet4_to_string(in_addr_t addr) +{ + return nmtst_inet_to_string(AF_INET, &addr); +} + +static inline const char * +nmtst_inet6_to_string(const struct in6_addr *addr) +{ + return nmtst_inet_to_string(AF_INET6, addr); +} + +static inline void +_nmtst_assert_ip4_address(const char *file, int line, in_addr_t addr, const char *str_expected) +{ + if (nmtst_inet4_from_string(str_expected) != addr) { + char buf[100]; + + g_error("%s:%d: Unexpected IPv4 address: expected %s, got %s", + file, + line, + str_expected ?: "0.0.0.0", + inet_ntop(AF_INET, &addr, buf, sizeof(buf))); + } +} +#define nmtst_assert_ip4_address(addr, str_expected) \ + _nmtst_assert_ip4_address(__FILE__, __LINE__, addr, str_expected) + +static inline void +_nmtst_assert_ip6_address(const char * file, + int line, + const struct in6_addr *addr, + const char * str_expected) +{ + struct in6_addr any = in6addr_any; + + if (!addr) + addr = &any; + + if (memcmp(nmtst_inet6_from_string(str_expected), addr, sizeof(*addr)) != 0) { + char buf[100]; + + g_error("%s:%d: Unexpected IPv6 address: expected %s, got %s", + file, + line, + str_expected ?: "::", + inet_ntop(AF_INET6, addr, buf, sizeof(buf))); + } +} +#define nmtst_assert_ip6_address(addr, str_expected) \ + _nmtst_assert_ip6_address(__FILE__, __LINE__, addr, str_expected) + +#define nmtst_assert_ip_address(addr_family, addr, str_expected) \ + G_STMT_START \ + { \ + if (NM_IS_IPv4(addr_family)) \ + nmtst_assert_ip4_address(*((const in_addr_t *) (addr)), (str_expected)); \ + else \ + nmtst_assert_ip6_address((const struct in6_addr *) (addr), (str_expected)); \ + } \ + G_STMT_END + +#define nmtst_spawn_sync(working_directory, standard_out, standard_err, assert_exit_status, ...) \ + __nmtst_spawn_sync(working_directory, \ + standard_out, \ + standard_err, \ + assert_exit_status, \ + ##__VA_ARGS__, \ + NULL) +static inline int __nmtst_spawn_sync(const char *working_directory, + char ** standard_out, + char ** standard_err, + int assert_exit_status, + ...) G_GNUC_NULL_TERMINATED; +static inline int +__nmtst_spawn_sync(const char *working_directory, + char ** standard_out, + char ** standard_err, + int assert_exit_status, + ...) +{ + int exit_status = 0; + GError * error = NULL; + char * arg; + va_list va_args; + GPtrArray *argv = g_ptr_array_new(); + gboolean success; + + va_start(va_args, assert_exit_status); + while ((arg = va_arg(va_args, char *))) + g_ptr_array_add(argv, arg); + va_end(va_args); + + g_assert(argv->len >= 1); + g_ptr_array_add(argv, NULL); + + success = g_spawn_sync(working_directory, + (char **) argv->pdata, + NULL, + 0 /*G_SPAWN_DEFAULT*/, + NULL, + NULL, + standard_out, + standard_err, + &exit_status, + &error); + if (!success) + g_error("nmtst_spawn_sync(%s): %s", ((char **) argv->pdata)[0], error->message); + g_assert(!error); + + g_assert(!standard_out || *standard_out); + g_assert(!standard_err || *standard_err); + + if (assert_exit_status != -1) { + /* exit status is a guint8 on success. Set @assert_exit_status to -1 + * not to check for the exit status. */ + g_assert(WIFEXITED(exit_status)); + g_assert_cmpint(WEXITSTATUS(exit_status), ==, assert_exit_status); + } + + g_ptr_array_free(argv, TRUE); + return exit_status; +} + +/*****************************************************************************/ + +static inline char * +nmtst_file_resolve_relative_path(const char *rel, const char *cwd) +{ + gs_free char *cwd_free = NULL; + + g_assert(rel && *rel); + + if (g_path_is_absolute(rel)) + return g_strdup(rel); + + if (!cwd) + cwd = cwd_free = g_get_current_dir(); + return g_build_filename(cwd, rel, NULL); +} + +static inline char * +nmtst_file_get_contents(const char *filename) +{ + GError * error = NULL; + gboolean success; + char * contents = NULL; + gsize len; + + success = g_file_get_contents(filename, &contents, &len, &error); + nmtst_assert_success(success && contents, error); + g_assert_cmpint(strlen(contents), ==, len); + return contents; +} + +#define nmtst_file_set_contents_size(filename, content, size) \ + G_STMT_START \ + { \ + GError * _error = NULL; \ + gboolean _success; \ + const char *_content = (content); \ + gssize _size = (size); \ + \ + g_assert(_content); \ + \ + if (_size < 0) { \ + g_assert(_size == -1); \ + _size = strlen(_content); \ + } \ + \ + _success = g_file_set_contents((filename), _content, _size, &_error); \ + nmtst_assert_success(_success, _error); \ + } \ + G_STMT_END + +#define nmtst_file_set_contents(filename, content) \ + nmtst_file_set_contents_size(filename, content, -1) + +/*****************************************************************************/ + +static inline void +nmtst_file_unlink_if_exists(const char *name) +{ + int errsv; + + g_assert(name && name[0]); + + if (unlink(name) != 0) { + errsv = errno; + if (errsv != ENOENT) + g_error("nmtst_file_unlink_if_exists(%s): failed with %s", + name, + nm_strerror_native(errsv)); + } +} + +static inline void +nmtst_file_unlink(const char *name) +{ + int errsv; + + g_assert(name && name[0]); + + if (unlink(name) != 0) { + errsv = errno; + g_error("nmtst_file_unlink(%s): failed with %s", name, nm_strerror_native(errsv)); + } +} + +static inline void +_nmtst_auto_unlinkfile(char **p_name) +{ + if (*p_name) { + nmtst_file_unlink(*p_name); + nm_clear_g_free(p_name); + } +} + +#define nmtst_auto_unlinkfile nm_auto(_nmtst_auto_unlinkfile) + +/*****************************************************************************/ + +static inline void +_nmtst_assert_resolve_relative_path_equals(const char *f1, + const char *f2, + const char *file, + int line) +{ + gs_free char *p1 = NULL, *p2 = NULL; + + p1 = nmtst_file_resolve_relative_path(f1, NULL); + p2 = nmtst_file_resolve_relative_path(f2, NULL); + g_assert(p1 && *p1); + + /* Fixme: later we might need to coalesce repeated '/', "./", and "../". + * For now, it's good enough. */ + if (g_strcmp0(p1, p2) != 0) + g_error("%s:%d : filenames don't match \"%s\" vs. \"%s\" // \"%s\" - \"%s\"", + file, + line, + f1, + f2, + p1, + p2); +} +#define nmtst_assert_resolve_relative_path_equals(f1, f2) \ + _nmtst_assert_resolve_relative_path_equals(f1, f2, __FILE__, __LINE__); + +/*****************************************************************************/ + +#ifdef __NETWORKMANAGER_LOGGING_H__ +static inline gpointer +nmtst_logging_disable(gboolean always) +{ + gpointer p; + + g_assert(nmtst_initialized()); + if (!always && __nmtst_internal.no_expect_message) { + /* The caller does not want to @always suppress logging. Instead, + * the caller wants to suppress unexpected log messages that would + * fail assertions (since we possibly assert against all unexpected + * log messages). + * + * If the test is run with no-expect-message, then don't suppress + * the loggings, because they also wouldn't fail assertions. */ + return NULL; + } + + p = g_memdup(_nm_logging_enabled_state, sizeof(_nm_logging_enabled_state)); + memset(_nm_logging_enabled_state, 0, sizeof(_nm_logging_enabled_state)); + return p; +} + +static inline void +nmtst_logging_reenable(gpointer old_state) +{ + g_assert(nmtst_initialized()); + if (old_state) { + memcpy(_nm_logging_enabled_state, old_state, sizeof(_nm_logging_enabled_state)); + g_free(old_state); + } +} +#endif + +/*****************************************************************************/ + +#ifdef NM_SETTING_IP_CONFIG_H +static inline void +nmtst_setting_ip_config_add_address(NMSettingIPConfig *s_ip, const char *address, guint prefix) +{ + NMIPAddress *addr; + int family; + + g_assert(s_ip); + + if (nm_utils_ipaddr_is_valid(AF_INET, address)) + family = AF_INET; + else if (nm_utils_ipaddr_is_valid(AF_INET6, address)) + family = AF_INET6; + else + g_assert_not_reached(); + + addr = nm_ip_address_new(family, address, prefix, NULL); + g_assert(addr); + g_assert(nm_setting_ip_config_add_address(s_ip, addr)); + nm_ip_address_unref(addr); +} + +static inline void +nmtst_setting_ip_config_add_route(NMSettingIPConfig *s_ip, + const char * dest, + guint prefix, + const char * next_hop, + gint64 metric) +{ + NMIPRoute *route; + int family; + + g_assert(s_ip); + + if (nm_utils_ipaddr_is_valid(AF_INET, dest)) + family = AF_INET; + else if (nm_utils_ipaddr_is_valid(AF_INET6, dest)) + family = AF_INET6; + else + g_assert_not_reached(); + + route = nm_ip_route_new(family, dest, prefix, next_hop, metric, NULL); + g_assert(route); + g_assert(nm_setting_ip_config_add_route(s_ip, route)); + nm_ip_route_unref(route); +} + +static inline void +nmtst_assert_route_attribute_string(NMIPRoute *route, const char *name, const char *value) +{ + GVariant *variant; + + variant = nm_ip_route_get_attribute(route, name); + g_assert(variant); + g_assert(g_variant_is_of_type(variant, G_VARIANT_TYPE_STRING)); + g_assert_cmpstr(g_variant_get_string(variant, NULL), ==, value); +} + +static inline void +nmtst_assert_route_attribute_byte(NMIPRoute *route, const char *name, guchar value) +{ + GVariant *variant; + + variant = nm_ip_route_get_attribute(route, name); + g_assert(variant); + g_assert(g_variant_is_of_type(variant, G_VARIANT_TYPE_BYTE)); + g_assert_cmpint(g_variant_get_byte(variant), ==, value); +} + +static inline void +nmtst_assert_route_attribute_uint32(NMIPRoute *route, const char *name, guint32 value) +{ + GVariant *variant; + + variant = nm_ip_route_get_attribute(route, name); + g_assert(variant); + g_assert(g_variant_is_of_type(variant, G_VARIANT_TYPE_UINT32)); + g_assert_cmpint(g_variant_get_uint32(variant), ==, value); +} + +static inline void +nmtst_assert_route_attribute_boolean(NMIPRoute *route, const char *name, gboolean value) +{ + GVariant *variant; + + variant = nm_ip_route_get_attribute(route, name); + g_assert(variant); + g_assert(g_variant_is_of_type(variant, G_VARIANT_TYPE_BOOLEAN)); + g_assert_cmpint(g_variant_get_boolean(variant), ==, value); +} +#endif /* NM_SETTING_IP_CONFIG_H */ + +#if (defined(__NM_SIMPLE_CONNECTION_H__) && defined(__NM_SETTING_CONNECTION_H__)) \ + || (defined(NM_CONNECTION_H)) + +static inline NMConnection * +nmtst_clone_connection(NMConnection *connection) +{ + g_assert(NM_IS_CONNECTION(connection)); + + #if defined(__NM_SIMPLE_CONNECTION_H__) + return nm_simple_connection_new_clone(connection); + #else + return nm_connection_duplicate(connection); + #endif +} + +static inline NMConnection * +nmtst_create_minimal_connection(const char * id, + const char * uuid, + const char * type, + NMSettingConnection **out_s_con) +{ + NMConnection * con; + NMSetting * s_base = NULL; + NMSettingConnection *s_con; + gs_free char * uuid_free = NULL; + + g_assert(id); + + if (uuid) + g_assert(nm_utils_is_uuid(uuid)); + else + uuid = uuid_free = nm_utils_uuid_generate(); + + if (type) { + GType type_g; + + #if defined(__NM_SIMPLE_CONNECTION_H__) + type_g = nm_setting_lookup_type(type); + #else + type_g = nm_connection_lookup_setting_type(type); + #endif + + g_assert(type_g != G_TYPE_INVALID); + + s_base = g_object_new(type_g, NULL); + g_assert(NM_IS_SETTING(s_base)); + } + + #if defined(__NM_SIMPLE_CONNECTION_H__) + con = nm_simple_connection_new(); + #else + con = nm_connection_new(); + #endif + + g_assert(con); + + s_con = NM_SETTING_CONNECTION(nm_setting_connection_new()); + + g_assert(s_con); + + g_object_set(s_con, + NM_SETTING_CONNECTION_ID, + id, + NM_SETTING_CONNECTION_UUID, + uuid, + NM_SETTING_CONNECTION_TYPE, + type, + NULL); + nm_connection_add_setting(con, NM_SETTING(s_con)); + + if (s_base) + nm_connection_add_setting(con, s_base); + + if (out_s_con) + *out_s_con = s_con; + return con; +} + +static inline gboolean +_nmtst_connection_normalize_v(NMConnection *connection, va_list args) +{ + GError * error = NULL; + gboolean success; + gboolean was_modified = FALSE; + GHashTable *parameters = NULL; + const char *p_name; + + g_assert(NM_IS_CONNECTION(connection)); + + while ((p_name = va_arg(args, const char *))) { + if (!parameters) + parameters = g_hash_table_new(g_str_hash, g_str_equal); + g_hash_table_insert(parameters, (gpointer *) p_name, va_arg(args, gpointer)); + } + + success = nm_connection_normalize(connection, parameters, &was_modified, &error); + g_assert_no_error(error); + g_assert(success); + + if (parameters) + g_hash_table_destroy(parameters); + + return was_modified; +} + +static inline gboolean +_nmtst_connection_normalize(NMConnection *connection, ...) +{ + gboolean was_modified; + va_list args; + + va_start(args, connection); + was_modified = _nmtst_connection_normalize_v(connection, args); + va_end(args); + + return was_modified; +} + #define nmtst_connection_normalize(connection, ...) \ + _nmtst_connection_normalize(connection, ##__VA_ARGS__, NULL) + +static inline NMConnection * +_nmtst_connection_duplicate_and_normalize(NMConnection *connection, ...) +{ + va_list args; + + connection = nmtst_clone_connection(connection); + + va_start(args, connection); + _nmtst_connection_normalize_v(connection, args); + va_end(args); + + return connection; +} + #define nmtst_connection_duplicate_and_normalize(connection, ...) \ + _nmtst_connection_duplicate_and_normalize(connection, ##__VA_ARGS__, NULL) + +static inline void +nmtst_assert_connection_equals(NMConnection *a, + gboolean normalize_a, + NMConnection *b, + gboolean normalize_b) +{ + gboolean compare; + gs_unref_object NMConnection *a2 = NULL; + gs_unref_object NMConnection *b2 = NULL; + GHashTable * out_settings = NULL; + + g_assert(NM_IS_CONNECTION(a)); + g_assert(NM_IS_CONNECTION(b)); + + if (normalize_a) + a = a2 = nmtst_connection_duplicate_and_normalize(a); + if (normalize_b) + b = b2 = nmtst_connection_duplicate_and_normalize(b); + + compare = nm_connection_diff(a, b, NM_SETTING_COMPARE_FLAG_EXACT, &out_settings); + if (!compare || out_settings) { + const char * name, *pname; + GHashTable * setting; + GHashTableIter iter, iter2; + + __NMTST_LOG(g_message, ">>> ASSERTION nmtst_assert_connection_equals() fails"); + if (out_settings) { + g_hash_table_iter_init(&iter, out_settings); + while (g_hash_table_iter_next(&iter, (gpointer *) &name, (gpointer *) &setting)) { + __NMTST_LOG(g_message, ">>> differences in setting '%s':", name); + + g_hash_table_iter_init(&iter2, setting); + while (g_hash_table_iter_next(&iter2, (gpointer *) &pname, NULL)) + __NMTST_LOG(g_message, ">>> differences in setting '%s.%s'", name, pname); + } + } + + #ifdef __NM_KEYFILE_INTERNAL_H__ + { + nm_auto_unref_keyfile GKeyFile *kf_a = NULL, *kf_b = NULL; + gs_free char * str_a = NULL, *str_b = NULL; + + kf_a = nm_keyfile_write(a, NM_KEYFILE_HANDLER_FLAGS_NONE, NULL, NULL, NULL); + kf_b = nm_keyfile_write(b, NM_KEYFILE_HANDLER_FLAGS_NONE, NULL, NULL, NULL); + + if (kf_a) + str_a = g_key_file_to_data(kf_a, NULL, NULL); + if (kf_b) + str_b = g_key_file_to_data(kf_b, NULL, NULL); + + __NMTST_LOG(g_message, + ">>> Connection A as kf (*WARNING: keyfile representation might not show " + "the difference*):\n%s", + str_a); + __NMTST_LOG(g_message, + ">>> Connection B as kf (*WARNING: keyfile representation might not show " + "the difference*):\n%s", + str_b); + } + #endif + } + g_assert(compare); + g_assert(!out_settings); + + compare = nm_connection_compare(a, b, NM_SETTING_COMPARE_FLAG_EXACT); + g_assert(compare); +} + +static inline void +nmtst_assert_connection_verifies(NMConnection *con) +{ + /* assert that the connection does verify, it might be normaliziable or not */ + GError * error = NULL; + gboolean success; + + g_assert(NM_IS_CONNECTION(con)); + + success = nm_connection_verify(con, &error); + g_assert_no_error(error); + g_assert(success); +} + +static inline void +nmtst_assert_connection_verifies_without_normalization(NMConnection *con) +{ + /* assert that the connection verifies and does not need any normalization */ + GError * error = NULL; + gboolean success; + gboolean was_modified = FALSE; + gs_unref_object NMConnection *clone = NULL; + + clone = nmtst_clone_connection(con); + + nmtst_assert_connection_verifies(con); + + success = nm_connection_normalize(clone, NULL, &was_modified, &error); + g_assert_no_error(error); + g_assert(success); + nmtst_assert_connection_equals(con, FALSE, clone, FALSE); + g_assert(!was_modified); +} + +static inline void +nmtst_assert_connection_verifies_and_normalizable(NMConnection *con) +{ + /* assert that the connection does verify, but normalization still modifies it */ + GError * error = NULL; + gboolean success; + gboolean was_modified = FALSE; + gs_unref_object NMConnection *clone = NULL; + + clone = nmtst_clone_connection(con); + + nmtst_assert_connection_verifies(con); + + success = nm_connection_normalize(clone, NULL, &was_modified, &error); + g_assert_no_error(error); + g_assert(success); + g_assert(was_modified); + + /* again! */ + nmtst_assert_connection_verifies_without_normalization(clone); +} + +static inline void +nmtst_assert_connection_verifies_after_normalization(NMConnection *con, + GQuark expect_error_domain, + int expect_error_code) +{ + /* assert that the connection does not verify, but normalization does fix it */ + GError * error = NULL; + gboolean success; + gboolean was_modified = FALSE; + gs_unref_object NMConnection *clone = NULL; + + clone = nmtst_clone_connection(con); + + success = nm_connection_verify(con, &error); + nmtst_assert_error(error, expect_error_domain, expect_error_code, NULL); + g_assert(!success); + g_clear_error(&error); + + success = nm_connection_normalize(clone, NULL, &was_modified, &error); + g_assert_no_error(error); + g_assert(success); + g_assert(was_modified); + + /* again! */ + nmtst_assert_connection_verifies_without_normalization(clone); +} + +static inline void +nmtst_assert_connection_unnormalizable(NMConnection *con, + GQuark expect_error_domain, + int expect_error_code) +{ + /* assert that the connection does not verify, and it cannot be fixed by normalization */ + + GError * error = NULL; + gboolean success; + gboolean was_modified = FALSE; + gs_unref_object NMConnection *clone = NULL; + + clone = nmtst_clone_connection(con); + + success = nm_connection_verify(con, &error); + nmtst_assert_error(error, expect_error_domain, expect_error_code, NULL); + g_assert(!success); + g_clear_error(&error); + + success = nm_connection_normalize(clone, NULL, &was_modified, &error); + nmtst_assert_error(error, expect_error_domain, expect_error_code, NULL); + g_assert(!success); + g_assert(!was_modified); + nmtst_assert_connection_equals(con, FALSE, clone, FALSE); + g_clear_error(&error); +} + +static inline void +nmtst_assert_setting_verifies(NMSetting *setting) +{ + /* assert that the setting verifies without an error */ + + GError * error = NULL; + gboolean success; + + g_assert(NM_IS_SETTING(setting)); + + success = nm_setting_verify(setting, NULL, &error); + g_assert_no_error(error); + g_assert(success); +} + + #if defined(__NM_SIMPLE_CONNECTION_H__) && NM_CHECK_VERSION(1, 10, 0) \ + && (!defined(NM_VERSION_MAX_ALLOWED) || NM_VERSION_MAX_ALLOWED >= NM_VERSION_1_10) +static inline void +_nmtst_assert_connection_has_settings(NMConnection *connection, + gboolean has_at_least, + gboolean has_at_most, + ...) +{ + gs_unref_hashtable GHashTable *names = NULL; + gs_free NMSetting **settings = NULL; + va_list ap; + const char * name; + guint i, len; + gs_unref_ptrarray GPtrArray *names_arr = NULL; + + g_assert(NM_IS_CONNECTION(connection)); + + names = g_hash_table_new(g_str_hash, g_str_equal); + names_arr = g_ptr_array_new(); + + va_start(ap, has_at_most); + while ((name = va_arg(ap, const char *))) { + if (!nm_g_hash_table_add(names, (gpointer) name)) + g_assert_not_reached(); + g_ptr_array_add(names_arr, (gpointer) name); + } + va_end(ap); + + g_ptr_array_add(names_arr, NULL); + + settings = nm_connection_get_settings(connection, &len); + for (i = 0; i < len; i++) { + if (!g_hash_table_remove(names, nm_setting_get_name(settings[i])) && has_at_most) { + g_error( + "nmtst_assert_connection_has_settings(): has setting \"%s\" which is not expected", + nm_setting_get_name(settings[i])); + } + } + if (g_hash_table_size(names) > 0 && has_at_least) { + gs_free char * expected_str = g_strjoinv(" ", (char **) names_arr->pdata); + gs_free const char **settings_names = NULL; + gs_free char * has_str = NULL; + + settings_names = g_new0(const char *, len + 1); + for (i = 0; i < len; i++) + settings_names[i] = nm_setting_get_name(settings[i]); + has_str = g_strjoinv(" ", (char **) settings_names); + + g_error("nmtst_assert_connection_has_settings(): the setting lacks %u expected settings " + "(expected: [%s] vs. has: [%s])", + g_hash_table_size(names), + expected_str, + has_str); + } +} + #define nmtst_assert_connection_has_settings(connection, ...) \ + _nmtst_assert_connection_has_settings((connection), TRUE, TRUE, __VA_ARGS__, NULL) + #define nmtst_assert_connection_has_settings_at_least(connection, ...) \ + _nmtst_assert_connection_has_settings((connection), TRUE, FALSE, __VA_ARGS__, NULL) + #define nmtst_assert_connection_has_settings_at_most(connection, ...) \ + _nmtst_assert_connection_has_settings((connection), FALSE, TRUE, __VA_ARGS__, NULL) + #endif + +static inline void +nmtst_assert_setting_verify_fails(NMSetting *setting, + GQuark expect_error_domain, + int expect_error_code) +{ + /* assert that the setting verification fails */ + + GError * error = NULL; + gboolean success; + + g_assert(NM_IS_SETTING(setting)); + + success = nm_setting_verify(setting, NULL, &error); + nmtst_assert_error(error, expect_error_domain, expect_error_code, NULL); + g_assert(!success); + g_clear_error(&error); +} + +static inline void +nmtst_assert_setting_is_equal(gconstpointer /* const NMSetting * */ a, + gconstpointer /* const NMSetting * */ b, + NMSettingCompareFlags flags) +{ + gs_unref_hashtable GHashTable *hash = NULL; + guint32 r = nmtst_get_rand_uint32(); + + g_assert(NM_IS_SETTING(a)); + g_assert(NM_IS_SETTING(b)); + + if (NM_FLAGS_HAS(r, 0x4)) + NM_SWAP(&a, &b); + + g_assert(nm_setting_compare((NMSetting *) a, (NMSetting *) b, flags)); + + if (NM_FLAGS_HAS(r, 0x8)) + NM_SWAP(&a, &b); + + g_assert(nm_setting_diff((NMSetting *) a, (NMSetting *) b, flags, NM_FLAGS_HAS(r, 0x1), &hash)); + g_assert(!hash); +} +#endif + +#ifdef __NM_SETTING_PRIVATE_H__ +static inline NMSetting * +nmtst_assert_setting_dbus_new(GType gtype, GVariant *variant) +{ + NMSetting * setting; + gs_free_error GError *error = NULL; + + g_assert(g_type_is_a(gtype, NM_TYPE_SETTING)); + g_assert(gtype != NM_TYPE_SETTING); + g_assert(variant); + g_assert(g_variant_is_of_type(variant, NM_VARIANT_TYPE_SETTING)); + + setting = + _nm_setting_new_from_dbus(gtype, variant, NULL, NM_SETTING_PARSE_FLAGS_STRICT, &error); + nmtst_assert_success(setting, error); + return setting; +} + +static inline void +nmtst_assert_setting_dbus_roundtrip(gconstpointer /* const NMSetting * */ setting) +{ + gs_unref_object NMSetting *setting2 = NULL; + gs_unref_variant GVariant *variant = NULL; + + g_assert(NM_IS_SETTING(setting)); + + variant = _nm_setting_to_dbus((NMSetting *) setting, NULL, NM_CONNECTION_SERIALIZE_ALL, NULL); + setting2 = nmtst_assert_setting_dbus_new(G_OBJECT_TYPE(setting), variant); + nmtst_assert_setting_is_equal(setting, setting2, NM_SETTING_COMPARE_FLAG_EXACT); +} +#endif + +#ifdef __NM_UTILS_H__ +static inline void +nmtst_assert_hwaddr_equals(gconstpointer hwaddr1, + gssize hwaddr1_len, + const char * expected, + const char * file, + int line) +{ + guint8 buf2[NM_UTILS_HWADDR_LEN_MAX]; + gsize hwaddr2_len = 1; + const char *p; + gboolean success; + + g_assert(hwaddr1_len > 0 && hwaddr1_len <= NM_UTILS_HWADDR_LEN_MAX); + + g_assert(expected); + for (p = expected; *p; p++) { + if (*p == ':' || *p == '-') + hwaddr2_len++; + } + g_assert(hwaddr2_len <= NM_UTILS_HWADDR_LEN_MAX); + g_assert(nm_utils_hwaddr_aton(expected, buf2, hwaddr2_len)); + + /* Manually check the entire hardware address instead of using + * nm_utils_hwaddr_matches() because that function doesn't compare + * entire InfiniBand addresses for various (legitimate) reasons. + */ + success = (hwaddr1_len == hwaddr2_len); + if (success) + success = !memcmp(hwaddr1, buf2, hwaddr1_len); + if (!success) { + g_error("assert: %s:%d: hwaddr '%s' (%zd) expected, but got %s (%zd)", + file, + line, + expected, + hwaddr2_len, + nm_utils_hwaddr_ntoa(hwaddr1, hwaddr1_len), + hwaddr1_len); + } +} + #define nmtst_assert_hwaddr_equals(hwaddr1, hwaddr1_len, expected) \ + nmtst_assert_hwaddr_equals(hwaddr1, hwaddr1_len, expected, __FILE__, __LINE__) +#endif + +#if defined(__NM_SIMPLE_CONNECTION_H__) && defined(__NM_SETTING_CONNECTION_H__) \ + && defined(__NM_KEYFILE_INTERNAL_H__) + +static inline NMConnection * +nmtst_create_connection_from_keyfile(const char *keyfile_str, const char *full_filename) +{ + nm_auto_unref_keyfile GKeyFile *keyfile = NULL; + gs_free_error GError *error = NULL; + gboolean success; + NMConnection * con; + gs_free char * filename = g_path_get_basename(full_filename); + gs_free char * base_dir = g_path_get_dirname(full_filename); + + g_assert(keyfile_str); + g_assert(full_filename && full_filename[0] == '/'); + + keyfile = g_key_file_new(); + success = g_key_file_load_from_data(keyfile, + keyfile_str, + strlen(keyfile_str), + G_KEY_FILE_NONE, + &error); + nmtst_assert_success(success, error); + + con = nm_keyfile_read(keyfile, base_dir, NM_KEYFILE_HANDLER_FLAGS_NONE, NULL, NULL, &error); + nmtst_assert_success(NM_IS_CONNECTION(con), error); + + nm_keyfile_read_ensure_id(con, filename); + nm_keyfile_read_ensure_uuid(con, full_filename); + + nmtst_connection_normalize(con); + + return con; +} + +#endif + +#ifdef __NM_CONNECTION_H__ + +static inline GVariant * +_nmtst_variant_new_vardict(int dummy, ...) +{ + GVariantBuilder builder; + va_list ap; + const char * name; + GVariant * variant; + + g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT); + + va_start(ap, dummy); + while ((name = va_arg(ap, const char *))) { + variant = va_arg(ap, GVariant *); + g_variant_builder_add(&builder, "{sv}", name, variant); + } + va_end(ap); + + return g_variant_builder_end(&builder); +} + #define nmtst_variant_new_vardict(...) _nmtst_variant_new_vardict(0, __VA_ARGS__, NULL) + + #define nmtst_assert_variant_is_of_type(variant, type) \ + G_STMT_START \ + { \ + GVariant *_variantx = (variant); \ + \ + g_assert(_variantx); \ + g_assert(g_variant_is_of_type(_variantx, (type))); \ + } \ + G_STMT_END + + #define nmtst_assert_variant_uint32(variant, val) \ + G_STMT_START \ + { \ + GVariant *_variant = (variant); \ + \ + nmtst_assert_variant_is_of_type(_variant, G_VARIANT_TYPE_UINT32); \ + g_assert_cmpint(g_variant_get_uint32(_variant), ==, (val)); \ + } \ + G_STMT_END + + #define nmtst_assert_variant_string(variant, str) \ + G_STMT_START \ + { \ + gsize _l; \ + GVariant * _variant = (variant); \ + const char *_str = (str); \ + \ + nmtst_assert_variant_is_of_type(_variant, G_VARIANT_TYPE_STRING); \ + g_assert(_str); \ + g_assert_cmpstr(g_variant_get_string(_variant, &_l), ==, _str); \ + g_assert_cmpint(_l, ==, strlen(_str)); \ + } \ + G_STMT_END + + #ifdef __NM_SHARED_UTILS_H__ + #define _nmtst_assert_variant_bytestring_cmp_str(_ptr, _ptr2, _len) \ + G_STMT_START \ + { \ + if (memcmp(_ptr2, _ptr, _len) != 0) { \ + gs_free char *_x1 = NULL; \ + gs_free char *_x2 = NULL; \ + const char * _xx1; \ + const char * _xx2; \ + \ + _xx1 = nm_utils_buf_utf8safe_escape(_ptr, \ + _len, \ + NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_CTRL, \ + &_x1); \ + _xx2 = nm_utils_buf_utf8safe_escape(_ptr2, \ + _len, \ + NM_UTILS_STR_UTF8_SAFE_FLAG_ESCAPE_CTRL, \ + &_x2); \ + g_assert_cmpstr(_xx1, ==, _xx2); \ + g_assert_not_reached(); \ + } \ + } \ + G_STMT_END + #else + #define _nmtst_assert_variant_bytestring_cmp_str(_ptr, _ptr2, _len) \ + G_STMT_START {} \ + G_STMT_END + #endif + + #define nmtst_assert_variant_bytestring(variant, ptr, len) \ + G_STMT_START \ + { \ + GVariant * _variant = (variant); \ + gconstpointer _ptr = (ptr); \ + gconstpointer _ptr2; \ + gsize _len = (len); \ + gsize _len2; \ + \ + nmtst_assert_variant_is_of_type(_variant, G_VARIANT_TYPE_BYTESTRING); \ + _ptr2 = g_variant_get_fixed_array(_variant, &_len2, 1); \ + g_assert_cmpint(_len2, ==, _len); \ + if (_len != 0 && _ptr) { \ + _nmtst_assert_variant_bytestring_cmp_str(_ptr, _ptr2, _len); \ + g_assert_cmpmem(_ptr2, _len2, _ptr, _len); \ + } \ + } \ + G_STMT_END + +typedef enum { + NMTST_VARIANT_EDITOR_CONNECTION, + NMTST_VARIANT_EDITOR_SETTING, + NMTST_VARIANT_EDITOR_PROPERTY +} NmtstVariantEditorPhase; + + #define NMTST_VARIANT_EDITOR(__connection_variant, __code) \ + G_STMT_START \ + { \ + GVariantIter __connection_iter, *__setting_iter; \ + GVariantBuilder __connection_builder, __setting_builder; \ + const char * __cur_setting_name, *__cur_property_name; \ + GVariant * __property_val; \ + NmtstVariantEditorPhase __phase; \ + \ + g_variant_builder_init(&__connection_builder, NM_VARIANT_TYPE_CONNECTION); \ + g_variant_iter_init(&__connection_iter, __connection_variant); \ + \ + __phase = NMTST_VARIANT_EDITOR_CONNECTION; \ + __cur_setting_name = NULL; \ + __cur_property_name = NULL; \ + __code; \ + while (g_variant_iter_next(&__connection_iter, \ + "{&sa{sv}}", \ + &__cur_setting_name, \ + &__setting_iter)) { \ + g_variant_builder_init(&__setting_builder, NM_VARIANT_TYPE_SETTING); \ + __phase = NMTST_VARIANT_EDITOR_SETTING; \ + __cur_property_name = NULL; \ + __code; \ + \ + while (__cur_setting_name \ + && g_variant_iter_next(__setting_iter, \ + "{&sv}", \ + &__cur_property_name, \ + &__property_val)) { \ + __phase = NMTST_VARIANT_EDITOR_PROPERTY; \ + __code; \ + \ + if (__cur_property_name) { \ + g_variant_builder_add(&__setting_builder, \ + "{sv}", \ + __cur_property_name, \ + __property_val); \ + } \ + g_variant_unref(__property_val); \ + } \ + \ + if (__cur_setting_name) \ + g_variant_builder_add(&__connection_builder, \ + "{sa{sv}}", \ + __cur_setting_name, \ + &__setting_builder); \ + else \ + g_variant_builder_clear(&__setting_builder); \ + g_variant_iter_free(__setting_iter); \ + } \ + \ + g_variant_unref(__connection_variant); \ + \ + __connection_variant = g_variant_builder_end(&__connection_builder); \ + } \ + G_STMT_END; + + #define NMTST_VARIANT_ADD_SETTING(__setting_name, __setting_variant) \ + G_STMT_START \ + { \ + if (__phase == NMTST_VARIANT_EDITOR_CONNECTION) \ + g_variant_builder_add(&__connection_builder, \ + "{s@a{sv}}", \ + __setting_name, \ + __setting_variant); \ + } \ + G_STMT_END + + #define NMTST_VARIANT_DROP_SETTING(__setting_name) \ + G_STMT_START \ + { \ + if (__phase == NMTST_VARIANT_EDITOR_SETTING && __cur_setting_name) { \ + if (!strcmp(__cur_setting_name, __setting_name)) \ + __cur_setting_name = NULL; \ + } \ + } \ + G_STMT_END + + #define NMTST_VARIANT_ADD_PROPERTY(__setting_name, __property_name, __format_string, __value) \ + G_STMT_START \ + { \ + if (__phase == NMTST_VARIANT_EDITOR_SETTING) { \ + if (!strcmp(__cur_setting_name, __setting_name)) { \ + g_variant_builder_add(&__setting_builder, \ + "{sv}", \ + __property_name, \ + g_variant_new(__format_string, __value)); \ + } \ + } \ + } \ + G_STMT_END + + #define NMTST_VARIANT_DROP_PROPERTY(__setting_name, __property_name) \ + G_STMT_START \ + { \ + if (__phase == NMTST_VARIANT_EDITOR_PROPERTY && __cur_property_name) { \ + if (!strcmp(__cur_setting_name, __setting_name) \ + && !strcmp(__cur_property_name, __property_name)) \ + __cur_property_name = NULL; \ + } \ + } \ + G_STMT_END + + #define NMTST_VARIANT_CHANGE_PROPERTY(__setting_name, \ + __property_name, \ + __format_string, \ + __value) \ + G_STMT_START \ + { \ + NMTST_VARIANT_DROP_PROPERTY(__setting_name, __property_name); \ + NMTST_VARIANT_ADD_PROPERTY(__setting_name, __property_name, __format_string, __value); \ + } \ + G_STMT_END + +#endif /* __NM_CONNECTION_H__ */ + +static inline GVariant * +nmtst_variant_from_string(const GVariantType *variant_type, const char *variant_str) +{ + GVariant *variant; + GError * error = NULL; + + g_assert(variant_type); + g_assert(variant_str); + + variant = g_variant_parse(variant_type, variant_str, NULL, NULL, &error); + nmtst_assert_success(variant, error); + return variant; +} + +/*****************************************************************************/ + +static inline void +nmtst_keyfile_assert_data(GKeyFile *kf, const char *data, gssize data_len) +{ + nm_auto_unref_keyfile GKeyFile *kf2 = NULL; + gs_free_error GError *error = NULL; + gs_free char * d1 = NULL; + gs_free char * d2 = NULL; + gboolean success; + gsize d1_len; + gsize d2_len; + + g_assert(kf); + g_assert(data || data_len == 0); + g_assert(data_len >= -1); + + d1 = g_key_file_to_data(kf, &d1_len, &error); + nmtst_assert_success(d1, error); + + if (data_len == -1) { + g_assert_cmpint(strlen(d1), ==, d1_len); + data_len = strlen(data); + g_assert_cmpstr(d1, ==, data); + } + + g_assert_cmpmem(d1, d1_len, data, (gsize) data_len); + + /* also check that we can re-generate the same keyfile from the data. */ + + kf2 = g_key_file_new(); + success = g_key_file_load_from_data(kf2, d1, d1_len, G_KEY_FILE_NONE, &error); + nmtst_assert_success(success, error); + + d2 = g_key_file_to_data(kf2, &d2_len, &error); + nmtst_assert_success(d2, error); + + g_assert_cmpmem(d2, d2_len, d1, d1_len); +} + +static inline gssize +nmtst_keyfile_get_num_keys(GKeyFile *keyfile, const char *group_name) +{ + gs_strfreev char **keys = NULL; + gs_free_error GError *error = NULL; + gsize l; + + g_assert(keyfile); + g_assert(group_name); + + if (!g_key_file_has_group(keyfile, group_name)) + return -1; + + keys = g_key_file_get_keys(keyfile, group_name, &l, &error); + + nmtst_assert_success(keys, error); + + g_assert_cmpint(NM_PTRARRAY_LEN(keys), ==, l); + + return l; +} + +/*****************************************************************************/ + +#if defined(NM_SETTING_IP_CONFIG_H) && defined(__NM_SHARED_UTILS_H__) + +static inline NMIPAddress * +nmtst_ip_address_new(int addr_family, const char *str) +{ + NMIPAddr addr; + int plen; + GError * error = NULL; + NMIPAddress *a; + + if (!nm_utils_parse_inaddr_prefix_bin(addr_family, str, &addr_family, &addr, &plen)) + g_assert_not_reached(); + + if (plen == -1) + plen = addr_family == AF_INET ? 32 : 128; + + a = nm_ip_address_new_binary(addr_family, &addr, plen, &error); + nmtst_assert_success(a, error); + return a; +} + +#endif + +/*****************************************************************************/ + +#endif /* __NM_TEST_UTILS_H__ */ diff --git a/src/libnm-glib-aux/tests/test-json-aux.c b/src/libnm-glib-aux/tests/test-json-aux.c index b27504482d..5f33f4fe39 100644 --- a/src/libnm-glib-aux/tests/test-json-aux.c +++ b/src/libnm-glib-aux/tests/test-json-aux.c @@ -6,7 +6,7 @@ #include "libnm-glib-aux/nm-json-aux.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" /*****************************************************************************/ diff --git a/src/libnm-glib-aux/tests/test-shared-general.c b/src/libnm-glib-aux/tests/test-shared-general.c index bc3a85bf17..efb0937b54 100644 --- a/src/libnm-glib-aux/tests/test-shared-general.c +++ b/src/libnm-glib-aux/tests/test-shared-general.c @@ -11,7 +11,7 @@ #include "libnm-glib-aux/nm-time-utils.h" #include "libnm-glib-aux/nm-ref-string.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" /*****************************************************************************/ diff --git a/src/libnm-platform/tests/test-nm-platform.c b/src/libnm-platform/tests/test-nm-platform.c index f4b32d4693..5b1b8e87a1 100644 --- a/src/libnm-platform/tests/test-nm-platform.c +++ b/src/libnm-platform/tests/test-nm-platform.c @@ -6,7 +6,7 @@ #include "libnm-platform/nm-netlink.h" #include "libnm-platform/nmp-netns.h" -#include "nm-utils/nm-test-utils.h" +#include "libnm-glib-aux/nm-test-utils.h" /*****************************************************************************/ |