#include <dbus/dbus-spawn.h>
#include <dbus/dbus-timeout.h>
#include <dbus/dbus-sysdeps.h>
+#include <dbus/dbus-test-tap.h>
#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
err = !check_func (data);
if (err)
- _dbus_assert_not_reached ("Test failed");
+ _dbus_test_fatal ("Test failed");
return TRUE;
}
/* Do normal tests */
if (!init_service_reload_test (&directory))
- _dbus_assert_not_reached ("could not initiate service reload test");
+ _dbus_test_fatal ("could not initiate service reload test");
if (!do_service_reload_test (test_data_dir, &directory, FALSE))
{
/* Do OOM tests */
if (!init_service_reload_test (&directory))
- _dbus_assert_not_reached ("could not initiate service reload test");
+ _dbus_test_fatal ("could not initiate service reload test");
if (!do_service_reload_test (test_data_dir, &directory, TRUE))
{
dir = NULL;
if (!_dbus_string_init (&test_directory))
- _dbus_assert_not_reached ("didn't allocate test_directory");
+ _dbus_test_fatal ("didn't allocate test_directory");
_dbus_string_init_const (&filename, subdir);
if (!_dbus_string_copy (test_base_dir, 0,
&test_directory, 0))
- _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
+ _dbus_test_fatal ("couldn't copy test_base_dir to test_directory");
if (!_dbus_concat_dir_and_file (&test_directory, &filename))
- _dbus_assert_not_reached ("couldn't allocate full path");
+ _dbus_test_fatal ("couldn't allocate full path");
_dbus_string_free (&filename);
if (!_dbus_string_init (&filename))
- _dbus_assert_not_reached ("didn't allocate filename string");
+ _dbus_test_fatal ("didn't allocate filename string");
dbus_error_init (&error);
dir = _dbus_directory_open (&test_directory, &error);
LoaderOomData d;
if (!_dbus_string_init (&full_path))
- _dbus_assert_not_reached ("couldn't init string");
+ _dbus_test_fatal ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
- _dbus_assert_not_reached ("couldn't copy dir to full_path");
+ _dbus_test_fatal ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
- _dbus_assert_not_reached ("couldn't concat file to dir");
+ _dbus_test_fatal ("couldn't concat file to dir");
if (!_dbus_string_ends_with_c_str (&full_path, ".conf"))
{
*/
/* if (!_dbus_test_oom_handling ("config-loader", check_loader_oom_func, &d)) */
if (!check_loader_oom_func (&d))
- _dbus_assert_not_reached ("test failed");
-
+ _dbus_test_fatal ("test failed");
+
_dbus_string_free (&full_path);
}
dbus_bool_t ret;
if (!_dbus_string_init (&service_name))
- _dbus_assert_not_reached ("couldn't init string");
+ _dbus_test_fatal ("couldn't init string");
if (!_dbus_string_append (&service_name, checks[i].name))
- _dbus_assert_not_reached ("couldn't append string");
+ _dbus_test_fatal ("couldn't append string");
ret = bus_policy_check_can_own (policy, &service_name);
_dbus_test_diag (" Check name %s: %s", checks[i].name,
dir = NULL;
if (!_dbus_string_init (&test_directory))
- _dbus_assert_not_reached ("didn't allocate test_directory");
+ _dbus_test_fatal ("didn't allocate test_directory");
_dbus_string_init_const (&filename, subdir);
if (!_dbus_string_copy (test_base_dir, 0,
&test_directory, 0))
- _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
+ _dbus_test_fatal ("couldn't copy test_base_dir to test_directory");
if (!_dbus_concat_dir_and_file (&test_directory, &filename))
- _dbus_assert_not_reached ("couldn't allocate full path");
+ _dbus_test_fatal ("couldn't allocate full path");
_dbus_string_free (&filename);
if (!_dbus_string_init (&filename))
- _dbus_assert_not_reached ("didn't allocate filename string");
+ _dbus_test_fatal ("didn't allocate filename string");
dbus_error_init (&error);
dir = _dbus_directory_open (&test_directory, &error);
LoaderOomData d;
if (!_dbus_string_init (&full_path))
- _dbus_assert_not_reached ("couldn't init string");
+ _dbus_test_fatal ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
- _dbus_assert_not_reached ("couldn't copy dir to full_path");
+ _dbus_test_fatal ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
- _dbus_assert_not_reached ("couldn't concat file to dir");
+ _dbus_test_fatal ("couldn't concat file to dir");
if (!_dbus_string_ends_with_c_str (&full_path, ".conf"))
{
*/
/* if (!_dbus_test_oom_handling ("config-loader", check_loader_oom_func, &d)) */
if (!check_loader_oom_func (&d))
- _dbus_assert_not_reached ("test failed");
-
+ _dbus_test_fatal ("test failed");
+
_dbus_string_free (&full_path);
}
retval = FALSE;
if (!_dbus_string_init (&filename))
- _dbus_assert_not_reached ("didn't allocate filename string");
+ _dbus_test_fatal ("didn't allocate filename string");
dbus_error_init (&error);
dir = _dbus_directory_open (target_directory, &error);
DBusString full_path;
if (!_dbus_string_init (&full_path))
- _dbus_assert_not_reached ("couldn't init string");
+ _dbus_test_fatal ("couldn't init string");
if (!_dbus_string_copy (target_directory, 0, &full_path, 0))
- _dbus_assert_not_reached ("couldn't copy dir to full_path");
+ _dbus_test_fatal ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
- _dbus_assert_not_reached ("couldn't concat file to dir");
+ _dbus_test_fatal ("couldn't concat file to dir");
if (!_dbus_string_ends_with_c_str (&full_path, ".conf"))
{
retval = FALSE;
if (!_dbus_string_init (&test_directory))
- _dbus_assert_not_reached ("didn't allocate test_directory");
+ _dbus_test_fatal ("didn't allocate test_directory");
_dbus_string_init_const (&filename, subdir);
if (!_dbus_string_copy (test_base_dir, 0,
&test_directory, 0))
- _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
+ _dbus_test_fatal ("couldn't copy test_base_dir to test_directory");
if (!_dbus_concat_dir_and_file (&test_directory, &filename))
- _dbus_assert_not_reached ("couldn't allocate full path");
+ _dbus_test_fatal ("couldn't allocate full path");
_dbus_string_free (&filename);
if (!_dbus_string_init (&filename))
- _dbus_assert_not_reached ("didn't allocate filename string");
+ _dbus_test_fatal ("didn't allocate filename string");
dbus_error_init (&error);
dir = _dbus_directory_open (&test_directory, &error);
continue;
if (!_dbus_string_init (&full_path))
- _dbus_assert_not_reached ("couldn't init string");
+ _dbus_test_fatal ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
- _dbus_assert_not_reached ("couldn't copy dir to full_path");
+ _dbus_test_fatal ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
- _dbus_assert_not_reached ("couldn't concat file to dir");
-
+ _dbus_test_fatal ("couldn't concat file to dir");
+
equal = all_are_equiv (&full_path);
_dbus_string_free (&full_path);
!_dbus_string_init (&data_home_based) ||
!_dbus_string_init (&data_dirs_based) ||
!_dbus_string_init (&data_dirs_based2))
- _dbus_assert_not_reached ("OOM allocating strings");
+ _dbus_test_fatal ("OOM allocating strings");
if (!_dbus_string_copy (test_base_dir, 0,
&full_path, 0))
- _dbus_assert_not_reached ("couldn't copy test_base_dir to full_path");
+ _dbus_test_fatal ("couldn't copy test_base_dir to full_path");
_dbus_string_init_const (&tmp, "valid-config-files");
if (!_dbus_concat_dir_and_file (&full_path, &tmp))
- _dbus_assert_not_reached ("couldn't allocate full path");
+ _dbus_test_fatal ("couldn't allocate full path");
_dbus_string_init_const (&tmp, "standard-session-dirs.conf");
if (!_dbus_concat_dir_and_file (&full_path, &tmp))
- _dbus_assert_not_reached ("couldn't allocate full path");
+ _dbus_test_fatal ("couldn't allocate full path");
#ifdef DBUS_WIN
if (!_dbus_string_append (&install_root_based, DBUS_DATADIR) ||
!_dbus_string_append (&runtime_dir_based, xdg_runtime_dir) ||
!_dbus_string_append (&data_home_based, xdg_data_home) ||
!_dbus_string_append (&data_home_based, "/dbus-1/services"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
if (!_dbus_ensure_directory (&runtime_dir_based, NULL))
- _dbus_assert_not_reached ("Unable to create fake XDG_RUNTIME_DIR");
+ _dbus_test_fatal ("Unable to create fake XDG_RUNTIME_DIR");
if (!_dbus_string_append (&runtime_dir_based, "/dbus-1/services"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
/* Sanity check: the Makefile sets this up. We assume that if this is
* right, the XDG_DATA_DIRS will be too. */
if (!_dbus_string_starts_with_c_str (&data_home_based, dbus_test_builddir))
- _dbus_assert_not_reached ("$XDG_DATA_HOME should start with $DBUS_TEST_BUILDDIR");
+ _dbus_test_fatal ("$XDG_DATA_HOME should start with $DBUS_TEST_BUILDDIR");
if (!_dbus_string_starts_with_c_str (&runtime_dir_based, dbus_test_builddir))
- _dbus_assert_not_reached ("$XDG_RUNTIME_DIR should start with $DBUS_TEST_BUILDDIR");
+ _dbus_test_fatal ("$XDG_RUNTIME_DIR should start with $DBUS_TEST_BUILDDIR");
test_session_service_dir_matches[0] = _dbus_string_get_const_data (
&runtime_dir_based);
parser = bus_config_load (&full_path, TRUE, NULL, &error);
if (parser == NULL)
- _dbus_assert_not_reached (error.message);
+ _dbus_test_fatal ("%s", error.message);
dirs = bus_config_parser_get_service_dirs (parser);
}
if (!bus_config_parser_get_watched_dirs (parser, &watched_dirs))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
#ifdef DBUS_WIN
/* We expect all directories to be watched (not that it matters on Windows,
dirs = NULL;
if (!_dbus_get_standard_system_servicedirs (&dirs))
- _dbus_assert_not_reached ("couldn't get stardard dirs");
+ _dbus_test_fatal ("couldn't get stardard dirs");
/* make sure we read and parse the env variable correctly */
i = 0;
/* Run disconnect handler in test.c */
if (bus_connection_dispatch_one_message (connection))
- _dbus_assert_not_reached ("something received on connection being killed other than the disconnect");
+ _dbus_test_fatal ("something received on connection being killed other than the disconnect");
_dbus_assert (!dbus_connection_get_is_connected (connection));
dbus_connection_unref (connection);
dbus_free (base_service);
if (socd.failed)
- _dbus_assert_not_reached ("didn't get the expected NameOwnerChanged (deletion) messages");
+ _dbus_test_fatal ("didn't get the expected NameOwnerChanged (deletion) messages");
if (!check_no_leftovers (context))
- _dbus_assert_not_reached ("stuff left in message queues after disconnecting a client");
+ _dbus_test_fatal ("stuff left in message queues after disconnecting a client");
}
static void
dbus_connection_close (connection);
/* dispatching disconnect handler will unref once */
if (bus_connection_dispatch_one_message (connection))
- _dbus_assert_not_reached ("message other than disconnect dispatched after failure to register");
+ _dbus_test_fatal ("message other than disconnect dispatched after failure to register");
_dbus_assert (!bus_test_client_listed (connection));
dbus_connection_unref (connection);
if (!_dbus_test_oom_handling (description, check_oom_check1_func,
&d))
- _dbus_assert_not_reached ("test failed");
+ _dbus_test_fatal ("test failed");
}
static dbus_bool_t
/* save the config name for the activation helper */
if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename))
- _dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
+ _dbus_test_fatal ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
dbus_error_init (&error);
foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (foo == NULL)
- _dbus_assert_not_reached ("could not alloc connection");
+ _dbus_test_fatal ("could not alloc connection");
if (!bus_setup_debug_client (foo))
- _dbus_assert_not_reached ("could not set up connection");
+ _dbus_test_fatal ("could not set up connection");
spin_connection_until_authenticated (context, foo);
if (!check_hello_message (context, foo))
- _dbus_assert_not_reached ("hello message failed");
+ _dbus_test_fatal ("hello message failed");
if (!check_double_hello_message (context, foo))
- _dbus_assert_not_reached ("double hello message failed");
+ _dbus_test_fatal ("double hello message failed");
if (!check_add_match (context, foo, ""))
- _dbus_assert_not_reached ("AddMatch message failed");
+ _dbus_test_fatal ("AddMatch message failed");
bar = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (bar == NULL)
- _dbus_assert_not_reached ("could not alloc connection");
+ _dbus_test_fatal ("could not alloc connection");
if (!bus_setup_debug_client (bar))
- _dbus_assert_not_reached ("could not set up connection");
+ _dbus_test_fatal ("could not set up connection");
spin_connection_until_authenticated (context, bar);
if (!check_hello_message (context, bar))
- _dbus_assert_not_reached ("hello message failed");
+ _dbus_test_fatal ("hello message failed");
if (!check_add_match (context, bar, ""))
- _dbus_assert_not_reached ("AddMatch message failed");
+ _dbus_test_fatal ("AddMatch message failed");
baz = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (baz == NULL)
- _dbus_assert_not_reached ("could not alloc connection");
+ _dbus_test_fatal ("could not alloc connection");
if (!bus_setup_debug_client (baz))
- _dbus_assert_not_reached ("could not set up connection");
+ _dbus_test_fatal ("could not set up connection");
spin_connection_until_authenticated (context, baz);
if (!check_hello_message (context, baz))
- _dbus_assert_not_reached ("hello message failed");
+ _dbus_test_fatal ("hello message failed");
if (!check_add_match (context, baz, ""))
- _dbus_assert_not_reached ("AddMatch message failed");
+ _dbus_test_fatal ("AddMatch message failed");
if (!check_add_match (context, baz, "interface='com.example'"))
- _dbus_assert_not_reached ("AddMatch message failed");
+ _dbus_test_fatal ("AddMatch message failed");
#ifdef DBUS_ENABLE_STATS
if (!check_get_all_match_rules (context, baz))
- _dbus_assert_not_reached ("GetAllMatchRules message failed");
+ _dbus_test_fatal ("GetAllMatchRules message failed");
#endif
if (!check_get_connection_unix_user (context, baz))
- _dbus_assert_not_reached ("GetConnectionUnixUser message failed");
+ _dbus_test_fatal ("GetConnectionUnixUser message failed");
#ifdef DBUS_WIN_FIXME
_dbus_verbose("TODO: testing of GetConnectionUnixProcessID message skipped for now\n");
#else
if (!check_get_connection_unix_process_id (context, baz))
- _dbus_assert_not_reached ("GetConnectionUnixProcessID message failed");
+ _dbus_test_fatal ("GetConnectionUnixProcessID message failed");
#endif
if (!check_list_services (context, baz))
- _dbus_assert_not_reached ("ListActivatableNames message failed");
+ _dbus_test_fatal ("ListActivatableNames message failed");
if (!check_no_leftovers (context))
_dbus_test_fatal ("Messages were left over after setting up initial connections");
/* specific to launcher */
if (use_launcher)
if (!check_launch_service_file_missing (context, foo))
- _dbus_assert_not_reached ("did not get service file not found error");
+ _dbus_test_fatal ("did not get service file not found error");
#if 0
/* Note: need to resolve some issues with the testing code in order to run
#endif
if (!check_existent_service_auto_start (context, foo))
- _dbus_assert_not_reached ("existent service auto start failed");
+ _dbus_test_fatal ("existent service auto start failed");
if (!check_shell_service_success_auto_start (context, foo))
- _dbus_assert_not_reached ("shell success service auto start failed");
+ _dbus_test_fatal ("shell success service auto start failed");
_dbus_verbose ("Disconnecting foo, bar, and baz\n");
/* save the config name for the activation helper */
if (!setenv_TEST_LAUNCH_HELPER_CONFIG (test_data_dir, filename))
- _dbus_assert_not_reached ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
+ _dbus_test_fatal ("no memory setting TEST_LAUNCH_HELPER_CONFIG");
dbus_error_init (&error);
foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (foo == NULL)
- _dbus_assert_not_reached ("could not alloc connection");
+ _dbus_test_fatal ("could not alloc connection");
if (!bus_setup_debug_client (foo))
- _dbus_assert_not_reached ("could not set up connection");
+ _dbus_test_fatal ("could not set up connection");
spin_connection_until_authenticated (context, foo);
if (!check_hello_message (context, foo))
- _dbus_assert_not_reached ("hello message failed");
+ _dbus_test_fatal ("hello message failed");
if (!check_double_hello_message (context, foo))
- _dbus_assert_not_reached ("double hello message failed");
+ _dbus_test_fatal ("double hello message failed");
if (!check_add_match (context, foo, ""))
- _dbus_assert_not_reached ("AddMatch message failed");
+ _dbus_test_fatal ("AddMatch message failed");
/* this only tests the activation.c user check */
if (!check_launch_service_user_missing (context, foo))
- _dbus_assert_not_reached ("user missing did not trigger error");
+ _dbus_test_fatal ("user missing did not trigger error");
/* this only tests the desktop.c exec check */
if (!check_launch_service_exec_missing (context, foo))
- _dbus_assert_not_reached ("exec missing did not trigger error");
+ _dbus_test_fatal ("exec missing did not trigger error");
/* this only tests the desktop.c service check */
if (!check_launch_service_service_missing (context, foo))
- _dbus_assert_not_reached ("service missing did not trigger error");
+ _dbus_test_fatal ("service missing did not trigger error");
_dbus_verbose ("Disconnecting foo\n");
foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (foo == NULL)
- _dbus_assert_not_reached ("could not alloc connection");
+ _dbus_test_fatal ("could not alloc connection");
if (!bus_setup_debug_client (foo))
- _dbus_assert_not_reached ("could not set up connection");
+ _dbus_test_fatal ("could not set up connection");
spin_connection_until_authenticated (context, foo);
if (!check_hello_message (context, foo))
- _dbus_assert_not_reached ("hello message failed");
+ _dbus_test_fatal ("hello message failed");
if (!check_add_match (context, foo, ""))
- _dbus_assert_not_reached ("addmatch message failed");
+ _dbus_test_fatal ("addmatch message failed");
if (!check_no_leftovers (context))
_dbus_test_fatal ("Messages were left over after setting up initial SHA-1 connection");
context = bus_context_new_test (test_data_dir, "valid-config-files/debug-allow-all.conf");
if (context == NULL)
- _dbus_assert_not_reached ("could not alloc context");
+ _dbus_test_fatal ("could not alloc context");
foo = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (foo == NULL)
- _dbus_assert_not_reached ("could not alloc connection");
+ _dbus_test_fatal ("could not alloc connection");
if (!bus_setup_debug_client (foo))
- _dbus_assert_not_reached ("could not set up connection");
+ _dbus_test_fatal ("could not set up connection");
spin_connection_until_authenticated (context, foo);
if (!check_hello_message (context, foo))
- _dbus_assert_not_reached ("hello message failed");
+ _dbus_test_fatal ("hello message failed");
if (!check_add_match (context, foo, ""))
- _dbus_assert_not_reached ("AddMatch message failed");
+ _dbus_test_fatal ("AddMatch message failed");
bar = dbus_connection_open_private (TEST_DEBUG_PIPE, &error);
if (bar == NULL)
- _dbus_assert_not_reached ("could not alloc connection");
+ _dbus_test_fatal ("could not alloc connection");
if (!bus_setup_debug_client (bar))
- _dbus_assert_not_reached ("could not set up connection");
+ _dbus_test_fatal ("could not set up connection");
spin_connection_until_authenticated (context, bar);
if (!check_hello_message (context, bar))
- _dbus_assert_not_reached ("hello message failed");
+ _dbus_test_fatal ("hello message failed");
if (!check_add_match (context, bar, ""))
- _dbus_assert_not_reached ("AddMatch message failed");
+ _dbus_test_fatal ("AddMatch message failed");
if (!(m = dbus_message_new_signal("/", "a.b.c", "d")))
- _dbus_assert_not_reached ("could not alloc message");
+ _dbus_test_fatal ("could not alloc message");
if (!(_dbus_socketpair (one, one+1, TRUE, &error)))
- _dbus_assert_not_reached("Failed to allocate pipe #1");
+ _dbus_test_fatal ("Failed to allocate pipe #1");
if (!(_dbus_socketpair (two, two+1, TRUE, &error)))
- _dbus_assert_not_reached("Failed to allocate pipe #2");
+ _dbus_test_fatal ("Failed to allocate pipe #2");
if (!dbus_message_append_args(m,
DBUS_TYPE_UNIX_FD, one,
DBUS_TYPE_UNIX_FD, two,
DBUS_TYPE_UNIX_FD, two,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached("Failed to attach fds.");
+ _dbus_test_fatal ("Failed to attach fds.");
if (!_dbus_close_socket (one[0], &error))
- _dbus_assert_not_reached("Failed to close pipe #1 ");
+ _dbus_test_fatal ("Failed to close pipe #1 ");
if (!_dbus_close_socket (two[0], &error))
- _dbus_assert_not_reached("Failed to close pipe #2 ");
+ _dbus_test_fatal ("Failed to close pipe #2 ");
if (!(dbus_connection_can_send_type(foo, DBUS_TYPE_UNIX_FD)))
- _dbus_assert_not_reached("Connection cannot do fd passing");
+ _dbus_test_fatal ("Connection cannot do fd passing");
if (!(dbus_connection_can_send_type(bar, DBUS_TYPE_UNIX_FD)))
- _dbus_assert_not_reached("Connection cannot do fd passing");
+ _dbus_test_fatal ("Connection cannot do fd passing");
if (!dbus_connection_send (foo, m, NULL))
- _dbus_assert_not_reached("Failed to send fds");
+ _dbus_test_fatal ("Failed to send fds");
dbus_message_unref(m);
block_connection_until_message_from_bus (context, foo, "unix fd reception on foo");
if (!(m = pop_message_waiting_for_memory (foo)))
- _dbus_assert_not_reached("Failed to receive msg");
+ _dbus_test_fatal ("Failed to receive msg");
if (!dbus_message_is_signal(m, "a.b.c", "d"))
- _dbus_assert_not_reached("bogus message received");
+ _dbus_test_fatal ("bogus message received");
dbus_message_unref(m);
block_connection_until_message_from_bus (context, bar, "unix fd reception on bar");
if (!(m = pop_message_waiting_for_memory (bar)))
- _dbus_assert_not_reached("Failed to receive msg");
+ _dbus_test_fatal ("Failed to receive msg");
if (!dbus_message_is_signal(m, "a.b.c", "d"))
- _dbus_assert_not_reached("bogus message received");
+ _dbus_test_fatal ("bogus message received");
if (!dbus_message_get_args(m,
&error,
DBUS_TYPE_UNIX_FD, &y,
DBUS_TYPE_UNIX_FD, &z,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached("Failed to parse fds.");
+ _dbus_test_fatal ("Failed to parse fds.");
dbus_message_unref(m);
if (write(x, "X", 1) != 1)
- _dbus_assert_not_reached("Failed to write to pipe #1");
+ _dbus_test_fatal ("Failed to write to pipe #1");
if (write(y, "Y", 1) != 1)
- _dbus_assert_not_reached("Failed to write to pipe #2");
+ _dbus_test_fatal ("Failed to write to pipe #2");
if (write(z, "Z", 1) != 1)
- _dbus_assert_not_reached("Failed to write to pipe #2/2nd fd");
+ _dbus_test_fatal ("Failed to write to pipe #2/2nd fd");
if (!_dbus_close(x, &error))
- _dbus_assert_not_reached("Failed to close pipe #1/other side ");
+ _dbus_test_fatal ("Failed to close pipe #1/other side ");
if (!_dbus_close(y, &error))
- _dbus_assert_not_reached("Failed to close pipe #2/other side ");
+ _dbus_test_fatal ("Failed to close pipe #2/other side ");
if (!_dbus_close(z, &error))
- _dbus_assert_not_reached("Failed to close pipe #2/other size 2nd fd ");
+ _dbus_test_fatal ("Failed to close pipe #2/other size 2nd fd ");
if (read(one[1].fd, &r, 1) != 1 || r != 'X')
- _dbus_assert_not_reached("Failed to read value from pipe.");
+ _dbus_test_fatal ("Failed to read value from pipe.");
if (read(two[1].fd, &r, 1) != 1 || r != 'Y')
- _dbus_assert_not_reached("Failed to read value from pipe.");
+ _dbus_test_fatal ("Failed to read value from pipe.");
if (read(two[1].fd, &r, 1) != 1 || r != 'Z')
- _dbus_assert_not_reached("Failed to read value from pipe.");
+ _dbus_test_fatal ("Failed to read value from pipe.");
if (!_dbus_close_socket (one[1], &error))
- _dbus_assert_not_reached("Failed to close pipe #1 ");
+ _dbus_test_fatal ("Failed to close pipe #1 ");
if (!_dbus_close_socket (two[1], &error))
- _dbus_assert_not_reached("Failed to close pipe #2 ");
+ _dbus_test_fatal ("Failed to close pipe #2 ");
_dbus_verbose ("Disconnecting foo\n");
kill_client_connection_unchecked (foo);
#include "test.h"
#include <dbus/dbus-internals.h>
#include <dbus/dbus-mainloop.h>
+#include <dbus/dbus-test-tap.h>
#include <dbus/dbus-timeout.h>
struct BusExpireList
item->item.added_tv_sec = tv_sec;
item->item.added_tv_usec = tv_usec;
if (!bus_expire_list_add (list, &item->item))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
next_interval =
do_expiration_with_monotonic_time (list, tv_sec_not_expired,
#include "services.h"
#include "utils.h"
#include <dbus/dbus-marshal-validate.h>
+#include <dbus/dbus-test-tap.h>
struct BusMatchRule
{
message1 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL);
_dbus_assert (message1 != NULL);
if (!dbus_message_set_member (message1, "Frobated"))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
v_STRING = "foobar";
v_INT32 = 3;
DBUS_TYPE_STRING, &v_STRING,
DBUS_TYPE_INT32, &v_INT32,
NULL))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
check_matching (message1, 1,
should_match_message_1,
should_not_match_message_1);
message2 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL);
_dbus_assert (message2 != NULL);
if (!dbus_message_set_member (message2, "NameOwnerChanged"))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
/* Obviously this isn't really a NameOwnerChanged signal. */
v_STRING = EXAMPLE_NAME;
if (!dbus_message_append_args (message2,
DBUS_TYPE_STRING, &v_STRING,
NULL))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
check_matching (message2, 2,
should_match_message_2,
_dbus_assert (message != NULL);
if (!dbus_message_set_member (message, "Foo"))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
if (!dbus_message_append_args (message,
type, &path,
NULL))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
matched = match_rule_matches (rule, NULL, NULL, message, 0);
message1 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL);
_dbus_assert (message1 != NULL);
if (!dbus_message_set_path (message1, "/foo/TheObjectManager"))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
message2 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL);
_dbus_assert (message2 != NULL);
if (!dbus_message_set_path (message2, "/foo/TheObjectManager/child_object"))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
message3 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL);
_dbus_assert (message3 != NULL);
if (!dbus_message_set_path (message3, "/foo/TheObjectManagerOther"))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
message4 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL);
_dbus_assert (message4 != NULL);
if (!dbus_message_set_path (message4, "/"))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
check_matching (message1, 1,
path_namespace_should_match_message_1,
bus_matchmaker_unref (matchmaker);
if (!_dbus_test_oom_handling ("parsing match rules", test_parsing, NULL))
- _dbus_assert_not_reached ("Parsing match rules test failed");
+ _dbus_test_fatal ("Parsing match rules test failed");
test_equality ();
test_matching ();
#include "dbus-list.h"
#include "dbus-string.h"
#include "dbus-protocol.h"
+#include <dbus/dbus-test-tap.h>
/**
* @defgroup DBusAddressInternals Address parsing
escaped = dbus_address_escape_value (test->unescaped);
if (escaped == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
if (strcmp (escaped, test->escaped) != 0)
{
if (!dbus_parse_address ("unix:path=/tmp/foo;debug:name=test,sliff=sloff;",
&entries, &len, &error))
- _dbus_assert_not_reached ("could not parse address");
+ _dbus_test_fatal ("could not parse address");
_dbus_assert (len == 2);
_dbus_assert (strcmp (dbus_address_entry_get_value (entries[0], "path"), "/tmp/foo") == 0);
_dbus_assert (strcmp (dbus_address_entry_get_value (entries[1], "name"), "test") == 0);
/* Different possible errors */
if (dbus_parse_address ("", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
if (dbus_parse_address ("foo", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
if (dbus_parse_address ("foo:bar", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
if (dbus_parse_address ("foo:bar,baz", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
if (dbus_parse_address ("foo:bar=foo,baz", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
if (dbus_parse_address ("foo:bar=foo;baz", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
if (dbus_parse_address ("foo:=foo", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
if (dbus_parse_address ("foo:foo=", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
if (dbus_parse_address ("foo:foo,bar=baz", &entries, &len, &error))
- _dbus_assert_not_reached ("Parsed incorrect address.");
+ _dbus_test_fatal ("Parsed incorrect address.");
else
dbus_error_free (&error);
credentials = _dbus_credentials_new ();
if (credentials == NULL)
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (uid != DBUS_UID_UNSET)
{
if (!_dbus_credentials_add_unix_uid (credentials, uid))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
}
if (pid != DBUS_PID_UNSET)
{
if (!_dbus_credentials_add_pid (credentials, pid))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
}
_dbus_auth_set_credentials (auth, credentials);
dir = NULL;
if (!_dbus_string_init (&test_directory))
- _dbus_assert_not_reached ("didn't allocate test_directory");
+ _dbus_test_fatal ("didn't allocate test_directory");
_dbus_string_init_const (&filename, subdir);
if (!_dbus_string_copy (test_base_dir, 0,
&test_directory, 0))
- _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
-
+ _dbus_test_fatal ("couldn't copy test_base_dir to test_directory");
+
if (!_dbus_concat_dir_and_file (&test_directory, &filename))
- _dbus_assert_not_reached ("couldn't allocate full path");
+ _dbus_test_fatal ("couldn't allocate full path");
_dbus_string_free (&filename);
if (!_dbus_string_init (&filename))
- _dbus_assert_not_reached ("didn't allocate filename string");
+ _dbus_test_fatal ("didn't allocate filename string");
dir = _dbus_directory_open (&test_directory, &error);
if (dir == NULL)
DBusString full_path;
if (!_dbus_string_init (&full_path))
- _dbus_assert_not_reached ("couldn't init string");
+ _dbus_test_fatal ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
- _dbus_assert_not_reached ("couldn't copy dir to full_path");
+ _dbus_test_fatal ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
- _dbus_assert_not_reached ("couldn't concat file to dir");
+ _dbus_test_fatal ("couldn't concat file to dir");
if (!_dbus_string_ends_with_c_str (&filename, ".auth-script"))
{
#include "dbus-internals.h"
#include "dbus-test.h"
#include "dbus-credentials.h"
+#include <dbus/dbus-test-tap.h>
/**
* @addtogroup DBusCredentials
creds = make_credentials (12, 511, SAMPLE_SID);
if (creds == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
/* test refcounting */
_dbus_credentials_ref (creds);
/* Test copy */
creds2 = _dbus_credentials_copy (creds);
if (creds2 == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_assert (_dbus_credentials_include (creds2, DBUS_CREDENTIAL_UNIX_USER_ID));
_dbus_assert (_dbus_credentials_include (creds2, DBUS_CREDENTIAL_UNIX_PROCESS_ID));
/* Same user if both unix and windows are the same */
creds2 = make_credentials (12, DBUS_PID_UNSET, SAMPLE_SID);
if (creds2 == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_assert (_dbus_credentials_same_user (creds, creds2));
/* Not the same user if Windows is missing */
creds2 = make_credentials (12, DBUS_PID_UNSET, NULL);
if (creds2 == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_assert (!_dbus_credentials_same_user (creds, creds2));
_dbus_assert (_dbus_credentials_are_superset (creds, creds2));
/* Not the same user if Windows is different */
creds2 = make_credentials (12, DBUS_PID_UNSET, OTHER_SAMPLE_SID);
if (creds2 == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_assert (!_dbus_credentials_same_user (creds, creds2));
_dbus_assert (!_dbus_credentials_are_superset (creds, creds2));
/* Not the same user if Unix is missing */
creds2 = make_credentials (DBUS_UID_UNSET, DBUS_PID_UNSET, SAMPLE_SID);
if (creds2 == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_assert (!_dbus_credentials_same_user (creds, creds2));
_dbus_assert (_dbus_credentials_are_superset (creds, creds2));
/* Not the same user if Unix is different */
creds2 = make_credentials (15, DBUS_PID_UNSET, SAMPLE_SID);
if (creds2 == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_assert (!_dbus_credentials_same_user (creds, creds2));
_dbus_assert (!_dbus_credentials_are_superset (creds, creds2));
/* Not the same user if both are missing */
creds2 = make_credentials (DBUS_UID_UNSET, DBUS_PID_UNSET, NULL);
if (creds2 == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_assert (!_dbus_credentials_same_user (creds, creds2));
_dbus_assert (_dbus_credentials_are_superset (creds, creds2));
#include <config.h>
#include "dbus-dataslot.h"
#include "dbus-threads-internal.h"
+#include <dbus/dbus-test-tap.h>
/**
* @defgroup DBusDataSlot Data slots
void *old_data;
if (!_dbus_data_slot_allocator_init (&allocator, _DBUS_LOCK_server_slots))
- _dbus_assert_not_reached ("no memory for allocator");
+ _dbus_test_fatal ("no memory for allocator");
_dbus_data_slot_list_init (&list);
_dbus_data_slot_allocator_alloc (&allocator, &tmp);
if (tmp != i)
- _dbus_assert_not_reached ("did not allocate slots in numeric order");
+ _dbus_test_fatal ("did not allocate slots in numeric order");
++i;
}
_DBUS_INT_TO_POINTER (i),
test_free_slot_data_func,
&old_free_func, &old_data))
- _dbus_assert_not_reached ("no memory to set data");
+ _dbus_test_fatal ("no memory to set data");
_dbus_assert (old_free_func == NULL);
_dbus_assert (old_data == NULL);
_DBUS_INT_TO_POINTER (i),
test_free_slot_data_func,
&old_free_func, &old_data))
- _dbus_assert_not_reached ("no memory to set data");
+ _dbus_test_fatal ("no memory to set data");
_dbus_assert (old_free_func == test_free_slot_data_func);
_dbus_assert (_DBUS_POINTER_TO_INT (old_data) == i);
keys = dbus_new (char *, N_HASH_KEYS);
if (keys == NULL)
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
for (i = 0; i < N_HASH_KEYS; i++)
{
keys[i] = dbus_malloc (128);
if (keys[i] == NULL)
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
}
_dbus_test_diag ("Computing test hash keys...");
while (i >= 0)
{
if (!_dbus_hash_iter_lookup (table1, keys[i], FALSE, &iter))
- _dbus_assert_not_reached ("hash entry should have existed");
+ _dbus_test_fatal ("hash entry should have existed");
_dbus_hash_iter_remove_entry (&iter);
if (!_dbus_hash_iter_lookup (table2, _DBUS_INT_TO_POINTER (i), FALSE, &iter))
- _dbus_assert_not_reached ("hash entry should have existed");
+ _dbus_test_fatal ("hash entry should have existed");
_dbus_hash_iter_remove_entry (&iter);
_dbus_assert (count_entries (table1) == i);
_dbus_assert (!_dbus_keyring_validate_context (&context));
if (!_dbus_string_init (&context))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_append_byte (&context, '\0'))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
_dbus_assert (!_dbus_keyring_validate_context (&context));
_dbus_string_free (&context);
#include "dbus-list.h"
#include "dbus-mempool.h"
#include "dbus-threads-internal.h"
+#include <dbus/dbus-test-tap.h>
/**
* @defgroup DBusList Linked list
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for append");
-
+ _dbus_test_fatal ("could not allocate for append");
+
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("count not allocate for prepend");
+ _dbus_test_fatal ("count not allocate for prepend");
++i;
verify_list (&list1);
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for prepend");
+ _dbus_test_fatal ("could not allocate for prepend");
++i;
}
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for prepend");
+ _dbus_test_fatal ("could not allocate for prepend");
++i;
}
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for prepend");
+ _dbus_test_fatal ("could not allocate for prepend");
++i;
verify_list (&list1);
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for prepend");
+ _dbus_test_fatal ("could not allocate for prepend");
++i;
}
if ((i % 2) == 0)
{
if (!_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("element should have been in list");
+ _dbus_test_fatal ("element should have been in list");
if (!_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("element should have been in list");
+ _dbus_test_fatal ("element should have been in list");
verify_list (&list1);
verify_list (&list2);
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for prepend");
+ _dbus_test_fatal ("could not allocate for prepend");
++i;
}
if ((i % 2) != 0)
{
if (!_dbus_list_remove (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("element should have been in list");
+ _dbus_test_fatal ("element should have been in list");
if (!_dbus_list_remove (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("element should have been in list");
+ _dbus_test_fatal ("element should have been in list");
verify_list (&list1);
verify_list (&list2);
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for prepend");
+ _dbus_test_fatal ("could not allocate for prepend");
++i;
}
while (i < 10)
{
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_prepend (&list2, _DBUS_INT_TO_POINTER (i)))
- _dbus_assert_not_reached ("could not allocate for prepend");
+ _dbus_test_fatal ("could not allocate for prepend");
++i;
}
/* using remove_last */
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (2)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (1)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
if (!_dbus_list_append (&list1, _DBUS_INT_TO_POINTER (3)))
- _dbus_assert_not_reached ("could not allocate for append");
+ _dbus_test_fatal ("could not allocate for append");
_dbus_list_remove_last (&list1, _DBUS_INT_TO_POINTER (2));
#include "dbus-internals.h"
#include "dbus-marshal-basic.h"
#include "dbus-signature.h"
+#include <dbus/dbus-test-tap.h>
#include <string.h>
if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_##typename, \
&v_##typename, \
byte_order, NULL)) \
- _dbus_assert_not_reached ("no memory"); \
+ _dbus_test_fatal ("no memory"); \
} while (0)
#define DEMARSHAL_BASIC(typename, byte_order) \
{ \
_dbus_verbose_bytes_of_string (&str, dump_pos, \
_dbus_string_get_length (&str) - dump_pos); \
- _dbus_assert_not_reached ("demarshaled wrong value"); \
+ _dbus_test_fatal ("demarshaled wrong value"); \
} \
} while (0)
_dbus_verbose_bytes_of_string (&str, dump_pos, \
_dbus_string_get_length (&str) - dump_pos); \
_dbus_warn ("literal '%s'\nvalue '%s'", literal, v_##typename); \
- _dbus_assert_not_reached ("demarshaled wrong value"); \
+ _dbus_test_fatal ("demarshaled wrong value"); \
} \
} while (0)
v_UINT32 = sizeof(literal); \
if (!_dbus_marshal_write_basic (&str, pos, DBUS_TYPE_UINT32, &v_UINT32, \
byte_order, &next)) \
- _dbus_assert_not_reached ("no memory"); \
+ _dbus_test_fatal ("no memory"); \
v_ARRAY_##typename = literal; \
if (!_dbus_marshal_write_fixed_multi (&str, next, DBUS_TYPE_##typename, \
&v_ARRAY_##typename, _DBUS_N_ELEMENTS(literal), \
byte_order, NULL)) \
- _dbus_assert_not_reached ("no memory"); \
+ _dbus_test_fatal ("no memory"); \
} while (0)
#define DEMARSHAL_FIXED_ARRAY(typename, byte_order) \
_dbus_verbose_bytes ((const unsigned char *) literal, sizeof (literal), 0); \
_dbus_verbose ("READ DATA\n"); \
_dbus_verbose_bytes ((const unsigned char *) v_ARRAY_##typename, sizeof (literal), 0); \
- _dbus_assert_not_reached ("demarshaled wrong fixed array value"); \
+ _dbus_test_fatal ("demarshaled wrong fixed array value"); \
} \
} while (0)
int byte_order;
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
+ _dbus_test_fatal ("failed to init string");
pos = 0;
DEMARSHAL_BASIC (DOUBLE, DBUS_BIG_ENDIAN);
t_DOUBLE = 3.14;
if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
- _dbus_assert_not_reached ("got wrong double value");
+ _dbus_test_fatal ("got wrong double value");
MARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN, 3.14);
DEMARSHAL_BASIC (DOUBLE, DBUS_LITTLE_ENDIAN);
t_DOUBLE = 3.14;
if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
- _dbus_assert_not_reached ("got wrong double value");
+ _dbus_test_fatal ("got wrong double value");
/* Marshal signed 16 integers */
MARSHAL_TEST (INT16, DBUS_BIG_ENDIAN, -12345);
int opposite_order;
if (!_dbus_string_init (&signature) || !_dbus_string_init (&body))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
opposite_order = byte_order == DBUS_LITTLE_ENDIAN ? DBUS_BIG_ENDIAN : DBUS_LITTLE_ENDIAN;
DBusTypeReader copy_reader;
if (!_dbus_string_init (©))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
if (!_dbus_string_copy (&body, 0, ©, 0))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_marshal_byteswap (&signature, 0,
byte_order,
_dbus_verbose_bytes_of_string (&block->signature,
offset,
_dbus_string_get_length (&block->signature) - offset);
- _dbus_assert_not_reached ("block did not verify: bad bytes at end of signature");
+ _dbus_test_fatal ("block did not verify: bad bytes at end of signature");
}
if (!_dbus_string_ends_with_c_str (&block->body,
FENCE_BYTES_STR))
_dbus_verbose_bytes_of_string (&block->body,
offset,
_dbus_string_get_length (&block->body) - offset);
- _dbus_assert_not_reached ("block did not verify: bad bytes at end of body");
+ _dbus_test_fatal ("block did not verify: bad bytes at end of body");
}
_dbus_assert (_dbus_string_validate_nul (&block->signature,
_dbus_assert (node->klass->instance_size >= (int) sizeof (TestTypeNodeContainer));
if (!_dbus_list_append (&container->children, child))
- _dbus_assert_not_reached ("no memory"); /* we never check the return value on node_append_child anyhow - it's run from outside the malloc-failure test code */
+ _dbus_test_fatal ("no memory"); /* we never check the return value on node_append_child anyhow - it's run from outside the malloc-failure test code */
return TRUE;
}
_dbus_verbose ("DEST\n");
_dbus_verbose_bytes_of_string (&dest.signature, 0,
_dbus_string_get_length (&dest.signature));
- _dbus_assert_not_reached ("signatures did not match");
+ _dbus_test_fatal ("signatures did not match");
}
if (!_dbus_string_equal (&src->body, &dest.body))
_dbus_verbose ("DEST\n");
_dbus_verbose_bytes_of_string (&dest.body, 0,
_dbus_string_get_length (&dest.body));
- _dbus_assert_not_reached ("bodies did not match");
+ _dbus_test_fatal ("bodies did not match");
}
retval = TRUE;
while (elem > 0)
{
if (!_dbus_type_reader_next (&array))
- _dbus_assert_not_reached ("should have had another element");
+ _dbus_test_fatal ("should have had another element");
--elem;
}
NodeIterationData nid;
if (!data_block_init (&block, byte_order, initial_offset))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
nid.signature = signature;
nid.block = █
else
{
if (!run_test_nodes_iteration (&nid))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
}
data_block_free (&block);
DBusString signature;
if (!_dbus_string_init (&signature))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
i = 0;
while (i < n_nodes)
{
if (! node_build_signature (nodes[i], &signature))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
++i;
}
while (i < n_nodes)
{
if (! node_build_signature (nodes[i], signature))
- _dbus_assert_not_reached ("no memory");
-
+ _dbus_test_fatal ("no memory");
+
++i;
}
if (!data_block_init (&block, byte_order, 0))
- _dbus_assert_not_reached ("no memory");
-
+ _dbus_test_fatal ("no memory");
+
data_block_init_reader_writer (&block,
&reader, &writer);
*/
if (!_dbus_string_insert_byte (&block.signature,
0, '\0'))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
i = 0;
while (i < n_nodes)
{
if (!node_write_value (nodes[i], &block, &writer, i))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
++i;
}
if (!_dbus_string_copy_len (&block.body, 0,
_dbus_string_get_length (&block.body) - N_FENCE_BYTES,
body, 0))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
data_block_free (&block);
}
/* Validate claimed length longer than real length */
_dbus_string_init_const (&str, "abc.efg");
if (_dbus_validate_bus_name (&str, 0, 8))
- _dbus_assert_not_reached ("validated too-long string");
+ _dbus_test_fatal ("validated too-long string");
if (_dbus_validate_interface (&str, 0, 8))
- _dbus_assert_not_reached ("validated too-long string");
+ _dbus_test_fatal ("validated too-long string");
if (_dbus_validate_error_name (&str, 0, 8))
- _dbus_assert_not_reached ("validated too-long string");
+ _dbus_test_fatal ("validated too-long string");
_dbus_string_init_const (&str, "abc");
if (_dbus_validate_member (&str, 0, 4))
- _dbus_assert_not_reached ("validated too-long string");
+ _dbus_test_fatal ("validated too-long string");
/* Validate string exceeding max name length */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
if (!_dbus_string_append (&str, "abc.def"))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (_dbus_validate_bus_name (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
+ _dbus_test_fatal ("validated overmax string");
if (_dbus_validate_interface (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
+ _dbus_test_fatal ("validated overmax string");
if (_dbus_validate_error_name (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
+ _dbus_test_fatal ("validated overmax string");
/* overlong member */
_dbus_string_set_length (&str, 0);
while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
if (!_dbus_string_append (&str, "abc"))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (_dbus_validate_member (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
+ _dbus_test_fatal ("validated overmax string");
/* overlong unique name */
_dbus_string_set_length (&str, 0);
_dbus_string_append (&str, ":");
while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
if (!_dbus_string_append (&str, "abc"))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (_dbus_validate_bus_name (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
+ _dbus_test_fatal ("validated overmax string");
_dbus_string_free (&str);
DBusString body;
if (!_dbus_string_init (&signature) || !_dbus_string_init (&body))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
sequence = 0;
while (dbus_internal_do_not_use_generate_bodies (sequence,
validity, sequence);
_dbus_verbose_bytes_of_string (&signature, 0, _dbus_string_get_length (&signature));
_dbus_verbose_bytes_of_string (&body, 0, _dbus_string_get_length (&body));
- _dbus_assert_not_reached ("test failed");
+ _dbus_test_fatal ("test failed");
}
_dbus_string_set_length (&signature, 0);
validity, sequence);
_dbus_verbose_bytes_of_string (&signature, 0, _dbus_string_get_length (&signature));
_dbus_verbose_bytes_of_string (&body, 0, _dbus_string_get_length (&body));
- _dbus_assert_not_reached ("test failed");
+ _dbus_test_fatal ("test failed");
}
_dbus_string_set_length (&signature, 0);
#include "dbus-sysdeps.h"
#include "dbus-list.h"
#include "dbus-threads.h"
+#include <dbus/dbus-test-tap.h>
#include <stdlib.h>
/**
guards = TRUE;
p = dbus_malloc (4);
if (p == NULL)
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
for (size = 4; size < 256; size += 4)
{
p = dbus_realloc (p, size);
if (p == NULL)
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
}
for (size = 256; size != 0; size -= 4)
{
p = dbus_realloc (p, size);
if (p == NULL)
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
}
dbus_free (p);
guards = old_guards;
set_reply_serial (DBusMessage *message)
{
if (message == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
if (!dbus_message_set_reply_serial (message, 100))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
}
static dbus_bool_t
if (!dbus_message_set_error_name (message,
"org.freedesktop.TestErrorName"))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
{
DBusMessageIter iter2;
const char *v_STRING = "This is an error";
if (!dbus_message_iter_append_basic (&iter2,
DBUS_TYPE_STRING,
&v_STRING))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
}
set_reply_serial (message);
}
if (message == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
*message_p = message;
"o.z.B",
"Nah");
if (message == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
byte_order = _dbus_header_get_byte_order (&message->header);
set_reply_serial (message);
if (!_dbus_string_init (&signature) || !_dbus_string_init (&body))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
if (dbus_internal_do_not_use_generate_bodies (iter_get_sequence (iter),
byte_order,
&signature, &body))
DBUS_HEADER_FIELD_SIGNATURE,
DBUS_TYPE_SIGNATURE,
&v_SIGNATURE))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
if (!_dbus_string_move (&body, 0, &message->body, 0))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_marshal_set_uint32 (&message->header.data, BODY_LENGTH_OFFSET,
_dbus_string_get_length (&message->body),
/* move for efficiency, since we'll nuke the message anyway */
if (!_dbus_string_move (&message->header.data, 0,
data, 0))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
if (!_dbus_string_copy (&message->body, 0,
data, _dbus_string_get_length (data)))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
}
static dbus_bool_t
"o.b.Z",
"Fro");
if (message == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
return message;
}
"o.b.Z",
"Fro");
if (message == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
return message;
}
DBusMessage *message;
message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
if (message == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
set_reply_serial (message);
DBusMessage *message;
message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
if (message == NULL)
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
if (!dbus_message_set_error_name (message, "foo.bar"))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
set_reply_serial (message);
return message;
DBUS_TYPE_INT32_AS_STRING :
DBUS_TYPE_VARIANT_AS_STRING,
&children[i]))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
++i;
parents[i] = children[i-1];
}
--i;
if (!dbus_message_iter_append_basic (&children[i], DBUS_TYPE_INT32, &v_INT32))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
while (i >= 0)
{
if (!dbus_message_iter_close_container (&parents[i], &children[i]))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
--i;
}
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
i = 0;
while (i < (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))
DBUS_HEADER_FIELD_SIGNATURE,
DBUS_TYPE_SIGNATURE,
&v_STRING))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
i = 0;
while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))
DBUS_HEADER_FIELD_SIGNATURE,
DBUS_TYPE_SIGNATURE,
&v_STRING))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
if (!_dbus_header_set_field_basic (&message->header,
DBUS_HEADER_FIELD_SENDER,
DBUS_TYPE_STRING, &v_STRING))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_BAD_SENDER;
message = simple_method_call ();
if (!dbus_message_set_interface (message, DBUS_INTERFACE_LOCAL))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_USES_LOCAL_INTERFACE;
message = simple_method_call ();
if (!dbus_message_set_path (message, DBUS_PATH_LOCAL))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_USES_LOCAL_PATH;
message = simple_method_call ();
if (!dbus_message_set_interface (message, NULL))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_VALID;
message = simple_signal ();
if (!dbus_message_set_interface (message, NULL))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_MISSING_INTERFACE;
message = simple_method_return ();
if (!_dbus_header_delete_field (&message->header, DBUS_HEADER_FIELD_REPLY_SERIAL))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_MISSING_REPLY_SERIAL;
message = simple_error ();
if (!dbus_message_set_error_name (message, NULL))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_MISSING_ERROR_NAME;
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
i = 0;
while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*3 + 3))
DBUS_HEADER_FIELD_SIGNATURE,
DBUS_TYPE_SIGNATURE,
&v_STRING))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
else
{
if (!_dbus_string_lengthen (data, adjust))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
*expected_validity = DBUS_INVALID_TOO_MUCH_DATA;
}
func = generators[generator].func;
if (!_dbus_string_init (&data->data))
- _dbus_assert_not_reached ("oom");
-
+ _dbus_test_fatal ("oom");
+
if ((*func)(iter, &data->data, &data->expected_validity))
;
else
DBusValidity expected_validity)
{
if (!_dbus_message_loader_queue_messages (loader))
- _dbus_assert_not_reached ("no memory to queue messages");
+ _dbus_test_fatal ("no memory to queue messages");
if (expected_validity == DBUS_VALID)
return check_have_valid_message (loader);
retval = FALSE;
if (!_dbus_string_init (&data))
- _dbus_assert_not_reached ("could not allocate string");
+ _dbus_test_fatal ("could not allocate string");
if (!dbus_internal_do_not_use_load_message_file (filename, &data))
goto failed;
dir = NULL;
if (!_dbus_string_init (&test_directory))
- _dbus_assert_not_reached ("didn't allocate test_directory");
+ _dbus_test_fatal ("didn't allocate test_directory");
_dbus_string_init_const (&filename, subdir);
if (!_dbus_string_copy (test_base_dir, 0,
&test_directory, 0))
- _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
+ _dbus_test_fatal ("couldn't copy test_base_dir to test_directory");
if (!_dbus_concat_dir_and_file (&test_directory, &filename))
- _dbus_assert_not_reached ("couldn't allocate full path");
+ _dbus_test_fatal ("couldn't allocate full path");
_dbus_string_free (&filename);
if (!_dbus_string_init (&filename))
- _dbus_assert_not_reached ("didn't allocate filename string");
+ _dbus_test_fatal ("didn't allocate filename string");
dir = _dbus_directory_open (&test_directory, &error);
if (dir == NULL)
DBusString full_path;
if (!_dbus_string_init (&full_path))
- _dbus_assert_not_reached ("couldn't init string");
+ _dbus_test_fatal ("couldn't init string");
if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
- _dbus_assert_not_reached ("couldn't copy dir to full_path");
+ _dbus_test_fatal ("couldn't copy dir to full_path");
if (!_dbus_concat_dir_and_file (&full_path, &filename))
- _dbus_assert_not_reached ("couldn't concat file to dir");
+ _dbus_test_fatal ("couldn't concat file to dir");
if (_dbus_string_ends_with_c_str (&filename, ".message-raw"))
;
#define GET_AND_CHECK(iter, typename, literal) \
do { \
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename) \
- _dbus_assert_not_reached ("got wrong argument type from message iter"); \
+ _dbus_test_fatal ("got wrong argument type from message iter"); \
dbus_message_iter_get_basic (&iter, &v_##typename); \
if (v_##typename != literal) \
- _dbus_assert_not_reached ("got wrong value from message iter"); \
+ _dbus_test_fatal ("got wrong value from message iter"); \
} while (0)
#define GET_AND_CHECK_STRCMP(iter, typename, literal) \
do { \
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_##typename) \
- _dbus_assert_not_reached ("got wrong argument type from message iter"); \
+ _dbus_test_fatal ("got wrong argument type from message iter"); \
dbus_message_iter_get_basic (&iter, &v_##typename); \
if (strcmp (v_##typename, literal) != 0) \
- _dbus_assert_not_reached ("got wrong value from message iter"); \
+ _dbus_test_fatal ("got wrong value from message iter"); \
} while (0)
#define GET_AND_CHECK_AND_NEXT(iter, typename, literal) \
do { \
GET_AND_CHECK(iter, typename, literal); \
if (!dbus_message_iter_next (&iter)) \
- _dbus_assert_not_reached ("failed to move iter to next"); \
+ _dbus_test_fatal ("failed to move iter to next"); \
} while (0)
#define GET_AND_CHECK_STRCMP_AND_NEXT(iter, typename, literal) \
do { \
GET_AND_CHECK_STRCMP(iter, typename, literal); \
if (!dbus_message_iter_next (&iter)) \
- _dbus_assert_not_reached ("failed to move iter to next"); \
+ _dbus_test_fatal ("failed to move iter to next"); \
} while (0)
static void
GET_AND_CHECK_AND_NEXT (iter, DOUBLE, 3.14159);
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
- _dbus_assert_not_reached ("Argument type not an array");
+ _dbus_test_fatal ("Argument type not an array");
if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_DOUBLE)
- _dbus_assert_not_reached ("Array type not double");
+ _dbus_test_fatal ("Array type not double");
dbus_message_iter_recurse (&iter, &array);
GET_AND_CHECK (array, DOUBLE, 2.5);
if (dbus_message_iter_next (&array))
- _dbus_assert_not_reached ("Didn't reach end of array");
+ _dbus_test_fatal ("Didn't reach end of array");
if (!dbus_message_iter_next (&iter))
- _dbus_assert_not_reached ("Reached end of arguments");
+ _dbus_test_fatal ("Reached end of arguments");
GET_AND_CHECK_AND_NEXT (iter, BYTE, 0xF0);
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY)
- _dbus_assert_not_reached ("no array");
+ _dbus_test_fatal ("no array");
if (dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_INT32)
- _dbus_assert_not_reached ("Array type not int32");
+ _dbus_test_fatal ("Array type not int32");
/* Empty array */
dbus_message_iter_recurse (&iter, &array);
if (dbus_message_iter_next (&array))
- _dbus_assert_not_reached ("Didn't reach end of array");
+ _dbus_test_fatal ("Didn't reach end of array");
if (!dbus_message_iter_next (&iter))
- _dbus_assert_not_reached ("Reached end of arguments");
+ _dbus_test_fatal ("Reached end of arguments");
GET_AND_CHECK (iter, BYTE, 0xF0);
if (dbus_message_iter_next (&iter))
- _dbus_assert_not_reached ("Didn't reach end of arguments");
+ _dbus_test_fatal ("Didn't reach end of arguments");
}
#endif
&our_string_array, &our_string_array_len,
0))
{
- _dbus_warn ("error: %s - %s", error.name,
+ _dbus_test_fatal ("Could not get arguments: %s - %s", error.name,
(error.message != NULL) ? error.message : "no message");
- _dbus_assert_not_reached ("Could not get arguments");
}
if (our_int16 != -0x123)
- _dbus_assert_not_reached ("16-bit integers differ!");
+ _dbus_test_fatal ("16-bit integers differ!");
if (our_uint16 != 0x123)
- _dbus_assert_not_reached ("16-bit uints differ!");
+ _dbus_test_fatal ("16-bit uints differ!");
if (our_int != -0x12345678)
- _dbus_assert_not_reached ("integers differ!");
+ _dbus_test_fatal ("integers differ!");
if (our_uint != 0x12300042)
- _dbus_assert_not_reached ("uints differ!");
+ _dbus_test_fatal ("uints differ!");
if (our_int64 != DBUS_INT64_CONSTANT (-0x123456789abcd))
- _dbus_assert_not_reached ("64-bit integers differ!");
+ _dbus_test_fatal ("64-bit integers differ!");
if (our_uint64 != DBUS_UINT64_CONSTANT (0x123456789abcd))
- _dbus_assert_not_reached ("64-bit unsigned integers differ!");
+ _dbus_test_fatal ("64-bit unsigned integers differ!");
v_DOUBLE = 3.14159;
if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double, v_DOUBLE))
- _dbus_assert_not_reached ("doubles differ!");
+ _dbus_test_fatal ("doubles differ!");
if (strcmp (our_str, "Test string") != 0)
- _dbus_assert_not_reached ("strings differ!");
+ _dbus_test_fatal ("strings differ!");
if (!our_bool)
- _dbus_assert_not_reached ("booleans differ");
+ _dbus_test_fatal ("booleans differ");
if (our_byte_1 != 42)
- _dbus_assert_not_reached ("bytes differ!");
+ _dbus_test_fatal ("bytes differ!");
if (our_byte_2 != 24)
- _dbus_assert_not_reached ("bytes differ!");
+ _dbus_test_fatal ("bytes differ!");
if (our_uint32_array_len != 4 ||
our_uint32_array[0] != 0x12345678 ||
our_uint32_array[1] != 0x23456781 ||
our_uint32_array[2] != 0x34567812 ||
our_uint32_array[3] != 0x45678123)
- _dbus_assert_not_reached ("uint array differs");
+ _dbus_test_fatal ("uint array differs");
if (our_int32_array_len != 4 ||
our_int32_array[0] != 0x12345678 ||
our_int32_array[1] != -0x23456781 ||
our_int32_array[2] != 0x34567812 ||
our_int32_array[3] != -0x45678123)
- _dbus_assert_not_reached ("int array differs");
+ _dbus_test_fatal ("int array differs");
if (our_uint64_array_len != 4 ||
our_uint64_array[0] != 0x12345678 ||
our_uint64_array[1] != 0x23456781 ||
our_uint64_array[2] != 0x34567812 ||
our_uint64_array[3] != 0x45678123)
- _dbus_assert_not_reached ("uint64 array differs");
+ _dbus_test_fatal ("uint64 array differs");
if (our_int64_array_len != 4 ||
our_int64_array[0] != 0x12345678 ||
our_int64_array[1] != -0x23456781 ||
our_int64_array[2] != 0x34567812 ||
our_int64_array[3] != -0x45678123)
- _dbus_assert_not_reached ("int64 array differs");
+ _dbus_test_fatal ("int64 array differs");
if (our_double_array_len != 3)
- _dbus_assert_not_reached ("double array had wrong length");
+ _dbus_test_fatal ("double array had wrong length");
/* On all IEEE machines (i.e. everything sane) exact equality
* should be preserved over the wire
*/
v_DOUBLE = 0.1234;
if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[0], v_DOUBLE))
- _dbus_assert_not_reached ("double array had wrong values");
+ _dbus_test_fatal ("double array had wrong values");
v_DOUBLE = 9876.54321;
if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[1], v_DOUBLE))
- _dbus_assert_not_reached ("double array had wrong values");
+ _dbus_test_fatal ("double array had wrong values");
v_DOUBLE = -300.0;
if (! _DBUS_DOUBLES_BITWISE_EQUAL (our_double_array[2], v_DOUBLE))
- _dbus_assert_not_reached ("double array had wrong values");
+ _dbus_test_fatal ("double array had wrong values");
if (our_byte_array_len != 4)
- _dbus_assert_not_reached ("byte array had wrong length");
+ _dbus_test_fatal ("byte array had wrong length");
if (our_byte_array[0] != 'a' ||
our_byte_array[1] != 'b' ||
our_byte_array[2] != 'c' ||
our_byte_array[3] != 234)
- _dbus_assert_not_reached ("byte array had wrong values");
+ _dbus_test_fatal ("byte array had wrong values");
if (our_boolean_array_len != 5)
- _dbus_assert_not_reached ("bool array had wrong length");
+ _dbus_test_fatal ("bool array had wrong length");
if (our_boolean_array[0] != TRUE ||
our_boolean_array[1] != FALSE ||
our_boolean_array[2] != TRUE ||
our_boolean_array[3] != TRUE ||
our_boolean_array[4] != FALSE)
- _dbus_assert_not_reached ("bool array had wrong values");
+ _dbus_test_fatal ("bool array had wrong values");
if (our_string_array_len != 4)
- _dbus_assert_not_reached ("string array was wrong length");
+ _dbus_test_fatal ("string array was wrong length");
if (strcmp (our_string_array[0], "Foo") != 0 ||
strcmp (our_string_array[1], "bar") != 0 ||
strcmp (our_string_array[2], "") != 0 ||
strcmp (our_string_array[3], "woo woo woo woo") != 0)
- _dbus_assert_not_reached ("string array had wrong values");
+ _dbus_test_fatal ("string array had wrong values");
dbus_free_string_array (our_string_array);
if (dbus_message_iter_next (&iter))
- _dbus_assert_not_reached ("Didn't reach end of arguments");
+ _dbus_test_fatal ("Didn't reach end of arguments");
}
static void
}
else
{
- _dbus_warn ("error: parse with wrong signature: 'uashuu'.");
+ _dbus_test_fatal ("error: parse with wrong signature: 'uashuu'.");
}
/* parse with wrong signature: "uashuashu" */
}
else
{
- _dbus_warn ("error: parse with wrong signature: 'uashuashu'.");
+ _dbus_test_fatal ("error: parse with wrong signature: 'uashuashu'.");
}
/* parse with correct signature: "uashuash" */
/* string length including nul byte not a multiple of 4 */
if (!dbus_message_set_sender (message, "org.foo.bar1"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
dbus_message_set_reply_serial (message, 5678);
_dbus_string_get_length (&message->body));
if (!dbus_message_set_sender (message, NULL))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
/* Set/get some header fields */
if (!dbus_message_set_path (message, "/foo"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Set/get them with longer values */
if (!dbus_message_set_path (message, "/foo/bar"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo/bar") == 0);
if (!dbus_message_set_interface (message, "org.Foo.Bar"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo.Bar") == 0);
if (!dbus_message_set_member (message, "BarFoo"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"BarFoo") == 0);
/* Realloc shorter again */
if (!dbus_message_set_path (message, "/foo"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Now pop back the message */
if (!_dbus_message_loader_queue_messages (loader))
- _dbus_assert_not_reached ("no memory to queue messages");
+ _dbus_test_fatal ("no memory to queue messages");
if (_dbus_message_loader_get_is_corrupted (loader))
- _dbus_assert_not_reached ("message loader corrupted");
+ _dbus_test_fatal ("message loader corrupted");
message = _dbus_message_loader_pop_message (loader);
if (!message)
- _dbus_assert_not_reached ("received a NULL message");
+ _dbus_test_fatal ("received a NULL message");
if (dbus_message_get_reply_serial (message) != 5678)
- _dbus_assert_not_reached ("reply serial fields differ");
+ _dbus_test_fatal ("reply serial fields differ");
dbus_message_unref (message);
char garbage_header[DBUS_MINIMUM_HEADER_SIZE] = "xxx";
if (!dbus_message_marshal (message_without_unix_fds, &marshalled, &len))
- _dbus_assert_not_reached ("failed to marshal message");
+ _dbus_test_fatal ("failed to marshal message");
_dbus_assert (len != 0);
_dbus_assert (marshalled != NULL);
(DBusForeachMessageFileFunc)
dbus_internal_do_not_use_try_message_file,
NULL))
- _dbus_assert_not_reached ("foreach_message_file test failed");
+ _dbus_test_fatal ("foreach_message_file test failed");
_dbus_check_fdleaks_leave (initial_fds);
#include "dbus-misc.h"
#include "dbus-internals.h"
#include "dbus-string.h"
+#include <dbus/dbus-test-tap.h>
/**
* @defgroup DBusMisc Miscellaneous
/* Check DBUS_VERSION_STRING */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!(_dbus_string_append_int (&str, major) &&
_dbus_string_append_byte (&str, '.') &&
_dbus_string_append_int (&str, minor) &&
_dbus_string_append_byte (&str, '.') &&
_dbus_string_append_int (&str, micro)))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
_dbus_assert (_dbus_string_equal_c_str (&str, DBUS_VERSION_STRING));
#include "dbus-hash.h"
#include "dbus-protocol.h"
#include "dbus-string.h"
+#include <dbus/dbus-test-tap.h>
#include <string.h>
#include <stdlib.h>
++i;
}
_dbus_warn ("}");
- _dbus_assert_not_reached ("path decompose failed");
+ _dbus_test_fatal ("path decompose failed");
}
dbus_free_string_array (result);
_dbus_string_init_const (&expected_str, expected);
if (!_dbus_string_init (&results))
- _dbus_assert_not_reached ("no memory for SHA-1 results");
+ _dbus_test_fatal ("no memory for SHA-1 results");
if (!_dbus_sha_compute (&input_str, &results))
- _dbus_assert_not_reached ("no memory for SHA-1 results");
+ _dbus_test_fatal ("no memory for SHA-1 results");
if (!_dbus_string_equal (&expected_str, &results))
{
if (byte_containing_next_bit >= _dbus_string_get_length (decoded))
{
if (!_dbus_string_set_length (decoded, byte_containing_next_bit + 1))
- _dbus_assert_not_reached ("no memory to extend to next byte");
+ _dbus_test_fatal ("no memory to extend to next byte");
}
old_byte = _dbus_string_get_byte (decoded, byte_containing_next_bit);
retval = FALSE;
if (!_dbus_string_init (&line))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
next_iteration:
while (_dbus_string_pop_line (results, &line))
int i;
if (!_dbus_string_move (&line, 0, result, 0))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
i = 0;
while (i < _dbus_string_get_length (result))
break;
default:
if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
- _dbus_assert_not_reached ("invalid SHA-1 test script");
+ _dbus_test_fatal ("invalid SHA-1 test script");
}
++i;
retval = FALSE;
if (!_dbus_string_init (&tests_file))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_init (&results_file))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_init (&tests))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_init (&results))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_init (&line))
- _dbus_assert_not_reached ("no memory");
-
+ _dbus_test_fatal ("no memory");
+
if (!_dbus_string_append (&tests_file, test_data_dir))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_append (&results_file, test_data_dir))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
_dbus_string_init_const (&tmp, "sha-1/byte-messages.sha1");
if (!_dbus_concat_dir_and_file (&tests_file, &tmp))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
_dbus_string_init_const (&tmp, "sha-1/byte-hashes.sha1");
if (!_dbus_concat_dir_and_file (&results_file, &tmp))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_file_get_contents (&tests, &tests_file, &error))
{
success = FALSE;
if (!_dbus_string_init (&next_line))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_init (&expected))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_init (&test))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_init (&result))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
/* the "compact strings" are "^"-terminated not
* newline-terminated so readahead to find the
if (!_dbus_string_append_byte (&line, ' ') ||
!_dbus_string_move (&next_line, 0, &line,
_dbus_string_get_length (&line)))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
}
if (!decode_compact_string (&line, &test))
}
if (!_dbus_sha_compute (&test, &result))
- _dbus_assert_not_reached ("no memory for SHA-1 result");
+ _dbus_test_fatal ("no memory for SHA-1 result");
if (!get_next_expected_result (&results, &expected))
{
#include "dbus-marshal-basic.h"
#include "dbus-internals.h"
#include "dbus-test.h"
+#include <dbus/dbus-test-tap.h>
/**
* Implementation details of #DBusSignatureIter, all fields are private
return TRUE;
#if 0
oom:
- _dbus_assert_not_reached ("out of memory");
+ _dbus_test_fatal ("out of memory");
return FALSE;
#endif
}
len = strlen (data);
if (!_dbus_string_init (&orig))
- _dbus_assert_not_reached ("could not init string");
+ _dbus_test_fatal ("could not init string");
if (!_dbus_string_init (&encoded))
- _dbus_assert_not_reached ("could not init string");
+ _dbus_test_fatal ("could not init string");
if (!_dbus_string_init (&decoded))
- _dbus_assert_not_reached ("could not init string");
+ _dbus_test_fatal ("could not init string");
if (!_dbus_string_append_len (&orig, data, len))
- _dbus_assert_not_reached ("couldn't append orig data");
+ _dbus_test_fatal ("couldn't append orig data");
if (!_dbus_string_hex_encode (&orig, 0, &encoded, 0))
- _dbus_assert_not_reached ("could not encode");
+ _dbus_test_fatal ("could not encode");
if (!_dbus_string_hex_decode (&encoded, 0, &end, &decoded, 0))
- _dbus_assert_not_reached ("could not decode");
+ _dbus_test_fatal ("could not decode");
_dbus_assert (_dbus_string_get_length (&encoded) == end);
if (!_dbus_string_equal (&orig, &decoded))
{
const char *s;
-
_dbus_test_diag ("Original string %d bytes encoded %d bytes decoded %d bytes",
_dbus_string_get_length (&orig),
int j;
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
+ _dbus_test_fatal ("failed to init string");
if (!_dbus_string_set_length (&str, lens[i]))
- _dbus_assert_not_reached ("failed to set string length");
+ _dbus_test_fatal ("failed to set string length");
j = lens[i];
while (j > 0)
/* Test equality */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("oom");
+ _dbus_test_fatal ("oom");
_dbus_string_init_const (&other, "H");
_dbus_assert (_dbus_string_equal_substring (&str, 0, 1, &other, 0));
/* Test appending data */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
+ _dbus_test_fatal ("failed to init string");
i = 0;
while (i < 10)
{
if (!_dbus_string_append (&str, "a"))
- _dbus_assert_not_reached ("failed to append string to string");
+ _dbus_test_fatal ("failed to append string to string");
_dbus_assert (_dbus_string_get_length (&str) == i * 2 + 1);
if (!_dbus_string_append_byte (&str, 'b'))
- _dbus_assert_not_reached ("failed to append byte to string");
+ _dbus_test_fatal ("failed to append byte to string");
_dbus_assert (_dbus_string_get_length (&str) == i * 2 + 2);
/* Check steal_data */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
+ _dbus_test_fatal ("failed to init string");
if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
+ _dbus_test_fatal ("could not append to string");
i = _dbus_string_get_length (&str);
if (!_dbus_string_steal_data (&str, &s))
- _dbus_assert_not_reached ("failed to steal data");
+ _dbus_test_fatal ("failed to steal data");
_dbus_assert (_dbus_string_get_length (&str) == 0);
_dbus_assert (((int)strlen (s)) == i);
/* Check move */
if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
+ _dbus_test_fatal ("could not append to string");
i = _dbus_string_get_length (&str);
if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
+ _dbus_test_fatal ("could not init string");
if (!_dbus_string_move (&str, 0, &other, 0))
- _dbus_assert_not_reached ("could not move");
+ _dbus_test_fatal ("could not move");
_dbus_assert (_dbus_string_get_length (&str) == 0);
_dbus_assert (_dbus_string_get_length (&other) == i);
if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
+ _dbus_test_fatal ("could not append to string");
if (!_dbus_string_move (&str, 0, &other, _dbus_string_get_length (&other)))
- _dbus_assert_not_reached ("could not move");
+ _dbus_test_fatal ("could not move");
_dbus_assert (_dbus_string_get_length (&str) == 0);
_dbus_assert (_dbus_string_get_length (&other) == i * 2);
if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
+ _dbus_test_fatal ("could not append to string");
if (!_dbus_string_move (&str, 0, &other, _dbus_string_get_length (&other) / 2))
- _dbus_assert_not_reached ("could not move");
+ _dbus_test_fatal ("could not move");
_dbus_assert (_dbus_string_get_length (&str) == 0);
_dbus_assert (_dbus_string_get_length (&other) == i * 3);
/* Check copy */
if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
+ _dbus_test_fatal ("could not append to string");
i = _dbus_string_get_length (&str);
if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
-
+ _dbus_test_fatal ("could not init string");
+
if (!_dbus_string_copy (&str, 0, &other, 0))
- _dbus_assert_not_reached ("could not copy");
+ _dbus_test_fatal ("could not copy");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == i);
if (!_dbus_string_copy (&str, 0, &other, _dbus_string_get_length (&other)))
- _dbus_assert_not_reached ("could not copy");
+ _dbus_test_fatal ("could not copy");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == i * 2);
"Hello WorldHello World"));
if (!_dbus_string_copy (&str, 0, &other, _dbus_string_get_length (&other) / 2))
- _dbus_assert_not_reached ("could not copy");
+ _dbus_test_fatal ("could not copy");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == i * 3);
/* Check replace */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
+ _dbus_test_fatal ("failed to init string");
+
if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
+ _dbus_test_fatal ("could not append to string");
i = _dbus_string_get_length (&str);
if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
-
+ _dbus_test_fatal ("could not init string");
+
if (!_dbus_string_replace_len (&str, 0, _dbus_string_get_length (&str),
&other, 0, _dbus_string_get_length (&other)))
- _dbus_assert_not_reached ("could not replace");
+ _dbus_test_fatal ("could not replace");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == i);
if (!_dbus_string_replace_len (&str, 0, _dbus_string_get_length (&str),
&other, 5, 1))
- _dbus_assert_not_reached ("could not replace center space");
+ _dbus_test_fatal ("could not replace center space");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == i * 2 - 1);
&other,
_dbus_string_get_length (&other) - 1,
1))
- _dbus_assert_not_reached ("could not replace end character");
-
+ _dbus_test_fatal ("could not replace end character");
+
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == i * 2 - 1);
_dbus_assert (_dbus_string_equal_c_str (&other,
*/
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
+ _dbus_test_fatal ("failed to init string");
+
if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
+ _dbus_test_fatal ("could not append to string");
i = _dbus_string_get_length (&str);
if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
+ _dbus_test_fatal ("could not init string");
if (!_dbus_string_append (&other, "Foo String"))
- _dbus_assert_not_reached ("could not append to string");
+ _dbus_test_fatal ("could not append to string");
a = _dbus_string_get_length (&other);
if (!_dbus_string_replace_len (&str, 0, 6,
&other, 4, 0))
- _dbus_assert_not_reached ("could not replace 0 length");
+ _dbus_test_fatal ("could not replace 0 length");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == a + 6);
&other,
_dbus_string_get_length (&other),
0))
- _dbus_assert_not_reached ("could not replace at the end");
+ _dbus_test_fatal ("could not replace at the end");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == a + 6 + 6);
&other,
_dbus_string_get_length (&other) - 5,
5))
- _dbus_assert_not_reached ("could not replace same length");
+ _dbus_test_fatal ("could not replace same length");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == a + 6 + 6);
if (!_dbus_string_replace_len (&str, 6, 5,
&other, 4, 12))
- _dbus_assert_not_reached ("could not replace with shorter string");
+ _dbus_test_fatal ("could not replace with shorter string");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == a + 5);
if (!_dbus_string_replace_len (&str, 0, 1,
&other, 0, 3))
- _dbus_assert_not_reached ("could not replace at the beginning");
+ _dbus_test_fatal ("could not replace at the beginning");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == a + 3);
&other,
_dbus_string_get_length (&other) - 5,
5))
- _dbus_assert_not_reached ("could not replace same length");
+ _dbus_test_fatal ("could not replace same length");
_dbus_assert (_dbus_string_get_length (&str) == i);
_dbus_assert (_dbus_string_get_length (&other) == a + 3);
/* Check insert/set/get byte */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
+ _dbus_test_fatal ("failed to init string");
if (!_dbus_string_append (&str, "Hello"))
- _dbus_assert_not_reached ("failed to append Hello");
+ _dbus_test_fatal ("failed to append Hello");
_dbus_assert (_dbus_string_get_byte (&str, 0) == 'H');
_dbus_assert (_dbus_string_get_byte (&str, 1) == 'e');
_dbus_assert (_dbus_string_get_byte (&str, 1) == 'q');
if (!_dbus_string_insert_bytes (&str, 0, 1, 255))
- _dbus_assert_not_reached ("can't insert byte");
+ _dbus_test_fatal ("can't insert byte");
if (!_dbus_string_insert_bytes (&str, 2, 4, 'Z'))
- _dbus_assert_not_reached ("can't insert byte");
+ _dbus_test_fatal ("can't insert byte");
if (!_dbus_string_insert_bytes (&str, _dbus_string_get_length (&str), 1, 'W'))
- _dbus_assert_not_reached ("can't insert byte");
-
+ _dbus_test_fatal ("can't insert byte");
+
_dbus_assert (_dbus_string_get_byte (&str, 0) == 255);
_dbus_assert (_dbus_string_get_byte (&str, 1) == 'H');
_dbus_assert (_dbus_string_get_byte (&str, 2) == 'Z');
/* Check append/parse int/double */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
+ _dbus_test_fatal ("failed to init string");
if (!_dbus_string_append_int (&str, 27))
- _dbus_assert_not_reached ("failed to append int");
+ _dbus_test_fatal ("failed to append int");
i = _dbus_string_get_length (&str);
if (!_dbus_string_parse_int (&str, 0, &v, &end))
- _dbus_assert_not_reached ("failed to parse int");
+ _dbus_test_fatal ("failed to parse int");
_dbus_assert (v == 27);
_dbus_assert (end == i);
/* Test find */
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
+ _dbus_test_fatal ("failed to init string");
if (!_dbus_string_append (&str, "Hello"))
- _dbus_assert_not_reached ("couldn't append to string");
+ _dbus_test_fatal ("couldn't append to string");
if (!_dbus_string_find (&str, 0, "He", &i))
- _dbus_assert_not_reached ("didn't find 'He'");
+ _dbus_test_fatal ("didn't find 'He'");
_dbus_assert (i == 0);
if (!_dbus_string_find (&str, 0, "Hello", &i))
- _dbus_assert_not_reached ("didn't find 'Hello'");
+ _dbus_test_fatal ("didn't find 'Hello'");
_dbus_assert (i == 0);
if (!_dbus_string_find (&str, 0, "ello", &i))
- _dbus_assert_not_reached ("didn't find 'ello'");
+ _dbus_test_fatal ("didn't find 'ello'");
_dbus_assert (i == 1);
if (!_dbus_string_find (&str, 0, "lo", &i))
- _dbus_assert_not_reached ("didn't find 'lo'");
+ _dbus_test_fatal ("didn't find 'lo'");
_dbus_assert (i == 3);
if (!_dbus_string_find (&str, 2, "lo", &i))
- _dbus_assert_not_reached ("didn't find 'lo'");
+ _dbus_test_fatal ("didn't find 'lo'");
_dbus_assert (i == 3);
if (_dbus_string_find (&str, 4, "lo", &i))
- _dbus_assert_not_reached ("did find 'lo'");
+ _dbus_test_fatal ("did find 'lo'");
if (!_dbus_string_find (&str, 0, "l", &i))
- _dbus_assert_not_reached ("didn't find 'l'");
+ _dbus_test_fatal ("didn't find 'l'");
_dbus_assert (i == 2);
if (!_dbus_string_find (&str, 0, "H", &i))
- _dbus_assert_not_reached ("didn't find 'H'");
+ _dbus_test_fatal ("didn't find 'H'");
_dbus_assert (i == 0);
if (!_dbus_string_find (&str, 0, "", &i))
- _dbus_assert_not_reached ("didn't find ''");
+ _dbus_test_fatal ("didn't find ''");
_dbus_assert (i == 0);
if (_dbus_string_find (&str, 0, "Hello!", NULL))
- _dbus_assert_not_reached ("Did find 'Hello!'");
+ _dbus_test_fatal ("Did find 'Hello!'");
if (_dbus_string_find (&str, 0, "Oh, Hello", NULL))
- _dbus_assert_not_reached ("Did find 'Oh, Hello'");
+ _dbus_test_fatal ("Did find 'Oh, Hello'");
if (_dbus_string_find (&str, 0, "ill", NULL))
- _dbus_assert_not_reached ("Did find 'ill'");
+ _dbus_test_fatal ("Did find 'ill'");
if (_dbus_string_find (&str, 0, "q", NULL))
- _dbus_assert_not_reached ("Did find 'q'");
+ _dbus_test_fatal ("Did find 'q'");
if (!_dbus_string_find_to (&str, 0, 2, "He", NULL))
- _dbus_assert_not_reached ("Didn't find 'He'");
+ _dbus_test_fatal ("Didn't find 'He'");
if (_dbus_string_find_to (&str, 0, 2, "Hello", NULL))
- _dbus_assert_not_reached ("Did find 'Hello'");
+ _dbus_test_fatal ("Did find 'Hello'");
if (!_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str), 'H', &i))
- _dbus_assert_not_reached ("Did not find 'H'");
+ _dbus_test_fatal ("Did not find 'H'");
_dbus_assert (i == 0);
if (!_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str), 'o', &i))
- _dbus_assert_not_reached ("Did not find 'o'");
+ _dbus_test_fatal ("Did not find 'o'");
_dbus_assert (i == _dbus_string_get_length (&str) - 1);
if (_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str) - 1, 'o', &i))
- _dbus_assert_not_reached ("Did find 'o'");
+ _dbus_test_fatal ("Did find 'o'");
_dbus_assert (i == -1);
if (_dbus_string_find_byte_backward (&str, 1, 'e', &i))
- _dbus_assert_not_reached ("Did find 'e'");
+ _dbus_test_fatal ("Did find 'e'");
_dbus_assert (i == -1);
if (!_dbus_string_find_byte_backward (&str, 2, 'e', &i))
- _dbus_assert_not_reached ("Didn't find 'e'");
+ _dbus_test_fatal ("Didn't find 'e'");
_dbus_assert (i == 1);
_dbus_string_free (&str);
/* Hex encoding */
_dbus_string_init_const (&str, "cafebabe, this is a bogus hex string");
if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
+ _dbus_test_fatal ("could not init string");
if (!_dbus_string_hex_decode (&str, 0, &end, &other, 0))
- _dbus_assert_not_reached ("deccoded bogus hex string with no error");
+ _dbus_test_fatal ("deccoded bogus hex string with no error");
_dbus_assert (end == 8);
_dbus_string_init_const (&str, "012\r\n567\n90");
if (!_dbus_string_find_eol (&str, 0, &found, &found_len) || found != 3 || found_len != 2)
- _dbus_assert_not_reached ("Did not find '\\r\\n'");
- if (found != 3 || found_len != 2)
- _dbus_assert_not_reached ("invalid return values");
-
- if (!_dbus_string_find_eol (&str, 5, &found, &found_len))
- _dbus_assert_not_reached ("Did not find '\\n'");
- if (found != 8 || found_len != 1)
- _dbus_assert_not_reached ("invalid return values");
-
- if (_dbus_string_find_eol (&str, 9, &found, &found_len))
- _dbus_assert_not_reached ("Found not expected '\\n'");
- else if (found != 11 || found_len != 0)
- _dbus_assert_not_reached ("invalid return values '\\n'");
+ _dbus_test_fatal ("Did not find '\\r\\n'");
+ if (found != 3 || found_len != 2)
+ _dbus_test_fatal ("invalid return values");
+
+ if (!_dbus_string_find_eol (&str, 5, &found, &found_len))
+ _dbus_test_fatal ("Did not find '\\n'");
+ if (found != 8 || found_len != 1)
+ _dbus_test_fatal ("invalid return values");
+
+ if (_dbus_string_find_eol (&str, 9, &found, &found_len))
+ _dbus_test_fatal ("Found not expected '\\n'");
+ else if (found != 11 || found_len != 0)
+ _dbus_test_fatal ("invalid return values '\\n'");
found = -1;
found_len = -1;
_dbus_string_init_const (&str, "");
if (_dbus_string_find_eol (&str, 0, &found, &found_len))
- _dbus_assert_not_reached ("found an eol in an empty string");
+ _dbus_test_fatal ("found an eol in an empty string");
_dbus_assert (found == 0);
_dbus_assert (found_len == 0);
found_len = -1;
_dbus_string_init_const (&str, "foobar");
if (_dbus_string_find_eol (&str, 0, &found, &found_len))
- _dbus_assert_not_reached ("found eol in string that lacks one");
+ _dbus_test_fatal ("found eol in string that lacks one");
_dbus_assert (found == 6);
_dbus_assert (found_len == 0);
found_len = -1;
_dbus_string_init_const (&str, "foobar\n");
if (!_dbus_string_find_eol (&str, 0, &found, &found_len))
- _dbus_assert_not_reached ("did not find eol in string that has one at end");
+ _dbus_test_fatal ("did not find eol in string that has one at end");
_dbus_assert (found == 6);
_dbus_assert (found_len == 1);
}
#define FOURTH_LINE "this is a fourth line"
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_append (&str, FIRST_LINE "\n" SECOND_LINE "\r\n" THIRD_LINE "\n" FOURTH_LINE))
- _dbus_assert_not_reached ("no memory");
-
+ _dbus_test_fatal ("no memory");
+
if (!_dbus_string_init (&line))
- _dbus_assert_not_reached ("no memory");
-
+ _dbus_test_fatal ("no memory");
+
if (!_dbus_string_pop_line (&str, &line))
- _dbus_assert_not_reached ("failed to pop first line");
+ _dbus_test_fatal ("failed to pop first line");
_dbus_assert (_dbus_string_equal_c_str (&line, FIRST_LINE));
if (!_dbus_string_pop_line (&str, &line))
- _dbus_assert_not_reached ("failed to pop second line");
+ _dbus_test_fatal ("failed to pop second line");
_dbus_assert (_dbus_string_equal_c_str (&line, SECOND_LINE));
if (!_dbus_string_pop_line (&str, &line))
- _dbus_assert_not_reached ("failed to pop third line");
+ _dbus_test_fatal ("failed to pop third line");
_dbus_assert (_dbus_string_equal_c_str (&line, THIRD_LINE));
if (!_dbus_string_pop_line (&str, &line))
- _dbus_assert_not_reached ("failed to pop fourth line");
+ _dbus_test_fatal ("failed to pop fourth line");
_dbus_assert (_dbus_string_equal_c_str (&line, FOURTH_LINE));
{
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
for (i = 0; i < 10000; i++)
if (!_dbus_string_append (&str, "abcdefghijklmnopqrstuvwxyz"))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_set_length (&str, 10))
- _dbus_assert_not_reached ("failed to set length");
+ _dbus_test_fatal ("failed to set length");
/* actually compact */
if (!_dbus_string_compact (&str, 2048))
- _dbus_assert_not_reached ("failed to compact after set_length");
+ _dbus_test_fatal ("failed to compact after set_length");
/* peek inside to make sure it worked */
if (((DBusRealString *)&str)->allocated > 30)
- _dbus_assert_not_reached ("compacting string didn't do anything");
+ _dbus_test_fatal ("compacting string didn't do anything");
if (!_dbus_string_equal_c_str (&str, "abcdefghij"))
- _dbus_assert_not_reached ("unexpected content after compact");
+ _dbus_test_fatal ("unexpected content after compact");
/* compact nothing */
if (!_dbus_string_compact (&str, 2048))
- _dbus_assert_not_reached ("failed to compact 2nd time");
+ _dbus_test_fatal ("failed to compact 2nd time");
if (!_dbus_string_equal_c_str (&str, "abcdefghij"))
- _dbus_assert_not_reached ("unexpected content after 2nd compact");
+ _dbus_test_fatal ("unexpected content after 2nd compact");
/* and make sure it still works...*/
if (!_dbus_string_append (&str, "123456"))
- _dbus_assert_not_reached ("failed to append after compact");
+ _dbus_test_fatal ("failed to append after compact");
if (!_dbus_string_equal_c_str (&str, "abcdefghij123456"))
- _dbus_assert_not_reached ("unexpected content after append");
+ _dbus_test_fatal ("unexpected content after append");
/* after growing automatically, this should do nothing */
if (!_dbus_string_compact (&str, 20000))
- _dbus_assert_not_reached ("failed to compact after grow");
+ _dbus_test_fatal ("failed to compact after grow");
/* but this one will do something */
if (!_dbus_string_compact (&str, 0))
- _dbus_assert_not_reached ("failed to compact after grow");
+ _dbus_test_fatal ("failed to compact after grow");
if (!_dbus_string_equal_c_str (&str, "abcdefghij123456"))
- _dbus_assert_not_reached ("unexpected content");
+ _dbus_test_fatal ("unexpected content");
if (!_dbus_string_append (&str, "!@#$%"))
- _dbus_assert_not_reached ("failed to append after compact");
+ _dbus_test_fatal ("failed to append after compact");
if (!_dbus_string_equal_c_str (&str, "abcdefghij123456!@#$%"))
- _dbus_assert_not_reached ("unexpected content");
+ _dbus_test_fatal ("unexpected content");
_dbus_string_free (&str);
}
const char two_strings[] = "one\ttwo";
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_append (&str, two_strings))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_split_on_byte (&str, '\t', &other))
- _dbus_assert_not_reached ("no memory or delimiter not found");
+ _dbus_test_fatal ("no memory or delimiter not found");
if (strcmp (_dbus_string_get_data (&str), "one") != 0)
- _dbus_assert_not_reached ("left side after split on tab is wrong");
+ _dbus_test_fatal ("left side after split on tab is wrong");
if (strcmp (_dbus_string_get_data (&other), "two") != 0)
- _dbus_assert_not_reached ("right side after split on tab is wrong");
+ _dbus_test_fatal ("right side after split on tab is wrong");
_dbus_string_free (&str);
_dbus_string_free (&other);
const char lower2_string[] = "toupperSTRING";
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_append (&str, upper_string))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
_dbus_string_tolower_ascii (&str, 0, _dbus_string_get_length(&str));
if (!_dbus_string_equal_c_str (&str, lower_string))
- _dbus_assert_not_reached ("_dbus_string_tolower_ascii failed");
+ _dbus_test_fatal ("_dbus_string_tolower_ascii failed");
_dbus_string_free (&str);
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_append (&str, upper_string))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
_dbus_string_tolower_ascii (&str, 0, 7);
if (!_dbus_string_equal_c_str (&str, lower2_string))
- _dbus_assert_not_reached ("_dbus_string_tolower_ascii failed in partial conversion");
+ _dbus_test_fatal ("_dbus_string_tolower_ascii failed in partial conversion");
_dbus_string_free (&str);
}
const char upper2_string[] = "TOUPPERstring";
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_append (&str, lower_string))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
_dbus_string_toupper_ascii (&str, 0, _dbus_string_get_length(&str));
if (!_dbus_string_equal_c_str (&str, upper_string))
- _dbus_assert_not_reached ("_dbus_string_toupper_ascii failed");
+ _dbus_test_fatal ("_dbus_string_toupper_ascii failed");
_dbus_string_free (&str);
if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_append (&str, lower_string))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
_dbus_string_toupper_ascii (&str, 0, 7);
if (!_dbus_string_equal_c_str (&str, upper2_string))
- _dbus_assert_not_reached ("_dbus_string_toupper_ascii failed in partial conversion");
+ _dbus_test_fatal ("_dbus_string_toupper_ascii failed in partial conversion");
_dbus_string_free (&str);
}
#include "dbus-internals.h"
#include "dbus-string.h"
#include "dbus-test.h"
+#include <dbus/dbus-test-tap.h>
#include <stdlib.h>
_dbus_string_init_const (&f, filename);
if (!_dbus_string_init (&d))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_get_dirname (&f, &d))
- _dbus_assert_not_reached ("no memory");
+ _dbus_test_fatal ("no memory");
if (!_dbus_string_equal_c_str (&d, dirname))
{
DBusError error;
if (!_dbus_username_from_current_process (&username))
- _dbus_assert_not_reached ("didn't get username");
+ _dbus_test_fatal ("didn't get username");
if (!_dbus_homedir_from_current_process (&homedir))
- _dbus_assert_not_reached ("didn't get homedir");
+ _dbus_test_fatal ("didn't get homedir");
if (!_dbus_get_user_id (username, &uid))
- _dbus_assert_not_reached ("didn't get uid");
+ _dbus_test_fatal ("didn't get uid");
if (!_dbus_groups_from_uid (uid, &group_ids, &n_group_ids))
- _dbus_assert_not_reached ("didn't get groups");
+ _dbus_test_fatal ("didn't get groups");
_dbus_test_diag (" Current user: %s homedir: %s gids:",
_dbus_string_get_const_data (username),
projects / thirdparty / dbus.git / commitdiff
