gck: Don't use g_assert() in testswip/nielsdg/gck-no-more-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.

9 files changed, 578 insertions, 601 deletions

diff --git a/gck/test-gck-attributes.c b/gck/test-gck-attributes.c
index 2e9d7ce..da11bf4 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 (&copy, &attr);
 	gck_attribute_clear (&attr);
-	g_assert (gck_attribute_get_ulong (&copy) == 88);
-	g_assert (copy.type == ATTR_TYPE);
+	g_assert_cmpuint (gck_attribute_get_ulong (&copy), ==, 88);
+	g_assert_cmpuint (copy.type, ==, ATTR_TYPE);
 	gck_attribute_clear (&copy);
 }
 
@@ -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 8efff23..00a6ad3 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 73a1386..afb7e90 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 320701b..1e9d658 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 19cdaca..1468b9b 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 61a5286..4741898 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 003f30d..cb7898f 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 e7b1745..c314233 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 17ccc66..bbfddda 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);