Merge lp:~charlesk/dbus-test-runner/support-gtestdbus-and-dbusmock-templates into lp:dbus-test-runner/15.10

[Charles Kerr]

Add support for dbusmock templates and for working with externally-managed DBuses and GTestDBuses.

Add support for dbusmock templates and for working with externally-managed DBuses and GTestDBuses.

[Ted Gould (ted)]

Quick review, some comments below

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:112
http://jenkins.qa.ubuntu.com/job/dbus-test-runner-ci/39/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-wily-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-wily-armhf-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-wily-i386-ci/3/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/dbus-test-runner-ci/39/rebuild

review: Needs Fixing (continuous-integration)

[lp:~charlesk/dbus-test-runner/support-gtestdbus-and-dbusmock-templates]

113. By Charles Kerr on 2015-09-21

we're removing some public functions and adding others, so bump both ABI and API

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:113
http://jenkins.qa.ubuntu.com/job/dbus-test-runner-ci/40/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-wily-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-wily-armhf-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/dbus-test-runner-wily-i386-ci/4/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/dbus-test-runner-ci/40/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

113. By Charles Kerr on 2015-09-21

we're removing some public functions and adding others, so bump both ABI and API

112. By Charles Kerr on 2015-09-21

copyediting: tidy up the new comments a little

111. By Charles Kerr on 2015-09-21

remove unused macro

110. By Charles Kerr on 2015-09-21

and while we're in the neighborhood, update DbusTestService to use G_DEFINE_TYPE_WITH_PRIVATE

109. By Charles Kerr on 2015-09-21

revert dbus_test_service_new() to take an address argument, as with the current ABI

108. By Charles Kerr on 2015-09-18

in libdbustest/, get the mock class working with the new template property

107. By Charles Kerr on 2015-09-18

in debian/libdbustest1.symbols, add dbus_test_dbus_mock_new_from_template()

106. By Charles Kerr on 2015-09-18

in libdbustest, add new method dbus_test_dbus_mock_new_from_template()

105. By Charles Kerr on 2015-09-18

in libdbustest/service.c, copyediting -- make whitespace of new code more consistent with existing code

104. By Charles Kerr on 2015-09-18

remove now-unused method dbus_test_service_set_keep_environment()

=== modified file 'Makefile.am'
--- Makefile.am	2012-04-23 15:45:16 +0000
+++ Makefile.am	2015-09-21 17:10:37 +0000
@@ -1,5 +1,4 @@
 SUBDIRS = \
-	data \
 	libdbustest \
 	src \
 	tests \
 
=== modified file 'configure.ac'
--- configure.ac	2015-01-20 22:26:38 +0000
+++ configure.ac	2015-09-21 17:10:37 +0000
@@ -76,7 +76,6 @@
 po/Makefile.in
 libdbustest/Makefile
 src/Makefile
-data/Makefile
 tests/Makefile
 ])
 
 
=== removed directory 'data'
=== removed file 'data/Makefile.am'
--- data/Makefile.am	2014-11-06 19:48:03 +0000
+++ data/Makefile.am	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-
-sessionconfdir = $(datadir)/dbus-test-runner/
-sessionconf_DATA = session.conf system.conf
-
-EXTRA_DIST = session.conf system.conf
 
=== removed file 'data/session.conf'
--- data/session.conf	2012-02-20 18:24:44 +0000
+++ data/session.conf	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
- "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
-<busconfig>
-  <!-- If we fork, keep the user's original umask to avoid affecting
-       the behavior of child processes. -->
-  <keep_umask/>
-
-  <type>session</type>
-
-  <listen>unix:tmpdir=/tmp</listen>
-
-  <standard_session_servicedirs />
-
-  <policy context="default">
-    <!-- Allow everything to be sent -->
-    <allow send_destination="*" eavesdrop="true"/>
-    <!-- Allow everything to be received -->
-    <allow eavesdrop="true"/>
-    <!-- Allow anyone to own anything -->
-    <allow own="*"/>
-  </policy>
-
-  <!-- raise the service start timeout to 40 seconds as it can timeout
-       on the live cd on slow machines -->
-  <limit name="service_start_timeout">60000</limit>
-
-  <!-- the memory limits are 1G instead of say 4G because they can't exceed 32-bit signed int max -->
-  <limit name="max_incoming_bytes">1000000000</limit>
-  <limit name="max_outgoing_bytes">1000000000</limit>
-  <limit name="max_message_size">1000000000</limit>
-  <limit name="service_start_timeout">120000</limit>  
-  <limit name="auth_timeout">240000</limit>
-  <limit name="max_completed_connections">100000</limit>  
-  <limit name="max_incomplete_connections">10000</limit>
-  <limit name="max_connections_per_user">100000</limit>
-  <limit name="max_pending_service_starts">10000</limit>
-  <limit name="max_names_per_connection">50000</limit>
-  <limit name="max_match_rules_per_connection">50000</limit>
-  <limit name="max_replies_per_connection">50000</limit>
-  <limit name="reply_timeout">300000</limit>
-
-</busconfig>
 
=== removed file 'data/system.conf'
--- data/system.conf	2014-11-06 19:54:27 +0000
+++ data/system.conf	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
- "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
-<busconfig>
-  <!-- If we fork, keep the user's original umask to avoid affecting
-       the behavior of child processes. -->
-  <keep_umask/>
-
-  <type>system</type>
-
-  <listen>unix:tmpdir=/tmp</listen>
-
-  <standard_session_servicedirs />
-
-  <policy context="default">
-    <!-- Allow everything to be sent -->
-    <allow send_destination="*" eavesdrop="true"/>
-    <!-- Allow everything to be received -->
-    <allow eavesdrop="true"/>
-    <!-- Allow anyone to own anything -->
-    <allow own="*"/>
-  </policy>
-
-  <!-- raise the service start timeout to 40 seconds as it can timeout
-       on the live cd on slow machines -->
-  <limit name="service_start_timeout">60000</limit>
-
-  <!-- the memory limits are 1G instead of say 4G because they can't exceed 32-bit signed int max -->
-  <limit name="max_incoming_bytes">1000000000</limit>
-  <limit name="max_outgoing_bytes">1000000000</limit>
-  <limit name="max_message_size">1000000000</limit>
-  <limit name="service_start_timeout">120000</limit>  
-  <limit name="auth_timeout">240000</limit>
-  <limit name="max_completed_connections">100000</limit>  
-  <limit name="max_incomplete_connections">10000</limit>
-  <limit name="max_connections_per_user">100000</limit>
-  <limit name="max_pending_service_starts">10000</limit>
-  <limit name="max_names_per_connection">50000</limit>
-  <limit name="max_match_rules_per_connection">50000</limit>
-  <limit name="max_replies_per_connection">50000</limit>
-  <limit name="reply_timeout">300000</limit>
-
-</busconfig>
 
=== modified file 'debian/libdbustest1.symbols'
--- debian/libdbustest1.symbols	2015-02-18 03:44:59 +0000
+++ debian/libdbustest1.symbols	2015-09-21 17:10:37 +0000
@@ -5,6 +5,7 @@
  dbus_test_dbus_mock_get_object@Base 15.04.0+15.04.20141209
  dbus_test_dbus_mock_get_type@Base 15.04.0+15.04.20141209
  dbus_test_dbus_mock_new@Base 15.04.0+15.04.20141209
+ dbus_test_dbus_mock_new_from_template@Base 0replaceme
  dbus_test_dbus_mock_object_add_method@Base 15.04.0+15.04.20141209
  dbus_test_dbus_mock_object_add_property@Base 15.04.0+15.04.20141209
  dbus_test_dbus_mock_object_check_method_call@Base 15.04.0+15.04.20141209
@@ -20,12 +21,10 @@
  dbus_test_service_add_task_with_priority@Base 15.04.0+15.04.20141209
  dbus_test_service_get_type@Base 15.04.0+15.04.20141209
  dbus_test_service_new@Base 15.04.0+15.04.20141209
+ dbus_test_service_new_with_test_bus@ 0replaceme
  dbus_test_service_remove_task@Base 15.04.0+15.04.20150218
  dbus_test_service_run@Base 15.04.0+15.04.20141209
  dbus_test_service_set_bus@Base 15.04.0+15.04.20141209
- dbus_test_service_set_conf_file@Base 15.04.0+15.04.20141209
- dbus_test_service_set_daemon@Base 15.04.0+15.04.20141209
- dbus_test_service_set_keep_environment@Base 15.04.0+15.04.20141209
  dbus_test_service_start_tasks@Base 15.04.0+15.04.20141209
  dbus_test_service_stop@Base 15.04.0+15.04.20141209
  dbus_test_task_get_bus@Base 15.04.0+15.04.20141209
 
=== modified file 'libdbustest/Makefile.am'
--- libdbustest/Makefile.am	2014-11-06 19:51:07 +0000
+++ libdbustest/Makefile.am	2015-09-21 17:10:37 +0000
@@ -1,8 +1,8 @@
 
 lib_LTLIBRARIES = libdbustest.la
 
