gio/tests/gmenumodel.c

   1 #include <gio/gio.h>
   2 #include <gio/gunixsocketaddress.h>
   3 #include <glib/gstdio.h>
   4 #include <string.h>
   5
   6 #include "gdbus-sessionbus.h"
   7
   8 static gboolean
   9 time_out (gpointer unused G_GNUC_UNUSED)
  10 {
  11   g_error ("Timed out");
  12   /* not reached */
  13   return FALSE;
  14 }
  15
  16 static guint
  17 add_timeout (guint seconds)
  18 {
  19 #ifdef G_OS_UNIX
  20   /* Safety-catch against the main loop having blocked */
  21   alarm (seconds + 5);
  22 #endif
  23   return g_timeout_add_seconds (seconds, time_out, NULL);
  24 }
  25
  26 static void
  27 cancel_timeout (guint timeout_id)
  28 {
  29 #ifdef G_OS_UNIX
  30   alarm (0);
  31 #endif
  32   g_source_remove (timeout_id);
  33 }
  34
  35 /* Markup printing {{{1 */
  36
  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.
  39  */
  40 static void
  41 indent_string (GString *string,
  42                gint     indent)
  43 {
  44   while (indent--)
  45     g_string_append_c (string, ' ');
  46 }
  47
  48 static GString *
  49 g_menu_markup_print_string (GString    *string,
  50                             GMenuModel *model,
  51                             gint        indent,
  52                             gint        tabstop)
  53 {
  54   gboolean need_nl = FALSE;
  55   gint i, n;
  56
  57   if G_UNLIKELY (string == NULL)
  58     string = g_string_new (NULL);
  59
  60   n = g_menu_model_get_n_items (model);
  61
  62   for (i = 0; i < n; i++)
  63     {
  64       GMenuAttributeIter *attr_iter;
  65       GMenuLinkIter *link_iter;
  66       GString *contents;
  67       GString *attrs;
  68
  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);
  73
  74       while (g_menu_attribute_iter_next (attr_iter))
  75         {
  76           const char *name = g_menu_attribute_iter_get_name (attr_iter);
  77           GVariant *value = g_menu_attribute_iter_get_value (attr_iter);
  78
  79           if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING))
  80             {
  81               gchar *str;
  82               str = g_markup_printf_escaped (" %s='%s'", name, g_variant_get_string (value, NULL));
  83               g_string_append (attrs, str);
  84               g_free (str);
  85             }
  86
  87           else
  88             {
  89               gchar *printed;
  90               gchar *str;
  91               const gchar *type;
  92
  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);
  98               g_free (printed);
  99               g_free (str);
 100             }
 101
 102           g_variant_unref (value);
 103         }
 104       g_object_unref (attr_iter);
 105
 106       while (g_menu_link_iter_next (link_iter))
 107         {
 108           const gchar *name = g_menu_link_iter_get_name (link_iter);
 109           GMenuModel *menu = g_menu_link_iter_get_value (link_iter);
 110           gchar *str;
 111
 112           if (contents->str[0])
 113             g_string_append_c (contents, '\n');
 114
 115           str = g_markup_printf_escaped ("<link name='%s'>\n", name);
 116           indent_string (contents, indent + tabstop);
 117           g_string_append (contents, str);
 118           g_free (str);
 119
 120           g_menu_markup_print_string (contents, menu, indent + 2 * tabstop, tabstop);
 121
 122           indent_string (contents, indent + tabstop);
 123           g_string_append (contents, "</link>\n");
 124           g_object_unref (menu);
 125         }
 126       g_object_unref (link_iter);
 127
 128       if (contents->str[0])
 129         {
 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");
 135           need_nl = TRUE;
 136         }
 137
 138       else
 139         {
 140           if (need_nl)
 141             g_string_append_c (string, '\n');
 142
 143           indent_string (string, indent);
 144           g_string_append_printf (string, "<item%s/>\n", attrs->str);
 145           need_nl = FALSE;
 146         }
 147
 148       g_string_free (contents, TRUE);
 149       g_string_free (attrs, TRUE);
 150     }
 151
 152   return string;
 153 }
 154
 155 /* TestItem {{{1 */
 156
 157 /* This utility struct is used by both the RandomMenu and MirrorMenu
 158  * class implementations below.
 159  */
 160 typedef struct {
 161   GHashTable *attributes;
 162   GHashTable *links;
 163 } TestItem;
 164
 165 static TestItem *
 166 test_item_new (GHashTable *attributes,
 167                GHashTable *links)
 168 {
 169   TestItem *item;
 170
 171   item = g_slice_new (TestItem);
 172   item->attributes = g_hash_table_ref (attributes);
 173   item->links = g_hash_table_ref (links);
 174
 175   return item;
 176 }
 177
 178 static void
 179 test_item_free (gpointer data)
 180 {
 181   TestItem *item = data;
 182
 183   g_hash_table_unref (item->attributes);
 184   g_hash_table_unref (item->links);
 185
 186   g_slice_free (TestItem, item);
 187 }
 188
 189 /* RandomMenu {{{1 */
 190 #define MAX_ITEMS 5
 191 #define TOP_ORDER 4
 192
 193 typedef struct {
 194   GMenuModel parent_instance;
 195
 196   GSequence *items;
 197   gint order;
 198 } RandomMenu;
 199
 200 typedef GMenuModelClass RandomMenuClass;
 201
 202 static GType random_menu_get_type (void);
 203 G_DEFINE_TYPE (RandomMenu, random_menu, G_TYPE_MENU_MODEL)
 204
 205 static gboolean
 206 random_menu_is_mutable (GMenuModel *model)
 207 {
 208   return TRUE;
 209 }
 210
 211 static gint
 212 random_menu_get_n_items (GMenuModel *model)
 213 {
 214   RandomMenu *menu = (RandomMenu *) model;
 215
 216   return g_sequence_get_length (menu->items);
 217 }
 218
 219 static void
 220 random_menu_get_item_attributes (GMenuModel  *model,
 221                                  gint         position,
 222                                  GHashTable **table)
 223 {
 224   RandomMenu *menu = (RandomMenu *) model;
 225   TestItem *item;
 226
 227   item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));
 228   *table = g_hash_table_ref (item->attributes);
 229 }
 230
 231 static void
 232 random_menu_get_item_links (GMenuModel  *model,
 233                             gint         position,
 234                             GHashTable **table)
 235 {
 236   RandomMenu *menu = (RandomMenu *) model;
 237   TestItem *item;
 238
 239   item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));
 240   *table = g_hash_table_ref (item->links);
 241 }
 242
 243 static void
 244 random_menu_finalize (GObject *object)
 245 {
 246   RandomMenu *menu = (RandomMenu *) object;
 247
 248   g_sequence_free (menu->items);
 249
 250   G_OBJECT_CLASS (random_menu_parent_class)
 251     ->finalize (object);
 252 }
 253
 254 static void
 255 random_menu_init (RandomMenu *menu)
 256 {
 257 }
 258
 259 static void
 260 random_menu_class_init (GMenuModelClass *class)
 261 {
 262   GObjectClass *object_class = G_OBJECT_CLASS (class);
 263
 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;
 268
 269   object_class->finalize = random_menu_finalize;
 270 }
 271
 272 static RandomMenu * random_menu_new (GRand *rand, gint order);
 273
 274 static void
 275 random_menu_change (RandomMenu *menu,
 276                     GRand      *rand)
 277 {
 278   gint position, removes, adds;
 279   GSequenceIter *point;
 280   gint n_items;
 281   gint i;
 282
 283   n_items = g_sequence_get_length (menu->items);
 284
 285   do
 286     {
 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);
 290     }
 291   while (removes == 0 && adds == 0);
 292
 293   point = g_sequence_get_iter_at_pos (menu->items, position + removes);
 294
 295   if (removes)
 296     {
 297       GSequenceIter *start;
 298
 299       start = g_sequence_get_iter_at_pos (menu->items, position);
 300       g_sequence_remove_range (start, point);
 301     }
 302
 303   for (i = 0; i < adds; i++)
 304     {
 305       const gchar *label;
 306       GHashTable *links;
 307       GHashTable *attributes;
 308
 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);
 311
 312       if (menu->order > 0 && g_rand_boolean (rand))
 313         {
 314           RandomMenu *child;
 315           const gchar *subtype;
 316
 317           child = random_menu_new (rand, menu->order - 1);
 318
 319           if (g_rand_boolean (rand))
 320             {
 321               subtype = G_MENU_LINK_SECTION;
 322               /* label some section headers */
 323               if (g_rand_boolean (rand))
 324                 label = "Section";
 325               else
 326                 label = NULL;
 327             }
 328           else
 329             {
 330               /* label all submenus */
 331               subtype = G_MENU_LINK_SUBMENU;
 332               label = "Submenu";
 333             }
 334
 335           g_hash_table_insert (links, g_strdup (subtype), child);
 336         }
 337       else
 338         /* label all terminals */
 339         label = "Menu Item";
 340
 341       if (label)
 342         g_hash_table_insert (attributes, g_strdup ("label"), g_variant_ref_sink (g_variant_new_string (label)));
 343
 344       g_sequence_insert_before (point, test_item_new (attributes, links));
 345       g_hash_table_unref (links);
 346       g_hash_table_unref (attributes);
 347     }
 348
 349   g_menu_model_items_changed (G_MENU_MODEL (menu), position, removes, adds);
 350 }
 351
 352 static RandomMenu *
 353 random_menu_new (GRand *rand,
 354                  gint   order)
 355 {
 356   RandomMenu *menu;
 357
 358   menu = g_object_new (random_menu_get_type (), NULL);
 359   menu->items = g_sequence_new (test_item_free);
 360   menu->order = order;
 361
 362   random_menu_change (menu, rand);
 363
 364   return menu;
 365 }
 366
 367 /* MirrorMenu {{{1 */
 368 typedef struct {
 369   GMenuModel parent_instance;
 370
 371   GMenuModel *clone_of;
 372   GSequence *items;
 373   gulong handler_id;
 374 } MirrorMenu;
 375
 376 typedef GMenuModelClass MirrorMenuClass;
 377
 378 static GType mirror_menu_get_type (void);
 379 G_DEFINE_TYPE (MirrorMenu, mirror_menu, G_TYPE_MENU_MODEL)
 380
 381 static gboolean
 382 mirror_menu_is_mutable (GMenuModel *model)
 383 {
 384   MirrorMenu *menu = (MirrorMenu *) model;
 385
 386   return menu->handler_id != 0;
 387 }
 388
 389 static gint
 390 mirror_menu_get_n_items (GMenuModel *model)
 391 {
 392   MirrorMenu *menu = (MirrorMenu *) model;
 393
 394   return g_sequence_get_length (menu->items);
 395 }
 396
 397 static void
 398 mirror_menu_get_item_attributes (GMenuModel  *model,
 399                                  gint         position,
 400                                  GHashTable **table)
 401 {
 402   MirrorMenu *menu = (MirrorMenu *) model;
 403   TestItem *item;
 404
 405   item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));
 406   *table = g_hash_table_ref (item->attributes);
 407 }
 408
 409 static void
 410 mirror_menu_get_item_links (GMenuModel  *model,
 411                             gint         position,
 412                             GHashTable **table)
 413 {
 414   MirrorMenu *menu = (MirrorMenu *) model;
 415   TestItem *item;
 416
 417   item = g_sequence_get (g_sequence_get_iter_at_pos (menu->items, position));
 418   *table = g_hash_table_ref (item->links);
 419 }
 420
 421 static void
 422 mirror_menu_finalize (GObject *object)
 423 {
 424   MirrorMenu *menu = (MirrorMenu *) object;
 425
 426   if (menu->handler_id)
 427     g_signal_handler_disconnect (menu->clone_of, menu->handler_id);
 428
 429   g_sequence_free (menu->items);
 430   g_object_unref (menu->clone_of);
 431
 432   G_OBJECT_CLASS (mirror_menu_parent_class)
 433     ->finalize (object);
 434 }
 435
 436 static void
 437 mirror_menu_init (MirrorMenu *menu)
 438 {
 439 }
 440
 441 static void
 442 mirror_menu_class_init (GMenuModelClass *class)
 443 {
 444   GObjectClass *object_class = G_OBJECT_CLASS (class);
 445
 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;
 450
 451   object_class->finalize = mirror_menu_finalize;
 452 }
 453
 454 static MirrorMenu * mirror_menu_new (GMenuModel *clone_of);
 455
 456 static void
 457 mirror_menu_changed (GMenuModel *model,
 458                      gint        position,
 459                      gint        removed,
 460                      gint        added,
 461                      gpointer    user_data)
 462 {
 463   MirrorMenu *menu = user_data;
 464   GSequenceIter *point;
 465   gint i;
 466
 467   g_assert (model == menu->clone_of);
 468
 469   point = g_sequence_get_iter_at_pos (menu->items, position + removed);
 470
 471   if (removed)
 472     {
 473       GSequenceIter *start;
 474
 475       start = g_sequence_get_iter_at_pos (menu->items, position);
 476       g_sequence_remove_range (start, point);
 477     }
 478
 479   for (i = position; i < position + added; i++)
 480     {
 481       GMenuAttributeIter *attr_iter;
 482       GMenuLinkIter *link_iter;
 483       GHashTable *links;
 484       GHashTable *attributes;
 485       const gchar *name;
 486       GMenuModel *child;
 487       GVariant *value;
 488
 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);
 491
 492       attr_iter = g_menu_model_iterate_item_attributes (model, i);
 493       while (g_menu_attribute_iter_get_next (attr_iter, &name, &value))
 494         {
 495           g_hash_table_insert (attributes, g_strdup (name), value);
 496         }
 497       g_object_unref (attr_iter);
 498
 499       link_iter = g_menu_model_iterate_item_links (model, i);
 500       while (g_menu_link_iter_get_next (link_iter, &name, &child))
 501         {
 502           g_hash_table_insert (links, g_strdup (name), mirror_menu_new (child));
 503           g_object_unref (child);
 504         }
 505       g_object_unref (link_iter);
 506
 507       g_sequence_insert_before (point, test_item_new (attributes, links));
 508       g_hash_table_unref (attributes);
 509       g_hash_table_unref (links);
 510     }
 511
 512   g_menu_model_items_changed (G_MENU_MODEL (menu), position, removed, added);
 513 }
 514
 515 static MirrorMenu *
 516 mirror_menu_new (GMenuModel *clone_of)
 517 {
 518   MirrorMenu *menu;
 519
 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);
 523
 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);
 527
 528   return menu;
 529 }
 530
 531 /* check_menus_equal(), assert_menus_equal() {{{1 */
 532 static gboolean
 533 check_menus_equal (GMenuModel *a,
 534                    GMenuModel *b)
 535 {
 536   gboolean equal = TRUE;
 537   gint a_n, b_n;
 538   gint i;
 539
 540   a_n = g_menu_model_get_n_items (a);
 541   b_n = g_menu_model_get_n_items (b);
 542
 543   if (a_n != b_n)
 544     return FALSE;
 545
 546   for (i = 0; i < a_n; i++)
 547     {
 548       GMenuAttributeIter *attr_iter;
 549       GVariant *a_value, *b_value;
 550       GMenuLinkIter *link_iter;
 551       GMenuModel *a_menu, *b_menu;
 552       const gchar *name;
 553
 554       attr_iter = g_menu_model_iterate_item_attributes (a, i);
 555       while (g_menu_attribute_iter_get_next (attr_iter, &name, &a_value))
 556         {
 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);
 559           if (b_value)
 560             g_variant_unref (b_value);
 561           g_variant_unref (a_value);
 562         }
 563       g_object_unref (attr_iter);
 564
 565       attr_iter = g_menu_model_iterate_item_attributes (b, i);
 566       while (g_menu_attribute_iter_get_next (attr_iter, &name, &b_value))
 567         {
 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);
 570           if (a_value)
 571             g_variant_unref (a_value);
 572           g_variant_unref (b_value);
 573         }
 574       g_object_unref (attr_iter);
 575
 576       link_iter = g_menu_model_iterate_item_links (a, i);
 577       while (g_menu_link_iter_get_next (link_iter, &name, &a_menu))
 578         {
 579           b_menu = g_menu_model_get_item_link (b, i, name);
 580           equal &= b_menu && check_menus_equal (a_menu, b_menu);
 581           if (b_menu)
 582             g_object_unref (b_menu);
 583           g_object_unref (a_menu);
 584         }
 585       g_object_unref (link_iter);
 586
 587       link_iter = g_menu_model_iterate_item_links (b, i);
 588       while (g_menu_link_iter_get_next (link_iter, &name, &b_menu))
 589         {
 590           a_menu = g_menu_model_get_item_link (a, i, name);
 591           equal &= a_menu && check_menus_equal (a_menu, b_menu);
 592           if (a_menu)
 593             g_object_unref (a_menu);
 594           g_object_unref (b_menu);
 595         }
 596       g_object_unref (link_iter);
 597     }
 598
 599   return equal;
 600 }
 601
 602 static void
 603 assert_menus_equal (GMenuModel *a,
 604                     GMenuModel *b)
 605 {
 606   if (!check_menus_equal (a, b))
 607     {
 608       GString *string;
 609
 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);
 616     }
 617 }
 618
 619 static void
 620 assert_menuitem_equal (GMenuItem  *item,
 621                        GMenuModel *model,
 622                        gint        index)
 623 {
 624   GMenuAttributeIter *attr_iter;
 625   GMenuLinkIter *link_iter;
 626   const gchar *name;
 627   GVariant *value;
 628   GMenuModel *linked_model;
 629
 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
 632    * items */
 633
 634   attr_iter = g_menu_model_iterate_item_attributes (model, index);
 635   while (g_menu_attribute_iter_get_next (attr_iter, &name, &value))
 636     {
 637       GVariant *item_value;
 638
 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));
 641
 642       g_variant_unref (item_value);
 643       g_variant_unref (value);
 644     }
 645
 646   link_iter = g_menu_model_iterate_item_links (model, index);
 647   while (g_menu_link_iter_get_next (link_iter, &name, &linked_model))
 648     {
 649       GMenuModel *item_linked_model;
 650
 651       item_linked_model = g_menu_item_get_link (item, name);
 652       g_assert (linked_model == item_linked_model);
 653
 654       g_object_unref (item_linked_model);
 655       g_object_unref (linked_model);
 656     }
 657
 658   g_object_unref (attr_iter);
 659   g_object_unref (link_iter);
 660 }
 661
 662 /* Test cases {{{1 */
 663 static void
 664 test_equality (void)
 665 {
 666   GRand *randa, *randb;
 667   guint32 seed;
 668   gint i;
 669
 670   seed = g_test_rand_int ();
 671
 672   randa = g_rand_new_with_seed (seed);
 673   randb = g_rand_new_with_seed (seed);
 674
 675   for (i = 0; i < 500; i++)
 676     {
 677       RandomMenu *a, *b;
 678
 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));
 682       g_object_unref (b);
 683       g_object_unref (a);
 684     }
 685
 686   g_rand_int (randa);
 687
 688   for (i = 0; i < 500;)
 689     {
 690       RandomMenu *a, *b;
 691
 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)))
 695         {
 696           /* by chance, they may really be equal.  double check. */
 697           GString *as, *bs;
 698
 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);
 704
 705           /* we're here because randa and randb just generated equal
 706            * menus.  they may do it again, so throw away randb and make
 707            * a fresh one.
 708            */
 709           g_rand_free (randb);
 710           randb = g_rand_new_with_seed (g_rand_int (randa));
 711         }
 712       else
 713         /* make sure we get enough unequals (ie: no GRand failure) */
 714         i++;
 715
 716       g_object_unref (b);
 717       g_object_unref (a);
 718     }
 719
 720   g_rand_free (randb);
 721   g_rand_free (randa);
 722 }
 723
 724 static void
 725 test_random (void)
 726 {
 727   RandomMenu *random;
 728   MirrorMenu *mirror;
 729   GRand *rand;
 730   gint i;
 731
 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));
 735
 736   for (i = 0; i < 500; i++)
 737     {
 738       assert_menus_equal (G_MENU_MODEL (random), G_MENU_MODEL (mirror));
 739       random_menu_change (random, rand);
 740     }
 741
 742   g_object_unref (mirror);
 743   g_object_unref (random);
 744
 745   g_rand_free (rand);
 746 }
 747
 748 typedef struct
 749 {
 750   GDBusConnection *client_connection;
 751   GDBusConnection *server_connection;
 752   GDBusServer *server;
 753
 754   GThread *service_thread;
 755   GMutex service_loop_lock;
 756   GCond service_loop_cond;
 757
 758   GMainLoop *service_loop;
 759   GMainLoop *loop;
 760 } PeerConnection;
 761
 762 static gboolean
 763 on_new_connection (GDBusServer *server,
 764                    GDBusConnection *connection,
 765                    gpointer user_data)
 766 {
 767   PeerConnection *data = user_data;
 768
 769   data->server_connection = g_object_ref (connection);
 770
 771   g_main_loop_quit (data->loop);
 772
 773   return TRUE;
 774 }
 775
 776 static void
 777 create_service_loop (GMainContext   *service_context,
 778                      PeerConnection *data)
 779 {
 780   g_assert (data->service_loop == NULL);
 781   g_mutex_lock (&data->service_loop_lock);
 782   data->service_loop = g_main_loop_new (service_context, FALSE);
 783   g_cond_broadcast (&data->service_loop_cond);
 784   g_mutex_unlock (&data->service_loop_lock);
 785 }
 786
 787 static void
 788 teardown_service_loop (PeerConnection *data)
 789 {
 790   g_mutex_lock (&data->service_loop_lock);
 791   g_clear_pointer (&data->service_loop, g_main_loop_unref);
 792   g_mutex_unlock (&data->service_loop_lock);
 793 }
 794
 795 static void
 796 await_service_loop (PeerConnection *data)
 797 {
 798   g_mutex_lock (&data->service_loop_lock);
 799   while (data->service_loop == NULL)
 800     g_cond_wait (&data->service_loop_cond, &data->service_loop_lock);
 801   g_mutex_unlock (&data->service_loop_lock);
 802 }
 803
 804 static gpointer
 805 service_thread_func (gpointer user_data)
 806 {
 807   PeerConnection *data = user_data;
 808   GMainContext *service_context;
 809   GError *error;
 810   gchar *address;
 811   gchar *tmpdir;
 812   GDBusServerFlags flags;
 813   gchar *guid;
 814
 815   service_context = g_main_context_new ();
 816   g_main_context_push_thread_default (service_context);
 817
 818   tmpdir = NULL;
 819   flags = G_DBUS_SERVER_FLAGS_NONE;
 820
 821 #ifdef G_OS_UNIX
 822   if (g_unix_socket_address_abstract_names_supported ())
 823     address = g_strdup ("unix:tmpdir=/tmp/test-dbus-peer");
 824   else
 825     {
 826       tmpdir = g_dir_make_tmp ("test-dbus-peer-XXXXXX", NULL);
 827       address = g_strdup_printf ("unix:tmpdir=%s", tmpdir);
 828     }
 829 #else
 830   address = g_strdup ("nonce-tcp:");
 831   flags |= G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
 832 #endif
 833
 834   guid = g_dbus_generate_guid ();
 835
 836   error = NULL;
 837   data->server = g_dbus_server_new_sync (address,
 838                                          flags,
 839                                          guid,
 840                                          NULL,
 841                                          NULL,
 842                                          &error);
 843   g_assert_no_error (error);
 844   g_free (address);
 845   g_free (guid);
 846
 847   g_signal_connect (data->server,
 848                     "new-connection",
 849                     G_CALLBACK (on_new_connection),
 850                     data);
 851
 852   g_dbus_server_start (data->server);
 853
 854   create_service_loop (service_context, data);
 855   g_main_loop_run (data->service_loop);
 856
 857   g_main_context_pop_thread_default (service_context);
 858
 859   teardown_service_loop (data);
 860   g_main_context_unref (service_context);
 861
 862   if (tmpdir)
 863     {
 864       g_rmdir (tmpdir);
 865       g_free (tmpdir);
 866     }
 867
 868   return NULL;
 869 }
 870
 871 static void
 872 peer_connection_up (PeerConnection *data)
 873 {
 874   GError *error;
 875
 876   memset (data, '\0', sizeof (PeerConnection));
 877   data->loop = g_main_loop_new (NULL, FALSE);
 878
 879   g_mutex_init (&data->service_loop_lock);
 880   g_cond_init (&data->service_loop_cond);
 881
 882   /* bring up a server - we run the server in a different thread to
 883      avoid deadlocks */
 884   data->service_thread = g_thread_new ("test_dbus_peer",
 885                                        service_thread_func,
 886                                        data);
 887   await_service_loop (data);
 888   g_assert (data->server != NULL);
 889
 890   /* bring up a connection and accept it */
 891   error = NULL;
 892   data->client_connection =
 893     g_dbus_connection_new_for_address_sync (g_dbus_server_get_client_address (data->server),
 894                                             G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
 895                                             NULL, /* GDBusAuthObserver */
 896                                             NULL, /* cancellable */
 897                                             &error);
 898   g_assert_no_error (error);
 899   g_assert (data->client_connection != NULL);
 900   while (data->server_connection == NULL)
 901     g_main_loop_run (data->loop);
 902 }
 903
 904 static void
 905 peer_connection_down (PeerConnection *data)
 906 {
 907   g_object_unref (data->client_connection);
 908   g_object_unref (data->server_connection);
 909
 910   g_dbus_server_stop (data->server);
 911   g_object_unref (data->server);
 912
 913   g_main_loop_quit (data->service_loop);
 914   g_thread_join (data->service_thread);
 915
 916   g_mutex_clear (&data->service_loop_lock);
 917   g_cond_clear (&data->service_loop_cond);
 918
 919   g_main_loop_unref (data->loop);
 920 }
 921
 922 struct roundtrip_state
 923 {
 924   RandomMenu *random;
 925   MirrorMenu *proxy_mirror;
 926   GDBusMenuModel *proxy;
 927   GMainLoop *loop;
 928   GRand *rand;
 929   gint success;
 930   gint count;
 931 };
 932
 933 static gboolean
 934 roundtrip_step (gpointer data)
 935 {
 936   struct roundtrip_state *state = data;
 937
 938   if (check_menus_equal (G_MENU_MODEL (state->random), G_MENU_MODEL (state->proxy)) &&
 939       check_menus_equal (G_MENU_MODEL (state->random), G_MENU_MODEL (state->proxy_mirror)))
 940     {
 941       state->success++;
 942       state->count = 0;
 943
 944       if (state->success < 100)
 945         random_menu_change (state->random, state->rand);
 946       else
 947         g_main_loop_quit (state->loop);
 948     }
 949   else if (state->count == 100)
 950     {
 951       assert_menus_equal (G_MENU_MODEL (state->random), G_MENU_MODEL (state->proxy));
 952       g_assert_not_reached ();
 953     }
 954   else
 955     state->count++;
 956
 957   return G_SOURCE_CONTINUE;
 958 }
 959
 960 static void
 961 do_roundtrip (GDBusConnection *exporter_connection,
 962               GDBusConnection *proxy_connection)
 963 {
 964   struct roundtrip_state state;
 965   guint export_id;
 966   guint id;
 967
 968   state.rand = g_rand_new_with_seed (g_test_rand_int ());
 969
 970   state.random = random_menu_new (state.rand, 2);
 971   export_id = g_dbus_connection_export_menu_model (exporter_connection,
 972                                                    "/",
 973                                                    G_MENU_MODEL (state.random),
 974                                                    NULL);
 975   state.proxy = g_dbus_menu_model_get (proxy_connection,
 976                                        g_dbus_connection_get_unique_name (proxy_connection),
 977                                        "/");
 978   state.proxy_mirror = mirror_menu_new (G_MENU_MODEL (state.proxy));
 979   state.count = 0;
 980   state.success = 0;
 981
 982   id = g_timeout_add (10, roundtrip_step, &state);
 983
 984   state.loop = g_main_loop_new (NULL, FALSE);
 985   g_main_loop_run (state.loop);
 986
 987   g_main_loop_unref (state.loop);
 988   g_source_remove (id);
 989   g_object_unref (state.proxy);
 990   g_dbus_connection_unexport_menu_model (exporter_connection, export_id);
 991   g_object_unref (state.random);
 992   g_object_unref (state.proxy_mirror);
 993   g_rand_free (state.rand);
 994 }
 995
 996 static void
 997 test_dbus_roundtrip (void)
 998 {
 999   GDBusConnection *bus;
1000
1001   bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
1002   do_roundtrip (bus, bus);
1003   g_object_unref (bus);
1004 }
1005
1006 static void
1007 test_dbus_peer_roundtrip (void)
1008 {
1009   PeerConnection peer;
1010
1011   peer_connection_up (&peer);
1012   do_roundtrip (peer.server_connection, peer.client_connection);
1013   peer_connection_down (&peer);
1014 }
1015
1016 static gint items_changed_count;
1017
1018 static void
1019 items_changed (GMenuModel *model,
1020                gint        position,
1021                gint        removed,
1022                gint        added,
1023                gpointer    data)
1024 {
1025   items_changed_count++;
1026 }
1027
1028 static gboolean
1029 stop_loop (gpointer data)
1030 {
1031   GMainLoop *loop = data;
1032
1033   g_main_loop_quit (loop);
1034
1035   return G_SOURCE_REMOVE;
1036 }
1037
1038 static void
1039 do_subscriptions (GDBusConnection *exporter_connection,
1040                   GDBusConnection *proxy_connection)
1041 {
1042   GMenu *menu;
1043   GDBusMenuModel *proxy;
1044   GMainLoop *loop;
1045   GError *error = NULL;
1046   guint export_id;
1047   guint timeout_id;
1048
1049   timeout_id = add_timeout (60);
1050   loop = g_main_loop_new (NULL, FALSE);
1051
1052   menu = g_menu_new ();
1053
1054   export_id = g_dbus_connection_export_menu_model (exporter_connection,
1055                                                    "/",
1056                                                    G_MENU_MODEL (menu),
1057                                                    &error);
1058   g_assert_no_error (error);
1059
1060   proxy = g_dbus_menu_model_get (proxy_connection,
1061                                  g_dbus_connection_get_unique_name (proxy_connection),
1062                                  "/");
1063   items_changed_count = 0;
1064   g_signal_connect (proxy, "items-changed",
1065                     G_CALLBACK (items_changed), NULL);
1066
1067   g_menu_append (menu, "item1", NULL);
1068   g_menu_append (menu, "item2", NULL);
1069   g_menu_append (menu, "item3", NULL);
1070
1071   g_assert_cmpint (items_changed_count, ==, 0);
1072
1073   /* We don't subscribe to change-notification until we look at the items */
1074   g_timeout_add (100, stop_loop, loop);
1075   g_main_loop_run (loop);
1076
1077   /* Looking at the items triggers subscription */
1078   g_menu_model_get_n_items (G_MENU_MODEL (proxy));
1079
1080   while (items_changed_count < 1)
1081     g_main_context_iteration (NULL, TRUE);
1082
1083   /* We get all three items in one batch */
1084   g_assert_cmpint (items_changed_count, ==, 1);
1085   g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (proxy)), ==, 3);
1086
1087   /* If we wait, we don't get any more */
1088   g_timeout_add (100, stop_loop, loop);
1089   g_main_loop_run (loop);
1090   g_assert_cmpint (items_changed_count, ==, 1);
1091   g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (proxy)), ==, 3);
1092
1093   /* Now we're subscribed, we get changes individually */
1094   g_menu_append (menu, "item4", NULL);
1095   g_menu_append (menu, "item5", NULL);
1096   g_menu_append (menu, "item6", NULL);
1097   g_menu_remove (menu, 0);
1098   g_menu_remove (menu, 0);
1099
1100   while (items_changed_count < 6)
1101     g_main_context_iteration (NULL, TRUE);
1102
1103   g_assert_cmpint (items_changed_count, ==, 6);
1104
1105   g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (proxy)), ==, 4);
1106
1107   /* After destroying the proxy and waiting a bit, we don't get any more
1108    * items-changed signals */
1109   g_object_unref (proxy);
1110
1111   g_timeout_add (100, stop_loop, loop);
1112   g_main_loop_run (loop);
1113
1114   g_menu_remove (menu, 0);
1115   g_menu_remove (menu, 0);
1116
1117   g_timeout_add (100, stop_loop, loop);
1118   g_main_loop_run (loop);
1119
1120   g_assert_cmpint (items_changed_count, ==, 6);
1121
1122   g_dbus_connection_unexport_menu_model (exporter_connection, export_id);
1123   g_object_unref (menu);
1124
1125   g_main_loop_unref (loop);
1126   cancel_timeout (timeout_id);
1127 }
1128
1129 static void
1130 test_dbus_subscriptions (void)
1131 {
1132   GDBusConnection *bus;
1133
1134   bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
1135   do_subscriptions (bus, bus);
1136   g_object_unref (bus);
1137 }
1138
1139 static void
1140 test_dbus_peer_subscriptions (void)
1141 {
1142   PeerConnection peer;
1143
1144   peer_connection_up (&peer);
1145   do_subscriptions (peer.server_connection, peer.client_connection);
1146   peer_connection_down (&peer);
1147 }
1148
1149 static gpointer
1150 do_modify (gpointer data)
1151 {
1152   RandomMenu *menu = data;
1153   GRand *rand;
1154   gint i;
1155
1156   rand = g_rand_new_with_seed (g_test_rand_int ());
1157
1158   for (i = 0; i < 10000; i++)
1159     {
1160       random_menu_change (menu, rand);
1161     }
1162
1163   return NULL;
1164 }
1165
1166 static gpointer
1167 do_export (gpointer data)
1168 {
1169   GMenuModel *menu = data;
1170   gint i;
1171   GDBusConnection *bus;
1172   gchar *path;
1173   GError *error = NULL;
1174   guint id;
1175
1176   bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
1177   path = g_strdup_printf ("/%p", data);
1178
1179   for (i = 0; i < 10000; i++)
1180     {
1181       id = g_dbus_connection_export_menu_model (bus, path, menu, &error);
1182       g_assert_no_error (error);
1183       g_dbus_connection_unexport_menu_model (bus, id);
1184       while (g_main_context_iteration (NULL, FALSE));
1185     }
1186
1187   g_free (path);
1188
1189   g_object_unref (bus);
1190
1191   return NULL;
1192 }
1193
1194 static void
1195 test_dbus_threaded (void)
1196 {
1197   RandomMenu *menu[10];
1198   GThread *call[10];
1199   GThread *export[10];
1200   gint i;
1201
1202   for (i = 0; i < 10; i++)
1203     {
1204       menu[i] = random_menu_new (g_rand_new_with_seed (g_test_rand_int ()), 2);
1205       call[i] = g_thread_new ("call", do_modify, menu[i]);
1206       export[i] = g_thread_new ("export", do_export, menu[i]);
1207     }
1208
1209   for (i = 0; i < 10; i++)
1210     {
1211       g_thread_join (call[i]);
1212       g_thread_join (export[i]);
1213     }
1214
1215   for (i = 0; i < 10; i++)
1216     g_object_unref (menu[i]);
1217 }
1218
1219 static void
1220 test_attributes (void)
1221 {
1222   GMenu *menu;
1223   GMenuItem *item;
1224   GVariant *v;
1225
1226   menu = g_menu_new ();
1227
1228   item = g_menu_item_new ("test", NULL);
1229   g_menu_item_set_attribute_value (item, "boolean", g_variant_new_boolean (FALSE));
1230   g_menu_item_set_attribute_value (item, "string", g_variant_new_string ("bla"));
1231
1232   g_menu_item_set_attribute (item, "double", "d", 1.5);
1233   v = g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three");
1234   g_menu_item_set_attribute_value (item, "complex", v);
1235   g_menu_item_set_attribute_value (item, "test-123", g_variant_new_string ("test-123"));
1236
1237   g_menu_append_item (menu, item);
1238
1239   g_menu_item_set_attribute (item, "double", "d", G_PI);
1240
1241   g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (menu)), ==, 1);
1242
1243   v = g_menu_model_get_item_attribute_value (G_MENU_MODEL (menu), 0, "boolean", NULL);
1244   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_BOOLEAN));
1245   g_variant_unref (v);
1246
1247   v = g_menu_model_get_item_attribute_value (G_MENU_MODEL (menu), 0, "string", NULL);
1248   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
1249   g_variant_unref (v);
1250
1251   v = g_menu_model_get_item_attribute_value (G_MENU_MODEL (menu), 0, "double", NULL);
1252   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_DOUBLE));
1253   g_variant_unref (v);
1254
1255   v = g_menu_model_get_item_attribute_value (G_MENU_MODEL (menu), 0, "complex", NULL);
1256   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE("a(si)")));
1257   g_variant_unref (v);
1258
1259   g_menu_remove_all (menu);
1260
1261   g_object_unref (menu);
1262   g_object_unref (item);
1263 }
1264
1265 static void
1266 test_attribute_iter (void)
1267 {
1268   GMenu *menu;
1269   GMenuItem *item;
1270   const gchar *name;
1271   GVariant *v;
1272   GMenuAttributeIter *iter;
1273   GHashTable *found;
1274
1275   menu = g_menu_new ();
1276
1277   item = g_menu_item_new ("test", NULL);
1278   g_menu_item_set_attribute_value (item, "boolean", g_variant_new_boolean (FALSE));
1279   g_menu_item_set_attribute_value (item, "string", g_variant_new_string ("bla"));
1280
1281   g_menu_item_set_attribute (item, "double", "d", 1.5);
1282   v = g_variant_new_parsed ("[('one', 1), ('two', %i), (%s, 3)]", 2, "three");
1283   g_menu_item_set_attribute_value (item, "complex", v);
1284   g_menu_item_set_attribute_value (item, "test-123", g_variant_new_string ("test-123"));
1285
1286   g_menu_append_item (menu, item);
1287
1288   g_menu_item_set_attribute (item, "double", "d", G_PI);
1289
1290   g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (menu)), ==, 1);
1291
1292   found = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)g_variant_unref);
1293
1294   iter = g_menu_model_iterate_item_attributes (G_MENU_MODEL (menu), 0);
1295   while (g_menu_attribute_iter_get_next (iter, &name, &v))
1296     g_hash_table_insert (found, g_strdup (name), v);
1297
1298   g_assert_cmpint (g_hash_table_size (found), ==, 6);
1299
1300   v = g_hash_table_lookup (found, "label");
1301   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
1302
1303   v = g_hash_table_lookup (found, "boolean");
1304   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_BOOLEAN));
1305
1306   v = g_hash_table_lookup (found, "string");
1307   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
1308
1309   v = g_hash_table_lookup (found, "double");
1310   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_DOUBLE));
1311
1312   v = g_hash_table_lookup (found, "complex");
1313   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE("a(si)")));
1314
1315   v = g_hash_table_lookup (found, "test-123");
1316   g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE_STRING));
1317
1318   g_hash_table_unref (found);
1319
1320   g_menu_remove_all (menu);
1321
1322   g_object_unref (menu);
1323   g_object_unref (item);
1324 }
1325
1326 static void
1327 test_links (void)
1328 {
1329   GMenu *menu;
1330   GMenuModel *m;
1331   GMenuModel *x;
1332   GMenuItem *item;
1333
1334   m = G_MENU_MODEL (g_menu_new ());
1335   g_menu_append (G_MENU (m), "test", NULL);
1336
1337   menu = g_menu_new ();
1338
1339   item = g_menu_item_new ("test2", NULL);
1340   g_menu_item_set_link (item, "submenu", m);
1341   g_menu_prepend_item (menu, item);
1342
1343   item = g_menu_item_new ("test1", NULL);
1344   g_menu_item_set_link (item, "section", m);
1345   g_menu_insert_item (menu, 0, item);
1346
1347   item = g_menu_item_new ("test3", NULL);
1348   g_menu_item_set_link (item, "wallet", m);
1349   g_menu_insert_item (menu, 1000, item);
1350
1351   item = g_menu_item_new ("test4", NULL);
1352   g_menu_item_set_link (item, "purse", m);
1353   g_menu_item_set_link (item, "purse", NULL);
1354   g_menu_append_item (menu, item);
1355
1356   g_assert_cmpint (g_menu_model_get_n_items (G_MENU_MODEL (menu)), ==, 4);
1357
1358   x = g_menu_model_get_item_link (G_MENU_MODEL (menu), 0, "section");
1359   g_assert (x == m);
1360   g_object_unref (x);
1361
1362   x = g_menu_model_get_item_link (G_MENU_MODEL (menu), 1, "submenu");
1363   g_assert (x == m);
1364   g_object_unref (x);
1365
1366   x = g_menu_model_get_item_link (G_MENU_MODEL (menu), 2, "wallet");
1367   g_assert (x == m);
1368   g_object_unref (x);
1369
1370   x = g_menu_model_get_item_link (G_MENU_MODEL (menu), 3, "purse");
1371   g_assert (x == NULL);
1372
1373   g_object_unref (m);
1374   g_object_unref (menu);
1375 }
1376
1377 static void
1378 test_mutable (void)
1379 {
1380   GMenu *menu;
1381
1382   menu = g_menu_new ();
1383   g_menu_append (menu, "test", "test");
1384
1385   g_assert (g_menu_model_is_mutable (G_MENU_MODEL (menu)));
1386   g_menu_freeze (menu);
1387   g_assert (!g_menu_model_is_mutable (G_MENU_MODEL (menu)));
1388
1389   g_object_unref (menu);
1390 }
1391
1392 static void
1393 test_convenience (void)
1394 {
1395   GMenu *m1, *m2;
1396   GMenu *sub;
1397   GMenuItem *item;
1398
1399   m1 = g_menu_new ();
1400   m2 = g_menu_new ();
1401   sub = g_menu_new ();
1402
1403   g_menu_prepend (m1, "label1", "do::something");
1404   g_menu_insert (m2, 0, "label1", "do::something");
1405
1406   g_menu_append (m1, "label2", "do::somethingelse");
1407   g_menu_insert (m2, -1, "label2", "do::somethingelse");
1408
1409   g_menu_insert_section (m1, 10, "label3", G_MENU_MODEL (sub));
1410   item = g_menu_item_new_section ("label3", G_MENU_MODEL (sub));
1411   g_menu_insert_item (m2, 10, item);
1412   g_object_unref (item);
1413
1414   g_menu_prepend_section (m1, "label4", G_MENU_MODEL (sub));
1415   g_menu_insert_section (m2, 0, "label4", G_MENU_MODEL (sub));
1416
1417   g_menu_append_section (m1, "label5", G_MENU_MODEL (sub));
1418   g_menu_insert_section (m2, -1, "label5", G_MENU_MODEL (sub));
1419
1420   g_menu_insert_submenu (m1, 5, "label6", G_MENU_MODEL (sub));
1421   item = g_menu_item_new_submenu ("label6", G_MENU_MODEL (sub));
1422   g_menu_insert_item (m2, 5, item);
1423   g_object_unref (item);
1424
1425   g_menu_prepend_submenu (m1, "label7", G_MENU_MODEL (sub));
1426   g_menu_insert_submenu (m2, 0, "label7", G_MENU_MODEL (sub));
1427
1428   g_menu_append_submenu (m1, "label8", G_MENU_MODEL (sub));
1429   g_menu_insert_submenu (m2, -1, "label8", G_MENU_MODEL (sub));
1430
1431   assert_menus_equal (G_MENU_MODEL (m1), G_MENU_MODEL (m2));
1432
1433   g_object_unref (m1);
1434   g_object_unref (m2);
1435 }
1436
1437 static void
1438 test_menuitem (void)
1439 {
1440   GMenu *menu;
1441   GMenu *submenu;
1442   GMenuItem *item;
1443   GIcon *icon;
1444   gboolean b;
1445   gchar *s;
1446
1447   menu = g_menu_new ();
1448   submenu = g_menu_new ();
1449
1450   item = g_menu_item_new ("label", "action");
1451   g_menu_item_set_attribute (item, "attribute", "b", TRUE);
1452   g_menu_item_set_link (item, G_MENU_LINK_SUBMENU, G_MENU_MODEL (submenu));
1453   g_menu_append_item (menu, item);
1454
1455   icon = g_themed_icon_new ("bla");
1456   g_menu_item_set_icon (item, icon);
1457   g_object_unref (icon);
1458
1459   g_assert (g_menu_item_get_attribute (item, "attribute", "b", &b));
1460   g_assert (b);
1461
1462   g_menu_item_set_action_and_target (item, "action", "(bs)", TRUE, "string");
1463   g_assert (g_menu_item_get_attribute (item, "target", "(bs)", &b, &s));
1464   g_assert (b);
1465   g_assert_cmpstr (s, ==, "string");
1466   g_free (s);
1467
1468   g_object_unref (item);
1469
1470   item = g_menu_item_new_from_model (G_MENU_MODEL (menu), 0);
1471   assert_menuitem_equal (item, G_MENU_MODEL (menu), 0);
1472   g_object_unref (item);
1473
1474   g_object_unref (menu);
1475   g_object_unref (submenu);
1476 }
1477
1478 /* Epilogue {{{1 */
1479 int
1480 main (int argc, char **argv)
1481 {
1482   gboolean ret;
1483
1484   g_test_init (&argc, &argv, NULL);
1485
1486   session_bus_up ();
1487
1488   g_test_add_func ("/gmenu/equality", test_equality);
1489   g_test_add_func ("/gmenu/random", test_random);
1490   g_test_add_func ("/gmenu/dbus/roundtrip", test_dbus_roundtrip);
1491   g_test_add_func ("/gmenu/dbus/subscriptions", test_dbus_subscriptions);
1492   g_test_add_func ("/gmenu/dbus/threaded", test_dbus_threaded);
1493   g_test_add_func ("/gmenu/dbus/peer/roundtrip", test_dbus_peer_roundtrip);
1494   g_test_add_func ("/gmenu/dbus/peer/subscriptions", test_dbus_peer_subscriptions);
1495   g_test_add_func ("/gmenu/attributes", test_attributes);
1496   g_test_add_func ("/gmenu/attributes/iterate", test_attribute_iter);
1497   g_test_add_func ("/gmenu/links", test_links);
1498   g_test_add_func ("/gmenu/mutable", test_mutable);
1499   g_test_add_func ("/gmenu/convenience", test_convenience);
1500   g_test_add_func ("/gmenu/menuitem", test_menuitem);
1501
1502   ret = g_test_run ();
1503
1504   session_bus_down ();
1505
1506   return ret;
1507 }
1508 /* vim:set foldmethod=marker: */