test: Replace some _dbus_assert() with _dbus_test_check()

Assertions can be disabled, but in test code the assertions are the
whole point, so use checks that can't be disabled instead.

Because there's a lot of test code, I haven't done this globally, only
in the tests that I recently converted from "embedded" to "modular".

Signed-off-by: Simon McVittie <smcv@collabora.com>

diff --git a/test/internals/hash.c b/test/internals/hash.c
index 314c65f0991c5640dd8ce2949e437af94b9a8c17..192d82e33bb7225897e73d435a8a84d2307c9ba6 100644 (file)
--- a/test/internals/hash.c
+++ b/test/internals/hash.c
@@ -94,7 +94,7 @@ count_entries (DBusHashTable *table)
   while (_dbus_hash_iter_next (&iter))
     ++count;
 
-  _dbus_assert (count == _dbus_hash_table_get_n_entries (table));
+  _dbus_test_check (count == _dbus_hash_table_get_n_entries (table));
 
   return count;
 }
@@ -150,7 +150,7 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       int len;
 
       len = sprintf (keys[i], "Hash key %d", i);
-      _dbus_assert (*(keys[i] + len) == '\0');
+      _dbus_test_check (*(keys[i] + len) == '\0');
       ++i;
     }
   _dbus_test_diag ("... done.");
@@ -206,21 +206,21 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
                                             i, steal (&str_value)))
         goto out;
 
-      _dbus_assert (count_entries (table1) == i + 1);
-      _dbus_assert (count_entries (table2) == i + 1);
-      _dbus_assert (count_entries (table3) == i + 1);
+      _dbus_test_check (count_entries (table1) == i + 1);
+      _dbus_test_check (count_entries (table2) == i + 1);
+      _dbus_test_check (count_entries (table3) == i + 1);
 
       out_value = _dbus_hash_table_lookup_string (table1, keys[i]);
-      _dbus_assert (out_value != NULL);
-      _dbus_assert (strcmp (out_value, "Value!") == 0);
+      _dbus_test_check (out_value != NULL);
+      _dbus_test_check (strcmp (out_value, "Value!") == 0);
 
       out_value = _dbus_hash_table_lookup_int (table2, i);
-      _dbus_assert (out_value != NULL);
-      _dbus_assert (strcmp (out_value, keys[i]) == 0);
+      _dbus_test_check (out_value != NULL);
+      _dbus_test_check (strcmp (out_value, keys[i]) == 0);
 
       out_value = _dbus_hash_table_lookup_uintptr (table3, i);
-      _dbus_assert (out_value != NULL);
-      _dbus_assert (strcmp (out_value, keys[i]) == 0);
+      _dbus_test_check (out_value != NULL);
+      _dbus_test_check (strcmp (out_value, keys[i]) == 0);
 
       ++i;
     }
@@ -235,9 +235,9 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
 
       _dbus_hash_table_remove_uintptr (table3, i);
 
-      _dbus_assert (count_entries (table1) == i);
-      _dbus_assert (count_entries (table2) == i);
-      _dbus_assert (count_entries (table3) == i);
+      _dbus_test_check (count_entries (table1) == i);
+      _dbus_test_check (count_entries (table2) == i);
+      _dbus_test_check (count_entries (table3) == i);
 
       --i;
     }
@@ -290,8 +290,8 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
                                         i, steal (&str_value)))
         goto out;
 
-      _dbus_assert (count_entries (table1) == i + 1);
-      _dbus_assert (count_entries (table2) == i + 1);
+      _dbus_test_check (count_entries (table1) == i + 1);
+      _dbus_test_check (count_entries (table2) == i + 1);
 
       ++i;
     }
@@ -305,7 +305,7 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       key = _dbus_hash_iter_get_string_key (&iter);
       value = _dbus_hash_iter_get_value (&iter);
 
-      _dbus_assert (_dbus_hash_table_lookup_string (table1, key) == value);
+      _dbus_test_check (_dbus_hash_table_lookup_string (table1, key) == value);
 
       str_value = _dbus_strdup ("Different value!");
       if (str_value == NULL)
