[gcr/wip/nielsdg/gck-no-more-g-assert-in-tests: 8/8] gck: Don't use g_assert() in tests
- From: Niels De Graef <nielsdg src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gcr/wip/nielsdg/gck-no-more-g-assert-in-tests: 8/8] gck: Don't use g_assert() in tests
- Date: Fri, 15 Jan 2021 23:32:09 +0000 (UTC)
commit e538ec6ca4664346308a18f18ec3423c075bad84
Author: Niels De Graef <nielsdegraef gmail com>
Date: Fri Jan 15 19:01:30 2021 +0100
gck: Don't use g_assert() in tests
`g_assert()` can be (accidentally) disabled if someone uses
`G_DISABLE_ASSERT` when compiling gcr, so that renders most tests
useless. As a nice side effect, we get better error report when
something goes wrong in a test.
gck/test-gck-attributes.c | 442 ++++++++++++++++++++++------------------------
gck/test-gck-crypto.c | 184 ++++++++++---------
gck/test-gck-enumerator.c | 93 +++++-----
gck/test-gck-module.c | 42 ++---
gck/test-gck-modules.c | 38 ++--
gck/test-gck-object.c | 106 +++++------
gck/test-gck-session.c | 126 ++++++-------
gck/test-gck-slot.c | 2 +-
gck/test-gck-uri.c | 146 +++++++--------
9 files changed, 578 insertions(+), 601 deletions(-)
---
diff --git a/gck/test-gck-attributes.c b/gck/test-gck-attributes.c
index 2e9d7ce4..da11bf43 100644
--- a/gck/test-gck-attributes.c
+++ b/gck/test-gck-attributes.c
@@ -41,12 +41,11 @@ test_init_memory (void)
{
GckAttribute attr;
- g_assert (sizeof (attr) == sizeof (CK_ATTRIBUTE));
+ g_assert_cmpuint (sizeof (attr), ==, sizeof (CK_ATTRIBUTE));
gck_attribute_init (&attr, ATTR_TYPE, (const guchar *)ATTR_DATA, N_ATTR_DATA);
- g_assert (attr.type == ATTR_TYPE);
- g_assert (attr.length == N_ATTR_DATA);
- g_assert (memcmp (attr.value, ATTR_DATA, attr.length) == 0);
+ g_assert_cmpuint (attr.type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr.value, attr.length, ATTR_DATA, N_ATTR_DATA);
gck_attribute_clear (&attr);
}
@@ -58,10 +57,10 @@ test_init_boolean (void)
CK_BBOOL ck_value = CK_FALSE;
gck_attribute_init_boolean (&attr, ATTR_TYPE, TRUE);
- g_assert (attr.type == ATTR_TYPE);
- g_assert (attr.length == sizeof (CK_BBOOL));
+ g_assert_cmpuint (attr.type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr.length, ==, sizeof (CK_BBOOL));
memcpy(&ck_value, attr.value, sizeof (CK_BBOOL));
- g_assert (ck_value == CK_TRUE);
+ g_assert_cmpint (ck_value, ==, CK_TRUE);
gck_attribute_clear (&attr);
}
@@ -79,9 +78,8 @@ test_init_date (void)
memcpy (ck_date.day, "05", 2);
gck_attribute_init_date (&attr, ATTR_TYPE, date);
g_date_free (date);
- g_assert (attr.type == ATTR_TYPE);
- g_assert (attr.length == sizeof (CK_DATE));
- g_assert (memcmp (attr.value, &ck_date, attr.length) == 0);
+ g_assert_cmpuint (attr.type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr.value, attr.length, &ck_date, sizeof (CK_DATE));
gck_attribute_clear (&attr);
}
@@ -93,10 +91,10 @@ test_init_ulong (void)
CK_ULONG ck_value = 0;
gck_attribute_init_ulong (&attr, ATTR_TYPE, 88);
- g_assert (attr.type == ATTR_TYPE);
- g_assert (attr.length == sizeof (CK_ULONG));
+ g_assert_cmpuint (attr.type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr.length, ==, sizeof (CK_ULONG));
memcpy(&ck_value, attr.value, sizeof (CK_ULONG));
- g_assert (ck_value == 88);
+ g_assert_cmpuint (ck_value, ==, 88);
gck_attribute_clear (&attr);
}
@@ -107,9 +105,8 @@ test_init_string (void)
GckAttribute attr;
gck_attribute_init_string (&attr, ATTR_TYPE, "a test string");
- g_assert (attr.type == ATTR_TYPE);
- g_assert (attr.length == strlen ("a test string"));
- g_assert (memcmp (attr.value, "a test string", attr.length) == 0);
+ g_assert_cmpuint (attr.type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr.value, attr.length, "a test string", strlen ("a test string"));
gck_attribute_clear (&attr);
}
@@ -120,11 +117,11 @@ test_init_invalid (void)
GckAttribute attr;
gck_attribute_init_invalid (&attr, ATTR_TYPE);
- g_assert (attr.type == ATTR_TYPE);
- g_assert (attr.length == (gulong)-1);
- g_assert (attr.value == NULL);
+ g_assert_cmpuint (attr.type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr.length, ==, (gulong)-1);
+ g_assert_null (attr.value);
- g_assert (gck_attribute_is_invalid (&attr));
+ g_assert_true (gck_attribute_is_invalid (&attr));
gck_attribute_clear (&attr);
}
@@ -134,9 +131,9 @@ test_init_empty (void)
GckAttribute attr;
gck_attribute_init_empty (&attr, ATTR_TYPE);
- g_assert (attr.type == ATTR_TYPE);
- g_assert (attr.length == 0);
- g_assert (attr.value == NULL);
+ g_assert_cmpuint (attr.type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr.length, ==, 0);
+ g_assert_null (attr.value);
gck_attribute_clear (&attr);
}
@@ -147,9 +144,8 @@ test_new_memory (void)
GckAttribute *attr;
attr = gck_attribute_new (ATTR_TYPE, ATTR_DATA, N_ATTR_DATA);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == N_ATTR_DATA);
- g_assert (memcmp (attr->value, ATTR_DATA, attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, ATTR_DATA, N_ATTR_DATA);
gck_attribute_free (attr);
}
@@ -161,10 +157,10 @@ test_new_boolean (void)
CK_BBOOL ck_value = CK_FALSE;
attr = gck_attribute_new_boolean (ATTR_TYPE, TRUE);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_BBOOL));
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, sizeof (CK_BBOOL));
memcpy(&ck_value, attr->value, sizeof (CK_BBOOL));
- g_assert (ck_value == CK_TRUE);
+ g_assert_cmpuint (ck_value, ==, CK_TRUE);
gck_attribute_free (attr);
}
@@ -182,9 +178,8 @@ test_new_date (void)
memcpy (ck_date.day, "05", 2);
attr = gck_attribute_new_date (ATTR_TYPE, date);
g_date_free (date);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_DATE));
- g_assert (memcmp (attr->value, &ck_date, attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, &ck_date, sizeof (CK_DATE));
gck_attribute_free (attr);
}
@@ -196,10 +191,10 @@ test_new_ulong (void)
CK_ULONG ck_value = 0;
attr = gck_attribute_new_ulong (ATTR_TYPE, 88);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_ULONG));
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, sizeof (CK_ULONG));
memcpy(&ck_value, attr->value, sizeof (CK_ULONG));
- g_assert (ck_value == 88);
+ g_assert_cmpuint (ck_value, ==, 88);
gck_attribute_free (attr);
}
@@ -211,9 +206,8 @@ test_new_string (void)
GckAttribute *attr;
attr = gck_attribute_new_string (ATTR_TYPE, "a test string");
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == strlen ("a test string"));
- g_assert (memcmp (attr->value, "a test string", attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, "a test string", strlen ("a test string"));
gck_attribute_free (attr);
}
@@ -224,11 +218,11 @@ test_new_invalid (void)
GckAttribute *attr;
attr = gck_attribute_new_invalid (ATTR_TYPE);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == (gulong)-1);
- g_assert (attr->value == NULL);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, (gulong)-1);
+ g_assert_null (attr->value);
- g_assert (gck_attribute_is_invalid (attr));
+ g_assert_true (gck_attribute_is_invalid (attr));
gck_attribute_free (attr);
}
@@ -239,9 +233,9 @@ test_new_empty (void)
GckAttribute *attr;
attr = gck_attribute_new_empty (ATTR_TYPE);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == 0);
- g_assert (attr->value == NULL);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, 0);
+ g_assert_null (attr->value);
gck_attribute_free (attr);
}
@@ -252,7 +246,7 @@ test_get_boolean (void)
GckAttribute *attr;
attr = gck_attribute_new_boolean (ATTR_TYPE, TRUE);
- g_assert (gck_attribute_get_boolean (attr) == TRUE);
+ g_assert_true (gck_attribute_get_boolean (attr));
gck_attribute_free (attr);
}
@@ -269,7 +263,7 @@ test_get_date (void)
memcpy (ck_date.day, "05", 2);
attr = gck_attribute_new_date (ATTR_TYPE, &date);
gck_attribute_get_date (attr, &date2);
- g_assert (g_date_compare (&date, &date2) == 0);
+ g_assert_true (g_date_compare (&date, &date2) == 0);
gck_attribute_free (attr);
}
@@ -279,7 +273,7 @@ test_get_ulong (void)
GckAttribute *attr;
attr = gck_attribute_new_ulong (ATTR_TYPE, 88);
- g_assert (gck_attribute_get_ulong (attr) == 88);
+ g_assert_cmpuint (gck_attribute_get_ulong (attr), ==, 88);
gck_attribute_free (attr);
}
@@ -291,14 +285,14 @@ test_get_string (void)
attr = gck_attribute_new_string (ATTR_TYPE, "a test string");
value = gck_attribute_get_string (attr);
- g_assert (strcmp ("a test string", value) == 0);
+ g_assert_cmpstr ("a test string", ==, value);
g_free (value);
gck_attribute_free (attr);
/* Should be able to store null strings */
attr = gck_attribute_new_string (ATTR_TYPE, NULL);
value = gck_attribute_get_string (attr);
- g_assert (value == NULL);
+ g_assert_null (value);
gck_attribute_free (attr);
}
@@ -310,13 +304,13 @@ test_dup_attribute (void)
gck_attribute_init_ulong (&attr, ATTR_TYPE, 88);
dup = gck_attribute_dup (&attr);
gck_attribute_clear (&attr);
- g_assert (gck_attribute_get_ulong (dup) == 88);
- g_assert (dup->type == ATTR_TYPE);
+ g_assert_cmpuint (gck_attribute_get_ulong (dup), ==, 88);
+ g_assert_cmpuint (dup->type, ==, ATTR_TYPE);
gck_attribute_free (dup);
/* Should be able to dup null */
dup = gck_attribute_dup (NULL);
- g_assert (dup == NULL);
+ g_assert_null (dup);
}
static void
@@ -327,8 +321,8 @@ test_copy_attribute (void)
gck_attribute_init_ulong (&attr, ATTR_TYPE, 88);
gck_attribute_init_copy (©, &attr);
gck_attribute_clear (&attr);
- g_assert (gck_attribute_get_ulong (©) == 88);
- g_assert (copy.type == ATTR_TYPE);
+ g_assert_cmpuint (gck_attribute_get_ulong (©), ==, 88);
+ g_assert_cmpuint (copy.type, ==, ATTR_TYPE);
gck_attribute_clear (©);
}
@@ -353,7 +347,7 @@ test_builder_blank (void)
GckBuilder builder;
gck_builder_init (&builder);
- g_assert (gck_builder_find (&builder, 88) == NULL);
+ g_assert_null (gck_builder_find (&builder, 88));
gck_builder_clear (&builder);
}
@@ -366,20 +360,17 @@ test_build_data (void)
gck_builder_add_data (&builder, ATTR_TYPE, (const guchar *)"Hello", 5);
attr = gck_builder_find (&builder, ATTR_TYPE);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == 5);
- g_assert (memcmp (attr->value, "Hello", attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, "Hello", 5);
gck_builder_set_data (&builder, ATTR_TYPE, (const guchar *)ATTR_DATA, N_ATTR_DATA);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == N_ATTR_DATA);
- g_assert (memcmp (attr->value, ATTR_DATA, attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, ATTR_DATA, N_ATTR_DATA);
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == N_ATTR_DATA);
- g_assert (memcmp (attr->value, ATTR_DATA, attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, ATTR_DATA, N_ATTR_DATA);
gck_attributes_unref (attrs);
}
@@ -395,8 +386,8 @@ test_build_data_invalid (void)
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (gck_attribute_is_invalid (attr));
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_true (gck_attribute_is_invalid (attr));
gck_attributes_unref (attrs);
}
@@ -414,10 +405,9 @@ test_build_data_secure (void)
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == 8);
- g_assert (memcmp (attr->value, "password", attr->length) == 0);
- g_assert (egg_secure_check (attr->value) == TRUE);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, "password", 8);
+ g_assert_true (egg_secure_check (attr->value));
egg_secure_free (memory);
gck_attributes_unref (attrs);
@@ -437,9 +427,8 @@ test_build_take (void)
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == N_ATTR_DATA);
- g_assert (memcmp (attr->value, ATTR_DATA, attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, ATTR_DATA, N_ATTR_DATA);
gck_attributes_unref (attrs);
}
@@ -463,8 +452,8 @@ test_build_take_invalid (void)
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (gck_attribute_is_invalid (attr));
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_true (gck_attribute_is_invalid (attr));
gck_attributes_unref (attrs);
}
@@ -482,10 +471,9 @@ test_build_take_secure (void)
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == 8);
- g_assert (memcmp (attr->value, "password", attr->length) == 0);
- g_assert (egg_secure_check (attr->value) == TRUE);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, "password", 8);
+ g_assert_true (egg_secure_check (attr->value));
gck_attributes_unref (attrs);
}
@@ -500,7 +488,7 @@ test_value_to_boolean (void)
if (!gck_value_to_boolean (&data, sizeof (data), &result))
g_assert_not_reached ();
- g_assert (result == TRUE);
+ g_assert_true (result);
if (!gck_value_to_boolean (&data, sizeof (data), NULL))
g_assert_not_reached ();
@@ -523,7 +511,7 @@ test_value_to_ulong (void)
if (!gck_value_to_ulong ((const guchar *)&data, sizeof (data), &result))
g_assert_not_reached ();
- g_assert (result == 34343);
+ g_assert_cmpuint (result, ==, 34343);
if (!gck_value_to_ulong ((const guchar *)&data, sizeof (data), NULL))
g_assert_not_reached ();
@@ -546,51 +534,51 @@ test_build_boolean (void)
gboolean value;
CK_BBOOL ck_value = CK_FALSE;
- g_assert (gck_builder_find_boolean (&builder, 5, &value) == FALSE);
+ g_assert_false (gck_builder_find_boolean (&builder, 5, &value));
gck_builder_add_boolean (&builder, ATTR_TYPE, FALSE);
gck_builder_set_invalid (&builder, 5);
- g_assert (gck_builder_find_boolean (&builder, 5, &value) == FALSE);
+ g_assert_false (gck_builder_find_boolean (&builder, 5, &value));
gck_builder_set_boolean (&builder, 5, TRUE);
attr = gck_builder_find (&builder, ATTR_TYPE);
- g_assert (attr != NULL);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_BBOOL));
+ g_assert_nonnull (attr);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, sizeof (CK_BBOOL));
memcpy(&ck_value, attr->value, sizeof (CK_BBOOL));
- g_assert (ck_value == CK_FALSE);
+ g_assert_cmpuint (ck_value, ==, CK_FALSE);
if (!gck_builder_find_boolean (&builder, ATTR_TYPE, &value))
g_assert_not_reached ();
- g_assert (value == FALSE);
+ g_assert_false (value);
gck_builder_set_boolean (&builder, ATTR_TYPE, TRUE);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_BBOOL));
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, sizeof (CK_BBOOL));
memcpy(&ck_value, attr->value, sizeof (CK_BBOOL));
- g_assert (ck_value == CK_TRUE);
+ g_assert_cmpuint (ck_value, ==, CK_TRUE);
if (!gck_builder_find_boolean (&builder, ATTR_TYPE, &value))
g_assert_not_reached ();
- g_assert (value == TRUE);
+ g_assert_true (value);
if (!gck_builder_find_boolean (&builder, 5, &value))
g_assert_not_reached ();
- g_assert (value == TRUE);
+ g_assert_true (value);
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr != NULL);
+ g_assert_nonnull (attr);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_BBOOL));
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, sizeof (CK_BBOOL));
memcpy(&ck_value, attr->value, sizeof (CK_BBOOL));
- g_assert (ck_value == CK_TRUE);
+ g_assert_cmpuint (ck_value, ==, CK_TRUE);
if (!gck_attributes_find_boolean (attrs, ATTR_TYPE, &value))
g_assert_not_reached ();
- g_assert (value == TRUE);
+ g_assert_true (value);
- g_assert (gck_attribute_get_boolean (attr) == TRUE);
+ g_assert_true (gck_attribute_get_boolean (attr));
g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);
gck_attributes_unref (attrs);
@@ -605,7 +593,7 @@ test_build_date (void)
CK_DATE ck_date;
GDate *date, date2;
- g_assert (gck_builder_find_date (&builder, 5, &date2) == FALSE);
+ g_assert_false (gck_builder_find_date (&builder, 5, &date2));
date = g_date_new_dmy(8, 8, 1960);
memcpy (ck_date.year, "1960", 4);
@@ -615,7 +603,7 @@ test_build_date (void)
gck_builder_add_date (&builder, ATTR_TYPE, date);
gck_builder_set_invalid (&builder, 5);
- g_assert (gck_builder_find_date (&builder, 5, &date2) == FALSE);
+ g_assert_false (gck_builder_find_date (&builder, 5, &date2));
attr = gck_builder_find (&builder, 5);
gck_attribute_get_date (attr, &date2);
g_assert_cmpint (date2.day, ==, 0);
@@ -625,17 +613,16 @@ test_build_date (void)
gck_builder_set_date (&builder, 5, date);
attr = gck_builder_find (&builder, ATTR_TYPE);
- g_assert (attr != NULL);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_DATE));
- g_assert (memcmp (attr->value, &ck_date, attr->length) == 0);
+ g_assert_nonnull (attr);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, &ck_date, sizeof (CK_DATE));
if (!gck_builder_find_date (&builder, ATTR_TYPE, &date2))
g_assert_not_reached ();
- g_assert (g_date_compare (date, &date2) == 0);
+ g_assert_true (g_date_compare (date, &date2) == 0);
if (!gck_builder_find_date (&builder, 5, &date2))
g_assert_not_reached ();
- g_assert (g_date_compare (date, &date2) == 0);
+ g_assert_true (g_date_compare (date, &date2) == 0);
g_date_free (date);
@@ -644,22 +631,20 @@ test_build_date (void)
memcpy (ck_date.month, "06", 2);
memcpy (ck_date.day, "05", 2);
gck_builder_set_date (&builder, ATTR_TYPE, date);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_DATE));
- g_assert (memcmp (attr->value, &ck_date, attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, &ck_date, sizeof (CK_DATE));
if (!gck_builder_find_date (&builder, ATTR_TYPE, &date2))
g_assert_not_reached ();
- g_assert (g_date_compare (date, &date2) == 0);
+ g_assert_true (g_date_compare (date, &date2) == 0);
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr != NULL);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_DATE));
- g_assert (memcmp (attr->value, &ck_date, attr->length) == 0);
+ g_assert_nonnull (attr);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, &ck_date, sizeof (CK_DATE));
gck_attribute_get_date (attr, &date2);
- g_assert (g_date_compare (date, &date2) == 0);
+ g_assert_true (g_date_compare (date, &date2) == 0);
g_date_free (date);
@@ -676,49 +661,49 @@ test_build_ulong (void)
gulong value;
CK_ULONG ck_value = 0;
- g_assert (gck_builder_find_ulong (&builder, 5, &value) == FALSE);
+ g_assert_false (gck_builder_find_ulong (&builder, 5, &value));
gck_builder_add_ulong (&builder, ATTR_TYPE, 99);
gck_builder_set_invalid (&builder, 5);
- g_assert (gck_builder_find_ulong (&builder, 5, &value) == FALSE);
+ g_assert_false (gck_builder_find_ulong (&builder, 5, &value));
gck_builder_set_ulong (&builder, 5, 292);
attr = gck_builder_find (&builder, ATTR_TYPE);
- g_assert (attr != NULL);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_ULONG));
+ g_assert_nonnull (attr);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, sizeof (CK_ULONG));
memcpy(&ck_value, attr->value, sizeof (CK_ULONG));
- g_assert (ck_value == 99);
+ g_assert_cmpuint (ck_value, ==, 99);
if (!gck_builder_find_ulong (&builder, ATTR_TYPE, &value))
g_assert_not_reached ();
- g_assert (value == 99);
+ g_assert_cmpuint (value, ==, 99);
gck_builder_set_ulong (&builder, ATTR_TYPE, 88);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_ULONG));
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, sizeof (CK_ULONG));
memcpy(&ck_value, attr->value, sizeof (CK_ULONG));
- g_assert (ck_value == 88);
+ g_assert_cmpuint (ck_value, ==, 88);
if (!gck_builder_find_ulong (&builder, ATTR_TYPE, &value))
g_assert_not_reached ();
- g_assert (value == 88);
+ g_assert_cmpuint (value, ==, 88);
if (!gck_builder_find_ulong (&builder, 5, &value))
g_assert_not_reached ();
- g_assert (value == 292);
+ g_assert_cmpuint (value, ==, 292);
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr != NULL);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == sizeof (CK_ULONG));
+ g_assert_nonnull (attr);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, sizeof (CK_ULONG));
memcpy(&ck_value, attr->value, sizeof (CK_ULONG));
- g_assert (ck_value == 88);
+ g_assert_cmpuint (ck_value, ==, 88);
if (!gck_attributes_find_ulong (attrs, ATTR_TYPE, &value))
g_assert_not_reached ();
- g_assert (value == 88);
- g_assert (gck_attribute_get_ulong (attr) == 88);
+ g_assert_cmpuint (value, ==, 88);
+ g_assert_cmpuint (gck_attribute_get_ulong (attr), ==, 88);
g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);
gck_attributes_unref (attrs);
@@ -732,19 +717,18 @@ test_build_string (void)
const GckAttribute *attr;
gchar *value;
- g_assert (gck_builder_find_string (&builder, 5, &value) == FALSE);
+ g_assert_false (gck_builder_find_string (&builder, 5, &value));
gck_builder_add_string (&builder, ATTR_TYPE, "My my");
gck_builder_set_invalid (&builder, 5);
- g_assert (gck_builder_find_string (&builder, 5, &value) == FALSE);
+ g_assert_false (gck_builder_find_string (&builder, 5, &value));
gck_builder_set_string (&builder, 5, "Hello");
attr = gck_builder_find (&builder, ATTR_TYPE);
- g_assert (attr != NULL);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == strlen ("My my"));
- g_assert (memcmp (attr->value, "My my", attr->length) == 0);
+ g_assert_nonnull (attr);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length, "My my", strlen ("My my"));
if (!gck_builder_find_string (&builder, 5, &value))
g_assert_not_reached ();
@@ -752,17 +736,17 @@ test_build_string (void)
g_free (value);
gck_builder_set_string (&builder, ATTR_TYPE, "a test string");
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == strlen ("a test string"));
- g_assert (memcmp (attr->value, "a test string", attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length,
+ "a test string", strlen ("a test string"));
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr != NULL);
+ g_assert_nonnull (attr);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == strlen ("a test string"));
- g_assert (memcmp (attr->value, "a test string", attr->length) == 0);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpmem (attr->value, attr->length,
+ "a test string", strlen ("a test string"));
if (!gck_attributes_find_string (attrs, ATTR_TYPE, &value))
g_assert_not_reached ();
@@ -787,15 +771,15 @@ test_build_string_null (void)
gck_builder_add_string (&builder, ATTR_TYPE, NULL);
- g_assert (gck_builder_find_string (&builder, ATTR_TYPE, &value) == FALSE);
+ g_assert_false (gck_builder_find_string (&builder, ATTR_TYPE, &value));
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->value == NULL);
- g_assert (attr->length == 0);
+ g_assert_null (attr->value);
+ g_assert_cmpuint (attr->length, ==, 0);
value = gck_attribute_get_string (attr);
- g_assert (value == NULL);
+ g_assert_null (value);
gck_attributes_unref (attrs);
}
@@ -813,11 +797,11 @@ test_build_invalid (void)
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == (gulong)-1);
- g_assert (attr->value == NULL);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, (gulong)-1);
+ g_assert_null (attr->value);
- g_assert (gck_attribute_is_invalid (attr));
+ g_assert_true (gck_attribute_is_invalid (attr));
g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);
gck_attributes_unref (attrs);
@@ -835,15 +819,15 @@ test_build_empty (void)
gck_builder_set_empty (&builder, 5);
attr = gck_builder_find (&builder, 5);
- g_assert (attr->type == 5);
- g_assert (attr->length == 0);
- g_assert (attr->value == NULL);
+ g_assert_cmpuint (attr->type, ==, 5);
+ g_assert_cmpuint (attr->length, ==, 0);
+ g_assert_null (attr->value);
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == ATTR_TYPE);
- g_assert (attr->length == 0);
- g_assert (attr->value == NULL);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
+ g_assert_cmpuint (attr->length, ==, 0);
+ g_assert_null (attr->value);
g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);
gck_attributes_unref (attrs);
@@ -862,7 +846,7 @@ test_builder_secure (void)
attrs = gck_builder_end (&builder);
attr = gck_attributes_at (attrs, 0);
- g_assert (egg_secure_check (attr->value));
+ g_assert_true (egg_secure_check (attr->value));
gck_attributes_unref (attrs);
}
@@ -883,12 +867,12 @@ test_builder_copy (void)
gck_builder_unref (copy);
attr = gck_attributes_at (attrs, 0);
- g_assert (gck_attribute_get_ulong (attr) == 88);
- g_assert (attr->type == ATTR_TYPE);
+ g_assert_cmpuint (gck_attribute_get_ulong (attr), ==, 88);
+ g_assert_cmpuint (attr->type, ==, ATTR_TYPE);
/* Should be able to copy null */
copy = gck_builder_copy (NULL);
- g_assert (copy == NULL);
+ g_assert_null (copy);
gck_attributes_unref (attrs);
}
@@ -904,17 +888,17 @@ test_builder_refs (void)
two = gck_builder_ref (builder);
- g_assert (builder == two);
+ g_assert_true (builder == two);
if (!gck_builder_find_ulong (builder, 88, &check))
g_assert_not_reached ();
- g_assert (check == 99);
+ g_assert_cmpuint (check, ==, 99);
gck_builder_unref (builder);
if (!gck_builder_find_ulong (two, 88, &check))
g_assert_not_reached ();
- g_assert (check == 99);
+ g_assert_cmpuint (check, ==, 99);
gck_builder_unref (two);
}
@@ -930,17 +914,17 @@ test_builder_boxed (void)
two = g_boxed_copy (GCK_TYPE_BUILDER, builder);
- g_assert (builder == two);
+ g_assert_true (builder == two);
if (!gck_builder_find_ulong (builder, 88, &check))
g_assert_not_reached ();
- g_assert (check == 99);
+ g_assert_cmpuint (check, ==, 99);
g_boxed_free (GCK_TYPE_BUILDER, builder);
if (!gck_builder_find_ulong (two, 88, &check))
g_assert_not_reached ();
- g_assert (check == 99);
+ g_assert_cmpuint (check, ==, 99);
gck_builder_unref (two);
}
@@ -964,7 +948,7 @@ test_builder_add_attr (void)
/* Should be equal, and also share the values */
gck_attribute_equal (aone, atwo);
- g_assert (aone->value == atwo->value);
+ g_assert_true (aone->value == atwo->value);
gck_attributes_unref (aones);
@@ -1007,10 +991,10 @@ test_attributes_refs (void)
GckAttributes *attrs;
attrs = gck_builder_end (&builder);
- g_assert (attrs != NULL);
- g_assert (gck_attributes_count (attrs) == 0);
+ g_assert_nonnull (attrs);
+ g_assert_cmpuint (gck_attributes_count (attrs), ==, 0);
- g_assert (gck_attributes_ref (attrs) == attrs);
+ g_assert_true (gck_attributes_ref (attrs) == attrs);
gck_attributes_unref (attrs);
gck_attributes_unref (attrs);
@@ -1028,50 +1012,49 @@ test_attributes_contents (GckAttributes *attrs,
gchar *value;
GDate date, *check;
- g_assert (attrs != NULL);
+ g_assert_nonnull (attrs);
if (count < 0)
count = extras ? 7 : 5;
g_assert_cmpuint (gck_attributes_count (attrs), ==, count);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == 0);
- g_assert (gck_attribute_get_boolean (attr) == TRUE);
+ g_assert_cmpuint (attr->type, ==, 0);
+ g_assert_true (gck_attribute_get_boolean (attr));
attr = gck_attributes_at (attrs, 1);
- g_assert (attr->type == 101);
+ g_assert_cmpuint (attr->type, ==, 101);
gck_assert_cmpulong (gck_attribute_get_ulong (attr), ==, 888);
attr = gck_attributes_at (attrs, 2);
- g_assert (attr->type == 202);
+ g_assert_cmpuint (attr->type, ==, 202);
value = gck_attribute_get_string (attr);
- g_assert (strcmp (value, "string") == 0);
+ g_assert_cmpstr (value, ==, "string");
g_free (value);
attr = gck_attributes_at (attrs, 3);
- g_assert (attr->type == 303);
+ g_assert_cmpuint (attr->type, ==, 303);
check = g_date_new_dmy (11, 12, 2008);
gck_attribute_get_date (attr, &date);
- g_assert (g_date_compare (&date, check) == 0);
+ g_assert_true (g_date_compare (&date, check) == 0);
g_date_free (check);
attr = gck_attributes_at (attrs, 4);
- g_assert (attr->type == 404);
- g_assert (attr->length == N_ATTR_DATA);
- g_assert (memcmp (attr->value, ATTR_DATA, N_ATTR_DATA) == 0);
+ g_assert_cmpuint (attr->type, ==, 404);
+ g_assert_cmpmem (attr->value, attr->length, ATTR_DATA, N_ATTR_DATA);
if (!extras)
return;
attr = gck_attributes_at (attrs, 5);
- g_assert (attr->type == 505);
- g_assert (attr->length == (gulong)-1);
- g_assert (attr->value == NULL);
- g_assert (gck_attribute_is_invalid (attr));
+ g_assert_cmpuint (attr->type, ==, 505);
+ g_assert_cmpuint (attr->length, ==, (gulong)-1);
+ g_assert_null (attr->value);
+ g_assert_true (gck_attribute_is_invalid (attr));
attr = gck_attributes_at (attrs, 6);
- g_assert (attr->type == 606);
- g_assert (attr->length == 0);
- g_assert (attr->value == NULL);
+ g_assert_cmpuint (attr->type, ==, 606);
+ g_assert_cmpuint (attr->length, ==, 0);
+ g_assert_null (attr->value);
}
static void
@@ -1087,13 +1070,13 @@ test_attributes_new_empty (void)
attrs = gck_attributes_new_empty (CKA_ID, CKA_LABEL, GCK_INVALID);
g_assert_cmpuint (gck_attributes_count (attrs), ==, 2);
attr = gck_attributes_at (attrs, 0);
- g_assert (attr->type == CKA_ID);
- g_assert (attr->length == 0);
- g_assert (attr->value == NULL);
+ g_assert_cmpuint (attr->type, ==, CKA_ID);
+ g_assert_cmpuint (attr->length, ==, 0);
+ g_assert_null (attr->value);
attr = gck_attributes_at (attrs, 1);
- g_assert (attr->type == CKA_LABEL);
- g_assert (attr->length == 0);
- g_assert (attr->value == NULL);
+ g_assert_cmpuint (attr->type, ==, CKA_LABEL);
+ g_assert_cmpuint (attr->length, ==, 0);
+ g_assert_null (attr->value);
gck_attributes_unref (attrs);
}
@@ -1114,9 +1097,9 @@ test_attributes_empty (void)
g_assert_cmpuint (gck_attributes_count (attrs), ==, 4);
for (i = 0; i < gck_attributes_count (attrs); ++i) {
attr = gck_attributes_at (attrs, i);
- g_assert (attr->type == ((i + 1) * 100) + i + 1);
- g_assert (attr->value == NULL);
- g_assert (attr->length == 0);
+ g_assert_cmpuint (attr->type, ==, ((i + 1) * 100) + i + 1);
+ g_assert_null (attr->value);
+ g_assert_cmpuint (attr->length, ==, 0);
}
gck_attributes_unref (attrs);
@@ -1191,7 +1174,7 @@ test_builder_set_blank (void)
gck_builder_set_boolean (&builder, 5, TRUE);
if (!gck_builder_find_boolean (&builder, 5, &value))
g_assert_not_reached ();
- g_assert (value == TRUE);
+ g_assert_true (value);
gck_builder_clear (&builder);
}
@@ -1209,14 +1192,14 @@ test_builder_add_only (void)
gck_attributes_unref (attrs);
attrs = gck_builder_end (&two);
- g_assert (gck_attributes_find (attrs, 0UL) != NULL);
- g_assert (gck_attributes_find (attrs, 202UL) != NULL);
- g_assert (gck_attributes_find (attrs, 404UL) != NULL);
- g_assert (gck_attributes_find (attrs, 606UL) != NULL);
+ g_assert_nonnull (gck_attributes_find (attrs, 0UL));
+ g_assert_nonnull (gck_attributes_find (attrs, 202UL));
+ g_assert_nonnull (gck_attributes_find (attrs, 404UL));
+ g_assert_nonnull (gck_attributes_find (attrs, 606UL));
- g_assert (gck_attributes_find (attrs, 101UL) == NULL);
- g_assert (gck_attributes_find (attrs, 303UL) == NULL);
- g_assert (gck_attributes_find (attrs, 505UL) == NULL);
+ g_assert_null (gck_attributes_find (attrs, 101UL));
+ g_assert_null (gck_attributes_find (attrs, 303UL));
+ g_assert_null (gck_attributes_find (attrs, 505UL));
gck_attributes_unref (attrs);
}
@@ -1235,14 +1218,14 @@ test_builder_add_except (void)
gck_attributes_unref (attrs);
attrs = gck_builder_end (&two);
- g_assert (gck_attributes_find (attrs, 0UL) == NULL);
- g_assert (gck_attributes_find (attrs, 202UL) == NULL);
- g_assert (gck_attributes_find (attrs, 404UL) == NULL);
- g_assert (gck_attributes_find (attrs, 606UL) == NULL);
+ g_assert_null (gck_attributes_find (attrs, 0UL));
+ g_assert_null (gck_attributes_find (attrs, 202UL));
+ g_assert_null (gck_attributes_find (attrs, 404UL));
+ g_assert_null (gck_attributes_find (attrs, 606UL));
- g_assert (gck_attributes_find (attrs, 101UL) != NULL);
- g_assert (gck_attributes_find (attrs, 303UL) != NULL);
- g_assert (gck_attributes_find (attrs, 505UL) != NULL);
+ g_assert_nonnull (gck_attributes_find (attrs, 101UL));
+ g_assert_nonnull (gck_attributes_find (attrs, 303UL));
+ g_assert_nonnull (gck_attributes_find (attrs, 505UL));
gck_attributes_unref (attrs);
}
@@ -1285,27 +1268,26 @@ test_find_attributes (void)
attrs = gck_builder_end (&builder);
attr = gck_attributes_find (attrs, 404);
- g_assert (attr != NULL);
- g_assert (attr->length == N_ATTR_DATA);
- g_assert (memcmp (attr->value, ATTR_DATA, N_ATTR_DATA) == 0);
+ g_assert_nonnull (attr);
+ g_assert_cmpmem (attr->value, attr->length, ATTR_DATA, N_ATTR_DATA);
ret = gck_attributes_find_boolean (attrs, 0UL, &bvalue);
- g_assert (ret == TRUE);
- g_assert (bvalue == TRUE);
+ g_assert_true (ret);
+ g_assert_true (bvalue);
ret = gck_attributes_find_ulong (attrs, 101UL, &uvalue);
- g_assert (ret == TRUE);
- g_assert (uvalue == 888);
+ g_assert_true (ret);
+ g_assert_cmpuint (uvalue, ==, 888);
ret = gck_attributes_find_string (attrs, 202UL, &svalue);
- g_assert (ret == TRUE);
- g_assert (svalue != NULL);
- g_assert (strcmp (svalue, "string") == 0);
+ g_assert_true (ret);
+ g_assert_nonnull (svalue);
+ g_assert_cmpstr (svalue, ==, "string");
g_free (svalue);
ret = gck_attributes_find_date (attrs, 303UL, &check);
- g_assert (ret == TRUE);
- g_assert (g_date_compare (date, &check) == 0);
+ g_assert_true (ret);
+ g_assert_true (g_date_compare (date, &check) == 0);
gck_attributes_unref (attrs);
g_date_free (date);
diff --git a/gck/test-gck-crypto.c b/gck/test-gck-crypto.c
index 8efff239..00a6ad3b 100644
--- a/gck/test-gck-crypto.c
+++ b/gck/test-gck-crypto.c
@@ -58,23 +58,23 @@ setup (Test *test, gconstpointer unused)
/* Successful load */
test->module = gck_module_initialize (_GCK_TEST_MODULE_PATH, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_MODULE (test->module));
+ g_assert_true (GCK_IS_MODULE (test->module));
g_object_add_weak_pointer (G_OBJECT (test->module), (gpointer *)&test->module);
slots = gck_module_get_slots (test->module, TRUE);
- g_assert (slots != NULL);
+ g_assert_nonnull (slots);
test->session = gck_slot_open_session (slots->data, 0, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (test->session));
+ g_assert_true (GCK_IS_SESSION (test->session));
g_object_add_weak_pointer (G_OBJECT (test->session), (gpointer *)&test->session);
slot = gck_session_get_slot (test->session);
- g_assert (slot);
+ g_assert_nonnull (slot);
test->session_with_auth = gck_session_from_handle (slot, gck_session_get_handle (test->session),
GCK_SESSION_AUTHENTICATE);
g_signal_connect (test->session_with_auth, "discard-handle", G_CALLBACK (on_discard_handle_ignore),
NULL);
- g_assert (test->session_with_auth);
+ g_assert_nonnull (test->session_with_auth);
g_object_add_weak_pointer (G_OBJECT (test->session_with_auth), (gpointer *)&test->session_with_auth);
g_object_unref (slot);
@@ -88,9 +88,9 @@ teardown (Test *test, gconstpointer unused)
g_object_unref (test->module);
g_object_unref (test->session_with_auth);
- g_assert (test->session == NULL);
- g_assert (test->session_with_auth == NULL);
- g_assert (test->module == NULL);
+ g_assert_null (test->session);
+ g_assert_null (test->session_with_auth);
+ g_assert_null (test->module);
}
static void
@@ -113,14 +113,14 @@ find_key (GckSession *session, CK_ATTRIBUTE_TYPE method, CK_MECHANISM_TYPE mech)
gck_builder_add_boolean (&builder, method, TRUE);
objects = gck_session_find_objects (session, gck_builder_end (&builder), NULL, NULL);
- g_assert (objects);
+ g_assert_nonnull (objects);
for (l = objects; l; l = g_list_next (l)) {
if (mech) {
mechs = (gulong *)gck_object_get_data (l->data, CKA_ALLOWED_MECHANISMS,
NULL, &n_mechs, NULL);
- g_assert (mechs);
- g_assert (n_mechs == sizeof (CK_MECHANISM_TYPE));
+ g_assert_nonnull (mechs);
+ g_assert_cmpuint (n_mechs, ==, sizeof (CK_MECHANISM_TYPE));
/* We know all of them only have one allowed mech */
match = (*mechs != mech);
@@ -147,7 +147,7 @@ find_key_with_value (GckSession *session, const gchar *value)
gck_builder_add_string (&builder, CKA_VALUE, value);
objects = gck_session_find_objects (session, gck_builder_end (&builder), NULL, NULL);
- g_assert (objects);
+ g_assert_nonnull (objects);
object = g_object_ref (objects->data);
gck_list_unref_free (objects);
@@ -162,17 +162,16 @@ check_key_with_value (GckSession *session, GckObject *key, CK_OBJECT_CLASS klass
gulong check;
attrs = gck_object_get (key, NULL, NULL, CKA_CLASS, CKA_VALUE, GCK_INVALID);
- g_assert (attrs);
+ g_assert_nonnull (attrs);
if (!gck_attributes_find_ulong (attrs, CKA_CLASS, &check))
g_assert_not_reached ();
- g_assert (check == klass);
+ g_assert_cmpuint (check, ==, klass);
attr = gck_attributes_find (attrs, CKA_VALUE);
- g_assert (attr);
- g_assert (!gck_attribute_is_invalid (attr));
- egg_assert_cmpsize (attr->length, ==, strlen (value));
- g_assert (memcmp (attr->value, value, attr->length) == 0);
+ g_assert_nonnull (attr);
+ g_assert_false (gck_attribute_is_invalid (attr));
+ g_assert_cmpmem (attr->value, attr->length, value, strlen (value));
gck_attributes_unref (attrs);
}
@@ -180,10 +179,10 @@ check_key_with_value (GckSession *session, GckObject *key, CK_OBJECT_CLASS klass
static gboolean
authenticate_object (GckSlot *module, GckObject *object, gchar *label, gchar **password)
{
- g_assert (GCK_IS_MODULE (module));
- g_assert (GCK_IS_OBJECT (object));
- g_assert (password);
- g_assert (!*password);
+ g_assert_true (GCK_IS_MODULE (module));
+ g_assert_true (GCK_IS_OBJECT (object));
+ g_assert_nonnull (password);
+ g_assert_null (*password);
*password = g_strdup ("booo");
return TRUE;
@@ -201,13 +200,13 @@ test_encrypt (Test *test, gconstpointer unused)
/* Find the right key */
key = find_key (test->session, CKA_ENCRYPT, CKM_MOCK_CAPITALIZE);
- g_assert (key);
+ g_assert_nonnull (key);
/* Simple one */
output = gck_session_encrypt (test->session, key, CKM_MOCK_CAPITALIZE, (const guchar*)"blah blah",
10, &n_output, NULL, &error);
g_assert_no_error (error);
- g_assert (output);
- g_assert (n_output == 10);
+ g_assert_nonnull (output);
+ g_assert_cmpuint (n_output, ==, 10);
g_assert_cmpstr ((gchar*)output, ==, "BLAH BLAH");
g_free (output);
@@ -215,13 +214,13 @@ test_encrypt (Test *test, gconstpointer unused)
gck_session_encrypt_async (test->session, key, &mech, (const guchar*)"second chance", 14, NULL,
fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
/* Get the result */
output = gck_session_encrypt_finish (test->session, result, &n_output, &error);
g_assert_no_error (error);
- g_assert (output);
- g_assert (n_output == 14);
+ g_assert_nonnull (output);
+ g_assert_cmpuint (n_output, ==, 14);
g_assert_cmpstr ((gchar*)output, ==, "SECOND CHANCE");
g_free (output);
@@ -241,13 +240,13 @@ test_decrypt (Test *test, gconstpointer unused)
/* Find the right key */
key = find_key (test->session, CKA_DECRYPT, CKM_MOCK_CAPITALIZE);
- g_assert (key);
+ g_assert_nonnull (key);
/* Simple one */
output = gck_session_decrypt (test->session, key, CKM_MOCK_CAPITALIZE, (const guchar*)"FRY???", 7,
&n_output, NULL, &error);
g_assert_no_error (error);
- g_assert (output);
- g_assert (n_output == 7);
+ g_assert_nonnull (output);
+ g_assert_cmpuint (n_output, ==, 7);
g_assert_cmpstr ((gchar*)output, ==, "fry???");
g_free (output);
@@ -255,13 +254,13 @@ test_decrypt (Test *test, gconstpointer unused)
gck_session_decrypt_async (test->session, key, &mech, (const guchar*)"FAT CHANCE", 11, NULL,
fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
/* Get the result */
output = gck_session_decrypt_finish (test->session, result, &n_output, &error);
g_assert_no_error (error);
- g_assert (output);
- g_assert (n_output == 11);
+ g_assert_nonnull (output);
+ g_assert_cmpuint (n_output, ==, 11);
g_assert_cmpstr ((gchar*)output, ==, "fat chance");
g_free (output);
@@ -281,17 +280,17 @@ test_login_context_specific (Test *test, gconstpointer unused)
/* Find the right key */
key = find_key (test->session, CKA_SIGN, CKM_MOCK_PREFIX);
- g_assert (GCK_IS_OBJECT (key));
+ g_assert_true (GCK_IS_OBJECT (key));
g_object_add_weak_pointer (G_OBJECT (key), (gpointer *)&key);
/* Simple one */
output = gck_session_sign (test->session, key, CKM_MOCK_PREFIX, (const guchar*)"TV Monster", 11,
&n_output, NULL, &error);
g_assert_error (error, GCK_ERROR, CKR_USER_NOT_LOGGED_IN);
- g_assert (output == NULL);
+ g_assert_null (output);
g_error_free (error);
g_object_unref (key);
- g_assert (key == NULL);
+ g_assert_null (key);
}
static void
@@ -309,12 +308,12 @@ test_sign (Test *test, gconstpointer unused)
/* Find the right key */
key = find_key (test->session_with_auth, CKA_SIGN, CKM_MOCK_PREFIX);
- g_assert (key);
+ g_assert_nonnull (key);
/* Simple one */
output = gck_session_sign (test->session_with_auth, key, CKM_MOCK_PREFIX, (const guchar*)"Labarbara",
10, &n_output, NULL, &error);
g_assert_no_error (error);
- g_assert (output);
+ g_assert_nonnull (output);
g_assert_cmpuint (n_output, ==, 24);
g_assert_cmpstr ((gchar*)output, ==, "signed-prefix:Labarbara");
g_free (output);
@@ -323,12 +322,12 @@ test_sign (Test *test, gconstpointer unused)
gck_session_sign_async (test->session_with_auth, key, &mech, (const guchar*)"Conrad", 7, NULL,
fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
/* Get the result */
output = gck_session_sign_finish (test->session_with_auth, result, &n_output, &error);
g_assert_no_error (error);
- g_assert (output);
+ g_assert_nonnull (output);
g_assert_cmpuint (n_output, ==, 17);
g_assert_cmpstr ((gchar*)output, ==, "my-prefix:Conrad");
g_free (output);
@@ -351,30 +350,30 @@ test_verify (Test *test, gconstpointer unused)
/* Find the right key */
key = find_key (test->session, CKA_VERIFY, CKM_MOCK_PREFIX);
- g_assert (GCK_IS_OBJECT (key));
+ g_assert_true (GCK_IS_OBJECT (key));
g_object_add_weak_pointer (G_OBJECT (key), (gpointer *)&key);
/* Simple one */
ret = gck_session_verify (test->session, key, CKM_MOCK_PREFIX, (const guchar*)"Labarbara", 10,
(const guchar*)"signed-prefix:Labarbara", 24, NULL, &error);
g_assert_no_error (error);
- g_assert (ret);
+ g_assert_true (ret);
/* Failure one */
ret = gck_session_verify_full (test->session, key, &mech, (const guchar*)"Labarbara", 10,
(const guchar*)"my-prefix:Loborboro", 20, NULL, &error);
- g_assert (error != NULL);
- g_assert (!ret);
+ g_assert_nonnull (error);
+ g_assert_false (ret);
g_clear_error (&error);
/* Asynchronous one */
gck_session_verify_async (test->session, key, &mech, (const guchar*)"Labarbara", 10,
(const guchar*)"my-prefix:Labarbara", 20, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_verify_finish (test->session, result, &error);
g_assert_no_error (error);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (result);
/* Asynchronous failure */
@@ -382,15 +381,15 @@ test_verify (Test *test, gconstpointer unused)
gck_session_verify_async (test->session, key, &mech, (const guchar*)"Labarbara", 10,
(const guchar*)"my-prefix:Labarxoro", 20, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_verify_finish (test->session, result, &error);
- g_assert (error != NULL);
- g_assert (!ret);
+ g_assert_nonnull (error);
+ g_assert_false (ret);
g_clear_error (&error);
g_object_unref (result);
g_object_unref (key);
- g_assert (key == NULL);
+ g_assert_null (key);
}
static void
@@ -413,7 +412,7 @@ test_generate_key_pair (Test *test, gconstpointer unused)
ret = gck_session_generate_key_pair_full (test->session, &mech, pub_attrs, prv_attrs,
&pub_key, &prv_key, NULL, &error);
g_assert_no_error (error);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (pub_key);
g_object_unref (prv_key);
@@ -422,20 +421,20 @@ test_generate_key_pair (Test *test, gconstpointer unused)
pub_key = prv_key = NULL;
ret = gck_session_generate_key_pair_full (test->session, &mech, pub_attrs, prv_attrs,
&pub_key, &prv_key, NULL, &error);
- g_assert (error != NULL);
- g_assert (!ret);
+ g_assert_nonnull (error);
+ g_assert_false (ret);
g_clear_error (&error);
- g_assert (pub_key == NULL);
- g_assert (prv_key == NULL);
+ g_assert_null (pub_key);
+ g_assert_null (prv_key);
/* Asynchronous one */
mech.type = CKM_MOCK_GENERATE;
gck_session_generate_key_pair_async (test->session, &mech, pub_attrs, prv_attrs, NULL,
fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_generate_key_pair_finish (test->session, result, &pub_key, &prv_key, &error);
g_assert_no_error (error);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (result);
g_object_unref (pub_key);
g_object_unref (prv_key);
@@ -446,14 +445,14 @@ test_generate_key_pair (Test *test, gconstpointer unused)
pub_key = prv_key = NULL;
gck_session_generate_key_pair_async (test->session, &mech, pub_attrs, prv_attrs, NULL,
fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_generate_key_pair_finish (test->session, result, &pub_key, &prv_key, &error);
- g_assert (error != NULL);
- g_assert (!ret);
+ g_assert_nonnull (error);
+ g_assert_false (ret);
g_clear_error (&error);
g_object_unref (result);
- g_assert (pub_key == NULL);
- g_assert (prv_key == NULL);
+ g_assert_null (pub_key);
+ g_assert_null (prv_key);
gck_attributes_unref (pub_attrs);
gck_attributes_unref (prv_attrs);
@@ -475,25 +474,23 @@ test_wrap_key (Test *test, gconstpointer unused)
/* Simple One */
output = gck_session_wrap_key (test->session, wrapper, CKM_MOCK_WRAP, wrapped, &n_output, NULL,
&error);
g_assert_no_error (error);
- g_assert (output);
- egg_assert_cmpsize (n_output, ==, 5);
- g_assert (memcmp (output, "value", 5) == 0);
+ g_assert_nonnull (output);
+ g_assert_cmpmem (output, n_output, "value", 5);
g_free (output);
/* Full One*/
output = gck_session_wrap_key_full (test->session, wrapper, &mech, wrapped, &n_output, NULL, &error);
g_assert_no_error (error);
- g_assert (output);
- egg_assert_cmpsize (n_output, ==, 5);
- g_assert (memcmp (output, "value", 5) == 0);
+ g_assert_nonnull (output);
+ g_assert_cmpmem (output, n_output, "value", 5);
g_free (output);
/* Failure one */
mech.type = 0;
n_output = 0;
output = gck_session_wrap_key_full (test->session, wrapper, &mech, wrapped, &n_output, NULL, &error);
- g_assert (error != NULL);
- g_assert (!output);
+ g_assert_nonnull (error);
+ g_assert_null (output);
g_clear_error (&error);
egg_assert_cmpsize (n_output, ==, 0);
@@ -501,12 +498,11 @@ test_wrap_key (Test *test, gconstpointer unused)
mech.type = CKM_MOCK_WRAP;
gck_session_wrap_key_async (test->session, wrapper, &mech, wrapped, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
output = gck_session_wrap_key_finish (test->session, result, &n_output, &error);
g_assert_no_error (error);
- g_assert (output);
- egg_assert_cmpsize (n_output, ==, 5);
- g_assert (memcmp (output, "value", 5) == 0);
+ g_assert_nonnull (output);
+ g_assert_cmpmem (output, n_output, "value", 5);
g_object_unref (result);
g_free (output);
@@ -516,10 +512,10 @@ test_wrap_key (Test *test, gconstpointer unused)
n_output = 0;
gck_session_wrap_key_async (test->session, wrapper, &mech, wrapped, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
output = gck_session_wrap_key_finish (test->session, result, &n_output, &error);
- g_assert (error != NULL);
- g_assert (!output);
+ g_assert_nonnull (error);
+ g_assert_null (output);
g_clear_error (&error);
egg_assert_cmpsize (n_output, ==, 0);
g_object_unref (result);
@@ -545,25 +541,25 @@ test_unwrap_key (Test *test, gconstpointer unused)
/* Full One*/
unwrapped = gck_session_unwrap_key_full (test->session, wrapper, &mech, (const guchar *)"special", 7,
attrs, NULL, &error);
g_assert_no_error (error);
- g_assert (GCK_IS_OBJECT (unwrapped));
+ g_assert_true (GCK_IS_OBJECT (unwrapped));
check_key_with_value (test->session, unwrapped, CKO_SECRET_KEY, "special");
g_object_unref (unwrapped);
/* Failure one */
mech.type = 0;
unwrapped = gck_session_unwrap_key_full (test->session, wrapper, &mech, (const guchar *)"special", 7,
attrs, NULL, &error);
- g_assert (error != NULL);
- g_assert (!unwrapped);
+ g_assert_nonnull (error);
+ g_assert_null (unwrapped);
g_clear_error (&error);
/* Asynchronous one */
mech.type = CKM_MOCK_WRAP;
gck_session_unwrap_key_async (test->session, wrapper, &mech, (const guchar *)"special", 7, attrs,
NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
unwrapped = gck_session_unwrap_key_finish (test->session, result, &error);
g_assert_no_error (error);
- g_assert (GCK_IS_OBJECT (unwrapped));
+ g_assert_true (GCK_IS_OBJECT (unwrapped));
check_key_with_value (test->session, unwrapped, CKO_SECRET_KEY, "special");
g_object_unref (unwrapped);
g_object_unref (result);
@@ -573,10 +569,10 @@ test_unwrap_key (Test *test, gconstpointer unused)
mech.type = 0;
gck_session_unwrap_key_async (test->session, wrapper, &mech, (const guchar *)"special", 6, attrs,
NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
unwrapped = gck_session_unwrap_key_finish (test->session, result, &error);
- g_assert (error != NULL);
- g_assert (!unwrapped);
+ g_assert_nonnull (error);
+ g_assert_null (unwrapped);
g_clear_error (&error);
g_object_unref (result);
@@ -601,25 +597,25 @@ test_derive_key (Test *test, gconstpointer unused)
/* Full One*/
derived = gck_session_derive_key_full (test->session, wrapper, &mech, attrs, NULL, &error);
g_assert_no_error (error);
- g_assert (GCK_IS_OBJECT (derived));
+ g_assert_true (GCK_IS_OBJECT (derived));
check_key_with_value (test->session, derived, CKO_SECRET_KEY, "derived");
g_object_unref (derived);
/* Failure one */
mech.type = 0;
derived = gck_session_derive_key_full (test->session, wrapper, &mech, attrs, NULL, &error);
- g_assert (error != NULL);
- g_assert (!derived);
+ g_assert_nonnull (error);
+ g_assert_null (derived);
g_clear_error (&error);
/* Asynchronous one */
mech.type = CKM_MOCK_DERIVE;
gck_session_derive_key_async (test->session, wrapper, &mech, attrs, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
derived = gck_session_derive_key_finish (test->session, result, &error);
g_assert_no_error (error);
- g_assert (GCK_IS_OBJECT (derived));
+ g_assert_true (GCK_IS_OBJECT (derived));
check_key_with_value (test->session, derived, CKO_SECRET_KEY, "derived");
g_object_unref (derived);
g_object_unref (result);
@@ -629,10 +625,10 @@ test_derive_key (Test *test, gconstpointer unused)
mech.type = 0;
gck_session_derive_key_async (test->session, wrapper, &mech, attrs, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
derived = gck_session_derive_key_finish (test->session, result, &error);
- g_assert (error != NULL);
- g_assert (!derived);
+ g_assert_nonnull (error);
+ g_assert_null (derived);
g_clear_error (&error);
g_object_unref (result);
diff --git a/gck/test-gck-enumerator.c b/gck/test-gck-enumerator.c
index 73a13860..afb7e900 100644
--- a/gck/test-gck-enumerator.c
+++ b/gck/test-gck-enumerator.c
@@ -50,7 +50,7 @@ setup (Test *test, gconstpointer unused)
/* Successful load */
test->module = gck_module_initialize (_GCK_TEST_MODULE_PATH, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_MODULE (test->module));
+ g_assert_true (GCK_IS_MODULE (test->module));
g_object_add_weak_pointer (G_OBJECT (test->module), (gpointer *)&test->module);
test->modules = g_list_append (NULL, g_object_ref (test->module));
@@ -62,7 +62,7 @@ teardown (Test *test, gconstpointer unused)
gck_list_unref_free (test->modules);
g_object_unref (test->module);
- g_assert (test->module == NULL);
+ g_assert_null (test->module);
g_thread_pool_stop_unused_threads ();
}
@@ -76,10 +76,10 @@ test_create (Test *test, gconstpointer unused)
uri_data = gck_uri_data_new ();
en = _gck_enumerator_new_for_modules (test->modules, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
g_object_get (en, "object-type", &object_type, NULL);
- g_assert (object_type == GCK_TYPE_OBJECT);
+ g_assert_true (object_type == GCK_TYPE_OBJECT);
g_object_unref (en);
}
@@ -94,7 +94,7 @@ test_create_slots (Test *test, gconstpointer unused)
uri_data = gck_uri_data_new ();
slots = gck_module_get_slots (test->module, FALSE);
en = _gck_enumerator_new_for_slots (slots, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
g_object_unref (en);
gck_list_unref_free (slots);
}
@@ -109,10 +109,10 @@ test_next (Test *test, gconstpointer unused)
uri_data = gck_uri_data_new ();
en = _gck_enumerator_new_for_modules (test->modules, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
obj = gck_enumerator_next (en, NULL, &error);
- g_assert (GCK_IS_OBJECT (obj));
+ g_assert_true (GCK_IS_OBJECT (obj));
g_object_unref (obj);
g_object_unref (en);
@@ -130,10 +130,10 @@ test_next_slots (Test *test, gconstpointer unused)
uri_data = gck_uri_data_new ();
slots = gck_module_get_slots (test->module, FALSE);
en = _gck_enumerator_new_for_slots (slots, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
obj = gck_enumerator_next (en, NULL, &error);
- g_assert (GCK_IS_OBJECT (obj));
+ g_assert_true (GCK_IS_OBJECT (obj));
g_object_unref (obj);
g_object_unref (en);
@@ -150,17 +150,17 @@ test_next_and_resume (Test *test, gconstpointer unused)
uri_data = gck_uri_data_new ();
en = _gck_enumerator_new_for_modules (test->modules, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
obj = gck_enumerator_next (en, NULL, &error);
g_assert_no_error (error);
- g_assert (GCK_IS_OBJECT (obj));
+ g_assert_true (GCK_IS_OBJECT (obj));
obj2 = gck_enumerator_next (en, NULL, &error);
g_assert_no_error (error);
- g_assert (GCK_IS_OBJECT (obj2));
+ g_assert_true (GCK_IS_OBJECT (obj2));
- g_assert (!gck_object_equal (obj, obj2));
+ g_assert_false (gck_object_equal (obj, obj2));
g_object_unref (obj);
g_object_unref (obj2);
@@ -177,13 +177,13 @@ test_next_n (Test *test, gconstpointer unused)
uri_data = gck_uri_data_new ();
en = _gck_enumerator_new_for_modules (test->modules, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
objects = gck_enumerator_next_n (en, -1, NULL, &error);
g_assert_no_error (error);
g_assert_cmpint (g_list_length (objects), ==, 5);
for (l = objects; l; l = g_list_next (l))
- g_assert (GCK_IS_OBJECT (l->data));
+ g_assert_true (GCK_IS_OBJECT (l->data));
gck_list_unref_free (objects);
g_object_unref (en);
@@ -208,17 +208,17 @@ test_next_async (Test *test, gconstpointer unused)
uri_data = gck_uri_data_new ();
en = _gck_enumerator_new_for_modules (test->modules, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
gck_enumerator_next_async (en, -1, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result);
+ g_assert_nonnull (result);
objects = gck_enumerator_next_finish (en, result, &error);
g_assert_no_error (error);
g_assert_cmpint (g_list_length (objects), ==, 5);
for (l = objects; l; l = g_list_next (l))
- g_assert (GCK_IS_OBJECT (l->data));
+ g_assert_true (GCK_IS_OBJECT (l->data));
g_object_unref (result);
gck_list_unref_free (objects);
@@ -238,16 +238,17 @@ test_enumerate_session (Test *test,
GList *slots;
slots = gck_module_get_slots (test->module, FALSE);
- g_assert (slots != NULL && GCK_IS_SLOT (slots->data));
+ g_assert_nonnull (slots);
+ g_assert_true (GCK_IS_SLOT (slots->data));
session = gck_session_open (slots->data, 0, NULL, NULL, &error);
g_assert_no_error (error);
en = gck_session_enumerate_objects (session, gck_builder_end (&builder));
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
obj = gck_enumerator_next (en, NULL, &error);
- g_assert (GCK_IS_OBJECT (obj));
+ g_assert_true (GCK_IS_OBJECT (obj));
g_object_unref (obj);
g_object_unref (en);
@@ -268,12 +269,12 @@ test_attribute_match (Test *test, gconstpointer unused)
gck_builder_add_string (&builder, CKA_LABEL, "Private Capitalize Key");
uri_data->attributes = gck_attributes_ref_sink (gck_builder_end (&builder));
en = _gck_enumerator_new_for_modules (test->modules, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
objects = gck_enumerator_next_n (en, -1, NULL, &error);
g_assert_no_error (error);
g_assert_cmpint (g_list_length (objects), ==, 1);
- g_assert (GCK_IS_OBJECT (objects->data));
+ g_assert_true (GCK_IS_OBJECT (objects->data));
gck_list_unref_free (objects);
g_object_unref (en);
@@ -292,7 +293,7 @@ test_authenticate_interaction (Test *test,
uri_data = gck_uri_data_new ();
en = _gck_enumerator_new_for_modules (test->modules, GCK_SESSION_LOGIN_USER, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
g_object_add_weak_pointer (G_OBJECT (en), (gpointer *)&en);
interaction = mock_interaction_new ("booo");
@@ -301,20 +302,20 @@ test_authenticate_interaction (Test *test,
check = NULL;
g_object_get (en, "interaction", &check, NULL);
- g_assert (interaction == check);
+ g_assert_true (interaction == check);
g_object_unref (interaction);
g_object_unref (check);
obj = gck_enumerator_next (en, NULL, &error);
- g_assert (GCK_IS_OBJECT (obj));
+ g_assert_true (GCK_IS_OBJECT (obj));
g_object_add_weak_pointer (G_OBJECT (obj), (gpointer *)&obj);
g_object_unref (obj);
g_object_unref (en);
- g_assert (en == NULL);
- g_assert (obj == NULL);
- g_assert (interaction == NULL);
+ g_assert_null (en);
+ g_assert_null (obj);
+ g_assert_null (interaction);
}
static gboolean
@@ -324,11 +325,11 @@ on_authenticate_token (GckModule *module,
gchar **password,
gpointer unused)
{
- g_assert (unused == GUINT_TO_POINTER (35));
- g_assert (password != NULL);
- g_assert (*password == NULL);
- g_assert (GCK_IS_MODULE (module));
- g_assert (GCK_IS_SLOT (slot));
+ g_assert_true (unused == GUINT_TO_POINTER (35));
+ g_assert_nonnull (password);
+ g_assert_null (*password);
+ g_assert_true (GCK_IS_MODULE (module));
+ g_assert_true (GCK_IS_SLOT (slot));
*password = g_strdup ("booo");
return TRUE;
@@ -349,11 +350,11 @@ test_authenticate_compat (Test *test,
uri_data = gck_uri_data_new ();
en = _gck_enumerator_new_for_modules (test->modules, GCK_SESSION_LOGIN_USER, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
g_object_add_weak_pointer (G_OBJECT (en), (gpointer *)&en);
obj = gck_enumerator_next (en, NULL, &error);
- g_assert (GCK_IS_OBJECT (obj));
+ g_assert_true (GCK_IS_OBJECT (obj));
g_object_add_weak_pointer (G_OBJECT (obj), (gpointer *)&obj);
g_object_unref (obj);
@@ -361,8 +362,8 @@ test_authenticate_compat (Test *test,
g_signal_handler_disconnect (test->modules->data, sig);
- g_assert (obj == NULL);
- g_assert (en == NULL);
+ g_assert_null (obj);
+ g_assert_null (en);
}
static void
@@ -377,11 +378,11 @@ test_token_match (Test *test, gconstpointer unused)
uri_data->token_info = g_new0 (GckTokenInfo, 1);
uri_data->token_info->label = g_strdup ("Invalid token name");
en = _gck_enumerator_new_for_modules (test->modules, 0, uri_data);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
objects = gck_enumerator_next_n (en, -1, NULL, &error);
g_assert_cmpint (g_list_length (objects), ==, 0);
- g_assert (error == NULL);
+ g_assert_no_error (error);
gck_list_unref_free (objects);
g_object_unref (en);
@@ -453,9 +454,9 @@ mock_object_set_property (GObject *obj,
switch (prop_id) {
case PROP_ATTRIBUTES:
- g_assert (self->attrs == NULL);
+ g_assert_null (self->attrs);
self->attrs = g_value_dup_boxed (value);
- g_assert (self->attrs != NULL);
+ g_assert_nonnull (self->attrs);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
@@ -525,8 +526,8 @@ test_attribute_get (Test *test,
for (l = objects; l != NULL; l = g_list_next (l)) {
mock = l->data;
- g_assert (G_TYPE_CHECK_INSTANCE_TYPE (mock, mock_object_get_type ()));
- g_assert (mock->attrs != NULL);
+ g_assert_true (G_TYPE_CHECK_INSTANCE_TYPE (mock, mock_object_get_type ()));
+ g_assert_nonnull (mock->attrs);
}
gck_list_unref_free (objects);
@@ -553,9 +554,9 @@ test_attribute_get_one_at_a_time (Test *test,
if (object == NULL)
break;
- g_assert (G_TYPE_CHECK_INSTANCE_TYPE (object, mock_object_get_type ()));
+ g_assert_true (G_TYPE_CHECK_INSTANCE_TYPE (object, mock_object_get_type ()));
mock = (MockObject *)object;
- g_assert (mock->attrs != NULL);
+ g_assert_nonnull (mock->attrs);
g_object_unref (object);
}
diff --git a/gck/test-gck-module.c b/gck/test-gck-module.c
index 320701b3..1e9d658b 100644
--- a/gck/test-gck-module.c
+++ b/gck/test-gck-module.c
@@ -43,7 +43,7 @@ setup (Test *test, gconstpointer unused)
/* Successful load */
test->module = gck_module_initialize (_GCK_TEST_MODULE_PATH, NULL, &err);
g_assert_no_error (err);
- g_assert (test->module);
+ g_assert_nonnull (test->module);
g_object_add_weak_pointer (G_OBJECT (test->module), (gpointer *)&test->module);
}
@@ -51,7 +51,7 @@ static void
teardown (Test *test, gconstpointer unused)
{
g_object_unref (test->module);
- g_assert (test->module == NULL);
+ g_assert_null (test->module);
}
static void
@@ -74,12 +74,12 @@ test_initialize_async (void)
NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
/* Get the result */
module = gck_module_initialize_finish (result, &error);
g_assert_no_error (error);
- g_assert (GCK_IS_MODULE (module));
+ g_assert_true (GCK_IS_MODULE (module));
g_object_unref (result);
g_object_unref (module);
@@ -95,14 +95,14 @@ test_invalid_modules (Test *test, gconstpointer unused)
/* Shouldn't be able to load modules */
invalid = gck_module_initialize ("blah-blah-non-existant", NULL, &error);
g_assert_error (error, GCK_ERROR, (int)CKR_GCK_MODULE_PROBLEM);
- g_assert (invalid == NULL);
+ g_assert_null (invalid);
g_clear_error (&error);
/* Shouldn't be able to load any file successfully */
invalid = gck_module_initialize ("/usr/lib/libm.so", NULL, &error);
g_assert_error (error, GCK_ERROR, (int)CKR_GCK_MODULE_PROBLEM);
- g_assert (invalid == NULL);
+ g_assert_null (invalid);
g_clear_error (&error);
}
@@ -115,17 +115,17 @@ test_module_equals_hash (Test *test, gconstpointer unused)
guint hash;
hash = gck_module_hash (test->module);
- g_assert (hash != 0);
+ g_assert_cmpuint (hash, !=, 0);
- g_assert (gck_module_equal (test->module, test->module));
+ g_assert_true (gck_module_equal (test->module, test->module));
other = gck_module_new (gck_module_get_functions (test->module));
obj = g_object_new (G_TYPE_OBJECT, NULL);
- g_assert (gck_module_equal (test->module, other));
+ g_assert_true (gck_module_equal (test->module, other));
/* TODO: Could do with another test for inequality */
- g_assert (!gck_module_equal (test->module, obj));
+ g_assert_false (gck_module_equal (test->module, obj));
g_object_unref (other);
g_object_unref (obj);
@@ -137,8 +137,8 @@ test_module_props (Test *test, gconstpointer unused)
gchar *path;
g_object_get (test->module, "path", &path, NULL);
- g_assert (path != NULL && "no module-path");
- g_assert (strcmp (_GCK_TEST_MODULE_PATH, path) == 0 && "module path wrong");
+ g_assert_nonnull (path);
+ g_assert_cmpstr (_GCK_TEST_MODULE_PATH, ==, path);
g_free (path);
}
@@ -148,15 +148,15 @@ test_module_info (Test *test, gconstpointer unused)
GckModuleInfo *info;
info = gck_module_get_info (test->module);
- g_assert (info != NULL && "no module info");
-
- g_assert (info->pkcs11_version_major == CRYPTOKI_VERSION_MAJOR && "wrong major version");
- g_assert (info->pkcs11_version_minor == CRYPTOKI_VERSION_MINOR && "wrong minor version");
- g_assert (strcmp ("TEST MANUFACTURER", info->manufacturer_id) == 0);
- g_assert (strcmp ("TEST LIBRARY", info->library_description) == 0);
- g_assert (0 == info->flags);
- g_assert (45 == info->library_version_major);
- g_assert (145 == info->library_version_minor);
+ g_assert_nonnull (info);
+
+ g_assert_cmpuint (info->pkcs11_version_major, ==, CRYPTOKI_VERSION_MAJOR);
+ g_assert_cmpuint (info->pkcs11_version_minor, ==, CRYPTOKI_VERSION_MINOR);
+ g_assert_cmpstr ("TEST MANUFACTURER", ==, info->manufacturer_id);
+ g_assert_cmpstr ("TEST LIBRARY", ==, info->library_description);
+ g_assert_cmpuint (0, ==, info->flags);
+ g_assert_cmpuint (45, ==, info->library_version_major);
+ g_assert_cmpuint (145, ==, info->library_version_minor);
gck_module_info_free (info);
}
diff --git a/gck/test-gck-modules.c b/gck/test-gck-modules.c
index 19cdaca3..1468b9b7 100644
--- a/gck/test-gck-modules.c
+++ b/gck/test-gck-modules.c
@@ -49,7 +49,7 @@ setup (Test *test, gconstpointer unused)
/* Successful load */
module = gck_module_initialize (_GCK_TEST_MODULE_PATH, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_MODULE (module));
+ g_assert_true (GCK_IS_MODULE (module));
test->modules = g_list_append (NULL, module);
}
@@ -71,12 +71,12 @@ test_enumerate_objects (Test *test, gconstpointer unused)
gck_builder_add_string (&builder, CKA_LABEL, "Private Capitalize Key");
en = gck_modules_enumerate_objects (test->modules, gck_builder_end (&builder), 0);
- g_assert (GCK_IS_ENUMERATOR (en));
+ g_assert_true (GCK_IS_ENUMERATOR (en));
objects = gck_enumerator_next_n (en, -1, NULL, &error);
g_assert_no_error (error);
g_assert_cmpint (g_list_length (objects), ==, 1);
- g_assert (GCK_IS_OBJECT (objects->data));
+ g_assert_true (GCK_IS_OBJECT (objects->data));
gck_list_unref_free (objects);
g_object_unref (en);
@@ -90,7 +90,7 @@ test_token_for_uri (Test *test, gconstpointer unused)
GError *error = NULL;
slot = gck_modules_token_for_uri (test->modules, "pkcs11:token=TEST%20LABEL", &error);
- g_assert (GCK_IS_SLOT (slot));
+ g_assert_true (GCK_IS_SLOT (slot));
g_object_unref (slot);
}
@@ -102,8 +102,8 @@ test_token_for_uri_not_found (Test *test, gconstpointer unused)
GError *error = NULL;
slot = gck_modules_token_for_uri (test->modules, "pkcs11:token=UNKNOWN", &error);
- g_assert (slot == NULL);
- g_assert (error == NULL);
+ g_assert_null (slot);
+ g_assert_no_error (error);
}
static void
@@ -113,9 +113,8 @@ test_token_for_uri_error (Test *test, gconstpointer unused)
GError *error = NULL;
slot = gck_modules_token_for_uri (test->modules, "http://invalid.uri";, &error);
- g_assert (slot == NULL);
- g_assert (error != NULL);
- g_assert (g_error_matches (error, GCK_URI_ERROR, GCK_URI_BAD_PREFIX));
+ g_assert_null (slot);
+ g_assert_error (error, GCK_URI_ERROR, GCK_URI_BAD_PREFIX);
g_error_free (error);
}
@@ -126,7 +125,7 @@ test_object_for_uri (Test *test, gconstpointer unused)
GError *error = NULL;
object = gck_modules_object_for_uri (test->modules,
"pkcs11:object=Public%20Capitalize%20Key;objecttype=public", 0, &error);
- g_assert (GCK_IS_OBJECT (object));
+ g_assert_true (GCK_IS_OBJECT (object));
g_object_unref (object);
}
@@ -137,8 +136,8 @@ test_object_for_uri_not_found (Test *test, gconstpointer unused)
GError *error = NULL;
object = gck_modules_object_for_uri (test->modules, "pkcs11:object=Unknown%20Label", 0, &error);
- g_assert (object == NULL);
- g_assert (error == NULL);
+ g_assert_null (object);
+ g_assert_null (error);
}
static void
@@ -148,9 +147,8 @@ test_object_for_uri_error (Test *test, gconstpointer unused)
GError *error = NULL;
object = gck_modules_object_for_uri (test->modules, "http://invalid.uri";, 0, &error);
- g_assert (object == NULL);
- g_assert (error != NULL);
- g_assert (g_error_matches (error, GCK_URI_ERROR, GCK_URI_BAD_PREFIX));
+ g_assert_null (object);
+ g_assert_error (error, GCK_URI_ERROR, GCK_URI_BAD_PREFIX);
g_error_free (error);
}
@@ -161,8 +159,8 @@ test_objects_for_uri (Test *test, gconstpointer unused)
GError *error = NULL;
objects = gck_modules_objects_for_uri (test->modules, "pkcs11:token=TEST%20LABEL", 0, &error);
- g_assert (objects);
- g_assert (!error);
+ g_assert_nonnull (objects);
+ g_assert_no_error (error);
g_assert_cmpint (g_list_length (objects), ==, 5);
gck_list_unref_free (objects);
@@ -176,12 +174,12 @@ test_enumerate_uri (Test *test, gconstpointer unused)
GError *error = NULL;
en = gck_modules_enumerate_uri (test->modules, "pkcs11:token=TEST%20LABEL", 0, &error);
- g_assert (GCK_IS_ENUMERATOR (en));
- g_assert (!error);
+ g_assert_true (GCK_IS_ENUMERATOR (en));
+ g_assert_no_error (error);
objects = gck_enumerator_next_n (en, -1, NULL, &error);
g_assert_cmpint (g_list_length (objects), ==, 5);
- g_assert (!error);
+ g_assert_no_error (error);
g_object_unref (en);
gck_list_unref_free (objects);
diff --git a/gck/test-gck-object.c b/gck/test-gck-object.c
index 61a52862..4741898e 100644
--- a/gck/test-gck-object.c
+++ b/gck/test-gck-object.c
@@ -51,10 +51,10 @@ setup (Test *test, gconstpointer unused)
/* Successful load */
test->module = gck_module_initialize (_GCK_TEST_MODULE_PATH, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_MODULE (test->module));
+ g_assert_true (GCK_IS_MODULE (test->module));
slots = gck_module_get_slots (test->module, TRUE);
- g_assert (slots != NULL);
+ g_assert_nonnull (slots);
test->slot = GCK_SLOT (slots->data);
g_object_ref (test->slot);
@@ -62,11 +62,11 @@ setup (Test *test, gconstpointer unused)
test->session = gck_slot_open_session (test->slot, 0, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (test->session));
+ g_assert_true (GCK_IS_SESSION (test->session));
/* Our module always exports a token object with this */
test->object = gck_object_from_handle (test->session, 2);
- g_assert (test->object != NULL);
+ g_assert_nonnull (test->object);
}
static void
@@ -85,11 +85,11 @@ test_object_props (Test *test, gconstpointer unused)
GckModule *mod;
CK_OBJECT_HANDLE handle;
g_object_get (test->object, "session", &sess, "module", &mod, "handle", &handle, NULL);
- g_assert (test->session == sess);
+ g_assert_true (test->session == sess);
g_object_unref (sess);
- g_assert (test->module == mod);
+ g_assert_true (test->module == mod);
g_object_unref (mod);
- g_assert (handle == 2);
+ g_assert_cmpuint (handle, ==, 2);
}
static void
@@ -103,30 +103,30 @@ test_object_equals_hash (Test *test, gconstpointer unused)
guint hash;
hash = gck_object_hash (test->object);
- g_assert (hash != 0);
+ g_assert_cmpuint (hash, !=, 0);
- g_assert (gck_object_equal (test->object, test->object));
+ g_assert_true (gck_object_equal (test->object, test->object));
other_slot = g_object_new (GCK_TYPE_SLOT, "module", test->module, "handle", GCK_MOCK_SLOT_TWO_ID,
NULL);
other_session = gck_slot_open_session (other_slot, 0, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (other_session));
+ g_assert_true (GCK_IS_SESSION (other_session));
other_object = gck_object_from_handle (other_session, gck_object_get_handle (test->object));
- g_assert (!gck_object_equal (test->object, other_object));
+ g_assert_false (gck_object_equal (test->object, other_object));
g_object_unref (other_slot);
g_object_unref (other_session);
g_object_unref (other_object);
obj = g_object_new (G_TYPE_OBJECT, NULL);
- g_assert (!gck_object_equal (test->object, obj));
+ g_assert_false (gck_object_equal (test->object, obj));
g_object_unref (obj);
other_object = gck_object_from_handle (test->session, 383838);
- g_assert (!gck_object_equal (test->object, other_object));
+ g_assert_false (gck_object_equal (test->object, other_object));
g_object_unref (other_object);
other_object = gck_object_from_handle (test->session, gck_object_get_handle (test->object));
- g_assert (gck_object_equal (test->object, other_object));
+ g_assert_true (gck_object_equal (test->object, other_object));
g_object_unref (other_object);
}
@@ -155,7 +155,7 @@ test_create_object (Test *test, gconstpointer unused)
attrs = gck_attributes_ref_sink (gck_builder_end (&builder));
object = gck_session_create_object (test->session, attrs, NULL, &err);
- g_assert (GCK_IS_OBJECT (object));
+ g_assert_true (GCK_IS_OBJECT (object));
g_assert_no_error (err);
last_handle = gck_object_get_handle (object);
@@ -164,14 +164,14 @@ test_create_object (Test *test, gconstpointer unused)
/* Using async */
gck_session_create_object_async (test->session, attrs, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
object = gck_session_create_object_finish (test->session, result, &err);
g_object_unref (result);
g_assert_no_error (err);
- g_assert (GCK_IS_OBJECT (object));
+ g_assert_true (GCK_IS_OBJECT (object));
- g_assert (last_handle != gck_object_get_handle (object));
+ g_assert_cmpuint (last_handle, !=, gck_object_get_handle (object));
g_object_unref (object);
gck_attributes_unref (attrs);
@@ -195,27 +195,27 @@ test_destroy_object (Test *test, gconstpointer unused)
/* Using simple */
object = gck_session_create_object (test->session, attrs, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_OBJECT (object));
+ g_assert_true (GCK_IS_OBJECT (object));
ret = gck_object_destroy (object, NULL, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (object);
/* Using async */
object = gck_session_create_object (test->session, attrs, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_OBJECT (object));
+ g_assert_true (GCK_IS_OBJECT (object));
/* Using async */
gck_object_destroy_async (object, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_object_destroy_finish (object, result, &err);
g_object_unref (result);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (object);
gck_attributes_unref (attrs);
@@ -238,8 +238,8 @@ test_get_attributes (Test *test, gconstpointer unused)
attrs = gck_object_get (test->object, NULL, &err, CKA_CLASS, CKA_LABEL, GCK_INVALID);
g_assert_no_error (err);
if (attrs != NULL) {
- g_assert (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == CKO_DATA);
- g_assert (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "TEST
LABEL") == 0);
+ g_assert_true (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == CKO_DATA);
+ g_assert_true (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "TEST
LABEL") == 0);
g_free (value); value = NULL;
}
gck_attributes_unref (attrs);
@@ -247,23 +247,23 @@ test_get_attributes (Test *test, gconstpointer unused)
/* Full */
attrs = gck_object_get_full (test->object, attr_types, G_N_ELEMENTS (attr_types), NULL, &err);
g_assert_no_error (err);
- g_assert (attrs);
- g_assert (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == CKO_DATA);
- g_assert (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "TEST LABEL") == 0);
+ g_assert_nonnull (attrs);
+ g_assert_true (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == CKO_DATA);
+ g_assert_true (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "TEST LABEL")
== 0);
g_free (value); value = NULL;
gck_attributes_unref (attrs);
/* Async */
gck_object_get_async (test->object, attr_types, G_N_ELEMENTS (attr_types), NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
attrs = gck_object_get_finish (test->object, result, &err);
g_object_unref (result);
g_assert_no_error (err);
- g_assert (attrs);
- g_assert (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == CKO_DATA);
- g_assert (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "TEST LABEL") == 0);
+ g_assert_nonnull (attrs);
+ g_assert_true (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == CKO_DATA);
+ g_assert_true (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "TEST LABEL")
== 0);
g_free (value); value = NULL;
gck_attributes_unref (attrs);
}
@@ -279,30 +279,30 @@ test_get_data_attribute (Test *test, gconstpointer unused)
/* Simple */
klass = (gulong *)gck_object_get_data (test->object, CKA_CLASS, NULL, &n_data, &err);
g_assert_no_error (err);
- g_assert (klass);
- g_assert (n_data == sizeof (CK_OBJECT_CLASS));
- g_assert (*klass == CKO_DATA);
+ g_assert_nonnull (klass);
+ g_assert_cmpuint (n_data, ==, sizeof (CK_OBJECT_CLASS));
+ g_assert_true (*klass == CKO_DATA);
g_free (klass);
/* Full */
klass = (gulong *)gck_object_get_data_full (test->object, CKA_CLASS, NULL, NULL, &n_data, &err);
g_assert_no_error (err);
- g_assert (klass);
- g_assert (n_data == sizeof (CK_OBJECT_CLASS));
- g_assert (*klass == CKO_DATA);
+ g_assert_nonnull (klass);
+ g_assert_cmpuint (n_data, ==, sizeof (CK_OBJECT_CLASS));
+ g_assert_true (*klass == CKO_DATA);
g_free (klass);
/* Async */
gck_object_get_data_async (test->object, CKA_CLASS, NULL, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
klass = (gulong *)gck_object_get_data_finish (test->object, result, &n_data, &err);
g_object_unref (result);
g_assert_no_error (err);
- g_assert (klass);
- g_assert (n_data == sizeof (CK_OBJECT_CLASS));
- g_assert (*klass == CKO_DATA);
+ g_assert_nonnull (klass);
+ g_assert_cmpuint (n_data, ==, sizeof (CK_OBJECT_CLASS));
+ g_assert_true (*klass == CKO_DATA);
g_free (klass);
}
@@ -324,10 +324,10 @@ test_set_attributes (Test *test, gconstpointer unused)
/* Full */
ret = gck_object_set (test->object, gck_builder_end (&builder), NULL, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
attrs = gck_object_get (test->object, NULL, &err, CKA_CLASS, CKA_LABEL, GCK_INVALID);
- g_assert (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == 6);
- g_assert (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "CHANGE TWO") == 0);
+ g_assert_true (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == 6);
+ g_assert_true (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "CHANGE TWO")
== 0);
g_free (value); value = NULL;
gck_attributes_unref (attrs);
@@ -337,15 +337,15 @@ test_set_attributes (Test *test, gconstpointer unused)
/* Async */
gck_object_set_async (test->object, gck_builder_end (&builder), NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_object_set_finish (test->object, result, &err);
g_object_unref (result);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
attrs = gck_object_get (test->object, NULL, &err, CKA_CLASS, CKA_LABEL, GCK_INVALID);
- g_assert (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == 7);
- g_assert (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "CHANGE THREE") ==
0);
+ g_assert_true (gck_attributes_find_ulong (attrs, CKA_CLASS, &klass) && klass == 7);
+ g_assert_true (gck_attributes_find_string (attrs, CKA_LABEL, &value) && strcmp (value, "CHANGE
THREE") == 0);
g_free (value); value = NULL;
gck_attributes_unref (attrs);
}
@@ -373,24 +373,24 @@ test_find_objects (Test *test, gconstpointer unused)
gck_builder_add_string (&builder, CKA_LABEL, "UNIQUE LABEL");
objects = gck_session_find_objects (test->session, gck_builder_end (&builder), NULL, &err);
g_assert_no_error (err);
- g_assert (g_list_length (objects) == 1);
+ g_assert_cmpuint (g_list_length (objects), ==, 1);
gck_list_unref_free (objects);
/* Full, All */
objects = gck_session_find_objects (test->session, gck_builder_end (&builder), NULL, &err);
g_assert_no_error (err);
- g_assert (g_list_length (objects) > 1);
+ g_assert_cmpuint (g_list_length (objects), >, 1);
gck_list_unref_free (objects);
/* Async, None */
gck_builder_add_string (&builder, CKA_LABEL, "blah blah");
gck_session_find_objects_async (test->session, gck_builder_end (&builder), NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
objects = gck_session_find_objects_finish (test->session, result, &err);
g_object_unref (result);
- g_assert (objects == NULL);
+ g_assert_null (objects);
gck_list_unref_free (objects);
}
diff --git a/gck/test-gck-session.c b/gck/test-gck-session.c
index 003f30dc..cb7898fb 100644
--- a/gck/test-gck-session.c
+++ b/gck/test-gck-session.c
@@ -50,11 +50,11 @@ setup (Test *test, gconstpointer unused)
/* Successful load */
test->module = gck_module_initialize (_GCK_TEST_MODULE_PATH, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_MODULE (test->module));
+ g_assert_true (GCK_IS_MODULE (test->module));
g_object_add_weak_pointer (G_OBJECT (test->module), (gpointer *)&test->module);
slots = gck_module_get_slots (test->module, TRUE);
- g_assert (slots != NULL);
+ g_assert_nonnull (slots);
test->slot = GCK_SLOT (slots->data);
g_object_ref (test->slot);
@@ -63,7 +63,7 @@ setup (Test *test, gconstpointer unused)
test->session = gck_slot_open_session (test->slot, 0, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (test->session));
+ g_assert_true (GCK_IS_SESSION (test->session));
g_object_add_weak_pointer (G_OBJECT (test->session), (gpointer *)&test->session);
}
@@ -74,9 +74,9 @@ teardown (Test *test, gconstpointer unused)
g_object_unref (test->slot);
g_object_unref (test->module);
- g_assert (test->session == NULL);
- g_assert (test->slot == NULL);
- g_assert (test->module == NULL);
+ g_assert_null (test->session);
+ g_assert_null (test->slot);
+ g_assert_null (test->module);
}
static void
@@ -87,13 +87,13 @@ test_session_props (Test *test, gconstpointer unused)
gulong handle;
g_object_get (test->session, "module", &mod, "handle", &handle, "slot", &sl, NULL);
- g_assert (mod == test->module);
- g_assert (sl == test->slot);
+ g_assert_true (mod == test->module);
+ g_assert_true (sl == test->slot);
g_object_unref (mod);
g_object_unref (sl);
- g_assert (handle != 0);
- g_assert (gck_session_get_handle (test->session) == handle);
+ g_assert_cmpuint (handle, !=, 0);
+ g_assert_cmpuint (gck_session_get_handle (test->session), ==, handle);
}
static void
@@ -102,11 +102,11 @@ test_session_info (Test *test, gconstpointer unused)
GckSessionInfo *info;
info = gck_session_get_info (test->session);
- g_assert (info != NULL && "no session info");
+ g_assert_nonnull (info);
- g_assert (info->slot_id == gck_slot_get_handle (test->slot));
- g_assert ((info->flags & CKF_SERIAL_SESSION) == CKF_SERIAL_SESSION);
- g_assert (info->device_error == 1414);
+ g_assert_cmpuint (info->slot_id, ==, gck_slot_get_handle (test->slot));
+ g_assert_cmphex ((info->flags & CKF_SERIAL_SESSION), ==, CKF_SERIAL_SESSION);
+ g_assert_cmpuint (info->device_error, ==, 1414);
gck_session_info_free (info);
}
@@ -127,7 +127,7 @@ test_open_close_session (Test *test, gconstpointer unused)
sess = gck_slot_open_session (test->slot, 0, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (sess));
+ g_assert_true (GCK_IS_SESSION (sess));
g_object_unref (sess);
@@ -135,20 +135,20 @@ test_open_close_session (Test *test, gconstpointer unused)
gck_slot_open_session_async (test->slot, 0, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
/* Get the result */
g_object_add_weak_pointer (G_OBJECT (result), (gpointer *)&result);
sess = gck_slot_open_session_finish (test->slot, result, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (sess));
+ g_assert_true (GCK_IS_SESSION (sess));
g_object_add_weak_pointer (G_OBJECT (sess), (gpointer *)&sess);
g_object_unref (result);
- g_assert (result == NULL);
+ g_assert_null (result);
g_object_unref (sess);
- g_assert (sess == NULL);
+ g_assert_null (sess);
}
static void
@@ -161,7 +161,7 @@ test_session_initable (Test *test,
sess = gck_session_open (test->slot, 0, NULL, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (sess));
+ g_assert_true (GCK_IS_SESSION (sess));
g_object_unref (sess);
@@ -169,12 +169,12 @@ test_session_initable (Test *test,
gck_session_open_async (test->slot, 0, NULL, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
/* Get the result */
sess = gck_session_open_finish (result, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (sess));
+ g_assert_true (GCK_IS_SESSION (sess));
g_object_unref (result);
g_object_unref (sess);
@@ -193,12 +193,12 @@ test_session_already (Test *test,
CK_RV rv;
funcs = gck_module_get_functions (test->module);
- g_assert (funcs != NULL);
+ g_assert_nonnull (funcs);
rv = funcs->C_OpenSession (gck_slot_get_handle (test->slot), CKF_SERIAL_SESSION,
NULL, NULL, &handle);
gck_assert_cmprv (rv, ==, CKR_OK);
- g_assert (handle != 0);
+ g_assert_cmpuint (handle, !=, 0);
session = g_initable_new (GCK_TYPE_SESSION, NULL, &error,
"slot", test->slot,
@@ -206,14 +206,14 @@ test_session_already (Test *test,
NULL);
g_assert_no_error (error);
- g_assert (GCK_IS_SESSION (session));
+ g_assert_true (GCK_IS_SESSION (session));
gck_assert_cmpulong (handle, ==, gck_session_get_handle (session));
g_object_unref (session);
rv = funcs->C_OpenSession (gck_slot_get_handle (test->slot), CKF_SERIAL_SESSION,
NULL, NULL, &handle);
gck_assert_cmprv (rv, ==, CKR_OK);
- g_assert (handle != 0);
+ g_assert_cmpuint (handle, !=, 0);
/* Test opening async */
g_async_initable_new_async (GCK_TYPE_SESSION, G_PRIORITY_DEFAULT, NULL,
@@ -223,14 +223,14 @@ test_session_already (Test *test,
NULL);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
/* Get the result */
source = g_async_result_get_source_object (result);
session = GCK_SESSION (g_async_initable_new_finish (G_ASYNC_INITABLE (source), result, &error));
g_object_unref (source);
g_assert_no_error (error);
- g_assert (GCK_IS_SESSION (session));
+ g_assert_true (GCK_IS_SESSION (session));
gck_assert_cmpulong (handle, ==, gck_session_get_handle (session));
g_object_unref (result);
@@ -250,7 +250,7 @@ test_open_interaction (Test *test,
sess = gck_session_open (test->slot, GCK_SESSION_LOGIN_USER, interaction, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (sess));
+ g_assert_true (GCK_IS_SESSION (sess));
g_object_unref (sess);
@@ -258,12 +258,12 @@ test_open_interaction (Test *test,
gck_session_open_async (test->slot, GCK_SESSION_LOGIN_USER, interaction, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
/* Get the result */
sess = gck_session_open_finish (result, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (sess));
+ g_assert_true (GCK_IS_SESSION (sess));
g_object_unref (interaction);
g_object_unref (result);
@@ -281,30 +281,30 @@ test_init_set_pin (Test *test, gconstpointer unused)
/* init pin */
ret = gck_session_init_pin (test->session, (guchar*)"booo", 4, NULL, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
/* set pin */
ret = gck_session_set_pin (test->session, (guchar*)"booo", 4, (guchar*)"tooo", 4, NULL, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
/* init pin async */
gck_session_init_pin_async (test->session, (guchar*)"booo", 4, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_init_pin_finish (test->session, result, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (result);
result = NULL;
/* set pin async */
gck_session_set_pin_async (test->session, (guchar*)"booo", 4, (guchar*)"tooo", 4, NULL,
fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_set_pin_finish (test->session, result, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (result);
result = NULL;
}
@@ -320,14 +320,14 @@ test_login_logout (Test *test, gconstpointer unused)
/* login/logout */
ret = gck_session_login (test->session, CKU_USER, (guchar*)"booo", 4, NULL, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
state = gck_session_get_state (test->session);
gck_assert_cmpulong (state, ==, CKS_RO_USER_FUNCTIONS);
ret = gck_session_logout (test->session, NULL, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
state = gck_session_get_state (test->session);
gck_assert_cmpulong (state, ==, CKS_RO_PUBLIC_SESSION);
@@ -335,11 +335,11 @@ test_login_logout (Test *test, gconstpointer unused)
/* login async */
gck_session_login_async (test->session, CKU_USER, (guchar*)"booo", 4, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_login_finish (test->session, result, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (result);
result = NULL;
@@ -350,11 +350,11 @@ test_login_logout (Test *test, gconstpointer unused)
/* logout async */
gck_session_logout_async (test->session, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_logout_finish (test->session, result, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
state = gck_session_get_state (test->session);
gck_assert_cmpulong (state, ==, CKS_RO_PUBLIC_SESSION);
@@ -378,14 +378,14 @@ test_login_interactive (Test *test,
/* login/logout */
ret = gck_session_login_interactive (test->session, CKU_USER, interaction, NULL, &error);
g_assert_no_error (error);
- g_assert (ret);
+ g_assert_true (ret);
state = gck_session_get_state (test->session);
gck_assert_cmpulong (state, ==, CKS_RO_USER_FUNCTIONS);
ret = gck_session_logout (test->session, NULL, &error);
g_assert_no_error (error);
- g_assert (ret);
+ g_assert_true (ret);
state = gck_session_get_state (test->session);
gck_assert_cmpulong (state, ==, CKS_RO_PUBLIC_SESSION);
@@ -393,11 +393,11 @@ test_login_interactive (Test *test,
/* login async */
gck_session_login_interactive_async (test->session, CKU_USER, interaction, NULL, fetch_async_result,
&result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
ret = gck_session_login_interactive_finish (test->session, result, &error);
g_assert_no_error (error);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (result);
result = NULL;
@@ -407,7 +407,7 @@ test_login_interactive (Test *test,
ret = gck_session_logout (test->session, NULL, &error);
g_assert_no_error (error);
- g_assert (ret);
+ g_assert_true (ret);
state = gck_session_get_state (test->session);
gck_assert_cmpulong (state, ==, CKS_RO_PUBLIC_SESSION);
@@ -418,11 +418,11 @@ test_login_interactive (Test *test,
static gboolean
authenticate_token (GckModule *module, GckSlot *slot, gchar *label, gchar **password, gpointer unused)
{
- g_assert (unused == GUINT_TO_POINTER (35));
- g_assert (password != NULL);
- g_assert (*password == NULL);
- g_assert (GCK_IS_MODULE (module));
- g_assert (GCK_IS_SLOT (slot));
+ g_assert_true (unused == GUINT_TO_POINTER (35));
+ g_assert_nonnull (password);
+ g_assert_null (*password);
+ g_assert_true (GCK_IS_MODULE (module));
+ g_assert_true (GCK_IS_SLOT (slot));
*password = g_strdup ("booo");
return TRUE;
@@ -446,52 +446,52 @@ test_auto_login (Test *test, gconstpointer unused)
/* Try to do something that requires a login */
object = gck_session_create_object (test->session, attrs, NULL, &err);
- g_assert (!object);
- g_assert (err && err->code == CKR_USER_NOT_LOGGED_IN);
+ g_assert_null (object);
+ g_assert_true (err && err->code == CKR_USER_NOT_LOGGED_IN);
g_clear_error (&err);
/* Setup for auto login */
g_signal_connect (test->module, "authenticate-slot", G_CALLBACK (authenticate_token),
GUINT_TO_POINTER (35));
new_session = gck_slot_open_session (test->slot, GCK_SESSION_READ_WRITE | GCK_SESSION_LOGIN_USER,
NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (new_session));
+ g_assert_true (GCK_IS_SESSION (new_session));
/* Try again to do something that requires a login */
object = gck_session_create_object (new_session, attrs, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_OBJECT (object));
+ g_assert_true (GCK_IS_OBJECT (object));
g_object_unref (object);
/* We should now be logged in, try to log out */
ret = gck_session_logout (new_session, NULL, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
g_object_unref (new_session);
/* Now try the same thing, but asyncronously */
gck_slot_open_session_async (test->slot, GCK_SESSION_READ_WRITE | GCK_SESSION_LOGIN_USER, NULL,
fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
new_session = gck_slot_open_session_finish (test->slot, result, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_SESSION (new_session));
+ g_assert_true (GCK_IS_SESSION (new_session));
g_object_unref (result);
result = NULL;
gck_session_create_object_async (new_session, attrs, NULL, fetch_async_result, &result);
egg_test_wait_until (500);
- g_assert (result != NULL);
+ g_assert_nonnull (result);
object = gck_session_create_object_finish (new_session, result, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_OBJECT (object));
+ g_assert_true (GCK_IS_OBJECT (object));
g_object_unref (result);
g_object_unref (object);
/* We should now be logged in, try to log out */
ret = gck_session_logout (new_session, NULL, &err);
g_assert_no_error (err);
- g_assert (ret);
+ g_assert_true (ret);
gck_attributes_unref (attrs);
g_object_unref (new_session);
diff --git a/gck/test-gck-slot.c b/gck/test-gck-slot.c
index e7b1745f..c3142334 100644
--- a/gck/test-gck-slot.c
+++ b/gck/test-gck-slot.c
@@ -44,7 +44,7 @@ setup (Test *test, gconstpointer unused)
/* Successful load */
test->module = gck_module_initialize (_GCK_TEST_MODULE_PATH, NULL, &err);
g_assert_no_error (err);
- g_assert (GCK_IS_MODULE (test->module));
+ g_assert_true (GCK_IS_MODULE (test->module));
slots = gck_module_get_slots (test->module, TRUE);
g_assert_nonnull (slots);
diff --git a/gck/test-gck-uri.c b/gck/test-gck-uri.c
index 17ccc664..bbfddda6 100644
--- a/gck/test-gck-uri.c
+++ b/gck/test-gck-uri.c
@@ -38,15 +38,15 @@ test_parse (void)
GckUriData *uri_data;
uri_data = gck_uri_parse ("pkcs11:", GCK_URI_FOR_MODULE, &error);
- g_assert (uri_data != NULL);
+ g_assert_nonnull (uri_data);
g_assert_no_error (error);
- g_assert (uri_data->attributes == NULL);
- g_assert (uri_data->token_info == NULL);
+ g_assert_null (uri_data->attributes);
+ g_assert_null (uri_data->token_info);
- g_assert (uri_data->module_info != NULL);
- g_assert (uri_data->module_info->library_description == NULL);
- g_assert (uri_data->module_info->manufacturer_id == NULL);
+ g_assert_nonnull (uri_data->module_info);
+ g_assert_null (uri_data->module_info->library_description);
+ g_assert_null (uri_data->module_info->manufacturer_id);
gck_uri_data_free (uri_data);
}
@@ -58,7 +58,7 @@ test_parse_bad_scheme (void)
GckUriData *uri_data;
uri_data = gck_uri_parse ("http:\\example.com\test", GCK_URI_FOR_ANY, &error);
- g_assert (uri_data == NULL);
+ g_assert_null (uri_data);
g_assert_error (error, GCK_URI_ERROR, GCK_URI_BAD_PREFIX);
g_error_free (error);
}
@@ -71,8 +71,8 @@ test_parse_with_label (void)
gchar *value;
uri_data = gck_uri_parse ("pkcs11:object=Test%20Label", GCK_URI_FOR_ANY, &error);
- g_assert (uri_data != NULL);
- g_assert (uri_data->attributes != NULL);
+ g_assert_nonnull (uri_data);
+ g_assert_nonnull (uri_data->attributes);
if (!gck_attributes_find_string (uri_data->attributes, CKA_LABEL, &value))
g_assert_not_reached ();
@@ -92,8 +92,8 @@ test_parse_with_label_and_klass (void)
gulong klass;
uri_data = gck_uri_parse ("pkcs11:object=Test%20Label;objecttype=cert", GCK_URI_FOR_ANY, &error);
- g_assert (uri_data);
- g_assert (uri_data->attributes);
+ g_assert_nonnull (uri_data);
+ g_assert_nonnull (uri_data->attributes);
if (!gck_attributes_find_string (uri_data->attributes, CKA_LABEL, &value))
g_assert_not_reached ();
@@ -102,7 +102,7 @@ test_parse_with_label_and_klass (void)
g_assert_not_reached ();
g_assert_cmpstr (value, ==, "Test Label");
- g_assert (klass == CKO_CERTIFICATE);
+ g_assert_cmphex (klass, ==, CKO_CERTIFICATE);
g_free (value);
gck_uri_data_free (uri_data);
@@ -116,14 +116,13 @@ test_parse_with_id (void)
GckUriData *uri_data;
uri_data = gck_uri_parse ("pkcs11:id=%54%45%53%54%00", GCK_URI_FOR_OBJECT, &error);
- g_assert (uri_data != NULL);
- g_assert (uri_data->attributes != NULL);
+ g_assert_nonnull (uri_data);
+ g_assert_nonnull (uri_data->attributes);
attr = gck_attributes_find (uri_data->attributes, CKA_ID);
- g_assert (attr);
- g_assert (attr->value);
- g_assert (attr->length == 5);
- g_assert (memcmp (attr->value, "TEST", 5) == 0);
+ g_assert_nonnull (attr);
+ g_assert_nonnull (attr->value);
+ g_assert_cmpmem (attr->value, attr->length, "TEST", 5);
gck_uri_data_free (uri_data);
}
@@ -135,7 +134,7 @@ test_parse_with_bad_string_encoding (void)
GckUriData *uri_data;
uri_data = gck_uri_parse ("pkcs11:object=Test%", GCK_URI_FOR_OBJECT, &error);
- g_assert (uri_data == NULL);
+ g_assert_null (uri_data);
g_assert_error (error, GCK_URI_ERROR, GCK_URI_BAD_ENCODING);
g_error_free (error);
}
@@ -146,7 +145,7 @@ test_parse_with_bad_binary_encoding (void)
GError *error = NULL;
GckUriData *uri_data;
uri_data = gck_uri_parse ("pkcs11:id=%%", GCK_URI_FOR_ANY, &error);
- g_assert (!uri_data);
+ g_assert_null (uri_data);
g_assert_error (error, GCK_URI_ERROR, GCK_URI_BAD_ENCODING);
g_error_free (error);
}
@@ -160,8 +159,8 @@ test_parse_with_token (void)
uri_data = gck_uri_parse ("pkcs11:token=Token%20Label;serial=3333;model=Deluxe;manufacturer=Me",
GCK_URI_FOR_TOKEN, &error);
- g_assert (uri_data);
- g_assert (uri_data->token_info);
+ g_assert_nonnull (uri_data);
+ g_assert_nonnull (uri_data->token_info);
g_assert_cmpstr (uri_data->token_info->label, ==, "Token Label");
g_assert_cmpstr (uri_data->token_info->serial_number, ==, "3333");
g_assert_cmpstr (uri_data->token_info->model, ==, "Deluxe");
@@ -176,7 +175,7 @@ test_parse_with_token_bad_encoding (void)
GckUriData *uri_data;
uri_data = gck_uri_parse ("pkcs11:token=Token%", GCK_URI_FOR_TOKEN, &error);
- g_assert (!uri_data);
+ g_assert_null (uri_data);
g_assert_error (error, GCK_URI_ERROR, GCK_URI_BAD_ENCODING);
g_error_free (error);
}
@@ -188,8 +187,8 @@ test_parse_with_bad_syntax (void)
GckUriData *uri_data;
uri_data = gck_uri_parse ("pkcs11:token", GCK_URI_FOR_ANY, &error);
- g_assert (uri_data == NULL);
- g_assert (g_error_matches (error, GCK_URI_ERROR, GCK_URI_BAD_SYNTAX));
+ g_assert_null (uri_data);
+ g_assert_error (error, GCK_URI_ERROR, GCK_URI_BAD_SYNTAX);
g_error_free (error);
}
@@ -202,8 +201,8 @@ test_parse_with_library (void)
uri_data = gck_uri_parse ("pkcs11:library-description=The%20Library;library-manufacturer=Me",
GCK_URI_FOR_MODULE, &error);
- g_assert (uri_data);
- g_assert (uri_data->module_info);
+ g_assert_nonnull (uri_data);
+ g_assert_nonnull (uri_data->module_info);
g_assert_cmpstr (uri_data->module_info->manufacturer_id, ==, "Me");
g_assert_cmpstr (uri_data->module_info->library_description, ==, "The Library");
gck_uri_data_free (uri_data);
@@ -216,7 +215,7 @@ test_parse_with_library_bad_encoding (void)
GckUriData *uri_data;
uri_data = gck_uri_parse ("pkcs11:library-description=Library%", GCK_URI_FOR_MODULE, &error);
- g_assert (!uri_data);
+ g_assert_null (uri_data);
g_assert_error (error, GCK_URI_ERROR, GCK_URI_BAD_ENCODING);
g_error_free (error);
}
@@ -248,22 +247,22 @@ test_build_with_token_info (void)
uri_data.token_info->model = g_strdup ("Deluxe");
uri = gck_uri_build (&uri_data, GCK_URI_FOR_TOKEN);
- g_assert (uri);
+ g_assert_nonnull (uri);
check = gck_uri_parse (uri, GCK_URI_FOR_TOKEN, NULL);
- g_assert (check);
- g_assert (check->token_info);
+ g_assert_nonnull (check);
+ g_assert_nonnull (check->token_info);
- g_assert (_gck_token_info_match (uri_data.token_info, check->token_info));
+ g_assert_true (_gck_token_info_match (uri_data.token_info, check->token_info));
gck_token_info_free (uri_data.token_info);
gck_uri_data_free (check);
- g_assert (g_str_has_prefix (uri, "pkcs11:"));
- g_assert (strstr (uri, "token=The%20Label"));
- g_assert (strstr (uri, "serial=44444"));
- g_assert (strstr (uri, "manufacturer=Me"));
- g_assert (strstr (uri, "model=Deluxe"));
+ g_assert_true (g_str_has_prefix (uri, "pkcs11:"));
+ g_assert_true (strstr (uri, "token=The%20Label"));
+ g_assert_true (strstr (uri, "serial=44444"));
+ g_assert_true (strstr (uri, "manufacturer=Me"));
+ g_assert_true (strstr (uri, "model=Deluxe"));
g_free (uri);
}
@@ -279,11 +278,11 @@ test_build_with_token_null_info (void)
uri_data.token_info->label = g_strdup ("The Label");
uri = gck_uri_build (&uri_data, GCK_URI_FOR_TOKEN);
- g_assert (uri);
+ g_assert_nonnull (uri);
- g_assert (g_str_has_prefix (uri, "pkcs11:"));
- g_assert (strstr (uri, "token=The%20Label"));
- g_assert (!strstr (uri, "serial="));
+ g_assert_true (g_str_has_prefix (uri, "pkcs11:"));
+ g_assert_true (strstr (uri, "token=The%20Label"));
+ g_assert_true (!strstr (uri, "serial="));
gck_token_info_free (uri_data.token_info);
g_free (uri);
@@ -301,11 +300,11 @@ test_build_with_token_empty_info (void)
uri_data.token_info->serial_number = g_strdup ("");
uri = gck_uri_build (&uri_data, GCK_URI_FOR_TOKEN);
- g_assert (uri);
+ g_assert_nonnull (uri);
- g_assert (g_str_has_prefix (uri, "pkcs11:"));
- g_assert (strstr (uri, "token=The%20Label"));
- g_assert (strstr (uri, "serial="));
+ g_assert_true (g_str_has_prefix (uri, "pkcs11:"));
+ g_assert_true (strstr (uri, "token=The%20Label"));
+ g_assert_true (strstr (uri, "serial="));
gck_token_info_free (uri_data.token_info);
g_free (uri);
@@ -329,13 +328,13 @@ test_build_with_attributes (void)
uri_data.attributes = gck_attributes_ref_sink (gck_builder_end (&builder));
uri = gck_uri_build (&uri_data, GCK_URI_FOR_OBJECT);
- g_assert (uri);
+ g_assert_nonnull (uri);
gck_attributes_unref (uri_data.attributes);
check = gck_uri_parse (uri, GCK_URI_FOR_ANY, NULL);
- g_assert (check);
- g_assert (check->attributes);
+ g_assert_nonnull (check);
+ g_assert_nonnull (check->attributes);
if (!gck_attributes_find_string (check->attributes, CKA_LABEL, &string))
g_assert_not_reached ();
@@ -344,19 +343,18 @@ test_build_with_attributes (void)
if (!gck_attributes_find_ulong (check->attributes, CKA_CLASS, &value))
g_assert_not_reached ();
- g_assert (value == CKO_DATA);
+ g_assert_cmphex (value, ==, CKO_DATA);
attr = gck_attributes_find (check->attributes, CKA_ID);
- g_assert (attr);
- g_assert (attr->length == 5);
- g_assert (memcmp (attr->value, "TEST", 5) == 0);
+ g_assert_nonnull (attr);
+ g_assert_cmpmem (attr->value, attr->length, "TEST", 5);
gck_uri_data_free (check);
- g_assert (g_str_has_prefix (uri, "pkcs11:"));
- g_assert (strstr (uri, "object=The%20Label"));
- g_assert (strstr (uri, "object-type=data") || strstr (uri, "type=data"));
- g_assert (strstr (uri, "id=%54%45%53%54%00") || strstr (uri, "id=TEST%00"));
+ g_assert_true (g_str_has_prefix (uri, "pkcs11:"));
+ g_assert_true (strstr (uri, "object=The%20Label"));
+ g_assert_true (strstr (uri, "object-type=data") || strstr (uri, "type=data"));
+ g_assert_true (strstr (uri, "id=%54%45%53%54%00") || strstr (uri, "id=TEST%00"));
g_free (uri);
}
@@ -369,10 +367,10 @@ test_parse_private_key (void)
gulong klass;
uri_data = gck_uri_parse ("pkcs11:objecttype=private", GCK_URI_FOR_OBJECT, &error);
- g_assert (uri_data);
+ g_assert_nonnull (uri_data);
g_assert_no_error (error);
- g_assert (uri_data->attributes);
+ g_assert_nonnull (uri_data->attributes);
if (!gck_attributes_find_ulong (uri_data->attributes, CKA_CLASS, &klass))
g_assert_not_reached ();
gck_assert_cmpulong (klass, ==, CKO_PRIVATE_KEY);
@@ -388,10 +386,10 @@ test_parse_secret_key (void)
gulong klass;
uri_data = gck_uri_parse ("pkcs11:objecttype=secretkey", GCK_URI_FOR_OBJECT, &error);
- g_assert (uri_data);
+ g_assert_nonnull (uri_data);
g_assert_no_error (error);
- g_assert (uri_data->attributes);
+ g_assert_nonnull (uri_data->attributes);
if (!gck_attributes_find_ulong (uri_data->attributes, CKA_CLASS, &klass))
g_assert_not_reached ();
gck_assert_cmpulong (klass, ==, CKO_SECRET_KEY);
@@ -408,11 +406,11 @@ test_parse_unknown_objecttype (void)
gulong klass;
uri_data = gck_uri_parse ("pkcs11:objecttype=unknown", GCK_URI_FOR_OBJECT, &error);
- g_assert (uri_data);
+ g_assert_nonnull (uri_data);
g_assert_no_error (error);
- g_assert (uri_data->attributes);
- g_assert (uri_data->any_unrecognized == TRUE);
+ g_assert_nonnull (uri_data->attributes);
+ g_assert_true (uri_data->any_unrecognized);
if (gck_attributes_find_ulong (uri_data->attributes, CKA_CLASS, &klass))
g_assert_not_reached ();
@@ -431,8 +429,8 @@ test_build_objecttype_cert (void)
uri_data->attributes = gck_attributes_ref_sink (gck_builder_end (&builder));
uri = gck_uri_build (uri_data, GCK_URI_FOR_OBJECT);
- g_assert (uri);
- g_assert (strstr (uri, "object-type=cert") || strstr (uri, "type=cert"));
+ g_assert_nonnull (uri);
+ g_assert_true (strstr (uri, "object-type=cert") || strstr (uri, "type=cert"));
gck_uri_data_free (uri_data);
g_free (uri);
@@ -450,8 +448,8 @@ test_build_objecttype_private (void)
uri_data->attributes = gck_attributes_ref_sink (gck_builder_end (&builder));
uri = gck_uri_build (uri_data, GCK_URI_FOR_OBJECT);
- g_assert (uri);
- g_assert (strstr (uri, "object-type=private") || strstr (uri, "type=private"));
+ g_assert_nonnull (uri);
+ g_assert_true (strstr (uri, "object-type=private") || strstr (uri, "type=private"));
gck_uri_data_free (uri_data);
g_free (uri);
@@ -469,8 +467,9 @@ test_build_objecttype_public (void)
uri_data->attributes = gck_attributes_ref_sink (gck_builder_end (&builder));
uri = gck_uri_build (uri_data, GCK_URI_FOR_OBJECT);
- g_assert (uri);
- g_assert (strstr (uri, "object-type=public") || strstr (uri, "type=public"));
+ g_assert_nonnull (uri);
+ g_assert_true (strstr (uri, "object-type=public") ||
+ strstr (uri, "type=public"));
gck_uri_data_free (uri_data);
g_free (uri);
@@ -488,8 +487,9 @@ test_build_objecttype_secret (void)
uri_data->attributes = gck_attributes_ref_sink (gck_builder_end (&builder));
uri = gck_uri_build (uri_data, GCK_URI_FOR_OBJECT);
- g_assert (uri);
- g_assert (strstr (uri, "object-type=secret-key") || strstr (uri, "type=secret-key"));
+ g_assert_nonnull (uri);
+ g_assert_true (strstr (uri, "object-type=secret-key") ||
+ strstr (uri, "type=secret-key"));
gck_uri_data_free (uri_data);
g_free (uri);
@@ -506,8 +506,8 @@ test_build_with_library (void)
uri_data->module_info->library_description = g_strdup ("The Description");
uri = gck_uri_build (uri_data, GCK_URI_FOR_MODULE);
- g_assert (uri);
- g_assert (strstr (uri, "library-description=The%20Description"));
+ g_assert_nonnull (uri);
+ g_assert_true (strstr (uri, "library-description=The%20Description"));
gck_uri_data_free (uri_data);
g_free (uri);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
