Pileus Git - ~andy/gtk/blob - tests/a11y/accessibility-dump.c

   1 /*
   2  * Copyright (C) 2011 Red Hat Inc.
   3  *
   4  * Author:
   5  *      Benjamin Otte <otte@redhat.com>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26 #include <glib/gstdio.h>
  27 #include <gtk/gtk.h>
  28
  29 #define DEPTH_INCREMENT 2
  30
  31 static char *
  32 get_test_file (const char *test_file,
  33                const char *extension,
  34                gboolean    must_exist)
  35 {
  36   GString *file = g_string_new (NULL);
  37
  38   if (g_str_has_suffix (test_file, ".ui"))
  39     g_string_append_len (file, test_file, strlen (test_file) - strlen (".ui"));
  40   else
  41     g_string_append (file, test_file);
  42
  43   g_string_append (file, extension);
  44
  45   if (must_exist &&
  46       !g_file_test (file->str, G_FILE_TEST_EXISTS))
  47     {
  48       g_string_free (file, TRUE);
  49       return NULL;
  50     }
  51
  52   return g_string_free (file, FALSE);
  53 }
  54
  55 static char *
  56 diff_with_file (const char  *file1,
  57                 char        *text,
  58                 gssize       len,
  59                 GError     **error)
  60 {
  61   const char *command[] = { "diff", "-u", file1, NULL, NULL };
  62   char *diff, *tmpfile;
  63   int fd;
  64
  65   diff = NULL;
  66
  67   if (len < 0)
  68     len = strlen (text);
  69
  70   /* write the text buffer to a temporary file */
  71   fd = g_file_open_tmp (NULL, &tmpfile, error);
  72   if (fd < 0)
  73     return NULL;
  74
  75   if (write (fd, text, len) != (int) len)
  76     {
  77       close (fd);
  78       g_set_error (error,
  79                    G_FILE_ERROR, G_FILE_ERROR_FAILED,
  80                    "Could not write data to temporary file '%s'", tmpfile);
  81       goto done;
  82     }
  83   close (fd);
  84   command[3] = tmpfile;
  85
  86   /* run diff command */
  87   g_spawn_sync (NULL,
  88                 (char **) command,
  89                 NULL,
  90                 G_SPAWN_SEARCH_PATH,
  91                 NULL, NULL,
  92                 &diff,
  93                 NULL, NULL,
  94                 error);
  95
  96 done:
  97   g_unlink (tmpfile);
  98   g_free (tmpfile);
  99
 100   return diff;
 101 }
 102
 103 static int unnamed_object_count;
 104
 105 static void
 106 setup_test (void)
 107 {
 108   unnamed_object_count = 0;
 109 }
 110
 111 static const char *
 112 get_name (AtkObject *accessible)
 113 {
 114   char *name;
 115
 116   name = g_object_get_data (G_OBJECT (accessible), "gtk-accessibility-dump-name");
 117   if (name)
 118     return name;
 119
 120   if (GTK_IS_ACCESSIBLE (accessible))
 121     {
 122       GtkWidget *widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible));
 123
 124       name = g_strdup (gtk_buildable_get_name (GTK_BUILDABLE (widget)));
 125     }
 126
 127   if (name == NULL && ATK_IS_TEXT (accessible))
 128     {
 129       name = atk_text_get_text (ATK_TEXT (accessible), 0, -1);
 130     }
 131
 132   if (name == NULL)
 133     {
 134       /* Generate a unique, repeatable name */
 135       name = g_strdup_printf ("unnamed-%s-%d", G_OBJECT_TYPE_NAME (accessible), unnamed_object_count++);
 136     }
 137
 138   g_object_set_data_full (G_OBJECT (accessible), "gtk-accessibility-dump-name", name, g_free);
 139   return name;
 140 }
 141
 142 static void
 143 dump_relation (GString     *string,
 144                guint        depth,
 145                AtkRelation *relation)
 146 {
 147   GPtrArray *targets;
 148   const char *name;
 149   guint i;
 150
 151   targets = atk_relation_get_target (relation);
 152   if (targets == NULL || targets->len == 0)
 153     return;
 154
 155   name = atk_relation_type_get_name (atk_relation_get_relation_type (relation));
 156   g_string_append_printf (string, "%*s%s: %s\n", depth, "", name, get_name (g_ptr_array_index (targets, 0)));
 157   depth += strlen (name) + 2;
 158
 159   for (i = 1; i < targets->len; i++)
 160     {
 161       g_string_append_printf (string, "%*s%s\n", depth, "", get_name (g_ptr_array_index (targets, i)));
 162     }
 163 }
 164
 165 static void
 166 dump_relation_set (GString        *string,
 167                    guint           depth,
 168                    AtkRelationSet *set)
 169 {
 170   guint i;
 171
 172   if (set == NULL)
 173     return;
 174
 175   for (i = 0; i < atk_relation_set_get_n_relations (set); i++)
 176     {
 177       AtkRelation *relation;
 178
 179       relation = atk_relation_set_get_relation (set, i);
 180
 181       dump_relation (string, depth, relation);
 182     }
 183
 184   g_object_unref (set);
 185 }
 186
 187 static void
 188 dump_state_set (GString     *string,
 189                 guint        depth,
 190                 AtkStateSet *set)
 191 {
 192   guint i;
 193
 194   if (set == NULL)
 195     return;
 196
 197   if (!atk_state_set_is_empty (set))
 198     {
 199       g_string_append_printf (string, "%*sstate:", depth, "");
 200       for (i = 0; i < ATK_STATE_LAST_DEFINED; i++)
 201         {
 202           if (atk_state_set_contains_state (set, i))
 203             g_string_append_printf (string, " %s", atk_state_type_get_name (i));
 204         }
 205       g_string_append_c (string, '\n');
 206     }
 207
 208   g_object_unref (set);
 209 }
 210
 211 static void
 212 dump_attribute (GString      *string,
 213                 guint         depth,
 214                 AtkAttribute *attribute)
 215 {
 216   g_string_append_printf (string, "%*s%s: %s\n", depth, "", attribute->name, attribute->value);
 217 }
 218
 219 static void
 220 dump_attribute_set (GString         *string,
 221                     guint            depth,
 222                     AtkAttributeSet *set)
 223 {
 224   GSList *l;
 225   AtkAttribute *attribute;
 226
 227   for (l = set; l; l = l->next)
 228     {
 229       attribute = l->data;
 230
 231       dump_attribute (string, depth, attribute);
 232     }
 233 }
 234
 235 static gint
 236 compare_attr (gconstpointer a, gconstpointer b)
 237 {
 238   const AtkAttribute *aattr = a;
 239   const AtkAttribute *battr = b;
 240
 241   return strcmp (aattr->name, battr->name);
 242 }
 243
 244 static void
 245 dump_text_attributes (GString         *string,
 246                       gint             depth,
 247                       const gchar     *name,
 248                       AtkAttributeSet *attributes)
 249 {
 250   GSList *l;
 251   AtkAttribute *attr;
 252   const gchar *value;
 253
 254   if (attributes == NULL)
 255     return;
 256
 257   attributes = g_slist_sort (attributes, compare_attr);
 258
 259   for (l = attributes; l; l = l->next)
 260     {
 261       attr = l->data;
 262       /* don't dump values that depend on the environment */
 263       if (strcmp (attr->name, "family-name") == 0 ||
 264           strcmp (attr->name, "size") == 0 ||
 265           strcmp (attr->name, "weight") == 0 ||
 266           strcmp (attr->name, "stretch") == 0 ||
 267           strcmp (attr->name, "variant") == 0 ||
 268           strcmp (attr->name, "style") == 0 ||
 269           strcmp (attr->name, "language") == 0 ||
 270           strcmp (attr->name, "fg-color") == 0 ||
 271           strcmp (attr->name, "bg-color") == 0 ||
 272           strcmp (attr->name, "direction") == 0)
 273         value = "<omitted>";
 274       else
 275         value = attr->value;
 276
 277       if (name)
 278         {
 279           /* first time this loop is run */
 280           g_string_append_printf (string, "%*s%s: %s: %s\n", depth, "", name, attr->name, value);
 281           depth += strlen (name) + 2;
 282           name = NULL;
 283         }
 284       else
 285         {
 286           /* every other time */
 287           g_string_append_printf (string, "%*s%s: %s\n", depth, "", attr->name, value);
 288         }
 289     }
 290
 291   atk_attribute_set_free (attributes);
 292 }
 293
 294 extern GType atk_layer_get_type (void);
 295
 296 static const gchar *
 297 layer_name (AtkLayer layer)
 298 {
 299   GEnumClass *class;
 300   GEnumValue *value;
 301
 302   class = g_type_class_ref (atk_layer_get_type ());
 303   value = g_enum_get_value (class, layer);
 304   g_type_class_unref (class);
 305
 306   return value->value_nick;
 307 }
 308
 309 static void
 310 dump_atk_component (AtkComponent *atk_component,
 311                     guint         depth,
 312                     GString      *string)
 313 {
 314   AtkLayer layer;
 315
 316   g_string_append_printf (string, "%*s<AtkComponent>\n", depth, "");
 317
 318   layer = atk_component_get_layer (atk_component);
 319   g_string_append_printf (string, "%*slayer: %s\n", depth, "", layer_name (layer));
 320
 321   g_string_append_printf (string, "%*salpha: %g\n", depth, "", atk_component_get_alpha (atk_component));
 322 }
 323
 324 static void
 325 dump_atk_text (AtkText *atk_text,
 326                guint    depth,
 327                GString *string)
 328 {
 329   gchar *text;
 330   gint i, start, end;
 331
 332   g_string_append_printf (string, "%*s<AtkText>\n", depth, "");
 333
 334   text = atk_text_get_text (atk_text, 0, -1);
 335   g_string_append_printf (string, "%*stext: %s\n", depth, "", text);
 336   g_free (text);
 337
 338   g_string_append_printf (string, "%*scharacter count: %d\n", depth, "", atk_text_get_character_count (atk_text));
 339
 340   g_string_append_printf (string, "%*scaret offset: %d\n", depth, "", atk_text_get_caret_offset (atk_text));
 341
 342   for (i = 0; i < atk_text_get_n_selections (atk_text); i++)
 343     {
 344       text = atk_text_get_selection (atk_text, i, &start, &end);
 345       if (text)
 346         g_string_append_printf (string, "%*sselection %d: (%d, %d) %s\n", depth, "", i, start, end, text);
 347       g_free (text);
 348     }
 349
 350   dump_text_attributes (string, depth, "default attributes", atk_text_get_default_attributes (atk_text));
 351 }
 352
 353 static void
 354 dump_atk_image (AtkImage *atk_image,
 355                 guint     depth,
 356                 GString  *string)
 357 {
 358   gint width, height;
 359
 360   g_string_append_printf (string, "%*s<AtkImage>\n", depth, "");
 361
 362   atk_image_get_image_size (atk_image, &width, &height);
 363   g_string_append_printf (string, "%*simage size: %d x %d\n", depth, "", width, height);
 364
 365   g_string_append_printf (string, "%*simage description: %s\n", depth, "", atk_image_get_image_description (atk_image));
 366 }
 367
 368 static void
 369 dump_atk_action (AtkAction *atk_action,
 370                  guint      depth,
 371                  GString   *string)
 372 {
 373   gint i;
 374
 375   g_string_append_printf (string, "%*s<AtkAction>\n", depth, "");
 376
 377   for (i = 0; i < atk_action_get_n_actions (atk_action); i++)
 378     {
 379       if (atk_action_get_name (atk_action, i))
 380         g_string_append_printf (string, "%*saction %d name: %s\n", depth, "", i, atk_action_get_name (atk_action, i));
 381       if (atk_action_get_description (atk_action, i))
 382         g_string_append_printf (string, "%*saction %d description: %s\n", depth, "", i, atk_action_get_description (atk_action, i));
 383       if (atk_action_get_keybinding (atk_action, i))
 384         g_string_append_printf (string, "%*saction %d keybinding: %s\n", depth, "", i, atk_action_get_keybinding (atk_action, i));
 385     }
 386 }
 387
 388 static void
 389 dump_atk_selection (AtkSelection *atk_selection,
 390                     guint         depth,
 391                     GString      *string)
 392 {
 393   guint n_selections, n_counted_selections;
 394   gint i;
 395
 396   n_selections = atk_selection_get_selection_count (atk_selection);
 397   g_string_append_printf (string, "%*s<AtkSelection>\n", depth, "");
 398   g_string_append_printf (string, "%*sselection count: %d\n", depth, "", n_selections);
 399
 400   n_counted_selections = 0;
 401   for (i = 0; i < atk_object_get_n_accessible_children (ATK_OBJECT (atk_selection)); i++)
 402     {
 403       if (atk_selection_is_child_selected (atk_selection, i))
 404         {
 405           AtkObject *object = atk_object_ref_accessible_child (ATK_OBJECT (atk_selection), i);
 406
 407           g_assert (object);
 408
 409           if (n_counted_selections == 0)
 410             {
 411               g_string_append_printf (string, "%*sselected children: %s\n", depth, "", get_name (object));
 412               depth += strlen ("selected children: ");
 413             }
 414           else
 415             g_string_append_printf (string, "%*s%s\n", depth, "", get_name (object));
 416           n_counted_selections++;
 417         }
 418     }
 419
 420   g_assert_cmpint (n_selections, ==, n_counted_selections);
 421 }
 422
 423 static void
 424 dump_atk_value (AtkValue *atk_value,
 425                 guint     depth,
 426                 GString  *string)
 427 {
 428   GValue value = { 0, };
 429   GValue svalue = { 0, };
 430
 431   g_string_append_printf (string, "%*s<AtkValue>\n", depth, "");
 432
 433   g_value_init (&value, G_TYPE_DOUBLE);
 434   g_value_init (&svalue, G_TYPE_STRING);
 435
 436   atk_value_get_minimum_value (atk_value, &value);
 437   if (g_value_transform (&value, &svalue))
 438     g_string_append_printf (string, "%*sminimum value: %s\n", depth, "", g_value_get_string (&svalue));
 439   else
 440     g_string_append_printf (string, "%*sminimum value: <%s>\n", depth, "", G_VALUE_TYPE_NAME (&value));
 441
 442   g_value_reset (&value);
 443   g_value_reset (&svalue);
 444
 445   atk_value_get_maximum_value (atk_value, &value);
 446   if (g_value_transform (&value, &svalue))
 447     g_string_append_printf (string, "%*smaximum value: %s\n", depth, "", g_value_get_string (&svalue));
 448   else
 449     g_string_append_printf (string, "%*smaximum value: <%s>\n", depth, "", G_VALUE_TYPE_NAME (&value));
 450
 451   g_value_reset (&value);
 452   g_value_reset (&svalue);
 453
 454   atk_value_get_current_value (atk_value, &value);
 455   if (g_value_transform (&value, &svalue))
 456     g_string_append_printf (string, "%*scurrent value: %s\n", depth, "", g_value_get_string (&svalue));
 457   else
 458     g_string_append_printf (string, "%*scurrent value: %s\n", depth, "", G_VALUE_TYPE_NAME (&value));
 459
 460   g_value_reset (&value);
 461   g_value_reset (&svalue);
 462
 463   atk_value_get_minimum_increment (atk_value, &value);
 464   if (g_value_transform (&value, &svalue))
 465     g_string_append_printf (string, "%*sminimum increment: %s\n", depth, "", g_value_get_string (&svalue));
 466   else
 467     g_string_append_printf (string, "%*sminimum increment: %s\n", depth, "", G_VALUE_TYPE_NAME (&value));
 468
 469   g_value_reset (&value);
 470   g_value_reset (&svalue);
 471 }
 472
 473 static void
 474 dump_atk_hyperlink_impl (AtkHyperlinkImpl *impl,
 475                          guint             depth,
 476                          GString          *string)
 477 {
 478   AtkHyperlink *atk_link;
 479   gint i;
 480
 481   g_string_append_printf (string, "%*s<AtkHyperlinkImpl>\n", depth, "");
 482
 483   atk_link = atk_hyperlink_impl_get_hyperlink (impl);
 484
 485   g_string_append_printf (string, "%*sanchors:", depth, "");
 486
 487   for (i = 0; i < atk_hyperlink_get_n_anchors (atk_link); i++)
 488     {
 489       gchar *uri;
 490
 491       uri = atk_hyperlink_get_uri (atk_link, i);
 492       g_string_append_printf (string, " %s", uri);
 493       g_free (uri);
 494     }
 495   g_string_append_c (string, '\n');
 496
 497   g_object_unref (atk_link);
 498 }
 499
 500 static void
 501 dump_atk_streamable_content (AtkStreamableContent *content,
 502                              guint                 depth,
 503                              GString              *string)
 504 {
 505   gint i;
 506
 507   g_string_append_printf (string, "%*s<AtkStreamableContent>\n", depth, "");
 508
 509   g_string_append_printf (string, "%*smime types:", depth, "");
 510   for (i = 0; i < atk_streamable_content_get_n_mime_types (content); i++)
 511     g_string_append_printf (string, " %s", atk_streamable_content_get_mime_type (content, i));
 512   g_string_append_c (string, '\n');
 513 }
 514
 515 static void dump_accessible (AtkObject *accessible,
 516                              guint      depth,
 517                              GString   *string);
 518
 519 static void
 520 dump_atk_table (AtkTable *table,
 521                 guint     depth,
 522                 GString  *string)
 523 {
 524   gint *selected;
 525   gint n_selected;
 526   gint i;
 527   AtkObject *obj;
 528   const gchar *desc;
 529
 530   g_string_append_printf (string, "%*s<AtkTable>\n", depth, "");
 531
 532   obj = atk_table_get_summary (table);
 533   if (obj)
 534     {
 535       g_string_append_printf (string, "%*s<summary>\n", depth, "");
 536       dump_accessible (obj, depth, string);
 537     }
 538
 539   obj = atk_table_get_caption (table);
 540   if (obj)
 541     {
 542       g_string_append_printf (string, "%*s<caption>\n", depth, "");
 543       dump_accessible (obj, depth, string);
 544     }
 545
 546   g_string_append_printf (string, "%*srows: %d\n", depth, "", atk_table_get_n_rows (table));
 547   g_string_append_printf (string, "%*scolumns: %d\n", depth, "", atk_table_get_n_columns (table));
 548
 549   selected = NULL;
 550   n_selected = atk_table_get_selected_rows (table, &selected);
 551   if (n_selected > 0)
 552     {
 553       g_string_append_printf (string, "%*sselected rows:", depth, "");
 554       for (i = 0; i < n_selected; i++)
 555         g_string_append_printf (string, " %d", selected[i]);
 556       g_string_append_c (string, '\n');
 557     }
 558   g_free (selected);
 559
 560   selected = NULL;
 561   n_selected = atk_table_get_selected_columns (table, &selected);
 562   if (n_selected > 0)
 563     {
 564       g_string_append_printf (string, "%*sselected columns:", depth, "");
 565       for (i = 0; i < n_selected; i++)
 566         g_string_append_printf (string, " %d", selected[i]);
 567       g_string_append_c (string, '\n');
 568     }
 569   g_free (selected);
 570
 571
 572   for (i = 0; i < atk_table_get_n_columns (table); i++)
 573     {
 574       desc = atk_table_get_column_description (table, i);
 575       if (desc)
 576         g_string_append_printf (string, "%*scolumn %d description: %s\n", depth, "", i, desc);
 577       obj = atk_table_get_column_header (table, i);
 578       if (obj)
 579         {
 580           g_string_append_printf (string, "%*s<column %d header>\n", depth, "", i);
 581           dump_accessible (obj, depth, string);
 582         }
 583     }
 584
 585   for (i = 0; i < atk_table_get_n_rows (table); i++)
 586     {
 587       desc = atk_table_get_row_description (table, i);
 588       if (desc)
 589         g_string_append_printf (string, "%*srow %d description: %s\n", depth, "", i, desc);
 590       obj = atk_table_get_row_header (table, i);
 591       if (obj)
 592         {
 593           g_string_append_printf (string, "%*s<row %d header>\n", depth, "", i);
 594           dump_accessible (obj, depth, string);
 595         }
 596     }
 597 }
 598
 599 static void
 600 dump_accessible (AtkObject     *accessible,
 601                  guint          depth,
 602                  GString       *string)
 603 {
 604   guint i;
 605
 606   g_string_append_printf (string, "%*s%s\n", depth, "", get_name (accessible));
 607   depth += DEPTH_INCREMENT;
 608
 609   g_string_append_printf (string, "%*s\"%s\"\n", depth, "", atk_role_get_name (atk_object_get_role (accessible)));
 610   if (GTK_IS_ACCESSIBLE (atk_object_get_parent (accessible)))
 611     g_string_append_printf (string, "%*sparent: %s\n", depth, "", get_name (atk_object_get_parent (accessible)));
 612   if (atk_object_get_index_in_parent (accessible) != -1)
 613     g_string_append_printf (string, "%*sindex: %d\n", depth, "", atk_object_get_index_in_parent (accessible));
 614   if (atk_object_get_name (accessible))
 615     g_string_append_printf (string, "%*sname: %s\n", depth, "", atk_object_get_name (accessible));
 616   if (atk_object_get_description (accessible))
 617     g_string_append_printf (string, "%*sdescription: %s\n", depth, "", atk_object_get_description (accessible));
 618   dump_relation_set (string, depth, atk_object_ref_relation_set (accessible));
 619   dump_state_set (string, depth, atk_object_ref_state_set (accessible));
 620   dump_attribute_set (string, depth, atk_object_get_attributes (accessible));
 621
 622   if (ATK_IS_COMPONENT (accessible))
 623     dump_atk_component (ATK_COMPONENT (accessible), depth, string);
 624
 625   if (ATK_IS_TEXT (accessible))
 626     dump_atk_text (ATK_TEXT (accessible), depth, string);
 627
 628   if (ATK_IS_IMAGE (accessible))
 629     dump_atk_image (ATK_IMAGE (accessible), depth, string);
 630
 631   if (ATK_IS_ACTION (accessible))
 632     dump_atk_action (ATK_ACTION (accessible), depth, string);
 633
 634   if (ATK_IS_SELECTION (accessible))
 635     dump_atk_selection (ATK_SELECTION (accessible), depth, string);
 636
 637   if (ATK_IS_VALUE (accessible))
 638     dump_atk_value (ATK_VALUE (accessible), depth, string);
 639
 640   if (ATK_IS_HYPERLINK_IMPL (accessible))
 641     dump_atk_hyperlink_impl (ATK_HYPERLINK_IMPL (accessible), depth, string);
 642
 643   if (ATK_IS_STREAMABLE_CONTENT (accessible))
 644     dump_atk_streamable_content (ATK_STREAMABLE_CONTENT (accessible), depth, string);
 645
 646   if (ATK_IS_TABLE (accessible))
 647     dump_atk_table (ATK_TABLE (accessible), depth, string);
 648
 649   for (i = 0; i < atk_object_get_n_accessible_children (accessible); i++)
 650     {
 651       AtkObject *child = atk_object_ref_accessible_child (accessible, i);
 652       dump_accessible (child, depth, string);
 653       g_object_unref (child);
 654     }
 655 }
 656
 657 static GtkWidget *
 658 builder_get_toplevel (GtkBuilder *builder)
 659 {
 660   GSList *list, *walk;
 661   GtkWidget *window = NULL;
 662
 663   list = gtk_builder_get_objects (builder);
 664   for (walk = list; walk; walk = walk->next)
 665     {
 666       if (GTK_IS_WINDOW (walk->data) &&
 667           gtk_widget_get_parent (walk->data) == NULL)
 668         {
 669           window = walk->data;
 670           break;
 671         }
 672     }
 673
 674   g_slist_free (list);
 675
 676   return window;
 677 }
 678
 679 static void
 680 dump_ui_file (const char *ui_file,
 681               GString *string)
 682 {
 683   GtkWidget *window;
 684   GtkBuilder *builder;
 685   GError *error = NULL;
 686
 687   builder = gtk_builder_new ();
 688   gtk_builder_add_from_file (builder, ui_file, &error);
 689   g_assert_no_error (error);
 690   window = builder_get_toplevel (builder);
 691   g_object_unref (builder);
 692   g_assert (window);
 693
 694   gtk_widget_show (window);
 695
 696   dump_accessible (gtk_widget_get_accessible (window), 0, string);
 697   gtk_widget_destroy (window);
 698 }
 699
 700 static void
 701 dump_to_stdout (GFile *file)
 702 {
 703   char *ui_file;
 704   GString *dump;
 705
 706   ui_file = g_file_get_path (file);
 707   dump = g_string_new ("");
 708
 709   dump_ui_file (ui_file, dump);
 710   g_print ("%s", dump->str);
 711
 712   g_string_free (dump, TRUE);
 713   g_free (ui_file);
 714 }
 715
 716 static void
 717 test_ui_file (GFile *file)
 718 {
 719   char *ui_file, *a11y_file;
 720   GString *dump;
 721   GError *error = NULL;
 722
 723   ui_file = g_file_get_path (file);
 724   a11y_file = get_test_file (ui_file, ".txt", TRUE);
 725   dump = g_string_new ("");
 726
 727   dump_ui_file (ui_file, dump);
 728
 729   if (a11y_file)
 730     {
 731       char *diff = diff_with_file (a11y_file, dump->str, dump->len, &error);
 732       g_assert_no_error (error);
 733
 734       if (diff && diff[0])
 735         {
 736           g_test_message ("Contents don't match expected contents:\n%s", diff);
 737           g_test_fail ();
 738           g_free (diff);
 739         }
 740     }
 741   else if (dump->str[0])
 742     {
 743       g_test_message ("Expected a reference file:\n%s", dump->str);
 744       g_test_fail ();
 745     }
 746
 747   g_string_free (dump, TRUE);
 748   g_free (a11y_file);
 749   g_free (ui_file);
 750 }
 751
 752 static void
 753 add_test_for_file (GFile *file)
 754 {
 755   g_test_add_vtable (g_file_get_path (file),
 756                      0,
 757                      g_object_ref (file),
 758                      (GTestFixtureFunc) setup_test,
 759                      (GTestFixtureFunc) test_ui_file,
 760                      (GTestFixtureFunc) g_object_unref);
 761 }
 762
 763 static int
 764 compare_files (gconstpointer a, gconstpointer b)
 765 {
 766   GFile *file1 = G_FILE (a);
 767   GFile *file2 = G_FILE (b);
 768   char *path1, *path2;
 769   int result;
 770
 771   path1 = g_file_get_path (file1);
 772   path2 = g_file_get_path (file2);
 773
 774   result = strcmp (path1, path2);
 775
 776   g_free (path1);
 777   g_free (path2);
 778
 779   return result;
 780 }
 781
 782 static void
 783 add_tests_for_files_in_directory (GFile *dir)
 784 {
 785   GFileEnumerator *enumerator;
 786   GFileInfo *info;
 787   GList *files;
 788   GError *error = NULL;
 789
 790   enumerator = g_file_enumerate_children (dir, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
 791   g_assert_no_error (error);
 792   files = NULL;
 793
 794   while ((info = g_file_enumerator_next_file (enumerator, NULL, &error)))
 795     {
 796       const char *filename;
 797
 798       filename = g_file_info_get_name (info);
 799
 800       if (!g_str_has_suffix (filename, ".ui"))
 801         {
 802           g_object_unref (info);
 803           continue;
 804         }
 805
 806       files = g_list_prepend (files, g_file_get_child (dir, filename));
 807
 808       g_object_unref (info);
 809     }
 810
 811   g_assert_no_error (error);
 812   g_object_unref (enumerator);
 813
 814   files = g_list_sort (files, compare_files);
 815   g_list_foreach (files, (GFunc) add_test_for_file, NULL);
 816   g_list_free_full (files, g_object_unref);
 817 }
 818
 819 int
 820 main (int argc, char **argv)
 821 {
 822   gtk_test_init (&argc, &argv);
 823
 824   if (argc < 2)
 825     {
 826       const char *basedir;
 827       GFile *dir;
 828
 829       if (g_getenv ("srcdir"))
 830         basedir = g_getenv ("srcdir");
 831       else
 832         basedir = ".";
 833
 834       dir = g_file_new_for_path (basedir);
 835
 836       add_tests_for_files_in_directory (dir);
 837
 838       g_object_unref (dir);
 839     }
 840   else if (argc == 3 && strcmp (argv[1], "--generate") == 0)
 841     {
 842       GFile *file = g_file_new_for_commandline_arg (argv[2]);
 843
 844       dump_to_stdout (file);
 845
 846       g_object_unref (file);
 847
 848       return 0;
 849     }
 850   else
 851     {
 852       guint i;
 853
 854       for (i = 1; i < argc; i++)
 855         {
 856           GFile *file = g_file_new_for_commandline_arg (argv[i]);
 857
 858           add_test_for_file (file);
 859
 860           g_object_unref (file);
 861         }
 862     }
 863
 864   return g_test_run ();
 865 }
 866