libnm/tests: convert test cases to use g_assert() instead of ASSERT() (test-setting...

diff --git a/libnm-core/tests/test-setting-8021x.c b/libnm-core/tests/test-setting-8021x.c
index 4940401..687353c 100644 (file)
--- a/libnm-core/tests/test-setting-8021x.c
+++ b/libnm-core/tests/test-setting-8021x.c
@@ -41,16 +41,12 @@ compare_blob_data (const char *test,
        GError *error = NULL;
        gboolean success;
 
-       success = g_file_get_contents (key_path, &contents, &len, &error);
-       ASSERT (success == TRUE,
-               test, "failed to read blob key file: %s", error->message);
-
-       ASSERT (len > 0, test, "blob key file invalid (size 0)");
+       g_assert (key && g_bytes_get_size (key) > 0);
 
-       g_assert_cmpint (len, ==, g_bytes_get_size (key));
+       success = g_file_get_contents (key_path, &contents, &len, &error);
+       nmtst_assert_success (success, error);
 
-       ASSERT (memcmp (contents, g_bytes_get_data (key, NULL), len) == 0,
-               test, "blob key file and blob key data don't match");
+       g_assert_cmpmem (contents, len, g_bytes_get_data (key, NULL), g_bytes_get_size (key));
 
        g_free (contents);
 }
@@ -58,8 +54,11 @@ compare_blob_data (const char *test,
 static void
 check_scheme_path (GBytes *value, const char *path)
 {
-       const guint8 *p = g_bytes_get_data (value, NULL);
+       const guint8 *p;
+
+       g_assert (value);
 
+       p = g_bytes_get_data (value, NULL);
        g_assert (memcmp (p, NM_SETTING_802_1X_CERT_SCHEME_PREFIX_PATH, strlen (NM_SETTING_802_1X_CERT_SCHEME_PREFIX_PATH)) == 0);
        p += strlen (NM_SETTING_802_1X_CERT_SCHEME_PREFIX_PATH);
        g_assert (memcmp (p, path, strlen (path)) == 0);
@@ -81,7 +80,7 @@ test_private_key_import (const char *path,
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "private-key-import", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_private_key (s_8021x,
                                                     path,
@@ -89,29 +88,21 @@ test_private_key_import (const char *path,
                                                     scheme,
                                                     &format,
                                                     &error);
-       ASSERT (success == TRUE,
-               "private-key-import", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "private-key-import", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
        tmp_fmt = nm_setting_802_1x_get_private_key_format (s_8021x);
-       ASSERT (tmp_fmt == format,
-               "private-key-import", "unexpected re-read private key format (expected %d, got %d)",
-               format, tmp_fmt);
+       g_assert (tmp_fmt == format);
 
        /* Make sure the password is what we expect */
        pw = nm_setting_802_1x_get_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "private-key-import", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "private-key-import", "failed to compare private key password");
+       g_assert (pw != NULL);
+       g_assert_cmpstr (pw, ==, password);
 
        if (scheme == NM_SETTING_802_1X_CK_SCHEME_BLOB) {
                tmp_key = nm_setting_802_1x_get_private_key_blob (s_8021x);
-               ASSERT (tmp_key != NULL, "private-key-import", "missing private key blob");
                compare_blob_data ("private-key-import", path, tmp_key);
        } else if (scheme == NM_SETTING_802_1X_CK_SCHEME_PATH) {
                g_object_get (s_8021x, NM_SETTING_802_1X_PRIVATE_KEY, &tmp_key, NULL);
-               ASSERT (tmp_key != NULL, "private-key-import", "missing private key value");
                check_scheme_path (tmp_key, path);
                g_bytes_unref (tmp_key);
        } else
@@ -120,14 +111,13 @@ test_private_key_import (const char *path,
        /* If it's PKCS#12 ensure the client cert is the same value */
        if (format == NM_SETTING_802_1X_CK_FORMAT_PKCS12) {
                g_object_get (s_8021x, NM_SETTING_802_1X_PRIVATE_KEY, &tmp_key, NULL);
-               ASSERT (tmp_key != NULL, "private-key-import", "missing private key value");
+               g_assert (tmp_key);
 
                g_object_get (s_8021x, NM_SETTING_802_1X_CLIENT_CERT, &client_cert, NULL);
-               ASSERT (client_cert != NULL, "private-key-import", "missing client certificate value");
+               g_assert (client_cert);
 
                /* make sure they are the same */
-               ASSERT (g_bytes_equal (tmp_key, client_cert),
-                       "private-key-import", "unexpected different private key and client cert data");
+               g_assert (g_bytes_equal (tmp_key, client_cert));
 
                g_bytes_unref (tmp_key);
                g_bytes_unref (client_cert);
@@ -150,7 +140,7 @@ test_phase2_private_key_import (const char *path,
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "phase2-private-key-import", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_phase2_private_key (s_8021x,
                                                            path,
@@ -158,29 +148,21 @@ test_phase2_private_key_import (const char *path,
                                                            scheme,
                                                            &format,
                                                            &error);
-       ASSERT (success == TRUE,
-               "phase2-private-key-import", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "phase2-private-key-import", "unexpected private key format");
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
        tmp_fmt = nm_setting_802_1x_get_phase2_private_key_format (s_8021x);
-       ASSERT (tmp_fmt == format,
-               "phase2-private-key-import", "unexpected re-read private key format (expected %d, got %d)",
-               format, tmp_fmt);
+       g_assert (tmp_fmt == format);
 
        /* Make sure the password is what we expect */
        pw = nm_setting_802_1x_get_phase2_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "phase2-private-key-import", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "phase2-private-key-import", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        if (scheme == NM_SETTING_802_1X_CK_SCHEME_BLOB) {
                tmp_key = nm_setting_802_1x_get_phase2_private_key_blob (s_8021x);
-               ASSERT (tmp_key != NULL, "phase2-private-key-import", "missing private key blob");
                compare_blob_data ("phase2-private-key-import", path, tmp_key);
        } else if (scheme == NM_SETTING_802_1X_CK_SCHEME_PATH) {
                g_object_get (s_8021x, NM_SETTING_802_1X_PHASE2_PRIVATE_KEY, &tmp_key, NULL);
-               ASSERT (tmp_key != NULL, "phase2-private-key-import", "missing private key value");
                check_scheme_path (tmp_key, path);
                g_bytes_unref (tmp_key);
        } else
@@ -189,14 +171,13 @@ test_phase2_private_key_import (const char *path,
        /* If it's PKCS#12 ensure the client cert is the same value */
        if (format == NM_SETTING_802_1X_CK_FORMAT_PKCS12) {
                g_object_get (s_8021x, NM_SETTING_802_1X_PHASE2_PRIVATE_KEY, &tmp_key, NULL);
-               ASSERT (tmp_key != NULL, "private-key-import", "missing private key value");
+               g_assert (tmp_key);
 
                g_object_get (s_8021x, NM_SETTING_802_1X_PHASE2_CLIENT_CERT, &client_cert, NULL);
-               ASSERT (client_cert != NULL, "private-key-import", "missing client certificate value");
+               g_assert (client_cert);
 
                /* make sure they are the same */
-               ASSERT (g_bytes_equal (tmp_key, client_cert),
-                       "private-key-import", "unexpected different private key and client cert data");
+               g_assert (g_bytes_equal (tmp_key, client_cert));
 
                g_bytes_unref (tmp_key);
                g_bytes_unref (client_cert);
@@ -215,7 +196,7 @@ test_wrong_password_keeps_data (const char *path, const char *password)
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "wrong-password-keeps-data", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_private_key (s_8021x,
                                                     path,
@@ -223,10 +204,8 @@ test_wrong_password_keeps_data (const char *path, const char *password)
                                                     NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                     &format,
                                                     &error);
-       ASSERT (success == TRUE,
-               "wrong-password-keeps-data", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "wrong-password-keeps-data", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
 
        /* Now try to set it to something that's not a certificate */
        format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN;
@@ -236,20 +215,14 @@ test_wrong_password_keeps_data (const char *path, const char *password)
                                                     NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                     &format,
                                                     &error);
-       ASSERT (success == FALSE,
-               "wrong-password-keeps-data", "unexpected success reading private key");
-       ASSERT (error != NULL,
-               "wrong-password-keeps-data", "unexpected missing error");
-       ASSERT (format == NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "wrong-password-keeps-data", "unexpected success reading private key format");
+       nmtst_assert_no_success (success, error);
+       g_assert (format == NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
        g_clear_error (&error);
 
        /* Make sure the password hasn't changed */
        pw = nm_setting_802_1x_get_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "wrong-password-keeps-data", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "wrong-password-keeps-data", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        g_object_unref (s_8021x);
 }
@@ -264,7 +237,7 @@ test_clear_private_key (const char *path, const char *password)
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "clear-private-key", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_private_key (s_8021x,
                                                     path,
@@ -272,17 +245,13 @@ test_clear_private_key (const char *path, const char *password)
                                                     NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                     &format,
                                                     &error);
-       ASSERT (success == TRUE,
-               "clear-private-key", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "clear-private-key", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
 
        /* Make sure the password is what we expect */
        pw = nm_setting_802_1x_get_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "clear-private-key", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "clear-private-key", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        /* Now clear it */
        success = nm_setting_802_1x_set_private_key (s_8021x,
@@ -291,14 +260,10 @@ test_clear_private_key (const char *path, const char *password)
                                                     NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                     NULL,
                                                     &error);
-       ASSERT (success == TRUE,
-               "clear-private-key", "unexpected failure clearing private key");
-       ASSERT (error == NULL,
-               "clear-private-key", "unexpected error clearing private key");
+       nmtst_assert_success (success, error);
 
        /* Ensure the password is also now clear */
-       ASSERT (nm_setting_802_1x_get_private_key_password (s_8021x) == NULL,
-               "clear-private-key", "unexpected private key password");
+       g_assert (!nm_setting_802_1x_get_private_key_password (s_8021x));
 
        g_object_unref (s_8021x);
 }
@@ -313,7 +278,7 @@ test_wrong_phase2_password_keeps_data (const char *path, const char *password)
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "wrong-phase2-password-keeps-data", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_phase2_private_key (s_8021x,
                                                            path,
@@ -321,10 +286,8 @@ test_wrong_phase2_password_keeps_data (const char *path, const char *password)
                                                            NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                            &format,
                                                            &error);
-       ASSERT (success == TRUE,
-               "wrong-phase2-password-keeps-data", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "wrong-phase2-password-keeps-data", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
 
        /* Now try to set it to something that's not a certificate */
        format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN;
@@ -334,20 +297,14 @@ test_wrong_phase2_password_keeps_data (const char *path, const char *password)
                                                            NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                            &format,
                                                            &error);
-       ASSERT (success == FALSE,
-               "wrong-phase2-password-keeps-data", "unexpected success reading private key");
-       ASSERT (error != NULL,
-               "wrong-phase2-password-keeps-data", "unexpected missing error");
-       ASSERT (format == NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "wrong-phase2-password-keeps-data", "unexpected success reading private key format");
+       nmtst_assert_no_success (success, error);
+       g_assert (format == NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
        g_clear_error (&error);
 
        /* Make sure the password hasn't changed */
        pw = nm_setting_802_1x_get_phase2_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "wrong-phase2-password-keeps-data", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "wrong-phase2-password-keeps-data", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        g_object_unref (s_8021x);
 }
@@ -362,7 +319,7 @@ test_clear_phase2_private_key (const char *path, const char *password)
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "clear-phase2-private-key", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_phase2_private_key (s_8021x,
                                                            path,
@@ -370,17 +327,13 @@ test_clear_phase2_private_key (const char *path, const char *password)
                                                            NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                            &format,
                                                            &error);
-       ASSERT (success == TRUE,
-               "clear-phase2-private-key", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "clear-phase2-private-key", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
 
        /* Make sure the password is what we expect */
        pw = nm_setting_802_1x_get_phase2_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "clear-phase2-private-key", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "clear-phase2-private-key", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        /* Now clear it */
        success = nm_setting_802_1x_set_phase2_private_key (s_8021x,
@@ -389,14 +342,10 @@ test_clear_phase2_private_key (const char *path, const char *password)
                                                            NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                            NULL,
                                                            &error);
-       ASSERT (success == TRUE,
-               "clear-phase2-private-key", "unexpected failure clearing private key");
-       ASSERT (error == NULL,
-               "clear-phase2-private-key", "unexpected error clearing private key");
+       nmtst_assert_success (success, error);
 
        /* Ensure the password is also now clear */
-       ASSERT (nm_setting_802_1x_get_phase2_private_key_password (s_8021x) == NULL,
-               "clear-phase2-private-key", "unexpected private key password");
+       g_assert (!nm_setting_802_1x_get_phase2_private_key_password (s_8021x));
 
        g_object_unref (s_8021x);
 }

diff --git a/libnm-core/tests/test-settings-defaults.c b/libnm-core/tests/test-settings-defaults.c
index 21e16f3..9513d74 100644 (file)
--- a/libnm-core/tests/test-settings-defaults.c
+++ b/libnm-core/tests/test-settings-defaults.c
@@ -53,9 +53,7 @@ test_defaults (GType type, const char *name)
        setting = g_object_new (type, NULL);
 
        property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (setting), &n_property_specs);
-       ASSERT (property_specs != NULL,
-               name, "couldn't find property specs for object of type '%s'",
-               g_type_name (G_OBJECT_TYPE (setting)));
+       g_assert (property_specs);
 
        for (i = 0; i < n_property_specs; i++) {
                GParamSpec *prop_spec = property_specs[i];
@@ -87,9 +85,7 @@ test_defaults (GType type, const char *name)
                } else
                        ok = g_param_value_defaults (prop_spec, &value);
 
-               ASSERT (ok,
-                       name, "property '%s' value '%s' not the expected default value '%s'",
-                       prop_spec->name, actual, expected);
+               g_assert (ok);
 
                g_free (actual);
                g_free (expected);

diff --git a/libnm-util/tests/test-setting-8021x.c b/libnm-util/tests/test-setting-8021x.c
index 14e1df1..b02a0ee 100644 (file)
--- a/libnm-util/tests/test-setting-8021x.c
+++ b/libnm-util/tests/test-setting-8021x.c
@@ -41,17 +41,12 @@ compare_blob_data (const char *test,
        GError *error = NULL;
        gboolean success;
 
-       success = g_file_get_contents (key_path, &contents, &len, &error);
-       ASSERT (success == TRUE,
-               test, "failed to read blob key file: %s", error->message);
-
-       ASSERT (len > 0, test, "blob key file invalid (size 0)");
-
-       g_assert_cmpint (len, ==, key->len);
+       g_assert (key && key->len > 0);
 
-       ASSERT (memcmp (contents, key->data, len) == 0,
-               test, "blob key file and blob key data don't match");
+       success = g_file_get_contents (key_path, &contents, &len, &error);
+       nmtst_assert_success (success, error);
 
+       g_assert_cmpmem (contents, len, key->data, key->len);
        g_free (contents);
 }
 
@@ -60,8 +55,11 @@ compare_blob_data (const char *test,
 static void
 check_scheme_path (GByteArray *value, const char *path)
 {
-       guint8 *p = value->data;
+       guint8 *p;
+
+       g_assert (value);
 
+       p = value->data;
        g_assert (memcmp (p, SCHEME_PATH, strlen (SCHEME_PATH)) == 0);
        p += strlen (SCHEME_PATH);
        g_assert (memcmp (p, path, strlen (path)) == 0);
@@ -83,7 +81,7 @@ test_private_key_import (const char *path,
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "private-key-import", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_private_key (s_8021x,
                                                     path,
@@ -91,29 +89,21 @@ test_private_key_import (const char *path,
                                                     scheme,
                                                     &format,
                                                     &error);
-       ASSERT (success == TRUE,
-               "private-key-import", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "private-key-import", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
        tmp_fmt = nm_setting_802_1x_get_private_key_format (s_8021x);
-       ASSERT (tmp_fmt == format,
-               "private-key-import", "unexpected re-read private key format (expected %d, got %d)",
-               format, tmp_fmt);
+       g_assert (tmp_fmt == format);
 
        /* Make sure the password is what we expect */
        pw = nm_setting_802_1x_get_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "private-key-import", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "private-key-import", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        if (scheme == NM_SETTING_802_1X_CK_SCHEME_BLOB) {
                tmp_key = (GByteArray *) nm_setting_802_1x_get_private_key_blob (s_8021x);
-               ASSERT (tmp_key != NULL, "private-key-import", "missing private key blob");
                compare_blob_data ("private-key-import", path, tmp_key);
        } else if (scheme == NM_SETTING_802_1X_CK_SCHEME_PATH) {
                g_object_get (s_8021x, NM_SETTING_802_1X_PRIVATE_KEY, &tmp_key, NULL);
-               ASSERT (tmp_key != NULL, "private-key-import", "missing private key value");
                check_scheme_path (tmp_key, path);
                g_byte_array_free (tmp_key, TRUE);
        } else
@@ -122,16 +112,13 @@ test_private_key_import (const char *path,
        /* If it's PKCS#12 ensure the client cert is the same value */
        if (format == NM_SETTING_802_1X_CK_FORMAT_PKCS12) {
                g_object_get (s_8021x, NM_SETTING_802_1X_PRIVATE_KEY, &tmp_key, NULL);
-               ASSERT (tmp_key != NULL, "private-key-import", "missing private key value");
+               g_assert (tmp_key);
 
                g_object_get (s_8021x, NM_SETTING_802_1X_CLIENT_CERT, &client_cert, NULL);
-               ASSERT (client_cert != NULL, "private-key-import", "missing client certificate value");
+               g_assert (client_cert);
 
                /* make sure they are the same */
-               ASSERT (tmp_key->len == client_cert->len,
-                       "private-key-import", "unexpected different private key and client cert lengths");
-               ASSERT (memcmp (tmp_key->data, client_cert->data, tmp_key->len) == 0,
-                       "private-key-import", "unexpected different private key and client cert data");
+               g_assert_cmpmem (tmp_key->data, tmp_key->len, client_cert->data, client_cert->len);
 
                g_byte_array_free (tmp_key, TRUE);
                g_byte_array_free (client_cert, TRUE);
@@ -154,7 +141,7 @@ test_phase2_private_key_import (const char *path,
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "phase2-private-key-import", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_phase2_private_key (s_8021x,
                                                            path,
@@ -162,29 +149,21 @@ test_phase2_private_key_import (const char *path,
                                                            scheme,
                                                            &format,
                                                            &error);
-       ASSERT (success == TRUE,
-               "phase2-private-key-import", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "phase2-private-key-import", "unexpected private key format");
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
        tmp_fmt = nm_setting_802_1x_get_phase2_private_key_format (s_8021x);
-       ASSERT (tmp_fmt == format,
-               "phase2-private-key-import", "unexpected re-read private key format (expected %d, got %d)",
-               format, tmp_fmt);
+       g_assert (tmp_fmt == format);
 
        /* Make sure the password is what we expect */
        pw = nm_setting_802_1x_get_phase2_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "phase2-private-key-import", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "phase2-private-key-import", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        if (scheme == NM_SETTING_802_1X_CK_SCHEME_BLOB) {
                tmp_key = (GByteArray *) nm_setting_802_1x_get_phase2_private_key_blob (s_8021x);
-               ASSERT (tmp_key != NULL, "phase2-private-key-import", "missing private key blob");
                compare_blob_data ("phase2-private-key-import", path, tmp_key);
        } else if (scheme == NM_SETTING_802_1X_CK_SCHEME_PATH) {
                g_object_get (s_8021x, NM_SETTING_802_1X_PHASE2_PRIVATE_KEY, &tmp_key, NULL);
-               ASSERT (tmp_key != NULL, "phase2-private-key-import", "missing private key value");
                check_scheme_path (tmp_key, path);
                g_byte_array_free (tmp_key, TRUE);
        } else
@@ -193,16 +172,13 @@ test_phase2_private_key_import (const char *path,
        /* If it's PKCS#12 ensure the client cert is the same value */
        if (format == NM_SETTING_802_1X_CK_FORMAT_PKCS12) {
                g_object_get (s_8021x, NM_SETTING_802_1X_PHASE2_PRIVATE_KEY, &tmp_key, NULL);
-               ASSERT (tmp_key != NULL, "private-key-import", "missing private key value");
+               g_assert (tmp_key);
 
                g_object_get (s_8021x, NM_SETTING_802_1X_PHASE2_CLIENT_CERT, &client_cert, NULL);
-               ASSERT (client_cert != NULL, "private-key-import", "missing client certificate value");
+               g_assert (client_cert);
 
                /* make sure they are the same */
-               ASSERT (tmp_key->len == client_cert->len,
-                       "private-key-import", "unexpected different private key and client cert lengths");
-               ASSERT (memcmp (tmp_key->data, client_cert->data, tmp_key->len) == 0,
-                       "private-key-import", "unexpected different private key and client cert data");
+               g_assert_cmpmem (tmp_key->data, tmp_key->len, client_cert->data, client_cert->len);
 
                g_byte_array_free (tmp_key, TRUE);
                g_byte_array_free (client_cert, TRUE);
@@ -221,7 +197,7 @@ test_wrong_password_keeps_data (const char *path, const char *password)
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "wrong-password-keeps-data", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_private_key (s_8021x,
                                                     path,
@@ -229,10 +205,8 @@ test_wrong_password_keeps_data (const char *path, const char *password)
                                                     NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                     &format,
                                                     &error);
-       ASSERT (success == TRUE,
-               "wrong-password-keeps-data", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "wrong-password-keeps-data", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
 
        /* Now try to set it to something that's not a certificate */
        format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN;
@@ -242,20 +216,14 @@ test_wrong_password_keeps_data (const char *path, const char *password)
                                                     NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                     &format,
                                                     &error);
-       ASSERT (success == FALSE,
-               "wrong-password-keeps-data", "unexpected success reading private key");
-       ASSERT (error != NULL,
-               "wrong-password-keeps-data", "unexpected missing error");
-       ASSERT (format == NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "wrong-password-keeps-data", "unexpected success reading private key format");
+       nmtst_assert_no_success (success, error);
+       g_assert (format == NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
        g_clear_error (&error);
 
        /* Make sure the password hasn't changed */
        pw = nm_setting_802_1x_get_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "wrong-password-keeps-data", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "wrong-password-keeps-data", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        g_object_unref (s_8021x);
 }
@@ -270,7 +238,7 @@ test_clear_private_key (const char *path, const char *password)
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "clear-private-key", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_private_key (s_8021x,
                                                     path,
@@ -278,17 +246,13 @@ test_clear_private_key (const char *path, const char *password)
                                                     NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                     &format,
                                                     &error);
-       ASSERT (success == TRUE,
-               "clear-private-key", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "clear-private-key", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
 
        /* Make sure the password is what we expect */
        pw = nm_setting_802_1x_get_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "clear-private-key", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "clear-private-key", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        /* Now clear it */
        success = nm_setting_802_1x_set_private_key (s_8021x,
@@ -297,14 +261,10 @@ test_clear_private_key (const char *path, const char *password)
                                                     NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                     NULL,
                                                     &error);
-       ASSERT (success == TRUE,
-               "clear-private-key", "unexpected failure clearing private key");
-       ASSERT (error == NULL,
-               "clear-private-key", "unexpected error clearing private key");
+       nmtst_assert_success (success, error);
 
        /* Ensure the password is also now clear */
-       ASSERT (nm_setting_802_1x_get_private_key_password (s_8021x) == NULL,
-               "clear-private-key", "unexpected private key password");
+       g_assert (!nm_setting_802_1x_get_private_key_password (s_8021x));
 
        g_object_unref (s_8021x);
 }
@@ -319,7 +279,7 @@ test_wrong_phase2_password_keeps_data (const char *path, const char *password)
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "wrong-phase2-password-keeps-data", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_phase2_private_key (s_8021x,
                                                            path,
@@ -327,10 +287,8 @@ test_wrong_phase2_password_keeps_data (const char *path, const char *password)
                                                            NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                            &format,
                                                            &error);
-       ASSERT (success == TRUE,
-               "wrong-phase2-password-keeps-data", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "wrong-phase2-password-keeps-data", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
 
        /* Now try to set it to something that's not a certificate */
        format = NM_SETTING_802_1X_CK_FORMAT_UNKNOWN;
@@ -340,20 +298,14 @@ test_wrong_phase2_password_keeps_data (const char *path, const char *password)
                                                            NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                            &format,
                                                            &error);
-       ASSERT (success == FALSE,
-               "wrong-phase2-password-keeps-data", "unexpected success reading private key");
-       ASSERT (error != NULL,
-               "wrong-phase2-password-keeps-data", "unexpected missing error");
-       ASSERT (format == NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "wrong-phase2-password-keeps-data", "unexpected success reading private key format");
+       nmtst_assert_no_success (success, error);
+       g_assert (format == NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
        g_clear_error (&error);
 
        /* Make sure the password hasn't changed */
        pw = nm_setting_802_1x_get_phase2_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "wrong-phase2-password-keeps-data", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "wrong-phase2-password-keeps-data", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        g_object_unref (s_8021x);
 }
@@ -368,7 +320,7 @@ test_clear_phase2_private_key (const char *path, const char *password)
        const char *pw;
 
        s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
-       ASSERT (s_8021x != NULL, "clear-phase2-private-key", "setting was NULL");
+       g_assert (s_8021x);
 
        success = nm_setting_802_1x_set_phase2_private_key (s_8021x,
                                                            path,
@@ -376,17 +328,13 @@ test_clear_phase2_private_key (const char *path, const char *password)
                                                            NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                            &format,
                                                            &error);
-       ASSERT (success == TRUE,
-               "clear-phase2-private-key", "error reading private key: %s", error->message);
-       ASSERT (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN,
-               "clear-phase2-private-key", "unexpected private key format (got %d)", format);
+       nmtst_assert_success (success, error);
+       g_assert (format != NM_SETTING_802_1X_CK_FORMAT_UNKNOWN);
 
        /* Make sure the password is what we expect */
        pw = nm_setting_802_1x_get_phase2_private_key_password (s_8021x);
-       ASSERT (pw != NULL,
-               "clear-phase2-private-key", "failed to get previous private key password");
-       ASSERT (strcmp (pw, password) == 0,
-               "clear-phase2-private-key", "failed to compare private key password");
+       g_assert (pw);
+       g_assert_cmpstr (pw, ==, password);
 
        /* Now clear it */
        success = nm_setting_802_1x_set_phase2_private_key (s_8021x,
@@ -395,14 +343,10 @@ test_clear_phase2_private_key (const char *path, const char *password)
                                                            NM_SETTING_802_1X_CK_SCHEME_BLOB,
                                                            NULL,
                                                            &error);
-       ASSERT (success == TRUE,
-               "clear-phase2-private-key", "unexpected failure clearing private key");
-       ASSERT (error == NULL,
-               "clear-phase2-private-key", "unexpected error clearing private key");
+       nmtst_assert_success (success, error);
 
        /* Ensure the password is also now clear */
-       ASSERT (nm_setting_802_1x_get_phase2_private_key_password (s_8021x) == NULL,
-               "clear-phase2-private-key", "unexpected private key password");
+       g_assert (!nm_setting_802_1x_get_phase2_private_key_password (s_8021x));
 
        g_object_unref (s_8021x);
 }

diff --git a/libnm-util/tests/test-settings-defaults.c b/libnm-util/tests/test-settings-defaults.c
index 09f112c..76cc285 100644 (file)
--- a/libnm-util/tests/test-settings-defaults.c
+++ b/libnm-util/tests/test-settings-defaults.c
@@ -53,9 +53,7 @@ test_defaults (GType type, const char *name)
        setting = g_object_new (type, NULL);
 
        property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (setting), &n_property_specs);
-       ASSERT (property_specs != NULL,
-               name, "couldn't find property specs for object of type '%s'",
-               g_type_name (G_OBJECT_TYPE (setting)));
+       g_assert (property_specs);
 
        for (i = 0; i < n_property_specs; i++) {
                GParamSpec *prop_spec = property_specs[i];
@@ -87,9 +85,7 @@ test_defaults (GType type, const char *name)
                } else
                        ok = g_param_value_defaults (prop_spec, &value);
 
-               ASSERT (ok,
-                       name, "property '%s' value '%s' not the expected default value '%s'",
-                       prop_spec->name, actual, expected);
+               g_assert (ok);
 
                g_free (actual);
                g_free (expected);