/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2010 - 2014 Red Hat, Inc.
 */

#include "libnm-client-impl/nm-default-libnm.h"

#include <sys/types.h>
#include <signal.h>

#include "libnm-client-impl/nm-dbus-helpers.h"

#include "libnm-client-test/nm-test-libnm-utils.h"
#include "libnm-glib-aux/nm-time-utils.h"

static struct {
    GMainLoop *loop;
} gl = {};

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

static gboolean
loop_quit(gpointer user_data)
{
    g_main_loop_quit((GMainLoop *) user_data);
    return G_SOURCE_REMOVE;
}

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

static void
devices_notify_cb(NMClient *c, GParamSpec *pspec, gpointer user_data)
{
    gboolean        *notified = user_data;
    const GPtrArray *devices;
    NMDevice        *device;

    devices = nm_client_get_devices(c);
    g_assert(devices);
    g_assert_cmpint(devices->len, ==, 1);

    device = g_ptr_array_index(devices, 0);
    g_assert(device);
    g_assert_cmpstr(nm_device_get_iface(device), ==, "eth0");

    *notified = TRUE;
}

static void
test_device_added(void)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo  = NULL;
    gs_unref_object NMClient                      *client = NULL;
    const GPtrArray                               *devices;
    NMDevice                                      *device;
    gboolean                                       notified = FALSE;
    GError                                        *error    = NULL;

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    client = nmtstc_client_new(TRUE);

    devices = nm_client_get_devices(client);
    g_assert(devices->len == 0);

    g_signal_connect(client, "notify::devices", G_CALLBACK(devices_notify_cb), &notified);

    /* Tell the test service to add a new device */
    nmtstc_service_add_device(sinfo, client, "AddWiredDevice", "eth0");

    /* coverity[loop_condition] */
    while (!notified)
        g_main_context_iteration(NULL, TRUE);

    g_signal_handlers_disconnect_by_func(client, devices_notify_cb, &notified);

    devices = nm_client_get_devices(client);
    g_assert(devices);
    g_assert_cmpint(devices->len, ==, 1);

    device = g_ptr_array_index(devices, 0);
    g_assert(device);
    g_assert_cmpstr(nm_device_get_iface(device), ==, "eth0");

    /* Try deleting the device via the ordinary NM interface, which should fail */
    nm_device_delete(device, NULL, &error);
    g_assert_error(error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_NOT_SOFTWARE);
    g_clear_error(&error);
}

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

typedef enum {
    SIGNAL_FIRST  = 0x01,
    SIGNAL_SECOND = 0x02,
    SIGNAL_MASK   = 0x0F,
    NOTIFY_FIRST  = 0x10,
    NOTIFY_SECOND = 0x20,
    NOTIFY_MASK   = 0xF0
} DeviceSignaledAfterInitType;

static void
device_sai_added_cb(NMClient *c, NMDevice *device, gpointer user_data)
{
    guint *result = user_data;

    g_assert(device);
    g_assert_cmpstr(nm_device_get_iface(device), ==, "eth0");

    g_assert((*result & SIGNAL_MASK) == 0);
    *result |= *result ? SIGNAL_SECOND : SIGNAL_FIRST;
}

static void
devices_sai_notify_cb(NMClient *c, GParamSpec *pspec, gpointer user_data)
{
    guint           *result = user_data;
    const GPtrArray *devices;
    NMDevice        *device;

    g_assert_cmpstr(pspec->name, ==, "devices");

    devices = nm_client_get_devices(c);
    g_assert(devices);
    g_assert_cmpint(devices->len, ==, 1);

    device = g_ptr_array_index(devices, 0);
    g_assert(device);
    g_assert_cmpstr(nm_device_get_iface(device), ==, "eth0");

    g_assert((*result & NOTIFY_MASK) == 0);
    *result |= *result ? NOTIFY_SECOND : NOTIFY_FIRST;
}

static void
test_device_added_signal_after_init(void)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo  = NULL;
    gs_unref_object NMClient                      *client = NULL;
    const GPtrArray                               *devices;
    NMDevice                                      *device;
    guint                                          result = 0;

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    client = nmtstc_client_new(TRUE);

    devices = nm_client_get_devices(client);
    g_assert(devices->len == 0);

    g_signal_connect(client, NM_CLIENT_DEVICE_ADDED, G_CALLBACK(device_sai_added_cb), &result);

    g_signal_connect(client,
                     "notify::" NM_CLIENT_DEVICES,
                     G_CALLBACK(devices_sai_notify_cb),
                     &result);

    /* Tell the test service to add a new device */
    nmtstc_service_add_device(sinfo, client, "AddWiredDevice", "eth0");

    /* Ensure the 'device-added' signal doesn't show up before
     * the 'Devices' property change notification */
    /* coverity[loop_condition] */
    while (!(result & SIGNAL_MASK) && !(result & NOTIFY_MASK))
        g_main_context_iteration(NULL, TRUE);

    g_signal_handlers_disconnect_by_func(client, device_sai_added_cb, &result);
    g_signal_handlers_disconnect_by_func(client, devices_sai_notify_cb, &result);

    g_assert((result & SIGNAL_MASK) == SIGNAL_SECOND);
    g_assert((result & NOTIFY_MASK) == NOTIFY_FIRST);

    devices = nm_client_get_devices(client);
    g_assert(devices);
    g_assert_cmpint(devices->len, ==, 1);

    device = g_ptr_array_index(devices, 0);
    g_assert(device);
    g_assert_cmpstr(nm_device_get_iface(device), ==, "eth0");
}

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

static const char *expected_bssid = "66:55:44:33:22:11";

typedef struct {
    GMainLoop *loop;
    gboolean   found;
    char      *ap_path;
    gboolean   signaled;
    gboolean   notified;
    guint      quit_id;
    guint      quit_count;
} WifiApInfo;

static void
wifi_check_quit(WifiApInfo *info)
{
    info->quit_count--;
    if (info->quit_count == 0) {
        g_source_remove(info->quit_id);
        info->quit_id = 0;
        g_main_loop_quit(info->loop);
    }
}

static void
got_ap_path(WifiApInfo *info, const char *path)
{
    if (info->ap_path)
        g_assert_cmpstr(info->ap_path, ==, path);
    else
        info->ap_path = g_strdup(path);
}

static void
wifi_ap_added_cb(NMDeviceWifi *w, NMAccessPoint *ap, WifiApInfo *info)
{
    g_assert(ap);
    g_assert_cmpstr(nm_access_point_get_bssid(ap), ==, expected_bssid);
    got_ap_path(info, nm_object_get_path(NM_OBJECT(ap)));

    info->signaled = TRUE;
    wifi_check_quit(info);
}

static void
wifi_ap_add_notify_cb(NMDeviceWifi *w, GParamSpec *pspec, WifiApInfo *info)
{
    const GPtrArray *aps;
    NMAccessPoint   *ap;

    aps = nm_device_wifi_get_access_points(w);
    g_assert(aps);
    g_assert_cmpint(aps->len, ==, 1);

    ap = g_ptr_array_index(aps, 0);
    g_assert(ap);
    g_assert_cmpstr(nm_access_point_get_bssid(ap), ==, "66:55:44:33:22:11");
    got_ap_path(info, nm_object_get_path(NM_OBJECT(ap)));

    info->notified = TRUE;
    wifi_check_quit(info);
}

