fdo-mirrors/dbus
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/dbus/dbus.git synced 2026-02-05 01:50:29 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

test: Replace some _dbus_assert() with _dbus_test_check()

Browse source 
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>
This commit is contained in:
Simon McVittie 2020-04-16 14:23:17 +01:00
parent e559663e03
commit 9251d32206
2 changed files with 163 additions and 163 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
test/internals/hash.c
View file

@ -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;
}

260
test/internals/misc-internals.c
View file

@ -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;