Imported Upstream version 1.1.91 upstream/1.1.91

1 files changed, 230 insertions, 176 deletions

diff --git a/libnm-core/tests/test-general.c b/libnm-core/tests/test-general.c
index e8eb0baf..82af4140 100644
--- a/libnm-core/tests/test-general.c
+++ b/libnm-core/tests/test-general.c
@@ -21,13 +21,11 @@
 
 #define NM_GLIB_COMPAT_H_TEST
 
-#include "config.h"
+#include "nm-default.h"
 
 #include <string.h>
 
-#include <nm-utils.h>
-#include "nm-default.h"
-
+#include "nm-utils.h"
 #include "nm-setting-private.h"
 #include "nm-utils.h"
 #include "nm-utils-private.h"
@@ -62,9 +60,10 @@
 #include "nm-simple-connection.h"
 #include "nm-keyfile-internal.h"
 
-#include "nm-test-utils.h"
 #include "test-general-enums.h"
 
+#include "nm-test-utils.h"
+
 /* When passing a "bool" typed argument to a variadic function that
  * expects a gboolean, the compiler will promote the integer type
  * to have at least size (int). That way:
@@ -73,56 +72,47 @@
 G_STATIC_ASSERT (sizeof (gboolean) == sizeof (int));
 G_STATIC_ASSERT (sizeof (bool) <= sizeof (int));
 
+/*****************************************************************************/
+
 static void
 vpn_check_func (const char *key, const char *value, gpointer user_data)
 {
-	const char *test = user_data;
-
 	if (!strcmp (key, "foobar1")) {
-		ASSERT (strcmp (value, "blahblah1") == 0,
-				test, "unexpected vpn item '%s' / '%s'", key, value);
+		g_assert_cmpstr (value, ==, "blahblah1");
 		return;
 	}
 
 	if (!strcmp (key, "foobar2")) {
-		ASSERT (strcmp (value, "blahblah2") == 0,
-				test, "unexpected vpn item '%s' / '%s'", key, value);
+		g_assert_cmpstr (value, ==, "blahblah2");
 		return;
 	}
 
 	if (!strcmp (key, "foobar3")) {
-		ASSERT (strcmp (value, "blahblah3") == 0,
-				test, "unexpected vpn item '%s' / '%s'", key, value);
+		g_assert_cmpstr (value, ==, "blahblah3");
 		return;
 	}
 
 	if (!strcmp (key, "foobar4")) {
-		ASSERT (strcmp (value, "blahblah4") == 0,
-				test, "unexpected vpn item '%s' / '%s'", key, value);
+		g_assert_cmpstr (value, ==, "blahblah4");
 		return;
 	}
 
-	ASSERT (FALSE, test, "unexpected vpn item '%s'", key);
+	g_assert_not_reached ();
 }
 
 static void
 vpn_check_empty_func (const char *key, const char *value, gpointer user_data)
 {
-	const char *test = user_data;
-
-	/* We don't expect any values */
-	ASSERT (FALSE, test, "unexpected vpn item '%s'", key);
+	g_assert_not_reached ();
 }
 
 static void
 test_setting_vpn_items (void)
 {
-	NMSettingVpn *s_vpn;
+	gs_unref_object NMSettingVpn *s_vpn = NULL;
 
 	s_vpn = (NMSettingVpn *) nm_setting_vpn_new ();
-	ASSERT (s_vpn != NULL,
-	        "vpn-items",
-	        "error creating vpn setting");
+	g_assert (s_vpn);
 
 	nm_setting_vpn_add_data_item (s_vpn, "foobar1", "blahblah1");
 	nm_setting_vpn_add_data_item (s_vpn, "foobar2", "blahblah2");
@@ -130,7 +120,7 @@ test_setting_vpn_items (void)
 	nm_setting_vpn_add_data_item (s_vpn, "foobar4", "blahblah4");
 
 	/* Ensure that added values are all present */
-	nm_setting_vpn_foreach_data_item (s_vpn, vpn_check_func, "vpn-data");
+	nm_setting_vpn_foreach_data_item (s_vpn, vpn_check_func, NULL);
 	nm_setting_vpn_remove_data_item (s_vpn, "foobar1");
 	nm_setting_vpn_remove_data_item (s_vpn, "foobar2");
 	nm_setting_vpn_remove_data_item (s_vpn, "foobar3");
@@ -142,7 +132,7 @@ test_setting_vpn_items (void)
 	nm_setting_vpn_add_secret (s_vpn, "foobar4", "blahblah4");
 
 	/* Ensure that added values are all present */
-	nm_setting_vpn_foreach_secret (s_vpn, vpn_check_func, "vpn-secrets");
+	nm_setting_vpn_foreach_secret (s_vpn, vpn_check_func, NULL);
 	nm_setting_vpn_remove_secret (s_vpn, "foobar1");
 	nm_setting_vpn_remove_secret (s_vpn, "foobar2");
 	nm_setting_vpn_remove_secret (s_vpn, "foobar3");
@@ -173,7 +163,7 @@ test_setting_vpn_items (void)
 	nm_setting_vpn_add_data_item (s_vpn, "", "blahblah1");
 	g_test_assert_expected_messages ();
 
-	nm_setting_vpn_foreach_data_item (s_vpn, vpn_check_empty_func, "vpn-data-empty");
+	nm_setting_vpn_foreach_data_item (s_vpn, vpn_check_empty_func, NULL);
 
 	/* Try to add some blank secrets and make sure they are rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*key != NULL*");
@@ -200,9 +190,7 @@ test_setting_vpn_items (void)
 	nm_setting_vpn_add_secret (s_vpn, "", "blahblah1");
 	g_test_assert_expected_messages ();
 
-	nm_setting_vpn_foreach_secret (s_vpn, vpn_check_empty_func, "vpn-secrets-empty");
-
-	g_object_unref (s_vpn);
+	nm_setting_vpn_foreach_secret (s_vpn, vpn_check_empty_func, NULL);
 }
 
 static void
@@ -221,14 +209,7 @@ test_setting_vpn_update_secrets (void)
 	const char *val2 = "value2";
 
 	connection = nm_simple_connection_new ();
-	ASSERT (connection != NULL,
-	        "vpn-update-secrets",
-	        "error creating connection");
-
 	s_vpn = (NMSettingVpn *) nm_setting_vpn_new ();
-	ASSERT (s_vpn != NULL,
-	        "vpn-update-secrets",
-	        "error creating vpn setting");
 	nm_connection_add_setting (connection, NM_SETTING (s_vpn));
 
 	g_variant_builder_init (&settings_builder, NM_VARIANT_TYPE_CONNECTION);
@@ -247,21 +228,17 @@ test_setting_vpn_update_secrets (void)
 	settings = g_variant_builder_end (&settings_builder);
 
 	success = nm_connection_update_secrets (connection, NM_SETTING_VPN_SETTING_NAME, settings, &error);
-	ASSERT (success == TRUE,
-	        "vpn-update-secrets", "failed to update VPN secrets: %s", error->message);
+	g_assert_no_error (error);
+	g_assert (success);
 
 	/* Read the secrets back out */
 	tmp = nm_setting_vpn_get_secret (s_vpn, key1);
-	ASSERT (tmp != NULL,
-	        "vpn-update-secrets", "unexpected failure getting key #1");
-	ASSERT (strcmp (tmp, val1) == 0,
-	        "vpn-update-secrets", "unexpected key #1 value");
+	g_assert (tmp);
+	g_assert_cmpstr (tmp, ==, val1);
 
 	tmp = nm_setting_vpn_get_secret (s_vpn, key2);
-	ASSERT (tmp != NULL,
-	        "vpn-update-secrets", "unexpected failure getting key #2");
-	ASSERT (strcmp (tmp, val2) == 0,
-	        "vpn-update-secrets", "unexpected key #2 value");
+	g_assert (tmp);
+	g_assert_cmpstr (tmp, ==, val2);
 
 	g_variant_unref (settings);
 	g_object_unref (connection);
@@ -666,25 +643,17 @@ test_setting_gsm_apn_spaces (void)
 	const char *tmp;
 
 	s_gsm = (NMSettingGsm *) nm_setting_gsm_new ();
-	ASSERT (s_gsm != NULL,
-	        "gsm-apn-spaces",
-	        "error creating GSM setting");
+	g_assert (s_gsm);
 
 	/* Trailing space */
 	g_object_set (s_gsm, NM_SETTING_GSM_APN, "foobar ", NULL);
 	tmp = nm_setting_gsm_get_apn (s_gsm);
-	ASSERT (tmp != NULL,
-	        "gsm-apn-spaces", "empty APN");
-	ASSERT (strcmp (tmp, "foobar") == 0,
-	        "gsm-apn-spaces", "unexpected APN");
+	g_assert_cmpstr (tmp, ==, "foobar");
 
 	/* Leading space */
 	g_object_set (s_gsm, NM_SETTING_GSM_APN, " foobar", NULL);
 	tmp = nm_setting_gsm_get_apn (s_gsm);
-	ASSERT (tmp != NULL,
-	        "gsm-apn-spaces", "empty APN");
-	ASSERT (strcmp (tmp, "foobar") == 0,
-	        "gsm-apn-spaces", "unexpected APN");
+	g_assert_cmpstr (tmp, ==, "foobar");
 }
 
 static void