@@ -313,14 +313,14 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
 
       value = str_value;
       _dbus_hash_iter_set_value (&iter, steal (&str_value));
-      _dbus_assert (_dbus_hash_table_lookup_string (table1, key) == value);
+      _dbus_test_check (_dbus_hash_table_lookup_string (table1, key) == value);
     }
 
   _dbus_hash_iter_init (table1, &iter);
   while (_dbus_hash_iter_next (&iter))
     {
       _dbus_hash_iter_remove_entry (&iter);
-      _dbus_assert (count_entries (table1) == i - 1);
+      _dbus_test_check (count_entries (table1) == i - 1);
       --i;
     }
 
@@ -333,7 +333,7 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       key = _dbus_hash_iter_get_int_key (&iter);
       value = _dbus_hash_iter_get_value (&iter);
 
-      _dbus_assert (_dbus_hash_table_lookup_int (table2, key) == value);
+      _dbus_test_check (_dbus_hash_table_lookup_int (table2, key) == value);
 
       str_value = _dbus_strdup ("Different value!");
       if (str_value == NULL)
@@ -341,7 +341,7 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
 
       value = str_value;
       _dbus_hash_iter_set_value (&iter, steal (&str_value));
-      _dbus_assert (_dbus_hash_table_lookup_int (table2, key) == value);
+      _dbus_test_check (_dbus_hash_table_lookup_int (table2, key) == value);
     }
 
   i = count_entries (table2);
@@ -349,7 +349,7 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
   while (_dbus_hash_iter_next (&iter))
     {
       _dbus_hash_iter_remove_entry (&iter);
-      _dbus_assert (count_entries (table2) + 1 == i);
+      _dbus_test_check (count_entries (table2) + 1 == i);
       --i;
     }
 
@@ -396,7 +396,7 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       if (!_dbus_hash_table_remove_string (table1, keys[i]))
         goto out;
 
-      _dbus_assert (_dbus_hash_table_get_n_entries (table1) == i);
+      _dbus_test_check (_dbus_hash_table_get_n_entries (table1) == i);
 
       --i;
     }
@@ -434,7 +434,7 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       if (!_dbus_hash_iter_lookup (table1,
                                    steal (&str_key), TRUE, &iter))
         goto out;
-      _dbus_assert (_dbus_hash_iter_get_value (&iter) == NULL);
+      _dbus_test_check (_dbus_hash_iter_get_value (&iter) == NULL);
       _dbus_hash_iter_set_value (&iter, steal (&str_value));
 
       str_value = _dbus_strdup (keys[i]);
@@ -444,18 +444,18 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       if (!_dbus_hash_iter_lookup (table2,
                                    _DBUS_INT_TO_POINTER (i), TRUE, &iter))
         goto out;
-      _dbus_assert (_dbus_hash_iter_get_value (&iter) == NULL);
+      _dbus_test_check (_dbus_hash_iter_get_value (&iter) == NULL);
       _dbus_hash_iter_set_value (&iter, steal (&str_value));
 
-      _dbus_assert (count_entries (table1) == i + 1);
-      _dbus_assert (count_entries (table2) == i + 1);
+      _dbus_test_check (count_entries (table1) == i + 1);
+      _dbus_test_check (count_entries (table2) == i + 1);
 
       if (!_dbus_hash_iter_lookup (table1, keys[i], FALSE, &iter))
         goto out;
 
       out_value = _dbus_hash_iter_get_value (&iter);