static void
wifi_ap_removed_cb(NMDeviceWifi *w, NMAccessPoint *ap, WifiApInfo *info)
{
    g_assert(ap);
    g_assert_cmpstr(info->ap_path, ==, nm_object_get_path(NM_OBJECT(ap)));

    info->signaled = TRUE;
    wifi_check_quit(info);
}

static void
wifi_ap_remove_notify_cb(NMDeviceWifi *w, GParamSpec *pspec, WifiApInfo *info)
{
    const GPtrArray *aps;

    aps = nm_device_wifi_get_access_points(w);
    g_assert(aps->len == 0);

    info->notified = TRUE;
    wifi_check_quit(info);
}

static void
test_wifi_ap_added_removed(void)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo  = NULL;
    gs_unref_object NMClient                      *client = NULL;
    NMDeviceWifi                                  *wifi;
    WifiApInfo                                     info = {gl.loop, FALSE, FALSE, 0, 0};
    GVariant                                      *ret;
    GError                                        *error         = NULL;
    gs_free char                                  *expected_path = NULL;

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    client = nmtstc_client_new(TRUE);

    /*************************************/
    /* Add the wifi device */
    wifi = (NMDeviceWifi *) nmtstc_service_add_device(sinfo, client, "AddWifiDevice", "wlan0");
    g_assert(NM_IS_DEVICE_WIFI(wifi));

    /*************************************/
    /* Add the wifi AP */
    info.signaled = FALSE;
    info.notified = FALSE;
    info.quit_id  = 0;

    ret = g_dbus_proxy_call_sync(sinfo->proxy,
                                 "AddWifiAp",
                                 g_variant_new("(sss)", "wlan0", "test-ap", expected_bssid),
                                 G_DBUS_CALL_FLAGS_NO_AUTO_START,
                                 3000,
                                 NULL,
                                 &error);
    g_assert_no_error(error);
    g_assert(ret);
    g_assert_cmpstr(g_variant_get_type_string(ret), ==, "(o)");
    g_variant_get(ret, "(o)", &expected_path);
    g_variant_unref(ret);

    g_signal_connect(wifi, "access-point-added", G_CALLBACK(wifi_ap_added_cb), &info);
    info.quit_count = 1;

    g_signal_connect(wifi, "notify::access-points", G_CALLBACK(wifi_ap_add_notify_cb), &info);
    info.quit_count++;

    /* Wait for libnm to find the AP */
    info.quit_id = g_timeout_add_seconds(5, loop_quit, gl.loop);
    g_main_loop_run(gl.loop);

    g_assert(info.signaled);
    g_assert(info.notified);
    g_assert(info.ap_path);
    g_assert_cmpstr(info.ap_path, ==, expected_path);
    g_signal_handlers_disconnect_by_func(wifi, wifi_ap_added_cb, &info);
    g_signal_handlers_disconnect_by_func(wifi, wifi_ap_add_notify_cb, &info);

    /*************************************/
    /* Remove the wifi device */
    info.signaled = FALSE;
    info.notified = FALSE;
    info.quit_id  = 0;

    ret = g_dbus_proxy_call_sync(sinfo->proxy,
                                 "RemoveWifiAp",
                                 g_variant_new("(so)", "wlan0", expected_path),
                                 G_DBUS_CALL_FLAGS_NO_AUTO_START,
                                 3000,
                                 NULL,
                                 &error);
    g_assert_no_error(error);
    nm_clear_pointer(&ret, g_variant_unref);

    g_signal_connect(wifi, "access-point-removed", G_CALLBACK(wifi_ap_removed_cb), &info);
    info.quit_count = 1;

    g_signal_connect(wifi, "notify::access-points", G_CALLBACK(wifi_ap_remove_notify_cb), &info);
    info.quit_count++;

    /* Wait for libnm to find the AP */
    info.quit_id = g_timeout_add_seconds(5, loop_quit, gl.loop);
    g_main_loop_run(gl.loop);

    g_assert(info.signaled);
    g_assert(info.notified);
    g_signal_handlers_disconnect_by_func(wifi, wifi_ap_removed_cb, &info);
    g_signal_handlers_disconnect_by_func(wifi, wifi_ap_remove_notify_cb, &info);

    g_free(info.ap_path);
}

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

typedef struct {
    GMainLoop *loop;
    gboolean   signaled;
    gboolean   notified;
    guint      quit_count;
    guint      quit_id;
} DaInfo;

static void
da_check_quit(DaInfo *info)
{
    info->quit_count--;
    if (info->quit_count == 0) {
        g_source_remove(info->quit_id);
        info->quit_id = 0;
        g_main_loop_quit(info->loop);
    }
}

static void
da_device_removed_cb(NMClient *c, NMDevice *device, DaInfo *info)
{
    g_assert_cmpstr(nm_device_get_iface(device), ==, "eth0");
    info->signaled = TRUE;
    da_check_quit(info);
}

static void
da_devices_notify_cb(NMClient *c, GParamSpec *pspec, DaInfo *info)
{
    const GPtrArray *devices;
    NMDevice        *device;
    guint            i;
    const char      *iface;

    devices = nm_client_get_devices(c);
    g_assert(devices);
    g_assert_cmpint(devices->len, ==, 2);

    for (i = 0; i < devices->len; i++) {
        device = g_ptr_array_index(devices, i);
        iface  = nm_device_get_iface(device);

        g_assert(!strcmp(iface, "wlan0") || !strcmp(iface, "eth1"));
    }

    info->notified = TRUE;
    da_check_quit(info);
}