@@ -693,36 +662,29 @@ test_setting_gsm_apn_bad_chars (void)
 	gs_unref_object NMSettingGsm *s_gsm = NULL;
 
 	s_gsm = (NMSettingGsm *) nm_setting_gsm_new ();
-	ASSERT (s_gsm != NULL,
-	        "gsm-apn-bad-chars",
-	        "error creating GSM setting");
+	g_assert (s_gsm);
 
 	g_object_set (s_gsm, NM_SETTING_GSM_NUMBER, "*99#", NULL);
 
 	/* Make sure a valid APN works */
 	g_object_set (s_gsm, NM_SETTING_GSM_APN, "foobar123.-baz", NULL);
-	ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == TRUE,
-	        "gsm-apn-bad-chars", "unexpectedly invalid GSM setting");
+	g_assert (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL));
 
 	/* Random invalid chars */
 	g_object_set (s_gsm, NM_SETTING_GSM_APN, "@#%$@#%@#%", NULL);
-	ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == FALSE,
-	        "gsm-apn-bad-chars", "unexpectedly valid GSM setting");
+	g_assert (!nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL));
 
 	/* Spaces */
 	g_object_set (s_gsm, NM_SETTING_GSM_APN, "foobar baz", NULL);
-	ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == FALSE,
-	        "gsm-apn-bad-chars", "unexpectedly valid GSM setting");
+	g_assert (!nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL));
 
 	/* 0 characters long */
 	g_object_set (s_gsm, NM_SETTING_GSM_APN, "", NULL);
