colin/NetworkManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d9968b133b32fbfbc5e726a8fc96e38cc044c831
NetworkManager/shared/nm-utils/nm-test-utils.h
Thomas Haller f591aa41c6 tests: add "/bin:/sbin" to "$PATH" for unit tests 
We call `tc` from iproute2, which commonly is at "/sbin/tc".
That might not be in the "$PATH" of a regular user, and consequently
we fail to run the test.

Work around that by always adding "/bin" and "/sbin" to the $PATH.
2021-02-15 13:58:48 +01:00

2825 lines
108 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* 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("libnm", 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__ */
Reference in New Issue View Git Blame Copy Permalink