static void
test_devices_array(void)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo  = NULL;
    gs_unref_object NMClient                      *client = NULL;
    DaInfo                                         info   = {gl.loop};
    NMDevice                                      *wlan0, *eth0, *eth1, *device;
    const GPtrArray                               *devices;
    GError                                        *error = NULL;
    GVariant                                      *ret;

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    client = nmtstc_client_new(TRUE);

    /*************************************/
    /* Add some devices */
    wlan0 = nmtstc_service_add_device(sinfo, client, "AddWifiDevice", "wlan0");
    eth0  = nmtstc_service_add_device(sinfo, client, "AddWiredDevice", "eth0");
    eth1  = nmtstc_service_add_device(sinfo, client, "AddWiredDevice", "eth1");

    /* Ensure the devices now exist */
    devices = nm_client_get_devices(client);
    g_assert(devices);
    g_assert_cmpint(devices->len, ==, 3);

    device = nm_client_get_device_by_iface(client, "wlan0");
    g_assert(NM_IS_DEVICE_WIFI(device));
    g_assert(device == wlan0);

    device = nm_client_get_device_by_iface(client, "eth0");
    g_assert(NM_IS_DEVICE_ETHERNET(device));
    g_assert(device == eth0);

    device = nm_client_get_device_by_iface(client, "eth1");
    g_assert(NM_IS_DEVICE_ETHERNET(device));
    g_assert(device == eth1);

    /********************************/
    /* Now remove the device in the middle */
    ret = g_dbus_proxy_call_sync(sinfo->proxy,
                                 "RemoveDevice",
                                 g_variant_new("(o)", nm_object_get_path(NM_OBJECT(eth0))),
                                 G_DBUS_CALL_FLAGS_NO_AUTO_START,
                                 3000,
                                 NULL,
                                 &error);
    g_assert_no_error(error);
    g_assert(ret);
    g_variant_unref(ret);

    g_signal_connect(client, "device-removed", G_CALLBACK(da_device_removed_cb), &info);

    g_signal_connect(client, "notify::devices", G_CALLBACK(da_devices_notify_cb), &info);
    info.quit_count = 2;

    /* Wait for libnm to notice the changes */
    info.quit_id = g_timeout_add_seconds(5, loop_quit, gl.loop);
    g_main_loop_run(gl.loop);

    g_assert_cmpint(info.quit_count, ==, 0);
    g_signal_handlers_disconnect_by_func(client, da_device_removed_cb, &info);
    g_signal_handlers_disconnect_by_func(client, da_devices_notify_cb, &info);

    /* Ensure only two are left */
    devices = nm_client_get_devices(client);
    g_assert(devices);
    g_assert_cmpint(devices->len, ==, 2);

    device = nm_client_get_device_by_iface(client, "wlan0");
    g_assert(NM_IS_DEVICE_WIFI(device));
    g_assert(device == wlan0);

    device = nm_client_get_device_by_iface(client, "eth1");
    g_assert(NM_IS_DEVICE_ETHERNET(device));
    g_assert(device == eth1);
}

static void
nm_running_changed(GObject *client, GParamSpec *pspec, gpointer user_data)
{
    int *running_changed = user_data;

    if (running_changed)
        (*running_changed)++;
    g_main_loop_quit(gl.loop);
}

static void
test_client_nm_running(void)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo   = NULL;
    gs_unref_object NMClient                      *client1 = NULL;
    gs_unref_object NMClient                      *client2 = NULL;
    guint                                          quit_id;
    int                                            running_changed = 0;
    GError                                        *error           = NULL;

    client1 = nmtstc_client_new(TRUE);

    g_assert(!nm_client_get_nm_running(client1));
    g_assert_cmpstr(nm_client_get_version(client1), ==, NULL);

    g_assert(!nm_client_networking_get_enabled(client1));
    /* This will have no effect, but it shouldn't cause any warnings either. */
    nm_client_networking_set_enabled(client1, TRUE, NULL);
    g_assert(!nm_client_networking_get_enabled(client1));

    /* OTOH, this should result in an error */
    nm_client_set_logging(client1, "DEFAULT", "INFO", &error);
    g_assert_error(error, NM_CLIENT_ERROR, NM_CLIENT_ERROR_MANAGER_NOT_RUNNING);
    g_clear_error(&error);

    /* Now start the test service. */
    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    client2 = nmtstc_client_new(FALSE);

    /* client2 should know that NM is running, but the previously-created
     * client1 hasn't gotten the news yet.
     */
    g_assert(!nm_client_get_nm_running(client1));
    g_assert(nm_client_get_nm_running(client2));

    g_signal_connect(client1,
                     "notify::" NM_CLIENT_NM_RUNNING,
                     G_CALLBACK(nm_running_changed),
                     &running_changed);
    quit_id = g_timeout_add_seconds(5, loop_quit, gl.loop);
    g_main_loop_run(gl.loop);
    g_assert_cmpint(running_changed, ==, 1);
    g_assert(nm_client_get_nm_running(client1));
    g_source_remove(quit_id);

    /* And kill it */
    nm_clear_pointer(&sinfo, nmtstc_service_cleanup);

    g_assert(nm_client_get_nm_running(client1));

    quit_id = g_timeout_add_seconds(5, loop_quit, gl.loop);
    g_main_loop_run(gl.loop);
    g_assert_cmpint(running_changed, ==, 2);
    g_assert(!nm_client_get_nm_running(client1));
    g_source_remove(quit_id);
}

typedef struct {
    GMainLoop          *loop;
    NMActiveConnection *ac;

    int remaining;

    NMDevice *device;
    gulong    ac_signal_id;
} TestACInfo;

static void
assert_ac_and_device(NMClient *client)
{
    const GPtrArray    *devices, *acs, *ac_devices;
    NMDevice           *device, *ac_device;
    NMActiveConnection *ac, *device_ac;

    acs = nm_client_get_active_connections(client);
    g_assert(acs != NULL);
    g_assert_cmpint(acs->len, ==, 1);
    devices = nm_client_get_devices(client);
    g_assert(devices != NULL);
    g_assert_cmpint(devices->len, >=, 1);

    ac         = acs->pdata[0];
    ac_devices = nm_active_connection_get_devices(ac);
    g_assert(ac_devices != NULL);
    g_assert_cmpint(ac_devices->len, ==, 1);
    ac_device = ac_devices->pdata[0];
    g_assert(ac_device != NULL);

    device = devices->pdata[0];
    if (device != ac_device && devices->len > 1)
        device = devices->pdata[1];

    g_assert_cmpstr(nm_object_get_path(NM_OBJECT(device)),
                    ==,
                    nm_object_get_path(NM_OBJECT(ac_device)));
    g_assert(device == ac_device);

    device_ac = nm_device_get_active_connection(device);
    if (!device_ac) {
        /* the stub NetworkManager service starts activating in an idle handler (delayed). That means, the
         * device may not yet refer to the active connection at this point. */
    } else {
        g_assert_cmpstr(nm_object_get_path(NM_OBJECT(ac)),
                        ==,
                        nm_object_get_path(NM_OBJECT(device_ac)));
        g_assert(ac == device_ac);
    }
}

static void
add_and_activate_cb(GObject *object, GAsyncResult *result, gpointer user_data)
{
    NMClient   *client = NM_CLIENT(object);
    TestACInfo *info   = user_data;
    GError     *error  = NULL;

    info->ac = nm_client_add_and_activate_connection_finish(client, result, &error);
    g_assert_no_error(error);
    g_assert(info->ac != NULL);

    assert_ac_and_device(client);

    info->remaining--;
    if (!info->remaining)
        g_main_loop_quit(info->loop);
}

static void
client_acs_changed_cb(GObject *client, GParamSpec *pspec, gpointer user_data)
{
    TestACInfo      *info = user_data;
    const GPtrArray *acs;

    acs = nm_client_get_active_connections(NM_CLIENT(client));
    g_assert(acs != NULL);
    g_assert_cmpint(acs->len, ==, 1);

    info->remaining--;
    if (!info->remaining)
        g_main_loop_quit(info->loop);
}

