1 /* Integration tests for monitor-mode D-Bus connections
3 * Copyright © 2010-2011 Nokia Corporation
4 * Copyright © 2015 Collabora Ltd.
6 * Permission is hereby granted, free of charge, to any person
7 * obtaining a copy of this software and associated documentation files
8 * (the "Software"), to deal in the Software without restriction,
9 * including without limitation the rights to use, copy, modify, merge,
10 * publish, distribute, sublicense, and/or sell copies of the Software,
11 * and to permit persons to whom the Software is furnished to do so,
12 * subject to the following conditions:
14 * The above copyright notice and this permission notice shall be
15 * included in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
20 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
21 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
22 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 #include "test-utils-glib.h"
34 const char *config_file;
35 const char * const *match_rules;
36 gboolean care_about_our_names;
48 DBusConnection *monitor;
49 DBusConnection *sender;
50 DBusConnection *recipient;
54 const char *monitor_name;
55 const char *sender_name;
56 const char *recipient_name;
58 DBusConnection *systemd;
59 const char *systemd_name;
60 DBusMessage *systemd_message;
61 DBusConnection *activated;
62 const char *activated_name;
63 DBusMessage *activated_message;
66 static const char * const no_match_rules[] = {
70 static const char * const wildcard_match_rules[] = {
76 static const char * const eavesdrop_match_rules[] = {
82 static const char * const no_eavesdrop_match_rules[] = {
88 static const char * const selective_match_rules[] = {
89 "interface='com.example.Interesting'",
90 "interface='com.example.Fun'",
95 static Config forbidding_config = {
96 "valid-config-files/forbidding.conf",
101 static Config wildcard_config = {
103 wildcard_match_rules,
107 static Config selective_config = {
109 selective_match_rules,
113 static Config no_rules_config = {
119 static Config eavesdrop_config = {
121 eavesdrop_match_rules,
125 static Config no_eavesdrop_config = {
127 no_eavesdrop_match_rules,
131 static Config fake_systemd_config = {
132 "valid-config-files/systemd-activation.conf",
137 static Config side_effects_config = {
143 static inline const char *
144 not_null2 (const char *x,
145 const char *fallback)
153 static inline const char *
154 not_null (const char *x)
156 return not_null2 (x, "(null)");
159 #define log_message(m) _log_message (m, __FILE__, __LINE__)
163 _log_message (DBusMessage *m,
167 g_test_message ("%s:%d: message type %d (%s)", file, line,
168 dbus_message_get_type (m),
169 dbus_message_type_to_string (dbus_message_get_type (m)));
170 g_test_message ("\tfrom: %s",
171 not_null2 (dbus_message_get_sender (m), "(dbus-daemon)"));
172 g_test_message ("\tto: %s",
173 not_null2 (dbus_message_get_destination (m), "(broadcast)"));
174 g_test_message ("\tpath: %s",
175 not_null (dbus_message_get_path (m)));
176 g_test_message ("\tinterface: %s",
177 not_null (dbus_message_get_interface (m)));
178 g_test_message ("\tmember: %s",
179 not_null (dbus_message_get_member (m)));
180 g_test_message ("\tsignature: %s",
181 not_null (dbus_message_get_signature (m)));
182 g_test_message ("\terror name: %s",
183 not_null (dbus_message_get_error_name (m)));
185 if (strcmp ("s", dbus_message_get_signature (m)) == 0)
187 DBusError e = DBUS_ERROR_INIT;
190 dbus_message_get_args (m, &e,
191 DBUS_TYPE_STRING, &s,
193 test_assert_no_error (&e);
194 g_test_message ("\tstring payload: %s", s);
198 /* these are macros so they get the right line number */
200 #define assert_hello(m) \
202 g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
203 ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_METHOD_CALL)); \
204 g_assert_cmpstr (dbus_message_get_destination (m), ==, DBUS_SERVICE_DBUS); \
205 g_assert_cmpstr (dbus_message_get_path (m), ==, DBUS_PATH_DBUS); \
206 g_assert_cmpstr (dbus_message_get_interface (m), ==, DBUS_INTERFACE_DBUS); \
207 g_assert_cmpstr (dbus_message_get_member (m), ==, "Hello"); \
208 g_assert_cmpstr (dbus_message_get_signature (m), ==, ""); \
209 g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
210 g_assert_cmpint (dbus_message_get_reply_serial (m), ==, 0); \
213 #define assert_hello_reply(m) \
215 DBusError _e = DBUS_ERROR_INIT; \
218 g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
219 ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_METHOD_RETURN)); \
220 g_assert_cmpstr (dbus_message_get_sender (m), ==, DBUS_SERVICE_DBUS); \
221 g_assert_cmpstr (dbus_message_get_path (m), ==, NULL); \
222 g_assert_cmpstr (dbus_message_get_interface (m), ==, NULL); \
223 g_assert_cmpstr (dbus_message_get_member (m), ==, NULL); \
224 g_assert_cmpstr (dbus_message_get_signature (m), ==, "s"); \
225 g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
226 g_assert_cmpint (dbus_message_get_reply_serial (m), !=, 0); \
228 dbus_message_get_args (m, &_e, \
229 DBUS_TYPE_STRING, &_s, \
230 DBUS_TYPE_INVALID); \
231 test_assert_no_error (&_e); \
232 g_assert_cmpstr (dbus_message_get_destination (m), ==, _s); \
235 #define assert_name_acquired(m) \
237 DBusError _e = DBUS_ERROR_INIT; \
240 g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
241 ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_SIGNAL)); \
242 g_assert_cmpstr (dbus_message_get_sender (m), ==, DBUS_SERVICE_DBUS); \
243 g_assert_cmpstr (dbus_message_get_path (m), ==, DBUS_PATH_DBUS); \
244 g_assert_cmpstr (dbus_message_get_interface (m), ==, DBUS_INTERFACE_DBUS); \
245 g_assert_cmpstr (dbus_message_get_member (m), ==, "NameAcquired"); \
246 g_assert_cmpstr (dbus_message_get_signature (m), ==, "s"); \
247 g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
248 g_assert_cmpint (dbus_message_get_reply_serial (m), ==, 0); \
250 dbus_message_get_args (m, &_e, \
251 DBUS_TYPE_STRING, &_s, \
252 DBUS_TYPE_INVALID); \
253 test_assert_no_error (&_e); \
254 g_assert_cmpstr (dbus_message_get_destination (m), ==, _s); \
257 #define assert_method_call(m, sender, \
258 destination, path, iface, method, signature) \
260 g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
261 ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_METHOD_CALL)); \
262 g_assert_cmpstr (dbus_message_get_sender (m), ==, sender); \
263 g_assert_cmpstr (dbus_message_get_destination (m), ==, destination); \
264 g_assert_cmpstr (dbus_message_get_path (m), ==, path); \
265 g_assert_cmpstr (dbus_message_get_interface (m), ==, iface); \
266 g_assert_cmpstr (dbus_message_get_member (m), ==, method); \
267 g_assert_cmpstr (dbus_message_get_signature (m), ==, signature); \
268 g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
269 g_assert_cmpint (dbus_message_get_reply_serial (m), ==, 0); \
272 #define assert_signal(m, \
273 sender, path, iface, member, signature, \
276 g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
277 ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_SIGNAL)); \
278 g_assert_cmpstr (dbus_message_get_sender (m), ==, sender); \
279 g_assert_cmpstr (dbus_message_get_destination (m), ==, destination); \
280 g_assert_cmpstr (dbus_message_get_path (m), ==, path); \
281 g_assert_cmpstr (dbus_message_get_interface (m), ==, iface); \
282 g_assert_cmpstr (dbus_message_get_member (m), ==, member); \
283 g_assert_cmpstr (dbus_message_get_signature (m), ==, signature); \
284 g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
285 g_assert_cmpint (dbus_message_get_reply_serial (m), ==, 0); \
288 #define assert_method_reply(m, sender, destination, signature) \
290 g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
291 ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_METHOD_RETURN)); \
292 g_assert_cmpstr (dbus_message_get_sender (m), ==, sender); \
293 g_assert_cmpstr (dbus_message_get_destination (m), ==, destination); \
294 g_assert_cmpstr (dbus_message_get_path (m), ==, NULL); \
295 g_assert_cmpstr (dbus_message_get_interface (m), ==, NULL); \
296 g_assert_cmpstr (dbus_message_get_member (m), ==, NULL); \
297 g_assert_cmpstr (dbus_message_get_signature (m), ==, signature); \
298 g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
299 g_assert_cmpint (dbus_message_get_reply_serial (m), !=, 0); \
302 #define assert_error_reply(m, sender, destination, error_name) \
304 g_assert_cmpstr (dbus_message_type_to_string (dbus_message_get_type (m)), \
305 ==, dbus_message_type_to_string (DBUS_MESSAGE_TYPE_ERROR)); \
306 g_assert_cmpstr (dbus_message_get_sender (m), ==, sender); \
307 g_assert_cmpstr (dbus_message_get_destination (m), ==, destination); \
308 g_assert_cmpstr (dbus_message_get_error_name (m), ==, error_name); \
309 g_assert_cmpstr (dbus_message_get_path (m), ==, NULL); \
310 g_assert_cmpstr (dbus_message_get_interface (m), ==, NULL); \
311 g_assert_cmpstr (dbus_message_get_member (m), ==, NULL); \
312 g_assert_cmpstr (dbus_message_get_signature (m), ==, "s"); \
313 g_assert_cmpint (dbus_message_get_serial (m), !=, 0); \
314 g_assert_cmpint (dbus_message_get_reply_serial (m), !=, 0); \
317 /* This is called after processing pending replies to our own method
318 * calls, but before anything else.
320 static DBusHandlerResult
321 monitor_filter (DBusConnection *connection,
322 DBusMessage *message,
325 Fixture *f = user_data;
327 g_assert_cmpstr (dbus_message_get_interface (message), !=,
328 "com.example.Tedious");
330 /* we are not interested in the monitor getting NameAcquired or NameLost
332 if (f->config == NULL || !f->config->care_about_our_names)
334 if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
336 dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
339 DBusError e = DBUS_ERROR_INIT;
342 dbus_message_get_args (message, &e,
343 DBUS_TYPE_STRING, &s,
345 test_assert_no_error (&e);
347 if (strcmp (s, f->monitor_name) == 0)
350 return DBUS_HANDLER_RESULT_HANDLED;
355 g_queue_push_tail (&f->monitored, dbus_message_ref (message));
357 return DBUS_HANDLER_RESULT_HANDLED;
360 static DBusHandlerResult
361 recipient_filter (DBusConnection *connection,
362 DBusMessage *message,
365 g_assert_cmpstr (dbus_message_get_interface (message), !=,
366 "com.example.CannotSend");
367 g_assert_cmpstr (dbus_message_get_interface (message), !=,
368 "com.example.CannotReceive");
370 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
373 static DBusHandlerResult
374 systemd_filter (DBusConnection *connection,
375 DBusMessage *message,
378 Fixture *f = user_data;
380 if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
382 dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
385 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
388 g_assert (f->systemd_message == NULL);
389 f->systemd_message = dbus_message_ref (message);
391 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
394 static DBusHandlerResult
395 activated_filter (DBusConnection *connection,
396 DBusMessage *message,
399 Fixture *f = user_data;
401 if (dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
403 dbus_message_is_signal (message, DBUS_INTERFACE_DBUS,
406 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
409 g_assert (f->activated_message == NULL);
410 f->activated_message = dbus_message_ref (message);
412 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
417 gconstpointer context)
421 f->ctx = test_main_context_get ();
424 dbus_error_init (&f->e);
426 f->address = test_get_dbus_daemon (f->config ? f->config->config_file : NULL,
427 TEST_USER_ME, &f->daemon_pid);
429 if (f->address == NULL)
432 f->monitor = test_connect_to_bus (f->ctx, f->address);
433 f->monitor_name = dbus_bus_get_unique_name (f->monitor);
434 f->sender = test_connect_to_bus (f->ctx, f->address);
435 f->sender_name = dbus_bus_get_unique_name (f->sender);
436 f->recipient = test_connect_to_bus (f->ctx, f->address);
437 f->recipient_name = dbus_bus_get_unique_name (f->recipient);
439 if (!dbus_connection_add_filter (f->monitor, monitor_filter, f, NULL))
442 if (!dbus_connection_add_filter (f->recipient, recipient_filter, f, NULL))
447 become_monitor (Fixture *f)
452 DBusMessageIter appender, array_appender;
453 const char * const *match_rules;
455 dbus_uint32_t zero = 0;
457 dbus_connection_set_route_peer_messages (f->monitor, TRUE);
459 if (f->config != NULL && f->config->match_rules != NULL)
460 match_rules = f->config->match_rules;
462 match_rules = wildcard_match_rules;
464 m = dbus_message_new_method_call (DBUS_SERVICE_DBUS,
465 DBUS_PATH_DBUS, DBUS_INTERFACE_MONITORING, "BecomeMonitor");
470 dbus_message_iter_init_append (m, &appender);
472 if (!dbus_message_iter_open_container (&appender, DBUS_TYPE_ARRAY, "s",
476 for (i = 0; match_rules[i] != NULL; i++)
478 if (!dbus_message_iter_append_basic (&array_appender, DBUS_TYPE_STRING,
483 if (!dbus_message_iter_close_container (&appender, &array_appender) ||
484 !dbus_message_iter_append_basic (&appender, DBUS_TYPE_UINT32, &zero))
487 if (!dbus_connection_send_with_reply (f->monitor, m, &pc,
488 DBUS_TIMEOUT_USE_DEFAULT) ||
492 dbus_message_unref (m);
495 if (dbus_pending_call_get_completed (pc))
496 test_pending_call_store_reply (pc, &m);
497 else if (!dbus_pending_call_set_notify (pc, test_pending_call_store_reply,
502 test_main_context_iterate (f->ctx, TRUE);
504 ok = dbus_message_get_args (m, &f->e,
506 test_assert_no_error (&f->e);
509 dbus_pending_call_unref (pc);
510 dbus_message_unref (m);
515 * Test the side-effects of becoming a monitor.
518 test_become_monitor (Fixture *f,
519 gconstpointer context)
523 dbus_bool_t got_unique = FALSE, got_a = FALSE, got_b = FALSE, got_c = FALSE;
524 dbus_bool_t lost_unique = FALSE, lost_a = FALSE, lost_b = FALSE, lost_c = FALSE;
526 if (f->address == NULL)
529 ret = dbus_bus_request_name (f->monitor, "com.example.A",
530 DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
531 test_assert_no_error (&f->e);
532 g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
534 ret = dbus_bus_request_name (f->monitor, "com.example.B",
535 DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
536 test_assert_no_error (&f->e);
537 g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
539 ret = dbus_bus_request_name (f->monitor, "com.example.C",
540 DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
541 test_assert_no_error (&f->e);
542 g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
544 while (!got_unique || !got_a || !got_b || !got_c)
546 if (g_queue_is_empty (&f->monitored))
547 test_main_context_iterate (f->ctx, TRUE);
549 while ((m = g_queue_pop_head (&f->monitored)) != NULL)
551 if (dbus_message_is_signal (m, DBUS_INTERFACE_DBUS,
555 dbus_bool_t ok = dbus_message_get_args (m, &f->e,
556 DBUS_TYPE_STRING, &name,
559 g_assert_cmpstr (dbus_message_get_path (m), ==,
562 test_assert_no_error (&f->e);
565 if (g_str_equal (name, f->monitor_name))
567 g_assert (!got_unique);
570 else if (g_str_equal (name, "com.example.A"))
575 else if (g_str_equal (name, "com.example.B"))
582 g_assert_cmpstr (name, ==, "com.example.C");
589 g_error ("unexpected message %s.%s",
590 dbus_message_get_interface (m),
591 dbus_message_get_member (m));
594 dbus_message_unref (m);
600 while (!lost_unique || !lost_a || !lost_b || !lost_c)
602 if (g_queue_is_empty (&f->monitored))
603 test_main_context_iterate (f->ctx, TRUE);
605 while ((m = g_queue_pop_head (&f->monitored)) != NULL)
607 if (dbus_message_is_signal (m, DBUS_INTERFACE_DBUS,
611 dbus_bool_t ok = dbus_message_get_args (m, &f->e,
612 DBUS_TYPE_STRING, &name,
615 test_assert_no_error (&f->e);
618 if (g_str_equal (name, f->monitor_name))
620 g_assert (!lost_unique);
623 else if (g_str_equal (name, "com.example.A"))
628 else if (g_str_equal (name, "com.example.B"))
635 g_assert_cmpstr (name, ==, "com.example.C");
642 g_error ("unexpected message %s.%s",
643 dbus_message_get_interface (m),
644 dbus_message_get_member (m));
647 dbus_message_unref (m);
651 /* Calling methods is forbidden; we get disconnected. */
652 dbus_bus_add_match (f->monitor, "", &f->e);
653 g_assert_cmpstr (f->e.name, ==, DBUS_ERROR_NO_REPLY);
654 g_assert (!dbus_connection_get_is_connected (f->monitor));
658 if (g_queue_is_empty (&f->monitored))
659 test_main_context_iterate (f->ctx, TRUE);
661 /* When we iterate all the connection's messages, we see ourselves
662 * losing all our names, then we're disconnected. */
663 while ((m = g_queue_pop_head (&f->monitored)) != NULL)
665 if (dbus_message_is_signal (m, DBUS_INTERFACE_LOCAL, "Disconnected"))
667 dbus_message_unref (m);
672 g_error ("unexpected message %s.%s",
673 dbus_message_get_interface (m),
674 dbus_message_get_member (m));
677 dbus_message_unref (m);
689 test_broadcast (Fixture *f,
690 gconstpointer context)
694 if (f->address == NULL)
697 dbus_bus_add_match (f->recipient, "type='signal'", &f->e);
698 test_assert_no_error (&f->e);
702 m = dbus_message_new_signal ("/foo", "com.example.bar", "BroadcastSignal1");
703 dbus_connection_send (f->sender, m, NULL);
704 dbus_message_unref (m);
706 m = dbus_message_new_signal ("/foo", "com.example.bar", "BroadcastSignal2");
707 dbus_connection_send (f->sender, m, NULL);
708 dbus_message_unref (m);
710 m = dbus_message_new_signal ("/foo", "com.example.bar", "BroadcastSignal3");
711 dbus_connection_send (f->sender, m, NULL);
712 dbus_message_unref (m);
714 while (g_queue_get_length (&f->monitored) < 3)
715 test_main_context_iterate (f->ctx, TRUE);
717 m = g_queue_pop_head (&f->monitored);
718 assert_signal (m, f->sender_name, "/foo", "com.example.bar",
719 "BroadcastSignal1", "", NULL);
720 dbus_message_unref (m);
722 m = g_queue_pop_head (&f->monitored);
723 assert_signal (m, f->sender_name, "/foo", "com.example.bar",
724 "BroadcastSignal2", "", NULL);
725 dbus_message_unref (m);
727 m = g_queue_pop_head (&f->monitored);
728 assert_signal (m, f->sender_name, "/foo", "com.example.bar",
729 "BroadcastSignal3", "", NULL);
730 dbus_message_unref (m);
732 m = g_queue_pop_head (&f->monitored);
733 g_assert (m == NULL);
737 test_forbidden_broadcast (Fixture *f,
738 gconstpointer context)
742 if (f->address == NULL)
745 dbus_bus_add_match (f->recipient, "type='signal'", &f->e);
746 test_assert_no_error (&f->e);
750 m = dbus_message_new_signal ("/foo", "com.example.CannotSend",
752 dbus_connection_send (f->sender, m, NULL);
753 dbus_message_unref (m);
755 m = dbus_message_new_signal ("/foo", "com.example.CannotReceive",
757 dbus_connection_send (f->sender, m, NULL);
758 dbus_message_unref (m);
760 m = dbus_message_new_signal ("/foo", "com.example.CannotSend",
762 dbus_connection_send (f->sender, m, NULL);
763 dbus_message_unref (m);
765 while (g_queue_get_length (&f->monitored) < 6)
766 test_main_context_iterate (f->ctx, TRUE);
768 m = g_queue_pop_head (&f->monitored);
769 assert_signal (m, f->sender_name, "/foo", "com.example.CannotSend",
770 "BroadcastSignal1", "", NULL);
771 dbus_message_unref (m);
773 m = g_queue_pop_head (&f->monitored);
774 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
775 DBUS_ERROR_ACCESS_DENIED);
776 dbus_message_unref (m);
778 m = g_queue_pop_head (&f->monitored);
779 assert_signal (m, f->sender_name, "/foo", "com.example.CannotReceive",
780 "BroadcastSignal2", "", NULL);
781 dbus_message_unref (m);
783 m = g_queue_pop_head (&f->monitored);
784 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
785 DBUS_ERROR_ACCESS_DENIED);
786 dbus_message_unref (m);
788 m = g_queue_pop_head (&f->monitored);
789 assert_signal (m, f->sender_name, "/foo", "com.example.CannotSend",
790 "BroadcastSignal3", "", NULL);
791 dbus_message_unref (m);
793 m = g_queue_pop_head (&f->monitored);
794 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
795 DBUS_ERROR_ACCESS_DENIED);
796 dbus_message_unref (m);
798 m = g_queue_pop_head (&f->monitored);
799 g_assert (m == NULL);
803 test_unicast_signal (Fixture *f,
804 gconstpointer context)
808 if (f->address == NULL)
813 m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal1");
814 if (!dbus_message_set_destination (m, f->recipient_name))
816 dbus_connection_send (f->sender, m, NULL);
817 dbus_message_unref (m);
819 m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal2");
820 if (!dbus_message_set_destination (m, f->recipient_name))
822 dbus_connection_send (f->sender, m, NULL);
823 dbus_message_unref (m);
825 m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal3");
826 if (!dbus_message_set_destination (m, f->recipient_name))
828 dbus_connection_send (f->sender, m, NULL);
829 dbus_message_unref (m);
831 while (g_queue_get_length (&f->monitored) < 3)
832 test_main_context_iterate (f->ctx, TRUE);
834 m = g_queue_pop_head (&f->monitored);
835 assert_signal (m, f->sender_name, "/foo",
836 "com.example.bar", "UnicastSignal1", "", f->recipient_name);
837 dbus_message_unref (m);
839 m = g_queue_pop_head (&f->monitored);
840 assert_signal (m, f->sender_name, "/foo",
841 "com.example.bar", "UnicastSignal2", "", f->recipient_name);
842 dbus_message_unref (m);
844 m = g_queue_pop_head (&f->monitored);
845 assert_signal (m, f->sender_name, "/foo",
846 "com.example.bar", "UnicastSignal3", "", f->recipient_name);
847 dbus_message_unref (m);
849 m = g_queue_pop_head (&f->monitored);
850 g_assert (m == NULL);
854 test_forbidden (Fixture *f,
855 gconstpointer context)
859 if (f->address == NULL)
864 m = dbus_message_new_signal ("/foo", "com.example.CannotSend",
866 if (!dbus_message_set_destination (m, f->recipient_name))
868 dbus_connection_send (f->sender, m, NULL);
869 dbus_message_unref (m);
871 m = dbus_message_new_signal ("/foo", "com.example.CannotReceive",
873 if (!dbus_message_set_destination (m, f->recipient_name))
875 dbus_connection_send (f->sender, m, NULL);
876 dbus_message_unref (m);
878 m = dbus_message_new_signal ("/foo", "com.example.CannotSend",
880 if (!dbus_message_set_destination (m, f->recipient_name))
882 dbus_connection_send (f->sender, m, NULL);
883 dbus_message_unref (m);
885 while (g_queue_get_length (&f->monitored) < 6)
886 test_main_context_iterate (f->ctx, TRUE);
888 m = g_queue_pop_head (&f->monitored);
889 assert_signal (m, f->sender_name, "/foo",
890 "com.example.CannotSend", "UnicastSignal1", "", f->recipient_name);
891 dbus_message_unref (m);
893 m = g_queue_pop_head (&f->monitored);
894 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
895 DBUS_ERROR_ACCESS_DENIED);
896 dbus_message_unref (m);
898 m = g_queue_pop_head (&f->monitored);
899 assert_signal (m, f->sender_name, "/foo",
900 "com.example.CannotReceive", "UnicastSignal2", "", f->recipient_name);
901 dbus_message_unref (m);
903 m = g_queue_pop_head (&f->monitored);
904 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
905 DBUS_ERROR_ACCESS_DENIED);
906 dbus_message_unref (m);
908 m = g_queue_pop_head (&f->monitored);
909 assert_signal (m, f->sender_name, "/foo",
910 "com.example.CannotSend", "UnicastSignal3", "", f->recipient_name);
911 dbus_message_unref (m);
913 m = g_queue_pop_head (&f->monitored);
914 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
915 DBUS_ERROR_ACCESS_DENIED);
916 dbus_message_unref (m);
918 m = g_queue_pop_head (&f->monitored);
919 g_assert (m == NULL);
923 test_method_call (Fixture *f,
924 gconstpointer context)
928 if (f->address == NULL)
933 /* regression test for
934 * https://bugs.freedesktop.org/show_bug.cgi?id=90952 */
935 m = dbus_message_new_method_call (f->recipient_name, "/foo",
936 DBUS_INTERFACE_PEER, "Ping");
937 dbus_connection_send (f->sender, m, NULL);
938 dbus_message_unref (m);
940 while (g_queue_get_length (&f->monitored) < 2)
941 test_main_context_iterate (f->ctx, TRUE);
943 m = g_queue_pop_head (&f->monitored);
944 assert_method_call (m, f->sender_name, f->recipient_name, "/foo",
945 DBUS_INTERFACE_PEER, "Ping", "");
946 dbus_message_unref (m);
948 m = g_queue_pop_head (&f->monitored);
949 assert_method_reply (m, f->recipient_name, f->sender_name, "");
950 dbus_message_unref (m);
952 m = g_queue_pop_head (&f->monitored);
953 g_assert (m == NULL);
955 m = dbus_message_new_method_call (f->recipient_name, "/foo", "com.example.bar",
957 dbus_connection_send (f->sender, m, NULL);
958 dbus_message_unref (m);
960 while (g_queue_get_length (&f->monitored) < 2)
961 test_main_context_iterate (f->ctx, TRUE);
963 m = g_queue_pop_head (&f->monitored);
964 assert_method_call (m, f->sender_name, f->recipient_name, "/foo",
965 "com.example.bar", "Call1", "");
966 dbus_message_unref (m);
968 m = g_queue_pop_head (&f->monitored);
969 assert_error_reply (m, f->recipient_name, f->sender_name,
970 DBUS_ERROR_UNKNOWN_METHOD);
971 dbus_message_unref (m);
973 m = g_queue_pop_head (&f->monitored);
974 g_assert (m == NULL);
978 test_forbidden_method_call (Fixture *f,
979 gconstpointer context)
983 if (f->address == NULL)
988 m = dbus_message_new_method_call (f->recipient_name, "/foo",
989 "com.example.CannotSend", "Call1");
990 dbus_connection_send (f->sender, m, NULL);
991 dbus_message_unref (m);
993 while (g_queue_get_length (&f->monitored) < 2)
994 test_main_context_iterate (f->ctx, TRUE);
996 m = g_queue_pop_head (&f->monitored);
997 assert_method_call (m, f->sender_name, f->recipient_name, "/foo",
998 "com.example.CannotSend", "Call1", "");
999 dbus_message_unref (m);
1001 m = g_queue_pop_head (&f->monitored);
1002 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
1003 DBUS_ERROR_ACCESS_DENIED);
1004 dbus_message_unref (m);
1006 m = g_queue_pop_head (&f->monitored);
1007 g_assert (m == NULL);
1009 m = dbus_message_new_method_call (f->recipient_name, "/foo",
1010 "com.example.CannotReceive", "Call2");
1011 dbus_connection_send (f->sender, m, NULL);
1012 dbus_message_unref (m);
1014 while (g_queue_get_length (&f->monitored) < 2)
1015 test_main_context_iterate (f->ctx, TRUE);
1017 m = g_queue_pop_head (&f->monitored);
1018 assert_method_call (m, f->sender_name, f->recipient_name, "/foo",
1019 "com.example.CannotReceive", "Call2", "");
1020 dbus_message_unref (m);
1022 m = g_queue_pop_head (&f->monitored);
1023 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
1024 DBUS_ERROR_ACCESS_DENIED);
1025 dbus_message_unref (m);
1027 m = g_queue_pop_head (&f->monitored);
1028 g_assert (m == NULL);
1032 test_dbus_daemon (Fixture *f,
1033 gconstpointer context)
1038 if (f->address == NULL)
1043 res = dbus_bus_request_name (f->sender, "com.example.Sender",
1044 DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
1045 test_assert_no_error (&f->e);
1046 g_assert_cmpint (res, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
1048 res = dbus_bus_release_name (f->sender, "com.example.Sender", &f->e);
1049 test_assert_no_error (&f->e);
1050 g_assert_cmpint (res, ==, DBUS_RELEASE_NAME_REPLY_RELEASED);
1052 while (g_queue_get_length (&f->monitored) < 8)
1053 test_main_context_iterate (f->ctx, TRUE);
1055 m = g_queue_pop_head (&f->monitored);
1056 assert_method_call (m, f->sender_name, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1057 DBUS_INTERFACE_DBUS, "RequestName", "su");
1058 dbus_message_unref (m);
1060 m = g_queue_pop_head (&f->monitored);
1061 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1062 "NameOwnerChanged", "sss", NULL);
1063 dbus_message_unref (m);
1065 /* FIXME: should we get this? */
1066 m = g_queue_pop_head (&f->monitored);
1067 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1068 "NameAcquired", "s", f->sender_name);
1069 dbus_message_unref (m);
1071 m = g_queue_pop_head (&f->monitored);
1072 assert_method_reply (m, DBUS_SERVICE_DBUS, f->sender_name, "u");
1073 dbus_message_unref (m);
1075 m = g_queue_pop_head (&f->monitored);
1076 assert_method_call (m, f->sender_name, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1077 DBUS_INTERFACE_DBUS, "ReleaseName", "s");
1078 dbus_message_unref (m);
1080 /* FIXME: should we get this? */
1081 m = g_queue_pop_head (&f->monitored);
1082 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1083 "NameLost", "s", f->sender_name);
1084 dbus_message_unref (m);
1086 m = g_queue_pop_head (&f->monitored);
1087 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1088 "NameOwnerChanged", "sss", NULL);
1089 dbus_message_unref (m);
1091 m = g_queue_pop_head (&f->monitored);
1092 assert_method_reply (m, DBUS_SERVICE_DBUS, f->sender_name, "u");
1093 dbus_message_unref (m);
1095 m = g_queue_pop_head (&f->monitored);
1096 g_assert (m == NULL);
1100 test_selective (Fixture *f,
1101 gconstpointer context)
1105 if (f->address == NULL)
1108 /* Match rules added before becoming a monitor should be cleared:
1109 * if they weren't, this test would get Interesting twice, then Tedious,
1110 * and only see Fun after that. */
1111 dbus_bus_add_match (f->monitor,
1112 "eavesdrop='true',interface='com.example.Interesting'", &f->e);
1113 test_assert_no_error (&f->e);
1114 dbus_bus_add_match (f->monitor,
1115 "eavesdrop='true',interface='com.example.Tedious'", &f->e);
1116 test_assert_no_error (&f->e);
1120 m = dbus_message_new_signal ("/foo", "com.example.Interesting",
1122 if (!dbus_message_set_destination (m, f->recipient_name))
1124 dbus_connection_send (f->sender, m, NULL);
1125 dbus_message_unref (m);
1127 m = dbus_message_new_signal ("/foo", "com.example.Tedious",
1129 if (!dbus_message_set_destination (m, f->recipient_name))
1131 dbus_connection_send (f->sender, m, NULL);
1132 dbus_message_unref (m);
1134 m = dbus_message_new_signal ("/foo", "com.example.Fun",
1136 if (!dbus_message_set_destination (m, f->recipient_name))
1138 dbus_connection_send (f->sender, m, NULL);
1139 dbus_message_unref (m);
1141 while (g_queue_get_length (&f->monitored) < 2)
1142 test_main_context_iterate (f->ctx, TRUE);
1144 /* We get the interesting signal and the fun signal, but not the tedious
1147 m = g_queue_pop_head (&f->monitored);
1148 assert_signal (m, f->sender_name, "/foo",
1149 "com.example.Interesting", "UnicastSignal1", "", f->recipient_name);
1150 dbus_message_unref (m);
1152 m = g_queue_pop_head (&f->monitored);
1153 assert_signal (m, f->sender_name, "/foo",
1154 "com.example.Fun", "UnicastSignal3", "", f->recipient_name);
1155 dbus_message_unref (m);
1157 m = g_queue_pop_head (&f->monitored);
1158 g_assert (m == NULL);
1162 expect_new_connection (Fixture *f)
1166 while (g_queue_get_length (&f->monitored) < 4)
1167 test_main_context_iterate (f->ctx, TRUE);
1169 m = g_queue_pop_head (&f->monitored);
1171 dbus_message_unref (m);
1173 m = g_queue_pop_head (&f->monitored);
1174 assert_hello_reply (m);
1175 dbus_message_unref (m);
1177 m = g_queue_pop_head (&f->monitored);
1178 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1179 "NameOwnerChanged", "sss", NULL);
1180 dbus_message_unref (m);
1182 m = g_queue_pop_head (&f->monitored);
1183 assert_name_acquired (m);
1184 dbus_message_unref (m);
1188 take_well_known_name (Fixture *f,
1189 DBusConnection *connection,
1194 ret = dbus_bus_request_name (connection, name,
1195 DBUS_NAME_FLAG_DO_NOT_QUEUE, &f->e);
1196 test_assert_no_error (&f->e);
1197 g_assert_cmpint (ret, ==, DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER);
1201 expect_take_well_known_name (Fixture *f,
1202 DBusConnection *connection,
1206 const char *connection_name = dbus_bus_get_unique_name (connection);
1208 while (g_queue_get_length (&f->monitored) < 4)
1209 test_main_context_iterate (f->ctx, TRUE);
1211 m = g_queue_pop_head (&f->monitored);
1212 assert_method_call (m, connection_name, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1213 DBUS_INTERFACE_DBUS, "RequestName", "su");
1214 dbus_message_unref (m);
1216 m = g_queue_pop_head (&f->monitored);
1217 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1218 "NameOwnerChanged", "sss", NULL);
1219 dbus_message_unref (m);
1221 m = g_queue_pop_head (&f->monitored);
1222 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS,
1223 "NameAcquired", "s", connection_name);
1224 dbus_message_unref (m);
1226 m = g_queue_pop_head (&f->monitored);
1227 assert_method_reply (m, DBUS_SERVICE_DBUS, connection_name, "u");
1228 dbus_message_unref (m);
1232 test_activation (Fixture *f,
1233 gconstpointer context)
1237 if (f->address == NULL)
1242 /* The sender sends a message to an activatable service. */
1243 m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal1");
1244 if (!dbus_message_set_destination (m, "com.example.SystemdActivatable1"))
1246 dbus_connection_send (f->sender, m, NULL);
1247 dbus_message_unref (m);
1249 /* We observe the activation request, and the message that caused it,
1250 * before systemd has even joined the bus. */
1251 while (g_queue_get_length (&f->monitored) < 2)
1252 test_main_context_iterate (f->ctx, TRUE);
1254 m = g_queue_pop_head (&f->monitored);
1255 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1256 "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1257 "org.freedesktop.systemd1");
1258 dbus_message_unref (m);
1259 m = g_queue_pop_head (&f->monitored);
1260 assert_signal (m, f->sender_name, "/foo",
1261 "com.example.bar", "UnicastSignal1", "",
1262 "com.example.SystemdActivatable1");
1263 dbus_message_unref (m);
1265 /* The fake systemd connects to the bus. */
1266 f->systemd = test_connect_to_bus (f->ctx, f->address);
1267 if (!dbus_connection_add_filter (f->systemd, systemd_filter, f, NULL))
1269 f->systemd_name = dbus_bus_get_unique_name (f->systemd);
1271 expect_new_connection (f);
1272 take_well_known_name (f, f->systemd, "org.freedesktop.systemd1");
1273 expect_take_well_known_name (f, f->systemd, "org.freedesktop.systemd1");
1275 /* It gets its activation request. */
1276 while (f->systemd_message == NULL)
1277 test_main_context_iterate (f->ctx, TRUE);
1279 m = f->systemd_message;
1280 f->systemd_message = NULL;
1281 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1282 "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1283 "org.freedesktop.systemd1");
1284 dbus_message_unref (m);
1286 /* systemd starts the activatable service. */
1287 f->activated = test_connect_to_bus (f->ctx, f->address);
1288 if (!dbus_connection_add_filter (f->activated, activated_filter,
1291 f->activated_name = dbus_bus_get_unique_name (f->activated);
1293 expect_new_connection (f);
1294 take_well_known_name (f, f->activated, "com.example.SystemdActivatable1");
1295 expect_take_well_known_name (f, f->activated,
1296 "com.example.SystemdActivatable1");
1298 /* The message is delivered to the activatable service. */
1299 while (f->activated_message == NULL)
1300 test_main_context_iterate (f->ctx, TRUE);
1302 m = f->activated_message;
1303 f->activated_message = NULL;
1304 assert_signal (m, f->sender_name, "/foo",
1305 "com.example.bar", "UnicastSignal1", "",
1306 "com.example.SystemdActivatable1");
1307 dbus_message_unref (m);
1309 /* The sender sends a message to a different activatable service. */
1310 m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal2");
1311 if (!dbus_message_set_destination (m, "com.example.SystemdActivatable2"))
1313 dbus_connection_send (f->sender, m, NULL);
1314 dbus_message_unref (m);
1316 /* This time systemd is already ready for it. */
1317 while (g_queue_get_length (&f->monitored) < 2 ||
1318 f->systemd_message == NULL)
1319 test_main_context_iterate (f->ctx, TRUE);
1321 m = f->systemd_message;
1322 f->systemd_message = NULL;
1323 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1324 "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1325 "org.freedesktop.systemd1");
1326 dbus_message_unref (m);
1328 /* The monitor sees the activation request and the signal that
1330 m = g_queue_pop_head (&f->monitored);
1331 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1332 "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1333 "org.freedesktop.systemd1");
1334 dbus_message_unref (m);
1335 m = g_queue_pop_head (&f->monitored);
1336 assert_signal (m, f->sender_name, "/foo",
1337 "com.example.bar", "UnicastSignal2", "",
1338 "com.example.SystemdActivatable2");
1339 dbus_message_unref (m);
1341 /* The activatable service takes its name. Here I'm faking it by using
1342 * an existing connection. */
1343 take_well_known_name (f, f->activated, "com.example.SystemdActivatable2");
1345 /* The message is delivered to the activatable service.
1346 * Implementation detail: the monitor sees this happen before it even
1347 * sees that the name request happened, which is pretty odd. */
1348 while (f->activated_message == NULL)
1349 test_main_context_iterate (f->ctx, TRUE);
1351 m = f->activated_message;
1352 f->activated_message = NULL;
1353 assert_signal (m, f->sender_name, "/foo",
1354 "com.example.bar", "UnicastSignal2", "",
1355 "com.example.SystemdActivatable2");
1356 dbus_message_unref (m);
1358 expect_take_well_known_name (f, f->activated,
1359 "com.example.SystemdActivatable2");
1361 /* A third activation. */
1362 m = dbus_message_new_signal ("/foo", "com.example.bar", "UnicastSignal3");
1363 if (!dbus_message_set_destination (m, "com.example.SystemdActivatable3"))
1365 dbus_connection_send (f->sender, m, NULL);
1366 dbus_message_unref (m);
1368 /* Once again, we see the activation request and the reason. */
1369 while (g_queue_get_length (&f->monitored) < 2)
1370 test_main_context_iterate (f->ctx, TRUE);
1372 m = g_queue_pop_head (&f->monitored);
1373 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1374 "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1375 "org.freedesktop.systemd1");
1376 dbus_message_unref (m);
1377 m = g_queue_pop_head (&f->monitored);
1378 assert_signal (m, f->sender_name, "/foo",
1379 "com.example.bar", "UnicastSignal3", "",
1380 "com.example.SystemdActivatable3");
1381 dbus_message_unref (m);
1383 /* systemd gets the request too. */
1384 while (f->systemd_message == NULL)
1385 test_main_context_iterate (f->ctx, TRUE);
1387 m = f->systemd_message;
1388 f->systemd_message = NULL;
1389 assert_signal (m, DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
1390 "org.freedesktop.systemd1.Activator", "ActivationRequest", "s",
1391 "org.freedesktop.systemd1");
1392 dbus_message_unref (m);
1394 /* This time activation fails */
1395 m = dbus_message_new_signal ("/org/freedesktop/systemd1",
1396 "org.freedesktop.systemd1.Activator", "ActivationFailure");
1400 const char *unit = "dbus-com.example.SystemdActivatable3.service";
1401 const char *error_name = "com.example.Nope";
1402 const char *error_message = "Computer says no";
1404 if (!dbus_message_append_args (m,
1405 DBUS_TYPE_STRING, &unit,
1406 DBUS_TYPE_STRING, &error_name,
1407 DBUS_TYPE_STRING, &error_message,
1413 if (!dbus_message_set_destination (m, "org.freedesktop.DBus"))
1415 dbus_connection_send (f->systemd, m, NULL);
1416 dbus_message_unref (m);
1418 /* The monitor sees activation fail */
1420 /* Once again, we see the activation request and the reason. */
1421 while (g_queue_get_length (&f->monitored) < 1)
1422 test_main_context_iterate (f->ctx, TRUE);
1424 m = g_queue_pop_head (&f->monitored);
1425 assert_error_reply (m, DBUS_SERVICE_DBUS, f->sender_name,
1426 "com.example.Nope");
1427 dbus_message_unref (m);
1431 teardown (Fixture *f,
1432 gconstpointer context G_GNUC_UNUSED)
1434 dbus_error_free (&f->e);
1435 g_clear_error (&f->ge);
1437 if (f->monitor != NULL)
1439 dbus_connection_remove_filter (f->monitor, monitor_filter, f);
1440 dbus_connection_close (f->monitor);
1441 dbus_connection_unref (f->monitor);
1445 if (f->sender != NULL)
1447 dbus_connection_close (f->sender);
1448 dbus_connection_unref (f->sender);
1452 if (f->recipient != NULL)
1454 dbus_connection_remove_filter (f->recipient, recipient_filter, f);
1455 dbus_connection_close (f->recipient);
1456 dbus_connection_unref (f->recipient);
1457 f->recipient = NULL;
1460 if (f->systemd != NULL)
1462 dbus_connection_remove_filter (f->systemd, systemd_filter, f);
1463 dbus_connection_close (f->systemd);
1464 dbus_connection_unref (f->systemd);
1468 if (f->activated != NULL)
1470 dbus_connection_remove_filter (f->activated, activated_filter, f);
1471 dbus_connection_close (f->activated);
1472 dbus_connection_unref (f->activated);
1473 f->activated = NULL;
1476 test_kill_pid (f->daemon_pid);
1477 g_spawn_close_pid (f->daemon_pid);
1479 test_main_context_unref (f->ctx);
1481 g_queue_foreach (&f->monitored, (GFunc) dbus_message_unref, NULL);
1482 g_queue_clear (&f->monitored);
1484 g_free (f->address);
1491 test_init (&argc, &argv);
1493 g_test_add ("/monitor/become", Fixture, &side_effects_config,
1494 setup, test_become_monitor, teardown);
1495 g_test_add ("/monitor/broadcast", Fixture, NULL,
1496 setup, test_broadcast, teardown);
1497 g_test_add ("/monitor/forbidden-broadcast", Fixture, &forbidding_config,
1498 setup, test_forbidden_broadcast, teardown);
1499 g_test_add ("/monitor/unicast-signal", Fixture, NULL,
1500 setup, test_unicast_signal, teardown);
1501 g_test_add ("/monitor/forbidden", Fixture, &forbidding_config,
1502 setup, test_forbidden, teardown);
1503 g_test_add ("/monitor/method-call", Fixture, NULL,
1504 setup, test_method_call, teardown);
1505 g_test_add ("/monitor/forbidden-method", Fixture, &forbidding_config,
1506 setup, test_forbidden_method_call, teardown);
1507 g_test_add ("/monitor/dbus-daemon", Fixture, NULL,
1508 setup, test_dbus_daemon, teardown);
1509 g_test_add ("/monitor/selective", Fixture, &selective_config,
1510 setup, test_selective, teardown);
1511 g_test_add ("/monitor/wildcard", Fixture, &wildcard_config,
1512 setup, test_unicast_signal, teardown);
1513 g_test_add ("/monitor/no-rule", Fixture, &no_rules_config,
1514 setup, test_unicast_signal, teardown);
1515 g_test_add ("/monitor/eavesdrop", Fixture, &eavesdrop_config,
1516 setup, test_unicast_signal, teardown);
1517 g_test_add ("/monitor/no-eavesdrop", Fixture, &no_eavesdrop_config,
1518 setup, test_unicast_signal, teardown);
1519 g_test_add ("/monitor/activation", Fixture, &fake_systemd_config,
1520 setup, test_activation, teardown);
1522 return g_test_run ();