-	ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == FALSE,
-	        "gsm-apn-bad-chars", "unexpectedly valid GSM setting");
+	g_assert (!nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL));
 
 	/* 65-character long */
 	g_object_set (s_gsm, NM_SETTING_GSM_APN, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijkl1", NULL);
-	ASSERT (nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL) == FALSE,
-	        "gsm-apn-bad-chars", "unexpectedly valid GSM setting");
+	g_assert (!nm_setting_verify (NM_SETTING (s_gsm), NULL, NULL));
 }
 
 static void
@@ -791,7 +753,7 @@ make_test_wsec_setting (const char *detail)
 	NMSettingWirelessSecurity *s_wsec;
 
 	s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new ();
-	ASSERT (s_wsec != NULL, detail, "error creating setting");
+	g_assert (s_wsec);
 
 	g_object_set (s_wsec,
 	              NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-psk",
@@ -800,24 +762,17 @@ make_test_wsec_setting (const char *detail)
 	              NM_SETTING_WIRELESS_SECURITY_PSK_FLAGS, NM_SETTING_SECRET_FLAG_NOT_SAVED,
 	              NM_SETTING_WIRELESS_SECURITY_WEP_KEY0, "aaaaaaaaaa",
 	              NULL);
-
 	return s_wsec;
 }
 
-#define ASSERT_CONTAINS(vardict, key, test_name, msg) \
-	{ \
-		GVariant *value; \
-		value = g_variant_lookup_value (vardict, key, NULL); \
-		ASSERT (value != NULL, test_name, msg); \
-		g_variant_unref (value); \
-	}
+static gboolean
+_variant_contains (GVariant *vardict, const char *key)
+{
+	gs_unref_variant GVariant *value = NULL;
 
-#define ASSERT_NOT_CONTAINS(vardict, key, test_name, msg) \
-	{ \
-		GVariant *value; \
-		value = g_variant_lookup_value (vardict, key, NULL); \
-		ASSERT (value == NULL, test_name, msg); \
-	}
+	value = g_variant_lookup_value (vardict, key, NULL);
+	return !!value;
+}
 
 static void
 test_setting_to_dbus_all (void)
@@ -830,14 +785,10 @@ test_setting_to_dbus_all (void)
 	dict = _nm_setting_to_dbus (NM_SETTING (s_wsec), NULL, NM_CONNECTION_SERIALIZE_ALL);
 
 	/* Make sure all keys are there */
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,
-	        "setting-to-dbus-all", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_KEY_MGMT);
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME,
-	        "setting-to-dbus-all", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME);
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_PSK,
-	        "setting-to-dbus-all", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_PSK);
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0,
-	        "setting-to-dbus-all", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_WEP_KEY0);
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT));
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME));
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_PSK));
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0));
 
 	g_variant_unref (dict);
 	g_object_unref (s_wsec);
@@ -854,16 +805,12 @@ test_setting_to_dbus_no_secrets (void)
 	dict = _nm_setting_to_dbus (NM_SETTING (s_wsec), NULL, NM_CONNECTION_SERIALIZE_NO_SECRETS);
 
 	/* Make sure non-secret keys are there */
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,
-	                 "setting-to-dbus-no-secrets", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_KEY_MGMT);
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME,
-	                 "setting-to-dbus-no-secrets", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME);
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT));
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME));
 
 	/* Make sure secrets are not there */
-	ASSERT_NOT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_PSK,
-	                     "setting-to-dbus-no-secrets", "unexpectedly present " NM_SETTING_WIRELESS_SECURITY_PSK);
-	ASSERT_NOT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0,
-	                     "setting-to-dbus-no-secrets", "unexpectedly present " NM_SETTING_WIRELESS_SECURITY_WEP_KEY0);
+	g_assert (!_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_PSK));
+	g_assert (!_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0));
 
 	g_variant_unref (dict);
 	g_object_unref (s_wsec);
@@ -880,16 +827,12 @@ test_setting_to_dbus_only_secrets (void)
 	dict = _nm_setting_to_dbus (NM_SETTING (s_wsec), NULL, NM_CONNECTION_SERIALIZE_ONLY_SECRETS);
 
 	/* Make sure non-secret keys are not there */
-	ASSERT_NOT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,
-	                     "setting-to-dbus-only-secrets", "unexpectedly present " NM_SETTING_WIRELESS_SECURITY_KEY_MGMT);
-	ASSERT_NOT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME,
-	                     "setting-to-dbus-only-secrets", "unexpectedly present " NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME);
+	g_assert (!_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT));
+	g_assert (!_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME));
 
 	/* Make sure secrets are there */
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_PSK,
-	                 "setting-to-dbus-only-secrets", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_PSK);
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0,
-	                 "setting-to-dbus-only-secrets", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_WEP_KEY0);
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_PSK));
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0));
 
 	g_variant_unref (dict);
 	g_object_unref (s_wsec);