static void
device_ac_changed_cb(GObject *device, GParamSpec *pspec, gpointer user_data)
{
    TestACInfo *info = user_data;

    g_assert(nm_device_get_active_connection(NM_DEVICE(device)) != NULL);

    info->remaining--;
    if (!info->remaining)
        g_main_loop_quit(info->loop);
}

static void
test_active_connections(void)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo  = NULL;
    gs_unref_object NMClient                      *client = NULL;
    NMDevice                                      *device;
    NMConnection                                  *conn;
    TestACInfo                                     info = {gl.loop, NULL, 0};

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    client = nmtstc_client_new(TRUE);

    /* Tell the test service to add a new device */
    device = nmtstc_service_add_device(sinfo, client, "AddWiredDevice", "eth0");

    conn = nmtst_create_minimal_connection("test-ac", NULL, NM_SETTING_WIRED_SETTING_NAME, NULL);
    nm_client_add_and_activate_connection_async(client,
                                                conn,
                                                device,
                                                NULL,
                                                NULL,
                                                add_and_activate_cb,
                                                &info);
    g_object_unref(conn);

    g_signal_connect(client,
                     "notify::" NM_CLIENT_ACTIVE_CONNECTIONS,
                     G_CALLBACK(client_acs_changed_cb),
                     &info);
    g_signal_connect(device,
                     "notify::" NM_DEVICE_ACTIVE_CONNECTION,
                     G_CALLBACK(device_ac_changed_cb),
                     &info);

    /* Two signals plus activate_cb */
    info.remaining = 3;
    g_main_loop_run(gl.loop);
    g_signal_handlers_disconnect_by_func(client, client_acs_changed_cb, &info);
    g_signal_handlers_disconnect_by_func(device, device_ac_changed_cb, &info);

    g_assert(info.ac != NULL);

    g_object_unref(info.ac);
    g_clear_object(&client);

    /* Ensure that we can correctly resolve the recursive property link between the
     * AC and the Device in a newly-created client.
     */
    client = nmtstc_client_new(TRUE);
    assert_ac_and_device(client);
    g_clear_object(&client);

    client = nmtstc_client_new(TRUE);
    assert_ac_and_device(client);
    g_clear_object(&client);
}

static void
client_devices_changed_cb(GObject *client, GParamSpec *pspec, gpointer user_data)
{
    TestACInfo      *info = user_data;
    const GPtrArray *devices;
    NMDevice        *device;

    devices = nm_client_get_devices(NM_CLIENT(client));
    g_assert(devices != NULL);
    if (devices->len < 2)
        return;
    g_assert_cmpint(devices->len, ==, 2);

    if (NM_IS_DEVICE_VLAN(devices->pdata[0]))
        device = devices->pdata[0];
    else if (NM_IS_DEVICE_VLAN(devices->pdata[1]))
        device = devices->pdata[1];
    else
        g_assert_not_reached();

    g_assert_cmpstr(nm_device_get_iface(device), ==, "eth0.1");

    if (!nm_device_get_active_connection(device)) {
        g_assert(info->ac_signal_id == 0);
        info->remaining++;
        info->device = device;
        g_object_add_weak_pointer(G_OBJECT(device), (gpointer *) &info->device);
        info->ac_signal_id = g_signal_connect(device,
                                              "notify::" NM_DEVICE_ACTIVE_CONNECTION,
                                              G_CALLBACK(device_ac_changed_cb),
                                              info);
    }

    info->remaining--;
    if (!info->remaining)
        g_main_loop_quit(info->loop);
}

typedef struct {
    GMainLoop          *loop;
    NMRemoteConnection *remote;
} TestConnectionInfo;

static void
add_connection_cb(GObject *object, GAsyncResult *result, gpointer user_data)
{
    TestConnectionInfo *info  = user_data;
    GError             *error = NULL;

    info->remote = nm_client_add_connection_finish(NM_CLIENT(object), result, &error);
    g_assert_no_error(error);
    g_main_loop_quit(info->loop);
}

static void
activate_cb(GObject *object, GAsyncResult *result, gpointer user_data)
{
    NMClient   *client = NM_CLIENT(object);
    TestACInfo *info   = user_data;
    GError     *error  = NULL;

    info->ac = nm_client_activate_connection_finish(client, result, &error);
    g_assert_no_error(error);
    g_assert(info->ac != NULL);

    assert_ac_and_device(client);

    info->remaining--;
    if (!info->remaining)
        g_main_loop_quit(info->loop);
}

static NMClient *
_activate_virtual(NMTstcServiceInfo *sinfo)
{
    NMClient            *client = NULL;
    NMConnection        *conn;
    NMSettingConnection *s_con;
    NMSettingVlan       *s_vlan;
    TestACInfo           info      = {gl.loop, NULL, 0};
    TestConnectionInfo   conn_info = {gl.loop, NULL};

    client = nmtstc_client_new(TRUE);

    nmtstc_service_add_device(sinfo, client, "AddWiredDevice", "eth0");

    conn = nmtst_create_minimal_connection("test-ac", NULL, NM_SETTING_VLAN_SETTING_NAME, &s_con);
    g_object_set(s_con, NM_SETTING_CONNECTION_INTERFACE_NAME, "eth0.1", NULL);
    s_vlan = nm_connection_get_setting_vlan(conn);
    g_object_set(s_vlan, NM_SETTING_VLAN_ID, 1, NM_SETTING_VLAN_PARENT, "eth0", NULL);

    nm_client_add_connection_async(client, conn, TRUE, NULL, add_connection_cb, &conn_info);
    g_main_loop_run(gl.loop);
    g_object_unref(conn);
    conn = NM_CONNECTION(conn_info.remote);

    nm_client_activate_connection_async(client, conn, NULL, NULL, NULL, activate_cb, &info);
    g_object_unref(conn);

    g_signal_connect(client,
                     "notify::" NM_CLIENT_ACTIVE_CONNECTIONS,
                     G_CALLBACK(client_acs_changed_cb),
                     &info);
    g_signal_connect(client,
                     "notify::" NM_CLIENT_DEVICES,
                     G_CALLBACK(client_devices_changed_cb),
                     &info);

    /* We're expecting a client::devices change, client::activate callback,
     * and a device::active-connection change.
     * The client::devices callback can hook a client::active-connections
     * change and bump this if the property is not yet loaded.
     */
    info.remaining = 3;

    g_main_loop_run(gl.loop);
    g_signal_handlers_disconnect_by_func(client, client_acs_changed_cb, &info);
    g_signal_handlers_disconnect_by_func(client, client_devices_changed_cb, &info);

    g_assert(info.ac != NULL);
    g_clear_object(&info.ac);

    if (info.device) {
        g_object_remove_weak_pointer(G_OBJECT(info.device), (gpointer *) &info.device);
        nm_clear_g_signal_handler(info.device, &info.ac_signal_id);
    }

    return client;
}

static void
test_activate_virtual(void)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo = NULL;

    if (nmtst_test_skip_slow())
        return;

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    g_object_unref(_activate_virtual(sinfo));
}

static void
_client_dev_removed(NMClient *client, NMDevice *device, int *p_count_call)
{
    (*p_count_call)++;
}

