Debian Codegraph @

tests/unit-tests/test-inline-checker-text-buffer.c

raw
1 /* SPDX-FileCopyrightText: 2016 - Sébastien Wilmet <[email protected]>
2 * SPDX-License-Identifier: LGPL-2.1-or-later
3 */
4
5 #include <gspell/gspell.h>
6 #include "gspell/gspell-inline-checker-text-buffer.h"
7
8 static GtkTextBuffer *
9 create_buffer (void)
10 {
11 GtkTextBuffer *gtk_buffer;
12 GspellTextBuffer *gspell_buffer;
13 const GspellLanguage *lang;
14 GspellChecker *checker;
15
16 gtk_buffer = gtk_text_buffer_new (NULL);
17 gspell_buffer = gspell_text_buffer_get_from_gtk_text_buffer (gtk_buffer);
18
19 lang = gspell_language_lookup ("en_US");
20 g_assert_true (lang != NULL);
21
22 checker = gspell_checker_new (lang);
23 gspell_text_buffer_set_spell_checker (gspell_buffer, checker);
24 g_object_unref (checker);
25
26 return gtk_buffer;
27 }
28
29 static void
30 insert_text_one_char_at_a_time (GtkTextBuffer *buffer,
31 GtkTextIter *iter,
32 const gchar *text)
33 {
34 const gchar *p;
35
36 /* Assumes it's only ASCII characters. */
37 for (p = text; p != NULL && *p != '\0'; p++)
38 {
39 gtk_text_buffer_insert (buffer, iter, p, 1);
40 }
41 }
42
43 /*
44 * check_highlighted_words:
45 * @buffer:
46 * @inline_checker:
47 * @...: list of pairs of character offsets (as #gint's) delimiting the expected
48 * highlighted words in @buffer. The list must be terminated by -1.
49 *
50 * Checks the boundaries of the highlighted words in @buffer.
51 */
52 static void
53 check_highlighted_words (GtkTextBuffer *buffer,
54 GspellInlineCheckerTextBuffer *inline_checker,
55 ...)
56 {
57 GtkTextTag *tag;
58 GtkTextIter iter;
59 va_list list;
60 gint remaining_list_element;
61
62 tag = _gspell_inline_checker_text_buffer_get_highlight_tag (inline_checker);
63 g_assert_true (GTK_IS_TEXT_TAG (tag));
64
65 gtk_text_buffer_get_start_iter (buffer, &iter);
66 va_start (list, inline_checker);
67
68 while (!gtk_text_iter_is_end (&iter))
69 {
70 GtkTextIter start;
71 GtkTextIter end;
72 gint start_offset;
73 gint end_offset;
74 gint expected_start_offset;
75 gint expected_end_offset;
76
77 start = iter;
78 if (!gtk_text_iter_starts_tag (&start, tag))
79 {
80 if (!gtk_text_iter_forward_to_tag_toggle (&start, tag))
81 {
82 break;
83 }
84
85 g_assert_true (gtk_text_iter_starts_tag (&start, tag));
86 }
87
88 end = start;
89 if (!gtk_text_iter_forward_to_tag_toggle (&end, tag))
90 {
91 g_assert_not_reached ();
92 }
93 g_assert_true (gtk_text_iter_ends_tag (&end, tag));
94
95 start_offset = gtk_text_iter_get_offset (&start);
96 expected_start_offset = va_arg (list, gint);
97 g_assert_cmpint (expected_start_offset, ==, start_offset);
98
99 end_offset = gtk_text_iter_get_offset (&end);
100 expected_end_offset = va_arg (list, gint);
101 g_assert_cmpint (expected_end_offset, ==, end_offset);
102
103 iter = end;
104 }
105
106 remaining_list_element = va_arg (list, gint);
107 g_assert_cmpint (remaining_list_element, ==, -1);
108
109 va_end (list);
110 }
111
112 static void
113 test_whole_buffer (void)
114 {
115 GtkTextBuffer *buffer;
116 GspellInlineCheckerTextBuffer *inline_checker;
117
118 buffer = create_buffer ();
119 gtk_text_buffer_set_text (buffer, "Hello jlyxdt, grrimbl?\nNo, not really today.", -1);
120
121 inline_checker = _gspell_inline_checker_text_buffer_new (buffer);
122 _gspell_inline_checker_text_buffer_set_unit_test_mode (inline_checker, TRUE);
123
124 check_highlighted_words (buffer,
125 inline_checker,
126 6, 12,
127 14, 21,
128 -1);
129
130 g_object_unref (inline_checker);
131 g_object_unref (buffer);
132 }
133
134 static void
135 test_text_insertion (void)
136 {
137 GtkTextBuffer *buffer;
138 GspellInlineCheckerTextBuffer *inline_checker;
139 GtkTextIter iter;
140
141 buffer = create_buffer ();
142 inline_checker = _gspell_inline_checker_text_buffer_new (buffer);
143 _gspell_inline_checker_text_buffer_set_unit_test_mode (inline_checker, TRUE);
144
145 gtk_text_buffer_get_start_iter (buffer, &iter);
146 gtk_text_buffer_insert (buffer, &iter, "Hello jlyxdt, grrimbl?\nNo, not really today.", -1);
147
148 check_highlighted_words (buffer,
149 inline_checker,
150 6, 12,
151 14, 21,
152 -1);
153
154 /* Modify a word: correctly spelled -> misspelled. */
155 gtk_text_buffer_get_start_iter (buffer, &iter);
156 gtk_text_buffer_insert (buffer, &iter, "ZK", -1);
157
158 check_highlighted_words (buffer,
159 inline_checker,
160 0, 7,
161 8, 14,
162 16, 23,
163 -1);
164
165 /* Insert new misspelled word. */
166 gtk_text_buffer_get_start_iter (buffer, &iter);
167 gtk_text_buffer_insert (buffer, &iter, "Tst ", -1);
168
169 check_highlighted_words (buffer,
170 inline_checker,
171 0, 3,
172 4, 11,
173 12, 18,
174 20, 27,
175 -1);
176
177 /* Modify word: misspelled -> correctly spelled. */
178 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
179 gtk_text_buffer_insert (buffer, &iter, "e", -1);
180
181 check_highlighted_words (buffer,
182 inline_checker,
183 5, 12,
184 13, 19,
185 21, 28,
186 -1);
187
188 /* Have two collapsed correctly spelled words ("Testagain"). */
189 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 4);
190 gtk_text_buffer_insert (buffer, &iter, "again", -1);
191
192 check_highlighted_words (buffer,
193 inline_checker,
194 0, 9,
195 10, 17,
196 18, 24,
197 26, 33,
198 -1);
199
200 /* Test neighbor words: "Testagain" -> "Test again". */
201 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 4);
202 gtk_text_buffer_insert (buffer, &iter, " ", -1);
203
204 check_highlighted_words (buffer,
205 inline_checker,
206 11, 18,
207 19, 25,
208 27, 34,
209 -1);
210
211 g_object_unref (inline_checker);
212 g_object_unref (buffer);
213 }
214
215 static void
216 test_text_deletion (void)
217 {
218 GtkTextBuffer *buffer;
219 GspellInlineCheckerTextBuffer *inline_checker;
220 GtkTextIter start;
221 GtkTextIter end;
222
223 buffer = create_buffer ();
224 gtk_text_buffer_set_text (buffer, "Test againnn againnn.", -1);
225
226 inline_checker = _gspell_inline_checker_text_buffer_new (buffer);
227 _gspell_inline_checker_text_buffer_set_unit_test_mode (inline_checker, TRUE);
228
229 check_highlighted_words (buffer,
230 inline_checker,
231 5, 12,
232 13, 20,
233 -1);
234
235 /* Modify end of word: misspelled -> still misspelled.
236 * First "againnn" -> "againn"
237 */
238 gtk_text_buffer_get_iter_at_offset (buffer, &start, 11);
239 gtk_text_buffer_get_iter_at_offset (buffer, &end, 12);
240 gtk_text_buffer_delete (buffer, &start, &end);
241
242 check_highlighted_words (buffer,
243 inline_checker,
244 5, 11,
245 12, 19,
246 -1);
247
248 /* Modify end of word: misspelled -> correctly spelled.
249 * "againn" -> "again"
250 */
251 gtk_text_buffer_get_iter_at_offset (buffer, &start, 10);
252 gtk_text_buffer_get_iter_at_offset (buffer, &end, 11);
253 gtk_text_buffer_delete (buffer, &start, &end);
254
255 check_highlighted_words (buffer,
256 inline_checker,
257 11, 18,
258 -1);
259
260 /* Modify middle of word: misspelled -> correctly spelled.
261 * Second "agai[nn]n" -> "again"
262 */
263 gtk_text_buffer_get_iter_at_offset (buffer, &start, 15);
264 gtk_text_buffer_get_iter_at_offset (buffer, &end, 17);
265 gtk_text_buffer_delete (buffer, &start, &end);
266
267 check_highlighted_words (buffer, inline_checker, -1);
268
269 /* Modify word: correctly spelled -> misspelled.
270 * Second "again" -> "agan"
271 */
272 gtk_text_buffer_get_iter_at_offset (buffer, &start, 14);
273 gtk_text_buffer_get_iter_at_offset (buffer, &end, 15);
274 gtk_text_buffer_delete (buffer, &start, &end);
275
276 check_highlighted_words (buffer,
277 inline_checker,
278 11, 15,
279 -1);
280
281 /* Collapse two correctly spelled words to form a misspelled word.
282 * "Test again" -> "Testagain"
283 */
284 gtk_text_buffer_get_iter_at_offset (buffer, &start, 4);
285 gtk_text_buffer_get_iter_at_offset (buffer, &end, 5);
286 gtk_text_buffer_delete (buffer, &start, &end);
287
288 check_highlighted_words (buffer,
289 inline_checker,
290 0, 9,
291 10, 14,
292 -1);
293
294 g_object_unref (inline_checker);
295 g_object_unref (buffer);
296 }
297
298 static void
299 test_current_word (void)
300 {
301 GtkTextBuffer *buffer;
302 GspellInlineCheckerTextBuffer *inline_checker;
303 GtkTextIter iter;
304 GtkTextIter start;
305 GtkTextIter end;
306
307 buffer = create_buffer ();
308 inline_checker = _gspell_inline_checker_text_buffer_new (buffer);
309 _gspell_inline_checker_text_buffer_set_unit_test_mode (inline_checker, TRUE);
310
311 gtk_text_buffer_get_start_iter (buffer, &iter);
312 insert_text_one_char_at_a_time (buffer, &iter, "Hella");
313 check_highlighted_words (buffer, inline_checker, -1);
314
315 gtk_text_buffer_insert (buffer, &iter, " ", -1);
316 check_highlighted_words (buffer,
317 inline_checker,
318 0, 5,
319 -1);
320
321 gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
322 check_highlighted_words (buffer, inline_checker, -1);
323
324 gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
325 check_highlighted_words (buffer, inline_checker, -1);
326
327 gtk_text_buffer_insert (buffer, &iter, "o", -1);
328 check_highlighted_words (buffer, inline_checker, -1);
329
330 gtk_text_buffer_insert (buffer, &iter, " ", -1);
331 check_highlighted_words (buffer, inline_checker, -1);
332
333 insert_text_one_char_at_a_time (buffer, &iter, "nrst");
334 check_highlighted_words (buffer, inline_checker, -1);
335
336 /* Cursor movement -> misspelled word highlighted. */
337 gtk_text_iter_backward_cursor_position (&iter);
338 gtk_text_buffer_place_cursor (buffer, &iter);
339
340 /* Buffer content: "Hello nrs|t".
341 * Cursor position: between 's' and 't'.
342 */
343 check_highlighted_words (buffer,
344 inline_checker,
345 6, 10,
346 -1);
347
348 /* Delete the 'e' programmatically, not at the cursor position.
349 * "Hello nrs|t" -> "Hllo nrs|t"
350 */
351 gtk_text_buffer_get_iter_at_offset (buffer, &start, 1);
352 gtk_text_buffer_get_iter_at_offset (buffer, &end, 2);
353 gtk_text_buffer_delete (buffer, &start, &end);
354 check_highlighted_words (buffer,
355 inline_checker,
356 0, 4,
357 5, 9, /* "nrst" still highlighted */
358 -1);
359
360 /* Insert 'e' programmatically, not at the cursor position.
361 * "Hllo nrs|t" -> "Hello nrs|t"
362 */
363 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
364 gtk_text_buffer_insert (buffer, &iter, "e", -1);
365 check_highlighted_words (buffer,
366 inline_checker,
367 6, 10, /* "nrst" still highlighted */
368 -1);
369
370 /* Delete "nrst" programmatically.
371 * "Hello nrs|t" -> "Hello |"
372 */
373 gtk_text_buffer_get_iter_at_offset (buffer, &start, 6);
374 gtk_text_buffer_get_iter_at_offset (buffer, &end, 10);
375 gtk_text_buffer_delete (buffer, &start, &end);
376 check_highlighted_words (buffer, inline_checker, -1);
377
378 /* Insert several chars at once at the cursor position (e.g. a paste).
379 * "Hello |" -> "Hello nrstkw|"
380 */
381 gtk_text_buffer_get_end_iter (buffer, &iter);
382 gtk_text_buffer_insert (buffer, &iter, "nrstkw", -1);
383 check_highlighted_words (buffer,
384 inline_checker,
385 6, 12,
386 -1);
387
388 /* Insert a comma to split a word in two.
389 * "Hello nrs|tkw" -> "Hello nrs,|tkw"
390 */
391 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 9);
392 gtk_text_buffer_place_cursor (buffer, &iter);
393 gtk_text_buffer_insert (buffer, &iter, ",", -1);
394 check_highlighted_words (buffer,
395 inline_checker,
396 6, 9,
397 10, 13, /* "tkw" also highlighted */
398 -1);
399
400 /* Delete selection.
401 * " H|el|llo " -> " H|llo "
402 */
403 gtk_text_buffer_set_text (buffer, " Helllo ", -1);
404 gtk_text_buffer_get_iter_at_offset (buffer, &start, 2);
405 gtk_text_buffer_get_iter_at_offset (buffer, &end, 4);
406 gtk_text_buffer_select_range (buffer, &start, &end);
407 gtk_text_buffer_delete (buffer, &start, &end);
408 check_highlighted_words (buffer,
409 inline_checker,
410 1, 5,
411 -1);
412
413 /* Backspace at end of word.
414 * " Hllo |" -> " Hllo|"
415 */
416 gtk_text_buffer_get_end_iter (buffer, &iter);
417 gtk_text_buffer_place_cursor (buffer, &iter);
418 gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
419 check_highlighted_words (buffer, inline_checker, -1);
420
421 /* Backspace before a word.
422 * " |Hllo" -> "|Hllo"
423 */
424 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 1);
425 gtk_text_buffer_place_cursor (buffer, &iter);
426 gtk_text_buffer_backspace (buffer, &iter, TRUE, TRUE);
427 check_highlighted_words (buffer,
428 inline_checker,
429 0, 4,
430 -1);
431
432 /* Delete at beginning of word.
433 * "| Hllo " -> "|Hllo "
434 */
435 gtk_text_buffer_set_text (buffer, " Hllo ", -1);
436 gtk_text_buffer_get_start_iter (buffer, &start);
437 gtk_text_buffer_get_iter_at_offset (buffer, &end, 1);
438 gtk_text_buffer_place_cursor (buffer, &start);
439 gtk_text_buffer_delete (buffer, &start, &end);
440 check_highlighted_words (buffer, inline_checker, -1);
441
442 /* Delete after a word.
443 * "Hllo| " -> "Hllo|"
444 */
445 gtk_text_buffer_get_iter_at_offset (buffer, &start, 4);
446 gtk_text_buffer_get_end_iter (buffer, &end);
447 gtk_text_buffer_place_cursor (buffer, &start);
448 gtk_text_buffer_delete (buffer, &start, &end);
449 check_highlighted_words (buffer,
450 inline_checker,
451 0, 4,
452 -1);
453
454 g_object_unref (inline_checker);
455 g_object_unref (buffer);
456 }
457
458 static void
459 test_apostrophes (void)
460 {
461 GtkTextBuffer *buffer;
462 GspellInlineCheckerTextBuffer *inline_checker;
463 GtkTextIter iter;
464 GtkTextIter start;
465 GtkTextIter end;
466
467 buffer = create_buffer ();
468 inline_checker = _gspell_inline_checker_text_buffer_new (buffer);
469 _gspell_inline_checker_text_buffer_set_unit_test_mode (inline_checker, TRUE);
470
471 gtk_text_buffer_set_text (buffer, "jlvd't ", -1);
472 check_highlighted_words (buffer,
473 inline_checker,
474 0, 6,
475 -1);
476
477 /* Delete the 't'.
478 * Note that the apostrophe is no longer highlighted.
479 * This works because we connect to the ::delete-range signal with and
480 * without the AFTER flag, to get the broader word boundaries.
481 */
482 gtk_text_buffer_get_iter_at_offset (buffer, &start, 5);
483 gtk_text_buffer_get_iter_at_offset (buffer, &end, 6);
484 gtk_text_buffer_delete (buffer, &start, &end);
485 check_highlighted_words (buffer,
486 inline_checker,
487 0, 4,
488 -1);
489
490 gtk_text_buffer_set_text (buffer, "jlvd't ", -1);
491 check_highlighted_words (buffer,
492 inline_checker,
493 0, 6,
494 -1);
495
496 /* Insert a space after the apostrophe.
497 * Note that the apostrophe is no longer highlighted.
498 * This works because we connect to the ::insert-text signal with and
499 * without the AFTER flag, to get the broader word boundaries.
500 */
501 gtk_text_buffer_get_iter_at_offset (buffer, &iter, 5);
502 gtk_text_buffer_insert (buffer, &iter, " ", -1);
503 check_highlighted_words (buffer,
504 inline_checker,
505 0, 4,
506 -1);
507
508 g_object_unref (inline_checker);
509 g_object_unref (buffer);
510 }
511
512 gint
513 main (gint argc,
514 gchar **argv)
515 {
516 gtk_test_init (&argc, &argv);
517
518 g_test_add_func ("/inline-checker-text-buffer/whole-buffer",
519 test_whole_buffer);
520
521 g_test_add_func ("/inline-checker-text-buffer/text-insertion",
522 test_text_insertion);
523
524 g_test_add_func ("/inline-checker-text-buffer/text-deletion",
525 test_text_deletion);
526
527 g_test_add_func ("/inline-checker-text-buffer/current-word",
528 test_current_word);
529
530 g_test_add_func ("/inline-checker-text-buffer/apostrophes",
531 test_apostrophes);
532
533 return g_test_run ();
534 }