@@ -1011,8 +954,7 @@ test_connection_to_dbus_setting_name (void)
 	/* Make sure the keys of the first level dict are setting names, not
 	 * the GType name of the setting objects.
 	 */
-	ASSERT_CONTAINS (dict, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,
-	                 "connection-to-dbus-setting-name", "unexpectedly missing " NM_SETTING_WIRELESS_SECURITY_SETTING_NAME);
+	g_assert (_variant_contains (dict, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME));
 
 	g_variant_unref (dict);
 	g_object_unref (connection);
@@ -1643,24 +1585,20 @@ test_connection_new_from_dbus (void)
 static void
 check_permission (NMSettingConnection *s_con,
                   guint32 idx,
-                  const char *expected_uname,
-                  const char *tag)
+                  const char *expected_uname)
 {
 	gboolean success;
 	const char *ptype = NULL, *pitem = NULL, *detail = NULL;
 
 	success = nm_setting_connection_get_permission (s_con, 0, &ptype, &pitem, &detail);
-	ASSERT (success == TRUE, tag, "unexpected failure getting added permission");
+	g_assert (success);
 
-	/* Permission type */
-	ASSERT (ptype != NULL, tag, "unexpected failure getting permission type");
-	ASSERT (strcmp (ptype, "user") == 0, tag, "retrieved unexpected permission type");
+	g_assert_cmpstr (ptype, ==, "user");
 
-	/* Permission item */
-	ASSERT (pitem != NULL, tag, "unexpected failure getting permission item");
-	ASSERT (strcmp (pitem, expected_uname) == 0, tag, "retrieved unexpected permission item");
+	g_assert (pitem);
+	g_assert_cmpstr (pitem, ==, expected_uname);
 
-	ASSERT (detail == NULL, tag, "unexpected success getting permission detail");
+	g_assert (!detail);
 }
 
 #define TEST_UNAME "asdfasfasdf"
@@ -1680,79 +1618,66 @@ test_setting_connection_permissions_helpers (void)
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*strcmp (ptype, \"user\") == 0*");
 	success = nm_setting_connection_add_permission (s_con, "foobar", "blah", NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (success == FALSE,
-	        "setting-connection-permissions-helpers", "unexpected success adding bad permission type #1");
+	g_assert (!success);
 
 	/* Ensure a bad [type] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*ptype*");
 	success = nm_setting_connection_add_permission (s_con, NULL, "blah", NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (success == FALSE,
-	        "setting-connection-permissions-helpers", "unexpected success adding bad permission type #2");
+	g_assert (!success);
 
 	/* Ensure a bad [item] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*uname*");
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*p != NULL*");
 	success = nm_setting_connection_add_permission (s_con, "user", NULL, NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (success == FALSE,
-	        "setting-connection-permissions-helpers", "unexpected success adding bad permission item #1");
+	g_assert (!success);
 
 	/* Ensure a bad [item] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*uname[0] != '\\0'*");
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*p != NULL*");
 	success = nm_setting_connection_add_permission (s_con, "user", "", NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (success == FALSE,
-	        "setting-connection-permissions-helpers", "unexpected success adding bad permission item #2");
+	g_assert (!success);
 
 	/* Ensure an [item] with ':' is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*strchr (uname, ':')*");
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*p != NULL*");
 	success = nm_setting_connection_add_permission (s_con, "user", "ad:asdf", NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (success == FALSE,
-	        "setting-connection-permissions-helpers", "unexpected success adding bad permission item #3");
+	g_assert (!success);
 
 	/* Ensure a non-UTF-8 [item] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*g_utf8_validate (uname, -1, NULL)*");
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*p != NULL*");
 	success = nm_setting_connection_add_permission (s_con, "user", buf, NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (success == FALSE,
-	        "setting-connection-permissions-helpers", "unexpected success adding bad permission item #4");
+	g_assert (!success);
 
 	/* Ensure a non-NULL [detail] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*detail == NULL*");
 	success = nm_setting_connection_add_permission (s_con, "user", "dafasdf", "asdf");
 	g_test_assert_expected_messages ();
-	ASSERT (success == FALSE,
-	        "setting-connection-permissions-helpers", "unexpected success adding bad detail");
+	g_assert (!success);
 
 	/* Ensure a valid call results in success */
 	success = nm_setting_connection_add_permission (s_con, "user", TEST_UNAME, NULL);
-	ASSERT (success == TRUE,
-	        "setting-connection-permissions-helpers", "unexpected failure adding valid user permisson");
+	g_assert (success);
 
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 1,
-	        "setting-connection-permissions-helpers", "unexpected failure getting number of permissions");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 1);
 
-	check_permission (s_con, 0, TEST_UNAME, "setting-connection-permissions-helpers");
+	check_permission (s_con, 0, TEST_UNAME);
 
 	/* Check the actual GObject property just to be paranoid */
 	g_object_get (G_OBJECT (s_con), NM_SETTING_CONNECTION_PERMISSIONS, &perms, NULL);