static void
test_activate_virtual_teardown(gconstpointer user_data)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo  = NULL;
    gs_unref_object NMClient                      *client = NULL;
    NMDevice                                      *dev_eth0_1;
    NMActiveConnection                            *ac;
    const GPtrArray                               *arr;
    int                                            call_count       = 0;
    gboolean                                       take_ref         = nmtst_get_rand_bool();
    gboolean                                       teardown_service = GPOINTER_TO_INT(user_data);

    if (nmtst_test_skip_slow())
        return;

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    client = _activate_virtual(sinfo);

    /* ensure we got all the necessary events in place. */
    nmtst_main_loop_run(gl.loop, 50);

    dev_eth0_1 = nm_client_get_device_by_iface(client, "eth0.1");
    g_assert(NM_IS_DEVICE_VLAN(dev_eth0_1));
    if (take_ref)
        g_object_ref(dev_eth0_1);

    arr = nm_device_get_available_connections(dev_eth0_1);
    g_assert(arr);
    g_assert_cmpint(arr->len, ==, 1);

    ac = nm_device_get_active_connection(dev_eth0_1);
    g_assert(NM_IS_ACTIVE_CONNECTION(ac));

    g_signal_connect(client, "device-removed", G_CALLBACK(_client_dev_removed), &call_count);

    if (teardown_service) {
        g_signal_connect(client,
                         "notify::" NM_CLIENT_NM_RUNNING,
                         G_CALLBACK(nm_running_changed),
                         NULL);
        nm_clear_pointer(&sinfo, nmtstc_service_cleanup);
        nmtst_main_loop_run(gl.loop, 1000);
        g_assert_cmpint(call_count, ==, 2);
    } else {
        g_clear_object(&client);
        g_assert_cmpint(call_count, ==, 0);
    }

    if (take_ref) {
        arr = nm_device_get_available_connections(dev_eth0_1);
        g_assert(arr);
        g_assert_cmpint(arr->len, ==, 0);

        g_assert(!nm_device_get_active_connection(dev_eth0_1));

        g_object_unref(dev_eth0_1);
    }
}

static void
test_device_connection_compatibility(void)
{
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo  = NULL;
    gs_unref_object NMClient                      *client = NULL;
    gs_unref_object NMConnection                  *conn   = NULL;
    NMDevice                                      *device1;
    NMDevice                                      *device2;
    NMSettingWired                                *s_wired;
    GError                                        *error = NULL;
    const char *subchannels[]   = {"0.0.8000", "0.0.8001", "0.0.8002", NULL};
    const char *subchannels_2[] = {"0.0.8000", "0.0.8001", NULL};
    const char *subchannels_x[] = {"0.0.8000", "0.0.8001", "0.0.800X", NULL};
    const char *hw_addr1        = "52:54:00:ab:db:23";
    const char *hw_addr2        = "52:54:00:ab:db:24";

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    client = nmtstc_client_new(TRUE);

    /* Create two devices */
    device1 = nmtstc_service_add_wired_device(sinfo, client, "eth0", hw_addr1, subchannels);
    device2 = nmtstc_service_add_wired_device(sinfo, client, "eth1", hw_addr2, NULL);

    g_assert_cmpstr(nm_device_get_hw_address(device1), ==, hw_addr1);
    g_assert_cmpstr(nm_device_get_hw_address(device2), ==, hw_addr2);

    conn =
        nmtst_create_minimal_connection("wired-matches", NULL, NM_SETTING_WIRED_SETTING_NAME, NULL);
    s_wired = nm_connection_get_setting_wired(conn);
    nm_setting_wired_add_mac_blacklist_item(s_wired, "00:11:22:33:44:55");

    /* device1 and conn are compatible */
    g_object_set(s_wired,
                 NM_SETTING_WIRED_MAC_ADDRESS,
                 hw_addr1,
                 NM_SETTING_WIRED_S390_SUBCHANNELS,
                 subchannels,
                 NULL);
    nm_device_connection_compatible(device1, conn, &error);
    g_assert_no_error(error);

    /* device2 and conn differ in subchannels */
    g_object_set(s_wired, NM_SETTING_WIRED_S390_SUBCHANNELS, subchannels_x, NULL);
    nm_device_connection_compatible(device2, conn, &error);
    g_assert_error(error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION);
    g_clear_error(&error);

    /* device1 and conn differ in subchannels - 2 in connection, 3 in device */
    g_object_set(s_wired, NM_SETTING_WIRED_S390_SUBCHANNELS, subchannels_2, NULL);
    nm_device_connection_compatible(device1, conn, &error);
    g_assert_error(error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION);
    g_clear_error(&error);

    g_object_set(s_wired, NM_SETTING_WIRED_S390_SUBCHANNELS, NULL, NULL);

    /* device2 and conn differ in MAC address */
    g_object_set(s_wired, NM_SETTING_WIRED_MAC_ADDRESS, "aa:bb:cc:dd:ee:ee", NULL);
    nm_device_connection_compatible(device2, conn, &error);
    g_assert_error(error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION);
    g_clear_error(&error);
    g_object_set(s_wired, NM_SETTING_WIRED_MAC_ADDRESS, NULL, NULL);

    /* device1 is blacklisted in conn */
    nm_setting_wired_add_mac_blacklist_item(s_wired, hw_addr1);
    nm_device_connection_compatible(device1, conn, &error);
    g_assert_error(error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION);
    g_clear_error(&error);
}

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

static gboolean
_test_connection_invalid_find_connections(gpointer element, gpointer needle, gpointer user_data)
{
    NMRemoteConnection *con  = NM_REMOTE_CONNECTION(element);
    const char         *path = needle;

    g_assert(NM_IS_REMOTE_CONNECTION(con));
    g_assert(path && *path);

    return strcmp(path, nm_connection_get_path((NMConnection *) con)) == 0;
}