-      _dbus_assert (out_value != NULL);
-      _dbus_assert (strcmp (out_value, "Value!") == 0);
+      _dbus_test_check (out_value != NULL);
+      _dbus_test_check (strcmp (out_value, "Value!") == 0);
 
       /* Iterate just to be sure it works, though
        * it's a stupid thing to do
@@ -467,8 +467,8 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
         goto out;
 
       out_value = _dbus_hash_iter_get_value (&iter);
-      _dbus_assert (out_value != NULL);
-      _dbus_assert (strcmp (out_value, keys[i]) == 0);
+      _dbus_test_check (out_value != NULL);
+      _dbus_test_check (strcmp (out_value, keys[i]) == 0);
 
       /* Iterate just to be sure it works, though
        * it's a stupid thing to do
@@ -490,8 +490,8 @@ _dbus_hash_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
         _dbus_test_fatal ("hash entry should have existed");
       _dbus_hash_iter_remove_entry (&iter);
 
-      _dbus_assert (count_entries (table1) == i);
-      _dbus_assert (count_entries (table2) == i);
+      _dbus_test_check (count_entries (table1) == i);
+      _dbus_test_check (count_entries (table2) == i);
 
       --i;
     }

diff --git a/test/internals/misc-internals.c b/test/internals/misc-internals.c
index ddd4a306c5d988caaeaa68fd36f2e390880e2cab..a1777bb2aee9aaf4d4e443c81549108af0352b12 100644 (file)
--- a/test/internals/misc-internals.c
+++ b/test/internals/misc-internals.c
@@ -52,8 +52,8 @@ verify_list (DBusList **list)
 
   if (link->next == link)
     {
-      _dbus_assert (link->prev == link);
-      _dbus_assert (*list == link);
+      _dbus_test_check (link->prev == link);
+      _dbus_test_check (*list == link);
       return;
     }
 
@@ -61,18 +61,18 @@ verify_list (DBusList **list)
   do
     {
       length += 1;
-      _dbus_assert (link->prev->next == link);
-      _dbus_assert (link->next->prev == link);
+      _dbus_test_check (link->prev->next == link);
+      _dbus_test_check (link->next->prev == link);
       link = link->next;
     }
   while (link != *list);
 
-  _dbus_assert (length == _dbus_list_get_length (list));
+  _dbus_test_check (length == _dbus_list_get_length (list));
 
   if (length == 1)
-    _dbus_assert (_dbus_list_length_is_one (list));
+    _dbus_test_check (_dbus_list_length_is_one (list));
   else
-    _dbus_assert (!_dbus_list_length_is_one (list));
+    _dbus_test_check (!_dbus_list_length_is_one (list));
 }
 
 static dbus_bool_t
@@ -219,12 +219,12 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       verify_list (&list1);
       verify_list (&list2);
 
-      _dbus_assert (_dbus_list_get_length (&list1) == i);
-      _dbus_assert (_dbus_list_get_length (&list2) == i);
+      _dbus_test_check (_dbus_list_get_length (&list1) == i);
+      _dbus_test_check (_dbus_list_get_length (&list2) == i);
     }
 
-  _dbus_assert (is_ascending_sequence (&list1));
-  _dbus_assert (is_descending_sequence (&list2));
+  _dbus_test_check (is_ascending_sequence (&list1));
+  _dbus_test_check (is_descending_sequence (&list2));
 
   /* Test list clear */
   _dbus_list_clear (&list1);
@@ -260,23 +260,23 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       data1 = _dbus_list_pop_last (&list1);
       data2 = _dbus_list_pop_first (&list2);
 
-      _dbus_assert (got_data1 == data1);
-      _dbus_assert (got_data2 == data2);
+      _dbus_test_check (got_data1 == data1);
+      _dbus_test_check (got_data2 == data2);
 
-      _dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
-      _dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (data1) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (data2) == i);
 
       verify_list (&list1);
       verify_list (&list2);
 
-      _dbus_assert (is_ascending_sequence (&list1));
-      _dbus_assert (is_descending_sequence (&list2));
+      _dbus_test_check (is_ascending_sequence (&list1));
+      _dbus_test_check (is_descending_sequence (&list2));
 
       --i;
     }
 
