1 /* Extensive GtkTreeStore tests.
2 * Copyright (C) 2007 Imendio AB
3 * Authors: Kristian Rietveld <kris@imendio.com>
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser 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 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19 /* To do:
20 * - All the to do items from liststore.c, plus:
21 * - Finish up the insertion tests; things aren't as nicely refactored
22 * here as in GtkListStore, so we need to check for corner cases on
23 * all insertion functions separately.
24 * - We only test in the root level, we also need all tests "duplicated"
25 * for child levels.
26 * - And we also need tests for creating these child levels, etc.
27 */
28
29 #include "treemodel.h"
30
31 #include <gtk/gtk.h>
32
33 static inline gboolean
iters_equal(GtkTreeIter * a,GtkTreeIter * b)34 iters_equal (GtkTreeIter *a,
35 GtkTreeIter *b)
36 {
37 if (a->stamp != b->stamp)
38 return FALSE;
39
40 if (a->user_data != b->user_data)
41 return FALSE;
42
43 /* user_data2 and user_data3 are not used in GtkTreeStore */
44
45 return TRUE;
46 }
47
48 static gboolean
iter_position(GtkTreeStore * store,GtkTreeIter * iter,int n)49 iter_position (GtkTreeStore *store,
50 GtkTreeIter *iter,
51 int n)
52 {
53 gboolean ret = TRUE;
54 GtkTreePath *path;
55
56 path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), iter);
57 if (!path)
58 return FALSE;
59
60 if (gtk_tree_path_get_indices (path)[0] != n)
61 ret = FALSE;
62
63 gtk_tree_path_free (path);
64
65 return ret;
66 }
67
68 /*
69 * Fixture
70 */
71 typedef struct
72 {
73 GtkTreeIter iter[5];
74 GtkTreeStore *store;
75 } TreeStore;
76
77 static void
tree_store_setup(TreeStore * fixture,gconstpointer test_data)78 tree_store_setup (TreeStore *fixture,
79 gconstpointer test_data)
80 {
81 int i;
82
83 fixture->store = gtk_tree_store_new (1, G_TYPE_INT);
84
85 for (i = 0; i < 5; i++)
86 {
87 gtk_tree_store_insert (fixture->store, &fixture->iter[i], NULL, i);
88 gtk_tree_store_set (fixture->store, &fixture->iter[i], 0, i, -1);
89 }
90 }
91
92 static void
tree_store_teardown(TreeStore * fixture,gconstpointer test_data)93 tree_store_teardown (TreeStore *fixture,
94 gconstpointer test_data)
95 {
96 g_object_unref (fixture->store);
97 }
98
99 /*
100 * The actual tests.
101 */
102
103 static void
check_model(TreeStore * fixture,int * new_order,int skip)104 check_model (TreeStore *fixture,
105 int *new_order,
106 int skip)
107 {
108 int i;
109 GtkTreePath *path;
110
111 path = gtk_tree_path_new ();
112 gtk_tree_path_down (path);
113
114 /* Check validity of the model and validity of the iters-persistent
115 * claim.
116 */
117 for (i = 0; i < 5; i++)
118 {
119 GtkTreeIter iter;
120
121 if (i == skip)
122 continue;
123
124 /* The saved iterator at new_order[i] should match the iterator
125 * at i.
126 */
127
128 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
129 &iter, path);
130
131 g_assert_true (gtk_tree_store_iter_is_valid (fixture->store, &iter));
132 g_assert_true (iters_equal (&iter, &fixture->iter[new_order[i]]));
133
134 gtk_tree_path_next (path);
135 }
136
137 gtk_tree_path_free (path);
138 }
139
140 /* insertion */
141 static void
tree_store_test_insert_high_values(void)142 tree_store_test_insert_high_values (void)
143 {
144 GtkTreeIter iter, iter2;
145 GtkTreeIter iter_copy;
146 GtkTreeStore *store;
147
148 store = gtk_tree_store_new (1, G_TYPE_INT);
149
150 gtk_tree_store_insert (store, &iter, NULL, 1234);
151 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter));
152 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 1);
153 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
154 g_assert_true (iters_equal (&iter, &iter_copy));
155 g_assert_true (iter_position (store, &iter, 0));
156
157 gtk_tree_store_insert (store, &iter2, NULL, 765);
158 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter2));
159 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 2);
160
161 /* Walk over the model */
162 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
163 g_assert_true (iters_equal (&iter, &iter_copy));
164 g_assert_true (iter_position (store, &iter, 0));
165
166 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
167 g_assert_true (iters_equal (&iter2, &iter_copy));
168 g_assert_true (iter_position (store, &iter2, 1));
169
170 g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
171
172 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 1));
173 g_assert_true (iters_equal (&iter2, &iter_copy));
174 g_assert_true (iter_position (store, &iter2, 1));
175
176 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
177 g_assert_true (iters_equal (&iter, &iter_copy));
178 g_assert_true (iter_position (store, &iter, 0));
179
180 g_assert_false (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
181
182 g_object_unref (store);
183 }
184
185 static void
tree_store_test_append(void)186 tree_store_test_append (void)
187 {
188 GtkTreeIter iter, iter2;
189 GtkTreeIter iter_copy;
190 GtkTreeStore *store;
191
192 store = gtk_tree_store_new (1, G_TYPE_INT);
193
194 gtk_tree_store_append (store, &iter, NULL);
195 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter));
196 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 1);
197 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
198 g_assert_true (iters_equal (&iter, &iter_copy));
199 g_assert_true (iter_position (store, &iter, 0));
200
201 gtk_tree_store_append (store, &iter2, NULL);
202 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter2));
203 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 2);
204
205 /* Walk over the model */
206 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
207 g_assert_true (iters_equal (&iter, &iter_copy));
208 g_assert_true (iter_position (store, &iter, 0));
209
210 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
211 g_assert_true (iters_equal (&iter2, &iter_copy));
212 g_assert_true (iter_position (store, &iter2, 1));
213
214 g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
215
216 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 1));
217 g_assert_true (iters_equal (&iter2, &iter_copy));
218 g_assert_true (iter_position (store, &iter2, 1));
219
220 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
221 g_assert_true (iters_equal (&iter, &iter_copy));
222 g_assert_true (iter_position (store, &iter, 0));
223
224 g_assert_false (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
225
226 g_object_unref (store);
227 }
228
229 static void
tree_store_test_prepend(void)230 tree_store_test_prepend (void)
231 {
232 GtkTreeIter iter, iter2;
233 GtkTreeIter iter_copy;
234 GtkTreeStore *store;
235
236 store = gtk_tree_store_new (1, G_TYPE_INT);
237
238 gtk_tree_store_prepend (store, &iter, NULL);
239 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter));
240 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 1);
241 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
242 g_assert_true (iters_equal (&iter, &iter_copy));
243 g_assert_true (iter_position (store, &iter, 0));
244
245 gtk_tree_store_prepend (store, &iter2, NULL);
246 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter2));
247 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 2);
248
249 /* Walk over the model */
250 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
251 g_assert_true (iters_equal (&iter2, &iter_copy));
252 g_assert_true (iter_position (store, &iter2, 0));
253
254 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
255 g_assert_true (iters_equal (&iter, &iter_copy));
256 g_assert_true (iter_position (store, &iter, 1));
257
258 g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
259
260 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 1));
261 g_assert_true (iters_equal (&iter, &iter_copy));
262 g_assert_true (iter_position (store, &iter, 1));
263
264 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
265 g_assert_true (iters_equal (&iter2, &iter_copy));
266 g_assert_true (iter_position (store, &iter2, 0));
267
268 g_assert_false (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
269
270 g_object_unref (store);
271 }
272
273 static void
tree_store_test_insert_after(void)274 tree_store_test_insert_after (void)
275 {
276 GtkTreeIter iter, iter2, iter3;
277 GtkTreeIter iter_copy;
278 GtkTreeStore *store;
279
280 store = gtk_tree_store_new (1, G_TYPE_INT);
281
282 gtk_tree_store_append (store, &iter, NULL);
283 gtk_tree_store_append (store, &iter2, NULL);
284
285 gtk_tree_store_insert_after (store, &iter3, NULL, &iter);
286 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter3));
287 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 3);
288 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 1));
289 g_assert_true (iters_equal (&iter3, &iter_copy));
290 g_assert_true (iter_position (store, &iter3, 1));
291
292 /* Walk over the model */
293 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
294 g_assert_true (iters_equal (&iter, &iter_copy));
295 g_assert_true (iter_position (store, &iter_copy, 0));
296
297 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
298 g_assert_true (iters_equal (&iter3, &iter_copy));
299 g_assert_true (iter_position (store, &iter_copy, 1));
300
301 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
302 g_assert_true (iters_equal (&iter2, &iter_copy));
303 g_assert_true (iter_position (store, &iter_copy, 2));
304
305 g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
306
307 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 2));
308 g_assert_true (iters_equal (&iter2, &iter_copy));
309 g_assert_true (iter_position (store, &iter2, 2));
310
311 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
312 g_assert_true (iters_equal (&iter3, &iter_copy));
313 g_assert_true (iter_position (store, &iter3, 1));
314
315 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
316 g_assert_true (iters_equal (&iter, &iter_copy));
317 g_assert_true (iter_position (store, &iter, 0));
318
319 g_assert_false (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
320
321 g_object_unref (store);
322 }
323
324 static void
tree_store_test_insert_after_NULL(void)325 tree_store_test_insert_after_NULL (void)
326 {
327 GtkTreeIter iter, iter2;
328 GtkTreeIter iter_copy;
329 GtkTreeStore *store;
330
331 store = gtk_tree_store_new (1, G_TYPE_INT);
332
333 gtk_tree_store_append (store, &iter, NULL);
334
335 /* move_after NULL is basically a prepend */
336 gtk_tree_store_insert_after (store, &iter2, NULL, NULL);
337 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter2));
338 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 2);
339
340 /* Walk over the model */
341 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
342 g_assert_true (iters_equal (&iter2, &iter_copy));
343 g_assert_true (iter_position (store, &iter2, 0));
344
345 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
346 g_assert_true (iters_equal (&iter, &iter_copy));
347 g_assert_true (iter_position (store, &iter, 1));
348
349 g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
350
351 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 0));
352 g_assert_true (iters_equal (&iter2, &iter_copy));
353
354 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 1));
355 g_assert_true (iters_equal (&iter, &iter_copy));
356 g_assert_true (iter_position (store, &iter, 1));
357
358 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
359 g_assert_true (iters_equal (&iter2, &iter_copy));
360 g_assert_true (iter_position (store, &iter2, 0));
361
362 g_assert_false (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
363
364 g_object_unref (store);
365 }
366
367 static void
tree_store_test_insert_before(void)368 tree_store_test_insert_before (void)
369 {
370 GtkTreeIter iter, iter2, iter3;
371 GtkTreeIter iter_copy;
372 GtkTreeStore *store;
373
374 store = gtk_tree_store_new (1, G_TYPE_INT);
375
376 gtk_tree_store_append (store, &iter, NULL);
377 gtk_tree_store_append (store, &iter2, NULL);
378
379 gtk_tree_store_insert_before (store, &iter3, NULL, &iter2);
380 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter3));
381 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 3);
382 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 1));
383 g_assert_true (iters_equal (&iter3, &iter_copy));
384 g_assert_true (iter_position (store, &iter3, 1));
385
386 /* Walk over the model */
387 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
388 g_assert_true (iters_equal (&iter, &iter_copy));
389 g_assert_true (iter_position (store, &iter_copy, 0));
390
391 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
392 g_assert_true (iters_equal (&iter3, &iter_copy));
393 g_assert_true (iter_position (store, &iter_copy, 1));
394
395 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
396 g_assert_true (iters_equal (&iter2, &iter_copy));
397 g_assert_true (iter_position (store, &iter_copy, 2));
398
399 g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
400
401 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 1));
402 g_assert_true (iters_equal (&iter3, &iter_copy));
403
404 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 2));
405 g_assert_true (iters_equal (&iter2, &iter_copy));
406 g_assert_true (iter_position (store, &iter2, 2));
407
408 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
409 g_assert_true (iters_equal (&iter3, &iter_copy));
410 g_assert_true (iter_position (store, &iter3, 1));
411
412 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
413 g_assert_true (iters_equal (&iter, &iter_copy));
414 g_assert_true (iter_position (store, &iter, 0));
415
416 g_assert_false (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
417
418 g_object_unref (store);
419 }
420
421 static void
tree_store_test_insert_before_NULL(void)422 tree_store_test_insert_before_NULL (void)
423 {
424 GtkTreeIter iter, iter2;
425 GtkTreeIter iter_copy;
426 GtkTreeStore *store;
427
428 store = gtk_tree_store_new (1, G_TYPE_INT);
429
430 gtk_tree_store_append (store, &iter, NULL);
431
432 /* move_before NULL is basically an append */
433 gtk_tree_store_insert_before (store, &iter2, NULL, NULL);
434 g_assert_true (gtk_tree_store_iter_is_valid (store, &iter2));
435 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), NULL), ==, 2);
436
437 /* Walk over the model */
438 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter_copy));
439 g_assert_true (iters_equal (&iter, &iter_copy));
440 g_assert_true (iter_position (store, &iter, 0));
441
442 g_assert_true (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
443 g_assert_true (iters_equal (&iter2, &iter_copy));
444 g_assert_true (iter_position (store, &iter2, 1));
445
446 g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter_copy));
447
448 g_assert_true (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter_copy, NULL, 1));
449 g_assert_true (iters_equal (&iter2, &iter_copy));
450 g_assert_true (iter_position (store, &iter2, 1));
451
452 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
453 g_assert_true (iters_equal (&iter, &iter_copy));
454 g_assert_true (iter_position (store, &iter, 0));
455
456 g_assert_false (gtk_tree_model_iter_previous (GTK_TREE_MODEL (store), &iter_copy));
457
458 g_object_unref (store);
459 }
460
461 /* setting values */
462 static void
tree_store_set_gvalue_to_transform(void)463 tree_store_set_gvalue_to_transform (void)
464 {
465 GtkTreeStore *store;
466 GtkTreeIter iter;
467 GValue value = G_VALUE_INIT;
468
469 /* https://bugzilla.gnome.org/show_bug.cgi?id=677649 */
470 store = gtk_tree_store_new (1, G_TYPE_LONG);
471 gtk_tree_store_append (store, &iter, NULL);
472
473 g_value_init (&value, G_TYPE_INT);
474 g_value_set_int (&value, 42);
475 gtk_tree_store_set_value (store, &iter, 0, &value);
476 }
477
478 /* removal */
479 static void
tree_store_test_remove_begin(TreeStore * fixture,gconstpointer user_data)480 tree_store_test_remove_begin (TreeStore *fixture,
481 gconstpointer user_data)
482 {
483 int new_order[5] = { -1, 1, 2, 3, 4 };
484 GtkTreePath *path;
485 GtkTreeIter iter;
486
487 /* Remove node at 0 */
488 path = gtk_tree_path_new_from_indices (0, -1);
489 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &iter, path);
490 gtk_tree_path_free (path);
491
492 g_assert_true (gtk_tree_store_remove (fixture->store, &iter) == TRUE);
493 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &fixture->iter[0]));
494 g_assert_true (iters_equal (&iter, &fixture->iter[1]));
495
496 check_model (fixture, new_order, 0);
497 }
498
499 static void
tree_store_test_remove_middle(TreeStore * fixture,gconstpointer user_data)500 tree_store_test_remove_middle (TreeStore *fixture,
501 gconstpointer user_data)
502 {
503 int new_order[5] = { 0, 1, -1, 3, 4 };
504 GtkTreePath *path;
505 GtkTreeIter iter;
506
507 /* Remove node at 2 */
508 path = gtk_tree_path_new_from_indices (2, -1);
509 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &iter, path);
510 gtk_tree_path_free (path);
511
512 g_assert_true (gtk_tree_store_remove (fixture->store, &iter));
513 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &fixture->iter[2]));
514 g_assert_true (iters_equal (&iter, &fixture->iter[3]));
515
516 check_model (fixture, new_order, 2);
517 }
518
519 static void
tree_store_test_remove_end(TreeStore * fixture,gconstpointer user_data)520 tree_store_test_remove_end (TreeStore *fixture,
521 gconstpointer user_data)
522 {
523 int new_order[5] = { 0, 1, 2, 3, -1 };
524 GtkTreePath *path;
525 GtkTreeIter iter;
526
527 /* Remove node at 4 */
528 path = gtk_tree_path_new_from_indices (4, -1);
529 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &iter, path);
530 gtk_tree_path_free (path);
531
532 g_assert_false (gtk_tree_store_remove (fixture->store, &iter));
533 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &fixture->iter[4]));
534
535 check_model (fixture, new_order, 4);
536 }
537
538 static void
tree_store_test_clear(TreeStore * fixture,gconstpointer user_data)539 tree_store_test_clear (TreeStore *fixture,
540 gconstpointer user_data)
541 {
542 int i;
543
544 gtk_tree_store_clear (fixture->store);
545
546 g_assert_cmpint (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (fixture->store), NULL), ==, 0);
547
548 for (i = 0; i < 5; i++)
549 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &fixture->iter[i]));
550 }
551
552 /* reorder */
553
554 static void
tree_store_test_reorder(TreeStore * fixture,gconstpointer user_data)555 tree_store_test_reorder (TreeStore *fixture,
556 gconstpointer user_data)
557 {
558 int new_order[5] = { 4, 1, 0, 2, 3 };
559
560 gtk_tree_store_reorder (fixture->store, NULL, new_order);
561 check_model (fixture, new_order, -1);
562 }
563
564 /* swapping */
565
566 static void
tree_store_test_swap_begin(TreeStore * fixture,gconstpointer user_data)567 tree_store_test_swap_begin (TreeStore *fixture,
568 gconstpointer user_data)
569 {
570 /* We swap nodes 0 and 1 at the beginning */
571 int new_order[5] = { 1, 0, 2, 3, 4 };
572
573 GtkTreeIter iter_a;
574 GtkTreeIter iter_b;
575
576 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_a, "0"));
577 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_b, "1"));
578
579 gtk_tree_store_swap (fixture->store, &iter_a, &iter_b);
580 check_model (fixture, new_order, -1);
581 }
582
583 static void
tree_store_test_swap_middle_next(TreeStore * fixture,gconstpointer user_data)584 tree_store_test_swap_middle_next (TreeStore *fixture,
585 gconstpointer user_data)
586 {
587 /* We swap nodes 2 and 3 in the middle that are next to each other */
588 int new_order[5] = { 0, 1, 3, 2, 4 };
589
590 GtkTreeIter iter_a;
591 GtkTreeIter iter_b;
592
593 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_a, "2"));
594 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_b, "3"));
595
596 gtk_tree_store_swap (fixture->store, &iter_a, &iter_b);
597 check_model (fixture, new_order, -1);
598 }
599
600 static void
tree_store_test_swap_middle_apart(TreeStore * fixture,gconstpointer user_data)601 tree_store_test_swap_middle_apart (TreeStore *fixture,
602 gconstpointer user_data)
603 {
604 /* We swap nodes 1 and 3 in the middle that are apart from each other */
605 int new_order[5] = { 0, 3, 2, 1, 4 };
606
607 GtkTreeIter iter_a;
608 GtkTreeIter iter_b;
609
610 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_a, "1"));
611 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_b, "3"));
612
613 gtk_tree_store_swap (fixture->store, &iter_a, &iter_b);
614 check_model (fixture, new_order, -1);
615 }
616
617 static void
tree_store_test_swap_end(TreeStore * fixture,gconstpointer user_data)618 tree_store_test_swap_end (TreeStore *fixture,
619 gconstpointer user_data)
620 {
621 /* We swap nodes 3 and 4 at the end */
622 int new_order[5] = { 0, 1, 2, 4, 3 };
623
624 GtkTreeIter iter_a;
625 GtkTreeIter iter_b;
626
627 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_a, "3"));
628 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_b, "4"));
629
630 gtk_tree_store_swap (fixture->store, &iter_a, &iter_b);
631 check_model (fixture, new_order, -1);
632 }
633
634 static void
tree_store_test_swap_single(void)635 tree_store_test_swap_single (void)
636 {
637 GtkTreeIter iter;
638 GtkTreeIter iter_copy;
639 GtkTreeStore *store;
640
641 store = gtk_tree_store_new (1, G_TYPE_INT);
642
643 /* Check if swap on a store with a single node does not corrupt
644 * the store.
645 */
646
647 gtk_tree_store_append (store, &iter, NULL);
648 iter_copy = iter;
649
650 gtk_tree_store_swap (store, &iter, &iter);
651 g_assert_true (iters_equal (&iter, &iter_copy));
652 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
653 g_assert_true (iters_equal (&iter, &iter_copy));
654
655 g_object_unref (store);
656 }
657
658 /* move after */
659
660 static void
tree_store_test_move_after_from_start(TreeStore * fixture,gconstpointer user_data)661 tree_store_test_move_after_from_start (TreeStore *fixture,
662 gconstpointer user_data)
663 {
664 /* We move node 0 after 2 */
665 int new_order[5] = { 1, 2, 0, 3, 4 };
666
667 GtkTreeIter iter;
668 GtkTreeIter position;
669
670 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "0"));
671 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "2"));
672
673 gtk_tree_store_move_after (fixture->store, &iter, &position);
674 check_model (fixture, new_order, -1);
675 }
676
677 static void
tree_store_test_move_after_next(TreeStore * fixture,gconstpointer user_data)678 tree_store_test_move_after_next (TreeStore *fixture,
679 gconstpointer user_data)
680 {
681 /* We move node 2 after 3 */
682 int new_order[5] = { 0, 1, 3, 2, 4 };
683
684 GtkTreeIter iter;
685 GtkTreeIter position;
686
687 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
688 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "3"));
689
690 gtk_tree_store_move_after (fixture->store, &iter, &position);
691 check_model (fixture, new_order, -1);
692 }
693
694 static void
tree_store_test_move_after_apart(TreeStore * fixture,gconstpointer user_data)695 tree_store_test_move_after_apart (TreeStore *fixture,
696 gconstpointer user_data)
697 {
698 /* We move node 1 after 3 */
699 int new_order[5] = { 0, 2, 3, 1, 4 };
700
701 GtkTreeIter iter;
702 GtkTreeIter position;
703
704 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "1"));
705 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "3"));
706
707 gtk_tree_store_move_after (fixture->store, &iter, &position);
708 check_model (fixture, new_order, -1);
709 }
710
711 static void
tree_store_test_move_after_end(TreeStore * fixture,gconstpointer user_data)712 tree_store_test_move_after_end (TreeStore *fixture,
713 gconstpointer user_data)
714 {
715 /* We move node 2 after 4 */
716 int new_order[5] = { 0, 1, 3, 4, 2 };
717
718 GtkTreeIter iter;
719 GtkTreeIter position;
720
721 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
722 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "4"));
723
724 gtk_tree_store_move_after (fixture->store, &iter, &position);
725 check_model (fixture, new_order, -1);
726 }
727
728 static void
tree_store_test_move_after_from_end(TreeStore * fixture,gconstpointer user_data)729 tree_store_test_move_after_from_end (TreeStore *fixture,
730 gconstpointer user_data)
731 {
732 /* We move node 4 after 1 */
733 int new_order[5] = { 0, 1, 4, 2, 3 };
734
735 GtkTreeIter iter;
736 GtkTreeIter position;
737
738 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "4"));
739 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "1"));
740
741 gtk_tree_store_move_after (fixture->store, &iter, &position);
742 check_model (fixture, new_order, -1);
743 }
744
745 static void
tree_store_test_move_after_change_ends(TreeStore * fixture,gconstpointer user_data)746 tree_store_test_move_after_change_ends (TreeStore *fixture,
747 gconstpointer user_data)
748 {
749 /* We move 0 after 4, this will cause both the head and tail ends to
750 * change.
751 */
752 int new_order[5] = { 1, 2, 3, 4, 0 };
753
754 GtkTreeIter iter;
755 GtkTreeIter position;
756
757 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "0"));
758 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "4"));
759
760 gtk_tree_store_move_after (fixture->store, &iter, &position);
761 check_model (fixture, new_order, -1);
762 }
763
764 static void
tree_store_test_move_after_NULL(TreeStore * fixture,gconstpointer user_data)765 tree_store_test_move_after_NULL (TreeStore *fixture,
766 gconstpointer user_data)
767 {
768 /* We move node 2, NULL should prepend */
769 int new_order[5] = { 2, 0, 1, 3, 4 };
770
771 GtkTreeIter iter;
772
773 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
774
775 gtk_tree_store_move_after (fixture->store, &iter, NULL);
776 check_model (fixture, new_order, -1);
777 }
778
779 static void
tree_store_test_move_after_single(void)780 tree_store_test_move_after_single (void)
781 {
782 GtkTreeIter iter;
783 GtkTreeIter iter_copy;
784 GtkTreeStore *store;
785
786 store = gtk_tree_store_new (1, G_TYPE_INT);
787
788 /* Check if move-after on a store with a single node does not corrupt
789 * the store.
790 */
791
792 gtk_tree_store_append (store, &iter, NULL);
793 iter_copy = iter;
794
795 gtk_tree_store_move_after (store, &iter, NULL);
796 g_assert_true (iters_equal (&iter, &iter_copy));
797 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
798 g_assert_true (iters_equal (&iter, &iter_copy));
799
800 gtk_tree_store_move_after (store, &iter, &iter);
801 g_assert_true (iters_equal (&iter, &iter_copy));
802 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
803 g_assert_true (iters_equal (&iter, &iter_copy));
804
805 g_object_unref (store);
806 }
807
808 /* move before */
809
810 static void
tree_store_test_move_before_next(TreeStore * fixture,gconstpointer user_data)811 tree_store_test_move_before_next (TreeStore *fixture,
812 gconstpointer user_data)
813 {
814 /* We move node 3 before 2 */
815 int new_order[5] = { 0, 1, 3, 2, 4 };
816
817 GtkTreeIter iter;
818 GtkTreeIter position;
819
820 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "3"));
821 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "2"));
822
823 gtk_tree_store_move_before (fixture->store, &iter, &position);
824 check_model (fixture, new_order, -1);
825 }
826
827 static void
tree_store_test_move_before_apart(TreeStore * fixture,gconstpointer user_data)828 tree_store_test_move_before_apart (TreeStore *fixture,
829 gconstpointer user_data)
830 {
831 /* We move node 1 before 3 */
832 int new_order[5] = { 0, 2, 1, 3, 4 };
833
834 GtkTreeIter iter;
835 GtkTreeIter position;
836
837 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "1"));
838 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "3"));
839
840 gtk_tree_store_move_before (fixture->store, &iter, &position);
841 check_model (fixture, new_order, -1);
842 }
843
844 static void
tree_store_test_move_before_to_start(TreeStore * fixture,gconstpointer user_data)845 tree_store_test_move_before_to_start (TreeStore *fixture,
846 gconstpointer user_data)
847 {
848 /* We move node 2 before 0 */
849 int new_order[5] = { 2, 0, 1, 3, 4 };
850
851 GtkTreeIter iter;
852 GtkTreeIter position;
853
854 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
855 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "0"));
856
857 gtk_tree_store_move_before (fixture->store, &iter, &position);
858 check_model (fixture, new_order, -1);
859 }
860
861 static void
tree_store_test_move_before_from_end(TreeStore * fixture,gconstpointer user_data)862 tree_store_test_move_before_from_end (TreeStore *fixture,
863 gconstpointer user_data)
864 {
865 /* We move node 4 before 2 (replace end) */
866 int new_order[5] = { 0, 1, 4, 2, 3 };
867
868 GtkTreeIter iter;
869 GtkTreeIter position;
870
871 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "4"));
872 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "2"));
873
874 gtk_tree_store_move_before (fixture->store, &iter, &position);
875 check_model (fixture, new_order, -1);
876 }
877
878 static void
tree_store_test_move_before_change_ends(TreeStore * fixture,gconstpointer user_data)879 tree_store_test_move_before_change_ends (TreeStore *fixture,
880 gconstpointer user_data)
881 {
882 /* We move node 4 before 0 */
883 int new_order[5] = { 4, 0, 1, 2, 3 };
884
885 GtkTreeIter iter;
886 GtkTreeIter position;
887
888 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "4"));
889 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "0"));
890
891 gtk_tree_store_move_before (fixture->store, &iter, &position);
892 check_model (fixture, new_order, -1);
893 }
894
895 static void
tree_store_test_move_before_NULL(TreeStore * fixture,gconstpointer user_data)896 tree_store_test_move_before_NULL (TreeStore *fixture,
897 gconstpointer user_data)
898 {
899 /* We move node 2, NULL should append */
900 int new_order[5] = { 0, 1, 3, 4, 2 };
901
902 GtkTreeIter iter;
903
904 g_assert_true (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
905
906 gtk_tree_store_move_before (fixture->store, &iter, NULL);
907 check_model (fixture, new_order, -1);
908 }
909
910 static void
tree_store_test_move_before_single(void)911 tree_store_test_move_before_single (void)
912 {
913 GtkTreeIter iter;
914 GtkTreeIter iter_copy;
915 GtkTreeStore *store;
916
917 store = gtk_tree_store_new (1, G_TYPE_INT);
918
919 /* Check if move-after on a store with a single node does not corrupt
920 * the store.
921 */
922
923 gtk_tree_store_append (store, &iter, NULL);
924 iter_copy = iter;
925
926 gtk_tree_store_move_before (store, &iter, NULL);
927 g_assert_true (iters_equal (&iter, &iter_copy));
928 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
929 g_assert_true (iters_equal (&iter, &iter_copy));
930
931 gtk_tree_store_move_before (store, &iter, &iter);
932 g_assert_true (iters_equal (&iter, &iter_copy));
933 g_assert_true (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
934 g_assert_true (iters_equal (&iter, &iter_copy));
935
936 g_object_unref (store);
937 }
938
939
940 /* iter invalidation */
941
942 static void
tree_store_test_iter_previous_invalid(TreeStore * fixture,gconstpointer user_data)943 tree_store_test_iter_previous_invalid (TreeStore *fixture,
944 gconstpointer user_data)
945 {
946 GtkTreeIter iter;
947
948 gtk_tree_model_get_iter_first (GTK_TREE_MODEL (fixture->store), &iter);
949
950 g_assert_true (gtk_tree_model_iter_previous (GTK_TREE_MODEL (fixture->store),
951 &iter) == FALSE);
952 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &iter));
953 g_assert_cmpint (iter.stamp, ==, 0);
954 }
955
956 static void
tree_store_test_iter_next_invalid(TreeStore * fixture,gconstpointer user_data)957 tree_store_test_iter_next_invalid (TreeStore *fixture,
958 gconstpointer user_data)
959 {
960 GtkTreePath *path;
961 GtkTreeIter iter;
962
963 path = gtk_tree_path_new_from_indices (4, -1);
964 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &iter, path);
965 gtk_tree_path_free (path);
966
967 g_assert_false (gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store),
968 &iter));
969 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &iter));
970 g_assert_cmpint (iter.stamp, ==, 0);
971 }
972
973 static void
tree_store_test_iter_children_invalid(TreeStore * fixture,gconstpointer user_data)974 tree_store_test_iter_children_invalid (TreeStore *fixture,
975 gconstpointer user_data)
976 {
977 GtkTreeIter iter, child;
978
979 gtk_tree_model_get_iter_first (GTK_TREE_MODEL (fixture->store), &iter);
980 g_assert_true (gtk_tree_store_iter_is_valid (fixture->store, &iter));
981
982 g_assert_false (gtk_tree_model_iter_children (GTK_TREE_MODEL (fixture->store),
983 &child, &iter));
984 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &child));
985 g_assert_cmpint (child.stamp, ==, 0);
986 }
987
988 static void
tree_store_test_iter_nth_child_invalid(TreeStore * fixture,gconstpointer user_data)989 tree_store_test_iter_nth_child_invalid (TreeStore *fixture,
990 gconstpointer user_data)
991 {
992 GtkTreeIter iter, child;
993
994 gtk_tree_model_get_iter_first (GTK_TREE_MODEL (fixture->store), &iter);
995 g_assert_true (gtk_tree_store_iter_is_valid (fixture->store, &iter));
996
997 g_assert_false (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (fixture->store),
998 &child, &iter, 0));
999 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &child));
1000 g_assert_cmpint (child.stamp, ==, 0);
1001 }
1002
1003 static void
tree_store_test_iter_parent_invalid(TreeStore * fixture,gconstpointer user_data)1004 tree_store_test_iter_parent_invalid (TreeStore *fixture,
1005 gconstpointer user_data)
1006 {
1007 GtkTreeIter iter, child;
1008
1009 gtk_tree_model_get_iter_first (GTK_TREE_MODEL (fixture->store), &child);
1010 g_assert_true (gtk_tree_store_iter_is_valid (fixture->store, &child));
1011
1012 g_assert_false (gtk_tree_model_iter_parent (GTK_TREE_MODEL (fixture->store),
1013 &iter, &child));
1014 g_assert_false (gtk_tree_store_iter_is_valid (fixture->store, &iter));
1015 g_assert_cmpint (iter.stamp, ==, 0);
1016 }
1017
1018 /* specific bugs */
1019 static void
specific_bug_77977(void)1020 specific_bug_77977 (void)
1021 {
1022 GtkTreeStore *tree_store;
1023 GtkTreeIter iter1, iter2, iter3;
1024 GtkTreePath *path;
1025 GtkTreeRowReference *row_ref;
1026
1027 /* Stripped down version of test case for bug 77977 by Damon Chaplin */
1028
1029 /*http://bugzilla.gnome.org/show_bug.cgi?id=77977 */
1030
1031 tree_store = gtk_tree_store_new (1, G_TYPE_STRING);
1032
1033 gtk_tree_store_append (tree_store, &iter1, NULL);
1034 gtk_tree_store_set (tree_store, &iter1, 0, "Window1", -1);
1035
1036 gtk_tree_store_append (tree_store, &iter2, &iter1);
1037 gtk_tree_store_set (tree_store, &iter2, 0, "Table1", -1);
1038
1039 gtk_tree_store_append (tree_store, &iter3, &iter2);
1040 gtk_tree_store_set (tree_store, &iter3, 0, "Button1", -1);
1041
1042 path = gtk_tree_path_new_from_indices (0, 0, 0, -1);
1043 row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (tree_store), path);
1044 gtk_tree_path_free (path);
1045
1046 gtk_tree_store_remove (tree_store, &iter1);
1047
1048 gtk_tree_row_reference_free (row_ref);
1049 g_object_unref (tree_store);
1050 }
1051
1052 static GLogWriterOutput
log_writer_drop_warnings(GLogLevelFlags log_level,const GLogField * fields,gsize n_fields,gpointer user_data)1053 log_writer_drop_warnings (GLogLevelFlags log_level,
1054 const GLogField *fields,
1055 gsize n_fields,
1056 gpointer user_data)
1057 {
1058 return G_LOG_WRITER_HANDLED;
1059 }
1060
1061 static void
specific_bug_698396(void)1062 specific_bug_698396 (void)
1063 {
1064 GtkTreeStore *tree_store;
1065 int new_order[1] = { 0 };
1066
1067 /*http://bugzilla.gnome.org/show_bug.cgi?id=698396 */
1068
1069 tree_store = gtk_tree_store_new (1, G_TYPE_STRING);
1070
1071 g_log_set_writer_func (log_writer_drop_warnings, NULL, NULL);
1072 gtk_tree_store_reorder (tree_store, NULL, new_order);
1073 g_log_set_writer_func (g_log_writer_default, NULL, NULL);
1074
1075 g_object_unref (tree_store);
1076 }
1077
1078 /* main */
1079
1080 void
register_tree_store_tests(void)1081 register_tree_store_tests (void)
1082 {
1083 /* insertion */
1084 g_test_add_func ("/TreeStore/insert-high-values",
1085 tree_store_test_insert_high_values);
1086 g_test_add_func ("/TreeStore/append",
1087 tree_store_test_append);
1088 g_test_add_func ("/TreeStore/prepend",
1089 tree_store_test_prepend);
1090 g_test_add_func ("/TreeStore/insert-after",
1091 tree_store_test_insert_after);
1092 g_test_add_func ("/TreeStore/insert-after-NULL",
1093 tree_store_test_insert_after_NULL);
1094 g_test_add_func ("/TreeStore/insert-before",
1095 tree_store_test_insert_before);
1096 g_test_add_func ("/TreeStore/insert-before-NULL",
1097 tree_store_test_insert_before_NULL);
1098
1099 /* setting values (FIXME) */
1100 g_test_add_func ("/TreeStore/set-gvalue-to-transform",
1101 tree_store_set_gvalue_to_transform);
1102
1103 /* removal */
1104 g_test_add ("/TreeStore/remove-begin", TreeStore, NULL,
1105 tree_store_setup, tree_store_test_remove_begin,
1106 tree_store_teardown);
1107 g_test_add ("/TreeStore/remove-middle", TreeStore, NULL,
1108 tree_store_setup, tree_store_test_remove_middle,
1109 tree_store_teardown);
1110 g_test_add ("/TreeStore/remove-end", TreeStore, NULL,
1111 tree_store_setup, tree_store_test_remove_end,
1112 tree_store_teardown);
1113
1114 g_test_add ("/TreeStore/clear", TreeStore, NULL,
1115 tree_store_setup, tree_store_test_clear,
1116 tree_store_teardown);
1117
1118 /* reordering */
1119 g_test_add ("/TreeStore/reorder", TreeStore, NULL,
1120 tree_store_setup, tree_store_test_reorder,
1121 tree_store_teardown);
1122
1123 /* swapping */
1124 g_test_add ("/TreeStore/swap-begin", TreeStore, NULL,
1125 tree_store_setup, tree_store_test_swap_begin,
1126 tree_store_teardown);
1127 g_test_add ("/TreeStore/swap-middle-next", TreeStore, NULL,
1128 tree_store_setup, tree_store_test_swap_middle_next,
1129 tree_store_teardown);
1130 g_test_add ("/TreeStore/swap-middle-apart", TreeStore, NULL,
1131 tree_store_setup, tree_store_test_swap_middle_apart,
1132 tree_store_teardown);
1133 g_test_add ("/TreeStore/swap-end", TreeStore, NULL,
1134 tree_store_setup, tree_store_test_swap_end,
1135 tree_store_teardown);
1136 g_test_add_func ("/TreeStore/swap-single",
1137 tree_store_test_swap_single);
1138
1139 /* moving */
1140 g_test_add ("/TreeStore/move-after-from-start", TreeStore, NULL,
1141 tree_store_setup, tree_store_test_move_after_from_start,
1142 tree_store_teardown);
1143 g_test_add ("/TreeStore/move-after-next", TreeStore, NULL,
1144 tree_store_setup, tree_store_test_move_after_next,
1145 tree_store_teardown);
1146 g_test_add ("/TreeStore/move-after-apart", TreeStore, NULL,
1147 tree_store_setup, tree_store_test_move_after_apart,
1148 tree_store_teardown);
1149 g_test_add ("/TreeStore/move-after-end", TreeStore, NULL,
1150 tree_store_setup, tree_store_test_move_after_end,
1151 tree_store_teardown);
1152 g_test_add ("/TreeStore/move-after-from-end", TreeStore, NULL,
1153 tree_store_setup, tree_store_test_move_after_from_end,
1154 tree_store_teardown);
1155 g_test_add ("/TreeStore/move-after-change-ends", TreeStore, NULL,
1156 tree_store_setup, tree_store_test_move_after_change_ends,
1157 tree_store_teardown);
1158 g_test_add ("/TreeStore/move-after-NULL", TreeStore, NULL,
1159 tree_store_setup, tree_store_test_move_after_NULL,
1160 tree_store_teardown);
1161 g_test_add_func ("/TreeStore/move-after-single",
1162 tree_store_test_move_after_single);
1163
1164 g_test_add ("/TreeStore/move-before-next", TreeStore, NULL,
1165 tree_store_setup, tree_store_test_move_before_next,
1166 tree_store_teardown);
1167 g_test_add ("/TreeStore/move-before-apart", TreeStore, NULL,
1168 tree_store_setup, tree_store_test_move_before_apart,
1169 tree_store_teardown);
1170 g_test_add ("/TreeStore/move-before-to-start", TreeStore, NULL,
1171 tree_store_setup, tree_store_test_move_before_to_start,
1172 tree_store_teardown);
1173 g_test_add ("/TreeStore/move-before-from-end", TreeStore, NULL,
1174 tree_store_setup, tree_store_test_move_before_from_end,
1175 tree_store_teardown);
1176 g_test_add ("/TreeStore/move-before-change-ends", TreeStore, NULL,
1177 tree_store_setup, tree_store_test_move_before_change_ends,
1178 tree_store_teardown);
1179 g_test_add ("/TreeStore/move-before-NULL", TreeStore, NULL,
1180 tree_store_setup, tree_store_test_move_before_NULL,
1181 tree_store_teardown);
1182 g_test_add_func ("/TreeStore/move-before-single",
1183 tree_store_test_move_before_single);
1184
1185 /* iter invalidation */
1186 g_test_add ("/TreeStore/iter-prev-invalid", TreeStore, NULL,
1187 tree_store_setup, tree_store_test_iter_previous_invalid,
1188 tree_store_teardown);
1189 g_test_add ("/TreeStore/iter-next-invalid", TreeStore, NULL,
1190 tree_store_setup, tree_store_test_iter_next_invalid,
1191 tree_store_teardown);
1192 g_test_add ("/TreeStore/iter-children-invalid", TreeStore, NULL,
1193 tree_store_setup, tree_store_test_iter_children_invalid,
1194 tree_store_teardown);
1195 g_test_add ("/TreeStore/iter-nth-child-invalid", TreeStore, NULL,
1196 tree_store_setup, tree_store_test_iter_nth_child_invalid,
1197 tree_store_teardown);
1198 g_test_add ("/TreeStore/iter-parent-invalid", TreeStore, NULL,
1199 tree_store_setup, tree_store_test_iter_parent_invalid,
1200 tree_store_teardown);
1201
1202 /* specific bugs */
1203 g_test_add_func ("/TreeStore/bug-77977", specific_bug_77977);
1204 g_test_add_func ("/TreeStore/bug-698396", specific_bug_698396);
1205 }
1206