-ABI_VERSION = 1
-API_VERSION = 1
+ABI_VERSION = 2
+API_VERSION = 2
 
 AM_CFLAGS = -Wall
 
@@ -35,8 +35,6 @@
 	$(COVERAGE_CFLAGS) \
 	-I$(top_srcdir) \
 	-I$(builddir) \
-	-DDEFAULT_SESSION_CONF="\"$(datadir)/dbus-test-runner/session.conf\"" \
-	-DDEFAULT_SYSTEM_CONF="\"$(datadir)/dbus-test-runner/system.conf\"" \
 	-DBUSTLE_DUAL_MONITOR="\"$(pkgdatadir)/dbus-test-bustle-handler\"" \
 	-DWATCHDOG="\"$(pkglibexecdir)/dbus-test-watchdog\"" \
 	-DG_LOG_DOMAIN=\"libdbustest\" \
 
=== modified file 'libdbustest/bustle.c'
--- libdbustest/bustle.c	2013-12-06 10:04:57 +0000
+++ libdbustest/bustle.c	2015-09-21 17:10:37 +0000
@@ -51,7 +51,7 @@
                                          GIOCondition          condition,
                                          gpointer              data);
 
-G_DEFINE_TYPE (DbusTestBustle, dbus_test_bustle, DBUS_TEST_TYPE_TASK);
+G_DEFINE_TYPE (DbusTestBustle, dbus_test_bustle, DBUS_TEST_TYPE_TASK)
 
 static void
 dbus_test_bustle_class_init (DbusTestBustleClass *klass)