-  _dbus_assert (list1 == NULL);
-  _dbus_assert (list2 == NULL);
+  _dbus_test_check (list1 == NULL);
+  _dbus_test_check (list2 == NULL);
 
   /* Test get_first_link, get_last_link, pop_first_link, pop_last_link */
 
@@ -305,30 +305,30 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
 
       link2 = _dbus_list_pop_first_link (&list2);
 
-      _dbus_assert (got_link2 == link2);
+      _dbus_test_check (got_link2 == link2);
 
       data1_indirect = got_link1->data;
       /* this call makes got_link1 invalid */
       data1 = _dbus_list_pop_last (&list1);
-      _dbus_assert (data1 == data1_indirect);
+      _dbus_test_check (data1 == data1_indirect);
       data2 = link2->data;
 
       _dbus_list_free_link (link2);
 
-      _dbus_assert (_DBUS_POINTER_TO_INT (data1) == i);
-      _dbus_assert (_DBUS_POINTER_TO_INT (data2) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (data1) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (data2) == i);
 
       verify_list (&list1);
       verify_list (&list2);
 
-      _dbus_assert (is_ascending_sequence (&list1));
-      _dbus_assert (is_descending_sequence (&list2));
+      _dbus_test_check (is_ascending_sequence (&list1));
+      _dbus_test_check (is_descending_sequence (&list2));
 
       --i;
     }
 
-  _dbus_assert (list1 == NULL);
-  _dbus_assert (list2 == NULL);
+  _dbus_test_check (list1 == NULL);
+  _dbus_test_check (list2 == NULL);
 
   /* Test iteration */
 
@@ -344,12 +344,12 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       verify_list (&list1);
       verify_list (&list2);
 
-      _dbus_assert (_dbus_list_get_length (&list1) == i);
-      _dbus_assert (_dbus_list_get_length (&list2) == i);
+      _dbus_test_check (_dbus_list_get_length (&list1) == i);
+      _dbus_test_check (_dbus_list_get_length (&list2) == i);
     }
 
-  _dbus_assert (is_ascending_sequence (&list1));
-  _dbus_assert (is_descending_sequence (&list2));
+  _dbus_test_check (is_ascending_sequence (&list1));
+  _dbus_test_check (is_descending_sequence (&list2));
 
   --i;
   link2 = _dbus_list_get_first_link (&list2);
@@ -357,7 +357,7 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
     {
       verify_list (&link2); /* pretend this link is the head */
 
-      _dbus_assert (_DBUS_POINTER_TO_INT (link2->data) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (link2->data) == i);
 
       link2 = _dbus_list_get_next_link (&list2, link2);
       --i;
@@ -369,7 +369,7 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
     {
       verify_list (&link1); /* pretend this link is the head */
 
-      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (link1->data) == i);
 
       link1 = _dbus_list_get_next_link (&list1, link1);
       ++i;
@@ -381,7 +381,7 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
     {
       verify_list (&link1); /* pretend this link is the head */
 
-      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (link1->data) == i);
 
       link1 = _dbus_list_get_prev_link (&list1, link1);
       --i;
@@ -418,8 +418,8 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       --i;
     }
 
-  _dbus_assert (all_odd_values (&list1));
-  _dbus_assert (all_odd_values (&list2));
+  _dbus_test_check (all_odd_values (&list1));
+  _dbus_test_check (all_odd_values (&list2));
 
   _dbus_list_clear (&list1);
   _dbus_list_clear (&list2);
@@ -452,8 +452,8 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       --i;
     }
 
-  _dbus_assert (all_even_values (&list1));
-  _dbus_assert (all_even_values (&list2));
+  _dbus_test_check (all_even_values (&list1));
+  _dbus_test_check (all_even_values (&list2));
 
   /* clear list using remove_link */
   while (list1 != NULL)
@@ -484,7 +484,7 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
     {
       DBusList *next = _dbus_list_get_next_link (&list2, link2);
 
-      _dbus_assert (_DBUS_POINTER_TO_INT (link2->data) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (link2->data) == i);
 
       if ((i % 2) == 0)
         _dbus_list_remove_link (&list2, link2);
@@ -495,7 +495,7 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       --i;
     }
 
