Debian Codegraph @

testsuite/gtk/textbuffer.c

raw
1 /* testtextbuffer.c -- Simplistic test suite
2 * Copyright (C) 2000 Red Hat, Inc
3 * Author: Havoc Pennington
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 #include "config.h"
20 #include <stdio.h>
21 #include <string.h>
22
23 #include <gtk/gtk.h>
24 #include "gtk/gtktexttypes.h" /* Private header, for UNKNOWN_CHAR */
25
26 static void
27 gtk_text_iter_spew (const GtkTextIter *iter, const gchar *desc)
28 {
29 g_print (" %20s: line %d / char %d / line char %d / line byte %d\n",
30 desc,
31 gtk_text_iter_get_line (iter),
32 gtk_text_iter_get_offset (iter),
33 gtk_text_iter_get_line_offset (iter),
34 gtk_text_iter_get_line_index (iter));
35 }
36
37 static void
38 check_get_set_text (GtkTextBuffer *buffer,
39 const char *str)
40 {
41 GtkTextIter start, end, iter;
42 char *text;
43 int n;
44
45 gtk_text_buffer_set_text (buffer, str, -1);
46 if (gtk_text_buffer_get_char_count (buffer) != g_utf8_strlen (str, -1))
47 g_error ("Wrong number of chars (%d not %d)",
48 gtk_text_buffer_get_char_count (buffer),
49 (int) g_utf8_strlen (str, -1));
50 gtk_text_buffer_get_bounds (buffer, &start, &end);
51 text = gtk_text_buffer_get_text (buffer, &start, &end, TRUE);
52 if (strcmp (text, str) != 0)
53 g_error ("Got '%s' as buffer contents", text);
54 g_free (text);
55
56 /* line char counts */
57 iter = start;
58 n = 0;
59 do
60 {
61 n += gtk_text_iter_get_chars_in_line (&iter);
62 }
63 while (gtk_text_iter_forward_line (&iter));
64
65 if (n != gtk_text_buffer_get_char_count (buffer))
66 g_error ("Sum of chars in lines is %d but buffer char count is %d",
67 n, gtk_text_buffer_get_char_count (buffer));
68
69 /* line byte counts */
70 iter = start;
71 n = 0;
72 do
73 {
74 n += gtk_text_iter_get_bytes_in_line (&iter);
75 }
76 while (gtk_text_iter_forward_line (&iter));
77
78 if (n != strlen (str))
79 g_error ("Sum of chars in lines is %d but buffer byte count is %d",
80 n, (int) strlen (str));
81
82 gtk_text_buffer_set_text (buffer, "", -1);
83
84 n = gtk_text_buffer_get_line_count (buffer);
85 if (n != 1)
86 g_error ("%d lines, expected 1", n);
87
88 n = gtk_text_buffer_get_char_count (buffer);
89 if (n != 0)
90 g_error ("%d chars, expected 0", n);
91 }
92
93 static gint
94 count_toggles_at_iter (GtkTextIter *iter,
95 GtkTextTag *of_tag)
96 {
97 GSList *tags;
98 GSList *tmp;
99 gint count = 0;
100
101 /* get toggle-ons and toggle-offs */
102 tags = gtk_text_iter_get_toggled_tags (iter, TRUE);
103 tags = g_slist_concat (tags,
104 gtk_text_iter_get_toggled_tags (iter, FALSE));
105
106 tmp = tags;
107 while (tmp != NULL)
108 {
109 if (of_tag == NULL)
110 ++count;
111 else if (of_tag == tmp->data)
112 ++count;
113
114 tmp = tmp->next;
115 }
116
117 g_slist_free (tags);
118
119 return count;
120 }
121
122 static gint
123 count_toggles_in_range_by_char (GtkTextBuffer *buffer,
124 GtkTextTag *of_tag,
125 const GtkTextIter *start,
126 const GtkTextIter *end)
127 {
128 GtkTextIter iter;
129 gint count = 0;
130
131 iter = *start;
132 do
133 {
134 count += count_toggles_at_iter (&iter, of_tag);
135 if (!gtk_text_iter_forward_char (&iter))
136 {
137 /* end iterator */
138 count += count_toggles_at_iter (&iter, of_tag);
139 break;
140 }
141 }
142 while (gtk_text_iter_compare (&iter, end) <= 0);
143
144 return count;
145 }
146
147 static gint
148 count_toggles_in_buffer (GtkTextBuffer *buffer,
149 GtkTextTag *of_tag)
150 {
151 GtkTextIter start, end;
152
153 gtk_text_buffer_get_bounds (buffer, &start, &end);
154
155 return count_toggles_in_range_by_char (buffer, of_tag, &start, &end);
156 }
157
158 static void
159 check_specific_tag_in_range (GtkTextBuffer *buffer,
160 const gchar *tag_name,
161 const GtkTextIter *start,
162 const GtkTextIter *end)
163 {
164 GtkTextIter iter;
165 GtkTextTag *tag;
166 gboolean state;
167 gint count;
168 gint buffer_count;
169 gint last_offset;
170
171 if (gtk_text_iter_compare (start, end) > 0)
172 {
173 g_print (" (inverted range for checking tags, skipping)\n");
174 return;
175 }
176
177 tag = gtk_text_tag_table_lookup (gtk_text_buffer_get_tag_table (buffer),
178 tag_name);
179
180 buffer_count = count_toggles_in_range_by_char (buffer, tag, start, end);
181
182 state = FALSE;
183 count = 0;
184
185 last_offset = -1;
186 iter = *start;
187 if (gtk_text_iter_toggles_tag (&iter, tag) ||
188 gtk_text_iter_forward_to_tag_toggle (&iter, tag))
189 {
190 do
191 {
192 gint this_offset;
193
194 ++count;
195
196 this_offset = gtk_text_iter_get_offset (&iter);
197
198 if (this_offset <= last_offset)
199 g_error ("forward_to_tag_toggle moved in wrong direction");
200
201 last_offset = this_offset;
202
203 if (gtk_text_iter_starts_tag (&iter, tag))
204 {
205 if (state)
206 g_error ("Tag %p is already on, and was toggled on?", tag);
207 state = TRUE;
208 }
209 else if (gtk_text_iter_ends_tag (&iter, tag))
210 {
211 if (!state)
212 g_error ("Tag %p toggled off, but wasn't toggled on?", tag);
213 state = FALSE;
214 }
215 else
216 g_error ("forward_to_tag_toggle went to a location without a toggle");
217 }
218 while (gtk_text_iter_forward_to_tag_toggle (&iter, tag) &&
219 gtk_text_iter_compare (&iter, end) <= 0);
220 }
221
222 if (count != buffer_count)
223 g_error ("Counted %d tags iterating by char, %d iterating forward by tag toggle",
224 buffer_count, count);
225
226 state = FALSE;
227 count = 0;
228
229 iter = *end;
230 last_offset = gtk_text_iter_get_offset (&iter);
231 if (gtk_text_iter_toggles_tag (&iter, tag) ||
232 gtk_text_iter_backward_to_tag_toggle (&iter, tag))
233 {
234 do
235 {
236 gint this_offset;
237
238 ++count;
239
240 this_offset = gtk_text_iter_get_offset (&iter);
241
242 if (this_offset >= last_offset)
243 g_error ("backward_to_tag_toggle moved in wrong direction");
244
245 last_offset = this_offset;
246
247 if (gtk_text_iter_starts_tag (&iter, tag))
248 {
249 if (!state)
250 g_error ("Tag %p wasn't on when we got to the on toggle going backward?", tag);
251 state = FALSE;
252 }
253 else if (gtk_text_iter_ends_tag (&iter, tag))
254 {
255 if (state)
256 g_error ("Tag %p off toggle, but we were already inside a tag?", tag);
257 state = TRUE;
258 }
259 else
260 g_error ("backward_to_tag_toggle went to a location without a toggle");
261 }
262 while (gtk_text_iter_backward_to_tag_toggle (&iter, tag) &&
263 gtk_text_iter_compare (&iter, start) >= 0);
264 }
265
266 if (count != buffer_count)
267 g_error ("Counted %d tags iterating by char, %d iterating backward by tag toggle\n",
268 buffer_count, count);
269 }
270
271 static void
272 check_specific_tag (GtkTextBuffer *buffer,
273 const gchar *tag_name)
274 {
275 GtkTextIter start, end;
276
277 gtk_text_buffer_get_bounds (buffer, &start, &end);
278 check_specific_tag_in_range (buffer, tag_name, &start, &end);
279 gtk_text_iter_forward_chars (&start, 2);
280 gtk_text_iter_backward_chars (&end, 2);
281 if (gtk_text_iter_compare (&start, &end) < 0)
282 check_specific_tag_in_range (buffer, tag_name, &start, &end);
283 }
284
285 static void
286 run_tests (GtkTextBuffer *buffer)
287 {
288 GtkTextIter iter;
289 GtkTextIter start;
290 GtkTextIter end;
291 GtkTextIter mark;
292 gint i, j;
293 gint num_chars;
294 GtkTextMark *bar_mark;
295 GtkTextTag *tag;
296 GHashTable *tag_states;
297 gint count;
298 gint buffer_count;
299
300 gtk_text_buffer_get_bounds (buffer, &start, &end);
301
302 /* Check that walking the tree via chars and via iterators produces
303 * the same number of indexable locations.
304 */
305 num_chars = gtk_text_buffer_get_char_count (buffer);
306 iter = start;
307 bar_mark = gtk_text_buffer_create_mark (buffer, "bar", &iter, FALSE);
308 i = 0;
309 while (i < num_chars)
310 {
311 GtkTextIter current;
312 GtkTextMark *foo_mark;
313
314 gtk_text_buffer_get_iter_at_offset (buffer, &current, i);
315
316 if (!gtk_text_iter_equal (&iter, &current))
317 {
318 g_error ("get_char_index didn't return current iter");
319 }
320
321 j = gtk_text_iter_get_offset (&iter);
322
323 if (i != j)
324 {
325 g_error ("iter converted to %d not %d", j, i);
326 }
327
328 /* get/set mark */
329 gtk_text_buffer_get_iter_at_mark (buffer, &mark, bar_mark);
330
331 if (!gtk_text_iter_equal (&iter, &mark))
332 {
333 gtk_text_iter_spew (&iter, "iter");
334 gtk_text_iter_spew (&mark, "mark");
335 g_error ("Mark not moved to the right place.");
336 }
337
338 foo_mark = gtk_text_buffer_create_mark (buffer, "foo", &iter, FALSE);
339 gtk_text_buffer_get_iter_at_mark (buffer, &mark, foo_mark);
340 gtk_text_buffer_delete_mark (buffer, foo_mark);
341
342 if (!gtk_text_iter_equal (&iter, &mark))
343 {
344 gtk_text_iter_spew (&iter, "iter");
345 gtk_text_iter_spew (&mark, "mark");
346 g_error ("Mark not created in the right place.");
347 }
348
349 if (gtk_text_iter_is_end (&iter))
350 g_error ("iterators ran out before chars (offset %d of %d)",
351 i, num_chars);
352
353 gtk_text_iter_forward_char (&iter);
354
355 gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
356
357 ++i;
358 }
359
360 if (!gtk_text_iter_equal (&iter, &end))
361 g_error ("Iterating over all chars didn't end with the end iter");
362
363 /* Do the tree-walk backward
364 */
365 num_chars = gtk_text_buffer_get_char_count (buffer);
366 gtk_text_buffer_get_iter_at_offset (buffer, &iter, -1);
367
368 gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
369
370 i = num_chars;
371
372 if (!gtk_text_iter_equal (&iter, &end))
373 g_error ("iter at char -1 is not equal to the end iterator");
374
375 while (i >= 0)
376 {
377 GtkTextIter current;
378 GtkTextMark *foo_mark;
379
380 gtk_text_buffer_get_iter_at_offset (buffer, &current, i);
381
382 if (!gtk_text_iter_equal (&iter, &current))
383 {
384 g_error ("get_char_index didn't return current iter while going backward");
385 }
386 j = gtk_text_iter_get_offset (&iter);
387
388 if (i != j)
389 {
390 g_error ("going backward, iter converted to %d not %d", j, i);
391 }
392
393 /* get/set mark */
394 gtk_text_buffer_get_iter_at_mark (buffer, &mark, bar_mark);
395
396 if (!gtk_text_iter_equal (&iter, &mark))
397 {
398 gtk_text_iter_spew (&iter, "iter");
399 gtk_text_iter_spew (&mark, "mark");
400 g_error ("Mark not moved to the right place.");
401 }
402
403 foo_mark = gtk_text_buffer_create_mark (buffer, "foo", &iter, FALSE);
404 gtk_text_buffer_get_iter_at_mark (buffer, &mark, foo_mark);
405 gtk_text_buffer_delete_mark (buffer, foo_mark);
406
407 if (!gtk_text_iter_equal (&iter, &mark))
408 {
409 gtk_text_iter_spew (&iter, "iter");
410 gtk_text_iter_spew (&mark, "mark");
411 g_error ("Mark not created in the right place.");
412 }
413
414 if (i > 0)
415 {
416 if (!gtk_text_iter_backward_char (&iter))
417 g_error ("iterators ran out before char indexes");
418
419 gtk_text_buffer_move_mark (buffer, bar_mark, &iter);
420 }
421 else
422 {
423 if (gtk_text_iter_backward_char (&iter))
424 g_error ("went backward from 0?");
425 }
426
427 --i;
428 }
429
430 if (!gtk_text_iter_equal (&iter, &start))
431 g_error ("Iterating backward over all chars didn't end with the start iter");
432
433 /*
434 * Check that get_line_count returns the same number of lines
435 * as walking the tree by line
436 */
437 i = 1; /* include current (first) line */
438 gtk_text_buffer_get_iter_at_line (buffer, &iter, 0);
439 while (gtk_text_iter_forward_line (&iter))
440 ++i;
441
442 if (i != gtk_text_buffer_get_line_count (buffer))
443 g_error ("Counted %d lines, buffer has %d", i,
444 gtk_text_buffer_get_line_count (buffer));
445
446 /*
447 * Check that moving over tag toggles thinks about working.
448 */
449
450 buffer_count = count_toggles_in_buffer (buffer, NULL);
451
452 tag_states = g_hash_table_new (NULL, NULL);
453 count = 0;
454
455 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
456 if (gtk_text_iter_toggles_tag (&iter, NULL) ||
457 gtk_text_iter_forward_to_tag_toggle (&iter, NULL))
458 {
459 do
460 {
461 GSList *tags;
462 GSList *tmp;
463 gboolean found_some = FALSE;
464
465 /* get toggled-on tags */
466 tags = gtk_text_iter_get_toggled_tags (&iter, TRUE);
467
468 if (tags)
469 found_some = TRUE;
470
471 tmp = tags;
472 while (tmp != NULL)
473 {
474 ++count;
475
476 tag = tmp->data;
477
478 if (g_hash_table_lookup (tag_states, tag))
479 g_error ("Tag %p is already on, and was toggled on?", tag);
480
481 g_hash_table_insert (tag_states, tag, GINT_TO_POINTER (TRUE));
482
483 tmp = tmp->next;
484 }
485
486 g_slist_free (tags);
487
488 /* get toggled-off tags */
489 tags = gtk_text_iter_get_toggled_tags (&iter, FALSE);
490
491 if (tags)
492 found_some = TRUE;
493
494 tmp = tags;
495 while (tmp != NULL)
496 {
497 ++count;
498
499 tag = tmp->data;
500
501 if (!g_hash_table_lookup (tag_states, tag))
502 g_error ("Tag %p is already off, and was toggled off?", tag);
503
504 g_hash_table_remove (tag_states, tag);
505
506 tmp = tmp->next;
507 }
508
509 g_slist_free (tags);
510
511 if (!found_some)
512 g_error ("No tags found going forward to tag toggle.");
513
514 }
515 while (gtk_text_iter_forward_to_tag_toggle (&iter, NULL));
516 }
517
518 g_hash_table_destroy (tag_states);
519
520 if (count != buffer_count)
521 g_error ("Counted %d tags iterating by char, %d iterating by tag toggle\n",
522 buffer_count, count);
523
524 /* Go backward; here TRUE in the hash means we saw
525 * an off toggle last.
526 */
527
528 tag_states = g_hash_table_new (NULL, NULL);
529 count = 0;
530
531 gtk_text_buffer_get_end_iter (buffer, &iter);
532 if (gtk_text_iter_toggles_tag (&iter, NULL) ||
533 gtk_text_iter_backward_to_tag_toggle (&iter, NULL))
534 {
535 do
536 {
537 GSList *tags;
538 GSList *tmp;
539 gboolean found_some = FALSE;
540
541 /* get toggled-off tags */
542 tags = gtk_text_iter_get_toggled_tags (&iter, FALSE);
543
544 if (tags)
545 found_some = TRUE;
546
547 tmp = tags;
548 while (tmp != NULL)
549 {
550 ++count;
551
552 tag = tmp->data;
553
554 if (g_hash_table_lookup (tag_states, tag))
555 g_error ("Tag %p has two off-toggles in a row?", tag);
556
557 g_hash_table_insert (tag_states, tag, GINT_TO_POINTER (TRUE));
558
559 tmp = tmp->next;
560 }
561
562 g_slist_free (tags);
563
564 /* get toggled-on tags */
565 tags = gtk_text_iter_get_toggled_tags (&iter, TRUE);
566
567 if (tags)
568 found_some = TRUE;
569
570 tmp = tags;
571 while (tmp != NULL)
572 {
573 ++count;
574
575 tag = tmp->data;
576
577 if (!g_hash_table_lookup (tag_states, tag))
578 g_error ("Tag %p was toggled on, but saw no off-toggle?", tag);
579
580 g_hash_table_remove (tag_states, tag);
581
582 tmp = tmp->next;
583 }
584
585 g_slist_free (tags);
586
587 if (!found_some)
588 g_error ("No tags found going backward to tag toggle.");
589 }
590 while (gtk_text_iter_backward_to_tag_toggle (&iter, NULL));
591 }
592
593 g_hash_table_destroy (tag_states);
594
595 if (count != buffer_count)
596 g_error ("Counted %d tags iterating by char, %d iterating by tag toggle",
597 buffer_count, count);
598
599 check_specific_tag (buffer, "fg_red");
600 check_specific_tag (buffer, "bg_green");
601 check_specific_tag (buffer, "front_tag");
602 check_specific_tag (buffer, "center_tag");
603 check_specific_tag (buffer, "end_tag");
604 }
605
606 static void
607 fill_buffer (GtkTextBuffer *buffer)
608 {
609 GtkTextTag *tag;
610 GdkRGBA color;
611 GdkRGBA color2;
612 GtkTextIter iter;
613 GtkTextIter iter2;
614 GdkPixbuf *pixbuf;
615 int i;
616
617 color.red = 0.0;
618 color.green = 0.0;
619 color.blue = 1.0;
620 color.alpha = 1.0;
621
622 color2.red = 1.0;
623 color2.green = 0.0;
624 color2.blue = 0.0;
625 color2.alpha = 1.0;
626
627 gtk_text_buffer_create_tag (buffer, "fg_blue",
628 "foreground_rgba", &color,
629 "background_rgba", &color2,
630 "font", "-*-courier-bold-r-*-*-30-*-*-*-*-*-*-*",
631 NULL);
632
633 color.red = 1.0;
634 color.green = 0.0;
635 color.blue = 0.0;
636
637 gtk_text_buffer_create_tag (buffer, "fg_red",
638 "rise", -4,
639 "foreground_rgba", &color,
640 NULL);
641
642 color.red = 0.0;
643 color.green = 1.0;
644 color.blue = 0.0;
645
646 gtk_text_buffer_create_tag (buffer, "bg_green",
647 "background_rgba", &color,
648 "font", "-*-courier-bold-r-*-*-10-*-*-*-*-*-*-*",
649 NULL);
650
651 pixbuf = gdk_pixbuf_new_from_resource ("/org/gtk/libgtk/icons/16x16/actions/application-exit.png", NULL);
652
653 g_assert (pixbuf != NULL);
654
655 for (i = 0; i < 10; i++)
656 {
657 gchar *str;
658
659 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
660
661 gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
662
663 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
664
665 gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
666
667 str = g_strdup_printf ("%d Hello World!\nwoo woo woo woo woo woo woo woo\n",
668 i);
669
670 gtk_text_buffer_insert (buffer, &iter, str, -1);
671
672 g_free (str);
673
674 gtk_text_buffer_insert (buffer, &iter,
675 "(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"
676 /* This is UTF8 stuff, Emacs doesn't
677 really know how to display it */
678 "Spanish (Espa\303\261ol) \302\241Hola! / French (Fran\303\247ais) Bonjour, Salut / German (Deutsch S\303\274d) Gr\303\274\303\237 Gott (testing Latin-1 chars encoded in UTF8)\nThai (we can't display this, just making sure we don't crash) (\340\270\240\340\270\262\340\270\251\340\270\262\340\271\204\340\270\227\340\270\242) \340\270\252\340\270\247\340\270\261\340\270\252\340\270\224\340\270\265\340\270\204\340\270\243\340\270\261\340\270\232, \340\270\252\340\270\247\340\270\261\340\270\252\340\270\224\340\270\265\340\270\204\340\271\210\340\270\260\n",
679 -1);
680
681 gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
682 gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
683
684 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 4);
685
686 gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
687
688 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 7);
689
690 gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
691
692 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 8);
693
694 gtk_text_buffer_insert_pixbuf (buffer, &iter, pixbuf);
695
696 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 8);
697 iter2 = iter;
698 gtk_text_iter_forward_chars (&iter2, 10);
699
700 gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
701
702 gtk_text_iter_forward_chars (&iter, 7);
703 gtk_text_iter_forward_chars (&iter2, 10);
704
705 gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);
706
707 gtk_text_iter_forward_chars (&iter, 12);
708 gtk_text_iter_forward_chars (&iter2, 10);
709
710 gtk_text_buffer_apply_tag_by_name (buffer, "bg_green", &iter, &iter2);
711
712 gtk_text_iter_forward_chars (&iter, 10);
713 gtk_text_iter_forward_chars (&iter2, 15);
714
715 gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
716 gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
717
718 gtk_text_iter_forward_chars (&iter, 20);
719 gtk_text_iter_forward_chars (&iter2, 20);
720
721 gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
722 gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
723
724 gtk_text_iter_backward_chars (&iter, 25);
725 gtk_text_iter_forward_chars (&iter2, 5);
726
727 gtk_text_buffer_apply_tag_by_name (buffer, "fg_red", &iter, &iter2);
728 gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &iter, &iter2);
729
730 gtk_text_iter_forward_chars (&iter, 15);
731 gtk_text_iter_backward_chars (&iter2, 10);
732
733 gtk_text_buffer_remove_tag_by_name (buffer, "fg_red", &iter, &iter2);
734 gtk_text_buffer_remove_tag_by_name (buffer, "fg_blue", &iter, &iter2);
735 }
736
737 /* Put in tags that are just at the beginning, and just near the end,
738 * and just near the middle.
739 */
740 tag = gtk_text_buffer_create_tag (buffer, "front_tag", NULL);
741 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 3);
742 gtk_text_buffer_get_iter_at_offset (buffer, &iter2, 300);
743
744 gtk_text_buffer_apply_tag (buffer, tag, &iter, &iter2);
745
746 tag = gtk_text_buffer_create_tag (buffer, "end_tag", NULL);
747 gtk_text_buffer_get_end_iter (buffer, &iter2);
748 gtk_text_iter_backward_chars (&iter2, 12);
749 iter = iter2;
750 gtk_text_iter_backward_chars (&iter, 157);
751
752 gtk_text_buffer_apply_tag (buffer, tag, &iter, &iter2);
753
754 tag = gtk_text_buffer_create_tag (buffer, "center_tag", NULL);
755 gtk_text_buffer_get_iter_at_offset (buffer, &iter,
756 gtk_text_buffer_get_char_count (buffer)/2);
757 gtk_text_iter_backward_chars (&iter, 37);
758 iter2 = iter;
759 gtk_text_iter_forward_chars (&iter2, 57);
760
761 gtk_text_buffer_apply_tag (buffer, tag, &iter, &iter2);
762
763 g_object_unref (pixbuf);
764 }
765
766
767 /*
768 * Line separator tests (initially to avoid regression on bugzilla #57428)
769 */
770
771 static void
772 test_line_separation (const char* str,
773 gboolean expect_next_line,
774 gboolean expect_end_iter,
775 int expected_line_count,
776 int expected_line_break,
777 int expected_next_line_start)
778 {
779 GtkTextIter iter;
780 GtkTextBuffer* buffer;
781 gboolean on_next_line;
782 gboolean on_end_iter;
783 gint new_pos;
784
785 buffer = gtk_text_buffer_new (NULL);
786
787 gtk_text_buffer_set_text (buffer, str, -1);
788 gtk_text_buffer_get_iter_at_offset (buffer, &iter, expected_line_break);
789
790 g_assert (gtk_text_iter_ends_line (&iter) || gtk_text_iter_is_end (&iter));
791
792 g_assert (gtk_text_buffer_get_line_count (buffer) == expected_line_count);
793
794 on_next_line = gtk_text_iter_forward_line (&iter);
795
796 g_assert (expect_next_line == on_next_line);
797
798 on_end_iter = gtk_text_iter_is_end (&iter);
799
800 g_assert (on_end_iter == expect_end_iter);
801
802 new_pos = gtk_text_iter_get_offset (&iter);
803
804 if (on_next_line)
805 g_assert (expected_next_line_start == new_pos);
806
807 ++expected_line_break;
808 while (expected_line_break < expected_next_line_start)
809 {
810 gtk_text_buffer_get_iter_at_offset (buffer, &iter, expected_line_break);
811
812 g_assert (!gtk_text_iter_ends_line (&iter));
813
814 on_next_line = gtk_text_iter_forward_line (&iter);
815
816 g_assert (expect_next_line == on_next_line);
817
818 new_pos = gtk_text_iter_get_offset (&iter);
819
820 if (on_next_line)
821 g_assert (expected_next_line_start == new_pos);
822
823 ++expected_line_break;
824 }
825
826 /* FIXME tests for backward line */
827
828 g_object_unref (buffer);
829 }
830
831 /* there are cases where \r and \n should not be treated like \r\n,
832 * originally bug #337022. */
833 static void
834 split_r_n_separators_test (void)
835 {
836 GtkTextBuffer *buffer;
837 GtkTextIter iter;
838
839 buffer = gtk_text_buffer_new (NULL);
840
841 gtk_text_buffer_set_text (buffer, "foo\ra\nbar\n", -1);
842
843 /* delete 'a' so that we have
844
845 1 foo\r
846 2 \n
847 3 bar\n
848
849 * and both \r and \n are line separators */
850
851 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 5);
852 gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
853
854 g_assert (gtk_text_iter_ends_line (&iter));
855
856 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 3);
857 g_assert (gtk_text_iter_ends_line (&iter));
858
859 g_object_unref (buffer);
860 }
861
862 static void
863 test_line_separator (void)
864 {
865 char *str;
866 char buf[7] = { '\0', };
867
868 /* Only one character has type G_UNICODE_PARAGRAPH_SEPARATOR in
869 * Unicode 3.0; update this if that changes.
870 */
871 #define PARAGRAPH_SEPARATOR 0x2029
872
873 test_line_separation ("line", FALSE, TRUE, 1, 4, 4);
874 test_line_separation ("line\r\n", FALSE, TRUE, 2, 4, 6);
875 test_line_separation ("line\r", FALSE, TRUE, 2, 4, 5);
876 test_line_separation ("line\n", FALSE, TRUE, 2, 4, 5);
877 test_line_separation ("line\rqw", TRUE, FALSE, 2, 4, 5);
878 test_line_separation ("line\nqw", TRUE, FALSE, 2, 4, 5);
879 test_line_separation ("line\r\nqw", TRUE, FALSE, 2, 4, 6);
880
881 g_unichar_to_utf8 (PARAGRAPH_SEPARATOR, buf);
882
883 str = g_strdup_printf ("line%s", buf);
884 test_line_separation (str, FALSE, TRUE, 2, 4, 5);
885 g_free (str);
886 str = g_strdup_printf ("line%sqw", buf);
887 test_line_separation (str, TRUE, FALSE, 2, 4, 5);
888 g_free (str);
889
890 split_r_n_separators_test ();
891 }
892
893 static void
894 test_backspace (void)
895 {
896 GtkTextBuffer *buffer;
897 GtkTextIter iter;
898 gboolean ret;
899
900 buffer = gtk_text_buffer_new (NULL);
901
902 gtk_text_buffer_set_text (buffer, "foo", -1);
903 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 2);
904 ret = gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
905 g_assert (ret);
906 g_assert_cmpint (1, ==, gtk_text_iter_get_offset (&iter));
907 g_assert_cmpint (2, ==, gtk_text_buffer_get_char_count (buffer));
908
909 gtk_text_buffer_set_text (buffer, "foo", -1);
910 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
911 ret = gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
912 g_assert (!ret);
913 g_assert_cmpint (0, ==, gtk_text_iter_get_offset (&iter));
914 g_assert_cmpint (3, ==, gtk_text_buffer_get_char_count (buffer));
915
916 /* test bug #544724 */
917 gtk_text_buffer_set_text (buffer, "foo\r\n\r\nbar", -1);
918 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 5);
919 ret = gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
920 g_assert (ret);
921 g_assert_cmpint (0, ==, gtk_text_iter_get_line (&iter));
922 g_assert_cmpint (8, ==, gtk_text_buffer_get_char_count (buffer));
923
924 /* test empty last line */
925 gtk_text_buffer_set_text (buffer, "", -1);
926 gtk_text_buffer_get_end_iter (buffer, &iter);
927 ret = gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
928 g_assert (!ret);
929 g_assert_cmpint (0, ==, gtk_text_iter_get_offset (&iter));
930 g_assert_cmpint (0, ==, gtk_text_buffer_get_char_count (buffer));
931
932 gtk_text_buffer_set_text (buffer, "foo\n", -1);
933 gtk_text_buffer_get_end_iter (buffer, &iter);
934 ret = gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
935 g_assert (ret);
936 g_assert_cmpint (3, ==, gtk_text_iter_get_offset (&iter));
937 g_assert_cmpint (3, ==, gtk_text_buffer_get_char_count (buffer));
938
939 gtk_text_buffer_set_text (buffer, "foo\r\n", -1);
940 gtk_text_buffer_get_end_iter (buffer, &iter);
941 ret = gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
942 g_assert (ret);
943 g_assert_cmpint (3, ==, gtk_text_iter_get_offset (&iter));
944 g_assert_cmpint (3, ==, gtk_text_buffer_get_char_count (buffer));
945
946 g_object_unref (buffer);
947 }
948
949 static void
950 test_logical_motion (void)
951 {
952 char *str;
953 char buf1[7] = { '\0', };
954 char buf2[7] = { '\0', };
955 char buf3[7] = { '\0', };
956 int expected[30];
957 int expected_steps;
958 int i;
959 GtkTextBuffer *buffer;
960 GtkTextIter iter;
961
962 buffer = gtk_text_buffer_new (NULL);
963
964 #define LEADING_JAMO 0x1111
965 #define VOWEL_JAMO 0x1167
966 #define TRAILING_JAMO 0x11B9
967
968 g_unichar_to_utf8 (LEADING_JAMO, buf1);
969 g_unichar_to_utf8 (VOWEL_JAMO, buf2);
970 g_unichar_to_utf8 (TRAILING_JAMO, buf3);
971
972 /* Build the string "abc<leading><vowel><trailing>def\r\nxyz" */
973 str = g_strconcat ("abc", buf1, buf2, buf3, "def\r\nxyz", NULL);
974 gtk_text_buffer_set_text (buffer, str, -1);
975 g_free (str);
976
977 /* Check cursor positions */
978 memset (expected, 0, sizeof (expected));
979 expected[0] = 0; /* before 'a' */
980 expected[1] = 1; /* before 'b' */
981 expected[2] = 2; /* before 'c' */
982 expected[3] = 3; /* before jamo */
983 expected[4] = 6; /* before 'd' */
984 expected[5] = 7; /* before 'e' */
985 expected[6] = 8; /* before 'f' */
986 expected[7] = 9; /* before '\r' */
987 expected[8] = 11; /* before 'x' */
988 expected[9] = 12; /* before 'y' */
989 expected[10] = 13; /* before 'z' */
990 expected[11] = 14; /* after 'z' (only matters going backward) */
991 expected_steps = 11;
992
993 gtk_text_buffer_get_start_iter (buffer, &iter);
994 i = 0;
995 do
996 {
997 int pos;
998
999 pos = gtk_text_iter_get_offset (&iter);
1000
1001 if (pos != expected[i])
1002 {
1003 g_error ("Cursor position %d, expected %d",
1004 pos, expected[i]);
1005 }
1006
1007 ++i;
1008 }
1009 while (gtk_text_iter_forward_cursor_position (&iter));
1010
1011 if (!gtk_text_iter_is_end (&iter))
1012 g_error ("Expected to stop at the end iterator");
1013
1014 if (!gtk_text_iter_is_cursor_position (&iter))
1015 g_error ("Should be a cursor position before the end iterator");
1016
1017 if (i != expected_steps)
1018 g_error ("Expected %d steps, there were actually %d\n", expected_steps, i);
1019
1020 i = expected_steps;
1021 do
1022 {
1023 int pos;
1024
1025 pos = gtk_text_iter_get_offset (&iter);
1026
1027 if (pos != expected[i])
1028 {
1029 g_error ("Moving backward, cursor position %d, expected %d",
1030 pos, expected[i]);
1031 }
1032
1033 /* g_print ("%d = %d\n", pos, expected[i]); */
1034
1035 --i;
1036 }
1037 while (gtk_text_iter_backward_cursor_position (&iter));
1038
1039 if (i != -1)
1040 g_error ("Expected %d steps, there were actually %d", expected_steps - i, i);
1041
1042 if (!gtk_text_iter_is_start (&iter))
1043 g_error ("Expected to stop at the start iterator");
1044
1045
1046 /* Check sentence boundaries */
1047
1048 gtk_text_buffer_set_text (buffer, "Hi.\nHi. \nHi! Hi. Hi? Hi.", -1);
1049
1050 memset (expected, 0, sizeof (expected));
1051
1052 expected[0] = 0; /* before first Hi */
1053 expected[1] = 3; /* After first . */
1054 expected[2] = 7; /* After second . */
1055 expected[3] = 12; /* After ! */
1056 expected[4] = 16; /* After third . */
1057 expected[5] = 20; /* After ? */
1058
1059 expected_steps = 6;
1060
1061 gtk_text_buffer_get_start_iter (buffer, &iter);
1062 i = 0;
1063 do
1064 {
1065 int pos;
1066
1067 pos = gtk_text_iter_get_offset (&iter);
1068
1069 if (pos != expected[i])
1070 {
1071 g_error ("Sentence position %d, expected %d",
1072 pos, expected[i]);
1073 }
1074
1075 if (i != 0 &&
1076 !gtk_text_iter_is_end (&iter) &&
1077 !gtk_text_iter_ends_sentence (&iter))
1078 g_error ("Iterator at %d should end a sentence", pos);
1079
1080 ++i;
1081 }
1082 while (gtk_text_iter_forward_sentence_end (&iter));
1083
1084 if (i != expected_steps)
1085 g_error ("Expected %d steps, there were actually %d", expected_steps, i);
1086
1087 if (!gtk_text_iter_is_end (&iter))
1088 g_error ("Expected to stop at the end iterator");
1089
1090 gtk_text_buffer_set_text (buffer, "Hi.\nHi. \nHi! Hi. Hi? Hi.", -1);
1091
1092 memset (expected, 0, sizeof (expected));
1093
1094 expected[0] = 24;
1095 expected[1] = 21;
1096 expected[2] = 17;
1097 expected[3] = 13;
1098 expected[4] = 9;
1099 expected[5] = 4;
1100 expected[6] = 0;
1101
1102 expected_steps = 7;
1103
1104 gtk_text_buffer_get_end_iter (buffer, &iter);
1105 i = 0;
1106 do
1107 {
1108 int pos;
1109
1110 pos = gtk_text_iter_get_offset (&iter);
1111
1112 if (pos != expected[i])
1113 {
1114 g_error ("Sentence position %d, expected %d",
1115 pos, expected[i]);
1116 }
1117
1118 if (pos != 0 &&
1119 !gtk_text_iter_is_end (&iter) &&
1120 !gtk_text_iter_starts_sentence (&iter))
1121 g_error ("Iterator at %d should start a sentence", pos);
1122
1123 ++i;
1124 }
1125 while (gtk_text_iter_backward_sentence_start (&iter));
1126
1127 if (i != expected_steps)
1128 g_error ("Expected %d steps, there were actually %d", expected_steps, i);
1129
1130 if (gtk_text_iter_get_offset (&iter) != 0)
1131 g_error ("Expected to stop at the start iterator");
1132
1133 g_object_unref (buffer);
1134 }
1135
1136 static void
1137 test_marks (void)
1138 {
1139 GtkTextBuffer *buf1, *buf2;
1140 GtkTextMark *mark;
1141 GtkTextIter iter;
1142
1143 buf1 = gtk_text_buffer_new (NULL);
1144 buf2 = gtk_text_buffer_new (NULL);
1145
1146 gtk_text_buffer_get_start_iter (buf1, &iter);
1147 mark = gtk_text_buffer_create_mark (buf1, "foo", &iter, TRUE);
1148 g_object_ref (mark);
1149 gtk_text_mark_set_visible (mark, TRUE);
1150 gtk_text_buffer_delete_mark (buf1, mark);
1151
1152 g_assert (gtk_text_mark_get_visible (mark));
1153 g_assert (gtk_text_mark_get_left_gravity (mark));
1154 g_assert (!strcmp ("foo", gtk_text_mark_get_name (mark)));
1155 g_assert (gtk_text_mark_get_buffer (mark) == NULL);
1156 g_assert (gtk_text_mark_get_deleted (mark));
1157 g_assert (gtk_text_buffer_get_mark (buf1, "foo") == NULL);
1158
1159 gtk_text_buffer_get_start_iter (buf2, &iter);
1160 gtk_text_buffer_add_mark (buf2, mark, &iter);
1161 gtk_text_buffer_insert (buf2, &iter, "ewfwefwefwe", -1);
1162 gtk_text_buffer_get_iter_at_mark (buf2, &iter, mark);
1163
1164 g_assert (gtk_text_mark_get_visible (mark));
1165 g_assert (gtk_text_iter_is_start (&iter));
1166 g_assert (gtk_text_mark_get_left_gravity (mark));
1167 g_assert (!strcmp ("foo", gtk_text_mark_get_name (mark)));
1168 g_assert (gtk_text_mark_get_buffer (mark) == buf2);
1169 g_assert (!gtk_text_mark_get_deleted (mark));
1170 g_assert (gtk_text_buffer_get_mark (buf2, "foo") == mark);
1171
1172 gtk_text_buffer_delete_mark (buf2, mark);
1173 gtk_text_mark_set_visible (mark, FALSE);
1174 g_object_unref (mark);
1175
1176 mark = gtk_text_mark_new ("blah", TRUE);
1177 gtk_text_buffer_get_start_iter (buf1, &iter);
1178 gtk_text_mark_set_visible (mark, TRUE);
1179 gtk_text_buffer_add_mark (buf1, mark, &iter);
1180
1181 g_assert (gtk_text_mark_get_visible (mark));
1182 g_assert (gtk_text_mark_get_buffer (mark) == buf1);
1183 g_assert (!gtk_text_mark_get_deleted (mark));
1184 g_assert (gtk_text_buffer_get_mark (buf1, "blah") == mark);
1185 g_assert (!strcmp ("blah", gtk_text_mark_get_name (mark)));
1186
1187 gtk_text_mark_set_visible (mark, FALSE);
1188 gtk_text_buffer_delete_mark (buf1, mark);
1189 g_assert (!gtk_text_mark_get_visible (mark));
1190 g_assert (gtk_text_buffer_get_mark (buf1, "blah") == NULL);
1191 g_assert (gtk_text_mark_get_buffer (mark) == NULL);
1192 g_assert (gtk_text_mark_get_deleted (mark));
1193
1194 gtk_text_buffer_get_start_iter (buf2, &iter);
1195 gtk_text_buffer_add_mark (buf2, mark, &iter);
1196 g_assert (gtk_text_mark_get_buffer (mark) == buf2);
1197 g_assert (!gtk_text_mark_get_deleted (mark));
1198 g_assert (gtk_text_buffer_get_mark (buf2, "blah") == mark);
1199 g_assert (!strcmp ("blah", gtk_text_mark_get_name (mark)));
1200
1201 g_object_unref (mark);
1202 g_object_unref (buf1);
1203 g_object_unref (buf2);
1204 }
1205
1206 static void
1207 test_utf8 (void)
1208 {
1209 gunichar ch;
1210
1211 /* Check UTF8 unknown char thing */
1212 g_assert (GTK_TEXT_UNKNOWN_CHAR_UTF8_LEN == 3);
1213 g_assert (g_utf8_strlen (gtk_text_unknown_char_utf8_gtk_tests_only (), 3) == 1);
1214 ch = g_utf8_get_char (gtk_text_unknown_char_utf8_gtk_tests_only ());
1215 g_assert (ch == GTK_TEXT_UNKNOWN_CHAR);
1216 }
1217
1218 static void
1219 test_empty_buffer (void)
1220 {
1221 GtkTextBuffer *buffer;
1222 int n;
1223 GtkTextIter start;
1224
1225 buffer = gtk_text_buffer_new (NULL);
1226
1227 /* Check that buffer starts with one empty line and zero chars */
1228 n = gtk_text_buffer_get_line_count (buffer);
1229 if (n != 1)
1230 g_error ("%d lines, expected 1", n);
1231
1232 n = gtk_text_buffer_get_char_count (buffer);
1233 if (n != 0)
1234 g_error ("%d chars, expected 0", n);
1235
1236 /* empty first line contains 0 chars */
1237 gtk_text_buffer_get_start_iter (buffer, &start);
1238 n = gtk_text_iter_get_chars_in_line (&start);
1239 if (n != 0)
1240 g_error ("%d chars in first line, expected 0", n);
1241 n = gtk_text_iter_get_bytes_in_line (&start);
1242 if (n != 0)
1243 g_error ("%d bytes in first line, expected 0", n);
1244
1245 /* Run gruesome alien test suite on buffer */
1246 run_tests (buffer);
1247
1248 g_object_unref (buffer);
1249 }
1250
1251 static void
1252 test_get_set(void)
1253 {
1254 GtkTextBuffer *buffer;
1255
1256 buffer = gtk_text_buffer_new (NULL);
1257
1258 check_get_set_text (buffer, "Hello");
1259 check_get_set_text (buffer, "Hello\n");
1260 check_get_set_text (buffer, "Hello\r\n");
1261 check_get_set_text (buffer, "Hello\r");
1262 check_get_set_text (buffer, "Hello\nBar\nFoo");
1263 check_get_set_text (buffer, "Hello\nBar\nFoo\n");
1264
1265 g_object_unref (buffer);
1266 }
1267
1268 static void
1269 test_fill_empty (void)
1270 {
1271 GtkTextBuffer *buffer;
1272 int n;
1273 GtkTextIter start, end;
1274
1275 buffer = gtk_text_buffer_new (NULL);
1276
1277 /* Put stuff in the buffer */
1278 fill_buffer (buffer);
1279
1280 /* Subject stuff-bloated buffer to further torment */
1281 run_tests (buffer);
1282
1283 /* Delete all stuff from the buffer */
1284 gtk_text_buffer_get_bounds (buffer, &start, &end);
1285 gtk_text_buffer_delete (buffer, &start, &end);
1286
1287 /* Check buffer for emptiness (note that a single
1288 empty line always remains in the buffer) */
1289 n = gtk_text_buffer_get_line_count (buffer);
1290 if (n != 1)
1291 g_error ("%d lines, expected 1", n);
1292
1293 n = gtk_text_buffer_get_char_count (buffer);
1294 if (n != 0)
1295 g_error ("%d chars, expected 0", n);
1296
1297 run_tests (buffer);
1298
1299 g_object_unref (buffer);
1300 }
1301
1302 static void
1303 test_tag (void)
1304 {
1305 GtkTextBuffer *buffer;
1306 GtkTextIter start, end;
1307
1308 buffer = gtk_text_buffer_new (NULL);
1309
1310 fill_buffer (buffer);
1311
1312 gtk_text_buffer_set_text (buffer, "adcdef", -1);
1313 gtk_text_buffer_get_iter_at_offset (buffer, &start, 1);
1314 gtk_text_buffer_get_iter_at_offset (buffer, &end, 3);
1315 gtk_text_buffer_apply_tag_by_name (buffer, "fg_blue", &start, &end);
1316
1317 run_tests (buffer);
1318
1319 g_object_unref (buffer);
1320 }
1321
1322 static void
1323 check_buffer_contents (GtkTextBuffer *buffer,
1324 const gchar *contents)
1325 {
1326 GtkTextIter start;
1327 GtkTextIter end;
1328 gchar *buffer_contents;
1329
1330 gtk_text_buffer_get_start_iter (buffer, &start);
1331 gtk_text_buffer_get_end_iter (buffer, &end);
1332 buffer_contents = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
1333 g_assert_cmpstr (buffer_contents, ==, contents);
1334 }
1335
1336 static void
1337 test_clipboard (void)
1338 {
1339 GtkClipboard *clipboard;
1340 GtkTextBuffer *buffer;
1341 GtkTextIter start;
1342 GtkTextIter end;
1343 GtkTextTag *tag;
1344
1345 clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
1346
1347 buffer = gtk_text_buffer_new (NULL);
1348 gtk_text_buffer_set_text (buffer, "abcdef", -1);
1349
1350 /* Simple cut & paste */
1351 gtk_text_buffer_get_start_iter (buffer, &start);
1352 gtk_text_buffer_get_iter_at_offset (buffer, &end, 3);
1353 gtk_text_buffer_select_range (buffer, &start, &end);
1354
1355 gtk_text_buffer_cut_clipboard (buffer, clipboard, TRUE);
1356 check_buffer_contents (buffer, "def");
1357
1358 gtk_text_buffer_get_end_iter (buffer, &end);
1359 gtk_text_buffer_paste_clipboard (buffer, clipboard, &end, TRUE);
1360 check_buffer_contents (buffer, "defabc");
1361
1362 /* Simple copy & paste */
1363 gtk_text_buffer_get_iter_at_offset (buffer, &start, 3);
1364 gtk_text_buffer_get_end_iter (buffer, &end);
1365 gtk_text_buffer_select_range (buffer, &start, &end);
1366 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1367
1368 gtk_text_buffer_get_start_iter (buffer, &start);
1369 gtk_text_buffer_paste_clipboard (buffer, clipboard, &start, TRUE);
1370 check_buffer_contents (buffer, "abcdefabc");
1371
1372 /* Replace the selection when pasting */
1373 gtk_text_buffer_set_text (buffer, "abcdef", -1);
1374
1375 gtk_text_buffer_get_start_iter (buffer, &start);
1376 gtk_text_buffer_get_iter_at_offset (buffer, &end, 3);
1377 gtk_text_buffer_select_range (buffer, &start, &end);
1378 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1379
1380 gtk_text_buffer_get_iter_at_offset (buffer, &start, 3);
1381 gtk_text_buffer_get_end_iter (buffer, &end);
1382 gtk_text_buffer_select_range (buffer, &start, &end);
1383 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1384 check_buffer_contents (buffer, "abcabc");
1385
1386 /* Copy & paste text with tags.
1387 * See https://bugzilla.gnome.org/show_bug.cgi?id=339539
1388 */
1389 gtk_text_buffer_set_text (buffer, "abcdef", -1);
1390
1391 tag = gtk_text_buffer_create_tag (buffer, NULL, NULL);
1392
1393 gtk_text_buffer_get_start_iter (buffer, &start);
1394 gtk_text_buffer_get_iter_at_offset (buffer, &end, 4);
1395 gtk_text_buffer_apply_tag (buffer, tag, &start, &end);
1396
1397 gtk_text_buffer_get_iter_at_offset (buffer, &start, 3);
1398 gtk_text_buffer_get_end_iter (buffer, &end);
1399 gtk_text_buffer_select_range (buffer, &start, &end);
1400 gtk_text_buffer_copy_clipboard (buffer, clipboard);
1401 gtk_text_buffer_paste_clipboard (buffer, clipboard, NULL, TRUE);
1402 check_buffer_contents (buffer, "abcdef");
1403
1404 gtk_text_buffer_get_iter_at_offset (buffer, &start, 3);
1405 g_assert (gtk_text_iter_forward_to_tag_toggle (&start, tag));
1406 g_assert_cmpint (4, ==, gtk_text_iter_get_offset (&start));
1407
1408 g_object_unref (buffer);
1409 }
1410
1411 static void
1412 test_get_iter (void)
1413 {
1414 GtkTextBuffer *buffer;
1415 GtkTextIter iter;
1416 gint offset;
1417
1418 buffer = gtk_text_buffer_new (NULL);
1419
1420 /* ß takes 2 bytes in UTF-8 */
1421 gtk_text_buffer_set_text (buffer, "ab\nßd\r\nef", -1);
1422
1423 /* Test get_iter_at_line() */
1424 gtk_text_buffer_get_iter_at_line (buffer, &iter, 0);
1425 g_assert (gtk_text_iter_is_start (&iter));
1426
1427 gtk_text_buffer_get_iter_at_line (buffer, &iter, 1);
1428 offset = gtk_text_iter_get_offset (&iter);
1429 g_assert_cmpint (offset, ==, 3);
1430
1431 gtk_text_buffer_get_iter_at_line (buffer, &iter, 2);
1432 offset = gtk_text_iter_get_offset (&iter);
1433 g_assert_cmpint (offset, ==, 7);
1434
1435 gtk_text_buffer_get_iter_at_line (buffer, &iter, 3);
1436 g_assert (gtk_text_iter_is_end (&iter));
1437
1438 /* Test get_iter_at_line_offset() */
1439 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 0);
1440 g_assert (gtk_text_iter_is_start (&iter));
1441
1442 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 1);
1443 offset = gtk_text_iter_get_offset (&iter);
1444 g_assert_cmpint (offset, ==, 1);
1445
1446 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 2);
1447 offset = gtk_text_iter_get_offset (&iter);
1448 g_assert_cmpint (offset, ==, 2);
1449
1450 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 0, 3);
1451 offset = gtk_text_iter_get_offset (&iter);
1452 g_assert_cmpint (offset, ==, 2);
1453
1454 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 1, 1);
1455 offset = gtk_text_iter_get_offset (&iter);
1456 g_assert_cmpint (offset, ==, 4);
1457
1458 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 2, 1);
1459 offset = gtk_text_iter_get_offset (&iter);
1460 g_assert_cmpint (offset, ==, 8);
1461
1462 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 2, 2);
1463 g_assert (gtk_text_iter_is_end (&iter));
1464
1465 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 2, 3);
1466 g_assert (gtk_text_iter_is_end (&iter));
1467
1468 gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, 3, 1);
1469 g_assert (gtk_text_iter_is_end (&iter));
1470
1471 /* Test get_iter_at_line_index() */
1472 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 0, 0);
1473 g_assert (gtk_text_iter_is_start (&iter));
1474
1475 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 0, 1);
1476 offset = gtk_text_iter_get_offset (&iter);
1477 g_assert_cmpint (offset, ==, 1);
1478
1479 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 0, 2);
1480 offset = gtk_text_iter_get_offset (&iter);
1481 g_assert_cmpint (offset, ==, 2);
1482
1483 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 0, 3);
1484 offset = gtk_text_iter_get_offset (&iter);
1485 g_assert_cmpint (offset, ==, 2);
1486
1487 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 1, 0);
1488 offset = gtk_text_iter_get_offset (&iter);
1489 g_assert_cmpint (offset, ==, 3);
1490
1491 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 1, 2);
1492 offset = gtk_text_iter_get_offset (&iter);
1493 g_assert_cmpint (offset, ==, 4);
1494
1495 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 1, 3);
1496 offset = gtk_text_iter_get_offset (&iter);
1497 g_assert_cmpint (offset, ==, 5);
1498
1499 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 2, 2);
1500 g_assert (gtk_text_iter_is_end (&iter));
1501
1502 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 2, 3);
1503 g_assert (gtk_text_iter_is_end (&iter));
1504
1505 gtk_text_buffer_get_iter_at_line_index (buffer, &iter, 3, 1);
1506 g_assert (gtk_text_iter_is_end (&iter));
1507
1508 /* Test get_iter_at_offset() */
1509 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
1510 g_assert (gtk_text_iter_is_start (&iter));
1511
1512 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
1513 offset = gtk_text_iter_get_offset (&iter);
1514 g_assert_cmpint (offset, ==, 1);
1515
1516 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 8);
1517 offset = gtk_text_iter_get_offset (&iter);
1518 g_assert_cmpint (offset, ==, 8);
1519 g_assert (!gtk_text_iter_is_end (&iter));
1520
1521 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 9);
1522 g_assert (gtk_text_iter_is_end (&iter));
1523
1524 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 100);
1525 g_assert (gtk_text_iter_is_end (&iter));
1526
1527 gtk_text_buffer_get_iter_at_offset (buffer, &iter, -1);
1528 g_assert (gtk_text_iter_is_end (&iter));
1529
1530 g_object_unref (buffer);
1531 }
1532
1533 int
1534 main (int argc, char** argv)
1535 {
1536 /* First, we turn on btree debugging. */
1537 gtk_set_debug_flags (gtk_get_debug_flags () | GTK_DEBUG_TEXT);
1538
1539 gtk_test_init (&argc, &argv);
1540
1541 g_test_add_func ("/TextBuffer/UTF8 unknown char", test_utf8);
1542 g_test_add_func ("/TextBuffer/Line separator", test_line_separator);
1543 g_test_add_func ("/TextBuffer/Backspace", test_backspace);
1544 g_test_add_func ("/TextBuffer/Logical motion", test_logical_motion);
1545 g_test_add_func ("/TextBuffer/Marks", test_marks);
1546 g_test_add_func ("/TextBuffer/Empty buffer", test_empty_buffer);
1547 g_test_add_func ("/TextBuffer/Get and Set", test_get_set);
1548 g_test_add_func ("/TextBuffer/Fill and Empty", test_fill_empty);
1549 g_test_add_func ("/TextBuffer/Tag", test_tag);
1550 g_test_add_func ("/TextBuffer/Clipboard", test_clipboard);
1551 g_test_add_func ("/TextBuffer/Get iter", test_get_iter);
1552
1553 return g_test_run();
1554 }