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

   1 /*
   2  * Copyright (C) 2011 Red Hat Inc.
   3  *
   4  * Author:
   5  *      Matthias Clasen <mclasen@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 <gtk/gtk.h>
  24 #include <string.h>
  25
  26 static void
  27 set_text (GtkWidget   *widget,
  28           const gchar *text)
  29 {
  30   if (GTK_IS_LABEL (widget))
  31     gtk_label_set_text (GTK_LABEL (widget), text);
  32   else if (GTK_IS_ENTRY (widget))
  33     gtk_entry_set_text (GTK_ENTRY (widget), text);
  34   else if (GTK_IS_TEXT_VIEW (widget))
  35     gtk_text_buffer_set_text (gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget)), text, -1);
  36   else
  37     g_assert_not_reached ();
  38 }
  39
  40 static void
  41 test_basic (GtkWidget *widget)
  42 {
  43   AtkText *atk_text;
  44   const gchar *text = "Text goes here";
  45   gchar *ret;
  46   gint count;
  47   gunichar c;
  48
  49   atk_text = ATK_TEXT (gtk_widget_get_accessible (widget));
  50
  51   set_text (widget, text);
  52   ret = atk_text_get_text (atk_text, 5, 9);
  53   g_assert_cmpstr (ret, ==, "goes");
  54   g_free (ret);
  55
  56   ret = atk_text_get_text (atk_text, 0, 14);
  57   g_assert_cmpstr (ret, ==, text);
  58   g_free (ret);
  59
  60   ret = atk_text_get_text (atk_text, 0, -1);
  61   g_assert_cmpstr (ret, ==, text);
  62   g_free (ret);
  63
  64   count = atk_text_get_character_count (atk_text);
  65   g_assert_cmpint (count, ==, g_utf8_strlen (text, -1));
  66
  67   c = atk_text_get_character_at_offset (atk_text, 0);
  68   g_assert_cmpint (c, ==, 'T');
  69
  70   c = atk_text_get_character_at_offset (atk_text, 13);
  71   g_assert_cmpint (c, ==, 'e');
  72 }
  73
  74 typedef struct {
  75   gint count;
  76   gint position;
  77   gint length;
  78 } SignalData;
  79
  80 static void
  81 text_deleted (AtkText *atk_text, gint position, gint length, SignalData *data)
  82 {
  83   data->count++;
  84   data->position = position;
  85   data->length = length;
  86 }
  87
  88 static void
  89 text_inserted (AtkText *atk_text, gint position, gint length, SignalData *data)
  90 {
  91   data->count++;
  92   data->position = position;
  93   data->length = length;
  94 }
  95
  96 static void
  97 test_text_changed (GtkWidget *widget)
  98 {
  99   AtkText *atk_text;
 100   const gchar *text = "Text goes here";
 101   const gchar *text2 = "Text again";
 102   SignalData delete_data;
 103   SignalData insert_data;
 104
 105   atk_text = ATK_TEXT (gtk_widget_get_accessible (widget));
 106
 107   delete_data.count = 0;
 108   insert_data.count = 0;
 109
 110   g_signal_connect (atk_text, "text_changed::delete",
 111                     G_CALLBACK (text_deleted), &delete_data);
 112   g_signal_connect (atk_text, "text_changed::insert",
 113                     G_CALLBACK (text_inserted), &insert_data);
 114
 115   set_text (widget, text);
 116
 117   g_assert_cmpint (delete_data.count, ==, 0);
 118
 119   g_assert_cmpint (insert_data.count, ==, 1);
 120   g_assert_cmpint (insert_data.position, ==, 0);
 121   g_assert_cmpint (insert_data.length, ==, g_utf8_strlen (text, -1));
 122
 123   set_text (widget, text2);
 124
 125   g_assert_cmpint (delete_data.count, ==, 1);
 126   g_assert_cmpint (delete_data.position, ==, 0);
 127   g_assert_cmpint (delete_data.length, ==, g_utf8_strlen (text, -1));
 128
 129   g_assert_cmpint (insert_data.count, ==, 2);
 130   g_assert_cmpint (insert_data.position, ==, 0);
 131   g_assert_cmpint (insert_data.length, ==, g_utf8_strlen (text2, -1));
 132
 133   set_text (widget, "");
 134
 135   g_assert_cmpint (delete_data.count, ==, 2);
 136   g_assert_cmpint (delete_data.position, ==, 0);
 137   g_assert_cmpint (delete_data.length, ==, g_utf8_strlen (text2, -1));
 138
 139   g_assert_cmpint (insert_data.count, ==, 2);
 140
 141   g_signal_handlers_disconnect_by_func (atk_text, G_CALLBACK (text_deleted), &delete_data);
 142   g_signal_handlers_disconnect_by_func (atk_text, G_CALLBACK (text_inserted), &insert_data);
 143 }
 144
 145 typedef struct {
 146   gint gravity;
 147   gint offset;
 148   AtkTextBoundary boundary;
 149   gint start;
 150   gint end;
 151   const gchar *word;
 152 } Word;
 153
 154 static const gchar *
 155 boundary (AtkTextBoundary b)
 156 {
 157   switch (b)
 158     {
 159     case ATK_TEXT_BOUNDARY_CHAR:           return "ATK_TEXT_BOUNDARY_CHAR,          ";
 160     case ATK_TEXT_BOUNDARY_WORD_START:     return "ATK_TEXT_BOUNDARY_WORD_START,    ";
 161     case ATK_TEXT_BOUNDARY_WORD_END:       return "ATK_TEXT_BOUNDARY_WORD_END,      ";
 162     case ATK_TEXT_BOUNDARY_SENTENCE_START: return "ATK_TEXT_BOUNDARY_SENTENCE_START,";
 163     case ATK_TEXT_BOUNDARY_SENTENCE_END:   return "ATK_TEXT_BOUNDARY_SENTENCE_END,  ";
 164     case ATK_TEXT_BOUNDARY_LINE_START:     return "ATK_TEXT_BOUNDARY_LINE_START,    ";
 165     case ATK_TEXT_BOUNDARY_LINE_END:       return "ATK_TEXT_BOUNDARY_LINE_END,      ";
 166     default: g_assert_not_reached ();
 167     }
 168 }
 169
 170 static const gchar *
 171 gravity (gint g)
 172 {
 173   if (g < 0) return "before";
 174   else if (g > 0) return "after";
 175   else return "around";
 176 }
 177
 178 const gchar *
 179 char_rep (gunichar c)
 180 {
 181   static gchar out[6];
 182
 183   switch (c)
 184     {
 185       case '\n': return "\\n";
 186       case 196: return "?";
 187       case 214: return "?";
 188       case 220: return "?";
 189       default:
 190         memset (out, 0, 6);
 191         g_unichar_to_utf8 (c, out);
 192         return out;
 193     }
 194 }
 195
 196 gchar *
 197 escape (const gchar *p)
 198 {
 199   GString *s;
 200
 201   s = g_string_new ("");
 202
 203   while (*p)
 204     {
 205       if (*p == '\n')
 206         g_string_append (s, "\\n");
 207       else
 208         g_string_append_c (s, *p);
 209       p++;
 210     }
 211
 212   return g_string_free (s, FALSE);
 213 }
 214
 215 static void
 216 show_text_attributes (PangoLayout *l)
 217 {
 218   const PangoLogAttr *attr;
 219   gint n_attrs;
 220   const gchar *s;
 221   gchar e;
 222   const gchar *p;
 223   gint i;
 224   const gchar *text;
 225   GSList *lines, *li;
 226   glong so, eo;
 227
 228   printf ("\n");
 229
 230   text = pango_layout_get_text (l);
 231   attr = pango_layout_get_log_attrs_readonly (l, &n_attrs);
 232
 233   p = text;
 234   while (*p)
 235     {
 236       s = char_rep (g_utf8_get_char (p));
 237       printf (" %s", s);
 238       p = g_utf8_next_char (p);
 239     }
 240   printf ("\n");
 241   p = text;
 242   i = 0;
 243   do
 244     {
 245       if (*p)
 246         s = char_rep (g_utf8_get_char (p));
 247       else
 248         s = "";
 249       if (attr[i].is_word_start && attr[i].is_word_end)
 250         e = '|';
 251       else if (attr[i].is_word_start)
 252         e = '<';
 253       else if (attr[i].is_word_end)
 254         e = '>';
 255       else
 256         e = ' ';
 257       printf ("%c%*s", e, strlen (s), "");
 258       if (*p)
 259         p = g_utf8_next_char (p);
 260       i++;
 261     }
 262   while (*p || i < n_attrs);
 263   printf ("\n");
 264
 265   p = text;
 266   i = 0;
 267   do
 268     {
 269       if (*p)
 270         s = char_rep (g_utf8_get_char (p));
 271       else
 272         s = "";
 273       if (attr[i].is_sentence_start && attr[i].is_sentence_end)
 274         e = '|';
 275       else if (attr[i].is_sentence_start)
 276         e = '<';
 277       else if (attr[i].is_sentence_end)
 278         e = '>';
 279       else
 280         e = ' ';
 281       printf ("%c%*s", e, strlen (s), "");
 282       if (*p)
 283         p = g_utf8_next_char (p);
 284       i++;
 285     }
 286   while (*p || i < n_attrs);
 287   printf ("\n");
 288
 289   lines = pango_layout_get_lines_readonly (l);
 290   p = text;
 291   i = 0;
 292   do
 293     {
 294       gboolean start, end;
 295
 296       if (*p)
 297         s = char_rep (g_utf8_get_char (p));
 298       else
 299         s = "";
 300       start = end = FALSE;
 301       for (li = lines; li; li = li->next)
 302         {
 303           PangoLayoutLine *line = li->data;
 304           so = g_utf8_pointer_to_offset (text, text + line->start_index);
 305           eo = g_utf8_pointer_to_offset (text, text + line->start_index + line->length);
 306           if (so == i)
 307             start = TRUE;
 308           if (eo == i)
 309             end = TRUE;
 310         }
 311       if (start && end)
 312         e = '|';
 313       else if (start)
 314         e = '<';
 315       else if (end)
 316         e = '>';
 317       else
 318         e = ' ';
 319       printf ("%c%*s", e, strlen (s), "");
 320       if (*p)
 321         p = g_utf8_next_char (p);
 322       i++;
 323     }
 324   while (*p || i < n_attrs);
 325   printf ("\n");
 326 }
 327
 328 static void
 329 test_words (GtkWidget *widget)
 330 {
 331   AtkText *atk_text;
 332   const gchar *text = "abc! def\nghi jkl\nmno";
 333   Word expected[] = {
 334     { -1,  0, ATK_TEXT_BOUNDARY_CHAR,  0,  0, "" },
 335     { -1,  1, ATK_TEXT_BOUNDARY_CHAR,  0,  1, "a" },
 336     { -1,  2, ATK_TEXT_BOUNDARY_CHAR,  1,  2, "b" },
 337     { -1,  3, ATK_TEXT_BOUNDARY_CHAR,  2,  3, "c" },
 338     { -1,  4, ATK_TEXT_BOUNDARY_CHAR,  3,  4, "!" },
 339     { -1,  5, ATK_TEXT_BOUNDARY_CHAR,  4,  5, " " },
 340     { -1,  6, ATK_TEXT_BOUNDARY_CHAR,  5,  6, "d" },
 341     { -1,  7, ATK_TEXT_BOUNDARY_CHAR,  6,  7, "e" },
 342     { -1,  8, ATK_TEXT_BOUNDARY_CHAR,  7,  8, "f" },
 343     { -1,  9, ATK_TEXT_BOUNDARY_CHAR,  8,  9, "\n" },
 344     { -1, 10, ATK_TEXT_BOUNDARY_CHAR,  9, 10, "g" },
 345     { -1, 11, ATK_TEXT_BOUNDARY_CHAR, 10, 11, "h" },
 346     { -1, 12, ATK_TEXT_BOUNDARY_CHAR, 11, 12, "i" },
 347     { -1, 13, ATK_TEXT_BOUNDARY_CHAR, 12, 13, " " },
 348     { -1, 14, ATK_TEXT_BOUNDARY_CHAR, 13, 14, "j" },
 349     { -1, 15, ATK_TEXT_BOUNDARY_CHAR, 14, 15, "k" },
 350     { -1, 16, ATK_TEXT_BOUNDARY_CHAR, 15, 16, "l" },
 351     { -1, 17, ATK_TEXT_BOUNDARY_CHAR, 16, 17, "\n" },
 352     { -1, 18, ATK_TEXT_BOUNDARY_CHAR, 17, 18, "m" },
 353     { -1, 19, ATK_TEXT_BOUNDARY_CHAR, 18, 19, "n" },
 354     { -1, 20, ATK_TEXT_BOUNDARY_CHAR, 19, 20, "o" },
 355     { -1,  0, ATK_TEXT_BOUNDARY_WORD_START,  0,  0, "" },
 356     { -1,  1, ATK_TEXT_BOUNDARY_WORD_START,  0,  0, "" },
 357     { -1,  2, ATK_TEXT_BOUNDARY_WORD_START,  0,  0, "" },
 358     { -1,  3, ATK_TEXT_BOUNDARY_WORD_START,  0,  0, "" },
 359     { -1,  4, ATK_TEXT_BOUNDARY_WORD_START,  0,  0, "" },
 360     { -1,  5, ATK_TEXT_BOUNDARY_WORD_START,  0,  5, "abc! " },
 361     { -1,  6, ATK_TEXT_BOUNDARY_WORD_START,  0,  5, "abc! " },
 362     { -1,  7, ATK_TEXT_BOUNDARY_WORD_START,  0,  5, "abc! " },
 363     { -1,  8, ATK_TEXT_BOUNDARY_WORD_START,  0,  5, "abc! " },
 364     { -1,  9, ATK_TEXT_BOUNDARY_WORD_START,  5,  9, "def\n" },
 365     { -1, 10, ATK_TEXT_BOUNDARY_WORD_START,  5,  9, "def\n" },
 366     { -1, 11, ATK_TEXT_BOUNDARY_WORD_START,  5,  9, "def\n" },
 367     { -1, 12, ATK_TEXT_BOUNDARY_WORD_START,  5,  9, "def\n" },
 368     { -1, 13, ATK_TEXT_BOUNDARY_WORD_START,  9, 13, "ghi " },
 369     { -1, 14, ATK_TEXT_BOUNDARY_WORD_START,  9, 13, "ghi " },
 370     { -1, 15, ATK_TEXT_BOUNDARY_WORD_START,  9, 13, "ghi " },
 371     { -1, 16, ATK_TEXT_BOUNDARY_WORD_START,  9, 13, "ghi " },
 372     { -1, 17, ATK_TEXT_BOUNDARY_WORD_START, 13, 17, "jkl\n" },
 373     { -1, 18, ATK_TEXT_BOUNDARY_WORD_START, 13, 17, "jkl\n" },
 374     { -1, 19, ATK_TEXT_BOUNDARY_WORD_START, 13, 17, "jkl\n" },
 375     { -1, 20, ATK_TEXT_BOUNDARY_WORD_START, 13, 17, "jkl\n" },
 376     { -1,  0, ATK_TEXT_BOUNDARY_WORD_END,  0,  0, "" },
 377     { -1,  1, ATK_TEXT_BOUNDARY_WORD_END,  0,  0, "" },
 378     { -1,  2, ATK_TEXT_BOUNDARY_WORD_END,  0,  0, "" },
 379     { -1,  3, ATK_TEXT_BOUNDARY_WORD_END,  0,  3, "abc" },
 380     { -1,  4, ATK_TEXT_BOUNDARY_WORD_END,  0,  3, "abc" },
 381     { -1,  5, ATK_TEXT_BOUNDARY_WORD_END,  0,  3, "abc" },
 382     { -1,  6, ATK_TEXT_BOUNDARY_WORD_END,  0,  3, "abc" },
 383     { -1,  7, ATK_TEXT_BOUNDARY_WORD_END,  0,  3, "abc" },
 384     { -1,  8, ATK_TEXT_BOUNDARY_WORD_END,  3,  8, "! def" },
 385     { -1,  9, ATK_TEXT_BOUNDARY_WORD_END,  3,  8, "! def" },
 386     { -1, 10, ATK_TEXT_BOUNDARY_WORD_END,  3,  8, "! def" },
 387     { -1, 11, ATK_TEXT_BOUNDARY_WORD_END,  3,  8, "! def" },
 388     { -1, 12, ATK_TEXT_BOUNDARY_WORD_END,  8, 12, "\nghi" },
 389     { -1, 13, ATK_TEXT_BOUNDARY_WORD_END,  8, 12, "\nghi" },
 390     { -1, 14, ATK_TEXT_BOUNDARY_WORD_END,  8, 12, "\nghi" },
 391     { -1, 15, ATK_TEXT_BOUNDARY_WORD_END,  8, 12, "\nghi" },
 392     { -1, 16, ATK_TEXT_BOUNDARY_WORD_END, 12, 16, " jkl" },
 393     { -1, 17, ATK_TEXT_BOUNDARY_WORD_END, 12, 16, " jkl" },
 394     { -1, 18, ATK_TEXT_BOUNDARY_WORD_END, 12, 16, " jkl" },
 395     { -1, 19, ATK_TEXT_BOUNDARY_WORD_END, 12, 16, " jkl" },
 396     { -1, 20, ATK_TEXT_BOUNDARY_WORD_END, 16, 20, "\nmno" },
 397     { -1,  0, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  0, "" },
 398     { -1,  1, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  0, "" },
 399     { -1,  2, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  0, "" },
 400     { -1,  3, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  0, "" },
 401     { -1,  4, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  0, "" },
 402     { -1,  5, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  5, "abc! " },
 403     { -1,  6, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  5, "abc! " },
 404     { -1,  7, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  5, "abc! " },
 405     { -1,  8, ATK_TEXT_BOUNDARY_SENTENCE_START,  0,  5, "abc! " },
 406     { -1,  9, ATK_TEXT_BOUNDARY_SENTENCE_START,  5,  9, "def\n" },
 407     { -1, 10, ATK_TEXT_BOUNDARY_SENTENCE_START,  5,  9, "def\n" },
 408     { -1, 11, ATK_TEXT_BOUNDARY_SENTENCE_START,  5,  9, "def\n" },
 409     { -1, 12, ATK_TEXT_BOUNDARY_SENTENCE_START,  5,  9, "def\n" },
 410     { -1, 13, ATK_TEXT_BOUNDARY_SENTENCE_START,  5,  9, "def\n" },
 411     { -1, 14, ATK_TEXT_BOUNDARY_SENTENCE_START,  5,  9, "def\n" },
 412     { -1, 15, ATK_TEXT_BOUNDARY_SENTENCE_START,  5,  9, "def\n" },
 413     { -1, 16, ATK_TEXT_BOUNDARY_SENTENCE_START,  5,  9, "def\n" },
 414     { -1, 17, ATK_TEXT_BOUNDARY_SENTENCE_START,  9, 17, "ghi jkl\n" },
 415     { -1, 18, ATK_TEXT_BOUNDARY_SENTENCE_START,  9, 17, "ghi jkl\n" },
 416     { -1, 19, ATK_TEXT_BOUNDARY_SENTENCE_START,  9, 17, "ghi jkl\n" },
 417     { -1, 20, ATK_TEXT_BOUNDARY_SENTENCE_START,  9, 17, "ghi jkl\n" },
 418     { -1,  0, ATK_TEXT_BOUNDARY_SENTENCE_END,  0,  0, "" },
 419     { -1,  1, ATK_TEXT_BOUNDARY_SENTENCE_END,  0,  0, "" },
 420     { -1,  2, ATK_TEXT_BOUNDARY_SENTENCE_END,  0,  0, "" },
 421     { -1,  3, ATK_TEXT_BOUNDARY_SENTENCE_END,  0,  0, "" },
 422     { -1,  4, ATK_TEXT_BOUNDARY_SENTENCE_END,  0,  4, "abc!" },
 423     { -1,  5, ATK_TEXT_BOUNDARY_SENTENCE_END,  0,  4, "abc!" },
 424     { -1,  6, ATK_TEXT_BOUNDARY_SENTENCE_END,  0,  4, "abc!" },
 425     { -1,  7, ATK_TEXT_BOUNDARY_SENTENCE_END,  0,  4, "abc!" },
 426     { -1,  8, ATK_TEXT_BOUNDARY_SENTENCE_END,  4,  8, " def" },
 427     { -1,  9, ATK_TEXT_BOUNDARY_SENTENCE_END,  4,  8, " def" },
 428     { -1, 10, ATK_TEXT_BOUNDARY_SENTENCE_END,  4,  8, " def" },
 429     { -1, 11, ATK_TEXT_BOUNDARY_SENTENCE_END,  4,  8, " def" },
 430     { -1, 12, ATK_TEXT_BOUNDARY_SENTENCE_END,  4,  8, " def" },
 431     { -1, 13, ATK_TEXT_BOUNDARY_SENTENCE_END,  4,  8, " def" },
 432     { -1, 14, ATK_TEXT_BOUNDARY_SENTENCE_END,  4,  8, " def" },
 433     { -1, 15, ATK_TEXT_BOUNDARY_SENTENCE_END,  4,  8, " def" },
 434     { -1, 16, ATK_TEXT_BOUNDARY_SENTENCE_END,  8, 16, "\nghi jkl" },
 435     { -1, 17, ATK_TEXT_BOUNDARY_SENTENCE_END,  8, 16, "\nghi jkl" },
 436     { -1, 18, ATK_TEXT_BOUNDARY_SENTENCE_END,  8, 16, "\nghi jkl" },
 437     { -1, 19, ATK_TEXT_BOUNDARY_SENTENCE_END,  8, 16, "\nghi jkl" },
 438     { -1, 20, ATK_TEXT_BOUNDARY_SENTENCE_END, 16, 20, "\nmno" },
 439     { -1,  0, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 440     { -1,  1, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 441     { -1,  2, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 442     { -1,  3, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 443     { -1,  4, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 444     { -1,  5, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 445     { -1,  6, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 446     { -1,  7, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 447     { -1,  8, ATK_TEXT_BOUNDARY_LINE_START,  0,  0, "" },
 448     { -1,  9, ATK_TEXT_BOUNDARY_LINE_START,  0,  9, "abc! def\n" },
 449     { -1, 10, ATK_TEXT_BOUNDARY_LINE_START,  0,  9, "abc! def\n" },
 450     { -1, 11, ATK_TEXT_BOUNDARY_LINE_START,  0,  9, "abc! def\n" },
 451     { -1, 12, ATK_TEXT_BOUNDARY_LINE_START,  0,  9, "abc! def\n" },
 452     { -1, 13, ATK_TEXT_BOUNDARY_LINE_START,  0,  9, "abc! def\n" },
 453     { -1, 14, ATK_TEXT_BOUNDARY_LINE_START,  0,  9, "abc! def\n" },
 454     { -1, 15, ATK_TEXT_BOUNDARY_LINE_START,  0,  9, "abc! def\n" },
 455     { -1, 16, ATK_TEXT_BOUNDARY_LINE_START,  0,  9, "abc! def\n" },
 456     { -1, 17, ATK_TEXT_BOUNDARY_LINE_START,  9, 17, "ghi jkl\n" },
 457     { -1, 18, ATK_TEXT_BOUNDARY_LINE_START,  9, 17, "ghi jkl\n" },
 458     { -1, 19, ATK_TEXT_BOUNDARY_LINE_START,  9, 17, "ghi jkl\n" },
 459     { -1, 20, ATK_TEXT_BOUNDARY_LINE_START,  9, 17, "ghi jkl\n" },
 460     { -1,  0, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 461     { -1,  1, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 462     { -1,  2, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 463     { -1,  3, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 464     { -1,  4, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 465     { -1,  5, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 466     { -1,  6, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 467     { -1,  7, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 468     { -1,  8, ATK_TEXT_BOUNDARY_LINE_END,  0,  0, "" },
 469     { -1,  9, ATK_TEXT_BOUNDARY_LINE_END,  0,  8, "abc! def" },
 470     { -1, 10, ATK_TEXT_BOUNDARY_LINE_END,  0,  8, "abc! def" },
 471     { -1, 11, ATK_TEXT_BOUNDARY_LINE_END,  0,  8, "abc! def" },
 472     { -1, 12, ATK_TEXT_BOUNDARY_LINE_END,  0,  8, "abc! def" },
 473     { -1, 13, ATK_TEXT_BOUNDARY_LINE_END,  0,  8, "abc! def" },
 474     { -1, 14, ATK_TEXT_BOUNDARY_LINE_END,  0,  8, "abc! def" },
 475     { -1, 15, ATK_TEXT_BOUNDARY_LINE_END,  0,  8, "abc! def" },
 476     { -1, 16, ATK_TEXT_BOUNDARY_LINE_END,  0,  8, "abc! def" },
 477     { -1, 17, ATK_TEXT_BOUNDARY_LINE_END,  8, 16, "\nghi jkl" },
 478     { -1, 18, ATK_TEXT_BOUNDARY_LINE_END,  8, 16, "\nghi jkl" },
 479     { -1, 19, ATK_TEXT_BOUNDARY_LINE_END,  8, 16, "\nghi jkl" },
 480     { -1, 20, ATK_TEXT_BOUNDARY_LINE_END,  8, 16, "\nghi jkl" },
 481     {  0, -1, }
 482   };
 483   gint start, end;
 484   gchar *word;
 485   gchar *last_word;
 486   gint offset;
 487   gint i, j, k;
 488   gint b;
 489
 490   atk_text = ATK_TEXT (gtk_widget_get_accessible (widget));
 491
 492   set_text (widget, text);
 493 #if 0
 494   if (GTK_IS_LABEL (widget))
 495     show_text_attributes (gtk_label_get_layout (GTK_LABEL (widget)));
 496   else if (GTK_IS_ENTRY (widget))
 497     show_text_attributes (gtk_entry_get_layout (GTK_ENTRY (widget)));
 498 #endif
 499
 500 #if 0
 501   for (i = -1; i < 2; i++)
 502     for (j = ATK_TEXT_BOUNDARY_CHAR; j <= ATK_TEXT_BOUNDARY_LINE_END; j++)
 503       for (k = 0; k <= strlen (text); k++)
 504         {
 505       switch (i)
 506         {
 507           case -1:
 508             word = atk_text_get_text_before_offset (atk_text, k, j, &start, &end);
 509             break;
 510           case 0:
 511             word = atk_text_get_text_at_offset (atk_text, k, j, &start, &end);
 512             break;
 513           case 1:
 514             word = atk_text_get_text_after_offset (atk_text, k, j, &start, &end);
 515             break;
 516           default:
 517             g_assert_not_reached ();
 518             break;
 519         }
 520        printf ("    { %2d, %2d, %s %2d, %2d, \"%s\" },\n", i, k, boundary(j), start, end, escape (word));
 521        g_free (word);
 522      }
 523 #endif
 524
 525   for (i = 0; expected[i].offset != -1; i++)
 526     {
 527       if (GTK_IS_ENTRY (widget))
 528         {
 529           /* GtkEntry sets single-paragraph mode on its pango layout */
 530           if (expected[i].boundary == ATK_TEXT_BOUNDARY_LINE_START ||
 531               expected[i].boundary == ATK_TEXT_BOUNDARY_LINE_END)
 532             continue;
 533         }
 534
 535       switch (expected[i].gravity)
 536         {
 537           case -1:
 538             word = atk_text_get_text_before_offset (atk_text,
 539                                                     expected[i].offset,
 540                                                     expected[i].boundary,
 541                                                     &start, &end);
 542             break;
 543           case 0:
 544             word = atk_text_get_text_at_offset (atk_text,
 545                                                 expected[i].offset,
 546                                                 expected[i].boundary,
 547                                                 &start, &end);
 548             break;
 549           case 1:
 550             word = atk_text_get_text_after_offset (atk_text,
 551                                                    expected[i].offset,
 552                                                    expected[i].boundary,
 553                                                    &start, &end);
 554             break;
 555           default:
 556             g_assert_not_reached ();
 557             break;
 558         }
 559
 560       g_assert_cmpstr (word, ==, expected[i].word);
 561       g_assert_cmpint (start, ==, expected[i].start);
 562       g_assert_cmpint (end, ==, expected[i].end);
 563       g_free (word);
 564     }
 565 }
 566
 567 static void
 568 select_region (GtkWidget *widget,
 569                gint       start,
 570                gint       end)
 571 {
 572   if (GTK_IS_EDITABLE (widget))
 573     gtk_editable_select_region (GTK_EDITABLE (widget), start, end);
 574   else if (GTK_IS_LABEL (widget))
 575     gtk_label_select_region (GTK_LABEL (widget), start, end);
 576 }
 577
 578 typedef struct {
 579   gint count;
 580   gint position;
 581   gint bound;
 582 } SelectionData;
 583
 584 static void
 585 caret_moved_cb (AtkText *text, gint position, SelectionData *data)
 586 {
 587   data->count++;
 588   data->position = position;
 589 }
 590
 591 static void
 592 selection_changed_cb (AtkText *text, SelectionData *data)
 593 {
 594   data->count++;
 595
 596   atk_text_get_selection (text, 0, &data->bound, &data->position);
 597 }
 598
 599 static void
 600 test_selection (GtkWidget *widget)
 601 {
 602   AtkText *atk_text;
 603   const gchar *text = "Bla bla";
 604   gint n;
 605   gchar *ret;
 606   gint start, end;
 607   SelectionData data1;
 608   SelectionData data2;
 609
 610   if (GTK_IS_LABEL (widget))
 611     gtk_label_set_selectable (GTK_LABEL (widget), TRUE);
 612
 613   atk_text = ATK_TEXT (gtk_widget_get_accessible (widget));
 614
 615   data1.count = 0;
 616   data2.count = 0;
 617   g_signal_connect (atk_text, "text_caret_moved",
 618                     G_CALLBACK (caret_moved_cb), &data1);
 619   g_signal_connect (atk_text, "text_selection_changed",
 620                     G_CALLBACK (selection_changed_cb), &data2);
 621
 622   set_text (widget, text);
 623
 624   n = atk_text_get_n_selections (atk_text);
 625   g_assert_cmpint (n, ==, 0);
 626
 627   g_assert_cmpint (data1.count, ==, 0);
 628   g_assert_cmpint (data2.count, ==, 0);
 629
 630   select_region (widget, 4, 7);
 631
 632   g_assert_cmpint (data1.count, ==, 1);
 633   g_assert_cmpint (data1.position, ==, 7);
 634   g_assert_cmpint (data2.count, >=, 1);
 635   g_assert_cmpint (data2.bound, ==, 4);
 636   g_assert_cmpint (data2.position, ==, 7);
 637
 638   n = atk_text_get_n_selections (atk_text);
 639   g_assert_cmpint (n, ==, 1);
 640
 641   ret = atk_text_get_selection (atk_text, 0, &start, &end);
 642   g_assert_cmpstr (ret, ==, "bla");
 643   g_assert_cmpint (start, ==, 4);
 644   g_assert_cmpint (end, ==, 7);
 645   g_free (ret);
 646
 647   atk_text_remove_selection (atk_text, 0);
 648   n = atk_text_get_n_selections (atk_text);
 649   g_assert_cmpint (n, ==, 0);
 650
 651   g_assert_cmpint (data1.count, ==, 1);
 652   g_assert_cmpint (data2.count, >=, 2);
 653   g_assert_cmpint (data2.position, ==, 7);
 654   g_assert_cmpint (data2.bound, ==, 7);
 655 }
 656
 657 static void
 658 setup_test (GtkWidget *widget)
 659 {
 660   set_text (widget, "");
 661 }
 662
 663 static void
 664 add_text_test (const gchar      *prefix,
 665                GTestFixtureFunc  test_func,
 666                GtkWidget        *widget)
 667 {
 668   gchar *path;
 669
 670   path = g_strdup_printf ("%s/%s", prefix, G_OBJECT_TYPE_NAME (widget));
 671   g_test_add_vtable (path,
 672                      0,
 673                      g_object_ref (widget),
 674                      (GTestFixtureFunc) setup_test,
 675                      (GTestFixtureFunc) test_func,
 676                      (GTestFixtureFunc) g_object_unref);
 677   g_free (path);
 678 }
 679
 680 static void
 681 add_text_tests (GtkWidget *widget)
 682 {
 683   g_object_ref_sink (widget);
 684   add_text_test ("/text/basic", (GTestFixtureFunc) test_basic, widget);
 685   add_text_test ("/text/words", (GTestFixtureFunc) test_words, widget);
 686   add_text_test ("/text/changed", (GTestFixtureFunc) test_text_changed, widget);
 687   add_text_test ("/text/selection", (GTestFixtureFunc) test_selection, widget);
 688   g_object_unref (widget);
 689 }
 690
 691 static void
 692 test_bold_label (void)
 693 {
 694   GtkWidget *label;
 695   AtkObject *atk_obj;
 696   gchar *text;
 697
 698   g_test_bug ("126797");
 699
 700   label = gtk_label_new ("<b>Bold?</b>");
 701   g_object_ref_sink (label);
 702
 703   atk_obj = gtk_widget_get_accessible (label);
 704
 705   text = atk_text_get_text (ATK_TEXT (atk_obj), 0, -1);
 706   g_assert_cmpstr (text, ==, "<b>Bold?</b>");
 707   g_free (text);
 708
 709   gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
 710
 711   text = atk_text_get_text (ATK_TEXT (atk_obj), 0, -1);
 712   g_assert_cmpstr (text, ==, "Bold?");
 713   g_free (text);
 714
 715   g_object_unref (label);
 716 }
 717
 718 int
 719 main (int argc, char *argv[])
 720 {
 721   gtk_test_init (&argc, &argv, NULL);
 722
 723   g_test_bug_base ("http://bugzilla.gnome.org/");
 724
 725   g_test_add_func ("/text/bold/GtkLabel", test_bold_label);
 726
 727   add_text_tests (gtk_label_new (""));
 728   add_text_tests (gtk_entry_new ());
 729   add_text_tests (gtk_text_view_new ());
 730
 731   return g_test_run ();
 732 }