#define ASSERT_IDX(i)                                                                     \
    G_STMT_START                                                                          \
    {                                                                                     \
        g_assert_cmpint(idx[i], >=, 0);                                                   \
        g_assert(path##i && *path##i);                                                    \
        g_assert(NM_IS_REMOTE_CONNECTION(connections->pdata[idx[i]]));                    \
        g_assert_cmpstr(nm_connection_get_path(connections->pdata[idx[i]]), ==, path##i); \
    }                                                                                     \
    G_STMT_END

static void
test_connection_invalid(void)
{
    NMTSTC_SERVICE_INFO_SETUP(my_sinfo);
    gs_unref_object NMConnection *connection = NULL;
    NMSettingConnection          *s_con;
    gs_unref_object NMClient     *client = NULL;
    const GPtrArray              *connections;
    gs_free char                 *path0 = NULL;
    gs_free char                 *path1 = NULL;
    gs_free char                 *path2 = NULL;
    gs_free char                 *path3 = NULL;
    gs_free char                 *uuid2 = NULL;
    gsize                         n_found;
    gssize                        idx[4];
    gs_unref_variant GVariant    *variant = NULL;

    g_assert(g_main_loop_get_context(gl.loop)
             == (g_main_context_get_thread_default() ?: g_main_context_default()));

    /**************************************************************************
     * Add three connections before starting libnm. One valid, two invalid.
     *************************************************************************/

    connection = nmtst_create_minimal_connection("test-connection-invalid-0",
                                                 NULL,
                                                 NM_SETTING_WIRED_SETTING_NAME,
                                                 &s_con);
    nmtst_connection_normalize(connection);
    g_object_set(s_con, NM_SETTING_CONNECTION_UUID, nmtst_uuid_generate(), NULL);
    nmtstc_service_add_connection(my_sinfo, connection, TRUE, &path0);

    nm_connection_remove_setting(connection, NM_TYPE_SETTING_WIRED);
    g_object_set(s_con,
                 NM_SETTING_CONNECTION_ID,
                 "test-connection-invalid-1",
                 NM_SETTING_CONNECTION_TYPE,
                 "invalid-type-1",
                 NM_SETTING_CONNECTION_UUID,
                 nmtst_uuid_generate(),
                 NULL);
    nmtstc_service_add_connection(my_sinfo, connection, FALSE, &path1);

    g_object_set(s_con,
                 NM_SETTING_CONNECTION_ID,
                 "test-connection-invalid-2",
                 NM_SETTING_CONNECTION_TYPE,
                 "invalid-type-2",
                 NM_SETTING_CONNECTION_UUID,
                 nmtst_uuid_generate(),
                 NULL);
    variant = nm_connection_to_dbus(connection, NM_CONNECTION_SERIALIZE_ALL);
    NMTST_VARIANT_EDITOR(
        variant,
        NMTST_VARIANT_ADD_SETTING("invalid-type-2",
                                  nmtst_variant_new_vardict("some-key1",
                                                            g_variant_new_string("some-value1"),
                                                            "some-key2",
                                                            g_variant_new_uint32(4722))));
    g_variant_ref_sink(variant);
    nmtstc_service_add_connection_variant(my_sinfo, variant, FALSE, &path2);

    client = nmtstc_client_new(TRUE);

    connections = nm_client_get_connections(client);
    g_assert(connections);

    g_assert_cmpint(connections->len, ==, 3);
    n_found = nmtst_find_all_indexes(connections->pdata,
                                     connections->len,
                                     (gpointer *) ((const char *[]) {path0, path1, path2}),
                                     3,
                                     _test_connection_invalid_find_connections,
                                     NULL,
                                     idx);
    g_assert_cmpint(n_found, ==, 3);
    ASSERT_IDX(0);
    ASSERT_IDX(1);
    ASSERT_IDX(2);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[0]]);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[1]], 0, 0);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[2]], 0, 0);

    /**************************************************************************
     * After having the client up and running, add another invalid connection
     *************************************************************************/

    g_object_set(s_con,
                 NM_SETTING_CONNECTION_ID,
                 "test-connection-invalid-2",
                 NM_SETTING_CONNECTION_TYPE,
                 "invalid-type-2",
                 NM_SETTING_CONNECTION_UUID,
                 (uuid2 = g_strdup(nmtst_uuid_generate())),
                 NULL);
    nmtstc_service_add_connection(my_sinfo, connection, FALSE, &path3);

    nmtst_main_loop_run(gl.loop, 1000);

    connections = nm_client_get_connections(client);
    g_assert(connections);

    g_assert_cmpint(connections->len, ==, 4);
    n_found = nmtst_find_all_indexes(connections->pdata,
                                     connections->len,
                                     (gpointer *) ((const char *[]) {path0, path1, path2, path3}),
                                     4,
                                     _test_connection_invalid_find_connections,
                                     NULL,
                                     idx);
    g_assert_cmpint(n_found, ==, 4);
    ASSERT_IDX(0);
    ASSERT_IDX(1);
    ASSERT_IDX(2);
    ASSERT_IDX(3);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[0]]);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[1]], 0, 0);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[2]], 0, 0);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[3]], 0, 0);

    /**************************************************************************
     * Modify the invalid connection (still invalid)
     *************************************************************************/

    NMTST_VARIANT_EDITOR(variant,
                         NMTST_VARIANT_CHANGE_PROPERTY("invalid-type-2", "some-key2", "u", 4721));
    g_variant_ref_sink(variant);
    nmtstc_service_update_connection_variant(my_sinfo, path2, variant, FALSE);

    nmtst_main_loop_run(gl.loop, 100);

    connections = nm_client_get_connections(client);
    g_assert(connections);

    g_assert_cmpint(connections->len, ==, 4);
    n_found = nmtst_find_all_indexes(connections->pdata,
                                     connections->len,
                                     (gpointer *) ((const char *[]) {path0, path1, path2, path3}),
                                     4,
                                     _test_connection_invalid_find_connections,
                                     NULL,
                                     idx);
    g_assert_cmpint(n_found, ==, 4);
    ASSERT_IDX(0);
    ASSERT_IDX(1);
    ASSERT_IDX(2);
    ASSERT_IDX(3);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[0]]);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[1]], 0, 0);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[2]], 0, 0);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[3]], 0, 0);

    /**************************************************************************
     * Modify the invalid connection (becomes valid)
     *************************************************************************/

    NMTST_VARIANT_EDITOR(variant, NMTST_VARIANT_DROP_SETTING("invalid-type-2"));
    NMTST_VARIANT_EDITOR(variant,
                         NMTST_VARIANT_CHANGE_PROPERTY(NM_SETTING_CONNECTION_SETTING_NAME,
                                                       NM_SETTING_CONNECTION_TYPE,
                                                       "s",
                                                       NM_SETTING_WIRED_SETTING_NAME));
    g_variant_ref_sink(variant);
    nmtstc_service_update_connection_variant(my_sinfo, path2, variant, FALSE);

    nmtst_main_loop_run(gl.loop, 100);

    connections = nm_client_get_connections(client);
    g_assert(connections);

    g_assert_cmpint(connections->len, ==, 4);
    n_found = nmtst_find_all_indexes(connections->pdata,
                                     connections->len,
                                     (gpointer *) ((const char *[]) {path0, path1, path2, path3}),
                                     4,
                                     _test_connection_invalid_find_connections,
                                     NULL,
                                     idx);
    g_assert_cmpint(n_found, ==, 4);
    ASSERT_IDX(0);
    ASSERT_IDX(1);
    ASSERT_IDX(2);
    ASSERT_IDX(3);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[0]]);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[1]], 0, 0);
    nmtst_assert_connection_verifies_after_normalization(connections->pdata[idx[2]], 0, 0);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[3]], 0, 0);

    /**************************************************************************
     * Modify the invalid connection (still invalid)
     *************************************************************************/

    g_object_set(s_con, NM_SETTING_CONNECTION_ID, "test-connection-invalid-2x", NULL);
    nmtstc_service_update_connection(my_sinfo, path3, connection, FALSE);

    nmtst_main_loop_run(gl.loop, 100);

    connections = nm_client_get_connections(client);
    g_assert(connections);

    g_assert_cmpint(connections->len, ==, 4);
    n_found = nmtst_find_all_indexes(connections->pdata,
                                     connections->len,
                                     (gpointer *) ((const char *[]) {path0, path1, path2, path3}),
                                     4,
                                     _test_connection_invalid_find_connections,
                                     NULL,
                                     idx);
    g_assert_cmpint(n_found, ==, 4);
    ASSERT_IDX(0);
    ASSERT_IDX(1);
    ASSERT_IDX(2);
    ASSERT_IDX(3);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[0]]);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[1]], 0, 0);
    nmtst_assert_connection_verifies_after_normalization(connections->pdata[idx[2]], 0, 0);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[3]], 0, 0);
    g_assert_cmpstr("test-connection-invalid-2x",
                    ==,
                    nm_connection_get_id(connections->pdata[idx[3]]));

    /**************************************************************************
     * Modify the invalid connection (now becomes valid)
     *************************************************************************/

    g_clear_object(&connection);
    connection = nmtst_create_minimal_connection("test-connection-invalid-2",
                                                 NULL,
                                                 NM_SETTING_WIRED_SETTING_NAME,
                                                 &s_con);
    nmtst_connection_normalize(connection);
    g_object_set(s_con,
                 NM_SETTING_CONNECTION_ID,
                 "test-connection-invalid-2z",
                 NM_SETTING_CONNECTION_TYPE,
                 "802-3-ethernet",
                 NM_SETTING_CONNECTION_UUID,
                 uuid2,
                 NULL);

    nmtstc_service_update_connection(my_sinfo, path3, connection, FALSE);

    nmtst_main_loop_run(gl.loop, 100);

    connections = nm_client_get_connections(client);
    g_assert(connections);

    g_assert_cmpint(connections->len, ==, 4);
    n_found = nmtst_find_all_indexes(connections->pdata,
                                     connections->len,
                                     (gpointer *) ((const char *[]) {path0, path1, path2, path3}),
                                     4,
                                     _test_connection_invalid_find_connections,
                                     NULL,
                                     idx);
    g_assert_cmpint(n_found, ==, 4);
    ASSERT_IDX(0);
    ASSERT_IDX(1);
    ASSERT_IDX(2);
    ASSERT_IDX(3);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[0]]);
    nmtst_assert_connection_unnormalizable(connections->pdata[idx[1]], 0, 0);
    nmtst_assert_connection_verifies_after_normalization(connections->pdata[idx[2]], 0, 0);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[3]]);
    g_assert_cmpstr("test-connection-invalid-2z",
                    ==,
                    nm_connection_get_id(connections->pdata[idx[3]]));

    /**************************************************************************
     * Modify the invalid connection and make it valid
     *************************************************************************/

    g_clear_object(&connection);
    connection = nmtst_create_minimal_connection("test-connection-invalid-1",
                                                 NULL,
                                                 NM_SETTING_WIRED_SETTING_NAME,
                                                 &s_con);
    nmtst_connection_normalize(connection);
    g_object_set(s_con,
                 NM_SETTING_CONNECTION_ID,
                 "test-connection-invalid-1x",
                 NM_SETTING_CONNECTION_TYPE,
                 "802-3-ethernet",
                 NM_SETTING_CONNECTION_UUID,
                 nm_connection_get_uuid(connections->pdata[idx[1]]),
                 NULL);

    nmtstc_service_update_connection(my_sinfo, path1, connection, FALSE);

    nmtst_main_loop_run(gl.loop, 100);

    connections = nm_client_get_connections(client);
    g_assert(connections);

    g_assert_cmpint(connections->len, ==, 4);
    n_found = nmtst_find_all_indexes(connections->pdata,
                                     connections->len,
                                     (gpointer *) ((const char *[]) {path0, path1, path2, path3}),
                                     4,
                                     _test_connection_invalid_find_connections,
                                     NULL,
                                     idx);
    g_assert_cmpint(n_found, ==, 4);
    ASSERT_IDX(0);
    ASSERT_IDX(1);
    ASSERT_IDX(2);
    ASSERT_IDX(3);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[0]]);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[1]]);
    nmtst_assert_connection_verifies_after_normalization(connections->pdata[idx[2]], 0, 0);
    nmtst_assert_connection_verifies_without_normalization(connections->pdata[idx[3]]);
    g_assert_cmpstr("test-connection-invalid-1x",
                    ==,
                    nm_connection_get_id(connections->pdata[idx[1]]));
    g_assert_cmpstr("test-connection-invalid-2z",
                    ==,
                    nm_connection_get_id(connections->pdata[idx[3]]));

