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   AtkAttribute *aattr = a;
 239   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   gint i;
 394
 395   g_string_append_printf (string, "%*s<AtkSelection>\n", depth, "");
 396
 397   g_string_append_printf (string, "%*sselection count: %d\n", depth, "", atk_selection_get_selection_count (atk_selection));
 398
 399   if (atk_selection_get_selection_count (atk_selection) > 0)
 400     {
 401       g_string_append_printf (string, "%*sselected children:", depth, "");
 402       for (i = 0; i < atk_object_get_n_accessible_children (ATK_OBJECT (atk_selection)); i++)
 403         {
 404           if (atk_selection_is_child_selected (atk_selection, i))
 405             g_string_append_printf (string, " %d", i);
 406         }
 407       g_string_append_c (string, '\n');
 408     }
 409 }
 410
 411 static void
 412 dump_atk_value (AtkValue *atk_value,
 413                 guint     depth,
 414                 GString  *string)
 415 {
 416   GValue value = { 0, };
 417   GValue svalue = { 0, };
 418
 419   g_string_append_printf (string, "%*s<AtkValue>\n", depth, "");
 420
 421   g_value_init (&value, G_TYPE_DOUBLE);
 422   g_value_init (&svalue, G_TYPE_STRING);
 423
 424   atk_value_get_minimum_value (atk_value, &value);
 425   if (g_value_transform (&value, &svalue))
 426     g_string_append_printf (string, "%*sminimum value: %s\n", depth, "", g_value_get_string (&svalue));
 427   else
 428     g_string_append_printf (string, "%*sminimum value: <%s>\n", depth, "", G_VALUE_TYPE_NAME (&value));
 429
 430   g_value_reset (&value);
 431   g_value_reset (&svalue);
 432
 433   atk_value_get_maximum_value (atk_value, &value);
 434   if (g_value_transform (&value, &svalue))
 435     g_string_append_printf (string, "%*smaximum value: %s\n", depth, "", g_value_get_string (&svalue));
 436   else
 437     g_string_append_printf (string, "%*smaximum value: <%s>\n", depth, "", G_VALUE_TYPE_NAME (&value));
 438
 439   g_value_reset (&value);
 440   g_value_reset (&svalue);
 441
 442   atk_value_get_current_value (atk_value, &value);
 443   if (g_value_transform (&value, &svalue))
 444     g_string_append_printf (string, "%*scurrent value: %s\n", depth, "", g_value_get_string (&svalue));
 445   else
 446     g_string_append_printf (string, "%*scurrent value: %s\n", depth, "", G_VALUE_TYPE_NAME (&value));
 447
 448   g_value_reset (&value);
 449   g_value_reset (&svalue);
 450
 451   atk_value_get_minimum_increment (atk_value, &value);
 452   if (g_value_transform (&value, &svalue))
 453     g_string_append_printf (string, "%*sminimum increment: %s\n", depth, "", g_value_get_string (&svalue));
 454   else
 455     g_string_append_printf (string, "%*sminimum increment: %s\n", depth, "", G_VALUE_TYPE_NAME (&value));
 456
 457   g_value_reset (&value);
 458   g_value_reset (&svalue);
 459 }
 460
 461 static void
 462 dump_atk_hyperlink_impl (AtkHyperlinkImpl *impl,
 463                          guint             depth,
 464                          GString          *string)
 465 {
 466   AtkHyperlink *atk_link;
 467   gint i;
 468
 469   g_string_append_printf (string, "%*s<AtkHyperlinkImpl>\n", depth, "");
 470
 471   atk_link = atk_hyperlink_impl_get_hyperlink (impl);
 472
 473   g_string_append_printf (string, "%*sanchors:", depth, "");
 474
 475   for (i = 0; i < atk_hyperlink_get_n_anchors (atk_link); i++)
 476     {
 477       gchar *uri;
 478
 479       uri = atk_hyperlink_get_uri (atk_link, i);
 480       g_string_append_printf (string, " %s", uri);
 481       g_free (uri);
 482     }
 483   g_string_append_c (string, '\n');
 484
 485   g_object_unref (atk_link);
 486 }
 487
 488 static void
 489 dump_atk_streamable_content (AtkStreamableContent *content,
 490                              guint                 depth,
 491                              GString              *string)
 492 {
 493   gint i;
 494
 495   g_string_append_printf (string, "%*s<AtkStreamableContent>\n", depth, "");
 496
 497   g_string_append_printf (string, "%*smime types:", depth, "");
 498   for (i = 0; i < atk_streamable_content_get_n_mime_types (content); i++)
 499     g_string_append_printf (string, " %s", atk_streamable_content_get_mime_type (content, i));
 500   g_string_append_c (string, '\n');
 501 }
 502
 503 static void dump_accessible (AtkObject *accessible,
 504                              guint      depth,
 505                              GString   *string);
 506
 507 static void
 508 dump_atk_table (AtkTable *table,
 509                 guint     depth,
 510                 GString  *string)
 511 {
 512   gint *selected;
 513   gint n_selected;
 514   gint i;
 515   AtkObject *obj;
 516   const gchar *desc;
 517
 518   g_string_append_printf (string, "%*s<AtkTable>\n", depth, "");
 519
 520   obj = atk_table_get_summary (table);
 521   if (obj)
 522     {
 523       g_string_append_printf (string, "%*s<summary>\n", depth, "");
 524       dump_accessible (obj, depth, string);
 525     }
 526
 527   obj = atk_table_get_caption (table);
 528   if (obj)
 529     {
 530       g_string_append_printf (string, "%*s<caption>\n", depth, "");
 531       dump_accessible (obj, depth, string);
 532     }
 533
 534   g_string_append_printf (string, "%*srows: %d\n", depth, "", atk_table_get_n_rows (table));
 535   g_string_append_printf (string, "%*scolumns: %d\n", depth, "", atk_table_get_n_columns (table));
 536
 537   selected = NULL;
 538   n_selected = atk_table_get_selected_rows (table, &selected);
 539   if (n_selected > 0)
 540     {
 541       g_string_append_printf (string, "%*sselected rows:", depth, "");
 542       for (i = 0; i < n_selected; i++)
 543         g_string_append_printf (string, " %d", selected[i]);
 544       g_string_append_c (string, '\n');
 545     }
 546   g_free (selected);
 547
 548   selected = NULL;
 549   n_selected = atk_table_get_selected_columns (table, &selected);
 550   if (n_selected > 0)
 551     {
 552       g_string_append_printf (string, "%*sselected columns:", depth, "");
 553       for (i = 0; i < n_selected; i++)
 554         g_string_append_printf (string, " %d", selected[i]);
 555       g_string_append_c (string, '\n');
 556     }
 557   g_free (selected);
 558
 559
 560   for (i = 0; i < atk_table_get_n_columns (table); i++)
 561     {
 562       desc = atk_table_get_column_description (table, i);
 563       if (desc)
 564         g_string_append_printf (string, "%*scolumn %d description: %s\n", depth, "", i, desc);
 565       obj = atk_table_get_column_header (table, i);
 566       if (obj)
 567         {
 568           g_string_append_printf (string, "%*s<column %d header>\n", depth, "", i);
 569           dump_accessible (obj, depth, string);
 570         }
 571     }
 572
 573   for (i = 0; i < atk_table_get_n_rows (table); i++)
 574     {
 575       desc = atk_table_get_row_description (table, i);
 576       if (desc)
 577         g_string_append_printf (string, "%*srow %d description: %s\n", depth, "", i, desc);
 578       obj = atk_table_get_row_header (table, i);
 579       if (obj)
 580         {
 581           g_string_append_printf (string, "%*s<row %d header>\n", depth, "", i);
 582           dump_accessible (obj, depth, string);
 583         }
 584     }
 585 }
 586
 587 static void
 588 dump_accessible (AtkObject     *accessible,
 589                  guint          depth,
 590                  GString       *string)
 591 {
 592   guint i;
 593
 594   g_string_append_printf (string, "%*s%s\n", depth, "", get_name (accessible));
 595   depth += DEPTH_INCREMENT;
 596
 597   g_string_append_printf (string, "%*s\"%s\"\n", depth, "", atk_role_get_name (atk_object_get_role (accessible)));
 598   if (GTK_IS_ACCESSIBLE (atk_object_get_parent (accessible)))
 599     g_string_append_printf (string, "%*sparent: %s\n", depth, "", get_name (atk_object_get_parent (accessible)));
 600   if (atk_object_get_index_in_parent (accessible) != -1)
 601     g_string_append_printf (string, "%*sindex: %d\n", depth, "", atk_object_get_index_in_parent (accessible));
 602   if (atk_object_get_name (accessible))
 603     g_string_append_printf (string, "%*sname: %s\n", depth, "", atk_object_get_name (accessible));
 604   if (atk_object_get_description (accessible))
 605     g_string_append_printf (string, "%*sdescription: %s\n", depth, "", atk_object_get_description (accessible));
 606   dump_relation_set (string, depth, atk_object_ref_relation_set (accessible));
 607   dump_state_set (string, depth, atk_object_ref_state_set (accessible));
 608   dump_attribute_set (string, depth, atk_object_get_attributes (accessible));
 609
 610   if (ATK_IS_COMPONENT (accessible))
 611     dump_atk_component (ATK_COMPONENT (accessible), depth, string);
 612
 613   if (ATK_IS_TEXT (accessible))
 614     dump_atk_text (ATK_TEXT (accessible), depth, string);
 615
 616   if (ATK_IS_IMAGE (accessible))
 617     dump_atk_image (ATK_IMAGE (accessible), depth, string);
 618
 619   if (ATK_IS_ACTION (accessible))
 620     dump_atk_action (ATK_ACTION (accessible), depth, string);
 621
 622   if (ATK_IS_SELECTION (accessible))
 623     dump_atk_selection (ATK_SELECTION (accessible), depth, string);
 624
 625   if (ATK_IS_VALUE (accessible))
 626     dump_atk_value (ATK_VALUE (accessible), depth, string);
 627
 628   if (ATK_IS_HYPERLINK_IMPL (accessible))
 629     dump_atk_hyperlink_impl (ATK_HYPERLINK_IMPL (accessible), depth, string);
 630
 631   if (ATK_IS_STREAMABLE_CONTENT (accessible))
 632     dump_atk_streamable_content (ATK_STREAMABLE_CONTENT (accessible), depth, string);
 633
 634   if (ATK_IS_TABLE (accessible))
 635     dump_atk_table (ATK_TABLE (accessible), depth, string);
 636
 637   for (i = 0; i < atk_object_get_n_accessible_children (accessible); i++)
 638     {
 639       AtkObject *child = atk_object_ref_accessible_child (accessible, i);
 640       dump_accessible (child, depth, string);
 641       g_object_unref (child);
 642     }
 643 }
 644
 645 static GtkWidget *
 646 builder_get_toplevel (GtkBuilder *builder)
 647 {
 648   GSList *list, *walk;
 649   GtkWidget *window = NULL;
 650
 651   list = gtk_builder_get_objects (builder);
 652   for (walk = list; walk; walk = walk->next)
 653     {
 654       if (GTK_IS_WINDOW (walk->data) &&
 655           gtk_widget_get_parent (walk->data) == NULL)
 656         {
 657           window = walk->data;
 658           break;
 659         }
 660     }
 661
 662   g_slist_free (list);
 663
 664   return window;
 665 }
 666
 667 static void
 668 dump_ui_file (const char *ui_file,
 669               GString *string)
 670 {
 671   GtkWidget *window;
 672   GtkBuilder *builder;
 673   GError *error = NULL;
 674
 675   builder = gtk_builder_new ();
 676   gtk_builder_add_from_file (builder, ui_file, &error);
 677   g_assert_no_error (error);
 678   window = builder_get_toplevel (builder);
 679   g_object_unref (builder);
 680   g_assert (window);
 681
 682   gtk_widget_show (window);
 683
 684   dump_accessible (gtk_widget_get_accessible (window), 0, string);
 685   gtk_widget_destroy (window);
 686 }
 687
 688 static void
 689 dump_to_stdout (GFile *file)
 690 {
 691   char *ui_file;
 692   GString *dump;
 693
 694   ui_file = g_file_get_path (file);
 695   dump = g_string_new ("");
 696
 697   dump_ui_file (ui_file, dump);
 698   g_print ("%s", dump->str);
 699
 700   g_string_free (dump, TRUE);
 701   g_free (ui_file);
 702 }
 703
 704 static void
 705 test_ui_file (GFile *file)
 706 {
 707   char *ui_file, *a11y_file;
 708   GString *dump;
 709   GError *error = NULL;
 710
 711   ui_file = g_file_get_path (file);
 712   a11y_file = get_test_file (ui_file, ".txt", TRUE);
 713   dump = g_string_new ("");
 714
 715   dump_ui_file (ui_file, dump);
 716
 717   if (a11y_file)
 718     {
 719       char *diff = diff_with_file (a11y_file, dump->str, dump->len, &error);
 720       g_assert_no_error (error);
 721
 722       if (diff && diff[0])
 723         {
 724           g_test_message ("Contents don't match expected contents:\n%s", diff);
 725           g_test_fail ();
 726           g_free (diff);
 727         }
 728     }
 729   else if (dump->str[0])
 730     {
 731       g_test_message ("Expected a reference file:\n%s", dump->str);
 732       g_test_fail ();
 733     }
 734
 735   g_string_free (dump, TRUE);
 736   g_free (a11y_file);
 737   g_free (ui_file);
 738 }
 739
 740 static void
 741 add_test_for_file (GFile *file)
 742 {
 743   g_test_add_vtable (g_file_get_path (file),
 744                      0,
 745                      g_object_ref (file),
 746                      (GTestFixtureFunc) setup_test,
 747                      (GTestFixtureFunc) test_ui_file,
 748                      (GTestFixtureFunc) g_object_unref);
 749 }
 750
 751 static int
 752 compare_files (gconstpointer a, gconstpointer b)
 753 {
 754   GFile *file1 = G_FILE (a);
 755   GFile *file2 = G_FILE (b);
 756   char *path1, *path2;
 757   int result;
 758
 759   path1 = g_file_get_path (file1);
 760   path2 = g_file_get_path (file2);
 761
 762   result = strcmp (path1, path2);
 763
 764   g_free (path1);
 765   g_free (path2);
 766
 767   return result;
 768 }
 769
 770 static void
 771 add_tests_for_files_in_directory (GFile *dir)
 772 {
 773   GFileEnumerator *enumerator;
 774   GFileInfo *info;
 775   GList *files;
 776   GError *error = NULL;
 777
 778   enumerator = g_file_enumerate_children (dir, G_FILE_ATTRIBUTE_STANDARD_NAME, 0, NULL, &error);
 779   g_assert_no_error (error);
 780   files = NULL;
 781
 782   while ((info = g_file_enumerator_next_file (enumerator, NULL, &error)))
 783     {
 784       const char *filename;
 785
 786       filename = g_file_info_get_name (info);
 787
 788       if (!g_str_has_suffix (filename, ".ui"))
 789         {
 790           g_object_unref (info);
 791           continue;
 792         }
 793
 794       files = g_list_prepend (files, g_file_get_child (dir, filename));
 795
 796       g_object_unref (info);
 797     }
 798
 799   g_assert_no_error (error);
 800   g_object_unref (enumerator);
 801
 802   files = g_list_sort (files, compare_files);
 803   g_list_foreach (files, (GFunc) add_test_for_file, NULL);
 804   g_list_free_full (files, g_object_unref);
 805 }
 806
 807 int
 808 main (int argc, char **argv)
 809 {
 810   gtk_test_init (&argc, &argv);
 811
 812   if (argc < 2)
 813     {
 814       const char *basedir;
 815       GFile *dir;
 816
 817       if (g_getenv ("srcdir"))
 818         basedir = g_getenv ("srcdir");
 819       else
 820         basedir = ".";
 821
 822       dir = g_file_new_for_path (basedir);
 823
 824       add_tests_for_files_in_directory (dir);
 825
 826       g_object_unref (dir);
 827     }
 828   else if (argc == 3 && strcmp (argv[1], "--generate") == 0)
 829     {
 830       GFile *file = g_file_new_for_commandline_arg (argv[2]);
 831
 832       dump_to_stdout (file);
 833
 834       g_object_unref (file);
 835
 836       return 0;
 837     }
 838   else
 839     {
 840       guint i;
 841
 842       for (i = 1; i < argc; i++)
 843         {
 844           GFile *file = g_file_new_for_commandline_arg (argv[i]);
 845
 846           add_test_for_file (file);
 847
 848           g_object_unref (file);
 849         }
 850     }
 851
 852   return g_test_run ();
 853 }
 854