-	ASSERT (perms != NULL,
-	        "setting-connection-permissions-helpers", "unexpected failure getting permissions");
-	ASSERT (g_strv_length (perms) == 1,
-	        "setting-connection-permissions-helpers", "unexpected failure getting number of permissions");
-	ASSERT (strcmp (perms[0], expected_perm) == 0,
-	        "setting-connection-permissions-helpers", "unexpected permission property data");
+	g_assert (perms);
+	g_assert_cmpint (g_strv_length (perms), ==, 1);
+	g_assert_cmpstr (perms[0], ==, expected_perm);
 	g_strfreev (perms);
 
 	/* Now remove that permission and ensure we have 0 permissions */
 	nm_setting_connection_remove_permission (s_con, 0);
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-helpers", "unexpected failure removing permission");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	g_object_unref (s_con);
 }
@@ -1804,69 +1729,59 @@ test_setting_connection_permissions_property (void)
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*strncmp (str, PERM_USER_PREFIX, strlen (PERM_USER_PREFIX)) == 0*");
 	add_permission_property (s_con, "foobar", "blah", -1, NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected success adding bad permission type #1");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	/* Ensure a bad [type] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*strncmp (str, PERM_USER_PREFIX, strlen (PERM_USER_PREFIX)) == 0*");
 	add_permission_property (s_con, NULL, "blah", -1, NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected success adding bad permission type #2");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	/* Ensure a bad [item] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*last_colon > str*");
 	add_permission_property (s_con, "user", NULL, -1, NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected success adding bad permission item #1");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	/* Ensure a bad [item] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*last_colon > str*");
 	add_permission_property (s_con, "user", "", -1, NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected success adding bad permission item #2");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	/* Ensure an [item] with ':' in the middle is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*str[i] != ':'*");
 	add_permission_property (s_con, "user", "ad:asdf", -1, NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected success adding bad permission item #3");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	/* Ensure an [item] with ':' at the end is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*str[i] != ':'*");
 	add_permission_property (s_con, "user", "adasdfaf:", -1, NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected success adding bad permission item #4");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	/* Ensure a non-UTF-8 [item] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*g_utf8_validate (str, -1, NULL)*");
 	add_permission_property (s_con, "user", buf, (int) sizeof (buf), NULL);
 	g_test_assert_expected_messages ();
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected success adding bad permission item #5");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	/* Ensure a non-NULL [detail] is rejected */
 	g_test_expect_message ("libnm", G_LOG_LEVEL_CRITICAL, "*(last_colon + 1) == '\\0'*");
 	add_permission_property (s_con, "user", "dafasdf", -1, "asdf");
 	g_test_assert_expected_messages ();
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected success adding bad detail");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	/* Ensure a valid call results in success */
 	success = nm_setting_connection_add_permission (s_con, "user", TEST_UNAME, NULL);
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 1,
-	        "setting-connection-permissions-property", "unexpected failure adding valid user permisson");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 1);
 
-	check_permission (s_con, 0, TEST_UNAME, "setting-connection-permissions-property");
+	check_permission (s_con, 0, TEST_UNAME);
 
 	/* Now remove that permission and ensure we have 0 permissions */
 	nm_setting_connection_remove_permission (s_con, 0);
-	ASSERT (nm_setting_connection_get_num_permissions (s_con) == 0,
-	        "setting-connection-permissions-property", "unexpected failure removing permission");
+	g_assert_cmpint (nm_setting_connection_get_num_permissions (s_con), ==, 0);
 
 	g_object_unref (s_con);
 }
@@ -2040,12 +1955,13 @@ test_connection_diff_a_only (void)
 			{ NM_SETTING_IP_CONFIG_IGNORE_AUTO_ROUTES, NM_SETTING_DIFF_RESULT_IN_A },
 			{ NM_SETTING_IP_CONFIG_IGNORE_AUTO_DNS,    NM_SETTING_DIFF_RESULT_IN_A },
 			{ NM_SETTING_IP4_CONFIG_DHCP_CLIENT_ID,    NM_SETTING_DIFF_RESULT_IN_A },
-			{ NM_SETTING_IP4_CONFIG_DHCP_TIMEOUT,      NM_SETTING_DIFF_RESULT_IN_A },
+			{ NM_SETTING_IP_CONFIG_DHCP_TIMEOUT,       NM_SETTING_DIFF_RESULT_IN_A },
 			{ NM_SETTING_IP_CONFIG_DHCP_SEND_HOSTNAME, NM_SETTING_DIFF_RESULT_IN_A },
 			{ NM_SETTING_IP_CONFIG_DHCP_HOSTNAME,      NM_SETTING_DIFF_RESULT_IN_A },
 			{ NM_SETTING_IP4_CONFIG_DHCP_FQDN,         NM_SETTING_DIFF_RESULT_IN_A },
 			{ NM_SETTING_IP_CONFIG_NEVER_DEFAULT,      NM_SETTING_DIFF_RESULT_IN_A },
 			{ NM_SETTING_IP_CONFIG_MAY_FAIL,           NM_SETTING_DIFF_RESULT_IN_A },
+			{ NM_SETTING_IP_CONFIG_DAD_TIMEOUT,        NM_SETTING_DIFF_RESULT_IN_A },
 			{ NULL, NM_SETTING_DIFF_RESULT_UNKNOWN },
 		} },
 	};
@@ -2773,18 +2689,18 @@ test_ip4_netmask_to_prefix (void)
 }
 
 #define ASSERT_CHANGED(statement) \
