Pileus Git - ~andy/gtk/blob - tests/testtextbuffer.c

   1 /* Simplistic test suite */
   2
   3 #include <stdio.h>
   4
   5 #include <gtk/gtk.h>
   6 #include "gtktextbtree.h"
   7
   8 static void fill_buffer (GtkTextBuffer *buffer);
   9
  10 static void run_tests (GtkTextBuffer *buffer);
  11
  12 int
  13 main (int argc, char** argv)
  14 {
  15   GtkTextBuffer *buffer;
  16   int n;
  17   gunichar ch;
  18   GtkTextIter start, end;
  19
  20   gtk_init (&argc, &argv);
  21
  22   /* Check UTF8 unknown char thing */
  23   g_assert (g_utf8_strlen (gtk_text_unknown_char_utf8, 3) == 1);
  24   ch = g_utf8_get_char (gtk_text_unknown_char_utf8);
  25   g_assert (ch == gtk_text_unknown_char);
  26
  27   /* First, we turn on btree debugging. */
  28   gtk_debug_flags |= GTK_DEBUG_TEXT;
  29
  30   /* Create a buffer */
  31   buffer = gtk_text_buffer_new (NULL);
  32
  33   /* Check that buffer starts with one empty line and zero chars */
  34
  35   n = gtk_text_buffer_get_line_count (buffer);
  36   if (n != 1)
  37     g_error ("%d lines, expected 1", n);
  38
  39   n = gtk_text_buffer_get_char_count (buffer);
  40   if (n != 1)
  41     g_error ("%d chars, expected 1", n);
  42
  43   /* Run gruesome alien test suite on buffer */
  44   run_tests (buffer);
  45
  46   /* Put stuff in the buffer */
  47
  48   fill_buffer (buffer);
  49
  50   /* Subject stuff-bloated buffer to further torment */
  51   run_tests (buffer);
  52
  53   /* Delete all stuff from the buffer */
  54   gtk_text_buffer_get_bounds (buffer, &start, &end);
  55   gtk_text_buffer_delete (buffer, &start, &end);
  56
  57   /* Check buffer for emptiness (note that a single
  58      empty line always remains in the buffer) */
  59   n = gtk_text_buffer_get_line_count (buffer);
  60   if (n != 1)
  61     g_error ("%d lines, expected 1", n);
  62
  63   n = gtk_text_buffer_get_char_count (buffer);
  64   if (n != 1)
  65     g_error ("%d chars, expected 1", n);
  66
  67   run_tests (buffer);
  68
  69   g_print ("All tests passed.\n");
  70
  71   return 0;
  72 }
  73
  74 static void
  75 run_tests (GtkTextBuffer *buffer)
  76 {
  77   GtkTextIter iter;
  78   GtkTextIter start;
  79   GtkTextIter end;
  80   GtkTextIter mark;
  81   gint i, j;
  82   gint num_chars;
  83   GtkTextMark *bar_mark;
  84
  85   gtk_text_buffer_get_bounds (buffer, &start, &end);
  86
  87   /* Check that walking the tree via chars and via iterators produces
  88    * the same number of indexable locations.
  89    */
  90   num_chars = gtk_text_buffer_get_char_count (buffer);
  91   iter = start;
  92   bar_mark = gtk_text_buffer_create_mark (buffer, "bar", &iter, FALSE);
  93   i = 0;
  94   while (i < num_chars)
  95     {
  96       GtkTextIter current;
  97       GtkTextMark *foo_mark;
  98
  99       gtk_text_buffer_get_iter_at_offset (buffer, &current, i);
 100
 101       if (!gtk_text_iter_equal (&iter, &current))
 102         {
 103           g_error ("get_char_index didn't return current iter");
 104         }
 105
 106       j = gtk_text_iter_get_offset (&iter);
 107
 108       if (i != j)
 109         {
 110           g_error ("iter converted to %d not %d", j, i);
 111         }
 112
 113       /* get/set mark */
 114       gtk_text_buffer_get_iter_at_mark (buffer, &mark, bar_mark);
 115
 116       if (!gtk_text_iter_equal (&iter, &mark))
 117         {
 118           gtk_text_iter_spew (&iter, "iter");
 119           gtk_text_iter_spew (&mark, "mark");
 120           g_error ("Mark not moved to the right place.");
 121         }
 122
 123       foo_mark = gtk_text_buffer_create_mark (buffer, "foo", &iter, FALSE);
 124       gtk_text_buffer_get_iter_at_mark (buffer, &mark, foo_mark);
 125       gtk_text_buffer_delete_mark (buffer, foo_mark);
 126
 127       if (!gtk_text_iter_equal (&iter, &mark))
 128         {
 129           gtk_text_iter_spew (&iter, "iter");
 130           gtk_text_iter_spew (&mark, "mark");
 131           g_error ("Mark not created in the right place.");
 132         }
 133
 134       if (gtk_text_iter_is_last (&iter))
 135         g_error ("iterators ran out before chars (offset %d of %d)",
 136                  i, num_chars);
 137
 138       gtk_text_iter_next_char (&iter);
 139
 140       gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
 141
 142       ++i;
 143     }
 144
 145   if (!gtk_text_iter_equal (&iter, &end))
 146     g_error ("Iterating over all chars didn't end with the end iter");
 147
 148   /* Do the tree-walk backward
 149    */
 150   num_chars = gtk_text_buffer_get_char_count (buffer);
 151   gtk_text_buffer_get_iter_at_offset (buffer, &iter, -1);
 152
 153   gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
 154
 155   i = num_chars;
 156
 157   if (!gtk_text_iter_equal (&iter, &end))
 158     g_error ("iter at char -1 is not equal to the end iterator");
 159
 160   while (i >= 0)
 161     {
 162       GtkTextIter current;
 163       GtkTextMark *foo_mark;
 164
 165       gtk_text_buffer_get_iter_at_offset (buffer, &current, i);
 166
 167       if (!gtk_text_iter_equal (&iter, &current))
 168         {
 169           g_error ("get_char_index didn't return current iter while going backward");
 170         }
 171       j = gtk_text_iter_get_offset (&iter);
 172
 173       if (i != j)
 174         {
 175           g_error ("going backward, iter converted to %d not %d", j, i);
 176         }
 177
 178       /* get/set mark */
 179       gtk_text_buffer_get_iter_at_mark (buffer, &mark, bar_mark);
 180
 181       if (!gtk_text_iter_equal (&iter, &mark))
 182         {
 183           gtk_text_iter_spew (&iter, "iter");
 184           gtk_text_iter_spew (&mark, "mark");
 185           g_error ("Mark not moved to the right place.");
 186         }
 187
 188       foo_mark = gtk_text_buffer_create_mark (buffer, "foo", &iter, FALSE);
 189       gtk_text_buffer_get_iter_at_mark (buffer, &mark, foo_mark);
 190       gtk_text_buffer_delete_mark (buffer, foo_mark);
 191
 192       if (!gtk_text_iter_equal (&iter, &mark))
 193         {
 194           gtk_text_iter_spew (&iter, "iter");
 195           gtk_text_iter_spew (&mark, "mark");
 196           g_error ("Mark not created in the right place.");
 197         }
 198
 199       if (i > 0)
 200         {
 201           if (!gtk_text_iter_prev_char (&iter))
 202             g_error ("iterators ran out before char indexes");
 203
 204           gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
 205         }
 206       else
 207         {
 208           if (gtk_text_iter_prev_char (&iter))
 209             g_error ("went backward from 0?");
 210         }
 211
 212       --i;
 213     }
 214
 215   if (!gtk_text_iter_equal (&iter, &start))
 216     g_error ("Iterating backward over all chars didn't end with the start iter");
 217
 218   /*
 219    * Check that get_line_count returns the same number of lines
 220    * as walking the tree by line
 221    */
 222   i = 1; /* include current (first) line */
 223   gtk_text_buffer_get_iter_at_line (buffer, &iter, 0);
 224   while (gtk_text_iter_forward_line (&iter))
 225     ++i;
 226
 227   if (i != gtk_text_buffer_get_line_count (buffer))
 228     g_error ("Counted %d lines, buffer has %d", i,
 229              gtk_text_buffer_get_line_count (buffer));
 230 }
 231
 232
 233 static char  *book_closed_xpm[] = {
 234 "16 16 6 1",
 235 "       c None s None",
 236 ".      c black",
 237 "X      c red",
 238 "o      c yellow",
 239 "O      c #808080",
 240 "#      c white",
 241 "                ",
 242 "       ..       ",
 243 "     ..XX.      ",
 244 "   ..XXXXX.     ",
 245 " ..XXXXXXXX.    ",
 246 ".ooXXXXXXXXX.   ",
 247 "..ooXXXXXXXXX.  ",
 248 ".X.ooXXXXXXXXX. ",
 249 ".XX.ooXXXXXX..  ",
 250 " .XX.ooXXX..#O  ",
 251 "  .XX.oo..##OO. ",
 252 "   .XX..##OO..  ",
 253 "    .X.#OO..    ",
 254 "     ..O..      ",
 255 "      ..        ",
 256 "                "};
 257
 258 static void
 259 fill_buffer (GtkTextBuffer *buffer)
 260 {
 261   GtkTextTag *tag;
 262   GdkColor color, color2;
 263   GtkTextIter iter;
 264   GtkTextIter iter2;
 265   GdkPixbuf *pixbuf;
 266   int i;
 267
 268   tag = gtk_text_buffer_create_tag (buffer, "fg_blue");
 269
 270   color.red = color.green = 0;
 271   color.blue = 0xffff;
 272   color2.red = 0xfff;
 273   color2.blue = 0x0;
 274   color2.green = 0;
 275   gtk_object_set (GTK_OBJECT (tag),
 276                  "foreground_gdk", &color,
 277                  "background_gdk", &color2,
 278                  "font", "-*-courier-bold-r-*-*-30-*-*-*-*-*-*-*",
 279                  NULL);
 280
 281   tag = gtk_text_buffer_create_tag (buffer, "fg_red");
 282
 283   color.blue = color.green = 0;
 284   color.red = 0xffff;
 285   gtk_object_set (GTK_OBJECT (tag),
 286                  "offset", -4,
 287                  "foreground_gdk", &color,
 288                  NULL);
 289
 290   tag = gtk_text_buffer_create_tag (buffer, "bg_green");
 291
 292   color.blue = color.red = 0;
 293   color.green = 0xffff;
 294   gtk_object_set (GTK_OBJECT (tag),
 295                  "background_gdk", &color,
 296                  "font", "-*-courier-bold-r-*-*-10-*-*-*-*-*-*-*",
 297                  NULL);
 298
 299   pixbuf = gdk_pixbuf_new_from_xpm_data (book_closed_xpm);
 300
 301   g_assert (pixbuf != NULL);
 302
 303   i = 0;
 304   while (i < 10)
 305     {
 306       gchar *str;
 307
 308       gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
 309
 310       gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
 311
 312       gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
 313
 314       gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
 315
 316       str = g_strdup_printf ("%d Hello World!\nwoo woo woo woo woo woo woo woo\n",
 317                             i);
 318
 319       gtk_text_buffer_insert (buffer, &iter, str, -1);
 320
 321       g_free (str);
 322
 323       gtk_text_buffer_insert (buffer, &iter,
 324                               "(Hello World!)\nfoo foo Hello this is some text we are using to text word wrap. It has punctuation! gee; blah - hmm, great.\nnew line\n\n"
 325                               /* This is UTF8 stuff, Emacs doesn't
 326                                  really know how to display it */
 327                               "Spanish (Español) ¡Hola! / French (Français) Bonjour, Salut / German (Deutsch Süd) Grüß Gott (testing Latin-1 chars encoded in UTF8)\nThai (we can't display this, just making sure we don't crash)  (ภาษาไทย)  สวัสดีครับ, สวัสดีค่ะ\n",
 328                               -1);
 329
 330       gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
 331       gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
 332
 333       gtk_text_buffer_get_iter_at_offset (buffer, &iter, 4);
 334
 335       gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
 336
 337       gtk_text_buffer_get_iter_at_offset (buffer, &iter, 7);
 338
 339       gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
 340
 341       gtk_text_buffer_get_iter_at_offset (buffer, &iter, 8);
 342
 343       gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
 344
 345       gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 8);
 346       iter2 = iter;
 347       gtk_text_iter_forward_chars (&iter2, 10);
 348
 349       gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
 350
 351       gtk_text_iter_forward_chars (&iter, 7);
 352       gtk_text_iter_forward_chars (&iter2, 10);
 353
 354       gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);
 355
 356       gtk_text_iter_forward_chars (&iter, 12);
 357       gtk_text_iter_forward_chars (&iter2, 10);
 358
 359       gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);
 360
 361       gtk_text_iter_forward_chars (&iter, 10);
 362       gtk_text_iter_forward_chars (&iter2, 15);
 363
 364       gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
 365       gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
 366
 367       gtk_text_iter_forward_chars (&iter, 20);
 368       gtk_text_iter_forward_chars (&iter2, 20);
 369
 370       gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
 371       gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
 372
 373       gtk_text_iter_backward_chars (&iter, 25);
 374       gtk_text_iter_forward_chars (&iter2, 5);
 375
 376       gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
 377       gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
 378
 379       gtk_text_iter_forward_chars (&iter, 15);
 380       gtk_text_iter_backward_chars (&iter2, 10);
 381
 382       gtk_text_buffer_remove_tag_by_name (buffer, "fg_red", &iter, &iter2);
 383       gtk_text_buffer_remove_tag_by_name (buffer, "fg_blue", &iter, &iter2);
 384
 385       ++i;
 386     }
 387
 388   gdk_pixbuf_unref (pixbuf);
 389 }