diff options
Diffstat (limited to 'shared/nm-utils/nm-test-utils.h')
| -rw-r--r-- | shared/nm-utils/nm-test-utils.h | 2824 |
1 files changed, 0 insertions, 2824 deletions
diff --git a/shared/nm-utils/nm-test-utils.h b/shared/nm-utils/nm-test-utils.h deleted file mode 100644 index cf884f9c41..0000000000 --- a/shared/nm-utils/nm-test-utils.h +++ /dev/null @@ -1,2824 +0,0 @@ -/* 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__ */ |