-  _dbus_assert (all_odd_values (&list2));
+  _dbus_test_check (all_odd_values (&list2));
   _dbus_list_clear (&list2);
 
   i = 0;
@@ -504,7 +504,7 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
     {
       DBusList *next = _dbus_list_get_next_link (&list1, link1);
 
-      _dbus_assert (_DBUS_POINTER_TO_INT (link1->data) == i);
+      _dbus_test_check (_DBUS_POINTER_TO_INT (link1->data) == i);
 
       if ((i % 2) != 0)
         _dbus_list_remove_link (&list1, link1);
@@ -515,7 +515,7 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
       ++i;
     }
 
-  _dbus_assert (all_even_values (&list1));
+  _dbus_test_check (all_even_values (&list1));
   _dbus_list_clear (&list1);
 
   /* Test copying a list */
@@ -536,12 +536,12 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
   _dbus_list_copy (&list1, &copy1);
   verify_list (&list1);
   verify_list (&copy1);
-  _dbus_assert (lists_equal (&list1, &copy1));
+  _dbus_test_check (lists_equal (&list1, &copy1));
 
   _dbus_list_copy (&list2, &copy2);
   verify_list (&list2);
   verify_list (&copy2);
-  _dbus_assert (lists_equal (&list2, &copy2));
+  _dbus_test_check (lists_equal (&list2, &copy2));
 
   /* Now test copying empty lists */
   _dbus_list_clear (&list1);
@@ -556,12 +556,12 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
   _dbus_list_copy (&list1, &copy1);
   verify_list (&list1);
   verify_list (&copy1);
-  _dbus_assert (lists_equal (&list1, &copy1));
+  _dbus_test_check (lists_equal (&list1, &copy1));
 
   _dbus_list_copy (&list2, &copy2);
   verify_list (&list2);
   verify_list (&copy2);
-  _dbus_assert (lists_equal (&list2, &copy2));
+  _dbus_test_check (lists_equal (&list2, &copy2));
 
   _dbus_list_clear (&list1);
   _dbus_list_clear (&list2);
@@ -575,19 +575,19 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
   _dbus_list_insert_after (&list1, list1,
                            _DBUS_INT_TO_POINTER (1));
   verify_list (&list1);
-  _dbus_assert (is_ascending_sequence (&list1));
+  _dbus_test_check (is_ascending_sequence (&list1));
 
   /* inserting at the end */
   _dbus_list_insert_after (&list1, list1->next,
                            _DBUS_INT_TO_POINTER (2));
   verify_list (&list1);
-  _dbus_assert (is_ascending_sequence (&list1));
+  _dbus_test_check (is_ascending_sequence (&list1));
 
   /* using insert_after to prepend */
   _dbus_list_insert_after (&list1, NULL,
                            _DBUS_INT_TO_POINTER (-1));
   verify_list (&list1);
-  _dbus_assert (is_ascending_sequence (&list1));
+  _dbus_test_check (is_ascending_sequence (&list1));
 
   _dbus_list_clear (&list1);
 
@@ -602,7 +602,7 @@ _dbus_list_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
   _dbus_list_remove_last (&list1, _DBUS_INT_TO_POINTER (2));
 
   verify_list (&list1);
-  _dbus_assert (is_ascending_sequence (&list1));
+  _dbus_test_check (is_ascending_sequence (&list1));
 
   _dbus_list_clear (&list1);
 
@@ -625,32 +625,32 @@ _dbus_misc_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
    */
   dbus_get_version (&major, &minor, &micro);
 
