1 /* Extensive GtkTreeModelFilter tests.
2 * Copyright (C) 2009,2011 Kristian Rietveld <kris@gtk.org>
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
22 #include "treemodel.h"
23 #include "gtktreemodelrefcount.h"
26 * - Proper coverage checking to see if the unit tests cover
28 * - Check if the iterator stamp is incremented at the correct times.
30 * For more thorough testing:
31 * - Test with randomized models.
32 * - Extensively test a filter model wrapping a sort model,
33 * or a sort model wrapping a filter model by:
34 * # Checking structure.
35 * # Checking for correct signals emissions.
36 * # Checking correct reference counting.
37 * # Tests should be done with the sort and filter model
38 * in various filtering and sorting states.
46 #define LEVEL_LENGTH 5
49 create_tree_store_set_values (GtkTreeStore *store,
56 path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), iter);
57 path_string = gtk_tree_path_to_string (path);
59 gtk_tree_store_set (store, iter,
64 gtk_tree_path_free (path);
69 create_tree_store_recurse (int depth,
76 for (i = 0; i < LEVEL_LENGTH; i++)
80 gtk_tree_store_insert (store, &iter, parent, i);
81 create_tree_store_set_values (store, &iter, visible);
84 create_tree_store_recurse (depth - 1, store, &iter, visible);
89 create_tree_store (int depth,
94 store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
96 create_tree_store_recurse (depth, store, NULL, visible);
107 GtkWidget *tree_view;
110 GtkTreeModelFilter *filter;
112 SignalMonitor *monitor;
114 guint block_signals : 1;
119 filter_test_store_signal (FilterTest *fixture)
121 if (fixture->block_signals)
122 g_signal_stop_emission_by_name (fixture->store, "row-changed");
127 filter_test_setup_generic (FilterTest *fixture,
128 gconstpointer test_data,
133 const GtkTreePath *vroot = test_data;
134 GtkTreeModel *filter;
136 fixture->store = create_tree_store (depth, !empty);
138 g_signal_connect_swapped (fixture->store, "row-changed",
139 G_CALLBACK (filter_test_store_signal), fixture);
141 /* Please forgive me for casting const away. */
142 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture->store),
143 (GtkTreePath *)vroot);
144 fixture->filter = GTK_TREE_MODEL_FILTER (filter);
147 gtk_tree_model_filter_set_visible_column (fixture->filter, 1);
149 /* We need a tree view that's listening to get ref counting from that
152 fixture->tree_view = gtk_tree_view_new_with_model (filter);
154 fixture->monitor = signal_monitor_new (filter);
158 filter_test_setup_expand_root (FilterTest *fixture)
163 path = gtk_tree_path_new_from_indices (0, -1);
165 for (i = 0; i < LEVEL_LENGTH; i++)
167 gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view),
169 gtk_tree_path_next (path);
171 gtk_tree_path_free (path);
175 filter_test_setup (FilterTest *fixture,
176 gconstpointer test_data)
178 filter_test_setup_generic (fixture, test_data, 3, FALSE, FALSE);
182 filter_test_setup_empty (FilterTest *fixture,
183 gconstpointer test_data)
185 filter_test_setup_generic (fixture, test_data, 3, TRUE, FALSE);
189 filter_test_setup_unfiltered (FilterTest *fixture,
190 gconstpointer test_data)
192 filter_test_setup_generic (fixture, test_data, 3, FALSE, TRUE);
196 filter_test_setup_unfiltered_root_expanded (FilterTest *fixture,
197 gconstpointer test_data)
199 filter_test_setup_unfiltered (fixture, test_data);
200 filter_test_setup_expand_root (fixture);
204 filter_test_setup_empty_unfiltered (FilterTest *fixture,
205 gconstpointer test_data)
207 filter_test_setup_generic (fixture, test_data, 3, TRUE, TRUE);
211 filter_test_setup_empty_unfiltered_root_expanded (FilterTest *fixture,
212 gconstpointer test_data)
214 filter_test_setup_empty_unfiltered (fixture, test_data);
215 filter_test_setup_expand_root (fixture);
219 strip_virtual_root (GtkTreePath *path,
220 GtkTreePath *root_path)
222 GtkTreePath *real_path;
227 int depth = gtk_tree_path_get_depth (path);
228 int root_depth = gtk_tree_path_get_depth (root_path);
230 real_path = gtk_tree_path_new ();
232 for (j = 0; j < depth - root_depth; j++)
233 gtk_tree_path_append_index (real_path,
234 gtk_tree_path_get_indices (path)[root_depth + j]);
237 real_path = gtk_tree_path_copy (path);
243 count_visible (FilterTest *fixture,
244 GtkTreePath *store_path)
250 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
253 for (i = 0; i < LEVEL_LENGTH; i++)
257 gtk_tree_model_get (GTK_TREE_MODEL (fixture->store), &iter,
269 filter_test_append_refilter_signals_recurse (FilterTest *fixture,
270 GtkTreePath *store_path,
271 GtkTreePath *filter_path,
273 GtkTreePath *root_path)
276 int rows_deleted = 0;
279 gtk_tree_path_down (store_path);
280 gtk_tree_path_down (filter_path);
282 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
285 for (i = 0; i < LEVEL_LENGTH; i++)
288 GtkTreePath *real_path;
290 gtk_tree_model_get (GTK_TREE_MODEL (fixture->store), &iter,
295 (!gtk_tree_path_is_descendant (store_path, root_path)
296 || !gtk_tree_path_compare (store_path, root_path)))
298 if (!gtk_tree_path_compare (store_path, root_path))
301 && gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store),
304 GtkTreePath *store_copy;
305 GtkTreePath *filter_copy;
307 store_copy = gtk_tree_path_copy (store_path);
308 filter_copy = gtk_tree_path_copy (filter_path);
309 filter_test_append_refilter_signals_recurse (fixture,
314 gtk_tree_path_free (store_copy);
315 gtk_tree_path_free (filter_copy);
319 gtk_tree_path_next (store_path);
320 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
323 gtk_tree_path_next (filter_path);
328 real_path = strip_virtual_root (filter_path, root_path);
332 /* This row will be inserted */
333 signal_monitor_append_signal_path (fixture->monitor, ROW_CHANGED,
336 if (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store),
339 signal_monitor_append_signal_path (fixture->monitor,
340 ROW_HAS_CHILD_TOGGLED,
345 GtkTreePath *store_copy;
346 GtkTreePath *filter_copy;
348 store_copy = gtk_tree_path_copy (store_path);
349 filter_copy = gtk_tree_path_copy (filter_path);
350 filter_test_append_refilter_signals_recurse (fixture,
355 gtk_tree_path_free (store_copy);
356 gtk_tree_path_free (filter_copy);
360 GtkTreePath *tmp_path;
362 /* If all child rows are invisible, then the last row to
363 * become invisible will emit row-has-child-toggled on the
367 tmp_path = gtk_tree_path_copy (store_path);
368 gtk_tree_path_append_index (tmp_path, 0);
370 if (count_visible (fixture, tmp_path) == 0)
371 signal_monitor_append_signal_path (fixture->monitor,
372 ROW_HAS_CHILD_TOGGLED,
375 gtk_tree_path_free (tmp_path);
379 gtk_tree_path_next (filter_path);
383 /* This row will be deleted */
385 signal_monitor_append_signal_path (fixture->monitor, ROW_DELETED,
389 gtk_tree_path_free (real_path);
391 gtk_tree_path_next (store_path);
392 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
395 if (rows_deleted == LEVEL_LENGTH
396 && gtk_tree_path_get_depth (filter_path) > 1)
398 GtkTreePath *real_path;
400 gtk_tree_path_up (store_path);
401 gtk_tree_path_up (filter_path);
403 /* A row-has-child-toggled will be emitted on the parent */
406 && gtk_tree_path_is_descendant (store_path, root_path)
407 && gtk_tree_path_compare (store_path, root_path)))
409 real_path = strip_virtual_root (filter_path, root_path);
410 signal_monitor_append_signal_path (fixture->monitor,
411 ROW_HAS_CHILD_TOGGLED,
414 gtk_tree_path_free (real_path);
420 filter_test_append_refilter_signals (FilterTest *fixture,
423 /* A special function that walks the tree store like the
424 * model validation functions below.
427 GtkTreePath *filter_path;
429 path = gtk_tree_path_new ();
430 filter_path = gtk_tree_path_new ();
431 filter_test_append_refilter_signals_recurse (fixture,
436 gtk_tree_path_free (path);
437 gtk_tree_path_free (filter_path);
441 filter_test_append_refilter_signals_with_vroot (FilterTest *fixture,
443 GtkTreePath *root_path)
445 /* A special function that walks the tree store like the
446 * model validation functions below.
449 GtkTreePath *filter_path;
451 path = gtk_tree_path_new ();
452 filter_path = gtk_tree_path_new ();
453 filter_test_append_refilter_signals_recurse (fixture,
458 gtk_tree_path_free (path);
459 gtk_tree_path_free (filter_path);
463 filter_test_enable_filter (FilterTest *fixture)
465 gtk_tree_model_filter_set_visible_column (fixture->filter, 1);
466 gtk_tree_model_filter_refilter (fixture->filter);
470 filter_test_block_signals (FilterTest *fixture)
472 fixture->block_signals = TRUE;
476 filter_test_unblock_signals (FilterTest *fixture)
478 fixture->block_signals = FALSE;
482 filter_test_teardown (FilterTest *fixture,
483 gconstpointer test_data)
485 signal_monitor_free (fixture->monitor);
487 gtk_widget_destroy (fixture->tree_view);
489 g_object_unref (fixture->filter);
490 g_object_unref (fixture->store);
494 * Model structure validation
498 check_filter_model_recurse (FilterTest *fixture,
499 GtkTreePath *store_parent_path,
500 GtkTreePath *filter_parent_path)
503 GtkTreeIter store_iter;
504 GtkTreeIter filter_iter;
505 gboolean store_has_next, filter_has_next;
507 gtk_tree_path_down (store_parent_path);
508 gtk_tree_path_down (filter_parent_path);
510 store_has_next = gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
511 &store_iter, store_parent_path);
512 filter_has_next = gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->filter),
513 &filter_iter, filter_parent_path);
515 for (i = 0; i < LEVEL_LENGTH; i++)
519 g_return_if_fail (store_has_next == TRUE);
521 gtk_tree_model_get (GTK_TREE_MODEL (fixture->store),
529 gchar *filter_str, *store_str;
531 g_return_if_fail (filter_has_next == TRUE);
534 tmp = gtk_tree_model_get_path (GTK_TREE_MODEL (fixture->filter),
536 g_return_if_fail (gtk_tree_path_compare (tmp, filter_parent_path) == 0);
538 /* Verify model content */
539 gtk_tree_model_get (GTK_TREE_MODEL (fixture->store),
543 gtk_tree_model_get (GTK_TREE_MODEL (fixture->filter),
548 g_return_if_fail (g_strcmp0 (store_str, filter_str) == 0);
553 if (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->filter),
556 g_return_if_fail (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store), &store_iter));
558 check_filter_model_recurse (fixture,
559 gtk_tree_path_copy (store_parent_path),
563 /* Only when we do not recurse we need to free tmp */
564 gtk_tree_path_free (tmp);
566 gtk_tree_path_next (filter_parent_path);
567 filter_has_next = gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->filter), &filter_iter);
570 gtk_tree_path_next (store_parent_path);
571 store_has_next = gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &store_iter);
574 /* Both models should have no more content! */
575 g_return_if_fail (store_has_next == FALSE);
576 g_return_if_fail (filter_has_next == FALSE);
578 gtk_tree_path_free (store_parent_path);
579 gtk_tree_path_free (filter_parent_path);
583 check_filter_model (FilterTest *fixture)
587 if (fixture->monitor)
588 signal_monitor_assert_is_empty (fixture->monitor);
590 path = gtk_tree_path_new ();
592 check_filter_model_recurse (fixture, path, gtk_tree_path_copy (path));
596 check_filter_model_with_root (FilterTest *fixture,
599 if (fixture->monitor)
600 signal_monitor_assert_is_empty (fixture->monitor);
602 check_filter_model_recurse (fixture,
603 gtk_tree_path_copy (path),
604 gtk_tree_path_new ());
610 check_level_length (GtkTreeModelFilter *filter,
612 const int expected_length)
618 model_length = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (filter), NULL);
619 g_assert_cmpint (model_length, ==, expected_length);
624 gboolean retrieved_iter = FALSE;
627 retrieved_iter = gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (filter),
629 g_return_if_fail (retrieved_iter);
630 model_length = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (filter), &iter);
631 g_assert_cmpint (model_length, ==, expected_length);
636 set_path_visibility (FilterTest *fixture,
640 GtkTreeIter store_iter;
642 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
644 gtk_tree_store_set (fixture->store, &store_iter,
651 insert_path_with_visibility (FilterTest *fixture,
652 const gchar *path_string,
657 GtkTreeIter parent, iter;
659 path = gtk_tree_path_new_from_string (path_string);
660 position = gtk_tree_path_get_indices (path)[gtk_tree_path_get_depth (path)];
661 gtk_tree_path_up (path);
663 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &parent, path))
665 gtk_tree_store_insert (fixture->store, &iter, &parent, position);
666 create_tree_store_set_values (fixture->store, &iter, visible);
668 gtk_tree_path_free (path);
677 verify_test_suite (FilterTest *fixture,
678 gconstpointer user_data)
680 check_filter_model (fixture);
684 verify_test_suite_vroot (FilterTest *fixture,
685 gconstpointer user_data)
687 check_filter_model_with_root (fixture, (GtkTreePath *)user_data);
692 filled_hide_root_level (FilterTest *fixture,
693 gconstpointer user_data)
695 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "2");
696 set_path_visibility (fixture, "2", FALSE);
697 check_filter_model (fixture);
698 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
700 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
701 set_path_visibility (fixture, "0", FALSE);
702 check_filter_model (fixture);
703 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
705 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "2");
706 set_path_visibility (fixture, "4", FALSE);
707 check_filter_model (fixture);
708 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 3);
712 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
713 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
715 set_path_visibility (fixture, "1", FALSE);
716 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 4);
718 set_path_visibility (fixture, "3", FALSE);
719 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 5);
721 check_filter_model (fixture);
724 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
725 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
726 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "1");
727 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "1");
729 set_path_visibility (fixture, "1", TRUE);
730 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 4);
732 set_path_visibility (fixture, "3", TRUE);
733 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 3);
735 check_filter_model (fixture);
739 filled_hide_child_levels (FilterTest *fixture,
740 gconstpointer user_data)
742 set_path_visibility (fixture, "0:2", FALSE);
743 check_filter_model (fixture);
744 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
745 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 1);
747 set_path_visibility (fixture, "0:4", FALSE);
748 check_filter_model (fixture);
749 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
750 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
752 set_path_visibility (fixture, "0:4:3", FALSE);
753 check_filter_model (fixture);
754 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
755 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
757 set_path_visibility (fixture, "0:4:0", FALSE);
758 set_path_visibility (fixture, "0:4:1", FALSE);
759 set_path_visibility (fixture, "0:4:2", FALSE);
760 set_path_visibility (fixture, "0:4:4", FALSE);
761 check_filter_model (fixture);
762 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
763 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
765 /* Since "0:2" is hidden, "0:4" must be "0:3" in the filter model */
766 set_path_visibility (fixture, "0:4", TRUE);
767 check_filter_model (fixture);
768 check_level_length (fixture->filter, "0:3", 0);
770 set_path_visibility (fixture, "0:2", TRUE);
771 check_filter_model (fixture);
772 check_level_length (fixture->filter, "0:2", LEVEL_LENGTH);
773 check_level_length (fixture->filter, "0:3", LEVEL_LENGTH);
774 check_level_length (fixture->filter, "0:4", 0);
776 /* Once 0:4:0 got inserted, 0:4 became a parent. Because 0:4 is
777 * not visible, not signals are emitted.
779 set_path_visibility (fixture, "0:4:2", TRUE);
780 set_path_visibility (fixture, "0:4:4", TRUE);
781 signal_monitor_assert_is_empty (fixture->monitor);
782 check_level_length (fixture->filter, "0:4", 2);
786 filled_hide_child_levels_root_expanded (FilterTest *fixture,
787 gconstpointer user_data)
791 path = gtk_tree_path_new_from_indices (0, -1);
792 gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), path, FALSE);
793 gtk_tree_path_free (path);
795 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0:2");
796 set_path_visibility (fixture, "0:2", FALSE);
797 check_filter_model (fixture);
798 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
799 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 1);
801 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0:3");
802 set_path_visibility (fixture, "0:4", FALSE);
803 check_filter_model (fixture);
804 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
805 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
807 set_path_visibility (fixture, "0:4:3", FALSE);
808 check_filter_model (fixture);
809 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
810 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
812 set_path_visibility (fixture, "0:4:0", FALSE);
813 set_path_visibility (fixture, "0:4:1", FALSE);
814 set_path_visibility (fixture, "0:4:2", FALSE);
815 set_path_visibility (fixture, "0:4:4", FALSE);
816 check_filter_model (fixture);
817 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
818 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
820 /* Since "0:2" is hidden, "0:4" must be "0:3" in the filter model */
821 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0:3");
822 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:3");
823 set_path_visibility (fixture, "0:4", TRUE);
824 check_filter_model (fixture);
825 check_level_length (fixture->filter, "0:3", 0);
827 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0:2");
828 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:2");
829 set_path_visibility (fixture, "0:2", TRUE);
830 check_filter_model (fixture);
831 check_level_length (fixture->filter, "0:2", LEVEL_LENGTH);
832 check_level_length (fixture->filter, "0:3", LEVEL_LENGTH);
833 check_level_length (fixture->filter, "0:4", 0);
835 /* has-child-toggled for 0:4 is required. */
836 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:4");
837 set_path_visibility (fixture, "0:4:2", TRUE);
838 set_path_visibility (fixture, "0:4:4", TRUE);
839 signal_monitor_assert_is_empty (fixture->monitor);
840 check_level_length (fixture->filter, "0:4", 2);
845 filled_vroot_hide_root_level (FilterTest *fixture,
846 gconstpointer user_data)
848 GtkTreePath *path = (GtkTreePath *)user_data;
850 /* These changes do not affect the filter's root level */
851 set_path_visibility (fixture, "0", FALSE);
852 check_filter_model_with_root (fixture, path);
853 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
854 check_level_length (fixture->filter, "0", LEVEL_LENGTH);
856 set_path_visibility (fixture, "4", FALSE);
857 check_filter_model_with_root (fixture, path);
858 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
859 check_level_length (fixture->filter, "0", LEVEL_LENGTH);
861 /* Even though we set the virtual root parent node to FALSE,
862 * the virtual root contents remain.
864 set_path_visibility (fixture, "2", FALSE);
865 check_filter_model_with_root (fixture, path);
866 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
867 check_level_length (fixture->filter, "0", LEVEL_LENGTH);
870 set_path_visibility (fixture, "1", FALSE);
871 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
872 check_level_length (fixture->filter, "0", LEVEL_LENGTH);
874 set_path_visibility (fixture, "3", FALSE);
875 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
876 check_level_length (fixture->filter, "0", LEVEL_LENGTH);
878 check_filter_model_with_root (fixture, path);
881 set_path_visibility (fixture, "2", TRUE);
882 check_filter_model_with_root (fixture, path);
883 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
884 check_level_length (fixture->filter, "0", LEVEL_LENGTH);
886 set_path_visibility (fixture, "1", TRUE);
887 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
888 check_level_length (fixture->filter, "0", LEVEL_LENGTH);
890 set_path_visibility (fixture, "3", TRUE);
891 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
892 check_level_length (fixture->filter, "0", LEVEL_LENGTH);
894 check_filter_model_with_root (fixture, path);
896 /* Now test changes in the virtual root level */
897 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "2");
898 set_path_visibility (fixture, "2:2", FALSE);
899 check_filter_model_with_root (fixture, path);
900 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
902 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "3");
903 set_path_visibility (fixture, "2:4", FALSE);
904 check_filter_model_with_root (fixture, path);
905 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
907 set_path_visibility (fixture, "1:4", FALSE);
908 check_filter_model_with_root (fixture, path);
909 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
911 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "3");
912 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "3");
913 set_path_visibility (fixture, "2:4", TRUE);
914 check_filter_model_with_root (fixture, path);
915 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
917 set_path_visibility (fixture, "2", FALSE);
918 check_filter_model_with_root (fixture, path);
919 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
921 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
922 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
923 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
924 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
925 set_path_visibility (fixture, "2:0", FALSE);
926 set_path_visibility (fixture, "2:1", FALSE);
927 set_path_visibility (fixture, "2:2", FALSE);
928 set_path_visibility (fixture, "2:3", FALSE);
929 set_path_visibility (fixture, "2:4", FALSE);
930 check_filter_model_with_root (fixture, path);
931 check_level_length (fixture->filter, NULL, 0);
933 set_path_visibility (fixture, "2", TRUE);
934 check_filter_model_with_root (fixture, path);
935 check_level_length (fixture->filter, NULL, 0);
937 set_path_visibility (fixture, "1:4", FALSE);
938 check_filter_model_with_root (fixture, path);
939 check_level_length (fixture->filter, NULL, 0);
941 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
942 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
943 set_path_visibility (fixture, "2:4", TRUE);
944 check_filter_model_with_root (fixture, path);
945 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 4);
947 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
948 set_path_visibility (fixture, "2:4", FALSE);
949 check_filter_model_with_root (fixture, path);
950 check_level_length (fixture->filter, NULL, 0);
952 set_path_visibility (fixture, "2", FALSE);
953 check_filter_model_with_root (fixture, path);
954 check_level_length (fixture->filter, NULL, 0);
956 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
957 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
958 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "1");
959 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "1");
960 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "2");
961 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
962 set_path_visibility (fixture, "2:0", TRUE);
963 set_path_visibility (fixture, "2:1", TRUE);
964 set_path_visibility (fixture, "2:2", TRUE);
965 check_filter_model_with_root (fixture, path);
966 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
968 set_path_visibility (fixture, "2", TRUE);
969 check_filter_model_with_root (fixture, path);
970 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
974 filled_vroot_hide_child_levels (FilterTest *fixture,
975 gconstpointer user_data)
977 GtkTreePath *path = (GtkTreePath *)user_data;
979 set_path_visibility (fixture, "2:0:2", FALSE);
980 check_filter_model_with_root (fixture, path);
981 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
982 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 1);
984 set_path_visibility (fixture, "2:0:4", FALSE);
985 check_filter_model_with_root (fixture, path);
986 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
987 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
989 set_path_visibility (fixture, "2:0:4:3", FALSE);
990 check_filter_model_with_root (fixture, path);
991 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
992 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
994 set_path_visibility (fixture, "2:0:4:0", FALSE);
995 set_path_visibility (fixture, "2:0:4:1", FALSE);
996 set_path_visibility (fixture, "2:0:4:2", FALSE);
997 set_path_visibility (fixture, "2:0:4:4", FALSE);
998 check_filter_model_with_root (fixture, path);
999 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1000 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1002 /* Since "0:2" is hidden, "0:4" must be "0:3" in the filter model */
1003 set_path_visibility (fixture, "2:0:4", TRUE);
1004 check_filter_model_with_root (fixture, path);
1005 check_level_length (fixture->filter, "0:3", 0);
1007 set_path_visibility (fixture, "2:0:2", TRUE);
1008 check_filter_model_with_root (fixture, path);
1009 check_level_length (fixture->filter, "0:2", LEVEL_LENGTH);
1010 check_level_length (fixture->filter, "0:3", LEVEL_LENGTH);
1011 check_level_length (fixture->filter, "0:4", 0);
1013 /* Once 0:4:0 got inserted, 0:4 became a parent. However, 0:4 is not
1014 * visible, so no signal should be emitted.
1016 set_path_visibility (fixture, "2:0:4:2", TRUE);
1017 set_path_visibility (fixture, "2:0:4:4", TRUE);
1018 check_level_length (fixture->filter, "0:4", 2);
1019 signal_monitor_assert_is_empty (fixture->monitor);
1023 filled_vroot_hide_child_levels_root_expanded (FilterTest *fixture,
1024 gconstpointer user_data)
1026 GtkTreePath *path = (GtkTreePath *)user_data;
1027 GtkTreePath *tmp_path;
1029 tmp_path = gtk_tree_path_new_from_indices (0, -1);
1030 gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), tmp_path, FALSE);
1031 gtk_tree_path_free (tmp_path);
1033 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0:2");
1034 set_path_visibility (fixture, "2:0:2", FALSE);
1035 check_filter_model_with_root (fixture, path);
1036 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1037 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 1);
1039 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0:3");
1040 set_path_visibility (fixture, "2:0:4", FALSE);
1041 check_filter_model_with_root (fixture, path);
1042 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1043 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1045 set_path_visibility (fixture, "2:0:4:3", FALSE);
1046 check_filter_model_with_root (fixture, path);
1047 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1048 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1050 set_path_visibility (fixture, "2:0:4:0", FALSE);
1051 set_path_visibility (fixture, "2:0:4:1", FALSE);
1052 set_path_visibility (fixture, "2:0:4:2", FALSE);
1053 set_path_visibility (fixture, "2:0:4:4", FALSE);
1054 check_filter_model_with_root (fixture, path);
1055 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1056 check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1058 /* Since "0:2" is hidden, "0:4" must be "0:3" in the filter model */
1059 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0:3");
1060 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:3");
1061 set_path_visibility (fixture, "2:0:4", TRUE);
1062 check_filter_model_with_root (fixture, path);
1063 check_level_length (fixture->filter, "0:3", 0);
1065 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0:2");
1066 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:2");
1067 set_path_visibility (fixture, "2:0:2", TRUE);
1068 check_filter_model_with_root (fixture, path);
1069 check_level_length (fixture->filter, "0:2", LEVEL_LENGTH);
1070 check_level_length (fixture->filter, "0:3", LEVEL_LENGTH);
1071 check_level_length (fixture->filter, "0:4", 0);
1073 /* Once 0:4:0 got inserted, 0:4 became a parent */
1074 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:4");
1075 set_path_visibility (fixture, "2:0:4:2", TRUE);
1076 set_path_visibility (fixture, "2:0:4:4", TRUE);
1077 check_level_length (fixture->filter, "0:4", 2);
1078 signal_monitor_assert_is_empty (fixture->monitor);
1082 empty_show_nodes (FilterTest *fixture,
1083 gconstpointer user_data)
1085 check_filter_model (fixture);
1086 check_level_length (fixture->filter, NULL, 0);
1088 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1089 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1090 set_path_visibility (fixture, "3", TRUE);
1091 check_filter_model (fixture);
1092 check_level_length (fixture->filter, NULL, 1);
1093 check_level_length (fixture->filter, "0", 0);
1095 set_path_visibility (fixture, "3:2:2", TRUE);
1096 check_filter_model (fixture);
1097 check_level_length (fixture->filter, NULL, 1);
1098 check_level_length (fixture->filter, "0", 0);
1100 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1101 set_path_visibility (fixture, "3:2", TRUE);
1102 check_filter_model (fixture);
1103 check_level_length (fixture->filter, NULL, 1);
1104 check_level_length (fixture->filter, "0", 1);
1105 check_level_length (fixture->filter, "0:0", 1);
1106 check_level_length (fixture->filter, "0:0:0", 0);
1108 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1109 set_path_visibility (fixture, "3", FALSE);
1110 check_filter_model (fixture);
1111 check_level_length (fixture->filter, NULL, 0);
1113 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1114 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1115 set_path_visibility (fixture, "3:2:1", TRUE);
1116 set_path_visibility (fixture, "3", TRUE);
1117 check_filter_model (fixture);
1118 check_level_length (fixture->filter, NULL, 1);
1119 check_level_length (fixture->filter, "0", 1);
1120 check_level_length (fixture->filter, "0:0", 2);
1121 check_level_length (fixture->filter, "0:0:0", 0);
1125 empty_show_multiple_nodes (FilterTest *fixture,
1126 gconstpointer user_data)
1129 GtkTreePath *changed_path;
1131 check_filter_model (fixture);
1132 check_level_length (fixture->filter, NULL, 0);
1134 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1135 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1136 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "1");
1137 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "1");
1139 /* We simulate a change in visible func condition with this. The
1140 * visibility state of multiple nodes changes at once, we emit row-changed
1141 * for these nodes (and others) after that.
1143 filter_test_block_signals (fixture);
1144 set_path_visibility (fixture, "3", TRUE);
1145 set_path_visibility (fixture, "4", TRUE);
1146 filter_test_unblock_signals (fixture);
1148 changed_path = gtk_tree_path_new ();
1149 gtk_tree_path_append_index (changed_path, 2);
1150 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
1151 &iter, changed_path);
1152 /* Invisible node - so no signals expected */
1153 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1154 changed_path, &iter);
1156 gtk_tree_path_next (changed_path);
1157 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1158 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1159 changed_path, &iter);
1161 gtk_tree_path_next (changed_path);
1162 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1163 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1164 changed_path, &iter);
1166 gtk_tree_path_free (changed_path);
1168 check_filter_model (fixture);
1169 check_level_length (fixture->filter, NULL, 2);
1170 check_level_length (fixture->filter, "0", 0);
1172 set_path_visibility (fixture, "3:2:2", TRUE);
1173 check_filter_model (fixture);
1174 check_level_length (fixture->filter, NULL, 2);
1175 check_level_length (fixture->filter, "0", 0);
1177 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1178 set_path_visibility (fixture, "3:2", TRUE);
1179 check_filter_model (fixture);
1180 check_level_length (fixture->filter, NULL, 2);
1181 check_level_length (fixture->filter, "0", 1);
1182 check_level_length (fixture->filter, "0:0", 1);
1183 check_level_length (fixture->filter, "0:0:0", 0);
1185 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1186 set_path_visibility (fixture, "3", FALSE);
1187 check_filter_model (fixture);
1188 check_level_length (fixture->filter, NULL, 1);
1190 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1191 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1192 set_path_visibility (fixture, "3:2:1", TRUE);
1193 set_path_visibility (fixture, "3", TRUE);
1194 check_filter_model (fixture);
1195 check_level_length (fixture->filter, NULL, 2);
1196 check_level_length (fixture->filter, "0", 1);
1197 check_level_length (fixture->filter, "0:0", 2);
1198 check_level_length (fixture->filter, "0:0:0", 0);
1202 empty_vroot_show_nodes (FilterTest *fixture,
1203 gconstpointer user_data)
1205 GtkTreePath *path = (GtkTreePath *)user_data;
1207 check_filter_model_with_root (fixture, path);
1208 check_level_length (fixture->filter, NULL, 0);
1210 set_path_visibility (fixture, "2", TRUE);
1211 check_filter_model_with_root (fixture, path);
1212 check_level_length (fixture->filter, NULL, 0);
1214 set_path_visibility (fixture, "2:2:2", TRUE);
1215 check_filter_model_with_root (fixture, path);
1216 check_level_length (fixture->filter, NULL, 0);
1218 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1219 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1220 set_path_visibility (fixture, "2:2", TRUE);
1221 check_filter_model_with_root (fixture, path);
1222 check_level_length (fixture->filter, NULL, 1);
1223 check_level_length (fixture->filter, "0", 1);
1224 check_level_length (fixture->filter, "0:0", 0);
1226 set_path_visibility (fixture, "3", TRUE);
1227 check_filter_model_with_root (fixture, path);
1228 check_level_length (fixture->filter, NULL, 1);
1230 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1231 set_path_visibility (fixture, "2:2", FALSE);
1232 check_filter_model_with_root (fixture, path);
1233 check_level_length (fixture->filter, NULL, 0);
1235 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1236 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1237 set_path_visibility (fixture, "2:2:1", TRUE);
1238 set_path_visibility (fixture, "2:2", TRUE);
1239 check_filter_model_with_root (fixture, path);
1240 check_level_length (fixture->filter, NULL, 1);
1241 check_level_length (fixture->filter, "0", 2);
1242 check_level_length (fixture->filter, "0:1", 0);
1246 empty_vroot_show_multiple_nodes (FilterTest *fixture,
1247 gconstpointer user_data)
1250 GtkTreePath *changed_path;
1251 GtkTreePath *path = (GtkTreePath *)user_data;
1253 check_filter_model_with_root (fixture, path);
1254 check_level_length (fixture->filter, NULL, 0);
1256 /* We simulate a change in visible func condition with this. The
1257 * visibility state of multiple nodes changes at once, we emit row-changed
1258 * for these nodes (and others) after that.
1260 filter_test_block_signals (fixture);
1261 set_path_visibility (fixture, "2", TRUE);
1262 set_path_visibility (fixture, "3", TRUE);
1263 filter_test_unblock_signals (fixture);
1265 changed_path = gtk_tree_path_new ();
1266 gtk_tree_path_append_index (changed_path, 1);
1267 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
1268 &iter, changed_path);
1269 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1270 changed_path, &iter);
1272 gtk_tree_path_next (changed_path);
1273 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1274 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1275 changed_path, &iter);
1277 gtk_tree_path_next (changed_path);
1278 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1279 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1280 changed_path, &iter);
1282 gtk_tree_path_next (changed_path);
1283 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1284 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1285 changed_path, &iter);
1287 gtk_tree_path_free (changed_path);
1289 check_filter_model_with_root (fixture, path);
1290 check_level_length (fixture->filter, NULL, 0);
1292 set_path_visibility (fixture, "2:2:2", TRUE);
1293 check_filter_model_with_root (fixture, path);
1294 check_level_length (fixture->filter, NULL, 0);
1296 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1297 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1298 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "1");
1299 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "1");
1301 /* Again, we simulate a call to refilter */
1302 filter_test_block_signals (fixture);
1303 set_path_visibility (fixture, "2:2", TRUE);
1304 set_path_visibility (fixture, "2:3", TRUE);
1305 filter_test_unblock_signals (fixture);
1307 changed_path = gtk_tree_path_new ();
1308 gtk_tree_path_append_index (changed_path, 2);
1309 gtk_tree_path_append_index (changed_path, 1);
1310 gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
1311 &iter, changed_path);
1312 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1313 changed_path, &iter);
1315 gtk_tree_path_next (changed_path);
1316 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1317 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1318 changed_path, &iter);
1320 gtk_tree_path_next (changed_path);
1321 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1322 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1323 changed_path, &iter);
1325 gtk_tree_path_next (changed_path);
1326 gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1327 gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1328 changed_path, &iter);
1330 gtk_tree_path_free (changed_path);
1332 check_filter_model_with_root (fixture, path);
1333 check_level_length (fixture->filter, NULL, 2);
1334 check_level_length (fixture->filter, "0", 1);
1335 check_level_length (fixture->filter, "0:0", 0);
1337 set_path_visibility (fixture, "3", TRUE);
1338 check_filter_model_with_root (fixture, path);
1339 check_level_length (fixture->filter, NULL, 2);
1341 signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1342 set_path_visibility (fixture, "2:2", FALSE);
1343 check_filter_model_with_root (fixture, path);
1344 check_level_length (fixture->filter, NULL, 1);
1346 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1347 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1348 set_path_visibility (fixture, "2:2:1", TRUE);
1349 set_path_visibility (fixture, "2:2", TRUE);
1350 check_filter_model_with_root (fixture, path);
1351 check_level_length (fixture->filter, NULL, 2);
1352 check_level_length (fixture->filter, "0", 2);
1353 check_level_length (fixture->filter, "0:1", 0);
1358 unfiltered_hide_single (FilterTest *fixture,
1359 gconstpointer user_data)
1362 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1363 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1364 set_path_visibility (fixture, "2", FALSE);
1366 signal_monitor_assert_is_empty (fixture->monitor);
1367 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1369 /* The view only shows the root level, so we only expect signals
1370 * for the root level.
1372 filter_test_append_refilter_signals (fixture, 1);
1373 filter_test_enable_filter (fixture);
1375 check_filter_model (fixture);
1376 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1380 unfiltered_hide_single_root_expanded (FilterTest *fixture,
1381 gconstpointer user_data)
1384 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1385 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1386 set_path_visibility (fixture, "2", FALSE);
1388 signal_monitor_assert_is_empty (fixture->monitor);
1389 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1391 filter_test_append_refilter_signals (fixture, 2);
1392 filter_test_enable_filter (fixture);
1394 check_filter_model (fixture);
1395 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1399 unfiltered_hide_single_child (FilterTest *fixture,
1400 gconstpointer user_data)
1403 /* This row is not shown, so its signal is not propagated */
1404 set_path_visibility (fixture, "2:2", FALSE);
1406 signal_monitor_assert_is_empty (fixture->monitor);
1407 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1408 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1410 /* The view only shows the root level, so we only expect signals
1411 * for the root level.
1413 filter_test_append_refilter_signals (fixture, 0);
1414 filter_test_enable_filter (fixture);
1416 check_filter_model (fixture);
1417 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1418 check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1422 unfiltered_hide_single_child_root_expanded (FilterTest *fixture,
1423 gconstpointer user_data)
1426 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1427 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1428 set_path_visibility (fixture, "2:2", FALSE);
1430 signal_monitor_assert_is_empty (fixture->monitor);
1431 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1432 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1434 filter_test_append_refilter_signals (fixture, 2);
1435 filter_test_enable_filter (fixture);
1437 check_filter_model (fixture);
1438 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1439 check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1443 unfiltered_hide_single_multi_level (FilterTest *fixture,
1444 gconstpointer user_data)
1447 /* This row is not shown, so its signal is not propagated */
1448 set_path_visibility (fixture, "2:2:2", FALSE);
1450 /* This row is not shown, so its signal is not propagated */
1451 set_path_visibility (fixture, "2:2", FALSE);
1453 signal_monitor_assert_is_empty (fixture->monitor);
1454 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1455 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1456 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1458 /* The view only shows the root level, so we only expect signals
1459 * for the root level.
1461 filter_test_append_refilter_signals (fixture, 1);
1462 filter_test_enable_filter (fixture);
1464 check_filter_model (fixture);
1465 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1466 check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1468 set_path_visibility (fixture, "2:2", TRUE);
1470 check_filter_model (fixture);
1471 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1472 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1473 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH - 1);
1477 unfiltered_hide_single_multi_level_root_expanded (FilterTest *fixture,
1478 gconstpointer user_data)
1481 /* This row is not shown, so its signal is not propagated */
1482 set_path_visibility (fixture, "2:2:2", FALSE);
1484 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1485 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1486 set_path_visibility (fixture, "2:2", FALSE);
1488 signal_monitor_assert_is_empty (fixture->monitor);
1489 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1490 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1491 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1493 filter_test_append_refilter_signals (fixture, 2);
1494 filter_test_enable_filter (fixture);
1496 check_filter_model (fixture);
1497 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1498 check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1500 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "2:2");
1501 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1502 set_path_visibility (fixture, "2:2", TRUE);
1504 check_filter_model (fixture);
1505 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1506 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1507 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH - 1);
1513 unfiltered_vroot_hide_single (FilterTest *fixture,
1514 gconstpointer user_data)
1517 GtkTreePath *path = (GtkTreePath *)user_data;
1519 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1520 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1521 set_path_visibility (fixture, "2:2", FALSE);
1523 signal_monitor_assert_is_empty (fixture->monitor);
1524 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1526 /* The view only shows the root level, so we only expect signals
1527 * for the root level. (Though for the depth argument, we have to
1528 * take the virtual root into account).
1530 filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1531 filter_test_enable_filter (fixture);
1533 check_filter_model_with_root (fixture, path);
1534 check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1538 unfiltered_vroot_hide_single_child (FilterTest *fixture,
1539 gconstpointer user_data)
1542 GtkTreePath *path = (GtkTreePath *)user_data;
1544 /* Not visible, so no signal will be received. */
1545 set_path_visibility (fixture, "2:2:2", FALSE);
1547 signal_monitor_assert_is_empty (fixture->monitor);
1548 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1549 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1551 /* The view only shows the root level, so we only expect signals
1552 * for the root level. (Though for the depth argument, we have to
1553 * take the virtual root into account).
1555 filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1556 filter_test_enable_filter (fixture);
1558 check_filter_model_with_root (fixture, path);
1559 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1560 check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1564 unfiltered_vroot_hide_single_child_root_expanded (FilterTest *fixture,
1565 gconstpointer user_data)
1568 GtkTreePath *path = (GtkTreePath *)user_data;
1570 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1571 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1572 set_path_visibility (fixture, "2:2:2", FALSE);
1574 signal_monitor_assert_is_empty (fixture->monitor);
1575 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1576 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1578 filter_test_append_refilter_signals_with_vroot (fixture, 3, path);
1579 filter_test_enable_filter (fixture);
1581 check_filter_model_with_root (fixture, path);
1582 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1583 check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1587 unfiltered_vroot_hide_single_multi_level (FilterTest *fixture,
1588 gconstpointer user_data)
1591 GtkTreePath *path = (GtkTreePath *)user_data;
1593 /* This row is not shown, so its signal is not propagated */
1594 set_path_visibility (fixture, "2:2:2:2", FALSE);
1596 /* Not shown, so no signal */
1597 set_path_visibility (fixture, "2:2:2", FALSE);
1599 signal_monitor_assert_is_empty (fixture->monitor);
1600 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1601 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1602 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1604 /* We only expect signals for the root level. The depth is 2
1605 * because we have to take the virtual root into account.
1607 filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1608 filter_test_enable_filter (fixture);
1610 check_filter_model_with_root (fixture, path);
1611 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1612 check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1614 /* Not shown, so no signal */
1615 set_path_visibility (fixture, "2:2:2", TRUE);
1617 check_filter_model_with_root (fixture, path);
1618 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1619 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1620 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH - 1);
1624 unfiltered_vroot_hide_single_multi_level_root_expanded (FilterTest *fixture,
1625 gconstpointer user_data)
1628 GtkTreePath *path = (GtkTreePath *)user_data;
1630 /* This row is not shown, so its signal is not propagated */
1631 set_path_visibility (fixture, "2:2:2:2", FALSE);
1633 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1634 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1635 set_path_visibility (fixture, "2:2:2", FALSE);
1637 signal_monitor_assert_is_empty (fixture->monitor);
1638 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1639 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1640 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1642 filter_test_append_refilter_signals_with_vroot (fixture, 3, path);
1643 filter_test_enable_filter (fixture);
1645 check_filter_model_with_root (fixture, path);
1646 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1647 check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1649 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "2:2");
1650 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1651 set_path_visibility (fixture, "2:2:2", TRUE);
1653 check_filter_model_with_root (fixture, path);
1654 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1655 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1656 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH - 1);
1660 unfiltered_show_single (FilterTest *fixture,
1661 gconstpointer user_data)
1664 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1665 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1666 set_path_visibility (fixture, "2", TRUE);
1668 signal_monitor_assert_is_empty (fixture->monitor);
1669 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1671 /* We only expect signals for the root level */
1672 filter_test_append_refilter_signals (fixture, 1);
1673 filter_test_enable_filter (fixture);
1675 check_filter_model (fixture);
1676 check_level_length (fixture->filter, NULL, 1);
1680 unfiltered_show_single_child (FilterTest *fixture,
1681 gconstpointer user_data)
1684 set_path_visibility (fixture, "2:2", TRUE);
1686 signal_monitor_assert_is_empty (fixture->monitor);
1687 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1688 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1690 /* We only expect signals for the root level */
1691 filter_test_append_refilter_signals (fixture, 1);
1692 filter_test_enable_filter (fixture);
1694 check_filter_model (fixture);
1695 check_level_length (fixture->filter, NULL, 0);
1697 /* From here we are filtered, "2" in the real model is "0" in the filter
1700 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1701 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1702 set_path_visibility (fixture, "2", TRUE);
1703 signal_monitor_assert_is_empty (fixture->monitor);
1704 check_level_length (fixture->filter, NULL, 1);
1705 check_level_length (fixture->filter, "0", 1);
1709 unfiltered_show_single_child_root_expanded (FilterTest *fixture,
1710 gconstpointer user_data)
1713 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1714 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1715 set_path_visibility (fixture, "2:2", TRUE);
1717 signal_monitor_assert_is_empty (fixture->monitor);
1718 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1719 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1721 filter_test_append_refilter_signals (fixture, 2);
1722 filter_test_enable_filter (fixture);
1724 check_filter_model (fixture);
1725 check_level_length (fixture->filter, NULL, 0);
1727 /* From here we are filtered, "2" in the real model is "0" in the filter
1730 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1731 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1732 set_path_visibility (fixture, "2", TRUE);
1733 signal_monitor_assert_is_empty (fixture->monitor);
1734 check_level_length (fixture->filter, NULL, 1);
1735 check_level_length (fixture->filter, "0", 1);
1739 unfiltered_show_single_multi_level (FilterTest *fixture,
1740 gconstpointer user_data)
1743 /* The view is not showing these rows (collapsed state), so it is not
1744 * referenced. The signal should not go through.
1746 set_path_visibility (fixture, "2:2:2", TRUE);
1747 set_path_visibility (fixture, "2:2", TRUE);
1749 signal_monitor_assert_is_empty (fixture->monitor);
1750 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1751 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1752 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1754 /* We only expect signals for the first level */
1755 filter_test_append_refilter_signals (fixture, 1);
1756 filter_test_enable_filter (fixture);
1758 check_filter_model (fixture);
1759 check_level_length (fixture->filter, NULL, 0);
1761 /* From here we are filtered, "2" in the real model is "0" in the filter
1764 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1765 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1766 set_path_visibility (fixture, "2", TRUE);
1767 check_filter_model (fixture);
1768 check_level_length (fixture->filter, NULL, 1);
1769 check_level_length (fixture->filter, "0", 1);
1770 check_level_length (fixture->filter, "0:0", 1);
1774 unfiltered_show_single_multi_level_root_expanded (FilterTest *fixture,
1775 gconstpointer user_data)
1778 /* The view is not showing this row (collapsed state), so it is not
1779 * referenced. The signal should not go through.
1781 set_path_visibility (fixture, "2:2:2", TRUE);
1783 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1784 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1785 set_path_visibility (fixture, "2:2", TRUE);
1787 signal_monitor_assert_is_empty (fixture->monitor);
1788 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1789 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1790 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1792 filter_test_append_refilter_signals (fixture, 2);
1793 filter_test_enable_filter (fixture);
1795 check_filter_model (fixture);
1796 check_level_length (fixture->filter, NULL, 0);
1798 /* From here we are filtered, "2" in the real model is "0" in the filter
1801 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1802 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1803 set_path_visibility (fixture, "2", TRUE);
1804 check_filter_model (fixture);
1805 check_level_length (fixture->filter, NULL, 1);
1806 check_level_length (fixture->filter, "0", 1);
1807 check_level_length (fixture->filter, "0:0", 1);
1811 unfiltered_vroot_show_single (FilterTest *fixture,
1812 gconstpointer user_data)
1815 GtkTreePath *path = (GtkTreePath *)user_data;
1817 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1818 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1819 set_path_visibility (fixture, "2:2", TRUE);
1821 signal_monitor_assert_is_empty (fixture->monitor);
1822 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1824 /* The view only shows the root level, so the filter model only has
1825 * the first two levels cached.
1827 filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1828 filter_test_enable_filter (fixture);
1830 check_filter_model_with_root (fixture, path);
1831 check_level_length (fixture->filter, NULL, 1);
1835 unfiltered_vroot_show_single_child (FilterTest *fixture,
1836 gconstpointer user_data)
1839 GtkTreePath *path = (GtkTreePath *)user_data;
1841 set_path_visibility (fixture, "2:2:2", TRUE);
1843 signal_monitor_assert_is_empty (fixture->monitor);
1844 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1845 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1847 /* The view only shows the root level, so the filter model only has
1848 * the first two levels cached.
1850 filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1851 filter_test_enable_filter (fixture);
1853 check_filter_model_with_root (fixture, path);
1854 check_level_length (fixture->filter, NULL, 0);
1856 /* From here we are filtered, "2" in the real model is "0" in the filter
1859 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1860 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1861 set_path_visibility (fixture, "2:2", TRUE);
1862 signal_monitor_assert_is_empty (fixture->monitor);
1863 check_level_length (fixture->filter, NULL, 1);
1864 check_level_length (fixture->filter, "0", 1);
1868 unfiltered_vroot_show_single_child_root_expanded (FilterTest *fixture,
1869 gconstpointer user_data)
1872 GtkTreePath *path = (GtkTreePath *)user_data;
1874 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1875 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1876 set_path_visibility (fixture, "2:2:2", TRUE);
1878 signal_monitor_assert_is_empty (fixture->monitor);
1879 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1880 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1882 filter_test_append_refilter_signals_with_vroot (fixture, 3, path);
1883 filter_test_enable_filter (fixture);
1885 check_filter_model_with_root (fixture, path);
1886 check_level_length (fixture->filter, NULL, 0);
1888 /* From here we are filtered, "2" in the real model is "0" in the filter
1891 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1892 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1893 set_path_visibility (fixture, "2:2", TRUE);
1894 signal_monitor_assert_is_empty (fixture->monitor);
1895 check_level_length (fixture->filter, NULL, 1);
1896 check_level_length (fixture->filter, "0", 1);
1901 unfiltered_vroot_show_single_multi_level (FilterTest *fixture,
1902 gconstpointer user_data)
1905 GtkTreePath *path = (GtkTreePath *)user_data;
1907 /* The view is not showing this row (collapsed state), so it is not
1908 * referenced. The signal should not go through.
1910 set_path_visibility (fixture, "2:2:2:2", TRUE);
1912 set_path_visibility (fixture, "2:2:2", TRUE);
1914 signal_monitor_assert_is_empty (fixture->monitor);
1915 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1916 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1917 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1919 /* We only expect signals for the root level */
1920 filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1921 filter_test_enable_filter (fixture);
1923 check_filter_model_with_root (fixture, path);
1924 check_level_length (fixture->filter, NULL, 0);
1926 /* From here we are filtered, "2" in the real model is "0" in the filter
1929 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1930 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1931 set_path_visibility (fixture, "2:2", TRUE);
1932 check_filter_model_with_root (fixture, path);
1933 check_level_length (fixture->filter, NULL, 1);
1934 check_level_length (fixture->filter, "0", 1);
1935 check_level_length (fixture->filter, "0:0", 1);
1939 unfiltered_vroot_show_single_multi_level_root_expanded (FilterTest *fixture,
1940 gconstpointer user_data)
1943 GtkTreePath *path = (GtkTreePath *)user_data;
1945 /* The view is not showing this row (collapsed state), so it is not
1946 * referenced. The signal should not go through.
1948 set_path_visibility (fixture, "2:2:2:2", TRUE);
1950 signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1951 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1952 set_path_visibility (fixture, "2:2:2", TRUE);
1954 signal_monitor_assert_is_empty (fixture->monitor);
1955 check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1956 check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1957 check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1959 filter_test_append_refilter_signals_with_vroot (fixture, 3, path);
1960 filter_test_enable_filter (fixture);
1962 check_filter_model_with_root (fixture, path);
1963 check_level_length (fixture->filter, NULL, 0);
1965 /* From here we are filtered, "2" in the real model is "0" in the filter
1968 signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1969 signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1970 set_path_visibility (fixture, "2:2", TRUE);
1971 check_filter_model_with_root (fixture, path);
1972 check_level_length (fixture->filter, NULL, 1);
1973 check_level_length (fixture->filter, "0", 1);
1974 check_level_length (fixture->filter, "0:0", 1);
1978 unfiltered_rows_reordered_root_level (FilterTest *fixture,
1979 gconstpointer user_data)
1981 int order0[] = { 1, 2, 3, 4, 0 };
1982 int order1[] = { 0, 2, 1, 3, 4 };
1983 int order2[] = { 4, 0, 1, 2, 3 };
1984 GtkTreeIter iter0, iter1, iter2, iter3, iter4;
1987 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
1989 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
1991 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
1993 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
1995 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
1998 path = gtk_tree_path_new ();
1999 signal_monitor_append_signal_reordered (fixture->monitor,
2002 gtk_tree_store_move_after (fixture->store, &iter0, &iter4);
2003 signal_monitor_assert_is_empty (fixture->monitor);
2005 signal_monitor_append_signal_reordered (fixture->monitor,
2008 gtk_tree_store_move_after (fixture->store, &iter2, &iter3);
2009 signal_monitor_assert_is_empty (fixture->monitor);
2011 signal_monitor_append_signal_reordered (fixture->monitor,
2014 gtk_tree_store_move_before (fixture->store, &iter0, &iter1);
2015 signal_monitor_assert_is_empty (fixture->monitor);
2017 gtk_tree_path_free (path);
2021 unfiltered_rows_reordered_child_level (FilterTest *fixture,
2022 gconstpointer user_data)
2024 int order0[] = { 1, 2, 3, 4, 0 };
2025 int order1[] = { 0, 2, 1, 3, 4 };
2026 int order2[] = { 4, 0, 1, 2, 3 };
2027 GtkTreeIter iter0, iter1, iter2, iter3, iter4;
2031 path = gtk_tree_path_new_from_indices (0, -1);
2032 gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), path, FALSE);
2034 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2036 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2038 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2040 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2042 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2045 signal_monitor_append_signal_reordered (fixture->monitor,
2048 gtk_tree_store_move_after (fixture->store, &iter0, &iter4);
2049 signal_monitor_assert_is_empty (fixture->monitor);
2051 signal_monitor_append_signal_reordered (fixture->monitor,
2054 gtk_tree_store_move_after (fixture->store, &iter2, &iter3);
2055 signal_monitor_assert_is_empty (fixture->monitor);
2057 signal_monitor_append_signal_reordered (fixture->monitor,
2060 gtk_tree_store_move_before (fixture->store, &iter0, &iter1);
2061 signal_monitor_assert_is_empty (fixture->monitor);
2063 gtk_tree_path_free (path);
2067 filtered_rows_reordered_root_level_first_hidden (FilterTest *fixture,
2068 gconstpointer user_data)
2070 int order0[] = { 1, 2, 3, 0 };
2071 int order1[] = { 0, 2, 1, 3 };
2072 int order2[] = { 3, 0, 1, 2 };
2073 GtkTreeIter iter1, iter2, iter3, iter4;
2076 /* Hide middle path */
2077 signal_monitor_append_signal (fixture->monitor,
2079 set_path_visibility (fixture, "0", FALSE);
2080 signal_monitor_assert_is_empty (fixture->monitor);
2082 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2084 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2086 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2088 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2091 path = gtk_tree_path_new ();
2092 signal_monitor_append_signal_reordered (fixture->monitor,
2095 gtk_tree_store_move_after (fixture->store, &iter1, &iter4);
2096 signal_monitor_assert_is_empty (fixture->monitor);
2098 signal_monitor_append_signal_reordered (fixture->monitor,
2101 gtk_tree_store_move_after (fixture->store, &iter3, &iter4);
2102 signal_monitor_assert_is_empty (fixture->monitor);
2104 signal_monitor_append_signal_reordered (fixture->monitor,
2107 gtk_tree_store_move_before (fixture->store, &iter1, &iter2);
2108 signal_monitor_assert_is_empty (fixture->monitor);
2110 gtk_tree_path_free (path);
2114 filtered_rows_reordered_root_level_middle_hidden (FilterTest *fixture,
2115 gconstpointer user_data)
2117 int order0[] = { 1, 2, 3, 0 };
2118 int order1[] = { 0, 2, 1, 3 };
2119 int order2[] = { 3, 0, 1, 2 };
2120 GtkTreeIter iter0, iter1, iter3, iter4;
2123 /* Hide middle path */
2124 signal_monitor_append_signal (fixture->monitor,
2126 set_path_visibility (fixture, "2", FALSE);
2127 signal_monitor_assert_is_empty (fixture->monitor);
2129 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2131 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2133 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2135 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2138 path = gtk_tree_path_new ();
2139 signal_monitor_append_signal_reordered (fixture->monitor,
2142 gtk_tree_store_move_after (fixture->store, &iter0, &iter4);
2143 signal_monitor_assert_is_empty (fixture->monitor);
2145 signal_monitor_append_signal_reordered (fixture->monitor,
2148 gtk_tree_store_move_after (fixture->store, &iter3, &iter4);
2149 signal_monitor_assert_is_empty (fixture->monitor);
2151 signal_monitor_append_signal_reordered (fixture->monitor,
2154 gtk_tree_store_move_before (fixture->store, &iter0, &iter1);
2155 signal_monitor_assert_is_empty (fixture->monitor);
2157 gtk_tree_path_free (path);
2161 filtered_rows_reordered_child_level_first_hidden (FilterTest *fixture,
2162 gconstpointer user_data)
2164 int order0[] = { 1, 2, 3, 0 };
2165 int order1[] = { 0, 2, 1, 3 };
2166 int order2[] = { 3, 0, 1, 2 };
2167 GtkTreeIter iter1, iter2, iter3, iter4;
2171 path = gtk_tree_path_new_from_indices (0, -1);
2172 gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), path, TRUE);
2174 /* Hide middle path */
2175 signal_monitor_append_signal (fixture->monitor,
2176 ROW_DELETED, "0:0");
2177 set_path_visibility (fixture, "0:0", FALSE);
2178 signal_monitor_assert_is_empty (fixture->monitor);
2180 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2182 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2184 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2186 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2189 signal_monitor_append_signal_reordered (fixture->monitor,
2192 gtk_tree_store_move_after (fixture->store, &iter1, &iter4);
2193 signal_monitor_assert_is_empty (fixture->monitor);
2195 signal_monitor_append_signal_reordered (fixture->monitor,
2198 gtk_tree_store_move_after (fixture->store, &iter3, &iter4);
2199 signal_monitor_assert_is_empty (fixture->monitor);
2201 signal_monitor_append_signal_reordered (fixture->monitor,
2204 gtk_tree_store_move_before (fixture->store, &iter1, &iter2);
2205 signal_monitor_assert_is_empty (fixture->monitor);
2207 gtk_tree_path_free (path);
2211 filtered_rows_reordered_child_level_middle_hidden (FilterTest *fixture,
2212 gconstpointer user_data)
2214 int order0[] = { 1, 2, 3, 0 };
2215 int order1[] = { 0, 2, 1, 3 };
2216 int order2[] = { 3, 0, 1, 2 };
2217 GtkTreeIter iter0, iter1, iter3, iter4;
2221 path = gtk_tree_path_new_from_indices (0, -1);
2222 gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), path, FALSE);
2224 /* Hide middle path */
2225 signal_monitor_append_signal (fixture->monitor,
2226 ROW_DELETED, "0:2");
2227 set_path_visibility (fixture, "0:2", FALSE);
2228 signal_monitor_assert_is_empty (fixture->monitor);
2230 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2232 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2234 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2236 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2239 signal_monitor_append_signal_reordered (fixture->monitor,
2242 gtk_tree_store_move_after (fixture->store, &iter0, &iter4);
2243 signal_monitor_assert_is_empty (fixture->monitor);
2245 signal_monitor_append_signal_reordered (fixture->monitor,
2248 gtk_tree_store_move_after (fixture->store, &iter3, &iter4);
2249 signal_monitor_assert_is_empty (fixture->monitor);
2251 signal_monitor_append_signal_reordered (fixture->monitor,
2254 gtk_tree_store_move_before (fixture->store, &iter0, &iter1);
2255 signal_monitor_assert_is_empty (fixture->monitor);
2257 gtk_tree_path_free (path);
2261 filtered_rows_reordered_child_level_4_hidden (FilterTest *fixture,
2262 gconstpointer user_data)
2264 int order0[] = { 0 };
2265 GtkTreeIter iter1, iter4;
2269 path = gtk_tree_path_new_from_indices (0, -1);
2270 gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), path, FALSE);
2272 /* Hide last 4 paths */
2273 signal_monitor_append_signal (fixture->monitor,
2274 ROW_DELETED, "0:4");
2275 signal_monitor_append_signal (fixture->monitor,
2276 ROW_DELETED, "0:3");
2277 signal_monitor_append_signal (fixture->monitor,
2278 ROW_DELETED, "0:2");
2279 signal_monitor_append_signal (fixture->monitor,
2280 ROW_DELETED, "0:0");
2281 set_path_visibility (fixture, "0:4", FALSE);
2282 set_path_visibility (fixture, "0:3", FALSE);
2283 set_path_visibility (fixture, "0:2", FALSE);
2284 set_path_visibility (fixture, "0:0", FALSE);
2285 signal_monitor_assert_is_empty (fixture->monitor);
2287 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2289 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2292 signal_monitor_append_signal_reordered (fixture->monitor,
2295 gtk_tree_store_move_after (fixture->store, &iter1, &iter4);
2296 signal_monitor_assert_is_empty (fixture->monitor);
2298 gtk_tree_path_free (path);
2302 filtered_rows_reordered_child_level_all_hidden (FilterTest *fixture,
2303 gconstpointer user_data)
2305 GtkTreeIter iter1, iter4;
2309 path = gtk_tree_path_new_from_indices (0, -1);
2310 gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), path, FALSE);
2311 gtk_tree_path_free (path);
2313 /* Hide last 4 paths */
2314 signal_monitor_append_signal (fixture->monitor,
2315 ROW_DELETED, "0:4");
2316 signal_monitor_append_signal (fixture->monitor,
2317 ROW_DELETED, "0:3");
2318 signal_monitor_append_signal (fixture->monitor,
2319 ROW_DELETED, "0:2");
2320 signal_monitor_append_signal (fixture->monitor,
2321 ROW_DELETED, "0:1");
2322 signal_monitor_append_signal (fixture->monitor,
2323 ROW_DELETED, "0:0");
2324 signal_monitor_append_signal (fixture->monitor,
2325 ROW_HAS_CHILD_TOGGLED, "0");
2326 set_path_visibility (fixture, "0:4", FALSE);
2327 set_path_visibility (fixture, "0:3", FALSE);
2328 set_path_visibility (fixture, "0:2", FALSE);
2329 set_path_visibility (fixture, "0:1", FALSE);
2330 set_path_visibility (fixture, "0:0", FALSE);
2331 signal_monitor_assert_is_empty (fixture->monitor);
2333 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2335 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
2338 gtk_tree_store_move_after (fixture->store, &iter1, &iter4);
2339 signal_monitor_assert_is_empty (fixture->monitor);
2343 insert_before (void)
2345 GtkTreeStore *store;
2346 GtkTreeModel *filter;
2347 GtkWidget *tree_view;
2348 SignalMonitor *monitor;
2350 GtkTreeIter last_iter;
2353 /* This tests two aspects of the row-inserted handling:
2354 * 1) If the newly inserted node was already handled by building
2355 * the root level, don't handle it a second time.
2356 * 2) Offsets of existing nodes must be updated when a new
2360 store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
2361 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
2362 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter),
2365 tree_view = gtk_tree_view_new_with_model (filter);
2366 monitor = signal_monitor_new (filter);
2368 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 0);
2371 path = gtk_tree_path_new_from_indices (0, -1);
2372 signal_monitor_append_signal_path (monitor, ROW_INSERTED, path);
2373 gtk_tree_path_free (path);
2375 gtk_tree_store_insert_with_values (store, &iter, NULL, 0,
2376 0, "Foo", 1, TRUE, -1);
2378 signal_monitor_assert_is_empty (monitor);
2379 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
2382 path = gtk_tree_path_new_from_indices (1, -1);
2383 signal_monitor_append_signal_path (monitor, ROW_INSERTED, path);
2384 gtk_tree_path_free (path);
2386 gtk_tree_store_insert_with_values (store, &iter, NULL, 1,
2387 0, "Foo", 1, TRUE, -1);
2390 signal_monitor_assert_is_empty (monitor);
2391 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 2);
2393 /* Insert on 1 again -- invisible */
2394 gtk_tree_store_insert_with_values (store, &iter, NULL, 1,
2395 0, "Foo", 1, FALSE, -1);
2397 signal_monitor_assert_is_empty (monitor);
2398 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 2);
2400 /* Insert on 1 again -- visible */
2401 path = gtk_tree_path_new_from_indices (1, -1);
2402 signal_monitor_append_signal_path (monitor, ROW_INSERTED, path);
2403 gtk_tree_path_free (path);
2405 gtk_tree_store_insert_with_values (store, &iter, NULL, 1,
2406 0, "Foo", 1, TRUE, -1);
2408 signal_monitor_assert_is_empty (monitor);
2409 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 3);
2411 /* Modify the iter that should be at the last position and check the
2414 path = gtk_tree_path_new_from_indices (2, -1);
2415 signal_monitor_append_signal_path (monitor, ROW_CHANGED, path);
2416 gtk_tree_path_free (path);
2418 gtk_tree_store_set (store, &last_iter, 0, "Foo changed", -1);
2420 signal_monitor_assert_is_empty (monitor);
2421 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 3);
2427 GtkTreeStore *store;
2428 GtkTreeModel *filter;
2429 GtkWidget *tree_view;
2430 SignalMonitor *monitor;
2431 GtkTreeIter parent, iter;
2434 store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
2436 gtk_tree_store_insert_with_values (store, &parent, NULL, 0,
2437 0, "Parent", 1, TRUE, -1);
2440 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
2441 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter),
2444 tree_view = gtk_tree_view_new_with_model (filter);
2445 monitor = signal_monitor_new (filter);
2447 /* Insert child -- invisible */
2448 path = gtk_tree_path_new_from_indices (0, -1);
2449 signal_monitor_append_signal_path (monitor, ROW_HAS_CHILD_TOGGLED, path);
2450 /* The signal is received twice, once a pass through from GtkTreeStore
2451 * and one generated by GtkTreeModelFilter. Not accurate, but cannot
2454 signal_monitor_append_signal_path (monitor, ROW_HAS_CHILD_TOGGLED, path);
2455 gtk_tree_path_free (path);
2457 gtk_tree_store_insert_with_values (store, &iter, &parent, 1,
2458 0, "Child", 1, FALSE, -1);
2460 signal_monitor_assert_is_empty (monitor);
2461 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
2464 path = gtk_tree_path_new_from_indices (0, 0, -1);
2465 gtk_tree_path_up (path); /* 0 */
2466 signal_monitor_append_signal_path (monitor, ROW_HAS_CHILD_TOGGLED, path);
2467 gtk_tree_path_free (path);
2469 gtk_tree_store_insert_with_values (store, &iter, &parent, 0,
2470 0, "Child", 1, TRUE, -1);
2472 signal_monitor_assert_is_empty (monitor);
2473 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
2475 /* Insert child -- invisible */
2476 gtk_tree_store_insert_with_values (store, &iter, &parent, 1,
2477 0, "Child", 1, FALSE, -1);
2479 signal_monitor_assert_is_empty (monitor);
2480 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
2488 GtkTreeIter iter, iter1, iter2, iter3;
2490 GtkTreeModel *filter;
2491 GtkWidget *view G_GNUC_UNUSED;
2493 list = gtk_list_store_new (1, G_TYPE_INT);
2494 gtk_list_store_insert_with_values (list, &iter1, 0, 0, 1, -1);
2495 gtk_list_store_insert_with_values (list, &iter, 1, 0, 2, -1);
2496 gtk_list_store_insert_with_values (list, &iter, 2, 0, 3, -1);
2497 gtk_list_store_insert_with_values (list, &iter, 3, 0, 4, -1);
2498 gtk_list_store_insert_with_values (list, &iter, 4, 0, 5, -1);
2499 gtk_list_store_insert_with_values (list, &iter, 5, 0, 6, -1);
2500 gtk_list_store_insert_with_values (list, &iter2, 6, 0, 7, -1);
2501 gtk_list_store_insert_with_values (list, &iter3, 7, 0, 8, -1);
2503 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (list), NULL);
2504 view = gtk_tree_view_new_with_model (filter);
2506 gtk_list_store_remove (list, &iter1);
2507 gtk_list_store_remove (list, &iter3);
2508 gtk_list_store_remove (list, &iter2);
2510 gtk_widget_destroy (view);
2511 g_object_unref (filter);
2512 g_object_unref (list);
2516 remove_node_vroot (void)
2518 GtkTreeIter parent, root;
2519 GtkTreeIter iter, iter1, iter2, iter3;
2521 GtkTreeModel *filter;
2523 GtkWidget *view G_GNUC_UNUSED;
2525 tree = gtk_tree_store_new (1, G_TYPE_INT);
2526 gtk_tree_store_insert_with_values (tree, &parent, NULL, 0, 0, 0, -1);
2527 gtk_tree_store_insert_with_values (tree, &root, &parent, 0, 0, 0, -1);
2529 gtk_tree_store_insert_with_values (tree, &iter1, &root, 0, 0, 1, -1);
2530 gtk_tree_store_insert_with_values (tree, &iter, &root, 1, 0, 2, -1);
2531 gtk_tree_store_insert_with_values (tree, &iter, &root, 2, 0, 3, -1);
2532 gtk_tree_store_insert_with_values (tree, &iter, &root, 3, 0, 4, -1);
2533 gtk_tree_store_insert_with_values (tree, &iter, &root, 4, 0, 5, -1);
2534 gtk_tree_store_insert_with_values (tree, &iter, &root, 5, 0, 6, -1);
2535 gtk_tree_store_insert_with_values (tree, &iter2, &root, 6, 0, 7, -1);
2536 gtk_tree_store_insert_with_values (tree, &iter3, &root, 7, 0, 8, -1);
2538 path = gtk_tree_path_new_from_indices (0, 0, -1);
2539 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (tree), path);
2540 gtk_tree_path_free (path);
2542 view = gtk_tree_view_new_with_model (filter);
2544 gtk_tree_store_remove (tree, &iter1);
2545 gtk_tree_store_remove (tree, &iter3);
2546 gtk_tree_store_remove (tree, &iter2);
2548 gtk_widget_destroy (view);
2549 g_object_unref (filter);
2550 g_object_unref (tree);
2554 remove_vroot_ancestor (void)
2556 GtkTreeIter parent, root;
2557 GtkTreeIter iter, iter1, iter2, iter3;
2559 GtkTreeModel *filter;
2561 GtkWidget *view G_GNUC_UNUSED;
2563 tree = gtk_tree_store_new (1, G_TYPE_INT);
2564 gtk_tree_store_insert_with_values (tree, &parent, NULL, 0, 0, 0, -1);
2565 gtk_tree_store_insert_with_values (tree, &root, &parent, 0, 0, 0, -1);
2567 gtk_tree_store_insert_with_values (tree, &iter1, &root, 0, 0, 1, -1);
2568 gtk_tree_store_insert_with_values (tree, &iter, &root, 1, 0, 2, -1);
2569 gtk_tree_store_insert_with_values (tree, &iter, &root, 2, 0, 3, -1);
2570 gtk_tree_store_insert_with_values (tree, &iter, &root, 3, 0, 4, -1);
2571 gtk_tree_store_insert_with_values (tree, &iter, &root, 4, 0, 5, -1);
2572 gtk_tree_store_insert_with_values (tree, &iter, &root, 5, 0, 6, -1);
2573 gtk_tree_store_insert_with_values (tree, &iter2, &root, 6, 0, 7, -1);
2574 gtk_tree_store_insert_with_values (tree, &iter3, &root, 7, 0, 8, -1);
2576 path = gtk_tree_path_new_from_indices (0, 0, -1);
2577 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (tree), path);
2578 gtk_tree_path_free (path);
2580 view = gtk_tree_view_new_with_model (filter);
2582 gtk_tree_store_remove (tree, &parent);
2584 gtk_widget_destroy (view);
2585 g_object_unref (filter);
2586 g_object_unref (tree);
2590 ref_count_single_level (void)
2592 GtkTreeIter iter[5];
2593 GtkTreeModel *model;
2594 GtkTreeModelRefCount *ref_model;
2595 GtkTreeModel *filter_model;
2596 GtkWidget *tree_view;
2598 model = gtk_tree_model_ref_count_new ();
2599 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
2601 gtk_tree_store_append (GTK_TREE_STORE (model), &iter[0], NULL);
2602 gtk_tree_store_append (GTK_TREE_STORE (model), &iter[1], NULL);
2603 gtk_tree_store_append (GTK_TREE_STORE (model), &iter[2], NULL);
2604 gtk_tree_store_append (GTK_TREE_STORE (model), &iter[3], NULL);
2605 gtk_tree_store_append (GTK_TREE_STORE (model), &iter[4], NULL);
2607 assert_root_level_unreferenced (ref_model);
2609 filter_model = gtk_tree_model_filter_new (model, NULL);
2610 tree_view = gtk_tree_view_new_with_model (filter_model);
2612 assert_node_ref_count (ref_model, &iter[0], 2);
2613 assert_node_ref_count (ref_model, &iter[1], 1);
2614 assert_node_ref_count (ref_model, &iter[2], 1);
2615 assert_node_ref_count (ref_model, &iter[3], 1);
2616 assert_node_ref_count (ref_model, &iter[4], 1);
2618 gtk_widget_destroy (tree_view);
2620 assert_node_ref_count (ref_model, &iter[0], 1);
2621 assert_node_ref_count (ref_model, &iter[1], 0);
2622 assert_node_ref_count (ref_model, &iter[2], 0);
2623 assert_node_ref_count (ref_model, &iter[3], 0);
2624 assert_node_ref_count (ref_model, &iter[4], 0);
2626 g_object_unref (filter_model);
2628 assert_node_ref_count (ref_model, &iter[0], 0);
2630 g_object_unref (ref_model);
2634 ref_count_two_levels (void)
2636 GtkTreeIter parent1, parent2, iter, iter_first;
2637 GtkTreeModel *model;
2638 GtkTreeModelRefCount *ref_model;
2639 GtkTreeModel *filter_model;
2640 GtkWidget *tree_view;
2642 model = gtk_tree_model_ref_count_new ();
2643 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
2645 gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, NULL);
2646 gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, NULL);
2647 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_first, &parent2);
2648 gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &parent2);
2649 gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &parent2);
2651 assert_entire_model_unreferenced (ref_model);
2653 filter_model = gtk_tree_model_filter_new (model, NULL);
2654 tree_view = gtk_tree_view_new_with_model (filter_model);
2656 /* This is quite confusing:
2657 * - node 0 has a ref count of 2 because it is referenced as the
2658 * first node in a level and by the tree view.
2659 * - node 1 has a ref count of 2 because it is referenced by its
2660 * child level and by the tree view.
2662 assert_root_level_referenced (ref_model, 2);
2663 assert_node_ref_count (ref_model, &iter_first, 1);
2664 assert_node_ref_count (ref_model, &iter, 0);
2666 gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
2668 assert_node_ref_count (ref_model, &parent1, 2);
2669 assert_node_ref_count (ref_model, &parent2, 2);
2670 assert_node_ref_count (ref_model, &iter_first, 2);
2671 assert_node_ref_count (ref_model, &iter, 1);
2673 gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view));
2675 /* The child level is not destroyed because its parent is visible */
2676 assert_node_ref_count (ref_model, &parent1, 2);
2677 assert_node_ref_count (ref_model, &parent2, 2);
2678 assert_node_ref_count (ref_model, &iter_first, 1);
2679 assert_node_ref_count (ref_model, &iter, 0);
2681 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
2683 assert_node_ref_count (ref_model, &parent1, 2);
2684 assert_node_ref_count (ref_model, &parent2, 2);
2685 assert_node_ref_count (ref_model, &iter_first, 1);
2686 assert_node_ref_count (ref_model, &iter, 0);
2688 gtk_widget_destroy (tree_view);
2690 assert_root_level_referenced (ref_model, 1);
2691 assert_node_ref_count (ref_model, &iter_first, 1);
2692 assert_node_ref_count (ref_model, &iter, 0);
2694 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
2696 /* The root level and first level remain cached, only the references on the
2697 * first nodes of these levels are kept.
2699 assert_node_ref_count (ref_model, &parent1, 1);
2700 assert_node_ref_count (ref_model, &parent2, 1);
2701 assert_node_ref_count (ref_model, &iter_first, 1);
2702 assert_node_ref_count (ref_model, &iter, 0);
2704 g_object_unref (filter_model);
2705 g_object_unref (ref_model);
2709 ref_count_three_levels (void)
2711 GtkTreeIter grandparent1, grandparent2, parent1, parent2;
2712 GtkTreeIter iter_parent1, iter_parent2, iter_parent2_first;
2713 GtkTreeModel *model;
2714 GtkTreeModelRefCount *ref_model;
2715 GtkTreeModel *filter_model;
2717 GtkWidget *tree_view;
2719 model = gtk_tree_model_ref_count_new ();
2720 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
2727 * + iter_parent2_first
2731 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
2732 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
2733 gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
2734 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
2735 gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
2736 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2_first, &parent2);
2737 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
2739 assert_entire_model_unreferenced (ref_model);
2741 filter_model = gtk_tree_model_filter_new (model, NULL);
2742 tree_view = gtk_tree_view_new_with_model (filter_model);
2744 /* This is quite confusing:
2745 * - node 0 has a ref count of 2 because it is referenced as the
2746 * first node in a level and by the tree view.
2747 * - node 1 has a ref count of 2 because it is referenced by its
2748 * child level and by the tree view.
2750 assert_root_level_referenced (ref_model, 2);
2751 assert_node_ref_count (ref_model, &parent1, 1);
2752 assert_node_ref_count (ref_model, &parent2, 0);
2753 assert_level_unreferenced (ref_model, &parent1);
2754 assert_level_unreferenced (ref_model, &parent2);
2756 path = gtk_tree_path_new_from_indices (1, -1);
2757 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
2759 assert_node_ref_count (ref_model, &grandparent1, 2);
2760 assert_node_ref_count (ref_model, &grandparent2, 2);
2761 assert_node_ref_count (ref_model, &parent1, 3);
2762 assert_node_ref_count (ref_model, &parent2, 2);
2763 assert_node_ref_count (ref_model, &iter_parent1, 1);
2764 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
2765 assert_node_ref_count (ref_model, &iter_parent2, 0);
2767 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
2769 assert_node_ref_count (ref_model, &grandparent1, 2);
2770 assert_node_ref_count (ref_model, &grandparent2, 2);
2771 assert_node_ref_count (ref_model, &parent1, 3);
2772 assert_node_ref_count (ref_model, &parent2, 2);
2773 assert_node_ref_count (ref_model, &iter_parent1, 2);
2774 assert_node_ref_count (ref_model, &iter_parent2_first, 2);
2775 assert_node_ref_count (ref_model, &iter_parent2, 1);
2777 gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view));
2779 assert_node_ref_count (ref_model, &grandparent1, 2);
2780 assert_node_ref_count (ref_model, &grandparent2, 2);
2781 assert_node_ref_count (ref_model, &parent1, 2);
2782 assert_node_ref_count (ref_model, &parent2, 1);
2783 assert_node_ref_count (ref_model, &iter_parent1, 1);
2784 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
2785 assert_node_ref_count (ref_model, &iter_parent2, 0);
2787 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
2789 assert_node_ref_count (ref_model, &grandparent1, 2);
2790 assert_node_ref_count (ref_model, &grandparent2, 2);
2791 assert_node_ref_count (ref_model, &parent1, 1);
2792 assert_node_ref_count (ref_model, &parent2, 0);
2793 assert_node_ref_count (ref_model, &iter_parent1, 0);
2794 assert_node_ref_count (ref_model, &iter_parent2_first, 0);
2795 assert_node_ref_count (ref_model, &iter_parent2, 0);
2797 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
2799 assert_node_ref_count (ref_model, &grandparent1, 2);
2800 assert_node_ref_count (ref_model, &grandparent2, 2);
2801 assert_node_ref_count (ref_model, &parent1, 3);
2802 assert_node_ref_count (ref_model, &parent2, 2);
2803 assert_node_ref_count (ref_model, &iter_parent1, 1);
2804 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
2805 assert_node_ref_count (ref_model, &iter_parent2, 0);
2807 gtk_tree_path_append_index (path, 1);
2808 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
2810 assert_node_ref_count (ref_model, &grandparent1, 2);
2811 assert_node_ref_count (ref_model, &grandparent2, 2);
2812 assert_node_ref_count (ref_model, &parent1, 3);
2813 assert_node_ref_count (ref_model, &parent2, 2);
2814 assert_node_ref_count (ref_model, &iter_parent1, 1);
2815 assert_node_ref_count (ref_model, &iter_parent2_first, 2);
2816 assert_node_ref_count (ref_model, &iter_parent2, 1);
2818 gtk_tree_view_collapse_row (GTK_TREE_VIEW (tree_view), path);
2820 assert_node_ref_count (ref_model, &grandparent1, 2);
2821 assert_node_ref_count (ref_model, &grandparent2, 2);
2822 assert_node_ref_count (ref_model, &parent1, 3);
2823 assert_node_ref_count (ref_model, &parent2, 2);
2824 assert_node_ref_count (ref_model, &iter_parent1, 1);
2825 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
2826 assert_node_ref_count (ref_model, &iter_parent2, 0);
2828 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
2830 assert_node_ref_count (ref_model, &grandparent1, 2);
2831 assert_node_ref_count (ref_model, &grandparent2, 2);
2832 assert_node_ref_count (ref_model, &parent1, 3);
2833 assert_node_ref_count (ref_model, &parent2, 2);
2834 assert_node_ref_count (ref_model, &iter_parent1, 1);
2835 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
2836 assert_node_ref_count (ref_model, &iter_parent2, 0);
2838 gtk_tree_path_up (path);
2839 gtk_tree_view_collapse_row (GTK_TREE_VIEW (tree_view), path);
2840 gtk_tree_path_free (path);
2842 assert_node_ref_count (ref_model, &grandparent1, 2);
2843 assert_node_ref_count (ref_model, &grandparent2, 2);
2844 assert_node_ref_count (ref_model, &parent1, 2);
2845 assert_node_ref_count (ref_model, &parent2, 1);
2846 assert_node_ref_count (ref_model, &iter_parent1, 1);
2847 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
2848 assert_node_ref_count (ref_model, &iter_parent2, 0);
2850 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
2852 assert_node_ref_count (ref_model, &grandparent1, 2);
2853 assert_node_ref_count (ref_model, &grandparent2, 2);
2854 assert_node_ref_count (ref_model, &parent1, 1);
2855 assert_node_ref_count (ref_model, &parent2, 0);
2856 assert_node_ref_count (ref_model, &iter_parent1, 0);
2857 assert_node_ref_count (ref_model, &iter_parent2_first, 0);
2858 assert_node_ref_count (ref_model, &iter_parent2, 0);
2860 gtk_widget_destroy (tree_view);
2862 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
2864 /* The root level and first level remain cached, only the references on the
2865 * first nodes of these levels are kept. Grandparent2 is the parent
2866 * of the first level with parent1, so grandparent2 keeps a reference
2869 assert_node_ref_count (ref_model, &grandparent1, 1);
2870 assert_node_ref_count (ref_model, &grandparent2, 1);
2871 assert_node_ref_count (ref_model, &parent1, 1);
2872 assert_node_ref_count (ref_model, &parent2, 0);
2873 assert_node_ref_count (ref_model, &iter_parent1, 0);
2874 assert_node_ref_count (ref_model, &iter_parent2_first, 0);
2875 assert_node_ref_count (ref_model, &iter_parent2, 0);
2877 g_object_unref (filter_model);
2878 g_object_unref (ref_model);
2882 ref_count_delete_row (void)
2884 GtkTreeIter grandparent1, grandparent2, parent1, parent2;
2885 GtkTreeIter iter_parent1, iter_parent2, iter_parent2_first;
2886 GtkTreeModel *model;
2887 GtkTreeModelRefCount *ref_model;
2888 GtkTreeModel *filter_model;
2890 GtkWidget *tree_view;
2892 model = gtk_tree_model_ref_count_new ();
2893 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
2900 * + iter_parent2_first
2904 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
2905 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
2906 gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
2907 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
2908 gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
2909 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2_first, &parent2);
2910 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
2912 assert_entire_model_unreferenced (ref_model);
2914 filter_model = gtk_tree_model_filter_new (model, NULL);
2915 tree_view = gtk_tree_view_new_with_model (filter_model);
2917 assert_root_level_referenced (ref_model, 2);
2918 assert_node_ref_count (ref_model, &parent1, 1);
2919 assert_node_ref_count (ref_model, &parent2, 0);
2920 assert_level_unreferenced (ref_model, &parent1);
2921 assert_level_unreferenced (ref_model, &parent2);
2923 path = gtk_tree_path_new_from_indices (1, -1);
2924 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
2925 gtk_tree_path_free (path);
2927 assert_node_ref_count (ref_model, &grandparent1, 2);
2928 assert_node_ref_count (ref_model, &grandparent2, 2);
2929 assert_node_ref_count (ref_model, &parent1, 3);
2930 assert_node_ref_count (ref_model, &parent2, 2);
2931 assert_node_ref_count (ref_model, &iter_parent1, 2);
2932 assert_node_ref_count (ref_model, &iter_parent2_first, 2);
2933 assert_node_ref_count (ref_model, &iter_parent2, 1);
2935 gtk_tree_store_remove (GTK_TREE_STORE (model), &iter_parent2);
2937 assert_node_ref_count (ref_model, &grandparent1, 2);
2938 assert_node_ref_count (ref_model, &grandparent2, 2);
2939 assert_node_ref_count (ref_model, &parent1, 3);
2940 assert_node_ref_count (ref_model, &parent2, 2);
2941 assert_node_ref_count (ref_model, &iter_parent1, 2);
2942 assert_node_ref_count (ref_model, &iter_parent2_first, 2);
2944 gtk_tree_store_remove (GTK_TREE_STORE (model), &parent1);
2946 assert_node_ref_count (ref_model, &grandparent1, 2);
2947 assert_node_ref_count (ref_model, &grandparent2, 2);
2948 assert_node_ref_count (ref_model, &parent2, 3);
2949 assert_level_referenced (ref_model, 2, &parent2);
2951 gtk_tree_store_remove (GTK_TREE_STORE (model), &grandparent2);
2953 assert_node_ref_count (ref_model, &grandparent1, 2);
2955 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
2957 assert_node_ref_count (ref_model, &grandparent1, 2);
2959 gtk_widget_destroy (tree_view);
2960 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
2962 assert_node_ref_count (ref_model, &grandparent1, 1);
2964 g_object_unref (filter_model);
2966 assert_node_ref_count (ref_model, &grandparent1, 0);
2968 g_object_unref (ref_model);
2972 ref_count_filter_row_length_1 (void)
2974 GtkTreeIter level1_1;
2975 GtkTreeIter level2_1;
2976 GtkTreeIter level3_1;
2977 GtkTreeIter level4_1;
2978 GtkTreeModel *model;
2979 GtkTreeModelRefCount *ref_model;
2980 GtkTreeModel *filter_model;
2982 GtkWidget *tree_view;
2983 GType column_types[] = { G_TYPE_BOOLEAN };
2985 model = gtk_tree_model_ref_count_new ();
2986 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
2988 gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
2997 * Node level1_1 is expanded. This makes that levels 1 and 2 are
2998 * visible. Level 3 is cached because its parent is visible. Level 4
3002 gtk_tree_store_append (GTK_TREE_STORE (model), &level1_1, NULL);
3003 gtk_tree_store_append (GTK_TREE_STORE (model), &level2_1, &level1_1);
3004 gtk_tree_store_append (GTK_TREE_STORE (model), &level3_1, &level2_1);
3005 gtk_tree_store_append (GTK_TREE_STORE (model), &level4_1, &level3_1);
3007 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_1, 0, TRUE, -1);
3008 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_1, 0, TRUE, -1);
3009 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_1, 0, TRUE, -1);
3010 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_1, 0, TRUE, -1);
3012 assert_entire_model_unreferenced (ref_model);
3014 filter_model = gtk_tree_model_filter_new (model, NULL);
3015 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter_model), 0);
3016 tree_view = gtk_tree_view_new_with_model (filter_model);
3018 assert_node_ref_count (ref_model, &level1_1, 3);
3019 assert_node_ref_count (ref_model, &level2_1, 1);
3020 assert_node_ref_count (ref_model, &level3_1, 0);
3021 assert_node_ref_count (ref_model, &level4_1, 0);
3023 path = gtk_tree_path_new_from_indices (0, -1);
3024 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
3025 gtk_tree_path_free (path);
3027 assert_node_ref_count (ref_model, &level1_1, 3);
3028 assert_node_ref_count (ref_model, &level2_1, 3);
3029 assert_node_ref_count (ref_model, &level3_1, 1);
3030 assert_node_ref_count (ref_model, &level4_1, 0);
3032 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_1, 0, FALSE, -1);
3034 assert_node_ref_count (ref_model, &level1_1, 3);
3035 assert_node_ref_count (ref_model, &level2_1, 3);
3036 assert_node_ref_count (ref_model, &level3_1, 1);
3037 assert_node_ref_count (ref_model, &level4_1, 0);
3039 /* level3_1 has a visible parent, so the node is kept in the cache. */
3040 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_1, 0, FALSE, -1);
3042 assert_node_ref_count (ref_model, &level1_1, 3);
3043 assert_node_ref_count (ref_model, &level2_1, 3);
3044 assert_node_ref_count (ref_model, &level3_1, 1);
3045 assert_node_ref_count (ref_model, &level4_1, 0);
3047 /* level2_1 has a visible parent, so is kept in the cache. However,
3048 * the external reference should be released.
3050 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_1, 0, FALSE, -1);
3052 assert_node_ref_count (ref_model, &level1_1, 3);
3053 assert_node_ref_count (ref_model, &level2_1, 1);
3054 assert_node_ref_count (ref_model, &level3_1, 0);
3055 assert_node_ref_count (ref_model, &level4_1, 0);
3057 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_1, 0, FALSE, -1);
3059 assert_node_ref_count (ref_model, &level1_1, 2);
3060 assert_node_ref_count (ref_model, &level2_1, 1);
3061 assert_node_ref_count (ref_model, &level3_1, 0);
3062 assert_node_ref_count (ref_model, &level4_1, 0);
3064 gtk_widget_destroy (tree_view);
3065 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
3067 assert_node_ref_count (ref_model, &level1_1, 2);
3068 assert_node_ref_count (ref_model, &level2_1, 1);
3070 g_object_unref (filter_model);
3072 assert_node_ref_count (ref_model, &level1_1, 0);
3074 g_object_unref (ref_model);
3078 ref_count_filter_row_length_1_remove_in_root_level (void)
3080 GtkTreeIter level1_1;
3081 GtkTreeIter level2_1;
3082 GtkTreeIter level3_1;
3083 GtkTreeIter level4_1;
3084 GtkTreeModel *model;
3085 GtkTreeModelRefCount *ref_model;
3086 GtkTreeModel *filter_model;
3088 GtkWidget *tree_view;
3089 GType column_types[] = { G_TYPE_BOOLEAN };
3091 model = gtk_tree_model_ref_count_new ();
3092 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3094 gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
3104 gtk_tree_store_append (GTK_TREE_STORE (model), &level1_1, NULL);
3105 gtk_tree_store_append (GTK_TREE_STORE (model), &level2_1, &level1_1);
3106 gtk_tree_store_append (GTK_TREE_STORE (model), &level3_1, &level2_1);
3107 gtk_tree_store_append (GTK_TREE_STORE (model), &level4_1, &level3_1);
3109 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_1, 0, TRUE, -1);
3110 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_1, 0, TRUE, -1);
3111 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_1, 0, TRUE, -1);
3112 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_1, 0, TRUE, -1);
3114 assert_entire_model_unreferenced (ref_model);
3116 filter_model = gtk_tree_model_filter_new (model, NULL);
3117 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter_model), 0);
3118 tree_view = gtk_tree_view_new_with_model (filter_model);
3120 assert_node_ref_count (ref_model, &level1_1, 3);
3121 assert_node_ref_count (ref_model, &level2_1, 1);
3122 assert_node_ref_count (ref_model, &level3_1, 0);
3123 assert_node_ref_count (ref_model, &level4_1, 0);
3125 path = gtk_tree_path_new_from_indices (0, -1);
3126 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
3127 gtk_tree_path_free (path);
3129 assert_node_ref_count (ref_model, &level1_1, 3);
3130 assert_node_ref_count (ref_model, &level2_1, 3);
3131 assert_node_ref_count (ref_model, &level3_1, 3);
3132 assert_node_ref_count (ref_model, &level4_1, 2);
3134 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_1, 0, FALSE, -1);
3136 assert_node_ref_count (ref_model, &level1_1, 2);
3137 assert_node_ref_count (ref_model, &level2_1, 1);
3138 assert_node_ref_count (ref_model, &level3_1, 0);
3139 assert_node_ref_count (ref_model, &level4_1, 0);
3141 gtk_widget_destroy (tree_view);
3142 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
3144 assert_node_ref_count (ref_model, &level1_1, 2);
3145 assert_node_ref_count (ref_model, &level2_1, 1);
3146 assert_node_ref_count (ref_model, &level3_1, 0);
3147 assert_node_ref_count (ref_model, &level4_1, 0);
3149 g_object_unref (filter_model);
3151 assert_node_ref_count (ref_model, &level1_1, 0);
3152 assert_node_ref_count (ref_model, &level2_1, 0);
3153 assert_node_ref_count (ref_model, &level3_1, 0);
3154 assert_node_ref_count (ref_model, &level4_1, 0);
3156 g_object_unref (ref_model);
3160 ref_count_filter_row_length_1_remove_in_child_level (void)
3162 GtkTreeIter level1_1;
3163 GtkTreeIter level2_1;
3164 GtkTreeIter level3_1;
3165 GtkTreeIter level4_1;
3166 GtkTreeModel *model;
3167 GtkTreeModelRefCount *ref_model;
3168 GtkTreeModel *filter_model;
3170 GtkWidget *tree_view;
3171 GType column_types[] = { G_TYPE_BOOLEAN };
3173 model = gtk_tree_model_ref_count_new ();
3174 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3176 gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
3186 gtk_tree_store_append (GTK_TREE_STORE (model), &level1_1, NULL);
3187 gtk_tree_store_append (GTK_TREE_STORE (model), &level2_1, &level1_1);
3188 gtk_tree_store_append (GTK_TREE_STORE (model), &level3_1, &level2_1);
3189 gtk_tree_store_append (GTK_TREE_STORE (model), &level4_1, &level3_1);
3191 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_1, 0, TRUE, -1);
3192 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_1, 0, TRUE, -1);
3193 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_1, 0, TRUE, -1);
3194 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_1, 0, TRUE, -1);
3196 assert_entire_model_unreferenced (ref_model);
3198 filter_model = gtk_tree_model_filter_new (model, NULL);
3199 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter_model), 0);
3200 tree_view = gtk_tree_view_new_with_model (filter_model);
3202 assert_node_ref_count (ref_model, &level1_1, 3);
3203 assert_node_ref_count (ref_model, &level2_1, 1);
3204 assert_node_ref_count (ref_model, &level3_1, 0);
3205 assert_node_ref_count (ref_model, &level4_1, 0);
3207 path = gtk_tree_path_new_from_indices (0, -1);
3208 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
3209 gtk_tree_path_free (path);
3211 assert_node_ref_count (ref_model, &level1_1, 3);
3212 assert_node_ref_count (ref_model, &level2_1, 3);
3213 assert_node_ref_count (ref_model, &level3_1, 3);
3214 assert_node_ref_count (ref_model, &level4_1, 2);
3216 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_1, 0, FALSE, -1);
3218 assert_node_ref_count (ref_model, &level1_1, 3);
3219 assert_node_ref_count (ref_model, &level2_1, 1);
3220 assert_node_ref_count (ref_model, &level3_1, 0);
3221 assert_node_ref_count (ref_model, &level4_1, 0);
3223 gtk_widget_destroy (tree_view);
3224 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
3226 assert_node_ref_count (ref_model, &level1_1, 2);
3227 assert_node_ref_count (ref_model, &level2_1, 1);
3228 assert_node_ref_count (ref_model, &level3_1, 0);
3229 assert_node_ref_count (ref_model, &level4_1, 0);
3231 g_object_unref (filter_model);
3233 assert_node_ref_count (ref_model, &level1_1, 0);
3234 assert_node_ref_count (ref_model, &level2_1, 0);
3235 assert_node_ref_count (ref_model, &level3_1, 0);
3236 assert_node_ref_count (ref_model, &level4_1, 0);
3238 g_object_unref (ref_model);
3242 ref_count_filter_row_length_gt_1 (void)
3244 GtkTreeIter level1_1, level1_2;
3245 GtkTreeIter level2_1, level2_2;
3246 GtkTreeIter level3_1, level3_2;
3247 GtkTreeIter level4_1, level4_2;
3248 GtkTreeModel *model;
3249 GtkTreeModelRefCount *ref_model;
3250 GtkTreeModel *filter_model;
3252 GtkWidget *tree_view;
3253 GType column_types[] = { G_TYPE_BOOLEAN };
3255 model = gtk_tree_model_ref_count_new ();
3256 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3258 gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
3271 * Node level1_2 is expanded. This makes that levels 1 and 2 are
3272 * visible. Level 3 is cached because its parent is visible. Level 4
3276 gtk_tree_store_append (GTK_TREE_STORE (model), &level1_1, NULL);
3277 gtk_tree_store_append (GTK_TREE_STORE (model), &level1_2, NULL);
3278 gtk_tree_store_append (GTK_TREE_STORE (model), &level2_1, &level1_2);
3279 gtk_tree_store_append (GTK_TREE_STORE (model), &level2_2, &level1_2);
3280 gtk_tree_store_append (GTK_TREE_STORE (model), &level3_1, &level2_2);
3281 gtk_tree_store_append (GTK_TREE_STORE (model), &level3_2, &level2_2);
3282 gtk_tree_store_append (GTK_TREE_STORE (model), &level4_1, &level3_2);
3283 gtk_tree_store_append (GTK_TREE_STORE (model), &level4_2, &level3_2);
3285 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_1, 0, TRUE, -1);
3286 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_2, 0, TRUE, -1);
3287 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_1, 0, TRUE, -1);
3288 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_2, 0, TRUE, -1);
3289 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_1, 0, TRUE, -1);
3290 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_2, 0, TRUE, -1);
3291 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_1, 0, TRUE, -1);
3292 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_2, 0, TRUE, -1);
3294 assert_entire_model_unreferenced (ref_model);
3296 filter_model = gtk_tree_model_filter_new (model, NULL);
3297 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter_model), 0);
3298 tree_view = gtk_tree_view_new_with_model (filter_model);
3300 assert_node_ref_count (ref_model, &level1_1, 2);
3301 assert_node_ref_count (ref_model, &level1_2, 2);
3302 assert_node_ref_count (ref_model, &level2_1, 1);
3303 assert_node_ref_count (ref_model, &level2_2, 0);
3304 assert_node_ref_count (ref_model, &level3_1, 0);
3305 assert_node_ref_count (ref_model, &level3_2, 0);
3306 assert_node_ref_count (ref_model, &level4_1, 0);
3307 assert_node_ref_count (ref_model, &level4_2, 0);
3309 path = gtk_tree_path_new_from_indices (1, -1);
3310 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
3311 gtk_tree_path_free (path);
3313 assert_node_ref_count (ref_model, &level1_1, 2);
3314 assert_node_ref_count (ref_model, &level1_2, 2);
3315 assert_node_ref_count (ref_model, &level2_1, 2);
3316 assert_node_ref_count (ref_model, &level2_2, 2);
3317 assert_node_ref_count (ref_model, &level3_1, 1);
3318 assert_node_ref_count (ref_model, &level3_2, 0);
3319 assert_node_ref_count (ref_model, &level4_1, 0);
3320 assert_node_ref_count (ref_model, &level4_2, 0);
3322 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_1, 0, FALSE, -1);
3324 assert_node_ref_count (ref_model, &level1_1, 2);
3325 assert_node_ref_count (ref_model, &level1_2, 2);
3326 assert_node_ref_count (ref_model, &level2_1, 2);
3327 assert_node_ref_count (ref_model, &level2_2, 2);
3328 assert_node_ref_count (ref_model, &level3_1, 1);
3329 assert_node_ref_count (ref_model, &level3_2, 0);
3330 assert_node_ref_count (ref_model, &level4_1, 0);
3331 assert_node_ref_count (ref_model, &level4_2, 0);
3333 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_1, 0, FALSE, -1);
3335 assert_node_ref_count (ref_model, &level1_1, 2);
3336 assert_node_ref_count (ref_model, &level1_2, 2);
3337 assert_node_ref_count (ref_model, &level2_1, 2);
3338 assert_node_ref_count (ref_model, &level2_2, 2);
3339 assert_node_ref_count (ref_model, &level3_1, 0);
3340 assert_node_ref_count (ref_model, &level3_2, 1);
3341 assert_node_ref_count (ref_model, &level4_1, 0);
3342 assert_node_ref_count (ref_model, &level4_2, 0);
3344 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_2, 0, FALSE, -1);
3346 assert_node_ref_count (ref_model, &level1_1, 2);
3347 assert_node_ref_count (ref_model, &level1_2, 2);
3348 assert_node_ref_count (ref_model, &level2_1, 2);
3349 assert_node_ref_count (ref_model, &level2_2, 0);
3350 assert_node_ref_count (ref_model, &level3_1, 0);
3351 assert_node_ref_count (ref_model, &level3_2, 0);
3352 assert_node_ref_count (ref_model, &level4_1, 0);
3353 assert_node_ref_count (ref_model, &level4_2, 0);
3355 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_2, 0, FALSE, -1);
3357 assert_node_ref_count (ref_model, &level1_1, 2);
3358 assert_node_ref_count (ref_model, &level1_2, 0);
3359 assert_node_ref_count (ref_model, &level2_1, 0);
3360 assert_node_ref_count (ref_model, &level2_2, 0);
3361 assert_node_ref_count (ref_model, &level3_1, 0);
3362 assert_node_ref_count (ref_model, &level3_2, 0);
3363 assert_node_ref_count (ref_model, &level4_1, 0);
3364 assert_node_ref_count (ref_model, &level4_2, 0);
3366 gtk_widget_destroy (tree_view);
3367 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
3369 assert_node_ref_count (ref_model, &level1_1, 1);
3371 g_object_unref (filter_model);
3373 assert_node_ref_count (ref_model, &level1_1, 0);
3375 g_object_unref (ref_model);
3379 ref_count_filter_row_length_gt_1_visible_children (void)
3381 GtkTreeIter level1_1, level1_2;
3382 GtkTreeIter level2_1, level2_2;
3383 GtkTreeIter level3_1, level3_2;
3384 GtkTreeIter level4_1, level4_2;
3385 GtkTreeModel *model;
3386 GtkTreeModelRefCount *ref_model;
3387 GtkTreeModel *filter_model;
3389 GtkWidget *tree_view;
3390 GType column_types[] = { G_TYPE_BOOLEAN };
3392 model = gtk_tree_model_ref_count_new ();
3393 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3395 gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
3409 gtk_tree_store_append (GTK_TREE_STORE (model), &level1_1, NULL);
3410 gtk_tree_store_append (GTK_TREE_STORE (model), &level1_2, NULL);
3411 gtk_tree_store_append (GTK_TREE_STORE (model), &level2_1, &level1_2);
3412 gtk_tree_store_append (GTK_TREE_STORE (model), &level2_2, &level1_2);
3413 gtk_tree_store_append (GTK_TREE_STORE (model), &level3_1, &level2_2);
3414 gtk_tree_store_append (GTK_TREE_STORE (model), &level3_2, &level2_2);
3415 gtk_tree_store_append (GTK_TREE_STORE (model), &level4_1, &level3_2);
3416 gtk_tree_store_append (GTK_TREE_STORE (model), &level4_2, &level3_2);
3418 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_1, 0, TRUE, -1);
3419 gtk_tree_store_set (GTK_TREE_STORE (model), &level1_2, 0, TRUE, -1);
3420 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_1, 0, TRUE, -1);
3421 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_2, 0, TRUE, -1);
3422 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_1, 0, TRUE, -1);
3423 gtk_tree_store_set (GTK_TREE_STORE (model), &level3_2, 0, TRUE, -1);
3424 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_1, 0, TRUE, -1);
3425 gtk_tree_store_set (GTK_TREE_STORE (model), &level4_2, 0, TRUE, -1);
3427 assert_entire_model_unreferenced (ref_model);
3429 filter_model = gtk_tree_model_filter_new (model, NULL);
3430 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter_model), 0);
3431 tree_view = gtk_tree_view_new_with_model (filter_model);
3433 assert_node_ref_count (ref_model, &level1_1, 2);
3434 assert_node_ref_count (ref_model, &level1_2, 2);
3435 assert_node_ref_count (ref_model, &level2_1, 1);
3436 assert_node_ref_count (ref_model, &level2_2, 0);
3437 assert_node_ref_count (ref_model, &level3_1, 0);
3438 assert_node_ref_count (ref_model, &level3_2, 0);
3439 assert_node_ref_count (ref_model, &level4_1, 0);
3440 assert_node_ref_count (ref_model, &level4_2, 0);
3442 path = gtk_tree_path_new_from_indices (1, -1);
3443 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
3444 gtk_tree_path_free (path);
3446 assert_node_ref_count (ref_model, &level1_1, 2);
3447 assert_node_ref_count (ref_model, &level1_2, 2);
3448 assert_node_ref_count (ref_model, &level2_1, 2);
3449 assert_node_ref_count (ref_model, &level2_2, 2);
3450 assert_node_ref_count (ref_model, &level3_1, 2);
3451 assert_node_ref_count (ref_model, &level3_2, 2);
3452 assert_node_ref_count (ref_model, &level4_1, 2);
3453 assert_node_ref_count (ref_model, &level4_2, 1);
3455 gtk_tree_store_set (GTK_TREE_STORE (model), &level2_2, 0, FALSE, -1);
3457 assert_node_ref_count (ref_model, &level1_1, 2);
3458 assert_node_ref_count (ref_model, &level1_2, 2);
3459 assert_node_ref_count (ref_model, &level2_1, 2);
3460 assert_node_ref_count (ref_model, &level2_2, 0);
3461 assert_node_ref_count (ref_model, &level3_1, 0);
3462 assert_node_ref_count (ref_model, &level3_2, 0);
3463 assert_node_ref_count (ref_model, &level4_1, 0);
3464 assert_node_ref_count (ref_model, &level4_2, 0);
3466 gtk_widget_destroy (tree_view);
3467 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
3469 assert_node_ref_count (ref_model, &level1_1, 1);
3470 assert_node_ref_count (ref_model, &level1_2, 1);
3471 assert_node_ref_count (ref_model, &level2_1, 1);
3472 assert_node_ref_count (ref_model, &level2_2, 0);
3473 assert_node_ref_count (ref_model, &level3_1, 0);
3474 assert_node_ref_count (ref_model, &level3_2, 0);
3475 assert_node_ref_count (ref_model, &level4_1, 0);
3476 assert_node_ref_count (ref_model, &level4_2, 0);
3478 g_object_unref (filter_model);
3480 assert_node_ref_count (ref_model, &level1_1, 0);
3481 assert_node_ref_count (ref_model, &level1_2, 0);
3482 assert_node_ref_count (ref_model, &level2_1, 0);
3483 assert_node_ref_count (ref_model, &level2_2, 0);
3484 assert_node_ref_count (ref_model, &level3_1, 0);
3485 assert_node_ref_count (ref_model, &level3_2, 0);
3486 assert_node_ref_count (ref_model, &level4_1, 0);
3487 assert_node_ref_count (ref_model, &level4_2, 0);
3489 g_object_unref (ref_model);
3493 ref_count_cleanup (void)
3495 GtkTreeIter grandparent1, grandparent2, parent1, parent2;
3496 GtkTreeIter iter_parent1, iter_parent2, iter_parent2_first;
3497 GtkTreeModel *model;
3498 GtkTreeModelRefCount *ref_model;
3499 GtkTreeModel *filter_model;
3500 GtkWidget *tree_view;
3502 model = gtk_tree_model_ref_count_new ();
3503 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3510 * + iter_parent2_first
3514 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
3515 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
3516 gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
3517 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
3518 gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
3519 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2_first, &parent2);
3520 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
3522 filter_model = gtk_tree_model_filter_new (model, NULL);
3523 tree_view = gtk_tree_view_new_with_model (filter_model);
3525 gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
3527 assert_node_ref_count (ref_model, &grandparent1, 2);
3528 assert_node_ref_count (ref_model, &grandparent2, 2);
3529 assert_node_ref_count (ref_model, &parent1, 3);
3530 assert_node_ref_count (ref_model, &parent2, 2);
3531 assert_node_ref_count (ref_model, &iter_parent1, 2);
3532 assert_node_ref_count (ref_model, &iter_parent2_first, 2);
3533 assert_node_ref_count (ref_model, &iter_parent2, 1);
3535 gtk_widget_destroy (tree_view);
3537 assert_node_ref_count (ref_model, &grandparent1, 1);
3538 assert_node_ref_count (ref_model, &grandparent2, 1);
3539 assert_node_ref_count (ref_model, &parent1, 2);
3540 assert_node_ref_count (ref_model, &parent2, 1);
3541 assert_node_ref_count (ref_model, &iter_parent1, 1);
3542 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
3543 assert_node_ref_count (ref_model, &iter_parent2, 0);
3545 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
3547 /* The root level and first level remain cached, only the references on the
3548 * first nodes of these levels are kept. Grandparent2 is the parent
3549 * of the first level with parent1, so grandparent2 keeps a reference
3552 assert_node_ref_count (ref_model, &grandparent1, 1);
3553 assert_node_ref_count (ref_model, &grandparent2, 1);
3554 assert_node_ref_count (ref_model, &parent1, 1);
3555 assert_node_ref_count (ref_model, &parent2, 0);
3556 assert_node_ref_count (ref_model, &iter_parent1, 0);
3557 assert_node_ref_count (ref_model, &iter_parent2_first, 0);
3558 assert_node_ref_count (ref_model, &iter_parent2, 0);
3560 g_object_unref (filter_model);
3561 g_object_unref (ref_model);
3565 ref_count_row_ref (void)
3567 GtkTreeIter grandparent1, grandparent2, parent1, parent2;
3568 GtkTreeIter iter_parent1, iter_parent2, iter_parent2_first;
3569 GtkTreeModel *model;
3570 GtkTreeModelRefCount *ref_model;
3571 GtkTreeModel *filter_model;
3572 GtkWidget *tree_view;
3574 GtkTreeRowReference *row_ref;
3576 model = gtk_tree_model_ref_count_new ();
3577 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3588 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
3589 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
3590 gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
3591 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
3592 gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
3593 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2_first, &parent2);
3594 gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
3596 filter_model = gtk_tree_model_filter_new (model, NULL);
3597 tree_view = gtk_tree_view_new_with_model (filter_model);
3599 path = gtk_tree_path_new_from_indices (1, 1, 1, -1);
3600 row_ref = gtk_tree_row_reference_new (filter_model, path);
3601 gtk_tree_path_free (path);
3603 assert_node_ref_count (ref_model, &grandparent1, 2);
3604 assert_node_ref_count (ref_model, &grandparent2, 3);
3605 assert_node_ref_count (ref_model, &parent1, 1);
3606 assert_node_ref_count (ref_model, &parent2, 2);
3607 assert_node_ref_count (ref_model, &iter_parent1, 0);
3608 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
3609 assert_node_ref_count (ref_model, &iter_parent2, 1);
3611 gtk_tree_row_reference_free (row_ref);
3613 assert_node_ref_count (ref_model, &grandparent1, 2);
3614 assert_node_ref_count (ref_model, &grandparent2, 2);
3615 assert_node_ref_count (ref_model, &parent1, 1);
3616 assert_node_ref_count (ref_model, &parent2, 1);
3617 assert_node_ref_count (ref_model, &iter_parent1, 0);
3618 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
3619 assert_node_ref_count (ref_model, &iter_parent2, 0);
3621 path = gtk_tree_path_new_from_indices (1, 1, 1, -1);
3622 row_ref = gtk_tree_row_reference_new (filter_model, path);
3623 gtk_tree_path_free (path);
3625 assert_node_ref_count (ref_model, &grandparent1, 2);
3626 assert_node_ref_count (ref_model, &grandparent2, 3);
3627 assert_node_ref_count (ref_model, &parent1, 1);
3628 assert_node_ref_count (ref_model, &parent2, 2);
3629 assert_node_ref_count (ref_model, &iter_parent1, 0);
3630 assert_node_ref_count (ref_model, &iter_parent2_first, 1);
3631 assert_node_ref_count (ref_model, &iter_parent2, 1);
3633 gtk_tree_store_remove (GTK_TREE_STORE (model), &parent2);
3635 assert_node_ref_count (ref_model, &grandparent1, 2);
3636 assert_node_ref_count (ref_model, &grandparent2, 2);
3637 assert_node_ref_count (ref_model, &parent1, 1);
3638 assert_node_ref_count (ref_model, &iter_parent1, 0);
3640 gtk_tree_row_reference_free (row_ref);
3642 assert_node_ref_count (ref_model, &grandparent1, 2);
3643 assert_node_ref_count (ref_model, &grandparent2, 2);
3644 assert_node_ref_count (ref_model, &parent1, 1);
3645 assert_node_ref_count (ref_model, &iter_parent1, 0);
3647 gtk_widget_destroy (tree_view);
3649 gtk_tree_model_filter_clear_cache (GTK_TREE_MODEL_FILTER (filter_model));
3651 /* The root level and first level remain cached, only the references on the
3652 * first nodes of these levels are kept. Grandparent2 is the parent
3653 * of the first level with parent1, so grandparent2 keeps a reference
3656 assert_node_ref_count (ref_model, &grandparent1, 1);
3657 assert_node_ref_count (ref_model, &grandparent2, 1);
3658 assert_node_ref_count (ref_model, &parent1, 1);
3660 g_object_unref (filter_model);
3661 g_object_unref (ref_model);
3665 ref_count_transfer_root_level_insert (void)
3667 GtkTreeIter grandparent1, grandparent2, grandparent3;
3668 GtkTreeIter new_node;
3669 GtkTreeModel *model;
3670 GtkTreeModelRefCount *ref_model;
3671 GtkTreeModel *filter_model;
3672 GtkWidget *tree_view;
3674 model = gtk_tree_model_ref_count_new ();
3675 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3682 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
3683 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
3684 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent3, NULL);
3686 filter_model = gtk_tree_model_filter_new (model, NULL);
3687 tree_view = gtk_tree_view_new_with_model (filter_model);
3689 assert_node_ref_count (ref_model, &grandparent1, 2);
3690 assert_node_ref_count (ref_model, &grandparent2, 1);
3691 assert_node_ref_count (ref_model, &grandparent3, 1);
3693 gtk_tree_store_prepend (GTK_TREE_STORE (model), &new_node, NULL);
3695 assert_node_ref_count (ref_model, &new_node, 2);
3696 assert_node_ref_count (ref_model, &grandparent1, 1);
3697 assert_node_ref_count (ref_model, &grandparent2, 1);
3698 assert_node_ref_count (ref_model, &grandparent3, 1);
3700 gtk_widget_destroy (tree_view);
3701 g_object_unref (filter_model);
3702 g_object_unref (ref_model);
3706 ref_count_transfer_root_level_reordered (void)
3708 GtkTreeIter grandparent1, grandparent2, grandparent3;
3709 GtkTreeModel *model;
3710 GtkTreeModelRefCount *ref_model;
3711 GtkTreeModel *filter_model;
3712 GtkWidget *tree_view;
3714 model = gtk_tree_model_ref_count_new ();
3715 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3722 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
3723 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
3724 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent3, NULL);
3726 filter_model = gtk_tree_model_filter_new (model, NULL);
3727 tree_view = gtk_tree_view_new_with_model (filter_model);
3729 assert_node_ref_count (ref_model, &grandparent1, 2);
3730 assert_node_ref_count (ref_model, &grandparent2, 1);
3731 assert_node_ref_count (ref_model, &grandparent3, 1);
3733 /* gtk_tree_store_move() will emit rows-reordered */
3734 gtk_tree_store_move_after (GTK_TREE_STORE (model),
3735 &grandparent1, &grandparent3);
3737 assert_node_ref_count (ref_model, &grandparent2, 2);
3738 assert_node_ref_count (ref_model, &grandparent3, 1);
3739 assert_node_ref_count (ref_model, &grandparent1, 1);
3741 gtk_widget_destroy (tree_view);
3742 g_object_unref (filter_model);
3743 g_object_unref (ref_model);
3747 ref_count_transfer_root_level_reordered_filtered (void)
3749 GtkTreeIter grandparent1, grandparent2, grandparent3;
3750 GtkTreeModel *model;
3751 GtkTreeModelRefCount *ref_model;
3752 GtkTreeModel *filter_model;
3753 GtkWidget *tree_view;
3754 GType column_types[] = { G_TYPE_BOOLEAN };
3756 model = gtk_tree_model_ref_count_new ();
3757 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3759 gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
3767 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
3768 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
3769 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent3, NULL);
3771 /* Test with 1 node filtered */
3772 gtk_tree_store_set (GTK_TREE_STORE (model), &grandparent2, 0, TRUE, -1);
3773 gtk_tree_store_set (GTK_TREE_STORE (model), &grandparent3, 0, TRUE, -1);
3775 filter_model = gtk_tree_model_filter_new (model, NULL);
3776 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter_model), 0);
3777 tree_view = gtk_tree_view_new_with_model (filter_model);
3779 assert_node_ref_count (ref_model, &grandparent1, 0);
3780 assert_node_ref_count (ref_model, &grandparent2, 2);
3781 assert_node_ref_count (ref_model, &grandparent3, 1);
3783 /* Move the invisible node grandparent1 */
3785 /* gtk_tree_store_move() will emit rows-reordered */
3786 gtk_tree_store_move_after (GTK_TREE_STORE (model),
3787 &grandparent1, &grandparent3);
3789 assert_node_ref_count (ref_model, &grandparent2, 2);
3790 assert_node_ref_count (ref_model, &grandparent3, 1);
3791 assert_node_ref_count (ref_model, &grandparent1, 0);
3793 /* Move the invisible node grandparent1 */
3795 /* gtk_tree_store_move() will emit rows-reordered */
3796 gtk_tree_store_move_before (GTK_TREE_STORE (model),
3797 &grandparent1, &grandparent2);
3799 assert_node_ref_count (ref_model, &grandparent1, 0);
3800 assert_node_ref_count (ref_model, &grandparent2, 2);
3801 assert_node_ref_count (ref_model, &grandparent3, 1);
3803 /* Now swap grandparent2 and grandparent3, first reference must transfer */
3804 /* gtk_tree_store_swap() will emit rows-reordered */
3805 gtk_tree_store_swap (GTK_TREE_STORE (model),
3806 &grandparent2, &grandparent3);
3808 assert_node_ref_count (ref_model, &grandparent1, 0);
3809 assert_node_ref_count (ref_model, &grandparent3, 2);
3810 assert_node_ref_count (ref_model, &grandparent2, 1);
3813 gtk_tree_store_swap (GTK_TREE_STORE (model),
3814 &grandparent2, &grandparent3);
3816 assert_node_ref_count (ref_model, &grandparent1, 0);
3817 assert_node_ref_count (ref_model, &grandparent2, 2);
3818 assert_node_ref_count (ref_model, &grandparent3, 1);
3820 gtk_tree_store_set (GTK_TREE_STORE (model), &grandparent1, 0, TRUE, -1);
3822 assert_node_ref_count (ref_model, &grandparent1, 2);
3823 assert_node_ref_count (ref_model, &grandparent2, 1);
3824 assert_node_ref_count (ref_model, &grandparent3, 1);
3826 /* Test with two nodes filtered */
3827 gtk_tree_store_set (GTK_TREE_STORE (model), &grandparent1, 0, FALSE, -1);
3828 gtk_tree_store_set (GTK_TREE_STORE (model), &grandparent2, 0, FALSE, -1);
3830 assert_node_ref_count (ref_model, &grandparent1, 0);
3831 assert_node_ref_count (ref_model, &grandparent2, 0);
3832 assert_node_ref_count (ref_model, &grandparent3, 2);
3834 /* gtk_tree_store_move() will emit rows-reordered */
3835 gtk_tree_store_move_before (GTK_TREE_STORE (model),
3836 &grandparent3, &grandparent1);
3838 assert_node_ref_count (ref_model, &grandparent3, 2);
3839 assert_node_ref_count (ref_model, &grandparent2, 0);
3840 assert_node_ref_count (ref_model, &grandparent1, 0);
3842 gtk_widget_destroy (tree_view);
3843 g_object_unref (filter_model);
3844 g_object_unref (ref_model);
3848 ref_count_transfer_child_level_insert (void)
3850 GtkTreeIter grandparent1;
3851 GtkTreeIter parent1, parent2, parent3;
3852 GtkTreeIter new_node;
3853 GtkTreeModel *model;
3854 GtkTreeModelRefCount *ref_model;
3855 GtkTreeModel *filter_model;
3856 GtkWidget *tree_view;
3858 model = gtk_tree_model_ref_count_new ();
3859 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3867 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
3868 gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent1);
3869 gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent1);
3870 gtk_tree_store_append (GTK_TREE_STORE (model), &parent3, &grandparent1);
3872 filter_model = gtk_tree_model_filter_new (model, NULL);
3873 tree_view = gtk_tree_view_new_with_model (filter_model);
3875 assert_node_ref_count (ref_model, &grandparent1, 3);
3876 assert_node_ref_count (ref_model, &parent1, 1);
3877 assert_node_ref_count (ref_model, &parent2, 0);
3878 assert_node_ref_count (ref_model, &parent3, 0);
3880 gtk_tree_store_prepend (GTK_TREE_STORE (model), &new_node, &grandparent1);
3882 assert_node_ref_count (ref_model, &grandparent1, 3);
3883 assert_node_ref_count (ref_model, &new_node, 1);
3884 assert_node_ref_count (ref_model, &parent1, 0);
3885 assert_node_ref_count (ref_model, &parent2, 0);
3886 assert_node_ref_count (ref_model, &parent3, 0);
3888 gtk_widget_destroy (tree_view);
3889 g_object_unref (filter_model);
3890 g_object_unref (ref_model);
3894 ref_count_transfer_child_level_reordered (void)
3896 GtkTreeIter grandparent1;
3897 GtkTreeIter parent1, parent2, parent3;
3898 GtkTreeModel *model;
3899 GtkTreeModelRefCount *ref_model;
3900 GtkTreeModel *filter_model;
3901 GtkWidget *tree_view;
3903 model = gtk_tree_model_ref_count_new ();
3904 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3912 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
3913 gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent1);
3914 gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent1);
3915 gtk_tree_store_append (GTK_TREE_STORE (model), &parent3, &grandparent1);
3917 filter_model = gtk_tree_model_filter_new (model, NULL);
3918 tree_view = gtk_tree_view_new_with_model (filter_model);
3920 assert_node_ref_count (ref_model, &grandparent1, 3);
3921 assert_node_ref_count (ref_model, &parent1, 1);
3922 assert_node_ref_count (ref_model, &parent2, 0);
3923 assert_node_ref_count (ref_model, &parent3, 0);
3925 /* gtk_tree_store_move() will emit rows-reordered */
3926 gtk_tree_store_move_after (GTK_TREE_STORE (model),
3927 &parent1, &parent3);
3929 assert_node_ref_count (ref_model, &grandparent1, 3);
3930 assert_node_ref_count (ref_model, &parent2, 1);
3931 assert_node_ref_count (ref_model, &parent3, 0);
3932 assert_node_ref_count (ref_model, &parent1, 0);
3934 gtk_widget_destroy (tree_view);
3935 g_object_unref (filter_model);
3936 g_object_unref (ref_model);
3940 ref_count_transfer_child_level_reordered_filtered (void)
3942 GtkTreeIter grandparent1;
3943 GtkTreeIter parent1, parent2, parent3;
3944 GtkTreeModel *model;
3945 GtkTreeModelRefCount *ref_model;
3946 GtkTreeModel *filter_model;
3947 GtkWidget *tree_view;
3948 GType column_types[] = { G_TYPE_BOOLEAN };
3950 model = gtk_tree_model_ref_count_new ();
3951 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
3953 gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
3962 gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
3963 gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent1);
3964 gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent1);
3965 gtk_tree_store_append (GTK_TREE_STORE (model), &parent3, &grandparent1);
3967 /* Test with 1 node filtered (parent1) */
3968 gtk_tree_store_set (GTK_TREE_STORE (model), &grandparent1, 0, TRUE, -1);
3969 gtk_tree_store_set (GTK_TREE_STORE (model), &parent2, 0, TRUE, -1);
3970 gtk_tree_store_set (GTK_TREE_STORE (model), &parent3, 0, TRUE, -1);
3972 filter_model = gtk_tree_model_filter_new (model, NULL);
3973 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter_model), 0);
3974 tree_view = gtk_tree_view_new_with_model (filter_model);
3976 assert_node_ref_count (ref_model, &grandparent1, 3);
3977 assert_node_ref_count (ref_model, &parent1, 0);
3978 assert_node_ref_count (ref_model, &parent2, 1);
3979 assert_node_ref_count (ref_model, &parent3, 0);
3981 /* Move invisible node parent 1 */
3983 /* gtk_tree_store_move() will emit rows-reordered */
3984 gtk_tree_store_move_after (GTK_TREE_STORE (model),
3985 &parent1, &parent3);
3987 assert_node_ref_count (ref_model, &grandparent1, 3);
3988 assert_node_ref_count (ref_model, &parent2, 1);
3989 assert_node_ref_count (ref_model, &parent3, 0);
3990 assert_node_ref_count (ref_model, &parent1, 0);
3992 /* Move invisible node parent 1 */
3994 /* gtk_tree_store_move() will emit rows-reordered */
3995 gtk_tree_store_move_before (GTK_TREE_STORE (model),
3996 &parent1, &parent2);
3998 assert_node_ref_count (ref_model, &grandparent1, 3);
3999 assert_node_ref_count (ref_model, &parent1, 0);
4000 assert_node_ref_count (ref_model, &parent2, 1);
4001 assert_node_ref_count (ref_model, &parent3, 0);
4003 /* Now swap parent2 and parent2, first reference must transfer */
4004 /* gtk_tree_store_swap() will emit rows-reordered */
4005 gtk_tree_store_swap (GTK_TREE_STORE (model),
4006 &parent2, &parent3);
4008 assert_node_ref_count (ref_model, &grandparent1, 3);
4009 assert_node_ref_count (ref_model, &parent1, 0);
4010 assert_node_ref_count (ref_model, &parent3, 1);
4011 assert_node_ref_count (ref_model, &parent2, 0);
4014 gtk_tree_store_swap (GTK_TREE_STORE (model),
4015 &parent2, &parent3);
4017 assert_node_ref_count (ref_model, &grandparent1, 3);
4018 assert_node_ref_count (ref_model, &parent1, 0);
4019 assert_node_ref_count (ref_model, &parent2, 1);
4020 assert_node_ref_count (ref_model, &parent3, 0);
4022 gtk_tree_store_set (GTK_TREE_STORE (model), &parent1, 0, TRUE, -1);
4024 assert_node_ref_count (ref_model, &parent1, 1);
4025 assert_node_ref_count (ref_model, &parent2, 0);
4026 assert_node_ref_count (ref_model, &parent3, 0);
4028 /* Test with two nodes filtered */
4029 gtk_tree_store_set (GTK_TREE_STORE (model), &parent1, 0, FALSE, -1);
4030 gtk_tree_store_set (GTK_TREE_STORE (model), &parent2, 0, FALSE, -1);
4032 assert_node_ref_count (ref_model, &parent1, 0);
4033 assert_node_ref_count (ref_model, &parent2, 0);
4034 assert_node_ref_count (ref_model, &parent3, 1);
4036 /* gtk_tree_store_move() will emit rows-reordered */
4037 gtk_tree_store_move_before (GTK_TREE_STORE (model),
4038 &parent3, &parent1);
4040 assert_node_ref_count (ref_model, &parent3, 1);
4041 assert_node_ref_count (ref_model, &parent2, 0);
4042 assert_node_ref_count (ref_model, &parent1, 0);
4044 gtk_widget_destroy (tree_view);
4045 g_object_unref (filter_model);
4046 g_object_unref (ref_model);
4050 specific_path_dependent_filter_func (GtkTreeModel *model,
4056 path = gtk_tree_model_get_path (model, iter);
4057 if (gtk_tree_path_get_indices (path)[0] < 4)
4064 specific_path_dependent_filter (void)
4070 GtkTreeModel *filter;
4072 list = gtk_list_store_new (1, G_TYPE_INT);
4073 gtk_list_store_insert_with_values (list, &iter, 0, 0, 1, -1);
4074 gtk_list_store_insert_with_values (list, &iter, 1, 0, 2, -1);
4075 gtk_list_store_insert_with_values (list, &iter, 2, 0, 3, -1);
4076 gtk_list_store_insert_with_values (list, &iter, 3, 0, 4, -1);
4077 gtk_list_store_insert_with_values (list, &iter, 4, 0, 5, -1);
4078 gtk_list_store_insert_with_values (list, &iter, 5, 0, 6, -1);
4079 gtk_list_store_insert_with_values (list, &iter, 6, 0, 7, -1);
4080 gtk_list_store_insert_with_values (list, &iter, 7, 0, 8, -1);
4082 sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (list));
4083 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (sort), NULL);
4084 gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
4085 specific_path_dependent_filter_func,
4088 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort), 0,
4089 GTK_SORT_DESCENDING);
4091 for (i = 0; i < 4; i++)
4093 if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (list), &iter,
4095 gtk_list_store_remove (list, &iter);
4097 if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (list), &iter,
4099 gtk_list_store_remove (list, &iter);
4102 g_object_unref (filter);
4103 g_object_unref (sort);
4104 g_object_unref (list);
4109 specific_append_after_collapse_visible_func (GtkTreeModel *model,
4114 gboolean hide_negative_numbers;
4116 gtk_tree_model_get (model, iter, 1, &number, -1);
4117 hide_negative_numbers = GPOINTER_TO_INT (g_object_get_data (data, "private-hide-negative-numbers"));
4119 return (number >= 0 || !hide_negative_numbers);
4123 specific_append_after_collapse (void)
4125 /* This test is based on one of the test cases I found in my
4126 * old test cases directory. I unfortunately do not have a record
4127 * from who this test case originated. -Kris.
4131 * - Show tree, expand, collapse.
4136 GtkTreeIter child_iter;
4137 GtkTreeIter child_iter2;
4138 GtkTreePath *append_path;
4139 GtkTreeStore *store;
4140 GtkTreeModel *filter;
4144 GtkWidget *tree_view;
4146 store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_INT);
4148 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
4149 g_object_set_data (G_OBJECT (filter), "private-hide-negative-numbers",
4150 GINT_TO_POINTER (FALSE));
4151 gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
4152 specific_append_after_collapse_visible_func,
4155 sort = gtk_tree_model_sort_new_with_model (filter);
4157 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4158 tree_view = gtk_tree_view_new_with_model (sort);
4159 gtk_container_add (GTK_CONTAINER (window), tree_view);
4160 gtk_widget_realize (tree_view);
4162 while (gtk_events_pending ())
4163 gtk_main_iteration ();
4165 gtk_tree_store_prepend (store, &iter, NULL);
4166 gtk_tree_store_set (store, &iter,
4167 0, "hallo", 1, 1, -1);
4169 gtk_tree_store_append (store, &child_iter, &iter);
4170 gtk_tree_store_set (store, &child_iter,
4171 0, "toemaar", 1, 1, -1);
4173 gtk_tree_store_append (store, &child_iter2, &child_iter);
4174 gtk_tree_store_set (store, &child_iter2,
4175 0, "very deep", 1, 1, -1);
4177 append_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &child_iter2);
4179 gtk_tree_store_append (store, &child_iter, &iter);
4180 gtk_tree_store_set (store, &child_iter,
4181 0, "sja", 1, 1, -1);
4183 gtk_tree_store_append (store, &child_iter, &iter);
4184 gtk_tree_store_set (store, &child_iter,
4185 0, "some word", 1, -1, -1);
4187 /* Expand and collapse the tree */
4188 gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
4189 while (gtk_events_pending ())
4190 gtk_main_iteration ();
4192 gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view));
4193 while (gtk_events_pending ())
4194 gtk_main_iteration ();
4196 /* Add another it */
4197 g_object_set_data (G_OBJECT (filter), "private-hide-negative-numbers",
4198 GINT_TO_POINTER (TRUE));
4200 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, append_path))
4202 gtk_tree_store_append (store, &child_iter, &iter);
4203 gtk_tree_store_set (store, &child_iter,
4204 0, "new new new !!", 1, 1, -1);
4206 gtk_tree_path_free (append_path);
4209 gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
4210 while (gtk_events_pending ())
4211 gtk_main_iteration ();
4216 specific_sort_filter_remove_node_compare_func (GtkTreeModel *model,
4225 specific_sort_filter_remove_node_visible_func (GtkTreeModel *model,
4231 /* Do reference the model */
4232 gtk_tree_model_get (model, iter, 0, &item, -1);
4239 specific_sort_filter_remove_node (void)
4241 /* This test is based on one of the test cases I found in my
4242 * old test cases directory. I unfortunately do not have a record
4243 * from who this test case originated. -Kris.
4246 * - Create tree store, sort, filter models. The sort model has
4247 * a default sort func that is enabled, filter model a visible func
4248 * that defaults to returning FALSE.
4249 * - Remove a node from the tree store.
4253 GtkTreeStore *store;
4254 GtkTreeModel *filter;
4258 GtkWidget *tree_view;
4260 store = gtk_tree_store_new (1, G_TYPE_STRING);
4261 gtk_tree_store_append (store, &iter, NULL);
4262 gtk_tree_store_set (store, &iter, 0, "Hello1", -1);
4264 gtk_tree_store_append (store, &iter, NULL);
4265 gtk_tree_store_set (store, &iter, 0, "Hello2", -1);
4267 sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
4268 gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (sort),
4269 specific_sort_filter_remove_node_compare_func, NULL, NULL);
4271 filter = gtk_tree_model_filter_new (sort, NULL);
4272 gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
4273 specific_sort_filter_remove_node_visible_func,
4277 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
4278 tree_view = gtk_tree_view_new_with_model (filter);
4279 gtk_container_add (GTK_CONTAINER (window), tree_view);
4280 gtk_widget_realize (tree_view);
4282 while (gtk_events_pending ())
4283 gtk_main_iteration ();
4286 gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
4287 gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
4288 gtk_tree_store_remove (store, &iter);
4290 while (gtk_events_pending ())
4291 gtk_main_iteration ();
4296 specific_sort_filter_remove_root (void)
4298 /* This test is based on one of the test cases I found in my
4299 * old test cases directory. I unfortunately do not have a record
4300 * from who this test case originated. -Kris.
4303 GtkTreeModel *model, *sort, *filter;
4304 GtkTreeIter root, mid, leaf;
4307 model = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT));
4308 gtk_tree_store_append (GTK_TREE_STORE (model), &root, NULL);
4309 gtk_tree_store_append (GTK_TREE_STORE (model), &mid, &root);
4310 gtk_tree_store_append (GTK_TREE_STORE (model), &leaf, &mid);
4312 path = gtk_tree_model_get_path (model, &mid);
4314 sort = gtk_tree_model_sort_new_with_model (model);
4315 filter = gtk_tree_model_filter_new (sort, path);
4317 gtk_tree_path_free (path);
4319 gtk_tree_store_remove (GTK_TREE_STORE (model), &root);
4321 g_object_unref (filter);
4322 g_object_unref (sort);
4323 g_object_unref (model);
4328 specific_root_mixed_visibility (void)
4331 GtkTreeModel *filter;
4332 /* A bit nasty, apologies */
4335 fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
4337 for (i = 0; i < LEVEL_LENGTH; i++)
4341 gtk_tree_store_insert (fixture.store, &iter, NULL, i);
4343 create_tree_store_set_values (fixture.store, &iter, TRUE);
4345 create_tree_store_set_values (fixture.store, &iter, FALSE);
4348 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture.store), NULL);
4349 fixture.filter = GTK_TREE_MODEL_FILTER (filter);
4350 fixture.monitor = NULL;
4352 gtk_tree_model_filter_set_visible_column (fixture.filter, 1);
4354 /* In order to trigger the potential bug, we should not access
4355 * the filter model here (so don't call the check functions).
4358 /* Change visibility of an odd row to TRUE */
4359 set_path_visibility (&fixture, "3", TRUE);
4360 check_filter_model (&fixture);
4361 check_level_length (fixture.filter, NULL, 4);
4367 specific_has_child_filter_filter_func (GtkTreeModel *model,
4371 return gtk_tree_model_iter_has_child (model, iter);
4375 specific_has_child_filter (void)
4377 GtkTreeModel *filter;
4378 GtkTreeIter iter, root;
4379 FilterTest fixture; /* This is not how it should be done */
4380 GtkWidget *tree_view;
4382 fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
4383 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture.store), NULL);
4384 fixture.filter = GTK_TREE_MODEL_FILTER (filter);
4385 fixture.monitor = signal_monitor_new (filter);
4387 tree_view = gtk_tree_view_new_with_model (filter);
4389 /* We will filter on parent state using a filter function. We will
4390 * manually keep the boolean column in sync, so that we can use
4391 * check_filter_model() to check the consistency of the model.
4393 /* FIXME: We need a check_filter_model() that is not tied to LEVEL_LENGTH
4394 * to be able to check the structure here. We keep the calls to
4395 * check_filter_model() commented out until then.
4397 gtk_tree_model_filter_set_visible_func (fixture.filter,
4398 specific_has_child_filter_filter_func,
4401 /* The first node will be initially invisible: no signals */
4402 gtk_tree_store_append (fixture.store, &root, NULL);
4403 create_tree_store_set_values (fixture.store, &root, FALSE);
4405 /* check_filter_model (&fixture); */
4406 check_level_length (fixture.filter, NULL, 0);
4407 signal_monitor_assert_is_empty (fixture.monitor);
4409 /* Insert a child node. This will cause the parent to become visible
4410 * since there is a child now.
4412 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "0");
4413 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4414 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4416 gtk_tree_store_append (fixture.store, &iter, &root);
4417 create_tree_store_set_values (fixture.store, &iter, TRUE);
4419 /* Parent must now be visible. Do the level length check first,
4420 * to avoid modifying the child model triggering a row-changed to
4423 check_level_length (fixture.filter, NULL, 1);
4424 check_level_length (fixture.filter, "0", 0);
4425 signal_monitor_assert_is_empty (fixture.monitor);
4427 /* This should propagate row-changed */
4428 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "0");
4429 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4431 set_path_visibility (&fixture, "0", TRUE);
4432 /* check_filter_model (&fixture); */
4433 signal_monitor_assert_is_empty (fixture.monitor);
4435 /* New root node, no child, so no signal */
4436 gtk_tree_store_append (fixture.store, &root, NULL);
4437 check_level_length (fixture.filter, NULL, 1);
4438 signal_monitor_assert_is_empty (fixture.monitor);
4440 /* When the child comes in, this node will become visible */
4441 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "1");
4442 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4443 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4444 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "1");
4445 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4447 gtk_tree_store_append (fixture.store, &iter, &root);
4448 check_level_length (fixture.filter, NULL, 2);
4449 check_level_length (fixture.filter, "1", 0);
4451 create_tree_store_set_values (fixture.store, &root, TRUE);
4452 create_tree_store_set_values (fixture.store, &iter, TRUE);
4454 /* check_filter_model (&fixture); */
4455 signal_monitor_assert_is_empty (fixture.monitor);
4457 /* Add another child for 1 */
4458 gtk_tree_store_append (fixture.store, &iter, &root);
4459 create_tree_store_set_values (fixture.store, &iter, TRUE);
4460 check_level_length (fixture.filter, NULL, 2);
4461 check_level_length (fixture.filter, "0", 0);
4462 check_level_length (fixture.filter, "1", 0);
4463 signal_monitor_assert_is_empty (fixture.monitor);
4465 /* Now remove one of the remaining child rows */
4466 signal_monitor_append_signal (fixture.monitor, ROW_DELETED, "0");
4468 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture.store),
4470 gtk_tree_store_remove (fixture.store, &iter);
4472 check_level_length (fixture.filter, NULL, 1);
4473 check_level_length (fixture.filter, "0", 0);
4475 set_path_visibility (&fixture, "0", FALSE);
4476 /* check_filter_model (&fixture); */
4477 signal_monitor_assert_is_empty (fixture.monitor);
4482 specific_root_has_child_filter_filter_func (GtkTreeModel *model,
4489 path = gtk_tree_model_get_path (model, iter);
4490 depth = gtk_tree_path_get_depth (path);
4491 gtk_tree_path_free (path);
4496 return gtk_tree_model_iter_has_child (model, iter);
4500 specific_root_has_child_filter (void)
4502 GtkTreeModel *filter;
4503 GtkTreeIter iter, root;
4504 FilterTest fixture; /* This is not how it should be done ... */
4505 GtkWidget *tree_view;
4507 /* This is a variation on the above test case, specific has-child-filter,
4508 * herein the has-child check for visibility only applies to root level
4509 * nodes. In this test, children are always visible because we
4510 * only filter based on the "has child" criterion.
4513 fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
4514 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture.store), NULL);
4515 fixture.filter = GTK_TREE_MODEL_FILTER (filter);
4516 fixture.monitor = signal_monitor_new (filter);
4518 tree_view = gtk_tree_view_new_with_model (filter);
4520 /* We will filter on parent state using a filter function. We will
4521 * manually keep the boolean column in sync, so that we can use
4522 * check_filter_model() to check the consistency of the model.
4524 /* FIXME: We need a check_filter_model() that is not tied to LEVEL_LENGTH
4525 * to be able to check the structure here. We keep the calls to
4526 * check_filter_model() commented out until then.
4528 gtk_tree_model_filter_set_visible_func (fixture.filter,
4529 specific_root_has_child_filter_filter_func,
4532 /* Add a first node, this will be invisible initially, so no signal
4533 * should be emitted.
4535 gtk_tree_store_append (fixture.store, &root, NULL);
4536 create_tree_store_set_values (fixture.store, &root, FALSE);
4538 signal_monitor_assert_is_empty (fixture.monitor);
4539 /* check_filter_model (&fixture); */
4540 check_level_length (fixture.filter, NULL, 0);
4542 /* Add a child node. This will cause the parent to become visible,
4543 * so we expect row-inserted signals for both.
4545 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "0");
4546 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4547 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4549 gtk_tree_store_append (fixture.store, &iter, &root);
4550 signal_monitor_assert_is_empty (fixture.monitor);
4552 check_level_length (fixture.filter, NULL, 1);
4553 check_level_length (fixture.filter, "0", 1);
4555 /* Modify the content of iter, no signals because the parent is not
4558 create_tree_store_set_values (fixture.store, &iter, TRUE);
4559 signal_monitor_assert_is_empty (fixture.monitor);
4561 /* Parent must now be visible. Do the level length check first,
4562 * to avoid modifying the child model triggering a row-changed to
4565 check_level_length (fixture.filter, NULL, 1);
4566 check_level_length (fixture.filter, "0", 1);
4569 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "0");
4570 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4572 set_path_visibility (&fixture, "0", TRUE);
4573 /* check_filter_model (&fixture); */
4575 signal_monitor_assert_is_empty (fixture.monitor);
4577 /* Insert another node in the root level. Initially invisible, so
4578 * not expecting any signal.
4580 gtk_tree_store_append (fixture.store, &root, NULL);
4581 check_level_length (fixture.filter, NULL, 1);
4583 signal_monitor_assert_is_empty (fixture.monitor);
4585 /* Adding a child node which also makes parent at path 1 visible. */
4586 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "1");
4587 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4588 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4590 gtk_tree_store_append (fixture.store, &iter, &root);
4591 check_level_length (fixture.filter, NULL, 2);
4592 check_level_length (fixture.filter, "1", 1);
4594 signal_monitor_assert_is_empty (fixture.monitor);
4596 /* Check if row-changed is propagated */
4597 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "1");
4598 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4600 create_tree_store_set_values (fixture.store, &root, TRUE);
4601 create_tree_store_set_values (fixture.store, &iter, TRUE);
4602 /* check_filter_model (&fixture); */
4603 signal_monitor_assert_is_empty (fixture.monitor);
4605 /* Insert another child under node 1 */
4606 gtk_tree_store_append (fixture.store, &iter, &root);
4607 create_tree_store_set_values (fixture.store, &iter, TRUE);
4608 check_level_length (fixture.filter, NULL, 2);
4609 check_level_length (fixture.filter, "0", 1);
4610 check_level_length (fixture.filter, "1", 2);
4611 signal_monitor_assert_is_empty (fixture.monitor);
4613 /* Set a child node to invisible. This should not yield any
4614 * change, because filtering is only done on whether the root
4615 * node has a child, which it still has.
4617 set_path_visibility (&fixture, "0:0", FALSE);
4618 signal_monitor_assert_is_empty (fixture.monitor);
4620 /* Now remove one of the remaining child rows */
4621 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4622 signal_monitor_append_signal (fixture.monitor, ROW_DELETED, "0");
4624 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture.store),
4626 gtk_tree_store_remove (fixture.store, &iter);
4628 check_level_length (fixture.filter, NULL, 1);
4629 check_level_length (fixture.filter, "0", 2);
4630 signal_monitor_assert_is_empty (fixture.monitor);
4632 /* Set visibility of 0 to FALSE, no-op for filter model since
4633 * the child 0:0 is already gone
4635 set_path_visibility (&fixture, "0", FALSE);
4636 /* check_filter_model (&fixture); */
4637 signal_monitor_assert_is_empty (fixture.monitor);
4641 specific_has_child_filter_on_sort_model (void)
4643 GtkTreeModel *filter;
4644 GtkTreeModel *sort_model;
4645 GtkTreeIter iter, root;
4646 FilterTest fixture; /* This is not how it should be done */
4647 GtkWidget *tree_view;
4649 fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
4650 sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (fixture.store));
4651 filter = gtk_tree_model_filter_new (sort_model, NULL);
4652 fixture.filter = GTK_TREE_MODEL_FILTER (filter);
4653 fixture.monitor = signal_monitor_new (filter);
4655 tree_view = gtk_tree_view_new_with_model (filter);
4657 /* We will filter on parent state using a filter function. We will
4658 * manually keep the boolean column in sync, so that we can use
4659 * check_filter_model() to check the consistency of the model.
4661 /* FIXME: We need a check_filter_model() that is not tied to LEVEL_LENGTH
4662 * to be able to check the structure here. We keep the calls to
4663 * check_filter_model() commented out until then.
4665 gtk_tree_model_filter_set_visible_func (fixture.filter,
4666 specific_has_child_filter_filter_func,
4669 /* The first node will be initially invisible: no signals */
4670 gtk_tree_store_append (fixture.store, &root, NULL);
4671 create_tree_store_set_values (fixture.store, &root, FALSE);
4673 /* check_filter_model (&fixture); */
4674 check_level_length (fixture.filter, NULL, 0);
4675 signal_monitor_assert_is_empty (fixture.monitor);
4677 /* Insert a child node. This will cause the parent to become visible
4678 * since there is a child now.
4680 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "0");
4681 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4683 gtk_tree_store_append (fixture.store, &iter, &root);
4684 create_tree_store_set_values (fixture.store, &iter, TRUE);
4686 /* Parent must now be visible. Do the level length check first,
4687 * to avoid modifying the child model triggering a row-changed to
4690 check_level_length (fixture.filter, NULL, 1);
4691 check_level_length (fixture.filter, "0", 0);
4692 signal_monitor_assert_is_empty (fixture.monitor);
4694 /* This should propagate row-changed */
4695 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "0");
4696 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4698 set_path_visibility (&fixture, "0", TRUE);
4699 /* check_filter_model (&fixture); */
4700 signal_monitor_assert_is_empty (fixture.monitor);
4702 /* New root node, no child, so no signal */
4703 gtk_tree_store_append (fixture.store, &root, NULL);
4704 check_level_length (fixture.filter, NULL, 1);
4705 signal_monitor_assert_is_empty (fixture.monitor);
4707 /* When the child comes in, this node will become visible */
4708 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "1");
4709 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4710 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "1");
4711 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4713 gtk_tree_store_append (fixture.store, &iter, &root);
4714 check_level_length (fixture.filter, NULL, 2);
4715 check_level_length (fixture.filter, "1", 0);
4717 create_tree_store_set_values (fixture.store, &root, TRUE);
4718 create_tree_store_set_values (fixture.store, &iter, TRUE);
4720 /* check_filter_model (&fixture); */
4721 signal_monitor_assert_is_empty (fixture.monitor);
4723 /* Add another child for 1 */
4724 gtk_tree_store_append (fixture.store, &iter, &root);
4725 create_tree_store_set_values (fixture.store, &iter, TRUE);
4726 check_level_length (fixture.filter, NULL, 2);
4727 check_level_length (fixture.filter, "0", 0);
4728 check_level_length (fixture.filter, "1", 0);
4729 signal_monitor_assert_is_empty (fixture.monitor);
4731 /* Now remove one of the remaining child rows */
4732 signal_monitor_append_signal (fixture.monitor, ROW_DELETED, "0");
4734 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture.store),
4736 gtk_tree_store_remove (fixture.store, &iter);
4738 check_level_length (fixture.filter, NULL, 1);
4739 check_level_length (fixture.filter, "0", 0);
4741 set_path_visibility (&fixture, "0", FALSE);
4742 /* check_filter_model (&fixture); */
4743 signal_monitor_assert_is_empty (fixture.monitor);
4747 specific_at_least_2_children_filter_filter_func (GtkTreeModel *model,
4751 return gtk_tree_model_iter_n_children (model, iter) >= 2;
4755 specific_at_least_2_children_filter (void)
4757 GtkTreeModel *filter;
4758 GtkTreeIter iter, root;
4759 FilterTest fixture; /* This is not how it should be done */
4760 GtkWidget *tree_view;
4762 fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
4763 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture.store), NULL);
4764 fixture.filter = GTK_TREE_MODEL_FILTER (filter);
4765 fixture.monitor = signal_monitor_new (filter);
4767 tree_view = gtk_tree_view_new_with_model (filter);
4769 gtk_tree_model_filter_set_visible_func (fixture.filter,
4770 specific_at_least_2_children_filter_filter_func,
4773 /* The first node will be initially invisible: no signals */
4774 gtk_tree_store_append (fixture.store, &root, NULL);
4775 create_tree_store_set_values (fixture.store, &root, FALSE);
4777 /* check_filter_model (&fixture); */
4778 check_level_length (fixture.filter, NULL, 0);
4779 signal_monitor_assert_is_empty (fixture.monitor);
4781 /* Insert a child node. Nothing should happen.
4783 gtk_tree_store_append (fixture.store, &iter, &root);
4784 create_tree_store_set_values (fixture.store, &iter, TRUE);
4786 check_level_length (fixture.filter, NULL, 0);
4787 signal_monitor_assert_is_empty (fixture.monitor);
4789 /* Insert a second child node. This will cause the parent to become
4792 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "0");
4793 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4795 gtk_tree_store_append (fixture.store, &iter, &root);
4796 create_tree_store_set_values (fixture.store, &iter, TRUE);
4798 /* Parent must now be visible. Do the level length check first,
4799 * to avoid modifying the child model triggering a row-changed to
4802 check_level_length (fixture.filter, NULL, 1);
4803 check_level_length (fixture.filter, "0", 0);
4804 signal_monitor_assert_is_empty (fixture.monitor);
4806 /* This should propagate row-changed */
4807 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "0");
4808 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4810 set_path_visibility (&fixture, "0", TRUE);
4811 /* check_filter_model (&fixture); */
4812 signal_monitor_assert_is_empty (fixture.monitor);
4814 /* New root node, no child, so no signal */
4815 gtk_tree_store_append (fixture.store, &root, NULL);
4816 check_level_length (fixture.filter, NULL, 1);
4817 signal_monitor_assert_is_empty (fixture.monitor);
4819 /* First child, no signal, no change */
4820 gtk_tree_store_append (fixture.store, &iter, &root);
4821 check_level_length (fixture.filter, NULL, 1);
4822 signal_monitor_assert_is_empty (fixture.monitor);
4824 /* When the second child comes in, this node will become visible */
4825 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "1");
4826 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4827 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "1");
4828 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
4830 gtk_tree_store_append (fixture.store, &iter, &root);
4831 check_level_length (fixture.filter, NULL, 2);
4832 check_level_length (fixture.filter, "1", 0);
4834 create_tree_store_set_values (fixture.store, &root, TRUE);
4835 create_tree_store_set_values (fixture.store, &iter, TRUE);
4837 /* check_filter_model (&fixture); */
4838 signal_monitor_assert_is_empty (fixture.monitor);
4840 /* Add another child for 1 */
4841 gtk_tree_store_append (fixture.store, &iter, &root);
4842 create_tree_store_set_values (fixture.store, &iter, TRUE);
4843 check_level_length (fixture.filter, NULL, 2);
4844 check_level_length (fixture.filter, "0", 0);
4845 check_level_length (fixture.filter, "1", 0);
4846 signal_monitor_assert_is_empty (fixture.monitor);
4848 /* Now remove one of the remaining child rows */
4849 signal_monitor_append_signal (fixture.monitor, ROW_DELETED, "0");
4851 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture.store),
4853 gtk_tree_store_remove (fixture.store, &iter);
4855 check_level_length (fixture.filter, NULL, 1);
4856 check_level_length (fixture.filter, "0", 0);
4858 set_path_visibility (&fixture, "0", FALSE);
4859 /* check_filter_model (&fixture); */
4860 signal_monitor_assert_is_empty (fixture.monitor);
4864 specific_at_least_2_children_filter_on_sort_model (void)
4866 GtkTreeModel *filter;
4867 GtkTreeModel *sort_model;
4868 GtkTreeIter iter, root;
4869 FilterTest fixture; /* This is not how it should be done */
4870 GtkWidget *tree_view;
4872 fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
4873 sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (fixture.store));
4874 filter = gtk_tree_model_filter_new (sort_model, NULL);
4875 fixture.filter = GTK_TREE_MODEL_FILTER (filter);
4876 fixture.monitor = signal_monitor_new (filter);
4878 tree_view = gtk_tree_view_new_with_model (filter);
4880 gtk_tree_model_filter_set_visible_func (fixture.filter,
4881 specific_at_least_2_children_filter_filter_func,
4884 /* The first node will be initially invisible: no signals */
4885 gtk_tree_store_append (fixture.store, &root, NULL);
4886 create_tree_store_set_values (fixture.store, &root, FALSE);
4888 /* check_filter_model (&fixture); */
4889 check_level_length (fixture.filter, NULL, 0);
4890 signal_monitor_assert_is_empty (fixture.monitor);
4892 /* Insert a child node. Nothing should happen.
4894 gtk_tree_store_append (fixture.store, &iter, &root);
4895 create_tree_store_set_values (fixture.store, &iter, TRUE);
4897 check_level_length (fixture.filter, NULL, 0);
4898 signal_monitor_assert_is_empty (fixture.monitor);
4901 GtkTreePath *path = gtk_tree_path_new_from_indices (0, 0, -1);
4902 GtkTreeRowReference *ref;
4904 ref = gtk_tree_row_reference_new (sort_model, path);
4905 gtk_tree_path_free (path);
4908 /* Insert a second child node. This will cause the parent to become
4911 signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "0");
4912 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4914 gtk_tree_store_append (fixture.store, &iter, &root);
4915 create_tree_store_set_values (fixture.store, &iter, TRUE);
4917 /* Parent must now be visible. Do the level length check first,
4918 * to avoid modifying the child model triggering a row-changed to
4921 check_level_length (fixture.filter, NULL, 1);
4922 check_level_length (fixture.filter, "0", 0);
4923 signal_monitor_assert_is_empty (fixture.monitor);
4925 /* This should propagate row-changed */
4926 signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "0");
4927 signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
4929 set_path_visibility (&fixture, "0", TRUE);
4930 /* check_filter_model (&fixture); */
4931 signal_monitor_assert_is_empty (fixture.monitor);
4933 /* New root node, no child, so no signal */
4934 gtk_tree_store_append (fixture.store, &root, NULL);
4935 check_level_length (fixture.filter, NULL, 1);
4936 signal_monitor_assert_is_empty (fixture.monitor);
4941 specific_filter_add_child (void)
4943 /* This test is based on one of the test cases I found in my
4944 * old test cases directory. I unfortunately do not have a record
4945 * from who this test case originated. -Kris.
4949 GtkTreeIter iter_first;
4951 GtkTreeStore *store;
4952 GtkTreeModel *filter G_GNUC_UNUSED;
4954 store = gtk_tree_store_new (1, G_TYPE_STRING);
4956 gtk_tree_store_append (store, &iter_first, NULL);
4957 gtk_tree_store_set (store, &iter_first, 0, "Hello", -1);
4959 gtk_tree_store_append (store, &iter, NULL);
4960 gtk_tree_store_set (store, &iter, 0, "Hello", -1);
4962 gtk_tree_store_append (store, &iter, NULL);
4963 gtk_tree_store_set (store, &iter, 0, "Hello", -1);
4965 gtk_tree_store_append (store, &iter, NULL);
4966 gtk_tree_store_set (store, &iter, 0, "Hello", -1);
4968 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
4970 gtk_tree_store_set (store, &iter, 0, "Hello", -1);
4971 gtk_tree_store_append (store, &child, &iter_first);
4972 gtk_tree_store_set (store, &child, 0, "Hello", -1);
4976 specific_list_store_clear (void)
4980 GtkTreeModel *filter;
4981 GtkWidget *view G_GNUC_UNUSED;
4983 list = gtk_list_store_new (1, G_TYPE_INT);
4984 gtk_list_store_insert_with_values (list, &iter, 0, 0, 1, -1);
4985 gtk_list_store_insert_with_values (list, &iter, 1, 0, 2, -1);
4986 gtk_list_store_insert_with_values (list, &iter, 2, 0, 3, -1);
4987 gtk_list_store_insert_with_values (list, &iter, 3, 0, 4, -1);
4988 gtk_list_store_insert_with_values (list, &iter, 4, 0, 5, -1);
4989 gtk_list_store_insert_with_values (list, &iter, 5, 0, 6, -1);
4990 gtk_list_store_insert_with_values (list, &iter, 6, 0, 7, -1);
4991 gtk_list_store_insert_with_values (list, &iter, 7, 0, 8, -1);
4993 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (list), NULL);
4994 view = gtk_tree_view_new_with_model (filter);
4996 gtk_list_store_clear (list);
5000 specific_sort_ref_leaf_and_remove_ancestor (void)
5002 GtkTreeIter iter, child, child2, child3;
5006 GtkTreeRowReference *rowref;
5007 GtkWidget *view G_GNUC_UNUSED;
5009 tree = gtk_tree_store_new (1, G_TYPE_INT);
5010 gtk_tree_store_insert_with_values (tree, &iter, NULL, 0, 0, 1, -1);
5011 gtk_tree_store_insert_with_values (tree, &iter, NULL, 1, 0, 2, -1);
5012 gtk_tree_store_insert_with_values (tree, &iter, NULL, 2, 0, 3, -1);
5013 gtk_tree_store_insert_with_values (tree, &iter, NULL, 3, 0, 4, -1);
5015 gtk_tree_store_insert_with_values (tree, &child, &iter, 0, 0, 50, -1);
5016 gtk_tree_store_insert_with_values (tree, &child2, &child, 0, 0, 6, -1);
5017 gtk_tree_store_insert_with_values (tree, &child3, &child2, 0, 0, 7, -1);
5019 sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (tree));
5020 view = gtk_tree_view_new_with_model (sort);
5021 gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
5023 path = gtk_tree_path_new_from_indices (3, 0, 0, 0, -1);
5024 rowref = gtk_tree_row_reference_new (sort, path);
5025 gtk_tree_path_free (path);
5027 path = gtk_tree_path_new_from_indices (3, 0, 0, 0, -1);
5028 rowref = gtk_tree_row_reference_new (sort, path);
5029 gtk_tree_path_free (path);
5031 path = gtk_tree_path_new_from_indices (3, 0, -1);
5032 rowref = gtk_tree_row_reference_new (sort, path);
5033 gtk_tree_path_free (path);
5035 path = gtk_tree_path_new_from_indices (3, -1);
5036 rowref = gtk_tree_row_reference_new (sort, path);
5037 gtk_tree_path_free (path);
5039 /* Deleting a parent */
5040 path = gtk_tree_path_new_from_indices (3, 0, -1);
5041 gtk_tree_model_get_iter (GTK_TREE_MODEL (tree), &iter, path);
5042 gtk_tree_store_remove (tree, &iter);
5043 gtk_tree_path_free (path);
5045 gtk_tree_row_reference_free (rowref);
5049 specific_ref_leaf_and_remove_ancestor (void)
5051 GtkTreeIter iter, child, child2, child3;
5053 GtkTreeModel *filter;
5055 GtkTreeRowReference *rowref;
5056 GtkWidget *view G_GNUC_UNUSED;
5058 tree = gtk_tree_store_new (1, G_TYPE_INT);
5059 gtk_tree_store_insert_with_values (tree, &iter, NULL, 0, 0, 1, -1);
5060 gtk_tree_store_insert_with_values (tree, &iter, NULL, 1, 0, 2, -1);
5061 gtk_tree_store_insert_with_values (tree, &iter, NULL, 2, 0, 3, -1);
5062 gtk_tree_store_insert_with_values (tree, &iter, NULL, 3, 0, 4, -1);
5064 gtk_tree_store_insert_with_values (tree, &child, &iter, 0, 0, 50, -1);
5065 gtk_tree_store_insert_with_values (tree, &child2, &child, 0, 0, 6, -1);
5066 gtk_tree_store_insert_with_values (tree, &child3, &child2, 0, 0, 7, -1);
5068 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (tree), NULL);
5069 view = gtk_tree_view_new_with_model (filter);
5070 gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
5072 path = gtk_tree_path_new_from_indices (3, 0, 0, 0, -1);
5073 rowref = gtk_tree_row_reference_new (filter, path);
5074 gtk_tree_path_free (path);
5076 path = gtk_tree_path_new_from_indices (3, 0, 0, 0, -1);
5077 rowref = gtk_tree_row_reference_new (filter, path);
5078 gtk_tree_path_free (path);
5080 path = gtk_tree_path_new_from_indices (3, 0, -1);
5081 rowref = gtk_tree_row_reference_new (filter, path);
5082 gtk_tree_path_free (path);
5084 path = gtk_tree_path_new_from_indices (3, -1);
5085 rowref = gtk_tree_row_reference_new (filter, path);
5086 gtk_tree_path_free (path);
5088 /* Deleting a parent */
5089 path = gtk_tree_path_new_from_indices (3, 0, -1);
5090 gtk_tree_model_get_iter (GTK_TREE_MODEL (tree), &iter, path);
5091 gtk_tree_store_remove (tree, &iter);
5092 gtk_tree_path_free (path);
5094 gtk_tree_row_reference_free (rowref);
5098 specific_virtual_ref_leaf_and_remove_ancestor (void)
5100 GtkTreeIter iter, child, child2, child3;
5102 GtkTreeModel *filter;
5104 GtkTreeRowReference *rowref;
5105 GtkWidget *view G_GNUC_UNUSED;
5107 tree = gtk_tree_store_new (1, G_TYPE_INT);
5108 gtk_tree_store_insert_with_values (tree, &iter, NULL, 0, 0, 1, -1);
5109 gtk_tree_store_insert_with_values (tree, &iter, NULL, 1, 0, 2, -1);
5110 gtk_tree_store_insert_with_values (tree, &iter, NULL, 2, 0, 3, -1);
5111 gtk_tree_store_insert_with_values (tree, &iter, NULL, 3, 0, 4, -1);
5113 gtk_tree_store_insert_with_values (tree, &child, &iter, 0, 0, 50, -1);
5114 gtk_tree_store_insert_with_values (tree, &child2, &child, 0, 0, 6, -1);
5115 gtk_tree_store_insert_with_values (tree, &child3, &child2, 0, 0, 7, -1);
5117 /* Set a virtual root of 3:0 */
5118 path = gtk_tree_path_new_from_indices (3, 0, -1);
5119 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (tree), path);
5120 gtk_tree_path_free (path);
5122 view = gtk_tree_view_new_with_model (filter);
5123 gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
5125 path = gtk_tree_path_new_from_indices (0, 0, -1);
5126 rowref = gtk_tree_row_reference_new (filter, path);
5127 gtk_tree_path_free (path);
5129 path = gtk_tree_path_new_from_indices (0, 0, -1);
5130 rowref = gtk_tree_row_reference_new (filter, path);
5131 gtk_tree_path_free (path);
5133 path = gtk_tree_path_new_from_indices (0, -1);
5134 rowref = gtk_tree_row_reference_new (filter, path);
5135 gtk_tree_path_free (path);
5137 /* Deleting the virtual root */
5138 path = gtk_tree_path_new_from_indices (3, 0, -1);
5139 gtk_tree_model_get_iter (GTK_TREE_MODEL (tree), &iter, path);
5140 gtk_tree_store_remove (tree, &iter);
5141 gtk_tree_path_free (path);
5143 gtk_tree_row_reference_free (rowref);
5148 specific_bug_301558_sort_func (GtkTreeModel *model,
5155 gtk_tree_model_get (model, a, 0, &i, -1);
5156 gtk_tree_model_get (model, b, 0, &j, -1);
5162 specific_bug_301558 (void)
5164 /* Test case for GNOME Bugzilla bug 301558 provided by
5168 GtkTreeModel *filter;
5170 GtkTreeIter root, iter, iter2;
5171 GtkWidget *view G_GNUC_UNUSED;
5175 g_test_bug ("301558");
5177 tree = gtk_tree_store_new (2, G_TYPE_INT, G_TYPE_BOOLEAN);
5178 gtk_tree_store_append (tree, &iter, NULL);
5179 gtk_tree_store_set (tree, &iter, 0, 123, 1, TRUE, -1);
5180 gtk_tree_store_append (tree, &iter2, &iter);
5181 gtk_tree_store_set (tree, &iter2, 0, 73, 1, TRUE, -1);
5183 sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (tree));
5184 gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (sort),
5185 specific_bug_301558_sort_func,
5188 filter = gtk_tree_model_filter_new (sort, NULL);
5189 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter), 1);
5191 view = gtk_tree_view_new_with_model (filter);
5193 while (gtk_events_pending ())
5194 gtk_main_iteration ();
5198 for (i = 0; i < 10; i++)
5200 if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tree), &root))
5201 g_assert_not_reached ();
5205 gtk_tree_store_append (tree, &iter, &root);
5206 gtk_tree_store_set (tree, &iter, 0, 456, 1, TRUE, -1);
5211 n = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (tree), &root);
5212 gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (tree), &iter,
5214 gtk_tree_store_remove (tree, &iter);
5223 specific_bug_311955_filter_func (GtkTreeModel *model,
5229 gtk_tree_model_get (model, iter, 0, &value, -1);
5231 return (value != 0);
5235 specific_bug_311955 (void)
5237 /* This is a test case for GNOME Bugzilla bug 311955. It was written
5240 GtkTreeIter iter, child, root;
5241 GtkTreeStore *store;
5243 GtkTreeModel *filter;
5245 GtkWidget *window G_GNUC_UNUSED;
5246 GtkWidget *tree_view;
5251 g_test_bug ("311955");
5253 store = gtk_tree_store_new (1, G_TYPE_INT);
5255 gtk_tree_store_append (store, &root, NULL);
5256 gtk_tree_store_set (store, &root, 0, 33, -1);
5258 gtk_tree_store_append (store, &iter, &root);
5259 gtk_tree_store_set (store, &iter, 0, 50, -1);
5261 gtk_tree_store_append (store, &iter, NULL);
5262 gtk_tree_store_set (store, &iter, 0, 22, -1);
5264 sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
5265 filter = gtk_tree_model_filter_new (sort, NULL);
5267 gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
5268 specific_bug_311955_filter_func,
5271 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5272 tree_view = gtk_tree_view_new_with_model (filter);
5273 g_object_unref (store);
5275 gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
5277 while (gtk_events_pending ())
5278 gtk_main_iteration ();
5280 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 2);
5281 check_level_length (GTK_TREE_MODEL_FILTER (filter), "0", 1);
5284 for (i = 0; i < 4; i++)
5286 gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &root);
5288 gtk_tree_store_append (store, &iter, &root);
5291 gtk_tree_store_set (store, &iter, 0, i, -1);
5295 gtk_tree_store_append (store, &child, &iter);
5296 gtk_tree_store_set (store, &child, 0, 10, -1);
5300 while (gtk_events_pending ())
5301 gtk_main_iteration ();
5303 check_level_length (GTK_TREE_MODEL_FILTER (filter), "0", 3);
5304 check_level_length (GTK_TREE_MODEL_FILTER (filter), "0:2", 1);
5306 /* Remove bottommost child from the tree. */
5307 gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &root);
5308 n = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), &root);
5310 if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter, &root, n - 2))
5312 if (gtk_tree_model_iter_children (GTK_TREE_MODEL (store), &child, &iter))
5313 gtk_tree_store_remove (store, &child);
5316 g_assert_not_reached ();
5318 path = gtk_tree_path_new_from_indices (0, 2, -1);
5319 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
5320 gtk_tree_path_free (path);
5322 check_level_length (GTK_TREE_MODEL_FILTER (filter), "0", 3);
5323 check_level_length (GTK_TREE_MODEL_FILTER (filter), "0:2", 0);
5327 specific_bug_311955_clean (void)
5329 /* Cleaned up version of the test case for GNOME Bugzilla bug 311955,
5330 * which is easier to understand.
5332 GtkTreeIter iter, child, grandchild;
5333 GtkTreeStore *store;
5335 GtkTreeModel *filter;
5337 GtkWidget *tree_view;
5340 store = gtk_tree_store_new (1, G_TYPE_INT);
5342 gtk_tree_store_append (store, &iter, NULL);
5343 gtk_tree_store_set (store, &iter, 0, 1, -1);
5345 gtk_tree_store_append (store, &child, &iter);
5346 gtk_tree_store_set (store, &child, 0, 1, -1);
5348 sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
5349 filter = gtk_tree_model_filter_new (sort, NULL);
5351 gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
5352 specific_bug_311955_filter_func,
5355 tree_view = gtk_tree_view_new_with_model (filter);
5356 g_object_unref (store);
5358 gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
5360 while (gtk_events_pending ())
5361 gtk_main_iteration ();
5363 check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
5364 check_level_length (GTK_TREE_MODEL_FILTER (filter), "0", 1);
5366 gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
5368 gtk_tree_store_append (store, &child, &iter);
5369 gtk_tree_store_set (store, &child, 0, 0, -1);
5371 gtk_tree_store_append (store, &child, &iter);
5372 gtk_tree_store_set (store, &child, 0, 1, -1);
5374 gtk_tree_store_append (store, &child, &iter);
5375 gtk_tree_store_set (store, &child, 0, 1, -1);
5377 gtk_tree_store_append (store, &grandchild, &child);
5378 gtk_tree_store_set (store, &grandchild, 0, 1, -1);
5380 gtk_tree_store_append (store, &child, &iter);
5381 /* Don't set a value: assume 0 */
5383 /* Remove leaf node, check trigger row-has-child-toggled */
5384 path = gtk_tree_path_new_from_indices (0, 3, 0, -1);
5385 gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, path);
5386 gtk_tree_path_free (path);
5387 gtk_tree_store_remove (store, &iter);
5389 path = gtk_tree_path_new_from_indices (0, 2, -1);
5390 gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
5391 gtk_tree_path_free (path);
5393 check_level_length (GTK_TREE_MODEL_FILTER (filter), "0", 3);
5394 check_level_length (GTK_TREE_MODEL_FILTER (filter), "0:2", 0);
5396 gtk_widget_destroy (tree_view);
5400 specific_bug_346800 (void)
5402 /* This is a test case for GNOME Bugzilla bug 346800. It was written
5403 * by Jonathan Matthew.
5406 GtkTreeIter node_iters[50];
5407 GtkTreeIter child_iters[50];
5408 GtkTreeModel *model;
5409 GtkTreeModelFilter *filter;
5410 GtkTreeStore *store;
5414 columns = g_new (GType, 2);
5415 columns[0] = G_TYPE_STRING;
5416 columns[1] = G_TYPE_BOOLEAN;
5417 store = gtk_tree_store_newv (2, columns);
5418 model = GTK_TREE_MODEL (store);
5420 g_test_bug ("346800");
5422 filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (model, NULL));
5423 gtk_tree_model_filter_set_visible_column (filter, 1);
5425 for (i=0; i<items; i++)
5427 /* allocate random amounts of junk, otherwise the filter model's arrays can expand without moving */
5430 gtk_tree_store_append (store, &node_iters[i], NULL);
5431 gtk_tree_store_set (store, &node_iters[i],
5433 1, ((i%6) == 0) ? FALSE : TRUE,
5437 gtk_tree_store_append (store, &child_iters[i], &node_iters[i]);
5438 gtk_tree_store_set (store, &child_iters[i],
5439 0, "something else",
5442 gtk_tree_model_filter_refilter (filter);
5446 gtk_tree_store_set (GTK_TREE_STORE (model), &child_iters[i-1], 1,
5447 (i & 1) ? TRUE : FALSE, -1);
5448 gtk_tree_model_filter_refilter (filter);
5450 gtk_tree_store_set (GTK_TREE_STORE (model), &child_iters[i-2], 1,
5451 (i & 1) ? FALSE: TRUE, -1);
5452 gtk_tree_model_filter_refilter (filter);
5458 specific_bug_464173_visible_func (GtkTreeModel *model,
5462 gboolean *visible = (gboolean *)data;
5468 specific_bug_464173 (void)
5470 /* Test case for GNOME Bugzilla bug 464173, test case written
5471 * by Andreas Koehler.
5473 GtkTreeStore *model;
5474 GtkTreeModelFilter *f_model;
5475 GtkTreeIter iter1, iter2;
5476 GtkWidget *view G_GNUC_UNUSED;
5477 gboolean visible = TRUE;
5479 g_test_bug ("464173");
5481 model = gtk_tree_store_new (1, G_TYPE_STRING);
5482 gtk_tree_store_append (model, &iter1, NULL);
5483 gtk_tree_store_set (model, &iter1, 0, "Foo", -1);
5484 gtk_tree_store_append (model, &iter2, &iter1);
5485 gtk_tree_store_set (model, &iter2, 0, "Bar", -1);
5487 f_model = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL(model), NULL));
5488 gtk_tree_model_filter_set_visible_func (f_model,
5489 specific_bug_464173_visible_func,
5492 view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (f_model));
5495 gtk_tree_model_filter_refilter (f_model);
5500 specific_bug_540201_filter_func (GtkTreeModel *model,
5504 gboolean has_children;
5506 has_children = gtk_tree_model_iter_has_child (model, iter);
5508 return has_children;
5512 specific_bug_540201 (void)
5514 /* Test case for GNOME Bugzilla bug 540201, steps provided by
5517 GtkTreeIter iter, root;
5518 GtkTreeStore *store;
5519 GtkTreeModel *filter;
5521 GtkWidget *tree_view G_GNUC_UNUSED;
5523 g_test_bug ("540201");
5525 store = gtk_tree_store_new (1, G_TYPE_INT);
5527 gtk_tree_store_append (store, &root, NULL);
5528 gtk_tree_store_set (store, &root, 0, 33, -1);
5530 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
5531 tree_view = gtk_tree_view_new_with_model (filter);
5533 gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
5534 specific_bug_540201_filter_func,
5537 gtk_tree_store_append (store, &iter, &root);
5538 gtk_tree_store_set (store, &iter, 0, 50, -1);
5540 gtk_tree_store_append (store, &iter, &root);
5541 gtk_tree_store_set (store, &iter, 0, 22, -1);
5544 gtk_tree_store_append (store, &root, NULL);
5545 gtk_tree_store_set (store, &root, 0, 33, -1);
5547 gtk_tree_store_append (store, &iter, &root);
5548 gtk_tree_store_set (store, &iter, 0, 22, -1);
5553 specific_bug_549287_visible_func (GtkTreeModel *model,
5557 gboolean result = FALSE;
5559 result = gtk_tree_model_iter_has_child (model, iter);
5565 specific_bug_549287 (void)
5567 /* Test case for GNOME Bugzilla bug 529287, provided by Julient Puydt */
5570 GtkTreeStore *store;
5571 GtkTreeModel *filtered;
5572 GtkWidget *view G_GNUC_UNUSED;
5574 GtkTreeIter *swap, *parent, *child;
5576 g_test_bug ("529287");
5578 store = gtk_tree_store_new (1, G_TYPE_STRING);
5579 filtered = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
5580 gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filtered),
5581 specific_bug_549287_visible_func,
5584 view = gtk_tree_view_new_with_model (filtered);
5586 for (i = 0; i < 4; i++)
5588 if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter))
5590 parent = gtk_tree_iter_copy (&iter);
5591 child = gtk_tree_iter_copy (&iter);
5593 while (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store),
5602 gtk_tree_store_append (store, child, parent);
5603 gtk_tree_store_set (store, child,
5607 gtk_tree_iter_free (parent);
5608 gtk_tree_iter_free (child);
5612 gtk_tree_store_append (store, &iter, NULL);
5613 gtk_tree_store_set (store, &iter,
5618 /* since we inserted something, we changed the visibility conditions: */
5619 gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (filtered));
5624 specific_bug_621076_visible_func (GtkTreeModel *model,
5628 gboolean visible = FALSE;
5631 gtk_tree_model_get (model, iter, 0, &str, -1);
5632 if (str != NULL && g_str_has_prefix (str, "visible"))
5638 GtkTreeIter child_iter;
5641 /* Recursively check if we have a visible child */
5642 for (valid = gtk_tree_model_iter_children (model, &child_iter, iter);
5643 valid; valid = gtk_tree_model_iter_next (model, &child_iter))
5645 if (specific_bug_621076_visible_func (model, &child_iter, data))
5660 specific_bug_621076 (void)
5662 /* Test case for GNOME Bugzilla bug 621076, provided by Xavier Claessens */
5664 /* This test case differs from has-child-filter and root-has-child-filter
5665 * in that the visible function both filters on content and model
5666 * structure. Also, it is recursive.
5669 GtkTreeStore *store;
5670 GtkTreeModel *filter;
5672 GtkTreeIter group_iter;
5673 GtkTreeIter item_iter;
5674 SignalMonitor *monitor;
5676 g_test_bug ("621076");
5678 store = gtk_tree_store_new (1, G_TYPE_STRING);
5679 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
5680 gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
5681 specific_bug_621076_visible_func,
5684 view = gtk_tree_view_new_with_model (filter);
5685 g_object_ref_sink (view);
5687 monitor = signal_monitor_new (filter);
5689 signal_monitor_append_signal (monitor, ROW_INSERTED, "0");
5690 gtk_tree_store_insert_with_values (store, &item_iter, NULL, -1,
5691 0, "visible-group-0",
5693 signal_monitor_assert_is_empty (monitor);
5695 /* visible-group-0 is not expanded, so ROW_INSERTED should not be emitted
5696 * for its children. However, ROW_HAS_CHILD_TOGGLED should be emitted on
5697 * visible-group-0 to tell the view that row can be expanded. */
5698 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "0");
5699 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "0");
5700 group_iter = item_iter;
5701 gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
5704 signal_monitor_assert_is_empty (monitor);
5706 signal_monitor_append_signal (monitor, ROW_INSERTED, "1");
5707 gtk_tree_store_insert_with_values (store, &item_iter, NULL, -1,
5708 0, "visible-group-1",
5710 signal_monitor_assert_is_empty (monitor);
5712 /* We are adding an hidden item inside visible-group-1, so
5713 * ROW_HAS_CHILD_TOGGLED should not be emitted. It is emitted though,
5714 * because the signal originating at TreeStore will be propagated,
5715 * as well a generated signal because the state of the parent *could*
5716 * change by a change in the model.
5718 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1");
5719 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1");
5720 group_iter = item_iter;
5721 gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
5724 signal_monitor_assert_is_empty (monitor);
5726 /* This group is invisible and its parent too. Nothing should be emitted */
5727 group_iter = item_iter;
5728 gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
5731 signal_monitor_assert_is_empty (monitor);
5733 /* Adding a visible item in this group hierarchy will make all nodes
5734 * in this path visible. The first level should simply tell the view
5735 * that it now has a child, and the view will load the tree if needed
5736 * (depends on the expanded state).
5738 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1");
5739 group_iter = item_iter;
5740 gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
5741 0, "visible-1:0:0:0",
5743 signal_monitor_assert_is_empty (monitor);
5745 check_level_length (GTK_TREE_MODEL_FILTER (filter), "1", 1);
5747 gtk_tree_store_insert_with_values (store, &item_iter, NULL, -1,
5750 signal_monitor_assert_is_empty (monitor);
5752 /* Parent is invisible, and adding this invisible item won't change that,
5753 * so no signal should be emitted. */
5754 group_iter = item_iter;
5755 gtk_tree_store_insert_with_values (store, NULL, &group_iter, -1,
5758 signal_monitor_assert_is_empty (monitor);
5760 /* This makes group-2 visible, so it gets inserted and tells it has
5763 signal_monitor_append_signal (monitor, ROW_INSERTED, "2");
5764 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "2");
5765 gtk_tree_store_insert_with_values (store, NULL, &group_iter, -1,
5768 signal_monitor_assert_is_empty (monitor);
5770 /* group-2 is already visible, so this time it is a normal insertion */
5771 gtk_tree_store_insert_with_values (store, NULL, &group_iter, -1,
5774 signal_monitor_assert_is_empty (monitor);
5777 gtk_tree_store_insert_with_values (store, &item_iter, NULL, -1,
5780 signal_monitor_assert_is_empty (monitor);
5782 /* Parent is invisible, and adding this invisible item won't change that,
5783 * so no signal should be emitted. */
5784 group_iter = item_iter;
5785 gtk_tree_store_insert_with_values (store, NULL, &group_iter, -1,
5788 signal_monitor_assert_is_empty (monitor);
5790 gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
5793 signal_monitor_assert_is_empty (monitor);
5795 /* This will make group 3 visible. */
5796 signal_monitor_append_signal (monitor, ROW_INSERTED, "3");
5797 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "3");
5798 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "3");
5799 gtk_tree_store_set (store, &item_iter, 0, "visible-3:1", -1);
5800 signal_monitor_assert_is_empty (monitor);
5802 /* Make sure all groups are expanded, so the filter has the tree cached */
5803 gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
5804 while (gtk_events_pending ())
5805 gtk_main_iteration ();
5807 /* Should only yield a row-changed */
5808 signal_monitor_append_signal (monitor, ROW_CHANGED, "3:0");
5809 gtk_tree_store_set (store, &item_iter, 0, "visible-3:1", -1);
5810 signal_monitor_assert_is_empty (monitor);
5812 /* Now remove/hide some items. If a group loses its last item, the group
5813 * should be deleted instead of the item.
5816 signal_monitor_append_signal (monitor, ROW_DELETED, "2:1");
5817 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &item_iter, "2:2");
5818 gtk_tree_store_remove (store, &item_iter);
5819 signal_monitor_assert_is_empty (monitor);
5821 signal_monitor_append_signal (monitor, ROW_DELETED, "2:0");
5822 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "2");
5823 signal_monitor_append_signal (monitor, ROW_DELETED, "2");
5824 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &item_iter, "2:1");
5825 gtk_tree_store_set (store, &item_iter, 0, "invisible-2:1", -1);
5826 signal_monitor_assert_is_empty (monitor);
5828 signal_monitor_append_signal (monitor, ROW_DELETED, "1:0:0:0");
5829 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1:0:0");
5830 signal_monitor_append_signal (monitor, ROW_DELETED, "1:0");
5831 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1");
5832 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &item_iter, "1:0:0:0");
5833 gtk_tree_store_remove (store, &item_iter);
5834 signal_monitor_assert_is_empty (monitor);
5836 /* Hide a group using row-changed instead of row-deleted */
5837 /* Caution: group 2 is gone, so offsets of the signals have moved. */
5838 signal_monitor_append_signal (monitor, ROW_DELETED, "2:0");
5839 signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "2");
5840 signal_monitor_append_signal (monitor, ROW_DELETED, "2");
5841 gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &item_iter,
5843 gtk_tree_store_set (store, &item_iter, 0, "invisible-3:1", -1);
5844 signal_monitor_assert_is_empty (monitor);
5849 GtkTreeViewColumn *col;
5851 gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
5853 col = gtk_tree_view_column_new_with_attributes ("foo",
5854 gtk_cell_renderer_text_new (),
5856 gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
5858 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
5859 g_signal_connect (window, "delete-event",
5860 G_CALLBACK (gtk_widget_destroy), NULL);
5861 g_signal_connect (window, "destroy",
5862 G_CALLBACK (gtk_main_quit), NULL);
5864 gtk_container_add (GTK_CONTAINER (window), view);
5866 gtk_widget_show (view);
5867 gtk_widget_show (window);
5874 signal_monitor_free (monitor);
5875 g_object_unref (view);
5876 g_object_unref (store);
5877 g_object_unref (filter);
5881 specific_bug_657353_related (void)
5883 GtkTreeIter node1, node2, node3, node4;
5884 GtkTreeModel *model;
5885 GtkTreeModelRefCount *ref_model;
5886 GtkTreeModel *filter_model;
5887 GtkWidget *tree_view;
5888 GType column_types[] = { G_TYPE_BOOLEAN };
5890 /* gtk_tree_model_filter_rows_reordered() used to have a problem to
5891 * not properly transfer the first ref count when the first node in
5892 * the level does not have elt->offset == 0. This test checks for
5893 * that. This bug could cause the faulty condition
5894 * elt->ext_ref_count > elt->ref_count
5898 model = gtk_tree_model_ref_count_new ();
5899 ref_model = GTK_TREE_MODEL_REF_COUNT (model);
5901 gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
5904 gtk_tree_store_append (GTK_TREE_STORE (model), &node1, NULL);
5905 gtk_tree_store_append (GTK_TREE_STORE (model), &node2, NULL);
5906 gtk_tree_store_append (GTK_TREE_STORE (model), &node3, NULL);
5907 gtk_tree_store_append (GTK_TREE_STORE (model), &node4, NULL);
5909 /* Hide the first node */
5910 gtk_tree_store_set (GTK_TREE_STORE (model), &node1, 0, FALSE, -1);
5911 gtk_tree_store_set (GTK_TREE_STORE (model), &node2, 0, TRUE, -1);
5912 gtk_tree_store_set (GTK_TREE_STORE (model), &node3, 0, TRUE, -1);
5913 gtk_tree_store_set (GTK_TREE_STORE (model), &node4, 0, TRUE, -1);
5915 filter_model = gtk_tree_model_filter_new (model, NULL);
5916 gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter_model), 0);
5917 tree_view = gtk_tree_view_new_with_model (filter_model);
5919 assert_node_ref_count (ref_model, &node1, 0);
5920 assert_node_ref_count (ref_model, &node2, 2);
5921 assert_node_ref_count (ref_model, &node3, 1);
5922 assert_node_ref_count (ref_model, &node4, 1);
5924 /* Swap nodes 2 and 3 */
5926 /* gtk_tree_store_swap() will emit rows-reordered */
5927 gtk_tree_store_swap (GTK_TREE_STORE (model),
5930 assert_node_ref_count (ref_model, &node1, 0);
5931 assert_node_ref_count (ref_model, &node3, 2);
5932 assert_node_ref_count (ref_model, &node2, 1);
5933 assert_node_ref_count (ref_model, &node4, 1);
5936 gtk_tree_store_set (GTK_TREE_STORE (model), &node3, 0, FALSE, -1);
5938 assert_node_ref_count (ref_model, &node1, 0);
5939 assert_node_ref_count (ref_model, &node3, 0);
5940 assert_node_ref_count (ref_model, &node2, 2);
5941 assert_node_ref_count (ref_model, &node4, 1);
5943 gtk_widget_destroy (tree_view);
5944 g_object_unref (filter_model);
5945 g_object_unref (ref_model);
5949 specific_bug_658696 (void)
5951 GtkTreeStore *store;
5952 GtkTreeModel *filter;
5956 store = create_tree_store (4, TRUE);
5958 vroot = gtk_tree_path_new_from_indices (0, 0, -1);
5959 filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), vroot);
5960 gtk_tree_path_free (vroot);
5962 /* This used to cause a crash in gtk_tree_model_filter_check_ancestors() */
5963 gtk_tree_store_append (store, &iter, NULL);
5969 register_filter_model_tests (void)
5971 g_test_add ("/TreeModelFilter/self/verify-test-suite",
5975 filter_test_teardown);
5977 g_test_add ("/TreeModelFilter/self/verify-test-suite/vroot/depth-1",
5978 FilterTest, gtk_tree_path_new_from_indices (2, -1),
5980 verify_test_suite_vroot,
5981 filter_test_teardown);
5982 g_test_add ("/TreeModelFilter/self/verify-test-suite/vroot/depth-2",
5983 FilterTest, gtk_tree_path_new_from_indices (2, 3, -1),
5985 verify_test_suite_vroot,
5986 filter_test_teardown);
5989 g_test_add ("/TreeModelFilter/filled/hide-root-level",
5992 filled_hide_root_level,
5993 filter_test_teardown);
5994 g_test_add ("/TreeModelFilter/filled/hide-child-levels",
5997 filled_hide_child_levels,
5998 filter_test_teardown);
5999 g_test_add ("/TreeModelFilter/filled/hide-child-levels/root-expanded",
6002 filled_hide_child_levels_root_expanded,
6003 filter_test_teardown);
6005 g_test_add ("/TreeModelFilter/filled/hide-root-level/vroot",
6006 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6008 filled_vroot_hide_root_level,
6009 filter_test_teardown);
6010 g_test_add ("/TreeModelFilter/filled/hide-child-levels/vroot",
6011 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6013 filled_vroot_hide_child_levels,
6014 filter_test_teardown);
6015 g_test_add ("/TreeModelFilter/filled/hide-child-levels/vroot-root-expanded",
6016 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6018 filled_vroot_hide_child_levels_root_expanded,
6019 filter_test_teardown);
6022 g_test_add ("/TreeModelFilter/empty/show-nodes",
6024 filter_test_setup_empty,
6026 filter_test_teardown);
6027 g_test_add ("/TreeModelFilter/empty/show-multiple-nodes",
6029 filter_test_setup_empty,
6030 empty_show_multiple_nodes,
6031 filter_test_teardown);
6033 g_test_add ("/TreeModelFilter/empty/show-nodes/vroot",
6034 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6035 filter_test_setup_empty,
6036 empty_vroot_show_nodes,
6037 filter_test_teardown);
6038 g_test_add ("/TreeModelFilter/empty/show-multiple-nodes/vroot",
6039 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6040 filter_test_setup_empty,
6041 empty_vroot_show_multiple_nodes,
6042 filter_test_teardown);
6045 g_test_add ("/TreeModelFilter/unfiltered/hide-single",
6047 filter_test_setup_unfiltered,
6048 unfiltered_hide_single,
6049 filter_test_teardown);
6050 g_test_add ("/TreeModelFilter/unfiltered/hide-single/root-expanded",
6052 filter_test_setup_unfiltered_root_expanded,
6053 unfiltered_hide_single_root_expanded,
6054 filter_test_teardown);
6055 g_test_add ("/TreeModelFilter/unfiltered/hide-single-child",
6057 filter_test_setup_unfiltered,
6058 unfiltered_hide_single_child,
6059 filter_test_teardown);
6060 g_test_add ("/TreeModelFilter/unfiltered/hide-single-child/root-expanded",
6062 filter_test_setup_unfiltered_root_expanded,
6063 unfiltered_hide_single_child_root_expanded,
6064 filter_test_teardown);
6065 g_test_add ("/TreeModelFilter/unfiltered/hide-single-multi-level",
6067 filter_test_setup_unfiltered,
6068 unfiltered_hide_single_multi_level,
6069 filter_test_teardown);
6070 g_test_add ("/TreeModelFilter/unfiltered/hide-single-multi-level/root-expanded",
6072 filter_test_setup_unfiltered_root_expanded,
6073 unfiltered_hide_single_multi_level_root_expanded,
6074 filter_test_teardown);
6076 g_test_add ("/TreeModelFilter/unfiltered/hide-single/vroot",
6077 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6078 filter_test_setup_unfiltered,
6079 unfiltered_vroot_hide_single,
6080 filter_test_teardown);
6081 g_test_add ("/TreeModelFilter/unfiltered/hide-single-child/vroot",
6082 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6083 filter_test_setup_unfiltered,
6084 unfiltered_vroot_hide_single_child,
6085 filter_test_teardown);
6086 g_test_add ("/TreeModelFilter/unfiltered/hide-single-child/vroot/root-expanded",
6087 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6088 filter_test_setup_unfiltered_root_expanded,
6089 unfiltered_vroot_hide_single_child_root_expanded,
6090 filter_test_teardown);
6091 g_test_add ("/TreeModelFilter/unfiltered/hide-single-multi-level/vroot",
6092 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6093 filter_test_setup_unfiltered,
6094 unfiltered_vroot_hide_single_multi_level,
6095 filter_test_teardown);
6096 g_test_add ("/TreeModelFilter/unfiltered/hide-single-multi-level/vroot/root-expanded",
6097 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6098 filter_test_setup_unfiltered_root_expanded,
6099 unfiltered_vroot_hide_single_multi_level_root_expanded,
6100 filter_test_teardown);
6104 g_test_add ("/TreeModelFilter/unfiltered/show-single",
6106 filter_test_setup_empty_unfiltered,
6107 unfiltered_show_single,
6108 filter_test_teardown);
6109 g_test_add ("/TreeModelFilter/unfiltered/show-single-child",
6111 filter_test_setup_empty_unfiltered,
6112 unfiltered_show_single_child,
6113 filter_test_teardown);
6114 g_test_add ("/TreeModelFilter/unfiltered/show-single-child/root-expanded",
6116 filter_test_setup_empty_unfiltered_root_expanded,
6117 unfiltered_show_single_child_root_expanded,
6118 filter_test_teardown);
6119 g_test_add ("/TreeModelFilter/unfiltered/show-single-multi-level",
6121 filter_test_setup_empty_unfiltered,
6122 unfiltered_show_single_multi_level,
6123 filter_test_teardown);
6124 g_test_add ("/TreeModelFilter/unfiltered/show-single-multi-level/root-expanded",
6126 filter_test_setup_empty_unfiltered_root_expanded,
6127 unfiltered_show_single_multi_level_root_expanded,
6128 filter_test_teardown);
6130 g_test_add ("/TreeModelFilter/unfiltered/show-single/vroot",
6131 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6132 filter_test_setup_empty_unfiltered,
6133 unfiltered_vroot_show_single,
6134 filter_test_teardown);
6135 g_test_add ("/TreeModelFilter/unfiltered/show-single-child/vroot",
6136 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6137 filter_test_setup_empty_unfiltered,
6138 unfiltered_vroot_show_single_child,
6139 filter_test_teardown);
6140 g_test_add ("/TreeModelFilter/unfiltered/show-single-child/vroot/root-expanded",
6141 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6142 filter_test_setup_empty_unfiltered_root_expanded,
6143 unfiltered_vroot_show_single_child_root_expanded,
6144 filter_test_teardown);
6145 g_test_add ("/TreeModelFilter/unfiltered/show-single-multi-level/vroot",
6146 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6147 filter_test_setup_empty_unfiltered,
6148 unfiltered_vroot_show_single_multi_level,
6149 filter_test_teardown);
6150 g_test_add ("/TreeModelFilter/unfiltered/show-single-multi-level/vroot/root-expanded",
6151 FilterTest, gtk_tree_path_new_from_indices (2, -1),
6152 filter_test_setup_empty_unfiltered_root_expanded,
6153 unfiltered_vroot_show_single_multi_level_root_expanded,
6154 filter_test_teardown);
6157 g_test_add ("/TreeModelFilter/unfiltered/rows-reordered/root-level",
6159 filter_test_setup_unfiltered,
6160 unfiltered_rows_reordered_root_level,
6161 filter_test_teardown);
6162 g_test_add ("/TreeModelFilter/unfiltered/rows-reordered/child-level",
6164 filter_test_setup_unfiltered,
6165 unfiltered_rows_reordered_child_level,
6166 filter_test_teardown);
6168 g_test_add ("/TreeModelFilter/filtered/rows-reordered/root-level/first-hidden",
6171 filtered_rows_reordered_root_level_first_hidden,
6172 filter_test_teardown);
6173 g_test_add ("/TreeModelFilter/filtered/rows-reordered/root-level/middle-hidden",
6176 filtered_rows_reordered_root_level_middle_hidden,
6177 filter_test_teardown);
6178 g_test_add ("/TreeModelFilter/filtered/rows-reordered/child-level/first-hidden",
6181 filtered_rows_reordered_child_level_first_hidden,
6182 filter_test_teardown);
6183 g_test_add ("/TreeModelFilter/filtered/rows-reordered/child-level/middle-hidden",
6186 filtered_rows_reordered_child_level_middle_hidden,
6187 filter_test_teardown);
6188 g_test_add ("/TreeModelFilter/filtered/rows-reordered/child-level/4-hidden",
6191 filtered_rows_reordered_child_level_4_hidden,
6192 filter_test_teardown);
6193 g_test_add ("/TreeModelFilter/filtered/rows-reordered/child-level/all-hidden",
6196 filtered_rows_reordered_child_level_all_hidden,
6197 filter_test_teardown);
6199 /* Inserts in child models after creation of filter model */
6200 g_test_add_func ("/TreeModelFilter/insert/before",
6202 g_test_add_func ("/TreeModelFilter/insert/child",
6205 /* Removals from child model after creating of filter model */
6206 g_test_add_func ("/TreeModelFilter/remove/node",
6208 g_test_add_func ("/TreeModelFilter/remove/node-vroot",
6210 g_test_add_func ("/TreeModelFilter/remove/vroot-ancestor",
6211 remove_vroot_ancestor);
6213 /* Reference counting */
6214 g_test_add_func ("/TreeModelFilter/ref-count/single-level",
6215 ref_count_single_level);
6216 g_test_add_func ("/TreeModelFilter/ref-count/two-levels",
6217 ref_count_two_levels);
6218 g_test_add_func ("/TreeModelFilter/ref-count/three-levels",
6219 ref_count_three_levels);
6220 g_test_add_func ("/TreeModelFilter/ref-count/delete-row",
6221 ref_count_delete_row);
6222 g_test_add_func ("/TreeModelFilter/ref-count/filter-row/length-1",
6223 ref_count_filter_row_length_1);
6224 g_test_add_func ("/TreeModelFilter/ref-count/filter-row/length-1-remove-in-root-level",
6225 ref_count_filter_row_length_1_remove_in_root_level);
6226 g_test_add_func ("/TreeModelFilter/ref-count/filter-row/length-1-remove-in-child-level",
6227 ref_count_filter_row_length_1_remove_in_child_level);
6228 g_test_add_func ("/TreeModelFilter/ref-count/filter-row/length-gt-1",
6229 ref_count_filter_row_length_gt_1);
6230 g_test_add_func ("/TreeModelFilter/ref-count/filter-row/length-gt-1-visible-children",
6231 ref_count_filter_row_length_gt_1_visible_children);
6232 g_test_add_func ("/TreeModelFilter/ref-count/cleanup",
6234 g_test_add_func ("/TreeModelFilter/ref-count/row-ref",
6237 /* Reference counting, transfer of first reference on
6238 * first node in level. This is a GtkTreeModelFilter-specific
6241 g_test_add_func ("/TreeModelFilter/ref-count/transfer/root-level/insert",
6242 ref_count_transfer_root_level_insert);
6243 g_test_add_func ("/TreeModelFilter/ref-count/transfer/root-level/reordered",
6244 ref_count_transfer_root_level_reordered);
6245 g_test_add_func ("/TreeModelFilter/ref-count/transfer/root-level/reordered/filtered",
6246 ref_count_transfer_root_level_reordered_filtered);
6247 g_test_add_func ("/TreeModelFilter/ref-count/transfer/child-level/insert",
6248 ref_count_transfer_child_level_insert);
6249 g_test_add_func ("/TreeModelFilter/ref-count/transfer/child-level/reordered",
6250 ref_count_transfer_child_level_reordered);
6251 g_test_add_func ("/TreeModelFilter/ref-count/transfer/child-level/reordered/filtered",
6252 ref_count_transfer_child_level_reordered_filtered);
6254 g_test_add_func ("/TreeModelFilter/specific/path-dependent-filter",
6255 specific_path_dependent_filter);
6256 g_test_add_func ("/TreeModelFilter/specific/append-after-collapse",
6257 specific_append_after_collapse);
6258 g_test_add_func ("/TreeModelFilter/specific/sort-filter-remove-node",
6259 specific_sort_filter_remove_node);
6260 g_test_add_func ("/TreeModelFilter/specific/sort-filter-remove-root",
6261 specific_sort_filter_remove_root);
6262 g_test_add_func ("/TreeModelFilter/specific/root-mixed-visibility",
6263 specific_root_mixed_visibility);
6264 g_test_add_func ("/TreeModelFilter/specific/has-child-filter",
6265 specific_has_child_filter);
6266 g_test_add_func ("/TreeModelFilter/specific/has-child-filter-on-sort-model",
6267 specific_has_child_filter_on_sort_model);
6268 g_test_add_func ("/TreeModelFilter/specific/at-least-2-children-filter",
6269 specific_at_least_2_children_filter);
6270 g_test_add_func ("/TreeModelFilter/specific/at-least-2-children-filter-on-sort-model",
6271 specific_at_least_2_children_filter_on_sort_model);
6272 g_test_add_func ("/TreeModelFilter/specific/root-has-child-filter",
6273 specific_root_has_child_filter);
6274 g_test_add_func ("/TreeModelFilter/specific/filter-add-child",
6275 specific_filter_add_child);
6276 g_test_add_func ("/TreeModelFilter/specific/list-store-clear",
6277 specific_list_store_clear);
6278 g_test_add_func ("/TreeModelFilter/specific/sort-ref-leaf-and-remove-ancestor",
6279 specific_sort_ref_leaf_and_remove_ancestor);
6280 g_test_add_func ("/TreeModelFilter/specific/ref-leaf-and-remove-ancestor",
6281 specific_ref_leaf_and_remove_ancestor);
6282 g_test_add_func ("/TreeModelFilter/specific/virtual-ref-leaf-and-remove-ancestor",
6283 specific_virtual_ref_leaf_and_remove_ancestor);
6285 g_test_add_func ("/TreeModelFilter/specific/bug-301558",
6286 specific_bug_301558);
6287 g_test_add_func ("/TreeModelFilter/specific/bug-311955",
6288 specific_bug_311955);
6289 g_test_add_func ("/TreeModelFilter/specific/bug-311955-clean",
6290 specific_bug_311955_clean);
6291 g_test_add_func ("/TreeModelFilter/specific/bug-346800",
6292 specific_bug_346800);
6293 g_test_add_func ("/TreeModelFilter/specific/bug-464173",
6294 specific_bug_464173);
6295 g_test_add_func ("/TreeModelFilter/specific/bug-540201",
6296 specific_bug_540201);
6297 g_test_add_func ("/TreeModelFilter/specific/bug-549287",
6298 specific_bug_549287);
6299 g_test_add_func ("/TreeModelFilter/specific/bug-621076",
6300 specific_bug_621076);
6301 g_test_add_func ("/TreeModelFilter/specific/bug-657353-related",
6302 specific_bug_657353_related);
6303 g_test_add_func ("/TreeModelFilter/specific/bug-658696",
6304 specific_bug_658696);