-{ \
+G_STMT_START { \
 	changed = FALSE; \
 	statement; \
 	g_assert (changed); \
-}
+} G_STMT_END
 
 #define ASSERT_UNCHANGED(statement) \
-{ \
+G_STMT_START { \
 	changed = FALSE; \
 	statement; \
 	g_assert (!changed); \
-}
+} G_STMT_END
 
 static void
 test_connection_changed_signal (void)
@@ -3389,6 +3305,7 @@ _test_connection_normalize_type_normalizable_setting (const char *type,
 
 	g_assert (!nm_connection_get_setting_by_name (con, type));
 	nmtst_assert_connection_verifies_after_normalization (con, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_MISSING_SETTING);
+	nmtst_connection_normalize (con);
 
 	s_base = nm_connection_get_setting_by_name (con, type);
 	g_assert (s_base);
@@ -3445,6 +3362,7 @@ _test_connection_normalize_type_normalizable_type (const char *type,
 	g_assert (nm_connection_get_setting_by_name (con, type) == s_base);
 
 	nmtst_assert_connection_verifies_after_normalization (con, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_MISSING_PROPERTY);
+	nmtst_connection_normalize (con);
 
 	g_assert_cmpstr (nm_connection_get_connection_type (con), ==, type);
 	g_assert (nm_connection_get_setting_by_name (con, type) == s_base);
@@ -3709,6 +3627,7 @@ test_connection_normalize_slave_type_1 (void)
 
 	g_assert (!nm_connection_get_setting_by_name (con, NM_SETTING_BRIDGE_PORT_SETTING_NAME));
 	nmtst_assert_connection_verifies_after_normalization (con, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_MISSING_SETTING);
+	nmtst_connection_normalize (con);
 	g_assert (nm_connection_get_setting_by_name (con, NM_SETTING_BRIDGE_PORT_SETTING_NAME));
 	g_assert_cmpstr (nm_setting_connection_get_slave_type (s_con), ==, NM_SETTING_BRIDGE_SETTING_NAME);
 }
@@ -3739,6 +3658,7 @@ test_connection_normalize_slave_type_2 (void)
 	g_assert (nm_connection_get_setting_by_name (con, NM_SETTING_BRIDGE_PORT_SETTING_NAME));
 	g_assert_cmpstr (nm_setting_connection_get_slave_type (s_con), ==, NULL);
 	nmtst_assert_connection_verifies_after_normalization (con, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_MISSING_PROPERTY);
+	nmtst_connection_normalize (con);
 	g_assert (nm_connection_get_setting_by_name (con, NM_SETTING_BRIDGE_PORT_SETTING_NAME));
 	g_assert_cmpstr (nm_setting_connection_get_slave_type (s_con), ==, NM_SETTING_BRIDGE_SETTING_NAME);
 }
@@ -3762,7 +3682,8 @@ test_connection_normalize_infiniband_mtu (void)
 	              NM_SETTING_INFINIBAND_TRANSPORT_MODE, "datagram",
 	              NM_SETTING_INFINIBAND_MTU, (guint) 2044,
 	              NULL);
-	nmtst_assert_connection_verifies_without_normalization (con);
+	nmtst_assert_connection_verifies_and_normalizable (con);
+	nmtst_connection_normalize (con);
 	g_assert_cmpint (2044, ==, nm_setting_infiniband_get_mtu (s_infini));
 
 	g_object_set (s_infini,
@@ -3770,6 +3691,7 @@ test_connection_normalize_infiniband_mtu (void)
 	              NM_SETTING_INFINIBAND_MTU, (guint) 2045,
 	              NULL);
 	nmtst_assert_connection_verifies_after_normalization (con, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY);
+	nmtst_connection_normalize (con);
 	g_assert_cmpint (2044, ==, nm_setting_infiniband_get_mtu (s_infini));
 
 	g_object_set (s_infini,
@@ -3784,6 +3706,7 @@ test_connection_normalize_infiniband_mtu (void)
 	              NM_SETTING_INFINIBAND_MTU, (guint) 65521,
 	              NULL);
 	nmtst_assert_connection_verifies_after_normalization (con, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY);
+	nmtst_connection_normalize (con);
 	g_assert_cmpint (65520, ==, nm_setting_infiniband_get_mtu (s_infini));
 }
 
@@ -4023,6 +3946,7 @@ test_setting_compare_default_strv (void)
 	c1 = nmtst_create_minimal_connection ("test_compare_default_strv", NULL,
 	                                      NM_SETTING_WIRED_SETTING_NAME, NULL);
 	nmtst_assert_connection_verifies_and_normalizable (c1);
+	nmtst_connection_normalize (c1);
 
 	c2 = nm_simple_connection_new_clone (c1);
 	nmtst_assert_connection_verifies_without_normalization (c2);
@@ -4863,6 +4787,8 @@ test_nm_in_set (void)
 	_ASSERT (4,  NM_IN_SET (-1, G( 1), G( 2), G( 3), G(-1)));
 
 	_ASSERT (4,  NM_IN_SET (-1, G( 1), G( 2), G( 3), G(-1), G( 5)));