-  _dbus_assert (major == DBUS_MAJOR_VERSION);
-  _dbus_assert (minor == DBUS_MINOR_VERSION);
-  _dbus_assert (micro == DBUS_MICRO_VERSION);
+  _dbus_test_check (major == DBUS_MAJOR_VERSION);
+  _dbus_test_check (minor == DBUS_MINOR_VERSION);
+  _dbus_test_check (micro == DBUS_MICRO_VERSION);
 
 #define MAKE_VERSION(x, y, z) (((x) << 16) | ((y) << 8) | (z))
 
   /* check that MAKE_VERSION works and produces the intended ordering */
-  _dbus_assert (MAKE_VERSION (1, 0, 0) > MAKE_VERSION (0, 0, 0));
-  _dbus_assert (MAKE_VERSION (1, 1, 0) > MAKE_VERSION (1, 0, 0));
-  _dbus_assert (MAKE_VERSION (1, 1, 1) > MAKE_VERSION (1, 1, 0));
+  _dbus_test_check (MAKE_VERSION (1, 0, 0) > MAKE_VERSION (0, 0, 0));
+  _dbus_test_check (MAKE_VERSION (1, 1, 0) > MAKE_VERSION (1, 0, 0));
+  _dbus_test_check (MAKE_VERSION (1, 1, 1) > MAKE_VERSION (1, 1, 0));
 
-  _dbus_assert (MAKE_VERSION (2, 0, 0) > MAKE_VERSION (1, 1, 1));
-  _dbus_assert (MAKE_VERSION (2, 1, 0) > MAKE_VERSION (1, 1, 1));
-  _dbus_assert (MAKE_VERSION (2, 1, 1) > MAKE_VERSION (1, 1, 1));
+  _dbus_test_check (MAKE_VERSION (2, 0, 0) > MAKE_VERSION (1, 1, 1));
+  _dbus_test_check (MAKE_VERSION (2, 1, 0) > MAKE_VERSION (1, 1, 1));
+  _dbus_test_check (MAKE_VERSION (2, 1, 1) > MAKE_VERSION (1, 1, 1));
 
   /* check DBUS_VERSION */
-  _dbus_assert (MAKE_VERSION (major, minor, micro) == DBUS_VERSION);
+  _dbus_test_check (MAKE_VERSION (major, minor, micro) == DBUS_VERSION);
 
   /* check that ordering works with DBUS_VERSION */
-  _dbus_assert (MAKE_VERSION (major - 1, minor, micro) < DBUS_VERSION);
-  _dbus_assert (MAKE_VERSION (major, minor - 1, micro) < DBUS_VERSION);
-  _dbus_assert (MAKE_VERSION (major, minor, micro - 1) < DBUS_VERSION);
+  _dbus_test_check (MAKE_VERSION (major - 1, minor, micro) < DBUS_VERSION);
+  _dbus_test_check (MAKE_VERSION (major, minor - 1, micro) < DBUS_VERSION);
+  _dbus_test_check (MAKE_VERSION (major, minor, micro - 1) < DBUS_VERSION);
 
-  _dbus_assert (MAKE_VERSION (major + 1, minor, micro) > DBUS_VERSION);
-  _dbus_assert (MAKE_VERSION (major, minor + 1, micro) > DBUS_VERSION);
-  _dbus_assert (MAKE_VERSION (major, minor, micro + 1) > DBUS_VERSION);
+  _dbus_test_check (MAKE_VERSION (major + 1, minor, micro) > DBUS_VERSION);
+  _dbus_test_check (MAKE_VERSION (major, minor + 1, micro) > DBUS_VERSION);
+  _dbus_test_check (MAKE_VERSION (major, minor, micro + 1) > DBUS_VERSION);
 
   /* Check DBUS_VERSION_STRING */
 
@@ -664,7 +664,7 @@ _dbus_misc_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
         _dbus_string_append_int (&str, micro)))
     _dbus_test_fatal ("no memory");
 
-  _dbus_assert (_dbus_string_equal_c_str (&str, DBUS_VERSION_STRING));
+  _dbus_test_check (_dbus_string_equal_c_str (&str, DBUS_VERSION_STRING));
 
   _dbus_string_free (&str);
 