#undef ASSERT_IDX
}

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

typedef struct {
    NMClient    *nmc;
    NMOptionBool completed;
} WaitShutdownNmcInitData;

static void
_wait_shutdown_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    gs_free_error GError *error = NULL;
    gboolean              b;
    guint                *p_pending_ops = user_data;

    g_assert(!source);

    if (nmtst_get_rand_bool()) {
        b = nm_client_wait_shutdown_finish(result, &error);
        g_assert(b == !error);
    }

    g_assert_cmpint(*p_pending_ops, >, 0);
    (*p_pending_ops)--;
}

static void
_wait_shutdown_nmc_init_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    WaitShutdownNmcInitData *data  = user_data;
    gs_free_error GError    *error = NULL;
    gboolean                 b;

    g_assert(data->nmc == NM_CLIENT(source));
    g_assert(data->completed == NM_OPTION_BOOL_DEFAULT);

    b = g_async_initable_init_finish(G_ASYNC_INITABLE(source), result, &error);
    nmtst_assert_success(b, error);
    g_assert(b == TRUE);

    g_assert(NM_FLAGS_HAS(nm_client_get_instance_flags(data->nmc),
                          NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD));

    data->completed = TRUE;
}

static void
test_client_wait_shutdown(void)
{
    gs_unref_ptrarray GPtrArray *contexts =
        g_ptr_array_new_with_free_func((GDestroyNotify) g_main_context_unref);
    nmtstc_auto_service_cleanup NMTstcServiceInfo *sinfo = NULL;
    int                                            i_run;
    const int                                      N_RUN           = 50;
    gs_free_error GError                          *error           = NULL;
    gs_unref_object GDBusConnection               *dbus_connection = NULL;
    guint                                          pending_ops     = 0;
    int                                            i;
    gint64                                         until_msec;

    /* The test creates NMClient instances in various ways (with different
     * context of g_main_context_default()) and with sync/asnyc/no initialization.
     *
     * Then it calls nm_client_wait_shutdown() and checks that all callbacks
     * got invoked.
     *
     * You can also manually bump N_RUN and convince yourself that there are no
     * leaks.
     */

    sinfo = nmtstc_service_init();
    if (!nmtstc_service_available(sinfo))
        return;

    /* Have 5 contexts for creating clients (+ the default one). */
    g_ptr_array_add(contexts, g_main_context_ref(g_main_context_default()));
    for (i = 0; i < 5; i++)
        g_ptr_array_add(contexts, g_main_context_new());

    dbus_connection = g_bus_get_sync(_nm_dbus_bus_type(), NULL, &error);
    nmtst_assert_success(dbus_connection, error);

    for (i_run = 0; i_run < N_RUN; i_run++) {
        gs_unref_object GCancellable          *init_cancellable = g_cancellable_new();
        gs_unref_object NMClient              *nmc              = NULL;
        nm_auto_pop_gmaincontext GMainContext *client_context   = NULL;
        gboolean                               b;
        gboolean                               context_integrated = FALSE;
        gs_unref_object GCancellable          *cancellable_1      = NULL;
        GMainContext                          *ctx;

        /* Choose a random context for the client. */
        ctx = contexts->pdata[nmtst_get_rand_uint32() % contexts->len];
        if (ctx == g_main_context_default()) {
            /* don't use the main context explicitly. */
        } else if (!g_main_context_acquire(ctx)) {
            /* the context is in use, we cannot use it. */
        } else {
            g_main_context_release(ctx);
            client_context = g_main_context_ref(ctx);
            g_main_context_push_thread_default(client_context);
        }

        nmc = g_object_new(
            NM_TYPE_CLIENT,
            NM_CLIENT_INSTANCE_FLAGS,
            nmtst_get_rand_one_case_in(5) ? NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS : 0,
            NM_CLIENT_DBUS_CONNECTION,
            nmtst_get_rand_one_case_in(3) ? NULL : dbus_connection,
            NULL);

        if (nmtst_get_rand_bool()) {
            /* randomly already pop the context before initializing nmc. */
            nm_clear_pointer(&client_context, nm_g_main_context_pop_and_unref);
        }

        if (nmtst_get_rand_bool()) {
            nm_auto_pop_gmaincontext GMainContext *context =
                nm_g_main_context_push_thread_default(NULL);

            /* It is also allowed to start waiting before initialization started. Randomly do that. */
            pending_ops++;
            nm_client_wait_shutdown(
                nmc,
                nmtst_true_once(&context_integrated, nmtst_get_rand_bool()),
                (cancellable_1 = nmtst_get_rand_bool() ? g_cancellable_new() : NULL),
                _wait_shutdown_cb,
                &pending_ops);
        }

        /* randomly do some initialization... */
        switch (nmtst_get_rand_uint32() % 4) {
        case 0:
            /* Don't start initialization. */
            break;
        case 1:
            /* Do sync initialization. */
            b = g_initable_init(G_INITABLE(nmc),
                                nmtst_get_rand_bool() ? init_cancellable : NULL,
                                &error);
            nmtst_assert_success(b, error);
            break;
        case 2:
            /* Start async initialization in the background, but don't wait for it complete. */
            g_async_initable_init_async(G_ASYNC_INITABLE(nmc),
                                        G_PRIORITY_DEFAULT,
                                        nmtst_get_rand_bool() ? init_cancellable : NULL,
                                        NULL,
                                        NULL);
            break;
        default:
        {
            /* Do async initialization, and iterate the main context until done. */
            WaitShutdownNmcInitData data = {
                .completed = NM_OPTION_BOOL_DEFAULT,
                .nmc       = nmc,
            };

            g_async_initable_init_async(G_ASYNC_INITABLE(nmc),
                                        G_PRIORITY_DEFAULT,
                                        nmtst_get_rand_bool() ? init_cancellable : NULL,
                                        _wait_shutdown_nmc_init_cb,
                                        &data);

            while (data.completed != TRUE) {
                g_main_context_iteration(context_integrated ? g_main_context_default()
                                                            : nm_client_get_main_context(nmc),
                                         TRUE);
            }
            break;
        }
        }

        if (!context_integrated && nmtst_get_rand_bool()) {
            nm_clear_g_cancellable(&cancellable_1);
        }

        if (nmtst_get_rand_bool())
            nm_clear_pointer(&client_context, nm_g_main_context_pop_and_unref);

        {
            gs_unref_object GCancellable *cancellable = NULL;

            pending_ops++;
            nm_client_wait_shutdown(
                nmc,
                nmtst_true_once(&context_integrated, nmtst_get_rand_bool()),
                (cancellable = nmtst_get_rand_bool() ? g_cancellable_new() : NULL),
                _wait_shutdown_cb,
                &pending_ops);
        }

        if (nmtst_get_rand_bool())
            g_clear_object(&nmc);

        for (i = 0; i < (int) contexts->len; i++) {
            GMainContext *context = contexts->pdata[i];

            if (nmtst_get_rand_bool()) {
                /* iterate next time. */
                continue;
            }

            if (!g_main_context_acquire(context)) {
                /* It's integrated, skip. */
                continue;
            }
            g_main_context_release(context);

            while (g_main_context_iteration(context, FALSE)) {
                /* pass */
            }
        }
    }

    until_msec = nm_utils_get_monotonic_timestamp_msec() + 10000;
    while (pending_ops > 0 && nm_utils_get_monotonic_timestamp_msec() < until_msec) {
        for (i = contexts->len; i > 0; i--) {
            GMainContext *context = contexts->pdata[i - 1];

            if (!g_main_context_acquire(context)) {
                /* integrated, skip. */
                continue;
            }
            g_main_context_release(context);

            while (g_main_context_iteration(context, FALSE)) {
                /* pass */
            }
        }
    }

    g_assert_cmpint(pending_ops, ==, 0);
}

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