+	_ASSERT (5,  NM_IN_SET (-1, G( 1), G( 2), G( 3), G( 4), G(-1)));
+	_ASSERT (6,  NM_IN_SET (-1, G( 1), G( 2), G( 3), G( 4), G( 5), G( -1)));
 
 	_ASSERT (1, !NM_IN_SET_SE (-1, G( 1)));
 	_ASSERT (1,  NM_IN_SET_SE (-1, G(-1)));
@@ -4888,6 +4814,133 @@ test_nm_in_set (void)
 	_ASSERT (4,  NM_IN_SET_SE (-1, G( 1), G( 2), G( 3), G(-1)));
 
 	_ASSERT (5,  NM_IN_SET_SE (-1, G( 1), G( 2), G( 3), G(-1), G( 5)));
+	_ASSERT (6,  NM_IN_SET_SE (-1, G( 1), G( 2), G( 3), G( 4), G( 5), G(-1)));
+#undef G
+#undef N
+#undef _ASSERT
+}
+
+/******************************************************************************/
+
+static const char *
+_test_nm_in_set_getstr (int *call_counter, gboolean allow_called, const char *value)
+{
+	g_assert (call_counter);
+	*call_counter += 1;
+	if (!allow_called)
+		g_assert_not_reached ();
+	return value;
+}
+
+static void
+test_nm_in_strset (void)
+{
+	int call_counter = 0;
+
+#define G(x) _test_nm_in_set_getstr (&call_counter, TRUE,  x)
+#define N(x) _test_nm_in_set_getstr (&call_counter, FALSE,  x)
+#define _ASSERT(expected, expr) \
+	G_STMT_START { \
+		_test_nm_in_set_assert (&call_counter, 0); \
+		g_assert (expr); \
+		_test_nm_in_set_assert (&call_counter, (expected)); \
+	} G_STMT_END
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL)));
+	_ASSERT (1, !NM_IN_STRSET ("a",  G(NULL)));
+	_ASSERT (1, !NM_IN_STRSET (NULL, G("a")));
+
+	_ASSERT (1,  NM_IN_STRSET_SE (NULL, G(NULL)));
+	_ASSERT (1, !NM_IN_STRSET_SE ("a",  G(NULL)));
+	_ASSERT (1, !NM_IN_STRSET_SE (NULL, G("a")));
+
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N(NULL)));
+	_ASSERT (2, !NM_IN_STRSET ("a",  G(NULL), G(NULL)));
+	_ASSERT (2,  NM_IN_STRSET (NULL, G("a"),  G(NULL)));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N("a")));
+	_ASSERT (2,  NM_IN_STRSET ("a",  G(NULL), G("a")));
+	_ASSERT (2, !NM_IN_STRSET (NULL, G("a"),  G("a")));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N("b")));
+	_ASSERT (2, !NM_IN_STRSET ("a",  G(NULL), G("b")));
+	_ASSERT (2, !NM_IN_STRSET (NULL, G("a"),  G("b")));
+
+	_ASSERT (2,  NM_IN_STRSET_SE (NULL, G(NULL), G(NULL)));
+	_ASSERT (2, !NM_IN_STRSET_SE ("a",  G(NULL), G(NULL)));
+	_ASSERT (2,  NM_IN_STRSET_SE (NULL, G("a"),  G(NULL)));
+	_ASSERT (2,  NM_IN_STRSET_SE (NULL, G(NULL), G("a")));
+	_ASSERT (2,  NM_IN_STRSET_SE ("a",  G(NULL), G("a")));
+	_ASSERT (2, !NM_IN_STRSET_SE (NULL, G("a"),  G("a")));
+	_ASSERT (2,  NM_IN_STRSET_SE (NULL, G(NULL), G("b")));
+	_ASSERT (2, !NM_IN_STRSET_SE ("a",  G(NULL), G("b")));
+	_ASSERT (2, !NM_IN_STRSET_SE (NULL, G("a"),  G("b")));
+
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N(NULL), N(NULL)));
+	_ASSERT (3, !NM_IN_STRSET ("a",  G(NULL), G(NULL), G(NULL)));
+	_ASSERT (2,  NM_IN_STRSET (NULL, G("a"),  G(NULL), N(NULL)));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N("a"),  N(NULL)));
+	_ASSERT (2,  NM_IN_STRSET ("a",  G(NULL), G("a"),  N(NULL)));
+	_ASSERT (3,  NM_IN_STRSET (NULL, G("a"),  G("a"),  G(NULL)));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N("b"),  N(NULL)));
+	_ASSERT (3, !NM_IN_STRSET ("a",  G(NULL), G("b"),  G(NULL)));
+	_ASSERT (3,  NM_IN_STRSET (NULL, G("a"),  G("b"),  G(NULL)));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N(NULL), N("a")));
+	_ASSERT (3,  NM_IN_STRSET ("a",  G(NULL), G(NULL), G("a")));
+	_ASSERT (2,  NM_IN_STRSET (NULL, G("a"),  G(NULL), N("a")));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N("a"),  N("a")));
+	_ASSERT (2,  NM_IN_STRSET ("a",  G(NULL), G("a"),  N("a")));
+	_ASSERT (3, !NM_IN_STRSET (NULL, G("a"),  G("a"),  G("a")));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N("b"),  N("a")));
+	_ASSERT (3,  NM_IN_STRSET ("a",  G(NULL), G("b"),  G("a")));
+	_ASSERT (3, !NM_IN_STRSET (NULL, G("a"),  G("b"),  G("a")));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N(NULL), N("b")));
+	_ASSERT (3, !NM_IN_STRSET ("a",  G(NULL), G(NULL), G("b")));
+	_ASSERT (2,  NM_IN_STRSET (NULL, G("a"),  G(NULL), N("b")));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N("a"),  N("b")));
+	_ASSERT (2,  NM_IN_STRSET ("a",  G(NULL), G("a"),  N("b")));
+	_ASSERT (3, !NM_IN_STRSET (NULL, G("a"),  G("a"),  G("b")));
+	_ASSERT (1,  NM_IN_STRSET (NULL, G(NULL), N("b"),  N("b")));
+	_ASSERT (3, !NM_IN_STRSET ("a",  G(NULL), G("b"),  G("b")));
+	_ASSERT (3, !NM_IN_STRSET (NULL, G("a"),  G("b"),  G("b")));
+
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G(NULL), G(NULL)));
+	_ASSERT (3, !NM_IN_STRSET_SE ("a",  G(NULL), G(NULL), G(NULL)));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G("a"),  G(NULL), G(NULL)));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G("a"),  G(NULL)));
+	_ASSERT (3,  NM_IN_STRSET_SE ("a",  G(NULL), G("a"),  G(NULL)));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G("a"),  G("a"),  G(NULL)));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G("b"),  G(NULL)));
+	_ASSERT (3, !NM_IN_STRSET_SE ("a",  G(NULL), G("b"),  G(NULL)));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G("a"),  G("b"),  G(NULL)));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G(NULL), G("a")));
+	_ASSERT (3,  NM_IN_STRSET_SE ("a",  G(NULL), G(NULL), G("a")));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G("a"),  G(NULL), G("a")));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G("a"),  G("a")));
+	_ASSERT (3,  NM_IN_STRSET_SE ("a",  G(NULL), G("a"),  G("a")));
+	_ASSERT (3, !NM_IN_STRSET_SE (NULL, G("a"),  G("a"),  G("a")));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G("b"),  G("a")));
+	_ASSERT (3,  NM_IN_STRSET_SE ("a",  G(NULL), G("b"),  G("a")));
+	_ASSERT (3, !NM_IN_STRSET_SE (NULL, G("a"),  G("b"),  G("a")));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G(NULL), G("b")));
+	_ASSERT (3, !NM_IN_STRSET_SE ("a",  G(NULL), G(NULL), G("b")));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G("a"),  G(NULL), G("b")));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G("a"),  G("b")));
+	_ASSERT (3,  NM_IN_STRSET_SE ("a",  G(NULL), G("a"),  G("b")));
+	_ASSERT (3, !NM_IN_STRSET_SE (NULL, G("a"),  G("a"),  G("b")));
+	_ASSERT (3,  NM_IN_STRSET_SE (NULL, G(NULL), G("b"),  G("b")));
+	_ASSERT (3, !NM_IN_STRSET_SE ("a",  G(NULL), G("b"),  G("b")));
+	_ASSERT (3, !NM_IN_STRSET_SE (NULL, G("a"),  G("b"),  G("b")));
+
+
+	_ASSERT (3,  NM_IN_STRSET ("a",  G(NULL), G("b"),  G("a"),  N("a")));
+	_ASSERT (4,  NM_IN_STRSET ("a",  G(NULL), G("b"),  G("c"),  G("a")));
+	_ASSERT (4, !NM_IN_STRSET ("a",  G(NULL), G("b"),  G("c"),  G("d")));
+
+	_ASSERT (4,  NM_IN_STRSET ("a",  G(NULL), G("b"),  G("c"),  G("a"),  N("a")));
+	_ASSERT (5,  NM_IN_STRSET ("a",  G(NULL), G("b"),  G("c"),  G("d"),  G("a")));
+	_ASSERT (5, !NM_IN_STRSET ("a",  G(NULL), G("b"),  G("c"),  G("d"),  G("e")));
+
+	_ASSERT (5,  NM_IN_STRSET ("a",  G(NULL), G("b"),  G("c"),  G("d"),  G("a"),  N("a")));
+	_ASSERT (6,  NM_IN_STRSET ("a",  G(NULL), G("b"),  G("c"),  G("d"),  G("e"),  G("a")));
+	_ASSERT (6, !NM_IN_STRSET ("a",  G(NULL), G("b"),  G("c"),  G("d"),  G("e"),  G("f")));
 #undef G
 #undef N
 #undef _ASSERT
@@ -4903,6 +4956,7 @@ int main (int argc, char **argv)
 
 	/* The tests */
 	g_test_add_func ("/core/general/test_nm_in_set", test_nm_in_set);
+	g_test_add_func ("/core/general/test_nm_in_strset", test_nm_in_strset);
 	g_test_add_func ("/core/general/test_setting_vpn_items", test_setting_vpn_items);
 	g_test_add_func ("/core/general/test_setting_vpn_update_secrets", test_setting_vpn_update_secrets);
 	g_test_add_func ("/core/general/test_setting_vpn_modify_during_foreach", test_setting_vpn_modify_during_foreach);