@@ -702,9 +702,9 @@ _dbus_server_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
         }
 
       id = dbus_server_get_id (server);
-      _dbus_assert (id != NULL);
+      _dbus_test_check (id != NULL);
       address = dbus_server_get_address (server);
-      _dbus_assert (address != NULL);
+      _dbus_test_check (address != NULL);
 
       if (strstr (address, id) == NULL)
         {
@@ -740,24 +740,24 @@ _dbus_signature_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
   dbus_bool_t boolres;
 
   sig = "";
-  _dbus_assert (dbus_signature_validate (sig, NULL));
-  _dbus_assert (!dbus_signature_validate_single (sig, NULL));
+  _dbus_test_check (dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate_single (sig, NULL));
   dbus_signature_iter_init (&iter, sig);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID);
 
   sig = DBUS_TYPE_STRING_AS_STRING;
-  _dbus_assert (dbus_signature_validate (sig, NULL));
-  _dbus_assert (dbus_signature_validate_single (sig, NULL));
+  _dbus_test_check (dbus_signature_validate (sig, NULL));
+  _dbus_test_check (dbus_signature_validate_single (sig, NULL));
   dbus_signature_iter_init (&iter, sig);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING);
 
   sig = DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
-  _dbus_assert (dbus_signature_validate (sig, NULL));
+  _dbus_test_check (dbus_signature_validate (sig, NULL));
   dbus_signature_iter_init (&iter, sig);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING);
   boolres = dbus_signature_iter_next (&iter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_BYTE);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_BYTE);
 
   sig = DBUS_TYPE_UINT16_AS_STRING
     DBUS_STRUCT_BEGIN_CHAR_AS_STRING
@@ -766,23 +766,23 @@ _dbus_signature_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
     DBUS_TYPE_VARIANT_AS_STRING
     DBUS_TYPE_DOUBLE_AS_STRING
     DBUS_STRUCT_END_CHAR_AS_STRING;
-  _dbus_assert (dbus_signature_validate (sig, NULL));
+  _dbus_test_check (dbus_signature_validate (sig, NULL));
   dbus_signature_iter_init (&iter, sig);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16);
   boolres = dbus_signature_iter_next (&iter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT);
   dbus_signature_iter_recurse (&iter, &subiter);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRING);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRING);
   boolres = dbus_signature_iter_next (&subiter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32);
   boolres = dbus_signature_iter_next (&subiter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_VARIANT);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_VARIANT);
   boolres = dbus_signature_iter_next (&subiter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_DOUBLE);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_DOUBLE);
 
   sig = DBUS_TYPE_UINT16_AS_STRING
     DBUS_STRUCT_BEGIN_CHAR_AS_STRING
@@ -795,33 +795,33 @@ _dbus_signature_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
     DBUS_TYPE_BYTE_AS_STRING
     DBUS_STRUCT_END_CHAR_AS_STRING
     DBUS_STRUCT_END_CHAR_AS_STRING;
-  _dbus_assert (dbus_signature_validate (sig, NULL));
+  _dbus_test_check (dbus_signature_validate (sig, NULL));
   dbus_signature_iter_init (&iter, sig);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16);
   boolres = dbus_signature_iter_next (&iter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT);
   dbus_signature_iter_recurse (&iter, &subiter);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32);
   boolres = dbus_signature_iter_next (&subiter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_BYTE);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_BYTE);
   boolres = dbus_signature_iter_next (&subiter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_ARRAY);
-  _dbus_assert (dbus_signature_iter_get_element_type (&subiter) == DBUS_TYPE_ARRAY);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_ARRAY);
+  _dbus_test_check (dbus_signature_iter_get_element_type (&subiter) == DBUS_TYPE_ARRAY);
 
   dbus_signature_iter_recurse (&subiter, &subsubiter);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_ARRAY);