NMTST_DEFINE();

int
main(int argc, char **argv)
{
    g_setenv("LIBNM_USE_SESSION_BUS", "1", TRUE);

    nmtst_init(&argc, &argv, TRUE);

    gl.loop = g_main_loop_new(NULL, FALSE);

    g_test_add_func("/libnm/device-added", test_device_added);
    g_test_add_func("/libnm/device-added-signal-after-init", test_device_added_signal_after_init);
    g_test_add_func("/libnm/wifi-ap-added-removed", test_wifi_ap_added_removed);
    g_test_add_func("/libnm/devices-array", test_devices_array);
    g_test_add_func("/libnm/client-nm-running", test_client_nm_running);
    g_test_add_func("/libnm/active-connections", test_active_connections);
    g_test_add_func("/libnm/activate-virtual/without-teardown", test_activate_virtual);
    g_test_add_data_func("/libnm/activate-virtual/with-teardown/service",
                         GINT_TO_POINTER(true),
                         test_activate_virtual_teardown);
    g_test_add_data_func("/libnm/activate-virtual/with-teardown/client",
                         GINT_TO_POINTER(false),
                         test_activate_virtual_teardown);
    g_test_add_func("/libnm/device-connection-compatibility", test_device_connection_compatibility);
    g_test_add_func("/libnm/connection/invalid", test_connection_invalid);
    g_test_add_func("/libnm/test_client_wait_shutdown", test_client_wait_shutdown);

    return g_test_run();
}

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

/* this header is intended to be copied to users of nm_vpn_editor_plugin_call(),
 * to simplify invocation of generic functions. Include it here, to compile
 * the code. */
#include "contrib/nm-vpn-editor-plugin-call.h"