@@ -114,7 +114,7 @@
 
 	if (bustler->priv->stderr != NULL) {
 		while (G_IO_IN & g_io_channel_get_buffer_condition(bustler->priv->stderr)) {
-			bustle_write_error(bustler->priv->stderr, 0 /* unused */, bustler);
+			bustle_write_error(bustler->priv->stderr, (GIOCondition)0 /* unused */, bustler);
 		}
 
 		g_clear_pointer(&bustler->priv->stderr, g_io_channel_unref);
@@ -248,7 +248,7 @@
 	                         bustle_monitor, /* argv */
 	                         NULL, /* envp */
 	                         /* G_SPAWN_SEARCH_PATH | G_SPAWN_STDERR_TO_DEV_NULL, */ /* flags */
-	                         G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, /* flags */
+	                         (GSpawnFlags)(G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD), /* flags */
 	                         NULL, /* child setup func */
 	                         NULL, /* child setup data */
 	                         &bustler->priv->pid, /* PID */
@@ -279,7 +279,7 @@
 
 	bustler->priv->stderr = g_io_channel_unix_new(bustle_stderr_num);
 	g_io_add_watch(bustler->priv->stderr,
-	               G_IO_IN | G_IO_HUP | G_IO_ERR, /* conditions */
+	               (GIOCondition)(G_IO_IN | G_IO_HUP | G_IO_ERR), /* conditions */
 	               bustle_write_error, /* func */
 	               bustler); /* func data */
 
 
=== modified file 'libdbustest/dbus-mock.c'
--- libdbustest/dbus-mock.c	2015-01-30 02:43:44 +0000
+++ libdbustest/dbus-mock.c	2015-09-21 17:10:37 +0000
@@ -30,6 +30,7 @@
 
 struct _DbusTestDbusMockPrivate {
 	gchar * name;
+	gchar * template_pathname;
 	_DbusMockIfaceOrgFreedesktopDBusMock * proxy;
 	/* Entries of DbusTestDbusMockObject */
 	GList * objects;
@@ -65,9 +66,12 @@
 enum {
 	PROP_0,
 	PROP_DBUS_NAME,
+	PROP_TEMPLATE_PATHNAME,
 	NUM_PROPS
 };
 
+static GParamSpec * properties[NUM_PROPS];
+
 enum {
 	ERROR_METHOD_NOT_FOUND,
 	NUM_ERRORS
@@ -96,8 +100,8 @@
 static void method_free                    (gpointer data);
 static void property_free                  (gpointer data);
 
-G_DEFINE_TYPE (DbusTestDbusMock, dbus_test_dbus_mock, DBUS_TEST_TYPE_PROCESS);
-G_DEFINE_QUARK("dbus-test-dbus-mock", _dbus_mock);
+G_DEFINE_TYPE (DbusTestDbusMock, dbus_test_dbus_mock, DBUS_TEST_TYPE_PROCESS)
+G_DEFINE_QUARK("dbus-test-dbus-mock", _dbus_mock)
 
 /* Initialize Class */
 static void
@@ -113,12 +117,23 @@
 	object_class->set_property = set_property;
 	object_class->constructed = constructed;
 
-	g_object_class_install_property (object_class, PROP_DBUS_NAME,
-	                                 g_param_spec_string("dbus-name",
-	                                                     "DBus Name",
-	                                                     "The well known name for dbusmock on the session bus",
-	                                                     "com.canonical.DBusTestRunner.DBusMock", /* default */
-	                                                     G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
+        properties[PROP_0] = NULL;
+
+        properties[PROP_DBUS_NAME] = g_param_spec_string(
+		"dbus-name",
+		"DBus Name",
+		"The well known name for dbusmock on the session bus",
+		"com.canonical.DBusTestRunner.DBusMock", /* default */
+		(GParamFlags)(G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
+
+        properties[PROP_TEMPLATE_PATHNAME] = g_param_spec_string(
+		"template-pathname",
+		"Template Pathname",
+		"If using a dbusmock template, the full pathname for its file",
+		NULL, /* default */
+		(GParamFlags)(G_PARAM_STATIC_STRINGS | G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
+
+        g_object_class_install_properties (object_class, NUM_PROPS, properties);
 
 	DbusTestTaskClass * tclass = DBUS_TEST_TASK_CLASS(klass);
 
@@ -202,6 +217,9 @@
 	case PROP_DBUS_NAME:
 		g_value_set_string(value, self->priv->name);
 		break;
+	case PROP_TEMPLATE_PATHNAME:
+		g_value_set_string(value, self->priv->template_pathname);
+		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 	}
@@ -220,6 +238,10 @@
 		g_free(self->priv->name);
 		self->priv->name = g_value_dup_string(value);
 		break;
+	case PROP_TEMPLATE_PATHNAME:
+		g_free(self->priv->template_pathname);
+		self->priv->template_pathname = g_value_dup_string(value);
+		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 	}
@@ -350,7 +372,7 @@
 
 		if (add_object) {
 			proxy = _dbus_mock_iface_org_freedesktop_dbus_mock_proxy_new_sync(mock->priv->bus,
-				G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+				(GDBusProxyFlags)(G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START),
 				mock->priv->name,
 				object->object_path, /* path */
 				mock->priv->cancel,
@@ -442,9 +464,14 @@
 		paramval = "--system"; g_array_append_val(params, paramval);
 	}
 
-	g_array_append_val(params, self->priv->name);
-	paramval = "/"; g_array_append_val(params, paramval);
-	paramval = "com.canonical.DbusTest.DbusMock"; g_array_append_val(params, paramval);
+	if (self->priv->template_pathname != NULL) {
+		paramval = "--template"; g_array_append_val(params, paramval);
+		paramval = self->priv->template_pathname; g_array_append_val(params, paramval);
+	} else {
+		g_array_append_val(params, self->priv->name);
+		paramval = "/"; g_array_append_val(params, paramval);
+		paramval = "com.canonical.DbusTest.DbusMock"; g_array_append_val(params, paramval);
+	}
 
 	g_object_set(G_OBJECT(self), "parameters", params, NULL);
 	g_array_unref(params);
@@ -478,7 +505,7 @@
 
 	/* Zero, Setup the proxy */
 	self->priv->proxy = _dbus_mock_iface_org_freedesktop_dbus_mock_proxy_new_sync(self->priv->bus,
-		G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+		(GDBusProxyFlags)(G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START),
 		self->priv->name,
 		"/", /* path */
 		self->priv->cancel,
@@ -517,7 +544,6 @@
 	/* Second, Install Objects */
 	GList * lobj = self->priv->objects;
 	for (lobj = self->priv->objects; lobj != NULL; lobj = g_list_next(lobj)) {
-		GError * error = NULL;
 
 		DbusTestDbusMockObject * obj = (DbusTestDbusMockObject *)lobj->data;
 		install_object(self, obj, &error);
@@ -554,6 +580,30 @@
 }
 
 /**
+ * dbus_test_dbus_mock_new:
+ * @bus_name: The name dbus mock should get on the bus
+ *
+ * Creates a new dbus mock process with the given dbusmock template.
+ * As with dbus_test_dbus_mock_new(), this function doesn't start
+ * the process -- it queues up a mock to be started when the DBusTest
+ * framework is run.
+ *
+ * Return value: A new dbus mock instance
+ */
+DbusTestDbusMock *
+dbus_test_dbus_mock_new_from_template (const gchar * template_pathname)
+{
+	g_return_val_if_fail(template_pathname != NULL, NULL);
+	g_return_val_if_fail(*template_pathname != '\0', NULL);
+
+	DbusTestDbusMock * mock = g_object_new(DBUS_TEST_TYPE_DBUS_MOCK,
+	                                       "template-pathname", template_pathname,
+	                                       NULL);
+
+	return mock;
+}
+
+/**
  * dbus_test_dbus_mock_get_object:
  * @mock: A #DbusTestDbusMock instance
  * @path: DBus path of the object
@@ -666,7 +716,7 @@
  * Return value: Whether it was registered successfully
  */
 gboolean
-dbus_test_dbus_mock_object_add_method (DbusTestDbusMock * mock, DbusTestDbusMockObject * obj, const gchar * method, const GVariantType * inparams, const GVariantType * outparams, const gchar * python_code, G_GNUC_UNUSED GError ** error)
+dbus_test_dbus_mock_object_add_method (DbusTestDbusMock * mock, DbusTestDbusMockObject * obj, const gchar * method, const GVariantType * inparams, const GVariantType * outparams, const gchar * python_code, GError ** error)
 {
 	g_return_val_if_fail(DBUS_TEST_IS_DBUS_MOCK(mock), FALSE);
 	g_return_val_if_fail(obj != NULL, FALSE);
@@ -942,7 +992,7 @@
  * Return value: Whether it was added
  */
 gboolean
-dbus_test_dbus_mock_object_add_property (DbusTestDbusMock * mock, DbusTestDbusMockObject * obj, const gchar * name, const GVariantType * type, GVariant * value, G_GNUC_UNUSED GError ** error)
+dbus_test_dbus_mock_object_add_property (DbusTestDbusMock * mock, DbusTestDbusMockObject * obj, const gchar * name, const GVariantType * type, GVariant * value, GError ** error)
 {
 	g_return_val_if_fail(DBUS_TEST_IS_DBUS_MOCK(mock), FALSE);
 	g_return_val_if_fail(obj != NULL, FALSE);
 
=== modified file 'libdbustest/dbus-mock.h'
--- libdbustest/dbus-mock.h	2013-11-01 01:16:08 +0000
+++ libdbustest/dbus-mock.h	2015-09-21 17:10:37 +0000
@@ -61,6 +61,7 @@
 
 DbusTestDbusMock *          dbus_test_dbus_mock_new                       (const gchar *             bus_name);
 
+DbusTestDbusMock *          dbus_test_dbus_mock_new_from_template         (const char *              template_pathname);
 
 /* Object stuff */
 
 
=== modified file 'libdbustest/process.c'
--- libdbustest/process.c	2013-12-20 21:49:44 +0000
+++ libdbustest/process.c	2015-09-21 17:10:37 +0000
@@ -64,7 +64,7 @@
                                           const GValue * value,
                                           GParamSpec * pspec);
 
-G_DEFINE_TYPE (DbusTestProcess, dbus_test_process, DBUS_TEST_TYPE_TASK);
+G_DEFINE_TYPE (DbusTestProcess, dbus_test_process, DBUS_TEST_TYPE_TASK)
 
 static void
 dbus_test_process_class_init (DbusTestProcessClass *klass)
@@ -83,13 +83,13 @@
 	                                                     "Executable Name",
 	                                                     "The executable being run by the process object",
 	                                                     "", /* default */
-	                                                     G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
+	                                                     (GParamFlags)(G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE)));
 	g_object_class_install_property (object_class, PROP_PARAMETERS,
 	                                 g_param_spec_boxed("parameters",
 	                                                    "Parameters",
 	                                                    "Parameters to pass to the executable",
 	                                                    G_TYPE_ARRAY,
-	                                                    G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE));
+	                                                    (GParamFlags)(G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE)));
 
 	DbusTestTaskClass * task_class = DBUS_TEST_TASK_CLASS(klass);
 
@@ -194,7 +194,7 @@
 
 /* Get a property */
 static void
-get_property (GObject * object, guint property_id, G_GNUC_UNUSED GValue * value, GParamSpec * pspec)
+get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec)
 {
 	DbusTestProcess * self = DBUS_TEST_PROCESS(object);
 
@@ -214,7 +214,7 @@
 
 /* Set a property */
 static void
-set_property (GObject * object, guint property_id, G_GNUC_UNUSED const GValue * value, GParamSpec * pspec)
+set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec)
 {
 	if (get_state(DBUS_TEST_TASK(object)) == DBUS_TEST_TASK_STATE_RUNNING) {
 		g_warning("Can't set properties on a running process");
@@ -324,7 +324,7 @@
 	g_spawn_async_with_pipes(current_dir,
 	                         argv, /* argv */
 	                         NULL, /* envp */
-	                         G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, /* flags */
+	                         (GSpawnFlags)(G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD), /* flags */
 	                         NULL, /* child setup func */
 	                         NULL, /* child setup data */
 							 &(process->priv->pid), /* PID */
@@ -352,7 +352,7 @@
 	process->priv->io_chan = g_io_channel_unix_new(proc_stdout);
 	g_io_channel_set_buffer_size(process->priv->io_chan, 10 * 1024 * 1024); /* 10 MB should be enough for anyone */
 	process->priv->io_watch = g_io_add_watch(process->priv->io_chan,
-	                                         G_IO_IN | G_IO_HUP | G_IO_ERR, /* conditions */
+	                                         (GIOCondition)(G_IO_IN | G_IO_HUP | G_IO_ERR), /* conditions */
 	                                         proc_writes, /* func */
 	                                         process); /* func data */
 
 
=== modified file 'libdbustest/service.c'
--- libdbustest/service.c	2015-02-13 17:19:17 +0000
+++ libdbustest/service.c	2015-09-21 17:10:37 +0000
@@ -29,21 +29,27 @@
 #include "glib-compat.h"
 
 #include "dbus-test.h"
-#include "watchdog.h"
-
-typedef enum _ServiceState ServiceState;
-enum _ServiceState {
+
+enum {
+	PROP_0,
+	PROP_ADDRESS,
+	PROP_TEST_DBUS,
+	PROP_LAST
+};
+
+static GParamSpec * properties[PROP_LAST];
+
+typedef enum _ServiceState {
 	STATE_INIT,
-	STATE_DAEMON_STARTING,
-	STATE_DAEMON_STARTED,
-	STATE_DAEMON_FAILED,
+	STATE_BUS_STARTED,
 	STATE_STARTING,
 	STATE_STARTED,
 	STATE_RUNNING,
 	STATE_FINISHED
-};
+}
+ServiceState;
 
-struct _DbusTestServicePrivate {
+typedef struct DbusTestServicePrivate {
 	GQueue tasks_first;
 	GQueue tasks_normal;
 	GQueue tasks_last;
@@ -51,36 +57,28 @@
 	GMainLoop * mainloop;
 	ServiceState state;
 
-	gboolean daemon_crashed;
-
-	GPid dbus;
-	guint dbus_watch;
-	GIOChannel * dbus_io;
-	guint dbus_io_watch;
-	gchar * dbus_daemon;
-	gchar * dbus_configfile;
-
-	gboolean first_time;
-	gboolean keep_env;
-
-	DbusTestWatchdog * watchdog;
-	guint watchdog_source;
+	gchar * external_bus_address;
+
+	GTestDBus * test_dbus;
+	gboolean test_dbus_started_here;
 
 	DbusTestServiceBus bus_type;
-};
+}
+DbusTestServicePrivate;
 
 #define SERVICE_CHANGE_HANDLER  "dbus-test-service-change-handler"
 
-#define DBUS_TEST_SERVICE_GET_PRIVATE(o) \
-(G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUS_TEST_TYPE_SERVICE, DbusTestServicePrivate))
-
 static void dbus_test_service_class_init (DbusTestServiceClass *klass);
 static void dbus_test_service_init       (DbusTestService *self);
 static void dbus_test_service_dispose    (GObject *object);
 static void dbus_test_service_finalize   (GObject *object);
-static gboolean watchdog_ping            (gpointer user_data);
-
-G_DEFINE_TYPE (DbusTestService, dbus_test_service, G_TYPE_OBJECT);
+static void dbus_test_service_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec);
+static void dbus_test_service_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec);
+
+G_DEFINE_TYPE_WITH_PRIVATE(DbusTestService, dbus_test_service, G_TYPE_OBJECT)
+
+#define get_priv(service) ((DbusTestServicePrivate*)dbus_test_service_get_instance_private(service))
+
 
 static void
 dbus_test_service_class_init (DbusTestServiceClass *klass)
@@ -91,6 +89,30 @@
 
 	object_class->dispose = dbus_test_service_dispose;
 	object_class->finalize = dbus_test_service_finalize;
+	object_class->get_property = dbus_test_service_get_property;
+	object_class->set_property = dbus_test_service_set_property;
+
+	properties[PROP_0] = NULL;
+
+	properties[PROP_TEST_DBUS] = g_param_spec_object (
+		"test-dbus",
+		"Test DBus",
+		"Externally-owned test dbus. (Optional)",
+		G_TYPE_TEST_DBUS,
+		(GParamFlags)(G_PARAM_READWRITE |
+		              G_PARAM_CONSTRUCT_ONLY |
+		              G_PARAM_STATIC_STRINGS));
+
+	properties[PROP_ADDRESS] = g_param_spec_string (
+		"external-bus-address",
+		"External Bus Address",
+		"Address of externally-managed DBus for service to run on. (Optional)",
+		NULL,
+		(GParamFlags)(G_PARAM_READWRITE |
+		              G_PARAM_CONSTRUCT_ONLY |
+		              G_PARAM_STATIC_STRINGS));
+
+	g_object_class_install_properties (object_class, PROP_LAST, properties);
 
 	return;
 }
@@ -98,35 +120,16 @@
 static void
 dbus_test_service_init (DbusTestService *self)
 {
-	self->priv = DBUS_TEST_SERVICE_GET_PRIVATE(self);
-
-	g_queue_init(&self->priv->tasks_first);
-	g_queue_init(&self->priv->tasks_normal);
-	g_queue_init(&self->priv->tasks_last);
-
-	self->priv->mainloop = g_main_loop_new(NULL, FALSE);
-	self->priv->state = STATE_INIT;
-
-	self->priv->daemon_crashed = FALSE;
-
-	self->priv->dbus = 0;
-	self->priv->dbus_watch = 0;
-	self->priv->dbus_io = NULL;
-	self->priv->dbus_io_watch = 0;
-	self->priv->dbus_daemon = g_strdup("dbus-daemon");
-	self->priv->dbus_configfile = g_strdup(DEFAULT_SESSION_CONF);
-
-	self->priv->first_time = TRUE;
-	self->priv->keep_env = FALSE;
-
-	self->priv->watchdog = g_object_new(DBUS_TEST_TYPE_WATCHDOG, NULL);
-	self->priv->watchdog_source = g_timeout_add_seconds_full(G_PRIORITY_DEFAULT,
-	                                                         5,
-	                                                         watchdog_ping,
-	                                                         g_object_ref(self->priv->watchdog),
-	                                                         g_object_unref);
-
-	self->priv->bus_type = DBUS_TEST_SERVICE_BUS_SESSION;
+	DbusTestServicePrivate * priv = get_priv(self);
+
+	g_queue_init(&priv->tasks_first);
+	g_queue_init(&priv->tasks_normal);
+	g_queue_init(&priv->tasks_last);
+
+	priv->mainloop = g_main_loop_new(NULL, FALSE);
+	priv->state = STATE_INIT;
+
+	priv->bus_type = DBUS_TEST_SERVICE_BUS_SESSION;
 
 	return;
 }
@@ -145,64 +148,36 @@
 	return;
 }
 
+
 static void
 dbus_test_service_dispose (GObject *object)
 {
 	g_return_if_fail(DBUS_TEST_IS_SERVICE(object));
-	DbusTestService * self = DBUS_TEST_SERVICE(object);
-
-	if (!g_queue_is_empty(&self->priv->tasks_last)) {
-		g_queue_foreach(&self->priv->tasks_last, task_unref, NULL);
-		g_queue_clear(&self->priv->tasks_last);
-	}
-
-	if (!g_queue_is_empty(&self->priv->tasks_normal)) {
-		g_queue_foreach(&self->priv->tasks_normal, task_unref, NULL);
-		g_queue_clear(&self->priv->tasks_normal);
-	}
-
-	if (!g_queue_is_empty(&self->priv->tasks_first)) {
-		g_queue_foreach(&self->priv->tasks_first, task_unref, NULL);
-		g_queue_clear(&self->priv->tasks_first);
-	}
-
-	if (self->priv->dbus_watch != 0) {
-		g_source_remove(self->priv->dbus_watch);
-		self->priv->dbus_watch = 0;
-	}
-
-	if (self->priv->dbus_io_watch != 0) {
-		g_source_remove(self->priv->dbus_io_watch);
-		self->priv->dbus_io_watch = 0;
-	}
-
-	if (self->priv->dbus_io != NULL) {
-		g_io_channel_shutdown(self->priv->dbus_io, TRUE, NULL);
-		g_io_channel_unref(self->priv->dbus_io);
-		self->priv->dbus_io = NULL;
-	}
-
-	g_print("DBus daemon: Shutdown\n");
-	if (self->priv->dbus != 0) {
-		gchar * cmd = g_strdup_printf("kill -9 %d", self->priv->dbus);
-		g_spawn_command_line_async(cmd, NULL);
-		g_free(cmd);
-
-		g_spawn_close_pid(self->priv->dbus);
-		self->priv->dbus = 0;
-	}
-
-	if (self->priv->mainloop != NULL) {
-		g_main_loop_unref(self->priv->mainloop);
-		self->priv->mainloop = NULL;
-	}
-
-	g_clear_object(&self->priv->watchdog);
-
-	if (self->priv->watchdog_source != 0) {
-		g_source_remove(self->priv->watchdog_source);
-		self->priv->watchdog_source = 0;
-	}
+	DbusTestServicePrivate * priv = get_priv(DBUS_TEST_SERVICE(object));
+
+	if (!g_queue_is_empty(&priv->tasks_last)) {
+		g_queue_foreach(&priv->tasks_last, task_unref, NULL);
+		g_queue_clear(&priv->tasks_last);
+	}
+
+	if (!g_queue_is_empty(&priv->tasks_normal)) {
+		g_queue_foreach(&priv->tasks_normal, task_unref, NULL);
+		g_queue_clear(&priv->tasks_normal);
+	}
+
+	if (!g_queue_is_empty(&priv->tasks_first)) {
+		g_queue_foreach(&priv->tasks_first, task_unref, NULL);
+		g_queue_clear(&priv->tasks_first);
+	}
+
+	if (priv->test_dbus_started_here) {
+		priv->test_dbus_started_here = FALSE;
+		g_test_dbus_down (priv->test_dbus);
+	}
+
+	g_clear_object(&priv->test_dbus);
+
+	g_clear_pointer(&priv->mainloop, g_main_loop_unref);
 
 	G_OBJECT_CLASS (dbus_test_service_parent_class)->dispose (object);
 	return;
@@ -212,38 +187,100 @@
 dbus_test_service_finalize (GObject *object)
 {
 	g_return_if_fail(DBUS_TEST_IS_SERVICE(object));
-	DbusTestService * self = DBUS_TEST_SERVICE(object);
-
-	g_free(self->priv->dbus_daemon);
-	self->priv->dbus_daemon = NULL;
-	g_free(self->priv->dbus_configfile);
-	self->priv->dbus_configfile = NULL;
-
-	G_OBJECT_CLASS (dbus_test_service_parent_class)->finalize (object);
-	return;
-}
-
-DbusTestService *
-dbus_test_service_new (G_GNUC_UNUSED const gchar * address)
-{
-	DbusTestService * service = g_object_new(DBUS_TEST_TYPE_SERVICE,
-	                                         NULL);
-
-	/* TODO: Use the address */
-
-	return service;
-}
-
-/* Ping the watchdog so that it knows we're still alive */
-static gboolean
-watchdog_ping (gpointer user_data)
-{
-	DbusTestWatchdog * watchdog = DBUS_TEST_WATCHDOG(user_data);
-
-	dbus_test_watchdog_ping(watchdog);
-
-	return TRUE;
-}
+	DbusTestServicePrivate * priv = get_priv(DBUS_TEST_SERVICE(object));
+
+	g_clear_pointer(&priv->external_bus_address, g_free);
+}
+
+static void
+dbus_test_service_get_property (GObject *o, guint property_id, GValue *value, GParamSpec *pspec)
+{
+	DbusTestServicePrivate * priv = get_priv(DBUS_TEST_SERVICE(o));
+
+	switch (property_id) {
+	case PROP_ADDRESS:
+		g_value_set_string (value, priv->external_bus_address);
+		break;
+
+	case PROP_TEST_DBUS:
+		g_value_set_object (value, priv->test_dbus);
+		break;
+
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (o, property_id, pspec);
+	}
+}
+
+static void
+dbus_test_service_set_property (GObject *o, guint property_id, const GValue *value, GParamSpec *pspec)
+{
+	DbusTestServicePrivate * priv = get_priv(DBUS_TEST_SERVICE(o));
+
+	switch (property_id) {
+	case PROP_ADDRESS:
+		g_free(priv->external_bus_address);
+		priv->external_bus_address = g_value_dup_string(value);
+		break;
+
+	case PROP_TEST_DBUS:
+		g_warn_if_fail(priv->test_dbus == NULL);
+		priv->test_dbus = g_value_dup_object(value);
+		break;
+
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (o, property_id, pspec);
+	}
+}
+
+/**
+ * dbus_test_service_new:
+ * @mock: A #DbusTestDbusMock instance
+ * @external_bus_address: Address of an externally-managed bus, or NULL
+ *
+ * Creates a new DbusTestService.
+ *
+ * The most common use case is for DbusTestService to create and manage
+ * its own test bus. To use an externally-managed bus instead, pass its
+ * address in the external_bus_address agument.
+ *
+ * Return Value: (transfer full): A new DbusTestService
+ */
+DbusTestService *
+dbus_test_service_new (const gchar* external_bus_address)
+{
+	DbusTestService * service;
+
+	if (external_bus_address && *external_bus_address)
+		service = g_object_new(DBUS_TEST_TYPE_SERVICE, "external-bus-address", external_bus_address, NULL);
+	else
+		service = g_object_new(DBUS_TEST_TYPE_SERVICE, NULL);
+
+	return service;
+}
+
+/**
+ * dbus_test_service_new_test_bus:
+ * @mock: A #DbusTestDbusMock instance
+ * @test_bus: An externally-owned GTestDBus
+ *
+ * Creates a new DbusTestService with uses the specified GTestDBus.
+ *
+ * Return Value: (transfer full): A new DbusTestService
+ */
+DbusTestService *
+dbus_test_service_new_with_test_bus (GTestDBus * test_dbus)
+{
+	g_return_val_if_fail(test_dbus != NULL, NULL);
+	g_return_val_if_fail(G_IS_TEST_DBUS(test_dbus), NULL);
+
+	DbusTestService * service = g_object_new(DBUS_TEST_TYPE_SERVICE, "test-dbus", test_dbus, NULL);
+
+	return service;
+}
+
+/***
+****
+***/
 
 static gboolean
 all_tasks_finished_helper (G_GNUC_UNUSED DbusTestService * service, DbusTestTask * task, G_GNUC_UNUSED gpointer user_data)
@@ -273,9 +310,11 @@
 static gboolean
 all_tasks_bus_match (DbusTestService * service, DbusTestTask * task, G_GNUC_UNUSED gpointer user_data)
 {
-	return service->priv->bus_type == DBUS_TEST_SERVICE_BUS_BOTH ||
+	DbusTestServicePrivate * priv = get_priv(service);
+
+	return priv->bus_type == DBUS_TEST_SERVICE_BUS_BOTH ||
 		dbus_test_task_get_bus(task) == DBUS_TEST_SERVICE_BUS_BOTH ||
-		dbus_test_task_get_bus(task) == service->priv->bus_type;
+		dbus_test_task_get_bus(task) == priv->bus_type;
 }
 
 typedef struct {
@@ -301,6 +340,8 @@
 static gboolean
 all_tasks (DbusTestService * service, gboolean (*helper) (DbusTestService * service, DbusTestTask * task, gpointer user_data), gpointer user_data)
 {
+	DbusTestServicePrivate * priv = get_priv(service);
+
 	all_tasks_helper_data_t data = {
 		.passing = TRUE,
 		.service = service,
@@ -308,17 +349,17 @@
 		.user_data = user_data
 	};
 
-	g_queue_foreach(&service->priv->tasks_first, all_tasks_helper, &data);
-	if (!data.passing) {
-		return FALSE;
-	}
-
-	g_queue_foreach(&service->priv->tasks_normal, all_tasks_helper, &data);
-	if (!data.passing) {
-		return FALSE;
-	}
-
-	g_queue_foreach(&service->priv->tasks_last, all_tasks_helper, &data);
+	g_queue_foreach(&priv->tasks_first, all_tasks_helper, &data);
+	if (!data.passing) {
+		return FALSE;
+	}
+
+	g_queue_foreach(&priv->tasks_normal, all_tasks_helper, &data);
+	if (!data.passing) {
+		return FALSE;
+	}
+
+	g_queue_foreach(&priv->tasks_last, all_tasks_helper, &data);
 	if (!data.passing) {
 		return FALSE;
 	}
@@ -354,15 +395,16 @@
 static void
 normalize_name_lengths (DbusTestService * service)
 {
+	DbusTestServicePrivate * priv = get_priv(service);
 	glong length = 0;
 
-	g_queue_foreach(&service->priv->tasks_first, task_get_name_length, &length);
-	g_queue_foreach(&service->priv->tasks_normal, task_get_name_length, &length);
-	g_queue_foreach(&service->priv->tasks_last, task_get_name_length, &length);
+	g_queue_foreach(&priv->tasks_first, task_get_name_length, &length);
+	g_queue_foreach(&priv->tasks_normal, task_get_name_length, &length);
+	g_queue_foreach(&priv->tasks_last, task_get_name_length, &length);
 
-	g_queue_foreach(&service->priv->tasks_first, task_set_name_length, &length);
-	g_queue_foreach(&service->priv->tasks_normal, task_set_name_length, &length);
-	g_queue_foreach(&service->priv->tasks_last, task_set_name_length, &length);
+	g_queue_foreach(&priv->tasks_first, task_set_name_length, &length);
+	g_queue_foreach(&priv->tasks_normal, task_set_name_length, &length);
+	g_queue_foreach(&priv->tasks_last, task_set_name_length, &length);
 
 	return;
 }
@@ -377,198 +419,97 @@
 	return;
 }
 
-static gboolean
-dbus_writes (GIOChannel * channel, GIOCondition condition, gpointer data)
+static void
+ensure_bus_is_up (DbusTestService * service)
 {
-	DbusTestService * service = DBUS_TEST_SERVICE(data);
-
-	if (condition & G_IO_ERR) {
-		g_critical("DBus writing failure!");
-		return FALSE;
+	const gchar* address = NULL;
+	DbusTestServicePrivate * priv = get_priv(service);
+
+	if (priv->external_bus_address != NULL) {
+		/* if the client specified an externally-managed bus,
+		   we don't have to start anything here... */
+		address = priv->external_bus_address;
+	} else {
+		/* if the client didn't provide a GTestDBus, create our own */
+		if (priv->test_dbus == NULL)
+			priv->test_dbus = g_test_dbus_new (G_TEST_DBUS_NONE);
+
+		/* start the test dbus */
+		const gboolean bus_is_up = g_test_dbus_get_bus_address(priv->test_dbus) != NULL;
+		if (!bus_is_up) {
+			g_test_dbus_up (priv->test_dbus);
+			priv->test_dbus_started_here = TRUE;
+		}
+
+		address = g_test_dbus_get_bus_address(priv->test_dbus);
 	}
 
-	gchar * line;
-	gsize termloc;
-	GIOStatus status = g_io_channel_read_line (channel, &line, NULL, &termloc, NULL);
-	g_return_val_if_fail(status == G_IO_STATUS_NORMAL, FALSE);
-	line[termloc] = '\0';
-
-	g_print("DBus daemon: %s\n", line);
-
-	if (service->priv->first_time) {
-		service->priv->first_time = FALSE;
-
-		g_setenv("DBUS_STARTER_ADDRESS", line, TRUE);
-
-		switch (service->priv->bus_type) {
+	/* set the environment variables */
+	g_setenv("DBUS_STARTER_ADDRESS", address, TRUE);
+	switch (priv->bus_type) {
 		case DBUS_TEST_SERVICE_BUS_SESSION:
-			g_setenv("DBUS_SESSION_BUS_ADDRESS", line, TRUE);
+			g_setenv("DBUS_SESSION_BUS_ADDRESS", address, TRUE);
 			g_setenv("DBUS_STARTER_BUS_TYPE", "session", TRUE);
 			break;
 		case DBUS_TEST_SERVICE_BUS_SYSTEM:
-			g_setenv("DBUS_SYSTEM_BUS_ADDRESS", line, TRUE);
+			g_setenv("DBUS_SYSTEM_BUS_ADDRESS", address, TRUE);
 			g_setenv("DBUS_STARTER_BUS_TYPE", "system", TRUE);
 			break;
 		case DBUS_TEST_SERVICE_BUS_BOTH:
-			g_setenv("DBUS_SESSION_BUS_ADDRESS", line, TRUE);
-			g_setenv("DBUS_SYSTEM_BUS_ADDRESS", line, TRUE);
+			g_setenv("DBUS_SESSION_BUS_ADDRESS", address, TRUE);
+			g_setenv("DBUS_SYSTEM_BUS_ADDRESS", address, TRUE);
 			g_setenv("DBUS_STARTER_BUS_TYPE", "session", TRUE);
 			break;
-		}
-
-		if (service->priv->state == STATE_DAEMON_STARTING) {
-			g_main_loop_quit(service->priv->mainloop);
-		}
-	}
-
-	g_free(line);
-
-	return TRUE;
-}
-
-static void
-dbus_watcher (GPid pid, G_GNUC_UNUSED gint status, gpointer data)
-{
-	DbusTestService * service = DBUS_TEST_SERVICE(data);
-	g_critical("DBus Daemon exited abruptly!");
-
-	service->priv->daemon_crashed = TRUE;
-	g_main_loop_quit(DBUS_TEST_SERVICE(data)->priv->mainloop);
-
-	if (pid != 0) {
-		g_spawn_close_pid(pid);
-	}
-
-	return;
-}
-
-static void
-dbus_child_setup ()
-{
-	setpgrp();
-}
-
-static void
-start_daemon (DbusTestService * service)
-{
-	if (service->priv->dbus != 0) {
-		return;
-	}
-
-	service->priv->state = STATE_DAEMON_STARTING;
-
-	gint dbus_stdout = 0;
-	GError * error = NULL;
-	gchar * blank[1] = {NULL};
-	gchar * current_dir = g_get_current_dir();
-	gchar * dbus_startup[] = {service->priv->dbus_daemon, "--config-file", service->priv->dbus_configfile, "--print-address", NULL};
-	g_spawn_async_with_pipes(current_dir,
-	                         dbus_startup, /* argv */
-	                         service->priv->keep_env ? NULL : blank, /* envp */
-	                         G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, /* flags */
-	                         (GSpawnChildSetupFunc) dbus_child_setup, /* child setup func */
-	                         NULL, /* child setup data */
-	                         &service->priv->dbus, /* PID */
-	                         NULL, /* stdin */
-	                         &dbus_stdout, /* stdout */
-	                         NULL, /* stderr */
-	                         &error); /* error */
-
-	g_free (current_dir);
-
-	if (error != NULL) {
-		g_critical("Unable to start dbus daemon: %s", error->message);
-		g_error_free(error);
-		service->priv->daemon_crashed = TRUE;
-		return;
-	}
-
-	dbus_test_watchdog_add_pid(service->priv->watchdog, service->priv->dbus);
-
-	service->priv->dbus_watch = g_child_watch_add(service->priv->dbus, dbus_watcher, service);
-
-	service->priv->dbus_io = g_io_channel_unix_new(dbus_stdout);
-	service->priv->dbus_io_watch = g_io_add_watch(service->priv->dbus_io,
-	                                              G_IO_IN | G_IO_HUP | G_IO_ERR, /* conditions */
-	                                              dbus_writes, /* func */
-	                                              service); /* func data */
-
-	g_main_loop_run(service->priv->mainloop);
-
-	/* we should have a usable connection now, let's check */
-	const gchar * bus_address = NULL;
-	if (service->priv->bus_type == DBUS_TEST_SERVICE_BUS_SYSTEM) {
-		bus_address = g_getenv("DBUS_SYSTEM_BUS_ADDRESS");
-	} else {
-		bus_address = g_getenv("DBUS_SESSION_BUS_ADDRESS");
-	}
-	g_return_if_fail(bus_address != NULL);
-	gchar **tokens = g_strsplit (bus_address, ",", 0);
-
-	guint i;
-	gboolean is_valid = FALSE;
-	for (i = 0; i < g_strv_length (tokens); i++) {
-		if (strlen (tokens[i]) && g_dbus_is_supported_address (tokens[i], NULL)) {
-			is_valid = TRUE;
-			break;
-		}
-	}
-	g_strfreev(tokens);
-
-	if (!is_valid) {
-		service->priv->state = STATE_DAEMON_FAILED;
-		g_critical ("DBus daemon failed: Bus address is not supported");
-		g_error_free (error);
-		return;
-	}
-
-	service->priv->state = STATE_DAEMON_STARTED;
+	}
+
+	priv->state = STATE_BUS_STARTED;
+
 	return;
 }
 
 void
 dbus_test_service_start_tasks (DbusTestService * service)
 {
-	g_return_if_fail(DBUS_TEST_SERVICE(service));
+	g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
 	g_return_if_fail(all_tasks(service, all_tasks_bus_match, NULL));
 
-	start_daemon(service);
-	g_return_if_fail(g_getenv("DBUS_SESSION_BUS_ADDRESS") != NULL ||
-		g_getenv("DBUS_SYSTEM_BUS_ADDRESS") != NULL);
-	g_return_if_fail(service->priv->state != STATE_DAEMON_FAILED);
+	DbusTestServicePrivate * priv = get_priv(service);
+
+	ensure_bus_is_up(service);
+	g_return_if_fail(g_getenv("DBUS_STARTER_ADDRESS") != NULL);
 
 	if (all_tasks(service, all_tasks_started_helper, NULL)) {
 		/* If we have all started we can mark it as such as long
 		   as we understand where we could hit this case */
-		if (service->priv->state == STATE_INIT || service->priv->state == STATE_DAEMON_STARTED) {
-			service->priv->state = STATE_STARTED;
+		if (priv->state == STATE_INIT || priv->state == STATE_BUS_STARTED) {
+			priv->state = STATE_STARTED;
 		}
 		return;
 	}
 
 	normalize_name_lengths(service);
 
-	g_queue_foreach(&service->priv->tasks_first, task_starter, NULL);
-	if (!g_queue_is_empty(&service->priv->tasks_first)) {
-		g_usleep(100000);
-	}
-
-	g_queue_foreach(&service->priv->tasks_normal, task_starter, NULL);
-
-	if (!g_queue_is_empty(&service->priv->tasks_last)) {
-		g_usleep(100000);
-	}
-	g_queue_foreach(&service->priv->tasks_last, task_starter, NULL);
+	g_queue_foreach(&priv->tasks_first, task_starter, NULL);
+	if (!g_queue_is_empty(&priv->tasks_first)) {
+		g_usleep(100000);
+	}
+
+	g_queue_foreach(&priv->tasks_normal, task_starter, NULL);
+
+	if (!g_queue_is_empty(&priv->tasks_last)) {
+		g_usleep(100000);
+	}
+	g_queue_foreach(&priv->tasks_last, task_starter, NULL);
 
 	if (!all_tasks(service, all_tasks_started_helper, NULL)) {
-		service->priv->state = STATE_STARTING;
-		g_main_loop_run(service->priv->mainloop);
+		priv->state = STATE_STARTING;
+		g_main_loop_run(priv->mainloop);
 
 		/* This should never happen, but let's be sure */
 		g_return_if_fail(all_tasks(service, all_tasks_started_helper, NULL));
 	}
 
-	service->priv->state = STATE_STARTED;
+	priv->state = STATE_STARTED;
 
 	return;
 }
@@ -582,10 +523,6 @@
 static int
 get_status (DbusTestService * service)
 {
-	if (service->priv->daemon_crashed || service->priv->state == STATE_DAEMON_FAILED) {
-		return -1;
-	}
-
 	if (all_tasks(service, all_tasks_passed_helper, NULL)) {
 		return 0;
 	} else {
@@ -596,38 +533,41 @@
 int
 dbus_test_service_run (DbusTestService * service)
 {
-	g_return_val_if_fail(DBUS_TEST_SERVICE(service), -1);
+	g_return_val_if_fail(DBUS_TEST_IS_SERVICE(service), -1);
+
+	DbusTestServicePrivate * priv = get_priv(service);
 
 	dbus_test_service_start_tasks(service);
-	g_return_val_if_fail(service->priv->state == STATE_STARTED, get_status(service));
+	g_return_val_if_fail(priv->state == STATE_STARTED, get_status(service));
 
 	if (all_tasks(service, all_tasks_finished_helper, NULL)) {
 		return get_status(service);
 	}
 
-	service->priv->state = STATE_RUNNING;
-	g_main_loop_run(service->priv->mainloop);
+	priv->state = STATE_RUNNING;
+	g_main_loop_run(priv->mainloop);
 
 	/* This should never happen, but let's be sure */
 	g_return_val_if_fail(all_tasks(service, all_tasks_finished_helper, NULL), -1);
-	service->priv->state = STATE_FINISHED;
+	priv->state = STATE_FINISHED;
 
 	return get_status(service);
 }
 
 static void
-task_state_changed (G_GNUC_UNUSED DbusTestTask * task, G_GNUC_UNUSED DbusTestTaskState state, gpointer user_data)
+task_state_changed (G_GNUC_UNUSED DbusTestTask * task, G_GNUC_UNUSED DbusTestTaskState state, gpointer gservice)
 {
-	g_return_if_fail(DBUS_TEST_IS_SERVICE(user_data));
-	DbusTestService * service = DBUS_TEST_SERVICE(user_data);
+	g_return_if_fail(DBUS_TEST_IS_SERVICE(gservice));
+	DbusTestService * service = DBUS_TEST_SERVICE(gservice);
+	DbusTestServicePrivate * priv = get_priv(service);
 
-	if (service->priv->state == STATE_STARTING && all_tasks(service, all_tasks_started_helper, NULL)) {
-		g_main_loop_quit(service->priv->mainloop);
+	if (priv->state == STATE_STARTING && all_tasks(service, all_tasks_started_helper, NULL)) {
+		g_main_loop_quit(priv->mainloop);
 		return;
 	}
 
-	if (service->priv->state == STATE_RUNNING && all_tasks(service, all_tasks_finished_helper, NULL)) {
-		g_main_loop_quit(service->priv->mainloop);
+	if (priv->state == STATE_RUNNING && all_tasks(service, all_tasks_finished_helper, NULL)) {
+		g_main_loop_quit(priv->mainloop);
 		return;
 	}
 
@@ -637,7 +577,7 @@
 void
 dbus_test_service_add_task (DbusTestService * service, DbusTestTask * task)
 {
-	return dbus_test_service_add_task_with_priority(service, task, DBUS_TEST_SERVICE_PRIORITY_NORMAL);
+	dbus_test_service_add_task_with_priority(service, task, DBUS_TEST_SERVICE_PRIORITY_NORMAL);
 }
 
 void
@@ -650,17 +590,18 @@
 	   goals for busness. Fail early. */
 	g_return_if_fail(all_tasks_bus_match(service, task, NULL));
 
+	DbusTestServicePrivate * priv = get_priv(service);
 	GQueue * queue = NULL;
 
 	switch (prio) {
 	case DBUS_TEST_SERVICE_PRIORITY_FIRST:
-		queue = &service->priv->tasks_first;
+		queue = &priv->tasks_first;
 		break;
 	case DBUS_TEST_SERVICE_PRIORITY_NORMAL:
-		queue = &service->priv->tasks_normal;
+		queue = &priv->tasks_normal;
 		break;
 	case DBUS_TEST_SERVICE_PRIORITY_LAST:
-		queue = &service->priv->tasks_last;
+		queue = &priv->tasks_last;
 		break;
 	default:
 		g_assert_not_reached();
@@ -690,10 +631,12 @@
 	g_return_val_if_fail(DBUS_TEST_IS_SERVICE(service), FALSE);
 	g_return_val_if_fail(DBUS_TEST_IS_TASK(task), FALSE);
 
+	DbusTestServicePrivate * priv = get_priv(service);
+
 	guint count = 0;
-	count += g_queue_remove_all(&service->priv->tasks_first, task);
-	count += g_queue_remove_all(&service->priv->tasks_normal, task);
-	count += g_queue_remove_all(&service->priv->tasks_last, task);
+	count += g_queue_remove_all(&priv->tasks_first, task);
+	count += g_queue_remove_all(&priv->tasks_normal, task);
+	count += g_queue_remove_all(&priv->tasks_last, task);
 
 	/* Checking the count here so that we can generate a warning. Guessing that
 	   this actually never happens, but it's easy to check */
@@ -715,56 +658,27 @@
 }
 
 void
-dbus_test_service_set_daemon (DbusTestService * service, const gchar * daemon)
-{
-	g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
-	g_free(service->priv->dbus_daemon);
-	service->priv->dbus_daemon = g_strdup(daemon);
-	return;
-}
-
-void
-dbus_test_service_set_conf_file (DbusTestService * service, const gchar * conffile)
-{
-	g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
-	g_free(service->priv->dbus_configfile);
-	service->priv->dbus_configfile = g_strdup(conffile);
-	return;
-}
-
-void
-dbus_test_service_set_keep_environment (DbusTestService * service, gboolean keep_env)
-{
-	g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
-	service->priv->keep_env = keep_env;
-}
-
-void
 dbus_test_service_stop (DbusTestService * service)
 {
 	g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
-	g_main_loop_quit(service->priv->mainloop);
+
+	DbusTestServicePrivate * priv = get_priv(service);
+	g_main_loop_quit(priv->mainloop);
+
 	return;
 }
 
 void dbus_test_service_set_bus (DbusTestService * service, DbusTestServiceBus bus)
 {
 	g_return_if_fail(DBUS_TEST_IS_SERVICE(service));
-	g_return_if_fail(service->priv->dbus == 0); /* we can't change after we're running */
+
+	DbusTestServicePrivate * priv = get_priv(service);
+	g_return_if_fail(priv->state < STATE_BUS_STARTED); /* we can't change after the bus is started */
 
 	if (bus == DBUS_TEST_SERVICE_BUS_BOTH) {
 		g_warning("Setting bus to BOTH, which is typically only used as a default value.");
 	}
 
-	service->priv->bus_type = bus;
+	priv->bus_type = bus;
 	g_warn_if_fail(all_tasks(service, all_tasks_bus_match, NULL));
-
-	if (bus == DBUS_TEST_SERVICE_BUS_SYSTEM) {
-		g_free(service->priv->dbus_configfile);
-		service->priv->dbus_configfile = g_strdup(DEFAULT_SYSTEM_CONF);
-	} else {
-		/* BOTH and SESSION get the session config — for backwards compatibility there */
-		g_free(service->priv->dbus_configfile);
-		service->priv->dbus_configfile = g_strdup(DEFAULT_SESSION_CONF);
-	}
 }
 
=== modified file 'libdbustest/service.h'
--- libdbustest/service.h	2015-02-13 17:19:17 +0000
+++ libdbustest/service.h	2015-09-21 17:10:37 +0000
@@ -24,7 +24,7 @@
 #error "Please include #include <libdbustest/dbus-test.h> only"
 #endif
 
-#include <glib-object.h>
+#include <gio/gio.h>
 
 #include "task.h"
 
@@ -39,7 +39,6 @@
 
 typedef struct _DbusTestService         DbusTestService;
 typedef struct _DbusTestServiceClass    DbusTestServiceClass;
-typedef struct _DbusTestServicePrivate  DbusTestServicePrivate;
 
 struct _DbusTestServiceClass {
 	GObjectClass parent_class;
@@ -47,7 +46,6 @@
 
 struct _DbusTestService {
 	GObject parent;
-	DbusTestServicePrivate * priv;
 };
 
 typedef enum
@@ -65,7 +63,8 @@
 } DbusTestServiceBus;
 
 GType dbus_test_service_get_type (void);
-DbusTestService * dbus_test_service_new (const gchar * address);
+DbusTestService * dbus_test_service_new (const char* external_bus_addr);
+DbusTestService * dbus_test_service_new_with_test_bus(GTestDBus * test_bus);
 void dbus_test_service_start_tasks (DbusTestService * service);
 int dbus_test_service_run (DbusTestService * service);
 void dbus_test_service_stop (DbusTestService * service);
@@ -74,9 +73,6 @@
 void dbus_test_service_add_task_with_priority (DbusTestService * service, DbusTestTask * task, DbusTestServicePriority prio);
 gboolean dbus_test_service_remove_task (DbusTestService * service, DbusTestTask * task);
 
-void dbus_test_service_set_daemon (DbusTestService * service, const gchar * daemon);
-void dbus_test_service_set_conf_file (DbusTestService * service, const gchar * conffile);
-void dbus_test_service_set_keep_environment (DbusTestService * service, gboolean keep_env);
 void dbus_test_service_set_bus (DbusTestService * service, DbusTestServiceBus bus);
 
 G_END_DECLS
 
=== modified file 'libdbustest/task.c'
--- libdbustest/task.c	2015-01-30 02:36:45 +0000
+++ libdbustest/task.c	2015-09-21 17:10:37 +0000
@@ -55,7 +55,7 @@
 static void dbus_test_task_dispose    (GObject *object);
 static void dbus_test_task_finalize   (GObject *object);
 
-G_DEFINE_TYPE (DbusTestTask, dbus_test_task, G_TYPE_OBJECT);
+G_DEFINE_TYPE (DbusTestTask, dbus_test_task, G_TYPE_OBJECT)
 
 static guint signals[LAST_SIGNAL] = {0};
 
@@ -192,7 +192,7 @@
 void
 dbus_test_task_set_wait_for (DbusTestTask * task, const gchar * dbus_name)
 {
-	return dbus_test_task_set_wait_for_bus(task, dbus_name, DBUS_TEST_SERVICE_BUS_BOTH);
+	dbus_test_task_set_wait_for_bus(task, dbus_name, DBUS_TEST_SERVICE_BUS_BOTH);
 }
 
 void
 
=== modified file 'libdbustest/watchdog.c'
--- libdbustest/watchdog.c	2013-01-29 19:38:21 +0000
+++ libdbustest/watchdog.c	2015-09-21 17:10:37 +0000
@@ -15,7 +15,7 @@
 static void dbus_test_watchdog_init       (DbusTestWatchdog *self);
 static void dbus_test_watchdog_finalize   (GObject *object);
 
-G_DEFINE_TYPE (DbusTestWatchdog, dbus_test_watchdog, G_TYPE_OBJECT);
+G_DEFINE_TYPE (DbusTestWatchdog, dbus_test_watchdog, G_TYPE_OBJECT)
 
 /* Initialize class */
 static void
@@ -32,7 +32,7 @@
 
 /* Initialize instance data */
 static void
-dbus_test_watchdog_init (G_GNUC_UNUSED DbusTestWatchdog *self)
+dbus_test_watchdog_init (DbusTestWatchdog *self)
 {
 	self->priv = DBUS_TEST_WATCHDOG_GET_PRIVATE(self);
 
 
=== modified file 'po/Makefile.in.in'
--- po/Makefile.in.in	2012-07-12 15:56:53 +0000
+++ po/Makefile.in.in	2015-09-21 17:10:37 +0000
@@ -33,8 +33,7 @@
 datadir = @datadir@
 datarootdir = @datarootdir@
 libdir = @libdir@
-DATADIRNAME = @DATADIRNAME@
-itlocaledir = $(prefix)/$(DATADIRNAME)/locale
+localedir = @localedir@
 subdir = po
 install_sh = @install_sh@
 # Automake >= 1.8 provides @mkdir_p@.
@@ -80,7 +79,7 @@
 
 .po.pox:
 	$(MAKE) $(GETTEXT_PACKAGE).pot
-	$(MSGMERGE) $< $(GETTEXT_PACKAGE).pot -o $*.pox
+	$(MSGMERGE) $* $(GETTEXT_PACKAGE).pot -o $*.pox
 
 .po.mo:
 	$(INTLTOOL_V_MSGFMT)$(MSGFMT) -o $@ $<
@@ -108,7 +107,7 @@
 install-data-yes: all
 	linguas="$(USE_LINGUAS)"; \
 	for lang in $$linguas; do \
-	  dir=$(DESTDIR)$(itlocaledir)/$$lang/LC_MESSAGES; \
+	  dir=$(DESTDIR)$(localedir)/$$lang/LC_MESSAGES; \
 	  $(mkdir_p) $$dir; \
 	  if test -r $$lang.gmo; then \
 	    $(INSTALL_DATA) $$lang.gmo $$dir/$(GETTEXT_PACKAGE).mo; \
@@ -142,8 +141,8 @@
 uninstall:
 	linguas="$(USE_LINGUAS)"; \
 	for lang in $$linguas; do \
-	  rm -f $(DESTDIR)$(itlocaledir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE).mo; \
-	  rm -f $(DESTDIR)$(itlocaledir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE).mo.m; \
+	  rm -f $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE).mo; \
+	  rm -f $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE).mo.m; \
 	done
 
 check: all $(GETTEXT_PACKAGE).pot
 
=== modified file 'src/Makefile.am'
--- src/Makefile.am	2012-10-02 03:15:57 +0000
+++ src/Makefile.am	2015-09-21 17:10:37 +0000
@@ -5,7 +5,6 @@
 dbus_test_runner_CFLAGS  = $(DBUS_TEST_RUNNER_CFLAGS) \
 	$(COVERAGE_CFLAGS) \
 	-I$(top_srcdir) \
-	-DDEFAULT_SESSION_CONF="\"$(datadir)/dbus-test-runner/session.conf\"" \
 	-Wall -Werror -Wextra
 dbus_test_runner_LDADD   = $(DBUS_TEST_RUNNER_LIBS) \
 	$(top_builddir)/libdbustest/libdbustest.la
 
=== modified file 'src/dbus-test-runner.c'
--- src/dbus-test-runner.c	2014-12-09 22:24:27 +0000
+++ src/dbus-test-runner.c	2015-09-21 17:10:37 +0000
@@ -25,7 +25,6 @@
 
 static DbusTestServiceBus bus_type = DBUS_TEST_SERVICE_BUS_SESSION;
 static gint max_wait = 30;
-static gboolean keep_env = FALSE;
 static DbusTestProcess * last_task = NULL;
 static DbusTestService * service = NULL;
 static gboolean timeout = FALSE;
@@ -194,18 +193,13 @@
 	return FALSE;
 }
 
-static gchar * dbus_configfile = NULL;
-static gchar * dbus_daemon = NULL;
 static gchar * bustle_cmd = NULL;
 static gchar * bustle_datafile = NULL;
 
 static GOptionEntry general_options[] = {
-	{"dbus-daemon",  0,     0,                       G_OPTION_ARG_FILENAME,  &dbus_daemon,     "Path to the DBus deamon to use.  Defaults to 'dbus-daemon'.", "executable"},
-	{"dbus-config",  'd',   0,                       G_OPTION_ARG_FILENAME,  &dbus_configfile, "Configuration file for newly created DBus server.  Defaults to '" DEFAULT_SESSION_CONF "'.", "config_file"},
 	{"bustle-monitor", 0,   0,                       G_OPTION_ARG_FILENAME,  &bustle_cmd,      "Path to the Bustle DBus Monitor to use.  Defaults to 'bustle-dbus-monitor'.", "executable"},
 	{"bustle-data",  'b',   0,                       G_OPTION_ARG_FILENAME,  &bustle_datafile, "A file to write out data from the bustle logger to.", "data_file"},
 	{"max-wait",     'm',   0,                       G_OPTION_ARG_INT,       &max_wait,        "The maximum amount of time the test runner will wait for the test to complete.  Default is 30 seconds.", "seconds"},
-	{"keep-env",     0,     0,                       G_OPTION_ARG_NONE,      &keep_env,        "Whether to propagate the execution environment to the dbus-server and all the services activated by it.  By default the environment is cleared.", NULL },
 	{"bus-type",     0,     0,                       G_OPTION_ARG_CALLBACK,  option_bus_type,  "Configures which buses are represented by the tool to the tasks. Default: session", "{session|system|both}" },
 	{ NULL, 0, 0, 0, NULL, NULL, NULL }
 };
@@ -250,14 +244,6 @@
 
 	dbus_test_service_set_bus(service, bus_type);
 
-	if (dbus_daemon != NULL) {
-		dbus_test_service_set_daemon(service, dbus_daemon);
-	}
-
-	if (dbus_configfile != NULL) {
-		dbus_test_service_set_conf_file(service, dbus_configfile);
-	}
-
 	if (bustle_datafile != NULL) {
 		DbusTestBustle * bustler = dbus_test_bustle_new(bustle_datafile);
 		/* We want to ensure that bustle captures all the data so start it first */
@@ -274,8 +260,6 @@
 		g_timeout_add_seconds(max_wait, max_wait_hit, NULL);
 	}
 
-	dbus_test_service_set_keep_environment(service, keep_env);
-
 	/* These should all be in the service now */
 	if (last_task != NULL) {
 		g_object_unref(last_task);
 
=== modified file 'tests/Makefile.am'
--- tests/Makefile.am	2015-01-30 17:10:47 +0000
+++ tests/Makefile.am	2015-09-21 17:10:37 +0000
@@ -1,6 +1,6 @@
 
-DBUS_RUNNER=$(top_builddir)/src/dbus-test-runner --dbus-config $(srcdir)/../data/session.conf
-DBUS_RUNNER_SYSTEM=$(top_builddir)/src/dbus-test-runner --dbus-config $(srcdir)/../data/system.conf
+DBUS_RUNNER=$(top_builddir)/src/dbus-test-runner
+DBUS_RUNNER_SYSTEM=$(top_builddir)/src/dbus-test-runner
 TESTS = 
 DISTCLEANFILES = $(TESTS)
 XFAIL_TESTS =
 
=== modified file 'tests/test-libdbustest-mock.c'
--- tests/test-libdbustest-mock.c	2015-02-02 15:52:49 +0000
+++ tests/test-libdbustest-mock.c	2015-09-21 17:10:37 +0000
@@ -58,8 +58,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
 	g_assert(mock != NULL);
 
@@ -103,8 +101,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
 	g_assert(mock != NULL);
 
@@ -275,8 +271,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
 	g_assert(mock != NULL);
 
@@ -359,8 +353,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
 	g_assert(mock != NULL);
 
@@ -430,8 +422,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
 	g_assert(mock != NULL);
 
@@ -530,8 +520,6 @@
 	g_assert(service != NULL);
 	dbus_test_service_set_bus(service, DBUS_TEST_SERVICE_BUS_SYSTEM);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
 	g_assert(mock != NULL);
 	dbus_test_task_set_bus(DBUS_TEST_TASK(mock), DBUS_TEST_SERVICE_BUS_SYSTEM);
@@ -598,8 +586,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestDbusMock * mock = dbus_test_dbus_mock_new("foo.test");
 	g_assert(mock != NULL);
 
 
=== modified file 'tests/test-libdbustest.c'
--- tests/test-libdbustest.c	2013-01-29 20:32:11 +0000
+++ tests/test-libdbustest.c	2015-09-21 17:10:37 +0000
@@ -8,8 +8,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	g_unsetenv("DBUS_SESSION_BUS_ADDRESS");
 	dbus_test_service_start_tasks(service);
 	g_assert(g_getenv("DBUS_SESSION_BUS_ADDRESS") != NULL);
@@ -24,8 +22,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestTask * task = dbus_test_task_new();
 	g_assert(task != NULL);
 
@@ -46,8 +42,6 @@
 	DbusTestService * service = dbus_test_service_new(NULL);
 	g_assert(service != NULL);
 
-	dbus_test_service_set_conf_file(service, SESSION_CONF);
-
 	DbusTestTask * task = dbus_test_task_new();
 	g_assert(task != NULL);