-  _dbus_assert (dbus_signature_iter_get_element_type (&subsubiter) == DBUS_TYPE_DOUBLE);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_ARRAY);
+  _dbus_test_check (dbus_signature_iter_get_element_type (&subsubiter) == DBUS_TYPE_DOUBLE);
 
   dbus_signature_iter_recurse (&subsubiter, &subsubsubiter);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subsubsubiter) == DBUS_TYPE_DOUBLE);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subsubsubiter) == DBUS_TYPE_DOUBLE);
   boolres = dbus_signature_iter_next (&subiter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRUCT);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRUCT);
   dbus_signature_iter_recurse (&subiter, &subsubiter);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_BYTE);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_BYTE);
 
   sig = DBUS_TYPE_ARRAY_AS_STRING
     DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
@@ -829,63 +829,63 @@ _dbus_signature_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
     DBUS_TYPE_STRING_AS_STRING
     DBUS_DICT_ENTRY_END_CHAR_AS_STRING
     DBUS_TYPE_VARIANT_AS_STRING;
-  _dbus_assert (dbus_signature_validate (sig, NULL));
-  _dbus_assert (!dbus_signature_validate_single (sig, NULL));
+  _dbus_test_check (dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate_single (sig, NULL));
   dbus_signature_iter_init (&iter, sig);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_ARRAY);
-  _dbus_assert (dbus_signature_iter_get_element_type (&iter) == DBUS_TYPE_DICT_ENTRY);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_ARRAY);
+  _dbus_test_check (dbus_signature_iter_get_element_type (&iter) == DBUS_TYPE_DICT_ENTRY);
 
   dbus_signature_iter_recurse (&iter, &subiter);
   dbus_signature_iter_recurse (&subiter, &subsubiter);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_INT16);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_INT16);
   boolres = dbus_signature_iter_next (&subsubiter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_STRING);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_STRING);
   boolres = dbus_signature_iter_next (&subsubiter);
-  _dbus_assert (!boolres);
+  _dbus_test_check (!boolres);
 
   boolres = dbus_signature_iter_next (&iter);
-  _dbus_assert (boolres);
-  _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_VARIANT);
+  _dbus_test_check (boolres);
+  _dbus_test_check (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_VARIANT);
   boolres = dbus_signature_iter_next (&iter);
-  _dbus_assert (!boolres);
+  _dbus_test_check (!boolres);
 
   sig = DBUS_TYPE_DICT_ENTRY_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_TYPE_ARRAY_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_TYPE_UINT32_AS_STRING
     DBUS_TYPE_ARRAY_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_TYPE_ARRAY_AS_STRING
     DBUS_TYPE_DICT_ENTRY_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
     DBUS_TYPE_INT32_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
     DBUS_TYPE_INT32_AS_STRING
     DBUS_TYPE_STRING_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_STRUCT_END_CHAR_AS_STRING
     DBUS_STRUCT_BEGIN_CHAR_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
 
   sig = DBUS_STRUCT_BEGIN_CHAR_AS_STRING
     DBUS_TYPE_BOOLEAN_AS_STRING;
-  _dbus_assert (!dbus_signature_validate (sig, NULL));
+  _dbus_test_check (!dbus_signature_validate (sig, NULL));
   return TRUE;
 #if 0
  oom:
@@ -907,11 +907,11 @@ _dbus_transport_unix_test (const char *test_data_dir _DBUS_GNUC_UNUSED)
   dbus_error_init (&error);
 
   c = dbus_connection_open ("unixexec:argv0=false,argv1=foobar,path=/bin/false", &error);
-  _dbus_assert (c != NULL);
-  _dbus_assert (!dbus_error_is_set (&error));
+  _dbus_test_check (c != NULL);
+  _dbus_test_check (!dbus_error_is_set (&error));
 
   address = _dbus_connection_get_address (c);
-  _dbus_assert (address != NULL);
+  _dbus_test_check (address != NULL);
 
   /* Let's see if the address got parsed, reordered and formatted correctly */
   ret = strcmp (address, "unixexec:path=/bin/false,argv0=false,argv1=foobar") == 0;