2 #include <gio/gunixsocketaddress.h>
3 #include <glib/gstdio.h>
6 #include "gdbus-sessionbus.h"
8 #include "glib/glib-private.h"
11 time_out (gpointer unused G_GNUC_UNUSED)
13 g_error ("Timed out");
17 add_timeout (guint seconds)
20 /* Safety-catch against the main loop having blocked */
23 return g_timeout_add_seconds_once (seconds, time_out, NULL);
27 cancel_timeout (guint timeout_id)
32 g_source_remove (timeout_id);
35 /* Markup printing {{{1 */
37 /* This used to be part of GLib, but it was removed before the stable
38 * release because it wasn't generally useful. We want it here, though.
41 indent_string (GString *string,
45 g_string_append_c (string, ' ');
49 g_menu_markup_print_string (GString *string,
54 gboolean need_nl = FALSE;
57 if G_UNLIKELY (string == NULL)
58 string = g_string_new (NULL);
60 n = g_menu_model_get_n_items (model);
62 for (i = 0; i < n; i++)
64 GMenuAttributeIter *attr_iter;
65 GMenuLinkIter *link_iter;
69 attr_iter = g_menu_model_iterate_item_attributes (model, i);
70 link_iter = g_menu_model_iterate_item_links (model, i);
71 contents = g_string_new (NULL);
72 attrs = g_string_new (NULL);
74 while (g_menu_attribute_iter_next (attr_iter))
76 const char *name = g_menu_attribute_iter_get_name (attr_iter);
77 GVariant *value = g_menu_attribute_iter_get_value (attr_iter);
79 if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
82 str = g_markup_printf_escaped (" %s='%s'", name, g_variant_get_string (value, NULL));
83 g_string_append (attrs, str);
93 printed = g_variant_print (value, TRUE);
94 type = g_variant_type_peek_string (g_variant_get_type (value));
95 str = g_markup_printf_escaped ("<attribute name='%s' type='%s'>%s</attribute>\n", name, type, printed);
96 indent_string (contents, indent + tabstop);
97 g_string_append (contents, str);
102 g_variant_unref (value);
104 g_object_unref (attr_iter);
106 while (g_menu_link_iter_next (link_iter))
108 const gchar *name = g_menu_link_iter_get_name (link_iter);
109 GMenuModel *menu = g_menu_link_iter_get_value (link_iter);
112 if (contents->str[0])
113 g_string_append_c (contents, '\n');
115 str = g_markup_printf_escaped ("<link name='%s'>\n", name);
116 indent_string (contents, indent + tabstop);
117 g_string_append (contents, str);
120 g_menu_markup_print_string (contents, menu, indent + 2 * tabstop, tabstop);
122 indent_string (contents, indent + tabstop);
123 g_string_append (contents, "</link>\n");
124 g_object_unref (menu);
126 g_object_unref (link_iter);
128 if (contents->str[0])
130 indent_string (string, indent);
131 g_string_append_printf (string, "<item%s>\n", attrs->str);
132 g_string_append (string, contents->str);
133 indent_string (string, indent);
134 g_string_append (string, "</item>\n");
141 g_string_append_c (string, '\n');
143 indent_string (string, indent);
144 g_string_append_printf (string, "<item%s/>\n", attrs->str);
148 g_string_free (contents, TRUE);
149 g_string_free (attrs, TRUE);
157 /* This utility struct is used by both the RandomMenu and MirrorMenu
158 * class implementations below.
161 GHashTable *attributes;
166 test_item_new (GHashTable *attributes,
171 item = g_slice_new (TestItem);
172 item->attributes = g_hash_table_ref (attributes);
173 item->links = g_hash_table_ref (links);
179 test_item_free (gpointer data)
181 TestItem *item = data;
183 g_hash_table_unref (item->attributes);
184 g_hash_table_unref (item->links);
186 g_slice_free (TestItem, item);
189 /* RandomMenu {{{1 */
194 GMenuModel parent_instance;
200 typedef GMenuModelClass RandomMenuClass;
202 static GType random_menu_get_type (void);
203 G_DEFINE_TYPE (RandomMenu, random_menu, G_TYPE_MENU_MODEL)
206 random_menu_is_mutable (GMenuModel *model)
212 random_menu_get_n_items (GMenuModel *model)
214 RandomMenu *menu = (RandomMenu *) model;
216 return g_sequence_get_length (menu->items);
220 random_menu_get_item_attributes (GMenuModel *model,
224 RandomMenu *menu = (RandomMenu *) model;
227 item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));
228 *table = g_hash_table_ref (item->attributes);
232 random_menu_get_item_links (GMenuModel *model,
236 RandomMenu *menu = (RandomMenu *) model;
239 item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));
240 *table = g_hash_table_ref (item->links);
244 random_menu_finalize (GObject *object)
246 RandomMenu *menu = (RandomMenu *) object;
248 g_sequence_free (menu->items);
250 G_OBJECT_CLASS (random_menu_parent_class)
255 random_menu_init (RandomMenu *menu)
260 random_menu_class_init (GMenuModelClass *class)
262 GObjectClass *object_class = G_OBJECT_CLASS (class);
264 class->is_mutable = random_menu_is_mutable;
265 class->get_n_items = random_menu_get_n_items;
266 class->get_item_attributes = random_menu_get_item_attributes;
267 class->get_item_links = random_menu_get_item_links;
269 object_class->finalize = random_menu_finalize;
272 static RandomMenu * random_menu_new (GRand *rand, gint order);
275 random_menu_change (RandomMenu *menu,
278 gint position, removes, adds;
279 GSequenceIter *point;
283 n_items = g_sequence_get_length (menu->items);
287 position = g_rand_int_range (rand, 0, n_items + 1);
288 removes = g_rand_int_range (rand, 0, n_items - position + 1);
289 adds = g_rand_int_range (rand, 0, MAX_ITEMS - (n_items - removes) + 1);
291 while (removes == 0 && adds == 0);
293 point = g_sequence_get_iter_at_pos (menu->items, position + removes);
297 GSequenceIter *start;
299 start = g_sequence_get_iter_at_pos (menu->items, position);
300 g_sequence_remove_range (start, point);
303 for (i = 0; i < adds; i++)
307 GHashTable *attributes;
309 attributes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
310 links = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_object_unref);
312 if (menu->order > 0 && g_rand_boolean (rand))
315 const gchar *subtype;
317 child = random_menu_new (rand, menu->order - 1);
319 if (g_rand_boolean (rand))
321 subtype = G_MENU_LINK_SECTION;
322 /* label some section headers */
323 if (g_rand_boolean (rand))
330 /* label all submenus */
331 subtype = G_MENU_LINK_SUBMENU;
335 g_hash_table_insert (links, g_strdup (subtype), child);
338 /* label all terminals */
342 g_hash_table_insert (attributes, g_strdup ("label"), g_variant_ref_sink (g_variant_new_string (label)));
344 g_sequence_insert_before (point, test_item_new (attributes, links));
345 g_hash_table_unref (links);
346 g_hash_table_unref (attributes);
349 g_menu_model_items_changed (G_MENU_MODEL (menu), position, removes, adds);
353 random_menu_new (GRand *rand,
358 menu = g_object_new (random_menu_get_type (), NULL);
359 menu->items = g_sequence_new (test_item_free);
362 random_menu_change (menu, rand);
367 /* MirrorMenu {{{1 */
369 GMenuModel parent_instance;
371 GMenuModel *clone_of;
376 typedef GMenuModelClass MirrorMenuClass;
378 static GType mirror_menu_get_type (void);
379 G_DEFINE_TYPE (MirrorMenu, mirror_menu, G_TYPE_MENU_MODEL)
382 mirror_menu_is_mutable (GMenuModel *model)
384 MirrorMenu *menu = (MirrorMenu *) model;
386 return menu->handler_id != 0;
390 mirror_menu_get_n_items (GMenuModel *model)
392 MirrorMenu *menu = (MirrorMenu *) model;
394 return g_sequence_get_length (menu->items);
398 mirror_menu_get_item_attributes (GMenuModel *model,
402 MirrorMenu *menu = (MirrorMenu *) model;
405 item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));
406 *table = g_hash_table_ref (item->attributes);
410 mirror_menu_get_item_links (GMenuModel *model,
414 MirrorMenu *menu = (MirrorMenu *) model;
417 item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));
418 *table = g_hash_table_ref (item->links);
422 mirror_menu_finalize (GObject *object)
424 MirrorMenu *menu = (MirrorMenu *) object;
426 if (menu->handler_id)
427 g_signal_handler_disconnect (menu->clone_of, menu->handler_id);
429 g_sequence_free (menu->items);
430 g_object_unref (menu->clone_of);
432 G_OBJECT_CLASS (mirror_menu_parent_class)
437 mirror_menu_init (MirrorMenu *menu)
442 mirror_menu_class_init (GMenuModelClass *class)
444 GObjectClass *object_class = G_OBJECT_CLASS (class);
446 class->is_mutable = mirror_menu_is_mutable;
447 class->get_n_items = mirror_menu_get_n_items;
448 class->get_item_attributes = mirror_menu_get_item_attributes;
449 class->get_item_links = mirror_menu_get_item_links;
451 object_class->finalize = mirror_menu_finalize;
454 static MirrorMenu * mirror_menu_new (GMenuModel *clone_of);
457 mirror_menu_changed (GMenuModel *model,
463 MirrorMenu *menu = user_data;
464 GSequenceIter *point;
467 g_assert (model == menu->clone_of);
469 point = g_sequence_get_iter_at_pos (menu->items, position + removed);
473 GSequenceIter *start;
475 start = g_sequence_get_iter_at_pos (menu->items, position);
476 g_sequence_remove_range (start, point);
479 for (i = position; i < position + added; i++)
481 GMenuAttributeIter *attr_iter;
482 GMenuLinkIter *link_iter;
484 GHashTable *attributes;
489 attributes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
490 links = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_object_unref);
492 attr_iter = g_menu_model_iterate_item_attributes (model, i);
493 while (g_menu_attribute_iter_get_next (attr_iter, &name, &value))
495 g_hash_table_insert (attributes, g_strdup (name), value);
497 g_object_unref (attr_iter);
499 link_iter = g_menu_model_iterate_item_links (model, i);
500 while (g_menu_link_iter_get_next (link_iter, &name, &child))
502 g_hash_table_insert (links, g_strdup (name), mirror_menu_new (child));
503 g_object_unref (child);
505 g_object_unref (link_iter);
507 g_sequence_insert_before (point, test_item_new (attributes, links));
508 g_hash_table_unref (attributes);
509 g_hash_table_unref (links);
512 g_menu_model_items_changed (G_MENU_MODEL (menu), position, removed, added);
516 mirror_menu_new (GMenuModel *clone_of)
520 menu = g_object_new (mirror_menu_get_type (), NULL);
521 menu->items = g_sequence_new (test_item_free);
522 menu->clone_of = g_object_ref (clone_of);
524 if (g_menu_model_is_mutable (clone_of))
525 menu->handler_id = g_signal_connect (clone_of, "items-changed", G_CALLBACK (mirror_menu_changed), menu);
526 mirror_menu_changed (clone_of, 0, 0, g_menu_model_get_n_items (clone_of), menu);
531 /* check_menus_equal(), assert_menus_equal() {{{1 */
533 check_menus_equal (GMenuModel *a,
536 gboolean equal = TRUE;
540 a_n = g_menu_model_get_n_items (a);
541 b_n = g_menu_model_get_n_items (b);
546 for (i = 0; i < a_n; i++)
548 GMenuAttributeIter *attr_iter;
549 GVariant *a_value, *b_value;
550 GMenuLinkIter *link_iter;
551 GMenuModel *a_menu, *b_menu;
554 attr_iter = g_menu_model_iterate_item_attributes (a, i);
555 while (g_menu_attribute_iter_get_next (attr_iter, &name, &a_value))
557 b_value = g_menu_model_get_item_attribute_value (b, i, name, NULL);
558 equal &= b_value && g_variant_equal (a_value, b_value);
560 g_variant_unref (b_value);
561 g_variant_unref (a_value);
563 g_object_unref (attr_iter);
565 attr_iter = g_menu_model_iterate_item_attributes (b, i);
566 while (g_menu_attribute_iter_get_next (attr_iter, &name, &b_value))
568 a_value = g_menu_model_get_item_attribute_value (a, i, name, NULL);
569 equal &= a_value && g_variant_equal (a_value, b_value);
571 g_variant_unref (a_value);
572 g_variant_unref (b_value);
574 g_object_unref (attr_iter);
576 link_iter = g_menu_model_iterate_item_links (a, i);
577 while (g_menu_link_iter_get_next (link_iter, &name, &a_menu))
579 b_menu = g_menu_model_get_item_link (b, i, name);
580 equal &= b_menu && check_menus_equal (a_menu, b_menu);
582 g_object_unref (b_menu);
583 g_object_unref (a_menu);
585 g_object_unref (link_iter);
587 link_iter = g_menu_model_iterate_item_links (b, i);
588 while (g_menu_link_iter_get_next (link_iter, &name, &b_menu))
590 a_menu = g_menu_model_get_item_link (a, i, name);
591 equal &= a_menu && check_menus_equal (a_menu, b_menu);
593 g_object_unref (a_menu);
594 g_object_unref (b_menu);
596 g_object_unref (link_iter);
603 assert_menus_equal (GMenuModel *a,
606 if (!check_menus_equal (a, b))
610 string = g_string_new ("\n <a>\n");
611 g_menu_markup_print_string (string, G_MENU_MODEL (a), 4, 2);
612 g_string_append (string, " </a>\n\n-------------\n <b>\n");
613 g_menu_markup_print_string (string, G_MENU_MODEL (b), 4, 2);
614 g_string_append (string, " </b>\n");
615 g_error ("%s", string->str);
620 assert_menuitem_equal (GMenuItem *item,
624 GMenuAttributeIter *attr_iter;
625 GMenuLinkIter *link_iter;
628 GMenuModel *linked_model;
630 /* NOTE we can't yet test whether item has attributes or links that
631 * are not in the model, because there's no iterator API for menu
634 attr_iter = g_menu_model_iterate_item_attributes (model, index);
635 while (g_menu_attribute_iter_get_next (attr_iter, &name, &value))
637 GVariant *item_value;
639 item_value = g_menu_item_get_attribute_value (item, name, g_variant_get_type (value));
640 g_assert (item_value && g_variant_equal (item_value, value));
642 g_variant_unref (item_value);
643 g_variant_unref (value);
646 link_iter = g_menu_model_iterate_item_links (model, index);
647 while (g_menu_link_iter_get_next (link_iter, &name, &linked_model))
649 GMenuModel *item_linked_model;
651 item_linked_model = g_menu_item_get_link (item, name);
652 g_assert (linked_model == item_linked_model);
654 g_object_unref (item_linked_model);
655 g_object_unref (linked_model);
658 g_object_unref (attr_iter);
659 g_object_unref (link_iter);
662 /* Test cases {{{1 */
666 GRand *randa, *randb;
670 seed = g_test_rand_int ();
672 randa = g_rand_new_with_seed (seed);
673 randb = g_rand_new_with_seed (seed);
675 for (i = 0; i < 500; i++)
679 a = random_menu_new (randa, TOP_ORDER);
680 b = random_menu_new (randb, TOP_ORDER);
681 assert_menus_equal (G_MENU_MODEL (a), G_MENU_MODEL (b));
688 for (i = 0; i < 500;)
692 a = random_menu_new (randa, TOP_ORDER);
693 b = random_menu_new (randb, TOP_ORDER);
694 if (check_menus_equal (G_MENU_MODEL (a), G_MENU_MODEL (b)))
696 /* by chance, they may really be equal. double check. */
699 as = g_menu_markup_print_string (NULL, G_MENU_MODEL (a), 4, 2);
700 bs = g_menu_markup_print_string (NULL, G_MENU_MODEL (b), 4, 2);
701 g_assert_cmpstr (as->str, ==, bs->str);
702 g_string_free (bs, TRUE);
703 g_string_free (as, TRUE);
705 /* we're here because randa and randb just generated equal
706 * menus. they may do it again, so throw away randb and make
710 randb = g_rand_new_with_seed (g_rand_int (randa));
713 /* make sure we get enough unequals (ie: no GRand failure) */
732 rand = g_rand_new_with_seed (g_test_rand_int ());
733 random = random_menu_new (rand, TOP_ORDER);
734 mirror = mirror_menu_new (G_MENU_MODEL (random));
736 for (i = 0; i < 500; i++)
738 assert_menus_equal (G_MENU_MODEL (random), G_MENU_MODEL (mirror));
739 random_menu_change (random, rand);
742 g_object_unref (mirror);
743 g_object_unref (random);
750 GDBusConnection *client_connection;
751 GDBusConnection *server_connection;
754 GThread *service_thread;
755 /* Protects server_connection and service_loop. */
756 GMutex service_loop_lock;
757 GCond service_loop_cond;
759 GMainLoop *service_loop;
763 on_new_connection (GDBusServer *server,
764 GDBusConnection *connection,
767 PeerConnection *data = user_data;
769 g_mutex_lock (&data->service_loop_lock);
770 data->server_connection = g_object_ref (connection);
771 g_cond_broadcast (&data->service_loop_cond);
772 g_mutex_unlock (&data->service_loop_lock);
778 create_service_loop (GMainContext *service_context,
779 PeerConnection *data)
781 g_assert (data->service_loop == NULL);
782 g_mutex_lock (&data->service_loop_lock);
783 data->service_loop = g_main_loop_new (service_context, FALSE);
784 g_cond_broadcast (&data->service_loop_cond);
785 g_mutex_unlock (&data->service_loop_lock);
789 teardown_service_loop (PeerConnection *data)
791 g_mutex_lock (&data->service_loop_lock);
792 g_clear_pointer (&data->service_loop, g_main_loop_unref);
793 g_mutex_unlock (&data->service_loop_lock);
797 await_service_loop (PeerConnection *data)
799 g_mutex_lock (&data->service_loop_lock);
800 while (data->service_loop == NULL)
801 g_cond_wait (&data->service_loop_cond, &data->service_loop_lock);
802 g_mutex_unlock (&data->service_loop_lock);
806 await_server_connection (PeerConnection *data)
808 g_mutex_lock (&data->service_loop_lock);
809 while (data->server_connection == NULL)
810 g_cond_wait (&data->service_loop_cond, &data->service_loop_lock);
811 g_mutex_unlock (&data->service_loop_lock);
815 service_thread_func (gpointer user_data)
817 PeerConnection *data = user_data;
818 GMainContext *service_context;
822 GDBusServerFlags flags;
825 service_context = g_main_context_new ();
826 g_main_context_push_thread_default (service_context);
829 flags = G_DBUS_SERVER_FLAGS_NONE;
832 tmpdir = g_dir_make_tmp ("test-dbus-peer-XXXXXX", NULL);
833 address = g_strdup_printf ("unix:tmpdir=%s", tmpdir);
835 address = g_strdup ("nonce-tcp:");
836 flags |= G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
839 guid = g_dbus_generate_guid ();
842 data->server = g_dbus_server_new_sync (address,
848 g_assert_no_error (error);
852 g_signal_connect (data->server,
854 G_CALLBACK (on_new_connection),
857 g_dbus_server_start (data->server);
859 create_service_loop (service_context, data);
860 g_main_loop_run (data->service_loop);
862 g_main_context_pop_thread_default (service_context);
864 teardown_service_loop (data);
865 g_main_context_unref (service_context);
877 peer_connection_up (PeerConnection *data)
881 memset (data, '\0', sizeof (PeerConnection));
883 g_mutex_init (&data->service_loop_lock);
884 g_cond_init (&data->service_loop_cond);
886 /* bring up a server - we run the server in a different thread to
888 data->service_thread = g_thread_new ("test_dbus_peer",
891 await_service_loop (data);
892 g_assert (data->server != NULL);
894 /* bring up a connection and accept it */
896 data->client_connection =
897 g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (data->server),
898 G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
899 NULL, /* GDBusAuthObserver */
900 NULL, /* cancellable */
902 g_assert_no_error (error);
903 g_assert (data->client_connection != NULL);
904 await_server_connection (data);
908 peer_connection_down (PeerConnection *data)
910 g_object_unref (data->client_connection);
911 g_object_unref (data->server_connection);
913 g_dbus_server_stop (data->server);
914 g_object_unref (data->server);
916 g_main_loop_quit (data->service_loop);
917 g_thread_join (data->service_thread);
919 g_mutex_clear (&data->service_loop_lock);
920 g_cond_clear (&data->service_loop_cond);
923 struct roundtrip_state
926 MirrorMenu *proxy_mirror;
927 GDBusMenuModel *proxy;
935 roundtrip_step (gpointer data)
937 struct roundtrip_state *state = data;
939 if (check_menus_equal (G_MENU_MODEL (state->random), G_MENU_MODEL (state->proxy)) &&
940 check_menus_equal (G_MENU_MODEL (state->random), G_MENU_MODEL (state->proxy_mirror)))
945 if (state->success < 100)
946 random_menu_change (state->random, state->rand);
948 g_main_loop_quit (state->loop);
950 else if (state->count == 100)
952 assert_menus_equal (G_MENU_MODEL (state->random), G_MENU_MODEL (state->proxy));
953 g_assert_not_reached ();
958 return G_SOURCE_CONTINUE;
962 do_roundtrip (GDBusConnection *exporter_connection,
963 GDBusConnection *proxy_connection)
965 struct roundtrip_state state;
969 state.rand = g_rand_new_with_seed (g_test_rand_int ());
971 state.random = random_menu_new (state.rand, 2);
972 export_id = g_dbus_connection_export_menu_model (exporter_connection,
974 G_MENU_MODEL (state.random),
976 state.proxy = g_dbus_menu_model_get (proxy_connection,
977 g_dbus_connection_get_unique_name (proxy_connection),
979 state.proxy_mirror = mirror_menu_new (G_MENU_MODEL (state.proxy));
983 id = g_timeout_add (10, roundtrip_step, &state);
985 state.loop = g_main_loop_new (NULL, FALSE);
986 g_main_loop_run (state.loop);
988 g_main_loop_unref (state.loop);
989 g_source_remove (id);
990 g_object_unref (state.proxy);
991 g_dbus_connection_unexport_menu_model (exporter_connection, export_id);
992 g_object_unref (state.random);
993 g_object_unref (state.proxy_mirror);
994 g_rand_free (state.rand);
998 test_dbus_roundtrip (void)
1000 GDBusConnection *bus;
1002 bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
1003 do_roundtrip (bus, bus);
1004 g_object_unref (bus);
1008 test_dbus_peer_roundtrip (void)
1010 #ifdef _GLIB_ADDRESS_SANITIZER
1011 g_test_incomplete ("FIXME: Leaks a GCancellableSource, see glib#2313");
1012 (void) peer_connection_up;
1013 (void) peer_connection_down;
1015 PeerConnection peer;
1017 peer_connection_up (&peer);
1018 do_roundtrip (peer.server_connection, peer.client_connection);
1019 peer_connection_down (&peer);
1023 static gint items_changed_count;
1026 items_changed (GMenuModel *model,
1032 items_changed_count++;
1036 stop_loop (gpointer data)
1038 GMainLoop *loop = data;
1040 g_main_loop_quit (loop);
1042 return G_SOURCE_REMOVE;
1046 do_subscriptions (GDBusConnection *exporter_connection,
1047 GDBusConnection *proxy_connection)
1050 GDBusMenuModel *proxy;
1052 GError *error = NULL;
1056 timeout_id = add_timeout (60);
1057 loop = g_main_loop_new (NULL, FALSE);
1059 menu = g_menu_new ();
1061 export_id = g_dbus_connection_export_menu_model (exporter_connection,
1063 G_MENU_MODEL (menu),
1065 g_assert_no_error (error);
1067 proxy = g_dbus_menu_model_get (proxy_connection,
1068 g_dbus_connection_get_unique_name (proxy_connection),
1070 items_changed_count = 0;
1071 g_signal_connect (proxy, "items-changed",
1072 G_CALLBACK (items_changed), NULL);
1074 g_menu_append (menu, "item1", NULL);
1075 g_menu_append (menu, "item2", NULL);
1076 g_menu_append (menu, "item3", NULL);
1078 g_assert_cmpint (items_changed_count, ==, 0);
1080 /* We don't subscribe to change-notification until we look at the items */
1081 g_timeout_add (100, stop_loop, loop);
1082 g_main_loop_run (loop);
1084 /* Looking at the items triggers subscription */
1085 g_menu_model_get_n_items (G_MENU_MODEL (proxy));
1087 while (items_changed_count < 1)
1088 g_main_context_iteration (NULL, TRUE);
1090 /* We get all three items in one batch */
1091 g_assert_cmpint (items_changed_count, ==, 1);
1092 g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (proxy)), ==, 3);
1094 /* If we wait, we don't get any more */
1095 g_timeout_add (100, stop_loop, loop);
1096 g_main_loop_run (loop);
1097 g_assert_cmpint (items_changed_count, ==, 1);
1098 g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (proxy)), ==, 3);
1100 /* Now we're subscribed, we get changes individually */
1101 g_menu_append (menu, "item4", NULL);
1102 g_menu_append (menu, "item5", NULL);
1103 g_menu_append (menu, "item6", NULL);
1104 g_menu_remove (menu, 0);
1105 g_menu_remove (menu, 0);
1107 while (items_changed_count < 6)
1108 g_main_context_iteration (NULL, TRUE);
1110 g_assert_cmpint (items_changed_count, ==, 6);
1112 g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (proxy)), ==, 4);
1114 /* After destroying the proxy and waiting a bit, we don't get any more
1115 * items-changed signals */
1116 g_object_unref (proxy);
1118 g_timeout_add (100, stop_loop, loop);
1119 g_main_loop_run (loop);
1121 g_menu_remove (menu, 0);
1122 g_menu_remove (menu, 0);
1124 g_timeout_add (100, stop_loop, loop);
1125 g_main_loop_run (loop);
1127 g_assert_cmpint (items_changed_count, ==, 6);
1129 g_dbus_connection_unexport_menu_model (exporter_connection, export_id);
1130 g_object_unref (menu);
1132 g_main_loop_unref (loop);
1133 cancel_timeout (timeout_id);
1137 test_dbus_subscriptions (void)
1139 GDBusConnection *bus;
1141 bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
1142 do_subscriptions (bus, bus);
1143 g_object_unref (bus);
1147 test_dbus_peer_subscriptions (void)
1149 #ifdef _GLIB_ADDRESS_SANITIZER
1150 g_test_incomplete ("FIXME: Leaks a GCancellableSource, see glib#2313");
1151 (void) peer_connection_up;
1152 (void) peer_connection_down;
1154 PeerConnection peer;
1156 peer_connection_up (&peer);
1157 do_subscriptions (peer.server_connection, peer.client_connection);
1158 peer_connection_down (&peer);
1163 test_dbus_export_error_handling (void)
1166 RandomMenu *menu = NULL;
1167 GDBusConnection *bus;
1168 GError *local_error = NULL;
1171 g_test_summary ("Test that error handling of menu model export failure works");
1172 g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/3366");
1174 bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
1176 rand = g_rand_new_with_seed (g_test_rand_int ());
1177 menu = random_menu_new (rand, 2);
1179 id1 = g_dbus_connection_export_menu_model (bus, "/", G_MENU_MODEL (menu), &local_error);
1180 g_assert_no_error (local_error);
1181 g_assert_cmpuint (id1, !=, 0);
1183 /* Trigger a failure by trying to export on a path which is already in use */
1184 id2 = g_dbus_connection_export_menu_model (bus, "/", G_MENU_MODEL (menu), &local_error);
1185 g_assert_error (local_error, G_IO_ERROR, G_IO_ERROR_EXISTS);
1186 g_assert_cmpuint (id2, ==, 0);
1187 g_clear_error (&local_error);
1189 g_dbus_connection_unexport_menu_model (bus, id1);
1191 while (g_main_context_iteration (NULL, FALSE));
1193 g_clear_object (&menu);
1195 g_clear_object (&bus);
1199 do_modify (gpointer data)
1201 RandomMenu *menu = data;
1205 rand = g_rand_new_with_seed (g_test_rand_int ());
1207 for (i = 0; i < 10000; i++)
1209 random_menu_change (menu, rand);
1218 do_export (gpointer data)
1220 GMenuModel *menu = data;
1222 GDBusConnection *bus;
1224 GError *error = NULL;
1227 bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
1228 path = g_strdup_printf ("/%p", data);
1230 for (i = 0; i < 10000; i++)
1232 id = g_dbus_connection_export_menu_model (bus, path, menu, &error);
1233 g_assert_no_error (error);
1234 g_dbus_connection_unexport_menu_model (bus, id);
1235 while (g_main_context_iteration (NULL, FALSE));
1240 g_object_unref (bus);
1246 test_dbus_threaded (void)
1248 RandomMenu *menu[10];
1250 GThread *export[10];
1253 for (i = 0; i < 10; i++)
1255 GRand *rand = g_rand_new_with_seed (g_test_rand_int ());
1256 menu[i] = random_menu_new (rand, 2);
1257 call[i] = g_thread_new ("call", do_modify, menu[i]);
1258 export[i] = g_thread_new ("export", do_export, menu[i]);
1262 for (i = 0; i < 10; i++)
1264 g_thread_join (call[i]);
1265 g_thread_join (export[i]);
1268 for (i = 0; i < 10; i++)
1269 g_object_unref (menu[i]);
1273 test_attributes (void)
1279 menu = g_menu_new ();
1281 item = g_menu_item_new ("test", NULL);
1282 g_menu_item_set_attribute_value (item, "boolean", g_variant_new_boolean (FALSE));
1283 g_menu_item_set_attribute_value (item, "string", g_variant_new_string ("bla"));
1285 g_menu_item_set_attribute (item, "double", "d", 1.5);
1286 v = g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three");
1287 g_menu_item_set_attribute_value (item, "complex", v);
1288 g_menu_item_set_attribute_value (item, "test-123", g_variant_new_string ("test-123"));
1290 g_menu_append_item (menu, item);
1292 g_menu_item_set_attribute (item, "double", "d", G_PI);
1294 g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (menu)), ==, 1);
1296 v = g_menu_model_get_item_attribute_value (G_MENU_MODEL (menu), 0, "boolean", NULL);
1297 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_BOOLEAN));
1298 g_variant_unref (v);
1300 v = g_menu_model_get_item_attribute_value (G_MENU_MODEL (menu), 0, "string", NULL);
1301 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
1302 g_variant_unref (v);
1304 v = g_menu_model_get_item_attribute_value (G_MENU_MODEL (menu), 0, "double", NULL);
1305 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_DOUBLE));
1306 g_variant_unref (v);
1308 v = g_menu_model_get_item_attribute_value (G_MENU_MODEL (menu), 0, "complex", NULL);
1309 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE("a(si)")));
1310 g_variant_unref (v);
1312 g_menu_remove_all (menu);
1314 g_object_unref (menu);
1315 g_object_unref (item);
1319 test_attribute_iter (void)
1325 GMenuAttributeIter *iter;
1328 menu = g_menu_new ();
1330 item = g_menu_item_new ("test", NULL);
1331 g_menu_item_set_attribute_value (item, "boolean", g_variant_new_boolean (FALSE));
1332 g_menu_item_set_attribute_value (item, "string", g_variant_new_string ("bla"));
1334 g_menu_item_set_attribute (item, "double", "d", 1.5);
1335 v = g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three");
1336 g_menu_item_set_attribute_value (item, "complex", v);
1337 g_menu_item_set_attribute_value (item, "test-123", g_variant_new_string ("test-123"));
1339 g_menu_append_item (menu, item);
1341 g_menu_item_set_attribute (item, "double", "d", G_PI);
1343 g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (menu)), ==, 1);
1345 found = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)g_variant_unref);
1347 iter = g_menu_model_iterate_item_attributes (G_MENU_MODEL (menu), 0);
1348 while (g_menu_attribute_iter_get_next (iter, &name, &v))
1349 g_hash_table_insert (found, g_strdup (name), v);
1350 g_object_unref (iter);
1352 g_assert_cmpint (g_hash_table_size (found), ==, 6);
1354 v = g_hash_table_lookup (found, "label");
1355 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
1357 v = g_hash_table_lookup (found, "boolean");
1358 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_BOOLEAN));
1360 v = g_hash_table_lookup (found, "string");
1361 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
1363 v = g_hash_table_lookup (found, "double");
1364 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_DOUBLE));
1366 v = g_hash_table_lookup (found, "complex");
1367 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE("a(si)")));
1369 v = g_hash_table_lookup (found, "test-123");
1370 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
1372 g_hash_table_unref (found);
1374 g_menu_remove_all (menu);
1376 g_object_unref (menu);
1377 g_object_unref (item);
1388 m = G_MENU_MODEL (g_menu_new ());
1389 g_menu_append (G_MENU (m), "test", NULL);
1391 menu = g_menu_new ();
1393 item = g_menu_item_new ("test2", NULL);
1394 g_menu_item_set_link (item, "submenu", m);
1395 g_menu_prepend_item (menu, item);
1396 g_object_unref (item);
1398 item = g_menu_item_new ("test1", NULL);
1399 g_menu_item_set_link (item, "section", m);
1400 g_menu_insert_item (menu, 0, item);
1401 g_object_unref (item);
1403 item = g_menu_item_new ("test3", NULL);
1404 g_menu_item_set_link (item, "wallet", m);
1405 g_menu_insert_item (menu, 1000, item);
1406 g_object_unref (item);
1408 item = g_menu_item_new ("test4", NULL);
1409 g_menu_item_set_link (item, "purse", m);
1410 g_menu_item_set_link (item, "purse", NULL);
1411 g_menu_append_item (menu, item);
1412 g_object_unref (item);
1414 g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (menu)), ==, 4);
1416 x = g_menu_model_get_item_link (G_MENU_MODEL (menu), 0, "section");
1420 x = g_menu_model_get_item_link (G_MENU_MODEL (menu), 1, "submenu");
1424 x = g_menu_model_get_item_link (G_MENU_MODEL (menu), 2, "wallet");
1428 x = g_menu_model_get_item_link (G_MENU_MODEL (menu), 3, "purse");
1429 g_assert (x == NULL);
1432 g_object_unref (menu);
1440 menu = g_menu_new ();
1441 g_menu_append (menu, "test", "test");
1443 g_assert (g_menu_model_is_mutable (G_MENU_MODEL (menu)));
1444 g_menu_freeze (menu);
1445 g_assert (!g_menu_model_is_mutable (G_MENU_MODEL (menu)));
1447 g_object_unref (menu);
1451 test_convenience (void)
1459 sub = g_menu_new ();
1461 g_menu_prepend (m1, "label1", "do::something");
1462 g_menu_insert (m2, 0, "label1", "do::something");
1464 g_menu_append (m1, "label2", "do::somethingelse");
1465 g_menu_insert (m2, -1, "label2", "do::somethingelse");
1467 g_menu_insert_section (m1, 10, "label3", G_MENU_MODEL (sub));
1468 item = g_menu_item_new_section ("label3", G_MENU_MODEL (sub));
1469 g_menu_insert_item (m2, 10, item);
1470 g_object_unref (item);
1472 g_menu_prepend_section (m1, "label4", G_MENU_MODEL (sub));
1473 g_menu_insert_section (m2, 0, "label4", G_MENU_MODEL (sub));
1475 g_menu_append_section (m1, "label5", G_MENU_MODEL (sub));
1476 g_menu_insert_section (m2, -1, "label5", G_MENU_MODEL (sub));
1478 g_menu_insert_submenu (m1, 5, "label6", G_MENU_MODEL (sub));
1479 item = g_menu_item_new_submenu ("label6", G_MENU_MODEL (sub));
1480 g_menu_insert_item (m2, 5, item);
1481 g_object_unref (item);
1483 g_menu_prepend_submenu (m1, "label7", G_MENU_MODEL (sub));
1484 g_menu_insert_submenu (m2, 0, "label7", G_MENU_MODEL (sub));
1486 g_menu_append_submenu (m1, "label8", G_MENU_MODEL (sub));
1487 g_menu_insert_submenu (m2, -1, "label8", G_MENU_MODEL (sub));
1489 assert_menus_equal (G_MENU_MODEL (m1), G_MENU_MODEL (m2));
1491 g_object_unref (m1);
1492 g_object_unref (m2);
1493 g_object_unref (sub);
1497 test_menuitem (void)
1506 menu = g_menu_new ();
1507 submenu = g_menu_new ();
1509 item = g_menu_item_new ("label", "action");
1510 g_menu_item_set_attribute (item, "attribute", "b", TRUE);
1511 g_menu_item_set_link (item, G_MENU_LINK_SUBMENU, G_MENU_MODEL (submenu));
1512 g_menu_append_item (menu, item);
1514 icon = g_themed_icon_new ("bla");
1515 g_menu_item_set_icon (item, icon);
1516 g_object_unref (icon);
1518 g_assert (g_menu_item_get_attribute (item, "attribute", "b", &b));
1521 g_menu_item_set_action_and_target (item, "action", "(bs)", TRUE, "string");
1522 g_assert (g_menu_item_get_attribute (item, "target", "(bs)", &b, &s));
1524 g_assert_cmpstr (s, ==, "string");
1527 g_object_unref (item);
1529 item = g_menu_item_new_from_model (G_MENU_MODEL (menu), 0);
1530 assert_menuitem_equal (item, G_MENU_MODEL (menu), 0);
1531 g_object_unref (item);
1533 g_object_unref (menu);
1534 g_object_unref (submenu);
1537 static GDBusInterfaceInfo *
1538 org_gtk_Menus_get_interface (void)
1540 static GDBusInterfaceInfo *interface_info;
1542 if (interface_info == NULL)
1544 GError *error = NULL;
1545 GDBusNodeInfo *info;
1547 info = g_dbus_node_info_new_for_xml ("<node>"
1548 " <interface name='org.gtk.Menus'>"
1549 " <method name='Start'>"
1550 " <arg type='au' name='groups' direction='in'/>"
1551 " <arg type='a(uuaa{sv})' name='content' direction='out'/>"
1553 " <method name='End'>"
1554 " <arg type='au' name='groups' direction='in'/>"
1556 " <signal name='Changed'>"
1557 " arg type='a(uuuuaa{sv})' name='changes'/>"
1562 g_error ("%s\n", error->message);
1563 interface_info = g_dbus_node_info_lookup_interface (info, "org.gtk.Menus");
1564 g_assert (interface_info != NULL);
1565 g_dbus_interface_info_ref (interface_info);
1566 g_dbus_node_info_unref (info);
1569 return interface_info;
1573 g_menu_exporter_method_call (GDBusConnection *connection,
1574 const gchar *sender,
1575 const gchar *object_path,
1576 const gchar *interface_name,
1577 const gchar *method_name,
1578 GVariant *parameters,
1579 GDBusMethodInvocation *invocation,
1591 GError *error = NULL;
1593 g_dbus_method_invocation_return_value (invocation, g_variant_new_parsed ("@(a(uuaa{sv})) ([(0, 0, [{ 'label': <'test'> }])],)"));
1595 /* invalid signatures */
1596 g_dbus_connection_emit_signal (connection, sender, "/", "org.gtk.Menus", "Changed",
1597 g_variant_new_parsed ("([(1, 2, 3)],)"), &error);
1598 g_assert_no_error (error);
1600 /* add an item at an invalid position */
1601 g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "*invalid*");
1602 g_dbus_connection_emit_signal (connection, sender, "/", "org.gtk.Menus", "Changed",
1603 g_variant_new_parsed ("@(a(uuuuaa{sv})) ([(%u, %u, %u, %u, [{ 'label': <'test'> }])],)", 0, 0, 2, 0),
1605 g_assert_no_error (error);
1607 for (i = 0; i < G_N_ELEMENTS (data); i++)
1611 g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "*invalid*");
1612 params = g_variant_new_parsed ("@(a(uuuuaa{sv})) ([(%u, %u, %u, %u, [])],)", 0, 0, data[i].position, data[i].removed);
1613 g_dbus_connection_emit_signal (connection, sender, "/", "org.gtk.Menus", "Changed", params, &error);
1614 g_assert_no_error (error);
1619 menu_changed (GMenuModel *menu,
1625 unsigned int *counter = user_data;
1631 test_input_validation (void)
1633 const GDBusInterfaceVTable vtable = {
1634 g_menu_exporter_method_call, NULL, NULL, { NULL, }
1636 GError *error = NULL;
1637 GDBusConnection *bus;
1638 GDBusMenuModel *proxy;
1640 const gchar *bus_name;
1642 unsigned int n_signal_emissions = 0;
1645 g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/861");
1647 bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
1648 g_assert_no_error (error);
1650 id = g_dbus_connection_register_object (bus, "/", org_gtk_Menus_get_interface (),
1651 &vtable, NULL, NULL, &error);
1652 g_assert_no_error (error);
1654 bus_name = g_dbus_connection_get_unique_name (bus);
1655 proxy = g_dbus_menu_model_get (bus, bus_name, "/");
1657 signal_id = g_signal_connect (proxy, "items-changed", G_CALLBACK (menu_changed), &n_signal_emissions);
1659 /* get over laziness */
1660 g_menu_model_get_n_items (G_MENU_MODEL (proxy));
1662 loop = g_main_loop_new (NULL, FALSE);
1663 g_timeout_add (100, stop_loop, loop);
1664 g_main_loop_run (loop);
1666 /* "items-changed" should only be emitted for the initial contents of
1667 * the menu. Subsequent calls are all invalid.
1669 g_assert_cmpuint (n_signal_emissions, ==, 1);
1671 g_test_assert_expected_messages ();
1673 g_main_loop_unref (loop);
1674 g_dbus_connection_unregister_object (bus, id);
1675 g_signal_handler_disconnect (proxy, signal_id);
1676 g_object_unref (proxy);
1677 g_object_unref (bus);
1682 main (int argc, char **argv)
1686 g_test_init (&argc, &argv, NULL);
1690 g_test_add_func ("/gmenu/equality", test_equality);
1691 g_test_add_func ("/gmenu/random", test_random);
1692 g_test_add_func ("/gmenu/dbus/roundtrip", test_dbus_roundtrip);
1693 g_test_add_func ("/gmenu/dbus/subscriptions", test_dbus_subscriptions);
1694 g_test_add_func ("/gmenu/dbus/threaded", test_dbus_threaded);
1695 g_test_add_func ("/gmenu/dbus/peer/roundtrip", test_dbus_peer_roundtrip);
1696 g_test_add_func ("/gmenu/dbus/peer/subscriptions", test_dbus_peer_subscriptions);
1697 g_test_add_func ("/gmenu/dbus/export/error-handling", test_dbus_export_error_handling);
1698 g_test_add_func ("/gmenu/attributes", test_attributes);
1699 g_test_add_func ("/gmenu/attributes/iterate", test_attribute_iter);
1700 g_test_add_func ("/gmenu/links", test_links);
1701 g_test_add_func ("/gmenu/mutable", test_mutable);
1702 g_test_add_func ("/gmenu/convenience", test_convenience);
1703 g_test_add_func ("/gmenu/menuitem", test_menuitem);
1704 g_test_add_func ("/gmenu/input-validation", test_input_validation);
1706 ret = g_test_run ();
1708 session_bus_down ();
1712 /* vim:set foldmethod=marker: */