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

   1 /* Extensive GtkTreeModelFilter tests.
   2  * Copyright (C) 2009,2011  Kristian Rietveld  <kris@gtk.org>
   3  *
   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.
   8  *
   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.
  13  *
  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.
  18  */
  19
  20 #include <gtk/gtk.h>
  21
  22
  23 /* Left to do:
  24  *   - Proper coverage checking to see if the unit tests cover
  25  *     all possible cases.
  26  *   - Verify if the ref counting is done properly for both the
  27  *     normal ref_count and the zero_ref_count.  One way to test
  28  *     this area is by collapsing/expanding branches on the view
  29  *     that is connected to the filter model.
  30  *   - Check if the iterator stamp is incremented at the correct times.
  31  */
  32
  33
  34 /*
  35  * Model creation
  36  */
  37
  38 #define LEVEL_LENGTH 5
  39
  40 static void
  41 create_tree_store_set_values (GtkTreeStore *store,
  42                               GtkTreeIter  *iter,
  43                               gboolean      visible)
  44 {
  45   GtkTreePath *path;
  46   gchar *path_string;
  47
  48   path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), iter);
  49   path_string = gtk_tree_path_to_string (path);
  50
  51   gtk_tree_store_set (store, iter,
  52                       0, path_string,
  53                       1, visible,
  54                       -1);
  55
  56   gtk_tree_path_free (path);
  57   g_free (path_string);
  58 }
  59
  60 static void
  61 create_tree_store_recurse (int           depth,
  62                            GtkTreeStore *store,
  63                            GtkTreeIter  *parent,
  64                            gboolean      visible)
  65 {
  66   int i;
  67
  68   for (i = 0; i < LEVEL_LENGTH; i++)
  69     {
  70       GtkTreeIter iter;
  71
  72       gtk_tree_store_insert (store, &iter, parent, i);
  73       create_tree_store_set_values (store, &iter, visible);
  74
  75       if (depth > 0)
  76         create_tree_store_recurse (depth - 1, store, &iter, visible);
  77     }
  78 }
  79
  80 static GtkTreeStore *
  81 create_tree_store (int      depth,
  82                    gboolean visible)
  83 {
  84   GtkTreeStore *store;
  85
  86   store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
  87
  88   create_tree_store_recurse (depth, store, NULL, visible);
  89
  90   return store;
  91 }
  92
  93 /*
  94  * Signal monitor
  95  */
  96
  97 typedef enum
  98 {
  99   ROW_INSERTED,
 100   ROW_DELETED,
 101   ROW_CHANGED,
 102   ROW_HAS_CHILD_TOGGLED,
 103   ROWS_REORDERED,
 104   LAST_SIGNAL
 105 }
 106 SignalName;
 107
 108 static const char *
 109 signal_name_to_string (SignalName signal)
 110 {
 111   switch (signal)
 112     {
 113       case ROW_INSERTED:
 114           return "row-inserted";
 115
 116       case ROW_DELETED:
 117           return "row-deleted";
 118
 119       case ROW_CHANGED:
 120           return "row-changed";
 121
 122       case ROW_HAS_CHILD_TOGGLED:
 123           return "row-has-child-toggled";
 124
 125       case ROWS_REORDERED:
 126           return "rows-reordered";
 127
 128       default:
 129           /* Fall through */
 130           break;
 131     }
 132
 133   return "(unknown)";
 134 }
 135
 136 typedef struct
 137 {
 138   SignalName signal;
 139   GtkTreePath *path;
 140 }
 141 Signal;
 142
 143
 144 static Signal *
 145 signal_new (SignalName signal, GtkTreePath *path)
 146 {
 147   Signal *s;
 148
 149   s = g_new0 (Signal, 1);
 150   s->signal = signal;
 151   s->path = gtk_tree_path_copy (path);
 152
 153   return s;
 154 }
 155
 156 static void
 157 signal_free (Signal *s)
 158 {
 159   if (s->path)
 160     gtk_tree_path_free (s->path);
 161
 162   g_free (s);
 163 }
 164
 165
 166 typedef struct
 167 {
 168   GQueue *queue;
 169   GtkTreeModel *client;
 170   gulong signal_ids[LAST_SIGNAL];
 171 }
 172 SignalMonitor;
 173
 174
 175 static void
 176 signal_monitor_generic_handler (SignalMonitor *m,
 177                                 SignalName     signal,
 178                                 GtkTreeModel  *model,
 179                                 GtkTreePath   *path)
 180 {
 181   Signal *s;
 182
 183   if (g_queue_is_empty (m->queue))
 184     {
 185       gchar *path_str;
 186
 187       path_str = gtk_tree_path_to_string (path);
 188       g_error ("Signal queue empty, got signal %s path %s\n",
 189                signal_name_to_string (signal), path_str);
 190       g_free (path_str);
 191
 192       g_assert_not_reached ();
 193     }
 194
 195   if (m->client != model)
 196     {
 197       g_error ("Model mismatch; expected %p, got %p\n",
 198                m->client, model);
 199       g_assert_not_reached ();
 200     }
 201
 202   s = g_queue_peek_tail (m->queue);
 203
 204 #if 0
 205   /* For debugging: output signals that are coming in.  Leaks memory. */
 206   g_print ("signal=%s path=%s\n", signal_name_to_string (signal),
 207            gtk_tree_path_to_string (path));
 208 #endif
 209
 210   if (s->signal != signal
 211       || gtk_tree_path_compare (s->path, path) != 0)
 212     {
 213       gchar *path_str, *s_path_str;
 214
 215       s_path_str = gtk_tree_path_to_string (s->path);
 216       path_str = gtk_tree_path_to_string (path);
 217
 218       g_error ("Signals don't match; expected signal %s path %s, got signal %s path %s\n",
 219                signal_name_to_string (s->signal), s_path_str,
 220                signal_name_to_string (signal), path_str);
 221
 222       g_free (s_path_str);
 223       g_free (path_str);
 224
 225       g_assert_not_reached ();
 226     }
 227
 228   s = g_queue_pop_tail (m->queue);
 229
 230   signal_free (s);
 231 }
 232
 233 static void
 234 signal_monitor_row_inserted (GtkTreeModel *model,
 235                              GtkTreePath  *path,
 236                              GtkTreeIter  *iter,
 237                              gpointer      data)
 238 {
 239   signal_monitor_generic_handler (data, ROW_INSERTED,
 240                                   model, path);
 241 }
 242
 243 static void
 244 signal_monitor_row_deleted (GtkTreeModel *model,
 245                             GtkTreePath  *path,
 246                             gpointer      data)
 247 {
 248   signal_monitor_generic_handler (data, ROW_DELETED,
 249                                   model, path);
 250 }
 251
 252 static void
 253 signal_monitor_row_changed (GtkTreeModel *model,
 254                             GtkTreePath  *path,
 255                             GtkTreeIter  *iter,
 256                             gpointer      data)
 257 {
 258   signal_monitor_generic_handler (data, ROW_CHANGED,
 259                                   model, path);
 260 }
 261
 262 static void
 263 signal_monitor_row_has_child_toggled (GtkTreeModel *model,
 264                                       GtkTreePath  *path,
 265                                       GtkTreeIter  *iter,
 266                                       gpointer      data)
 267 {
 268   signal_monitor_generic_handler (data, ROW_HAS_CHILD_TOGGLED,
 269                                   model, path);
 270 }
 271
 272 static void
 273 signal_monitor_rows_reordered (GtkTreeModel *model,
 274                                GtkTreePath  *path,
 275                                GtkTreeIter  *iter,
 276                                gint         *new_order,
 277                                gpointer      data)
 278 {
 279   signal_monitor_generic_handler (data, ROWS_REORDERED,
 280                                   model, path);
 281 }
 282
 283 static SignalMonitor *
 284 signal_monitor_new (GtkTreeModel *client)
 285 {
 286   SignalMonitor *m;
 287
 288   m = g_new0 (SignalMonitor, 1);
 289   m->client = g_object_ref (client);
 290   m->queue = g_queue_new ();
 291
 292   m->signal_ids[ROW_INSERTED] = g_signal_connect (client,
 293                                                   "row-inserted",
 294                                                   G_CALLBACK (signal_monitor_row_inserted),
 295                                                   m);
 296   m->signal_ids[ROW_DELETED] = g_signal_connect (client,
 297                                                  "row-deleted",
 298                                                  G_CALLBACK (signal_monitor_row_deleted),
 299                                                  m);
 300   m->signal_ids[ROW_CHANGED] = g_signal_connect (client,
 301                                                  "row-changed",
 302                                                  G_CALLBACK (signal_monitor_row_changed),
 303                                                  m);
 304   m->signal_ids[ROW_HAS_CHILD_TOGGLED] = g_signal_connect (client,
 305                                                            "row-has-child-toggled",
 306                                                            G_CALLBACK (signal_monitor_row_has_child_toggled),
 307                                                            m);
 308   m->signal_ids[ROWS_REORDERED] = g_signal_connect (client,
 309                                                     "rows-reordered",
 310                                                     G_CALLBACK (signal_monitor_rows_reordered),
 311                                                     m);
 312
 313   return m;
 314 }
 315
 316 static void
 317 signal_monitor_free (SignalMonitor *m)
 318 {
 319   int i;
 320
 321   for (i = 0; i < LAST_SIGNAL; i++)
 322     g_signal_handler_disconnect (m->client, m->signal_ids[i]);
 323
 324   g_object_unref (m->client);
 325
 326   if (m->queue)
 327     g_queue_free (m->queue);
 328
 329   g_free (m);
 330 }
 331
 332 static void
 333 signal_monitor_assert_is_empty (SignalMonitor *m)
 334 {
 335   g_assert (g_queue_is_empty (m->queue));
 336 }
 337
 338 static void
 339 signal_monitor_append_signal_path (SignalMonitor *m,
 340                                    SignalName     signal,
 341                                    GtkTreePath   *path)
 342 {
 343   Signal *s;
 344
 345   s = signal_new (signal, path);
 346   g_queue_push_head (m->queue, s);
 347 }
 348
 349 static void
 350 signal_monitor_append_signal (SignalMonitor *m,
 351                               SignalName     signal,
 352                               const gchar   *path_string)
 353 {
 354   Signal *s;
 355   GtkTreePath *path;
 356
 357   path = gtk_tree_path_new_from_string (path_string);
 358
 359   s = signal_new (signal, path);
 360   g_queue_push_head (m->queue, s);
 361
 362   gtk_tree_path_free (path);
 363 }
 364
 365 /*
 366  * Fixture
 367  */
 368
 369 typedef struct
 370 {
 371   GtkWidget *tree_view;
 372
 373   GtkTreeStore *store;
 374   GtkTreeModelFilter *filter;
 375
 376   SignalMonitor *monitor;
 377
 378   guint block_signals : 1;
 379 } FilterTest;
 380
 381
 382 static void
 383 filter_test_store_signal (FilterTest *fixture)
 384 {
 385   if (fixture->block_signals)
 386     g_signal_stop_emission_by_name (fixture->store, "row-changed");
 387 }
 388
 389
 390 static void
 391 filter_test_setup_generic (FilterTest    *fixture,
 392                            gconstpointer  test_data,
 393                            int            depth,
 394                            gboolean       empty,
 395                            gboolean       unfiltered)
 396 {
 397   const GtkTreePath *vroot = test_data;
 398   GtkTreeModel *filter;
 399
 400   fixture->store = create_tree_store (depth, !empty);
 401
 402   g_signal_connect_swapped (fixture->store, "row-changed",
 403                             G_CALLBACK (filter_test_store_signal), fixture);
 404
 405   /* Please forgive me for casting const away. */
 406   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture->store),
 407                                       (GtkTreePath *)vroot);
 408   fixture->filter = GTK_TREE_MODEL_FILTER (filter);
 409
 410   if (!unfiltered)
 411     gtk_tree_model_filter_set_visible_column (fixture->filter, 1);
 412
 413   /* We need a tree view that's listening to get ref counting from that
 414    * side.
 415    */
 416   fixture->tree_view = gtk_tree_view_new_with_model (filter);
 417
 418   fixture->monitor = signal_monitor_new (filter);
 419 }
 420
 421 static void
 422 filter_test_setup_expand_root (FilterTest *fixture)
 423 {
 424   int i;
 425   GtkTreePath *path;
 426
 427   path = gtk_tree_path_new_from_indices (0, -1);
 428
 429   for (i = 0; i < LEVEL_LENGTH; i++)
 430     {
 431       gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view),
 432                                 path, FALSE);
 433       gtk_tree_path_next (path);
 434     }
 435   gtk_tree_path_free (path);
 436 }
 437
 438 static void
 439 filter_test_setup (FilterTest    *fixture,
 440                    gconstpointer  test_data)
 441 {
 442   filter_test_setup_generic (fixture, test_data, 3, FALSE, FALSE);
 443 }
 444
 445 static void
 446 filter_test_setup_empty (FilterTest    *fixture,
 447                          gconstpointer  test_data)
 448 {
 449   filter_test_setup_generic (fixture, test_data, 3, TRUE, FALSE);
 450 }
 451
 452 static void
 453 filter_test_setup_unfiltered (FilterTest    *fixture,
 454                               gconstpointer  test_data)
 455 {
 456   filter_test_setup_generic (fixture, test_data, 3, FALSE, TRUE);
 457 }
 458
 459 static void
 460 filter_test_setup_unfiltered_root_expanded (FilterTest    *fixture,
 461                                             gconstpointer  test_data)
 462 {
 463   filter_test_setup_unfiltered (fixture, test_data);
 464   filter_test_setup_expand_root (fixture);
 465 }
 466
 467 static void
 468 filter_test_setup_empty_unfiltered (FilterTest    *fixture,
 469                                     gconstpointer  test_data)
 470 {
 471   filter_test_setup_generic (fixture, test_data, 3, TRUE, TRUE);
 472 }
 473
 474 static void
 475 filter_test_setup_empty_unfiltered_root_expanded (FilterTest    *fixture,
 476                                                   gconstpointer  test_data)
 477 {
 478   filter_test_setup_empty_unfiltered (fixture, test_data);
 479   filter_test_setup_expand_root (fixture);
 480 }
 481
 482 static GtkTreePath *
 483 strip_virtual_root (GtkTreePath *path,
 484                     GtkTreePath *root_path)
 485 {
 486   GtkTreePath *real_path;
 487
 488   if (root_path)
 489     {
 490       int j;
 491       int depth = gtk_tree_path_get_depth (path);
 492       int root_depth = gtk_tree_path_get_depth (root_path);
 493
 494       real_path = gtk_tree_path_new ();
 495
 496       for (j = 0; j < depth - root_depth; j++)
 497         gtk_tree_path_append_index (real_path,
 498                                     gtk_tree_path_get_indices (path)[root_depth + j]);
 499     }
 500   else
 501     real_path = gtk_tree_path_copy (path);
 502
 503   return real_path;
 504 }
 505
 506 static int
 507 count_visible (FilterTest  *fixture,
 508                GtkTreePath *store_path)
 509 {
 510   int i;
 511   int n_visible = 0;
 512   GtkTreeIter iter;
 513
 514   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
 515                            &iter, store_path);
 516
 517   for (i = 0; i < LEVEL_LENGTH; i++)
 518     {
 519       gboolean visible;
 520
 521       gtk_tree_model_get (GTK_TREE_MODEL (fixture->store), &iter,
 522                           1, &visible,
 523                           -1);
 524
 525       if (visible)
 526         n_visible++;
 527     }
 528
 529   return n_visible;
 530 }
 531
 532 static void
 533 filter_test_append_refilter_signals_recurse (FilterTest  *fixture,
 534                                              GtkTreePath *store_path,
 535                                              GtkTreePath *filter_path,
 536                                              int          depth,
 537                                              GtkTreePath *root_path)
 538 {
 539   int i;
 540   int rows_deleted = 0;
 541   GtkTreeIter iter;
 542
 543   gtk_tree_path_down (store_path);
 544   gtk_tree_path_down (filter_path);
 545
 546   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
 547                            &iter, store_path);
 548
 549   for (i = 0; i < LEVEL_LENGTH; i++)
 550     {
 551       gboolean visible;
 552       GtkTreePath *real_path;
 553
 554       gtk_tree_model_get (GTK_TREE_MODEL (fixture->store), &iter,
 555                           1, &visible,
 556                           -1);
 557
 558       if (root_path &&
 559           (!gtk_tree_path_is_descendant (store_path, root_path)
 560            || !gtk_tree_path_compare (store_path, root_path)))
 561         {
 562           if (!gtk_tree_path_compare (store_path, root_path))
 563             {
 564               if (depth > 1
 565                   && gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store),
 566                                                     &iter))
 567                 {
 568                   GtkTreePath *store_copy;
 569                   GtkTreePath *filter_copy;
 570
 571                   store_copy = gtk_tree_path_copy (store_path);
 572                   filter_copy = gtk_tree_path_copy (filter_path);
 573                   filter_test_append_refilter_signals_recurse (fixture,
 574                                                                store_copy,
 575                                                                filter_copy,
 576                                                                depth - 1,
 577                                                                root_path);
 578                   gtk_tree_path_free (store_copy);
 579                   gtk_tree_path_free (filter_copy);
 580                 }
 581             }
 582
 583           gtk_tree_path_next (store_path);
 584           gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
 585
 586           if (visible)
 587             gtk_tree_path_next (filter_path);
 588
 589           continue;
 590         }
 591
 592       real_path = strip_virtual_root (filter_path, root_path);
 593
 594       if (visible)
 595         {
 596           /* This row will be inserted */
 597           signal_monitor_append_signal_path (fixture->monitor, ROW_CHANGED,
 598                                              real_path);
 599
 600           if (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store),
 601                                              &iter))
 602             {
 603               signal_monitor_append_signal_path (fixture->monitor,
 604                                                  ROW_HAS_CHILD_TOGGLED,
 605                                                  real_path);
 606
 607               if (depth > 1)
 608                 {
 609                   GtkTreePath *store_copy;
 610                   GtkTreePath *filter_copy;
 611
 612                   store_copy = gtk_tree_path_copy (store_path);
 613                   filter_copy = gtk_tree_path_copy (filter_path);
 614                   filter_test_append_refilter_signals_recurse (fixture,
 615                                                                store_copy,
 616                                                                filter_copy,
 617                                                                depth - 1,
 618                                                                root_path);
 619                   gtk_tree_path_free (store_copy);
 620                   gtk_tree_path_free (filter_copy);
 621                 }
 622               else if (depth == 1)
 623                 {
 624                   GtkTreePath *tmp_path;
 625
 626                   /* If all child rows are invisible, then the last row to
 627                    * become invisible will emit row-has-child-toggled on the
 628                    * parent.
 629                    */
 630
 631                   tmp_path = gtk_tree_path_copy (store_path);
 632                   gtk_tree_path_append_index (tmp_path, 0);
 633
 634                   if (count_visible (fixture, tmp_path) == 0)
 635                     signal_monitor_append_signal_path (fixture->monitor,
 636                                                        ROW_HAS_CHILD_TOGGLED,
 637                                                        real_path);
 638
 639                   gtk_tree_path_free (tmp_path);
 640                 }
 641             }
 642
 643           gtk_tree_path_next (filter_path);
 644         }
 645       else
 646         {
 647           /* This row will be deleted */
 648           rows_deleted++;
 649           signal_monitor_append_signal_path (fixture->monitor, ROW_DELETED,
 650                                              real_path);
 651         }
 652
 653       gtk_tree_path_free (real_path);
 654
 655       gtk_tree_path_next (store_path);
 656       gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
 657     }
 658
 659   if (rows_deleted == LEVEL_LENGTH
 660       && gtk_tree_path_get_depth (filter_path) > 1)
 661     {
 662       GtkTreePath *real_path;
 663
 664       gtk_tree_path_up (store_path);
 665       gtk_tree_path_up (filter_path);
 666
 667       /* A row-has-child-toggled will be emitted on the parent */
 668       if (!root_path
 669           || (root_path
 670               && gtk_tree_path_is_descendant (store_path, root_path)
 671               && gtk_tree_path_compare (store_path, root_path)))
 672         {
 673           real_path = strip_virtual_root (filter_path, root_path);
 674           signal_monitor_append_signal_path (fixture->monitor,
 675                                              ROW_HAS_CHILD_TOGGLED,
 676                                              real_path);
 677
 678           gtk_tree_path_free (real_path);
 679         }
 680     }
 681 }
 682
 683 static void
 684 filter_test_append_refilter_signals (FilterTest *fixture,
 685                                      int         depth)
 686 {
 687   /* A special function that walks the tree store like the
 688    * model validation functions below.
 689    */
 690   GtkTreePath *path;
 691   GtkTreePath *filter_path;
 692
 693   path = gtk_tree_path_new ();
 694   filter_path = gtk_tree_path_new ();
 695   filter_test_append_refilter_signals_recurse (fixture,
 696                                                path,
 697                                                filter_path,
 698                                                depth,
 699                                                NULL);
 700   gtk_tree_path_free (path);
 701   gtk_tree_path_free (filter_path);
 702 }
 703
 704 static void
 705 filter_test_append_refilter_signals_with_vroot (FilterTest  *fixture,
 706                                                 int          depth,
 707                                                 GtkTreePath *root_path)
 708 {
 709   /* A special function that walks the tree store like the
 710    * model validation functions below.
 711    */
 712   GtkTreePath *path;
 713   GtkTreePath *filter_path;
 714
 715   path = gtk_tree_path_new ();
 716   filter_path = gtk_tree_path_new ();
 717   filter_test_append_refilter_signals_recurse (fixture,
 718                                                path,
 719                                                filter_path,
 720                                                depth,
 721                                                root_path);
 722   gtk_tree_path_free (path);
 723   gtk_tree_path_free (filter_path);
 724 }
 725
 726 static void
 727 filter_test_enable_filter (FilterTest *fixture)
 728 {
 729   gtk_tree_model_filter_set_visible_column (fixture->filter, 1);
 730   gtk_tree_model_filter_refilter (fixture->filter);
 731 }
 732
 733 static void
 734 filter_test_block_signals (FilterTest *fixture)
 735 {
 736   fixture->block_signals = TRUE;
 737 }
 738
 739 static void
 740 filter_test_unblock_signals (FilterTest *fixture)
 741 {
 742   fixture->block_signals = FALSE;
 743 }
 744
 745 static void
 746 filter_test_teardown (FilterTest    *fixture,
 747                       gconstpointer  test_data)
 748 {
 749   signal_monitor_free (fixture->monitor);
 750
 751   gtk_widget_destroy (fixture->tree_view);
 752
 753   g_object_unref (fixture->filter);
 754   g_object_unref (fixture->store);
 755 }
 756
 757 /*
 758  * Model structure validation
 759  */
 760
 761 static void
 762 check_filter_model_recurse (FilterTest  *fixture,
 763                             GtkTreePath *store_parent_path,
 764                             GtkTreePath *filter_parent_path)
 765 {
 766   int i;
 767   GtkTreeIter store_iter;
 768   GtkTreeIter filter_iter;
 769   gboolean store_has_next, filter_has_next;
 770
 771   gtk_tree_path_down (store_parent_path);
 772   gtk_tree_path_down (filter_parent_path);
 773
 774   store_has_next = gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
 775                                             &store_iter, store_parent_path);
 776   filter_has_next = gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->filter),
 777                                              &filter_iter, filter_parent_path);
 778
 779   for (i = 0; i < LEVEL_LENGTH; i++)
 780     {
 781       gboolean visible;
 782
 783       g_return_if_fail (store_has_next == TRUE);
 784
 785       gtk_tree_model_get (GTK_TREE_MODEL (fixture->store),
 786                           &store_iter,
 787                           1, &visible,
 788                           -1);
 789
 790       if (visible)
 791         {
 792           GtkTreePath *tmp;
 793           gchar *filter_str, *store_str;
 794
 795           g_return_if_fail (filter_has_next == TRUE);
 796
 797           /* Verify path */
 798           tmp = gtk_tree_model_get_path (GTK_TREE_MODEL (fixture->filter),
 799                                          &filter_iter);
 800           g_return_if_fail (gtk_tree_path_compare (tmp, filter_parent_path) == 0);
 801
 802           /* Verify model content */
 803           gtk_tree_model_get (GTK_TREE_MODEL (fixture->store),
 804                               &store_iter,
 805                               0, &store_str,
 806                               -1);
 807           gtk_tree_model_get (GTK_TREE_MODEL (fixture->filter),
 808                               &filter_iter,
 809                               0, &filter_str,
 810                               -1);
 811
 812           g_return_if_fail (g_strcmp0 (store_str, filter_str) == 0);
 813
 814           g_free (store_str);
 815           g_free (filter_str);
 816
 817           if (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->filter),
 818                                              &filter_iter))
 819             {
 820               g_return_if_fail (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store), &store_iter));
 821
 822               check_filter_model_recurse (fixture,
 823                                           gtk_tree_path_copy (store_parent_path),
 824                                           tmp);
 825             }
 826           else
 827             /* Only when we do not recurse we need to free tmp */
 828             gtk_tree_path_free (tmp);
 829
 830           gtk_tree_path_next (filter_parent_path);
 831           filter_has_next = gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->filter), &filter_iter);
 832         }
 833
 834       gtk_tree_path_next (store_parent_path);
 835       store_has_next = gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &store_iter);
 836     }
 837
 838   /* Both models should have no more content! */
 839   g_return_if_fail (store_has_next == FALSE);
 840   g_return_if_fail (filter_has_next == FALSE);
 841
 842   gtk_tree_path_free (store_parent_path);
 843   gtk_tree_path_free (filter_parent_path);
 844 }
 845
 846 static void
 847 check_filter_model (FilterTest *fixture)
 848 {
 849   GtkTreePath *path;
 850
 851   if (fixture->monitor)
 852     signal_monitor_assert_is_empty (fixture->monitor);
 853
 854   path = gtk_tree_path_new ();
 855
 856   check_filter_model_recurse (fixture, path, gtk_tree_path_copy (path));
 857 }
 858
 859 static void
 860 check_filter_model_with_root (FilterTest  *fixture,
 861                               GtkTreePath *path)
 862 {
 863   if (fixture->monitor)
 864     signal_monitor_assert_is_empty (fixture->monitor);
 865
 866   check_filter_model_recurse (fixture,
 867                               gtk_tree_path_copy (path),
 868                               gtk_tree_path_new ());
 869 }
 870
 871 /* Helpers */
 872
 873 static void
 874 check_level_length (GtkTreeModelFilter *filter,
 875                     const gchar        *level,
 876                     const int           expected_length)
 877 {
 878   if (!level)
 879     {
 880       int model_length;
 881
 882       model_length = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (filter), NULL);
 883       g_assert_cmpint (model_length, ==, expected_length);
 884     }
 885   else
 886     {
 887       int model_length;
 888       gboolean retrieved_iter = FALSE;
 889       GtkTreeIter iter;
 890
 891       retrieved_iter = gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (filter),
 892                                                             &iter, level);
 893       g_return_if_fail (retrieved_iter);
 894       model_length = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (filter), &iter);
 895       g_assert_cmpint (model_length, ==, expected_length);
 896     }
 897 }
 898
 899 static void
 900 set_path_visibility (FilterTest  *fixture,
 901                      const gchar *path,
 902                      gboolean     visible)
 903 {
 904   GtkTreeIter store_iter;
 905
 906   gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),
 907                                        &store_iter, path);
 908   gtk_tree_store_set (fixture->store, &store_iter,
 909                       1, visible,
 910                       -1);
 911 }
 912
 913 #if 0
 914 static void
 915 insert_path_with_visibility (FilterTest  *fixture,
 916                              const gchar *path_string,
 917                              gboolean     visible)
 918 {
 919   int position;
 920   GtkTreePath *path;
 921   GtkTreeIter parent, iter;
 922
 923   path = gtk_tree_path_new_from_string (path_string);
 924   position = gtk_tree_path_get_indices (path)[gtk_tree_path_get_depth (path)];
 925   gtk_tree_path_up (path);
 926
 927   if (gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &parent, path))
 928     {
 929       gtk_tree_store_insert (fixture->store, &iter, &parent, position);
 930       create_tree_store_set_values (fixture->store, &iter, visible);
 931     }
 932   gtk_tree_path_free (path);
 933 }
 934 #endif
 935
 936 /*
 937  * The actual tests.
 938  */
 939
 940 static void
 941 verify_test_suite (FilterTest    *fixture,
 942                    gconstpointer  user_data)
 943 {
 944   check_filter_model (fixture);
 945 }
 946
 947 static void
 948 verify_test_suite_vroot (FilterTest    *fixture,
 949                          gconstpointer  user_data)
 950 {
 951   check_filter_model_with_root (fixture, (GtkTreePath *)user_data);
 952 }
 953
 954
 955 static void
 956 filled_hide_root_level (FilterTest    *fixture,
 957                         gconstpointer  user_data)
 958 {
 959   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "2");
 960   set_path_visibility (fixture, "2", FALSE);
 961   check_filter_model (fixture);
 962   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
 963
 964   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
 965   set_path_visibility (fixture, "0", FALSE);
 966   check_filter_model (fixture);
 967   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
 968
 969   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "2");
 970   set_path_visibility (fixture, "4", FALSE);
 971   check_filter_model (fixture);
 972   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 3);
 973
 974
 975   /* Hide remaining */
 976   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
 977   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
 978
 979   set_path_visibility (fixture, "1", FALSE);
 980   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 4);
 981
 982   set_path_visibility (fixture, "3", FALSE);
 983   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 5);
 984
 985   check_filter_model (fixture);
 986
 987   /* Show some */
 988   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
 989   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
 990   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "1");
 991   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "1");
 992
 993   set_path_visibility (fixture, "1", TRUE);
 994   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 4);
 995
 996   set_path_visibility (fixture, "3", TRUE);
 997   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 3);
 998
 999   check_filter_model (fixture);
1000 }
1001
1002 static void
1003 filled_hide_child_levels (FilterTest    *fixture,
1004                           gconstpointer  user_data)
1005 {
1006   set_path_visibility (fixture, "0:2", FALSE);
1007   check_filter_model (fixture);
1008   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1009   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 1);
1010
1011   set_path_visibility (fixture, "0:4", FALSE);
1012   check_filter_model (fixture);
1013   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1014   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1015
1016   set_path_visibility (fixture, "0:4:3", FALSE);
1017   check_filter_model (fixture);
1018   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1019   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1020
1021   set_path_visibility (fixture, "0:4:0", FALSE);
1022   set_path_visibility (fixture, "0:4:1", FALSE);
1023   set_path_visibility (fixture, "0:4:2", FALSE);
1024   set_path_visibility (fixture, "0:4:4", FALSE);
1025   check_filter_model (fixture);
1026   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1027   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1028
1029   /* Since "0:2" is hidden, "0:4" must be "0:3" in the filter model */
1030   set_path_visibility (fixture, "0:4", TRUE);
1031   check_filter_model (fixture);
1032   check_level_length (fixture->filter, "0:3", 0);
1033
1034   set_path_visibility (fixture, "0:2", TRUE);
1035   check_filter_model (fixture);
1036   check_level_length (fixture->filter, "0:2", LEVEL_LENGTH);
1037   check_level_length (fixture->filter, "0:3", LEVEL_LENGTH);
1038   check_level_length (fixture->filter, "0:4", 0);
1039
1040   /* Once 0:4:0 got inserted, 0:4 became a parent.  Because 0:4 is
1041    * not visible, not signals are emitted.
1042    */
1043   set_path_visibility (fixture, "0:4:2", TRUE);
1044   set_path_visibility (fixture, "0:4:4", TRUE);
1045   signal_monitor_assert_is_empty (fixture->monitor);
1046   check_level_length (fixture->filter, "0:4", 2);
1047 }
1048
1049 static void
1050 filled_hide_child_levels_root_expanded (FilterTest    *fixture,
1051                                         gconstpointer  user_data)
1052 {
1053   GtkTreePath *path;
1054
1055   path = gtk_tree_path_new_from_indices (0, -1);
1056   gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), path, FALSE);
1057   gtk_tree_path_free (path);
1058
1059   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0:2");
1060   set_path_visibility (fixture, "0:2", FALSE);
1061   check_filter_model (fixture);
1062   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1063   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 1);
1064
1065   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0:3");
1066   set_path_visibility (fixture, "0:4", FALSE);
1067   check_filter_model (fixture);
1068   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1069   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1070
1071   set_path_visibility (fixture, "0:4:3", FALSE);
1072   check_filter_model (fixture);
1073   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1074   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1075
1076   set_path_visibility (fixture, "0:4:0", FALSE);
1077   set_path_visibility (fixture, "0:4:1", FALSE);
1078   set_path_visibility (fixture, "0:4:2", FALSE);
1079   set_path_visibility (fixture, "0:4:4", FALSE);
1080   check_filter_model (fixture);
1081   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1082   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1083
1084   /* Since "0:2" is hidden, "0:4" must be "0:3" in the filter model */
1085   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0:3");
1086   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:3");
1087   set_path_visibility (fixture, "0:4", TRUE);
1088   check_filter_model (fixture);
1089   check_level_length (fixture->filter, "0:3", 0);
1090
1091   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0:2");
1092   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:2");
1093   set_path_visibility (fixture, "0:2", TRUE);
1094   check_filter_model (fixture);
1095   check_level_length (fixture->filter, "0:2", LEVEL_LENGTH);
1096   check_level_length (fixture->filter, "0:3", LEVEL_LENGTH);
1097   check_level_length (fixture->filter, "0:4", 0);
1098
1099   /* has-child-toggled for 0:4 is required.  */
1100   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:4");
1101   set_path_visibility (fixture, "0:4:2", TRUE);
1102   set_path_visibility (fixture, "0:4:4", TRUE);
1103   signal_monitor_assert_is_empty (fixture->monitor);
1104   check_level_length (fixture->filter, "0:4", 2);
1105 }
1106
1107
1108 static void
1109 filled_vroot_hide_root_level (FilterTest    *fixture,
1110                               gconstpointer  user_data)
1111 {
1112   GtkTreePath *path = (GtkTreePath *)user_data;
1113
1114   /* These changes do not affect the filter's root level */
1115   set_path_visibility (fixture, "0", FALSE);
1116   check_filter_model_with_root (fixture, path);
1117   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1118   check_level_length (fixture->filter, "0", LEVEL_LENGTH);
1119
1120   set_path_visibility (fixture, "4", FALSE);
1121   check_filter_model_with_root (fixture, path);
1122   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1123   check_level_length (fixture->filter, "0", LEVEL_LENGTH);
1124
1125   /* Even though we set the virtual root parent node to FALSE,
1126    * the virtual root contents remain.
1127    */
1128   set_path_visibility (fixture, "2", FALSE);
1129   check_filter_model_with_root (fixture, path);
1130   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1131   check_level_length (fixture->filter, "0", LEVEL_LENGTH);
1132
1133   /* No change */
1134   set_path_visibility (fixture, "1", FALSE);
1135   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1136   check_level_length (fixture->filter, "0", LEVEL_LENGTH);
1137
1138   set_path_visibility (fixture, "3", FALSE);
1139   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1140   check_level_length (fixture->filter, "0", LEVEL_LENGTH);
1141
1142   check_filter_model_with_root (fixture, path);
1143
1144   /* Show some */
1145   set_path_visibility (fixture, "2", TRUE);
1146   check_filter_model_with_root (fixture, path);
1147   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1148   check_level_length (fixture->filter, "0", LEVEL_LENGTH);
1149
1150   set_path_visibility (fixture, "1", TRUE);
1151   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1152   check_level_length (fixture->filter, "0", LEVEL_LENGTH);
1153
1154   set_path_visibility (fixture, "3", TRUE);
1155   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1156   check_level_length (fixture->filter, "0", LEVEL_LENGTH);
1157
1158   check_filter_model_with_root (fixture, path);
1159
1160   /* Now test changes in the virtual root level */
1161   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "2");
1162   set_path_visibility (fixture, "2:2", FALSE);
1163   check_filter_model_with_root (fixture, path);
1164   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1165
1166   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "3");
1167   set_path_visibility (fixture, "2:4", FALSE);
1168   check_filter_model_with_root (fixture, path);
1169   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
1170
1171   set_path_visibility (fixture, "1:4", FALSE);
1172   check_filter_model_with_root (fixture, path);
1173   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
1174
1175   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "3");
1176   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "3");
1177   set_path_visibility (fixture, "2:4", TRUE);
1178   check_filter_model_with_root (fixture, path);
1179   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1180
1181   set_path_visibility (fixture, "2", FALSE);
1182   check_filter_model_with_root (fixture, path);
1183   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1184
1185   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1186   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1187   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1188   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1189   set_path_visibility (fixture, "2:0", FALSE);
1190   set_path_visibility (fixture, "2:1", FALSE);
1191   set_path_visibility (fixture, "2:2", FALSE);
1192   set_path_visibility (fixture, "2:3", FALSE);
1193   set_path_visibility (fixture, "2:4", FALSE);
1194   check_filter_model_with_root (fixture, path);
1195   check_level_length (fixture->filter, NULL, 0);
1196
1197   set_path_visibility (fixture, "2", TRUE);
1198   check_filter_model_with_root (fixture, path);
1199   check_level_length (fixture->filter, NULL, 0);
1200
1201   set_path_visibility (fixture, "1:4", FALSE);
1202   check_filter_model_with_root (fixture, path);
1203   check_level_length (fixture->filter, NULL, 0);
1204
1205   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1206   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1207   set_path_visibility (fixture, "2:4", TRUE);
1208   check_filter_model_with_root (fixture, path);
1209   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 4);
1210
1211   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1212   set_path_visibility (fixture, "2:4", FALSE);
1213   check_filter_model_with_root (fixture, path);
1214   check_level_length (fixture->filter, NULL, 0);
1215
1216   set_path_visibility (fixture, "2", FALSE);
1217   check_filter_model_with_root (fixture, path);
1218   check_level_length (fixture->filter, NULL, 0);
1219
1220   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1221   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1222   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "1");
1223   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "1");
1224   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "2");
1225   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1226   set_path_visibility (fixture, "2:0", TRUE);
1227   set_path_visibility (fixture, "2:1", TRUE);
1228   set_path_visibility (fixture, "2:2", TRUE);
1229   check_filter_model_with_root (fixture, path);
1230   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
1231
1232   set_path_visibility (fixture, "2", TRUE);
1233   check_filter_model_with_root (fixture, path);
1234   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);
1235 }
1236
1237 static void
1238 filled_vroot_hide_child_levels (FilterTest    *fixture,
1239                                 gconstpointer  user_data)
1240 {
1241   GtkTreePath *path = (GtkTreePath *)user_data;
1242
1243   set_path_visibility (fixture, "2:0:2", FALSE);
1244   check_filter_model_with_root (fixture, path);
1245   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1246   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 1);
1247
1248   set_path_visibility (fixture, "2:0:4", FALSE);
1249   check_filter_model_with_root (fixture, path);
1250   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1251   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1252
1253   set_path_visibility (fixture, "2:0:4:3", FALSE);
1254   check_filter_model_with_root (fixture, path);
1255   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1256   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1257
1258   set_path_visibility (fixture, "2:0:4:0", FALSE);
1259   set_path_visibility (fixture, "2:0:4:1", FALSE);
1260   set_path_visibility (fixture, "2:0:4:2", FALSE);
1261   set_path_visibility (fixture, "2:0:4:4", FALSE);
1262   check_filter_model_with_root (fixture, path);
1263   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1264   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1265
1266   /* Since "0:2" is hidden, "0:4" must be "0:3" in the filter model */
1267   set_path_visibility (fixture, "2:0:4", TRUE);
1268   check_filter_model_with_root (fixture, path);
1269   check_level_length (fixture->filter, "0:3", 0);
1270
1271   set_path_visibility (fixture, "2:0:2", TRUE);
1272   check_filter_model_with_root (fixture, path);
1273   check_level_length (fixture->filter, "0:2", LEVEL_LENGTH);
1274   check_level_length (fixture->filter, "0:3", LEVEL_LENGTH);
1275   check_level_length (fixture->filter, "0:4", 0);
1276
1277   /* Once 0:4:0 got inserted, 0:4 became a parent */
1278   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:4");
1279   set_path_visibility (fixture, "2:0:4:2", TRUE);
1280   set_path_visibility (fixture, "2:0:4:4", TRUE);
1281   check_level_length (fixture->filter, "0:4", 2);
1282 }
1283
1284 static void
1285 filled_vroot_hide_child_levels_root_expanded (FilterTest    *fixture,
1286                                               gconstpointer  user_data)
1287 {
1288   GtkTreePath *path = (GtkTreePath *)user_data;
1289   GtkTreePath *tmp_path;
1290
1291   tmp_path = gtk_tree_path_new_from_indices (0, -1);
1292   gtk_tree_view_expand_row (GTK_TREE_VIEW (fixture->tree_view), tmp_path, FALSE);
1293   gtk_tree_path_free (tmp_path);
1294
1295   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0:2");
1296   set_path_visibility (fixture, "2:0:2", FALSE);
1297   check_filter_model_with_root (fixture, path);
1298   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1299   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 1);
1300
1301   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0:3");
1302   set_path_visibility (fixture, "2:0:4", FALSE);
1303   check_filter_model_with_root (fixture, path);
1304   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1305   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1306
1307   set_path_visibility (fixture, "2:0:4:3", FALSE);
1308   check_filter_model_with_root (fixture, path);
1309   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1310   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1311
1312   set_path_visibility (fixture, "2:0:4:0", FALSE);
1313   set_path_visibility (fixture, "2:0:4:1", FALSE);
1314   set_path_visibility (fixture, "2:0:4:2", FALSE);
1315   set_path_visibility (fixture, "2:0:4:4", FALSE);
1316   check_filter_model_with_root (fixture, path);
1317   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1318   check_level_length (fixture->filter, "0", LEVEL_LENGTH - 2);
1319
1320   /* Since "0:2" is hidden, "0:4" must be "0:3" in the filter model */
1321   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0:3");
1322   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:3");
1323   set_path_visibility (fixture, "2:0:4", TRUE);
1324   check_filter_model_with_root (fixture, path);
1325   check_level_length (fixture->filter, "0:3", 0);
1326
1327   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0:2");
1328   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:2");
1329   set_path_visibility (fixture, "2:0:2", TRUE);
1330   check_filter_model_with_root (fixture, path);
1331   check_level_length (fixture->filter, "0:2", LEVEL_LENGTH);
1332   check_level_length (fixture->filter, "0:3", LEVEL_LENGTH);
1333   check_level_length (fixture->filter, "0:4", 0);
1334
1335   /* Once 0:4:0 got inserted, 0:4 became a parent */
1336   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0:4");
1337   set_path_visibility (fixture, "2:0:4:2", TRUE);
1338   set_path_visibility (fixture, "2:0:4:4", TRUE);
1339   check_level_length (fixture->filter, "0:4", 2);
1340 }
1341
1342 static void
1343 empty_show_nodes (FilterTest    *fixture,
1344                   gconstpointer  user_data)
1345 {
1346   check_filter_model (fixture);
1347   check_level_length (fixture->filter, NULL, 0);
1348
1349   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1350   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1351   set_path_visibility (fixture, "3", TRUE);
1352   check_filter_model (fixture);
1353   check_level_length (fixture->filter, NULL, 1);
1354   check_level_length (fixture->filter, "0", 0);
1355
1356   set_path_visibility (fixture, "3:2:2", TRUE);
1357   check_filter_model (fixture);
1358   check_level_length (fixture->filter, NULL, 1);
1359   check_level_length (fixture->filter, "0", 0);
1360
1361   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1362   set_path_visibility (fixture, "3:2", TRUE);
1363   check_filter_model (fixture);
1364   check_level_length (fixture->filter, NULL, 1);
1365   check_level_length (fixture->filter, "0", 1);
1366   check_level_length (fixture->filter, "0:0", 1);
1367   check_level_length (fixture->filter, "0:0:0", 0);
1368
1369   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1370   set_path_visibility (fixture, "3", FALSE);
1371   check_filter_model (fixture);
1372   check_level_length (fixture->filter, NULL, 0);
1373
1374   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1375   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1376   set_path_visibility (fixture, "3:2:1", TRUE);
1377   set_path_visibility (fixture, "3", TRUE);
1378   check_filter_model (fixture);
1379   check_level_length (fixture->filter, NULL, 1);
1380   check_level_length (fixture->filter, "0", 1);
1381   check_level_length (fixture->filter, "0:0", 2);
1382   check_level_length (fixture->filter, "0:0:0", 0);
1383 }
1384
1385 static void
1386 empty_show_multiple_nodes (FilterTest    *fixture,
1387                            gconstpointer  user_data)
1388 {
1389   GtkTreeIter iter;
1390   GtkTreePath *changed_path;
1391
1392   check_filter_model (fixture);
1393   check_level_length (fixture->filter, NULL, 0);
1394
1395   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1396   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1397   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "1");
1398   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "1");
1399
1400   /* We simulate a change in visible func condition with this.  The
1401    * visibility state of multiple nodes changes at once, we emit row-changed
1402    * for these nodes (and others) after that.
1403    */
1404   filter_test_block_signals (fixture);
1405   set_path_visibility (fixture, "3", TRUE);
1406   set_path_visibility (fixture, "4", TRUE);
1407   filter_test_unblock_signals (fixture);
1408
1409   changed_path = gtk_tree_path_new ();
1410   gtk_tree_path_append_index (changed_path, 2);
1411   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
1412                            &iter, changed_path);
1413   /* Invisible node - so no signals expected */
1414   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1415                               changed_path, &iter);
1416
1417   gtk_tree_path_next (changed_path);
1418   gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1419   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1420                               changed_path, &iter);
1421
1422   gtk_tree_path_next (changed_path);
1423   gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1424   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1425                               changed_path, &iter);
1426
1427   gtk_tree_path_free (changed_path);
1428
1429   check_filter_model (fixture);
1430   check_level_length (fixture->filter, NULL, 2);
1431   check_level_length (fixture->filter, "0", 0);
1432
1433   set_path_visibility (fixture, "3:2:2", TRUE);
1434   check_filter_model (fixture);
1435   check_level_length (fixture->filter, NULL, 2);
1436   check_level_length (fixture->filter, "0", 0);
1437
1438   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1439   set_path_visibility (fixture, "3:2", TRUE);
1440   check_filter_model (fixture);
1441   check_level_length (fixture->filter, NULL, 2);
1442   check_level_length (fixture->filter, "0", 1);
1443   check_level_length (fixture->filter, "0:0", 1);
1444   check_level_length (fixture->filter, "0:0:0", 0);
1445
1446   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1447   set_path_visibility (fixture, "3", FALSE);
1448   check_filter_model (fixture);
1449   check_level_length (fixture->filter, NULL, 1);
1450
1451   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1452   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1453   set_path_visibility (fixture, "3:2:1", TRUE);
1454   set_path_visibility (fixture, "3", TRUE);
1455   check_filter_model (fixture);
1456   check_level_length (fixture->filter, NULL, 2);
1457   check_level_length (fixture->filter, "0", 1);
1458   check_level_length (fixture->filter, "0:0", 2);
1459   check_level_length (fixture->filter, "0:0:0", 0);
1460 }
1461
1462 static void
1463 empty_vroot_show_nodes (FilterTest    *fixture,
1464                         gconstpointer  user_data)
1465 {
1466   GtkTreePath *path = (GtkTreePath *)user_data;
1467
1468   check_filter_model_with_root (fixture, path);
1469   check_level_length (fixture->filter, NULL, 0);
1470
1471   set_path_visibility (fixture, "2", TRUE);
1472   check_filter_model_with_root (fixture, path);
1473   check_level_length (fixture->filter, NULL, 0);
1474
1475   set_path_visibility (fixture, "2:2:2", TRUE);
1476   check_filter_model_with_root (fixture, path);
1477   check_level_length (fixture->filter, NULL, 0);
1478
1479   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1480   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1481   set_path_visibility (fixture, "2:2", TRUE);
1482   check_filter_model_with_root (fixture, path);
1483   check_level_length (fixture->filter, NULL, 1);
1484   check_level_length (fixture->filter, "0", 1);
1485   check_level_length (fixture->filter, "0:0", 0);
1486
1487   set_path_visibility (fixture, "3", TRUE);
1488   check_filter_model_with_root (fixture, path);
1489   check_level_length (fixture->filter, NULL, 1);
1490
1491   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1492   set_path_visibility (fixture, "2:2", FALSE);
1493   check_filter_model_with_root (fixture, path);
1494   check_level_length (fixture->filter, NULL, 0);
1495
1496   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1497   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1498   set_path_visibility (fixture, "2:2:1", TRUE);
1499   set_path_visibility (fixture, "2:2", TRUE);
1500   check_filter_model_with_root (fixture, path);
1501   check_level_length (fixture->filter, NULL, 1);
1502   check_level_length (fixture->filter, "0", 2);
1503   check_level_length (fixture->filter, "0:1", 0);
1504 }
1505
1506 static void
1507 empty_vroot_show_multiple_nodes (FilterTest    *fixture,
1508                                  gconstpointer  user_data)
1509 {
1510   GtkTreeIter iter;
1511   GtkTreePath *changed_path;
1512   GtkTreePath *path = (GtkTreePath *)user_data;
1513
1514   check_filter_model_with_root (fixture, path);
1515   check_level_length (fixture->filter, NULL, 0);
1516
1517   /* We simulate a change in visible func condition with this.  The
1518    * visibility state of multiple nodes changes at once, we emit row-changed
1519    * for these nodes (and others) after that.
1520    */
1521   filter_test_block_signals (fixture);
1522   set_path_visibility (fixture, "2", TRUE);
1523   set_path_visibility (fixture, "3", TRUE);
1524   filter_test_unblock_signals (fixture);
1525
1526   changed_path = gtk_tree_path_new ();
1527   gtk_tree_path_append_index (changed_path, 1);
1528   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
1529                            &iter, changed_path);
1530   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1531                               changed_path, &iter);
1532
1533   gtk_tree_path_next (changed_path);
1534   gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1535   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1536                               changed_path, &iter);
1537
1538   gtk_tree_path_next (changed_path);
1539   gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1540   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1541                               changed_path, &iter);
1542
1543   gtk_tree_path_next (changed_path);
1544   gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1545   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1546                               changed_path, &iter);
1547
1548   gtk_tree_path_free (changed_path);
1549
1550   check_filter_model_with_root (fixture, path);
1551   check_level_length (fixture->filter, NULL, 0);
1552
1553   set_path_visibility (fixture, "2:2:2", TRUE);
1554   check_filter_model_with_root (fixture, path);
1555   check_level_length (fixture->filter, NULL, 0);
1556
1557   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1558   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1559   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "1");
1560   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "1");
1561
1562   /* Again, we simulate a call to refilter */
1563   filter_test_block_signals (fixture);
1564   set_path_visibility (fixture, "2:2", TRUE);
1565   set_path_visibility (fixture, "2:3", TRUE);
1566   filter_test_unblock_signals (fixture);
1567
1568   changed_path = gtk_tree_path_new ();
1569   gtk_tree_path_append_index (changed_path, 2);
1570   gtk_tree_path_append_index (changed_path, 1);
1571   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),
1572                            &iter, changed_path);
1573   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1574                               changed_path, &iter);
1575
1576   gtk_tree_path_next (changed_path);
1577   gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1578   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1579                               changed_path, &iter);
1580
1581   gtk_tree_path_next (changed_path);
1582   gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1583   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1584                               changed_path, &iter);
1585
1586   gtk_tree_path_next (changed_path);
1587   gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);
1588   gtk_tree_model_row_changed (GTK_TREE_MODEL (fixture->store),
1589                               changed_path, &iter);
1590
1591   gtk_tree_path_free (changed_path);
1592
1593   check_filter_model_with_root (fixture, path);
1594   check_level_length (fixture->filter, NULL, 2);
1595   check_level_length (fixture->filter, "0", 1);
1596   check_level_length (fixture->filter, "0:0", 0);
1597
1598   set_path_visibility (fixture, "3", TRUE);
1599   check_filter_model_with_root (fixture, path);
1600   check_level_length (fixture->filter, NULL, 2);
1601
1602   signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");
1603   set_path_visibility (fixture, "2:2", FALSE);
1604   check_filter_model_with_root (fixture, path);
1605   check_level_length (fixture->filter, NULL, 1);
1606
1607   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1608   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1609   set_path_visibility (fixture, "2:2:1", TRUE);
1610   set_path_visibility (fixture, "2:2", TRUE);
1611   check_filter_model_with_root (fixture, path);
1612   check_level_length (fixture->filter, NULL, 2);
1613   check_level_length (fixture->filter, "0", 2);
1614   check_level_length (fixture->filter, "0:1", 0);
1615 }
1616
1617
1618 static void
1619 unfiltered_hide_single (FilterTest    *fixture,
1620                         gconstpointer  user_data)
1621
1622 {
1623   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1624   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1625   set_path_visibility (fixture, "2", FALSE);
1626
1627   signal_monitor_assert_is_empty (fixture->monitor);
1628   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1629
1630   /* The view only shows the root level, so we only expect signals
1631    * for the root level.
1632    */
1633   filter_test_append_refilter_signals (fixture, 1);
1634   filter_test_enable_filter (fixture);
1635
1636   check_filter_model (fixture);
1637   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1638 }
1639
1640 static void
1641 unfiltered_hide_single_root_expanded (FilterTest    *fixture,
1642                                       gconstpointer  user_data)
1643
1644 {
1645   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1646   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1647   set_path_visibility (fixture, "2", FALSE);
1648
1649   signal_monitor_assert_is_empty (fixture->monitor);
1650   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1651
1652   filter_test_append_refilter_signals (fixture, 2);
1653   filter_test_enable_filter (fixture);
1654
1655   check_filter_model (fixture);
1656   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1657 }
1658
1659 static void
1660 unfiltered_hide_single_child (FilterTest    *fixture,
1661                               gconstpointer  user_data)
1662
1663 {
1664   /* This row is not shown, so its signal is not propagated */
1665   set_path_visibility (fixture, "2:2", FALSE);
1666
1667   signal_monitor_assert_is_empty (fixture->monitor);
1668   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1669   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1670
1671   /* The view only shows the root level, so we only expect signals
1672    * for the root level.
1673    */
1674   filter_test_append_refilter_signals (fixture, 0);
1675   filter_test_enable_filter (fixture);
1676
1677   check_filter_model (fixture);
1678   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1679   check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1680 }
1681
1682 static void
1683 unfiltered_hide_single_child_root_expanded (FilterTest    *fixture,
1684                                             gconstpointer  user_data)
1685
1686 {
1687   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1688   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1689   set_path_visibility (fixture, "2:2", FALSE);
1690
1691   signal_monitor_assert_is_empty (fixture->monitor);
1692   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1693   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1694
1695   filter_test_append_refilter_signals (fixture, 2);
1696   filter_test_enable_filter (fixture);
1697
1698   check_filter_model (fixture);
1699   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1700   check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1701 }
1702
1703 static void
1704 unfiltered_hide_single_multi_level (FilterTest    *fixture,
1705                                     gconstpointer  user_data)
1706
1707 {
1708   /* This row is not shown, so its signal is not propagated */
1709   set_path_visibility (fixture, "2:2:2", FALSE);
1710
1711   /* This row is not shown, so its signal is not propagated */
1712   set_path_visibility (fixture, "2:2", FALSE);
1713
1714   signal_monitor_assert_is_empty (fixture->monitor);
1715   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1716   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1717   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1718
1719   /* The view only shows the root level, so we only expect signals
1720    * for the root level.
1721    */
1722   filter_test_append_refilter_signals (fixture, 1);
1723   filter_test_enable_filter (fixture);
1724
1725   check_filter_model (fixture);
1726   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1727   check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1728
1729   set_path_visibility (fixture, "2:2", TRUE);
1730
1731   check_filter_model (fixture);
1732   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1733   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1734   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH - 1);
1735 }
1736
1737 static void
1738 unfiltered_hide_single_multi_level_root_expanded (FilterTest    *fixture,
1739                                                   gconstpointer  user_data)
1740
1741 {
1742   /* This row is not shown, so its signal is not propagated */
1743   set_path_visibility (fixture, "2:2:2", FALSE);
1744
1745   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1746   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1747   set_path_visibility (fixture, "2:2", FALSE);
1748
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);
1753
1754   filter_test_append_refilter_signals (fixture, 2);
1755   filter_test_enable_filter (fixture);
1756
1757   check_filter_model (fixture);
1758   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1759   check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1760
1761   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "2:2");
1762   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1763   set_path_visibility (fixture, "2:2", TRUE);
1764
1765   check_filter_model (fixture);
1766   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1767   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1768   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH - 1);
1769 }
1770
1771
1772
1773 static void
1774 unfiltered_vroot_hide_single (FilterTest    *fixture,
1775                               gconstpointer  user_data)
1776
1777 {
1778   GtkTreePath *path = (GtkTreePath *)user_data;
1779
1780   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1781   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1782   set_path_visibility (fixture, "2:2", FALSE);
1783
1784   signal_monitor_assert_is_empty (fixture->monitor);
1785   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1786
1787   /* The view only shows the root level, so we only expect signals
1788    * for the root level.  (Though for the depth argument, we have to
1789    * take the virtual root into account).
1790    */
1791   filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1792   filter_test_enable_filter (fixture);
1793
1794   check_filter_model_with_root (fixture, path);
1795   check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);
1796 }
1797
1798 static void
1799 unfiltered_vroot_hide_single_child (FilterTest    *fixture,
1800                                     gconstpointer  user_data)
1801
1802 {
1803   GtkTreePath *path = (GtkTreePath *)user_data;
1804
1805   /* Not visible, so no signal will be received. */
1806   set_path_visibility (fixture, "2:2:2", FALSE);
1807
1808   signal_monitor_assert_is_empty (fixture->monitor);
1809   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1810   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1811
1812   /* The view only shows the root level, so we only expect signals
1813    * for the root level.  (Though for the depth argument, we have to
1814    * take the virtual root into account).
1815    */
1816   filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1817   filter_test_enable_filter (fixture);
1818
1819   check_filter_model_with_root (fixture, path);
1820   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1821   check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1822 }
1823
1824 static void
1825 unfiltered_vroot_hide_single_child_root_expanded (FilterTest    *fixture,
1826                                                   gconstpointer  user_data)
1827
1828 {
1829   GtkTreePath *path = (GtkTreePath *)user_data;
1830
1831   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1832   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1833   set_path_visibility (fixture, "2:2:2", FALSE);
1834
1835   signal_monitor_assert_is_empty (fixture->monitor);
1836   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1837   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1838
1839   filter_test_append_refilter_signals_with_vroot (fixture, 3, path);
1840   filter_test_enable_filter (fixture);
1841
1842   check_filter_model_with_root (fixture, path);
1843   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1844   check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1845 }
1846
1847 static void
1848 unfiltered_vroot_hide_single_multi_level (FilterTest    *fixture,
1849                                           gconstpointer  user_data)
1850
1851 {
1852   GtkTreePath *path = (GtkTreePath *)user_data;
1853
1854   /* This row is not shown, so its signal is not propagated */
1855   set_path_visibility (fixture, "2:2:2:2", FALSE);
1856
1857   /* Not shown, so no signal */
1858   set_path_visibility (fixture, "2:2:2", FALSE);
1859
1860   signal_monitor_assert_is_empty (fixture->monitor);
1861   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1862   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1863   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1864
1865   /* We only expect signals for the root level.  The depth is 2
1866    * because we have to take the virtual root into account.
1867    */
1868   filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
1869   filter_test_enable_filter (fixture);
1870
1871   check_filter_model_with_root (fixture, path);
1872   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1873   check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1874
1875   /* Not shown, so no signal */
1876   set_path_visibility (fixture, "2:2:2", TRUE);
1877
1878   check_filter_model_with_root (fixture, path);
1879   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1880   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1881   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH - 1);
1882 }
1883
1884 static void
1885 unfiltered_vroot_hide_single_multi_level_root_expanded (FilterTest    *fixture,
1886                                                         gconstpointer  user_data)
1887
1888 {
1889   GtkTreePath *path = (GtkTreePath *)user_data;
1890
1891   /* This row is not shown, so its signal is not propagated */
1892   set_path_visibility (fixture, "2:2:2:2", FALSE);
1893
1894   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1895   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1896   set_path_visibility (fixture, "2:2:2", FALSE);
1897
1898   signal_monitor_assert_is_empty (fixture->monitor);
1899   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1900   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1901   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
1902
1903   filter_test_append_refilter_signals_with_vroot (fixture, 3, path);
1904   filter_test_enable_filter (fixture);
1905
1906   check_filter_model_with_root (fixture, path);
1907   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1908   check_level_length (fixture->filter, "2", LEVEL_LENGTH - 1);
1909
1910   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "2:2");
1911   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1912   set_path_visibility (fixture, "2:2:2", TRUE);
1913
1914   check_filter_model_with_root (fixture, path);
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 - 1);
1918 }
1919
1920 static void
1921 unfiltered_show_single (FilterTest    *fixture,
1922                         gconstpointer  user_data)
1923
1924 {
1925   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
1926   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
1927   set_path_visibility (fixture, "2", TRUE);
1928
1929   signal_monitor_assert_is_empty (fixture->monitor);
1930   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1931
1932   /* We only expect signals for the root level */
1933   filter_test_append_refilter_signals (fixture, 1);
1934   filter_test_enable_filter (fixture);
1935
1936   check_filter_model (fixture);
1937   check_level_length (fixture->filter, NULL, 1);
1938 }
1939
1940 static void
1941 unfiltered_show_single_child (FilterTest    *fixture,
1942                               gconstpointer  user_data)
1943
1944 {
1945   set_path_visibility (fixture, "2:2", TRUE);
1946
1947   signal_monitor_assert_is_empty (fixture->monitor);
1948   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1949   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1950
1951   /* We only expect signals for the root level */
1952   filter_test_append_refilter_signals (fixture, 1);
1953   filter_test_enable_filter (fixture);
1954
1955   check_filter_model (fixture);
1956   check_level_length (fixture->filter, NULL, 0);
1957
1958   /* From here we are filtered, "2" in the real model is "0" in the filter
1959    * model.
1960    */
1961   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1962   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1963   set_path_visibility (fixture, "2", TRUE);
1964   signal_monitor_assert_is_empty (fixture->monitor);
1965   check_level_length (fixture->filter, NULL, 1);
1966   check_level_length (fixture->filter, "0", 1);
1967 }
1968
1969 static void
1970 unfiltered_show_single_child_root_expanded (FilterTest    *fixture,
1971                                             gconstpointer  user_data)
1972
1973 {
1974   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
1975   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
1976   set_path_visibility (fixture, "2:2", TRUE);
1977
1978   signal_monitor_assert_is_empty (fixture->monitor);
1979   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
1980   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
1981
1982   filter_test_append_refilter_signals (fixture, 2);
1983   filter_test_enable_filter (fixture);
1984
1985   check_filter_model (fixture);
1986   check_level_length (fixture->filter, NULL, 0);
1987
1988   /* From here we are filtered, "2" in the real model is "0" in the filter
1989    * model.
1990    */
1991   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
1992   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
1993   set_path_visibility (fixture, "2", TRUE);
1994   signal_monitor_assert_is_empty (fixture->monitor);
1995   check_level_length (fixture->filter, NULL, 1);
1996   check_level_length (fixture->filter, "0", 1);
1997 }
1998
1999 static void
2000 unfiltered_show_single_multi_level (FilterTest    *fixture,
2001                                     gconstpointer  user_data)
2002
2003 {
2004   /* The view is not showing these rows (collapsed state), so it is not
2005    * referenced.  The signal should not go through.
2006    */
2007   set_path_visibility (fixture, "2:2:2", TRUE);
2008   set_path_visibility (fixture, "2:2", TRUE);
2009
2010   signal_monitor_assert_is_empty (fixture->monitor);
2011   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
2012   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
2013   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
2014
2015   /* We only expect signals for the first level */
2016   filter_test_append_refilter_signals (fixture, 1);
2017   filter_test_enable_filter (fixture);
2018
2019   check_filter_model (fixture);
2020   check_level_length (fixture->filter, NULL, 0);
2021
2022   /* From here we are filtered, "2" in the real model is "0" in the filter
2023    * model.
2024    */
2025   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
2026   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
2027   set_path_visibility (fixture, "2", TRUE);
2028   check_filter_model (fixture);
2029   check_level_length (fixture->filter, NULL, 1);
2030   check_level_length (fixture->filter, "0", 1);
2031   check_level_length (fixture->filter, "0:0", 1);
2032 }
2033
2034 static void
2035 unfiltered_show_single_multi_level_root_expanded (FilterTest    *fixture,
2036                                                   gconstpointer  user_data)
2037
2038 {
2039   /* The view is not showing this row (collapsed state), so it is not
2040    * referenced.  The signal should not go through.
2041    */
2042   set_path_visibility (fixture, "2:2:2", TRUE);
2043
2044   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
2045   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
2046   set_path_visibility (fixture, "2:2", TRUE);
2047
2048   signal_monitor_assert_is_empty (fixture->monitor);
2049   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
2050   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
2051   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
2052
2053   filter_test_append_refilter_signals (fixture, 2);
2054   filter_test_enable_filter (fixture);
2055
2056   check_filter_model (fixture);
2057   check_level_length (fixture->filter, NULL, 0);
2058
2059   /* From here we are filtered, "2" in the real model is "0" in the filter
2060    * model.
2061    */
2062   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
2063   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
2064   set_path_visibility (fixture, "2", TRUE);
2065   check_filter_model (fixture);
2066   check_level_length (fixture->filter, NULL, 1);
2067   check_level_length (fixture->filter, "0", 1);
2068   check_level_length (fixture->filter, "0:0", 1);
2069 }
2070
2071 static void
2072 unfiltered_vroot_show_single (FilterTest    *fixture,
2073                               gconstpointer  user_data)
2074
2075 {
2076   GtkTreePath *path = (GtkTreePath *)user_data;
2077
2078   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2");
2079   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2");
2080   set_path_visibility (fixture, "2:2", TRUE);
2081
2082   signal_monitor_assert_is_empty (fixture->monitor);
2083   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
2084
2085   /* The view only shows the root level, so the filter model only has
2086    * the first two levels cached.
2087    */
2088   filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
2089   filter_test_enable_filter (fixture);
2090
2091   check_filter_model_with_root (fixture, path);
2092   check_level_length (fixture->filter, NULL, 1);
2093 }
2094
2095 static void
2096 unfiltered_vroot_show_single_child (FilterTest    *fixture,
2097                                     gconstpointer  user_data)
2098
2099 {
2100   GtkTreePath *path = (GtkTreePath *)user_data;
2101
2102   set_path_visibility (fixture, "2:2:2", TRUE);
2103
2104   signal_monitor_assert_is_empty (fixture->monitor);
2105   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
2106   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
2107
2108   /* The view only shows the root level, so the filter model only has
2109    * the first two levels cached.
2110    */
2111   filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
2112   filter_test_enable_filter (fixture);
2113
2114   check_filter_model_with_root (fixture, path);
2115   check_level_length (fixture->filter, NULL, 0);
2116
2117   /* From here we are filtered, "2" in the real model is "0" in the filter
2118    * model.
2119    */
2120   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
2121   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
2122   set_path_visibility (fixture, "2:2", TRUE);
2123   signal_monitor_assert_is_empty (fixture->monitor);
2124   check_level_length (fixture->filter, NULL, 1);
2125   check_level_length (fixture->filter, "0", 1);
2126 }
2127
2128 static void
2129 unfiltered_vroot_show_single_child_root_expanded (FilterTest    *fixture,
2130                                                   gconstpointer  user_data)
2131
2132 {
2133   GtkTreePath *path = (GtkTreePath *)user_data;
2134
2135   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
2136   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
2137   set_path_visibility (fixture, "2:2:2", TRUE);
2138
2139   signal_monitor_assert_is_empty (fixture->monitor);
2140   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
2141   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
2142
2143   filter_test_append_refilter_signals_with_vroot (fixture, 3, path);
2144   filter_test_enable_filter (fixture);
2145
2146   check_filter_model_with_root (fixture, path);
2147   check_level_length (fixture->filter, NULL, 0);
2148
2149   /* From here we are filtered, "2" in the real model is "0" in the filter
2150    * model.
2151    */
2152   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
2153   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
2154   set_path_visibility (fixture, "2:2", TRUE);
2155   signal_monitor_assert_is_empty (fixture->monitor);
2156   check_level_length (fixture->filter, NULL, 1);
2157   check_level_length (fixture->filter, "0", 1);
2158 }
2159
2160
2161 static void
2162 unfiltered_vroot_show_single_multi_level (FilterTest    *fixture,
2163                                           gconstpointer  user_data)
2164
2165 {
2166   GtkTreePath *path = (GtkTreePath *)user_data;
2167
2168   /* The view is not showing this row (collapsed state), so it is not
2169    * referenced.  The signal should not go through.
2170    */
2171   set_path_visibility (fixture, "2:2:2:2", TRUE);
2172
2173   set_path_visibility (fixture, "2:2:2", TRUE);
2174
2175   signal_monitor_assert_is_empty (fixture->monitor);
2176   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
2177   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
2178   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
2179
2180   /* We only expect signals for the root level */
2181   filter_test_append_refilter_signals_with_vroot (fixture, 2, path);
2182   filter_test_enable_filter (fixture);
2183
2184   check_filter_model_with_root (fixture, path);
2185   check_level_length (fixture->filter, NULL, 0);
2186
2187   /* From here we are filtered, "2" in the real model is "0" in the filter
2188    * model.
2189    */
2190   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
2191   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
2192   set_path_visibility (fixture, "2:2", TRUE);
2193   check_filter_model_with_root (fixture, path);
2194   check_level_length (fixture->filter, NULL, 1);
2195   check_level_length (fixture->filter, "0", 1);
2196   check_level_length (fixture->filter, "0:0", 1);
2197 }
2198
2199 static void
2200 unfiltered_vroot_show_single_multi_level_root_expanded (FilterTest    *fixture,
2201                                                         gconstpointer  user_data)
2202
2203 {
2204   GtkTreePath *path = (GtkTreePath *)user_data;
2205
2206   /* The view is not showing this row (collapsed state), so it is not
2207    * referenced.  The signal should not go through.
2208    */
2209   set_path_visibility (fixture, "2:2:2:2", TRUE);
2210
2211   signal_monitor_append_signal (fixture->monitor, ROW_CHANGED, "2:2");
2212   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "2:2");
2213   set_path_visibility (fixture, "2:2:2", TRUE);
2214
2215   signal_monitor_assert_is_empty (fixture->monitor);
2216   check_level_length (fixture->filter, NULL, LEVEL_LENGTH);
2217   check_level_length (fixture->filter, "2", LEVEL_LENGTH);
2218   check_level_length (fixture->filter, "2:2", LEVEL_LENGTH);
2219
2220   filter_test_append_refilter_signals_with_vroot (fixture, 3, path);
2221   filter_test_enable_filter (fixture);
2222
2223   check_filter_model_with_root (fixture, path);
2224   check_level_length (fixture->filter, NULL, 0);
2225
2226   /* From here we are filtered, "2" in the real model is "0" in the filter
2227    * model.
2228    */
2229   signal_monitor_append_signal (fixture->monitor, ROW_INSERTED, "0");
2230   signal_monitor_append_signal (fixture->monitor, ROW_HAS_CHILD_TOGGLED, "0");
2231   set_path_visibility (fixture, "2:2", TRUE);
2232   check_filter_model_with_root (fixture, path);
2233   check_level_length (fixture->filter, NULL, 1);
2234   check_level_length (fixture->filter, "0", 1);
2235   check_level_length (fixture->filter, "0:0", 1);
2236 }
2237
2238
2239 static void
2240 insert_before (void)
2241 {
2242   GtkTreeStore *store;
2243   GtkTreeModel *filter;
2244   GtkWidget *tree_view;
2245   SignalMonitor *monitor;
2246   GtkTreeIter iter;
2247   GtkTreeIter last_iter;
2248   GtkTreePath *path;
2249
2250   /* This tests two aspects of the row-inserted handling:
2251    *   1) If the newly inserted node was already handled by building
2252    *      the root level, don't handle it a second time.
2253    *   2) Offsets of existing nodes must be updated when a new
2254    *      node is inserted.
2255    */
2256
2257   store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
2258   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
2259   gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter),
2260                                             1);
2261
2262   tree_view = gtk_tree_view_new_with_model (filter);
2263   monitor = signal_monitor_new (filter);
2264
2265   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 0);
2266
2267   /* Insert 0 */
2268   path = gtk_tree_path_new_from_indices (0, -1);
2269   signal_monitor_append_signal_path (monitor, ROW_INSERTED, path);
2270   gtk_tree_path_free (path);
2271
2272   gtk_tree_store_insert_with_values (store, &iter, NULL, 0,
2273                                      0, "Foo", 1, TRUE, -1);
2274
2275   signal_monitor_assert_is_empty (monitor);
2276   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
2277
2278   /* Insert 1 */
2279   path = gtk_tree_path_new_from_indices (1, -1);
2280   signal_monitor_append_signal_path (monitor, ROW_INSERTED, path);
2281   gtk_tree_path_free (path);
2282
2283   gtk_tree_store_insert_with_values (store, &iter, NULL, 1,
2284                                      0, "Foo", 1, TRUE, -1);
2285   last_iter = iter;
2286
2287   signal_monitor_assert_is_empty (monitor);
2288   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 2);
2289
2290   /* Insert on 1 again -- invisible */
2291   gtk_tree_store_insert_with_values (store, &iter, NULL, 1,
2292                                      0, "Foo", 1, FALSE, -1);
2293
2294   signal_monitor_assert_is_empty (monitor);
2295   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 2);
2296
2297   /* Insert on 1 again -- visible */
2298   path = gtk_tree_path_new_from_indices (1, -1);
2299   signal_monitor_append_signal_path (monitor, ROW_INSERTED, path);
2300   gtk_tree_path_free (path);
2301
2302   gtk_tree_store_insert_with_values (store, &iter, NULL, 1,
2303                                      0, "Foo", 1, TRUE, -1);
2304
2305   signal_monitor_assert_is_empty (monitor);
2306   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 3);
2307
2308   /* Modify the iter that should be at the last position and check the
2309    * signal we get.
2310    */
2311   path = gtk_tree_path_new_from_indices (2, -1);
2312   signal_monitor_append_signal_path (monitor, ROW_CHANGED, path);
2313   gtk_tree_path_free (path);
2314
2315   gtk_tree_store_set (store, &last_iter, 0, "Foo changed", -1);
2316
2317   signal_monitor_assert_is_empty (monitor);
2318   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 3);
2319 }
2320
2321 static void
2322 insert_child (void)
2323 {
2324   GtkTreeStore *store;
2325   GtkTreeModel *filter;
2326   GtkWidget *tree_view;
2327   SignalMonitor *monitor;
2328   GtkTreeIter parent, iter;
2329   GtkTreePath *path;
2330
2331   store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
2332
2333   gtk_tree_store_insert_with_values (store, &parent, NULL, 0,
2334                                      0, "Parent", 1, TRUE, -1);
2335
2336
2337   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
2338   gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter),
2339                                             1);
2340
2341   tree_view = gtk_tree_view_new_with_model (filter);
2342   monitor = signal_monitor_new (filter);
2343
2344   /* Insert child -- invisible */
2345   path = gtk_tree_path_new_from_indices (0, -1);
2346   signal_monitor_append_signal_path (monitor, ROW_HAS_CHILD_TOGGLED, path);
2347   /* The signal is received twice, once a pass through from GtkTreeStore
2348    * and one generated by GtkTreeModelFilter.  Not accurate, but cannot
2349    * hurt.
2350    */
2351   signal_monitor_append_signal_path (monitor, ROW_HAS_CHILD_TOGGLED, path);
2352   gtk_tree_path_free (path);
2353
2354   gtk_tree_store_insert_with_values (store, &iter, &parent, 1,
2355                                      0, "Child", 1, FALSE, -1);
2356
2357   signal_monitor_assert_is_empty (monitor);
2358   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
2359
2360   /* Insert child */
2361   path = gtk_tree_path_new_from_indices (0, 0, -1);
2362   gtk_tree_path_up (path); /* 0 */
2363   signal_monitor_append_signal_path (monitor, ROW_HAS_CHILD_TOGGLED, path);
2364   gtk_tree_path_free (path);
2365
2366   gtk_tree_store_insert_with_values (store, &iter, &parent, 0,
2367                                      0, "Child", 1, TRUE, -1);
2368
2369   signal_monitor_assert_is_empty (monitor);
2370   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
2371
2372   /* Insert child -- invisible */
2373   gtk_tree_store_insert_with_values (store, &iter, &parent, 1,
2374                                      0, "Child", 1, FALSE, -1);
2375
2376   signal_monitor_assert_is_empty (monitor);
2377   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 1);
2378 }
2379
2380
2381
2382 static void
2383 remove_node (void)
2384 {
2385   GtkTreeIter iter, iter1, iter2, iter3;
2386   GtkListStore *list;
2387   GtkTreeModel *filter;
2388   GtkWidget *view G_GNUC_UNUSED;
2389
2390   list = gtk_list_store_new (1, G_TYPE_INT);
2391   gtk_list_store_insert_with_values (list, &iter1, 0, 0, 1, -1);
2392   gtk_list_store_insert_with_values (list, &iter, 1, 0, 2, -1);
2393   gtk_list_store_insert_with_values (list, &iter, 2, 0, 3, -1);
2394   gtk_list_store_insert_with_values (list, &iter, 3, 0, 4, -1);
2395   gtk_list_store_insert_with_values (list, &iter, 4, 0, 5, -1);
2396   gtk_list_store_insert_with_values (list, &iter, 5, 0, 6, -1);
2397   gtk_list_store_insert_with_values (list, &iter2, 6, 0, 7, -1);
2398   gtk_list_store_insert_with_values (list, &iter3, 7, 0, 8, -1);
2399
2400   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (list), NULL);
2401   view = gtk_tree_view_new_with_model (filter);
2402
2403   gtk_list_store_remove (list, &iter1);
2404   gtk_list_store_remove (list, &iter3);
2405   gtk_list_store_remove (list, &iter2);
2406
2407   gtk_widget_destroy (view);
2408   g_object_unref (filter);
2409   g_object_unref (list);
2410 }
2411
2412 static void
2413 remove_node_vroot (void)
2414 {
2415   GtkTreeIter parent, root;
2416   GtkTreeIter iter, iter1, iter2, iter3;
2417   GtkTreeStore *tree;
2418   GtkTreeModel *filter;
2419   GtkTreePath *path;
2420   GtkWidget *view G_GNUC_UNUSED;
2421
2422   tree = gtk_tree_store_new (1, G_TYPE_INT);
2423   gtk_tree_store_insert_with_values (tree, &parent, NULL, 0, 0, 0, -1);
2424   gtk_tree_store_insert_with_values (tree, &root, &parent, 0, 0, 0, -1);
2425
2426   gtk_tree_store_insert_with_values (tree, &iter1, &root, 0, 0, 1, -1);
2427   gtk_tree_store_insert_with_values (tree, &iter, &root, 1, 0, 2, -1);
2428   gtk_tree_store_insert_with_values (tree, &iter, &root, 2, 0, 3, -1);
2429   gtk_tree_store_insert_with_values (tree, &iter, &root, 3, 0, 4, -1);
2430   gtk_tree_store_insert_with_values (tree, &iter, &root, 4, 0, 5, -1);
2431   gtk_tree_store_insert_with_values (tree, &iter, &root, 5, 0, 6, -1);
2432   gtk_tree_store_insert_with_values (tree, &iter2, &root, 6, 0, 7, -1);
2433   gtk_tree_store_insert_with_values (tree, &iter3, &root, 7, 0, 8, -1);
2434
2435   path = gtk_tree_path_new_from_indices (0, 0, -1);
2436   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (tree), path);
2437   gtk_tree_path_free (path);
2438
2439   view = gtk_tree_view_new_with_model (filter);
2440
2441   gtk_tree_store_remove (tree, &iter1);
2442   gtk_tree_store_remove (tree, &iter3);
2443   gtk_tree_store_remove (tree, &iter2);
2444
2445   gtk_widget_destroy (view);
2446   g_object_unref (filter);
2447   g_object_unref (tree);
2448 }
2449
2450 static void
2451 remove_vroot_ancestor (void)
2452 {
2453   GtkTreeIter parent, root;
2454   GtkTreeIter iter, iter1, iter2, iter3;
2455   GtkTreeStore *tree;
2456   GtkTreeModel *filter;
2457   GtkTreePath *path;
2458   GtkWidget *view G_GNUC_UNUSED;
2459
2460   tree = gtk_tree_store_new (1, G_TYPE_INT);
2461   gtk_tree_store_insert_with_values (tree, &parent, NULL, 0, 0, 0, -1);
2462   gtk_tree_store_insert_with_values (tree, &root, &parent, 0, 0, 0, -1);
2463
2464   gtk_tree_store_insert_with_values (tree, &iter1, &root, 0, 0, 1, -1);
2465   gtk_tree_store_insert_with_values (tree, &iter, &root, 1, 0, 2, -1);
2466   gtk_tree_store_insert_with_values (tree, &iter, &root, 2, 0, 3, -1);
2467   gtk_tree_store_insert_with_values (tree, &iter, &root, 3, 0, 4, -1);
2468   gtk_tree_store_insert_with_values (tree, &iter, &root, 4, 0, 5, -1);
2469   gtk_tree_store_insert_with_values (tree, &iter, &root, 5, 0, 6, -1);
2470   gtk_tree_store_insert_with_values (tree, &iter2, &root, 6, 0, 7, -1);
2471   gtk_tree_store_insert_with_values (tree, &iter3, &root, 7, 0, 8, -1);
2472
2473   path = gtk_tree_path_new_from_indices (0, 0, -1);
2474   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (tree), path);
2475   gtk_tree_path_free (path);
2476
2477   view = gtk_tree_view_new_with_model (filter);
2478
2479   gtk_tree_store_remove (tree, &parent);
2480
2481   gtk_widget_destroy (view);
2482   g_object_unref (filter);
2483   g_object_unref (tree);
2484 }
2485
2486
2487 static gboolean
2488 specific_path_dependent_filter_func (GtkTreeModel *model,
2489                                      GtkTreeIter  *iter,
2490                                      gpointer      data)
2491 {
2492   GtkTreePath *path;
2493
2494   path = gtk_tree_model_get_path (model, iter);
2495   if (gtk_tree_path_get_indices (path)[0] < 4)
2496     return FALSE;
2497
2498   return TRUE;
2499 }
2500
2501 static void
2502 specific_path_dependent_filter (void)
2503 {
2504   int i;
2505   GtkTreeIter iter;
2506   GtkListStore *list;
2507   GtkTreeModel *sort;
2508   GtkTreeModel *filter;
2509
2510   list = gtk_list_store_new (1, G_TYPE_INT);
2511   gtk_list_store_insert_with_values (list, &iter, 0, 0, 1, -1);
2512   gtk_list_store_insert_with_values (list, &iter, 1, 0, 2, -1);
2513   gtk_list_store_insert_with_values (list, &iter, 2, 0, 3, -1);
2514   gtk_list_store_insert_with_values (list, &iter, 3, 0, 4, -1);
2515   gtk_list_store_insert_with_values (list, &iter, 4, 0, 5, -1);
2516   gtk_list_store_insert_with_values (list, &iter, 5, 0, 6, -1);
2517   gtk_list_store_insert_with_values (list, &iter, 6, 0, 7, -1);
2518   gtk_list_store_insert_with_values (list, &iter, 7, 0, 8, -1);
2519
2520   sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (list));
2521   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (sort), NULL);
2522   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
2523                                           specific_path_dependent_filter_func,
2524                                           NULL, NULL);
2525
2526   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort), 0,
2527                                         GTK_SORT_DESCENDING);
2528
2529   for (i = 0; i < 4; i++)
2530     {
2531       if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (list), &iter,
2532                                          NULL, 1))
2533         gtk_list_store_remove (list, &iter);
2534
2535       if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (list), &iter,
2536                                          NULL, 2))
2537         gtk_list_store_remove (list, &iter);
2538     }
2539
2540   g_object_unref (filter);
2541   g_object_unref (sort);
2542   g_object_unref (list);
2543 }
2544
2545
2546 static gboolean
2547 specific_append_after_collapse_visible_func (GtkTreeModel *model,
2548                                              GtkTreeIter  *iter,
2549                                              gpointer      data)
2550 {
2551   gint number;
2552   gboolean hide_negative_numbers;
2553
2554   gtk_tree_model_get (model, iter, 1, &number, -1);
2555   hide_negative_numbers = GPOINTER_TO_INT (g_object_get_data (data, "private-hide-negative-numbers"));
2556
2557   return (number >= 0 || !hide_negative_numbers);
2558 }
2559
2560 static void
2561 specific_append_after_collapse (void)
2562 {
2563   /* This test is based on one of the test cases I found in my
2564    * old test cases directory.  I unfortunately do not have a record
2565    * from who this test case originated.  -Kris.
2566    *
2567    * General idea:
2568    * - Construct tree.
2569    * - Show tree, expand, collapse.
2570    * - Add a row.
2571    */
2572
2573   GtkTreeIter iter;
2574   GtkTreeIter child_iter;
2575   GtkTreeIter child_iter2;
2576   GtkTreePath *append_path;
2577   GtkTreeStore *store;
2578   GtkTreeModel *filter;
2579   GtkTreeModel *sort;
2580
2581   GtkWidget *window;
2582   GtkWidget *tree_view;
2583
2584   store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_INT);
2585
2586   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
2587   g_object_set_data (G_OBJECT (filter), "private-hide-negative-numbers",
2588                      GINT_TO_POINTER (FALSE));
2589   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
2590                                           specific_append_after_collapse_visible_func,
2591                                           filter, NULL);
2592
2593   sort = gtk_tree_model_sort_new_with_model (filter);
2594
2595   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2596   tree_view = gtk_tree_view_new_with_model (sort);
2597   gtk_container_add (GTK_CONTAINER (window), tree_view);
2598   gtk_widget_realize (tree_view);
2599
2600   while (gtk_events_pending ())
2601     gtk_main_iteration ();
2602
2603   gtk_tree_store_prepend (store, &iter, NULL);
2604   gtk_tree_store_set (store, &iter,
2605                       0, "hallo", 1, 1, -1);
2606
2607   gtk_tree_store_append (store, &child_iter, &iter);
2608   gtk_tree_store_set (store, &child_iter,
2609                       0, "toemaar", 1, 1, -1);
2610
2611   gtk_tree_store_append (store, &child_iter2, &child_iter);
2612   gtk_tree_store_set (store, &child_iter2,
2613                       0, "very deep", 1, 1, -1);
2614
2615   append_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &child_iter2);
2616
2617   gtk_tree_store_append (store, &child_iter, &iter);
2618   gtk_tree_store_set (store, &child_iter,
2619                       0, "sja", 1, 1, -1);
2620
2621   gtk_tree_store_append (store, &child_iter, &iter);
2622   gtk_tree_store_set (store, &child_iter,
2623                       0, "some word", 1, -1, -1);
2624
2625   /* Expand and collapse the tree */
2626   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
2627   while (gtk_events_pending ())
2628     gtk_main_iteration ();
2629
2630   gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view));
2631   while (gtk_events_pending ())
2632     gtk_main_iteration ();
2633
2634   /* Add another it */
2635   g_object_set_data (G_OBJECT (filter), "private-hide-negative-numbers",
2636                      GINT_TO_POINTER (TRUE));
2637
2638   if (gtk_tree_model_get_iter (GTK_TREE_MODEL (store), &iter, append_path))
2639     {
2640       gtk_tree_store_append (store, &child_iter, &iter);
2641       gtk_tree_store_set (store, &child_iter,
2642                           0, "new new new !!", 1, 1, -1);
2643     }
2644   gtk_tree_path_free (append_path);
2645
2646   /* Expand */
2647   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
2648   while (gtk_events_pending ())
2649     gtk_main_iteration ();
2650 }
2651
2652
2653 static gint
2654 specific_sort_filter_remove_node_compare_func (GtkTreeModel  *model,
2655                                                GtkTreeIter   *iter1,
2656                                                GtkTreeIter   *iter2,
2657                                                gpointer       data)
2658 {
2659   return -1;
2660 }
2661
2662 static gboolean
2663 specific_sort_filter_remove_node_visible_func (GtkTreeModel  *model,
2664                                                GtkTreeIter   *iter,
2665                                                gpointer       data)
2666 {
2667   char *item = NULL;
2668
2669   /* Do reference the model */
2670   gtk_tree_model_get (model, iter, 0, &item, -1);
2671   g_free (item);
2672
2673   return FALSE;
2674 }
2675
2676 static void
2677 specific_sort_filter_remove_node (void)
2678 {
2679   /* This test is based on one of the test cases I found in my
2680    * old test cases directory.  I unfortunately do not have a record
2681    * from who this test case originated.  -Kris.
2682    *
2683    * General idea:
2684    *  - Create tree store, sort, filter models.  The sort model has
2685    *    a default sort func that is enabled, filter model a visible func
2686    *    that defaults to returning FALSE.
2687    *  - Remove a node from the tree store.
2688    */
2689
2690   GtkTreeIter iter;
2691   GtkTreeStore *store;
2692   GtkTreeModel *filter;
2693   GtkTreeModel *sort;
2694
2695   GtkWidget *window;
2696   GtkWidget *tree_view;
2697
2698   store = gtk_tree_store_new (1, G_TYPE_STRING);
2699   gtk_tree_store_append (store, &iter, NULL);
2700   gtk_tree_store_set (store, &iter, 0, "Hello1", -1);
2701
2702   gtk_tree_store_append (store, &iter, NULL);
2703   gtk_tree_store_set (store, &iter, 0, "Hello2", -1);
2704
2705   sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
2706   gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (sort),
2707                                            specific_sort_filter_remove_node_compare_func, NULL, NULL);
2708
2709   filter = gtk_tree_model_filter_new (sort, NULL);
2710   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
2711                                           specific_sort_filter_remove_node_visible_func,
2712                                           filter, NULL);
2713
2714
2715   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2716   tree_view = gtk_tree_view_new_with_model (filter);
2717   gtk_container_add (GTK_CONTAINER (window), tree_view);
2718   gtk_widget_realize (tree_view);
2719
2720   while (gtk_events_pending ())
2721     gtk_main_iteration ();
2722
2723   /* Remove a node */
2724   gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter);
2725   gtk_tree_model_iter_next (GTK_TREE_MODEL (store), &iter);
2726   gtk_tree_store_remove (store, &iter);
2727
2728   while (gtk_events_pending ())
2729     gtk_main_iteration ();
2730 }
2731
2732
2733 static void
2734 specific_sort_filter_remove_root (void)
2735 {
2736   /* This test is based on one of the test cases I found in my
2737    * old test cases directory.  I unfortunately do not have a record
2738    * from who this test case originated.  -Kris.
2739    */
2740
2741   GtkTreeModel *model, *sort, *filter;
2742   GtkTreeIter root, mid, leaf;
2743   GtkTreePath *path;
2744
2745   model = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_INT));
2746   gtk_tree_store_append (GTK_TREE_STORE (model), &root, NULL);
2747   gtk_tree_store_append (GTK_TREE_STORE (model), &mid, &root);
2748   gtk_tree_store_append (GTK_TREE_STORE (model), &leaf, &mid);
2749
2750   path = gtk_tree_model_get_path (model, &mid);
2751
2752   sort = gtk_tree_model_sort_new_with_model (model);
2753   filter = gtk_tree_model_filter_new (sort, path);
2754
2755   gtk_tree_path_free (path);
2756
2757   gtk_tree_store_remove (GTK_TREE_STORE (model), &root);
2758
2759   g_object_unref (filter);
2760   g_object_unref (sort);
2761   g_object_unref (model);
2762 }
2763
2764
2765 static void
2766 specific_root_mixed_visibility (void)
2767 {
2768   int i;
2769   GtkTreeModel *filter;
2770   /* A bit nasty, apologies */
2771   FilterTest fixture;
2772
2773   fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
2774
2775   for (i = 0; i < LEVEL_LENGTH; i++)
2776     {
2777       GtkTreeIter iter;
2778
2779       gtk_tree_store_insert (fixture.store, &iter, NULL, i);
2780       if (i % 2 == 0)
2781         create_tree_store_set_values (fixture.store, &iter, TRUE);
2782       else
2783         create_tree_store_set_values (fixture.store, &iter, FALSE);
2784     }
2785
2786   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture.store), NULL);
2787   fixture.filter = GTK_TREE_MODEL_FILTER (filter);
2788   fixture.monitor = NULL;
2789
2790   gtk_tree_model_filter_set_visible_column (fixture.filter, 1);
2791
2792   /* In order to trigger the potential bug, we should not access
2793    * the filter model here (so don't call the check functions).
2794    */
2795
2796   /* Change visibility of an odd row to TRUE */
2797   set_path_visibility (&fixture, "3", TRUE);
2798   check_filter_model (&fixture);
2799   check_level_length (fixture.filter, NULL, 4);
2800 }
2801
2802
2803
2804 static gboolean
2805 specific_has_child_filter_filter_func (GtkTreeModel *model,
2806                                        GtkTreeIter  *iter,
2807                                        gpointer      data)
2808 {
2809   return gtk_tree_model_iter_has_child (model, iter);
2810 }
2811
2812 static void
2813 specific_has_child_filter (void)
2814 {
2815   GtkTreeModel *filter;
2816   GtkTreeIter iter, root;
2817   FilterTest fixture; /* This is not how it should be done */
2818   GtkWidget *tree_view;
2819
2820   fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
2821   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture.store), NULL);
2822   fixture.filter = GTK_TREE_MODEL_FILTER (filter);
2823   fixture.monitor = signal_monitor_new (filter);
2824
2825   tree_view = gtk_tree_view_new_with_model (filter);
2826
2827   /* We will filter on parent state using a filter function.  We will
2828    * manually keep the boolean column in sync, so that we can use
2829    * check_filter_model() to check the consistency of the model.
2830    */
2831   /* FIXME: We need a check_filter_model() that is not tied to LEVEL_LENGTH
2832    * to be able to check the structure here.  We keep the calls to
2833    * check_filter_model() commented out until then.
2834    */
2835   gtk_tree_model_filter_set_visible_func (fixture.filter,
2836                                           specific_has_child_filter_filter_func,
2837                                           NULL, NULL);
2838
2839   /* The first node will be initially invisible: no signals */
2840   gtk_tree_store_append (fixture.store, &root, NULL);
2841   create_tree_store_set_values (fixture.store, &root, FALSE);
2842
2843   /* check_filter_model (&fixture); */
2844   check_level_length (fixture.filter, NULL, 0);
2845   signal_monitor_assert_is_empty (fixture.monitor);
2846
2847   /* Insert a child node. This will cause the parent to become visible
2848    * since there is a child now.
2849    */
2850   signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "0");
2851   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
2852   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
2853
2854   gtk_tree_store_append (fixture.store, &iter, &root);
2855   create_tree_store_set_values (fixture.store, &iter, TRUE);
2856
2857   /* Parent must now be visible.  Do the level length check first,
2858    * to avoid modifying the child model triggering a row-changed to
2859    * the filter model.
2860    */
2861   check_level_length (fixture.filter, NULL, 1);
2862   check_level_length (fixture.filter, "0", 0);
2863   signal_monitor_assert_is_empty (fixture.monitor);
2864
2865   /* This should propagate row-changed */
2866   signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "0");
2867   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
2868
2869   set_path_visibility (&fixture, "0", TRUE);
2870   /* check_filter_model (&fixture); */
2871   signal_monitor_assert_is_empty (fixture.monitor);
2872
2873   /* New root node, no child, so no signal */
2874   gtk_tree_store_append (fixture.store, &root, NULL);
2875   check_level_length (fixture.filter, NULL, 1);
2876   signal_monitor_assert_is_empty (fixture.monitor);
2877
2878   /* When the child comes in, this node will become visible */
2879   signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "1");
2880   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
2881   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
2882   signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "1");
2883   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
2884
2885   gtk_tree_store_append (fixture.store, &iter, &root);
2886   check_level_length (fixture.filter, NULL, 2);
2887   check_level_length (fixture.filter, "1", 0);
2888
2889   create_tree_store_set_values (fixture.store, &root, TRUE);
2890   create_tree_store_set_values (fixture.store, &iter, TRUE);
2891
2892   /* check_filter_model (&fixture); */
2893   signal_monitor_assert_is_empty (fixture.monitor);
2894
2895   /* Add another child for 1 */
2896   gtk_tree_store_append (fixture.store, &iter, &root);
2897   create_tree_store_set_values (fixture.store, &iter, TRUE);
2898   check_level_length (fixture.filter, NULL, 2);
2899   check_level_length (fixture.filter, "0", 0);
2900   check_level_length (fixture.filter, "1", 0);
2901   signal_monitor_assert_is_empty (fixture.monitor);
2902
2903   /* Now remove one of the remaining child rows */
2904   signal_monitor_append_signal (fixture.monitor, ROW_DELETED, "0");
2905
2906   gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture.store),
2907                                        &iter, "0:0");
2908   gtk_tree_store_remove (fixture.store, &iter);
2909
2910   check_level_length (fixture.filter, NULL, 1);
2911   check_level_length (fixture.filter, "0", 0);
2912
2913   set_path_visibility (&fixture, "0", FALSE);
2914   /* check_filter_model (&fixture); */
2915   signal_monitor_assert_is_empty (fixture.monitor);
2916 }
2917
2918
2919 static gboolean
2920 specific_root_has_child_filter_filter_func (GtkTreeModel *model,
2921                                             GtkTreeIter  *iter,
2922                                             gpointer      data)
2923 {
2924   int depth;
2925   GtkTreePath *path;
2926
2927   path = gtk_tree_model_get_path (model, iter);
2928   depth = gtk_tree_path_get_depth (path);
2929   gtk_tree_path_free (path);
2930
2931   if (depth > 1)
2932     return TRUE;
2933   /* else */
2934   return gtk_tree_model_iter_has_child (model, iter);
2935 }
2936
2937 static void
2938 specific_root_has_child_filter (void)
2939 {
2940   GtkTreeModel *filter;
2941   GtkTreeIter iter, root;
2942   FilterTest fixture; /* This is not how it should be done ... */
2943   GtkWidget *tree_view;
2944
2945   /* This is a variation on the above test case, specific has-child-filter,
2946    * herein the has-child check for visibility only applies to root level
2947    * nodes.  In this test, children are always visible because we
2948    * only filter based on the "has child" criterion.
2949    */
2950
2951   fixture.store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
2952   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture.store), NULL);
2953   fixture.filter = GTK_TREE_MODEL_FILTER (filter);
2954   fixture.monitor = signal_monitor_new (filter);
2955
2956   tree_view = gtk_tree_view_new_with_model (filter);
2957
2958   /* We will filter on parent state using a filter function.  We will
2959    * manually keep the boolean column in sync, so that we can use
2960    * check_filter_model() to check the consistency of the model.
2961    */
2962   /* FIXME: We need a check_filter_model() that is not tied to LEVEL_LENGTH
2963    * to be able to check the structure here.  We keep the calls to
2964    * check_filter_model() commented out until then.
2965    */
2966   gtk_tree_model_filter_set_visible_func (fixture.filter,
2967                                           specific_root_has_child_filter_filter_func,
2968                                           NULL, NULL);
2969
2970   /* Add a first node, this will be invisible initially, so no signal
2971    * should be emitted.
2972    */
2973   gtk_tree_store_append (fixture.store, &root, NULL);
2974   create_tree_store_set_values (fixture.store, &root, FALSE);
2975
2976   signal_monitor_assert_is_empty (fixture.monitor);
2977   /* check_filter_model (&fixture); */
2978   check_level_length (fixture.filter, NULL, 0);
2979
2980   /* Add a child node.  This will cause the parent to become visible,
2981    * so we expect row-inserted signals for both.
2982    */
2983   signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "0");
2984   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
2985   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
2986
2987   gtk_tree_store_append (fixture.store, &iter, &root);
2988   signal_monitor_assert_is_empty (fixture.monitor);
2989
2990   check_level_length (fixture.filter, NULL, 1);
2991   check_level_length (fixture.filter, "0", 1);
2992
2993   /* Modify the content of iter, no signals because the parent is not
2994    * expanded.
2995    */
2996   create_tree_store_set_values (fixture.store, &iter, TRUE);
2997   signal_monitor_assert_is_empty (fixture.monitor);
2998
2999   /* Parent must now be visible.  Do the level length check first,
3000    * to avoid modifying the child model triggering a row-changed to
3001    * the filter model.
3002    */
3003   check_level_length (fixture.filter, NULL, 1);
3004   check_level_length (fixture.filter, "0", 1);
3005
3006   /* Modify path 0 */
3007   signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "0");
3008   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
3009
3010   set_path_visibility (&fixture, "0", TRUE);
3011   /* check_filter_model (&fixture); */
3012
3013   signal_monitor_assert_is_empty (fixture.monitor);
3014
3015   /* Insert another node in the root level.  Initially invisible, so
3016    * not expecting any signal.
3017    */
3018   gtk_tree_store_append (fixture.store, &root, NULL);
3019   check_level_length (fixture.filter, NULL, 1);
3020
3021   signal_monitor_assert_is_empty (fixture.monitor);
3022
3023   /* Adding a child node which also makes parent at path 1 visible. */
3024   signal_monitor_append_signal (fixture.monitor, ROW_INSERTED, "1");
3025   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
3026   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
3027
3028   gtk_tree_store_append (fixture.store, &iter, &root);
3029   check_level_length (fixture.filter, NULL, 2);
3030   check_level_length (fixture.filter, "1", 1);
3031
3032   signal_monitor_assert_is_empty (fixture.monitor);
3033
3034   /* Check if row-changed is propagated */
3035   signal_monitor_append_signal (fixture.monitor, ROW_CHANGED, "1");
3036   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "1");
3037
3038   create_tree_store_set_values (fixture.store, &root, TRUE);
3039   create_tree_store_set_values (fixture.store, &iter, TRUE);
3040   /* check_filter_model (&fixture); */
3041   signal_monitor_assert_is_empty (fixture.monitor);
3042
3043   /* Insert another child under node 1 */
3044   gtk_tree_store_append (fixture.store, &iter, &root);
3045   create_tree_store_set_values (fixture.store, &iter, TRUE);
3046   check_level_length (fixture.filter, NULL, 2);
3047   check_level_length (fixture.filter, "0", 1);
3048   check_level_length (fixture.filter, "1", 2);
3049   signal_monitor_assert_is_empty (fixture.monitor);
3050
3051   /* Set a child node to invisible.  This should not yield any
3052    * change, because filtering is only done on whether the root
3053    * node has a child, which it still has.
3054    */
3055   set_path_visibility (&fixture, "0:0", FALSE);
3056   signal_monitor_assert_is_empty (fixture.monitor);
3057
3058   /* Now remove one of the remaining child rows */
3059   signal_monitor_append_signal (fixture.monitor, ROW_HAS_CHILD_TOGGLED, "0");
3060   signal_monitor_append_signal (fixture.monitor, ROW_DELETED, "0");
3061
3062   gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture.store),
3063                                        &iter, "0:0");
3064   gtk_tree_store_remove (fixture.store, &iter);
3065
3066   check_level_length (fixture.filter, NULL, 1);
3067   check_level_length (fixture.filter, "0", 2);
3068   signal_monitor_assert_is_empty (fixture.monitor);
3069
3070   /* Set visibility of 0 to FALSE, no-op for filter model since
3071    * the child 0:0 is already gone
3072    */
3073   set_path_visibility (&fixture, "0", FALSE);
3074   /* check_filter_model (&fixture); */
3075   signal_monitor_assert_is_empty (fixture.monitor);
3076 }
3077
3078
3079 static void
3080 specific_filter_add_child (void)
3081 {
3082   /* This test is based on one of the test cases I found in my
3083    * old test cases directory.  I unfortunately do not have a record
3084    * from who this test case originated.  -Kris.
3085    */
3086
3087   GtkTreeIter iter;
3088   GtkTreeIter iter_first;
3089   GtkTreeIter child;
3090   GtkTreeStore *store;
3091   GtkTreeModel *filter G_GNUC_UNUSED;
3092
3093   store = gtk_tree_store_new (1, G_TYPE_STRING);
3094
3095   gtk_tree_store_append (store, &iter_first, NULL);
3096   gtk_tree_store_set (store, &iter_first, 0, "Hello", -1);
3097
3098   gtk_tree_store_append (store, &iter, NULL);
3099   gtk_tree_store_set (store, &iter, 0, "Hello", -1);
3100
3101   gtk_tree_store_append (store, &iter, NULL);
3102   gtk_tree_store_set (store, &iter, 0, "Hello", -1);
3103
3104   gtk_tree_store_append (store, &iter, NULL);
3105   gtk_tree_store_set (store, &iter, 0, "Hello", -1);
3106
3107   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
3108
3109   gtk_tree_store_set (store, &iter, 0, "Hello", -1);
3110   gtk_tree_store_append (store, &child, &iter_first);
3111   gtk_tree_store_set (store, &child, 0, "Hello", -1);
3112 }
3113
3114 static void
3115 specific_list_store_clear (void)
3116 {
3117   GtkTreeIter iter;
3118   GtkListStore *list;
3119   GtkTreeModel *filter;
3120   GtkWidget *view G_GNUC_UNUSED;
3121
3122   list = gtk_list_store_new (1, G_TYPE_INT);
3123   gtk_list_store_insert_with_values (list, &iter, 0, 0, 1, -1);
3124   gtk_list_store_insert_with_values (list, &iter, 1, 0, 2, -1);
3125   gtk_list_store_insert_with_values (list, &iter, 2, 0, 3, -1);
3126   gtk_list_store_insert_with_values (list, &iter, 3, 0, 4, -1);
3127   gtk_list_store_insert_with_values (list, &iter, 4, 0, 5, -1);
3128   gtk_list_store_insert_with_values (list, &iter, 5, 0, 6, -1);
3129   gtk_list_store_insert_with_values (list, &iter, 6, 0, 7, -1);
3130   gtk_list_store_insert_with_values (list, &iter, 7, 0, 8, -1);
3131
3132   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (list), NULL);
3133   view = gtk_tree_view_new_with_model (filter);
3134
3135   gtk_list_store_clear (list);
3136 }
3137
3138 static void
3139 specific_sort_ref_leaf_and_remove_ancestor (void)
3140 {
3141   GtkTreeIter iter, child, child2, child3;
3142   GtkTreeStore *tree;
3143   GtkTreeModel *sort;
3144   GtkTreePath *path;
3145   GtkTreeRowReference *rowref;
3146   GtkWidget *view G_GNUC_UNUSED;
3147
3148   tree = gtk_tree_store_new (1, G_TYPE_INT);
3149   gtk_tree_store_insert_with_values (tree, &iter, NULL, 0, 0, 1, -1);
3150   gtk_tree_store_insert_with_values (tree, &iter, NULL, 1, 0, 2, -1);
3151   gtk_tree_store_insert_with_values (tree, &iter, NULL, 2, 0, 3, -1);
3152   gtk_tree_store_insert_with_values (tree, &iter, NULL, 3, 0, 4, -1);
3153
3154   gtk_tree_store_insert_with_values (tree, &child, &iter, 0, 0, 50, -1);
3155   gtk_tree_store_insert_with_values (tree, &child2, &child, 0, 0, 6, -1);
3156   gtk_tree_store_insert_with_values (tree, &child3, &child2, 0, 0, 7, -1);
3157
3158   sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (tree));
3159   view = gtk_tree_view_new_with_model (sort);
3160   gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
3161
3162   path = gtk_tree_path_new_from_indices (3, 0, 0, 0, -1);
3163   rowref = gtk_tree_row_reference_new (sort, path);
3164   gtk_tree_path_free (path);
3165
3166   path = gtk_tree_path_new_from_indices (3, 0, 0, 0, -1);
3167   rowref = gtk_tree_row_reference_new (sort, path);
3168   gtk_tree_path_free (path);
3169
3170   path = gtk_tree_path_new_from_indices (3, 0, -1);
3171   rowref = gtk_tree_row_reference_new (sort, path);
3172   gtk_tree_path_free (path);
3173
3174   path = gtk_tree_path_new_from_indices (3, -1);
3175   rowref = gtk_tree_row_reference_new (sort, path);
3176   gtk_tree_path_free (path);
3177
3178   /* Deleting a parent */
3179   path = gtk_tree_path_new_from_indices (3, 0, -1);
3180   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree), &iter, path);
3181   gtk_tree_store_remove (tree, &iter);
3182   gtk_tree_path_free (path);
3183
3184   gtk_tree_row_reference_free (rowref);
3185 }
3186
3187 static void
3188 specific_ref_leaf_and_remove_ancestor (void)
3189 {
3190   GtkTreeIter iter, child, child2, child3;
3191   GtkTreeStore *tree;
3192   GtkTreeModel *filter;
3193   GtkTreePath *path;
3194   GtkTreeRowReference *rowref;
3195   GtkWidget *view G_GNUC_UNUSED;
3196
3197   tree = gtk_tree_store_new (1, G_TYPE_INT);
3198   gtk_tree_store_insert_with_values (tree, &iter, NULL, 0, 0, 1, -1);
3199   gtk_tree_store_insert_with_values (tree, &iter, NULL, 1, 0, 2, -1);
3200   gtk_tree_store_insert_with_values (tree, &iter, NULL, 2, 0, 3, -1);
3201   gtk_tree_store_insert_with_values (tree, &iter, NULL, 3, 0, 4, -1);
3202
3203   gtk_tree_store_insert_with_values (tree, &child, &iter, 0, 0, 50, -1);
3204   gtk_tree_store_insert_with_values (tree, &child2, &child, 0, 0, 6, -1);
3205   gtk_tree_store_insert_with_values (tree, &child3, &child2, 0, 0, 7, -1);
3206
3207   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (tree), NULL);
3208   view = gtk_tree_view_new_with_model (filter);
3209   gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
3210
3211   path = gtk_tree_path_new_from_indices (3, 0, 0, 0, -1);
3212   rowref = gtk_tree_row_reference_new (filter, path);
3213   gtk_tree_path_free (path);
3214
3215   path = gtk_tree_path_new_from_indices (3, 0, 0, 0, -1);
3216   rowref = gtk_tree_row_reference_new (filter, path);
3217   gtk_tree_path_free (path);
3218
3219   path = gtk_tree_path_new_from_indices (3, 0, -1);
3220   rowref = gtk_tree_row_reference_new (filter, path);
3221   gtk_tree_path_free (path);
3222
3223   path = gtk_tree_path_new_from_indices (3, -1);
3224   rowref = gtk_tree_row_reference_new (filter, path);
3225   gtk_tree_path_free (path);
3226
3227   /* Deleting a parent */
3228   path = gtk_tree_path_new_from_indices (3, 0, -1);
3229   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree), &iter, path);
3230   gtk_tree_store_remove (tree, &iter);
3231   gtk_tree_path_free (path);
3232
3233   gtk_tree_row_reference_free (rowref);
3234 }
3235
3236 static void
3237 specific_virtual_ref_leaf_and_remove_ancestor (void)
3238 {
3239   GtkTreeIter iter, child, child2, child3;
3240   GtkTreeStore *tree;
3241   GtkTreeModel *filter;
3242   GtkTreePath *path;
3243   GtkTreeRowReference *rowref;
3244   GtkWidget *view G_GNUC_UNUSED;
3245
3246   tree = gtk_tree_store_new (1, G_TYPE_INT);
3247   gtk_tree_store_insert_with_values (tree, &iter, NULL, 0, 0, 1, -1);
3248   gtk_tree_store_insert_with_values (tree, &iter, NULL, 1, 0, 2, -1);
3249   gtk_tree_store_insert_with_values (tree, &iter, NULL, 2, 0, 3, -1);
3250   gtk_tree_store_insert_with_values (tree, &iter, NULL, 3, 0, 4, -1);
3251
3252   gtk_tree_store_insert_with_values (tree, &child, &iter, 0, 0, 50, -1);
3253   gtk_tree_store_insert_with_values (tree, &child2, &child, 0, 0, 6, -1);
3254   gtk_tree_store_insert_with_values (tree, &child3, &child2, 0, 0, 7, -1);
3255
3256   /* Set a virtual root of 3:0 */
3257   path = gtk_tree_path_new_from_indices (3, 0, -1);
3258   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (tree), path);
3259   gtk_tree_path_free (path);
3260
3261   view = gtk_tree_view_new_with_model (filter);
3262   gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
3263
3264   path = gtk_tree_path_new_from_indices (0, 0, -1);
3265   rowref = gtk_tree_row_reference_new (filter, path);
3266   gtk_tree_path_free (path);
3267
3268   path = gtk_tree_path_new_from_indices (0, 0, -1);
3269   rowref = gtk_tree_row_reference_new (filter, path);
3270   gtk_tree_path_free (path);
3271
3272   path = gtk_tree_path_new_from_indices (0, -1);
3273   rowref = gtk_tree_row_reference_new (filter, path);
3274   gtk_tree_path_free (path);
3275
3276   /* Deleting the virtual root */
3277   path = gtk_tree_path_new_from_indices (3, 0, -1);
3278   gtk_tree_model_get_iter (GTK_TREE_MODEL (tree), &iter, path);
3279   gtk_tree_store_remove (tree, &iter);
3280   gtk_tree_path_free (path);
3281
3282   gtk_tree_row_reference_free (rowref);
3283 }
3284
3285
3286 static int
3287 specific_bug_301558_sort_func (GtkTreeModel *model,
3288                                GtkTreeIter  *a,
3289                                GtkTreeIter  *b,
3290                                gpointer      data)
3291 {
3292   int i, j;
3293
3294   gtk_tree_model_get (model, a, 0, &i, -1);
3295   gtk_tree_model_get (model, b, 0, &j, -1);
3296
3297   return j - i;
3298 }
3299
3300 static void
3301 specific_bug_301558 (void)
3302 {
3303   /* Test case for GNOME Bugzilla bug 301558 provided by
3304    * Markku Vire.
3305    */
3306   GtkTreeStore *tree;
3307   GtkTreeModel *filter;
3308   GtkTreeModel *sort;
3309   GtkTreeIter root, iter, iter2;
3310   GtkWidget *view G_GNUC_UNUSED;
3311   int i;
3312   gboolean add;
3313
3314   g_test_bug ("301558");
3315
3316   tree = gtk_tree_store_new (2, G_TYPE_INT, G_TYPE_BOOLEAN);
3317   gtk_tree_store_append (tree, &iter, NULL);
3318   gtk_tree_store_set (tree, &iter, 0, 123, 1, TRUE, -1);
3319   gtk_tree_store_append (tree, &iter2, &iter);
3320   gtk_tree_store_set (tree, &iter2, 0, 73, 1, TRUE, -1);
3321
3322   sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (tree));
3323   gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (sort),
3324                                            specific_bug_301558_sort_func,
3325                                            NULL, NULL);
3326
3327   filter = gtk_tree_model_filter_new (sort, NULL);
3328   gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter), 1);
3329
3330   view = gtk_tree_view_new_with_model (filter);
3331
3332   while (gtk_events_pending ())
3333     gtk_main_iteration ();
3334
3335   add = TRUE;
3336
3337   for (i = 0; i < 10; i++)
3338     {
3339       if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (tree), &root))
3340         g_assert_not_reached ();
3341
3342       if (add)
3343         {
3344           gtk_tree_store_append (tree, &iter, &root);
3345           gtk_tree_store_set (tree, &iter, 0, 456, 1, TRUE, -1);
3346         }
3347       else
3348         {
3349           int n;
3350           n = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (tree), &root);
3351           gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (tree), &iter,
3352                                          &root, n - 1);
3353           gtk_tree_store_remove (tree, &iter);
3354         }
3355
3356       add = !add;
3357     }
3358 }
3359
3360
3361 static gboolean
3362 specific_bug_311955_filter_func (GtkTreeModel *model,
3363                                  GtkTreeIter  *iter,
3364                                  gpointer      data)
3365 {
3366   int value;
3367
3368   gtk_tree_model_get (model, iter, 0, &value, -1);
3369
3370   return (value != 0);
3371 }
3372
3373 static void
3374 specific_bug_311955 (void)
3375 {
3376   /* This is a test case for GNOME Bugzilla bug 311955.  It was written
3377    * by Markku Vire.
3378    */
3379   GtkTreeIter iter, child, root;
3380   GtkTreeStore *store;
3381   GtkTreeModel *sort;
3382   GtkTreeModel *filter;
3383
3384   GtkWidget *window G_GNUC_UNUSED;
3385   GtkWidget *tree_view;
3386   int i;
3387   int n;
3388   GtkTreePath *path;
3389
3390   g_test_bug ("311955");
3391
3392   store = gtk_tree_store_new (1, G_TYPE_INT);
3393
3394   gtk_tree_store_append (store, &root, NULL);
3395   gtk_tree_store_set (store, &root, 0, 33, -1);
3396
3397   gtk_tree_store_append (store, &iter, &root);
3398   gtk_tree_store_set (store, &iter, 0, 50, -1);
3399
3400   gtk_tree_store_append (store, &iter, NULL);
3401   gtk_tree_store_set (store, &iter, 0, 22, -1);
3402
3403   sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
3404   filter = gtk_tree_model_filter_new (sort, NULL);
3405
3406   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
3407                                           specific_bug_311955_filter_func,
3408                                           NULL, NULL);
3409
3410   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3411   tree_view = gtk_tree_view_new_with_model (filter);
3412   g_object_unref (store);
3413
3414   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
3415
3416   while (gtk_events_pending ())
3417     gtk_main_iteration ();
3418
3419   check_level_length (GTK_TREE_MODEL_FILTER (filter), NULL, 2);
3420   check_level_length (GTK_TREE_MODEL_FILTER (filter), "0", 1);
3421
3422   /* Fill model */
3423   for (i = 0; i < 4; i++)
3424     {
3425       gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &root);
3426
3427       gtk_tree_store_append (store, &iter, &root);
3428
3429       if (i < 3)
3430         gtk_tree_store_set (store, &iter, 0, i, -1);
3431
3432       if (i % 2 == 0)
3433         {
3434           gtk_tree_store_append (store, &child, &iter);
3435           gtk_tree_store_set (store, &child, 0, 10, -1);
3436         }
3437     }
3438
3439   while (gtk_events_pending ())
3440     gtk_main_iteration ();
3441
3442   check_level_length (GTK_TREE_MODEL_FILTER (filter), "0", 3);
3443   check_level_length (GTK_TREE_MODEL_FILTER (filter), "0:2", 1);
3444
3445   /* Remove bottommost child from the tree. */
3446   gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &root);
3447   n = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (store), &root);
3448
3449   if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store), &iter, &root, n - 2))
3450     {
3451       if (gtk_tree_model_iter_children (GTK_TREE_MODEL (store), &child, &iter))
3452         gtk_tree_store_remove (store, &child);
3453     }
3454   else
3455     g_assert_not_reached ();
3456
3457   path = gtk_tree_path_new_from_indices (0, 2, -1);
3458   gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
3459   gtk_tree_path_free (path);
3460
3461   check_level_length (GTK_TREE_MODEL_FILTER (filter), "0", 3);
3462   check_level_length (GTK_TREE_MODEL_FILTER (filter), "0:2", 0);
3463 }
3464
3465 static void
3466 specific_bug_346800 (void)
3467 {
3468   /* This is a test case for GNOME Bugzilla bug 346800.  It was written
3469    * by Jonathan Matthew.
3470    */
3471
3472   GtkTreeIter node_iters[50];
3473   GtkTreeIter child_iters[50];
3474   GtkTreeModel *model;
3475   GtkTreeModelFilter *filter;
3476   GtkTreeStore *store;
3477   GType *columns;
3478   int i;
3479   int items = 50;
3480   columns = g_new (GType, 2);
3481   columns[0] = G_TYPE_STRING;
3482   columns[1] = G_TYPE_BOOLEAN;
3483   store = gtk_tree_store_newv (2, columns);
3484   model = GTK_TREE_MODEL (store);
3485
3486   g_test_bug ("346800");
3487
3488   filter = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (model, NULL));
3489   gtk_tree_model_filter_set_visible_column (filter, 1);
3490
3491   for (i=0; i<items; i++)
3492     {
3493       /* allocate random amounts of junk, otherwise the filter model's arrays can expand without moving */
3494
3495       g_malloc (138);
3496       gtk_tree_store_append (store, &node_iters[i], NULL);
3497       gtk_tree_store_set (store, &node_iters[i],
3498                           0, "something",
3499                           1, ((i%6) == 0) ? FALSE : TRUE,
3500                           -1);
3501
3502       g_malloc (47);
3503       gtk_tree_store_append (store, &child_iters[i], &node_iters[i]);
3504       gtk_tree_store_set (store, &child_iters[i],
3505                           0, "something else",
3506                           1, FALSE,
3507                           -1);
3508       gtk_tree_model_filter_refilter (filter);
3509
3510       if (i > 6)
3511         {
3512           gtk_tree_store_set (GTK_TREE_STORE (model), &child_iters[i-1], 1,
3513                               (i & 1) ? TRUE : FALSE, -1);
3514           gtk_tree_model_filter_refilter (filter);
3515
3516           gtk_tree_store_set (GTK_TREE_STORE (model), &child_iters[i-2], 1,
3517                               (i & 1) ? FALSE: TRUE, -1);
3518           gtk_tree_model_filter_refilter (filter);
3519         }
3520     }
3521 }
3522
3523 static gboolean
3524 specific_bug_464173_visible_func (GtkTreeModel *model,
3525                                   GtkTreeIter  *iter,
3526                                   gpointer      data)
3527 {
3528   gboolean *visible = (gboolean *)data;
3529
3530   return *visible;
3531 }
3532
3533 static void
3534 specific_bug_464173 (void)
3535 {
3536   /* Test case for GNOME Bugzilla bug 464173, test case written
3537    * by Andreas Koehler.
3538    */
3539   GtkTreeStore *model;
3540   GtkTreeModelFilter *f_model;
3541   GtkTreeIter iter1, iter2;
3542   GtkWidget *view G_GNUC_UNUSED;
3543   gboolean visible = TRUE;
3544
3545   g_test_bug ("464173");
3546
3547   model = gtk_tree_store_new (1, G_TYPE_STRING);
3548   gtk_tree_store_append (model, &iter1, NULL);
3549   gtk_tree_store_set (model, &iter1, 0, "Foo", -1);
3550   gtk_tree_store_append (model, &iter2, &iter1);
3551   gtk_tree_store_set (model, &iter2, 0, "Bar", -1);
3552
3553   f_model = GTK_TREE_MODEL_FILTER (gtk_tree_model_filter_new (GTK_TREE_MODEL(model), NULL));
3554   gtk_tree_model_filter_set_visible_func (f_model,
3555                                           specific_bug_464173_visible_func,
3556                                           &visible, NULL);
3557
3558   view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (f_model));
3559
3560   visible = FALSE;
3561   gtk_tree_model_filter_refilter (f_model);
3562 }
3563
3564
3565 static gboolean
3566 specific_bug_540201_filter_func (GtkTreeModel *model,
3567                                  GtkTreeIter  *iter,
3568                                  gpointer      data)
3569 {
3570   gboolean has_children;
3571
3572   has_children = gtk_tree_model_iter_has_child (model, iter);
3573
3574   return has_children;
3575 }
3576
3577 static void
3578 specific_bug_540201 (void)
3579 {
3580   /* Test case for GNOME Bugzilla bug 540201, steps provided by
3581    * Charles Day.
3582    */
3583   GtkTreeIter iter, root;
3584   GtkTreeStore *store;
3585   GtkTreeModel *filter;
3586
3587   GtkWidget *tree_view G_GNUC_UNUSED;
3588
3589   g_test_bug ("540201");
3590
3591   store = gtk_tree_store_new (1, G_TYPE_INT);
3592
3593   gtk_tree_store_append (store, &root, NULL);
3594   gtk_tree_store_set (store, &root, 0, 33, -1);
3595
3596   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
3597   tree_view = gtk_tree_view_new_with_model (filter);
3598
3599   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
3600                                           specific_bug_540201_filter_func,
3601                                           NULL, NULL);
3602
3603   gtk_tree_store_append (store, &iter, &root);
3604   gtk_tree_store_set (store, &iter, 0, 50, -1);
3605
3606   gtk_tree_store_append (store, &iter, &root);
3607   gtk_tree_store_set (store, &iter, 0, 22, -1);
3608
3609
3610   gtk_tree_store_append (store, &root, NULL);
3611   gtk_tree_store_set (store, &root, 0, 33, -1);
3612
3613   gtk_tree_store_append (store, &iter, &root);
3614   gtk_tree_store_set (store, &iter, 0, 22, -1);
3615 }
3616
3617
3618 static gboolean
3619 specific_bug_549287_visible_func (GtkTreeModel *model,
3620                                   GtkTreeIter  *iter,
3621                                   gpointer      data)
3622 {
3623   gboolean result = FALSE;
3624
3625   result = gtk_tree_model_iter_has_child (model, iter);
3626
3627   return result;
3628 }
3629
3630 static void
3631 specific_bug_549287 (void)
3632 {
3633   /* Test case for GNOME Bugzilla bug 529287, provided by Julient Puydt */
3634
3635   int i;
3636   GtkTreeStore *store;
3637   GtkTreeModel *filtered;
3638   GtkWidget *view G_GNUC_UNUSED;
3639   GtkTreeIter iter;
3640   GtkTreeIter *swap, *parent, *child;
3641
3642   g_test_bug ("529287");
3643
3644   store = gtk_tree_store_new (1, G_TYPE_STRING);
3645   filtered = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
3646   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filtered),
3647                                           specific_bug_549287_visible_func,
3648                                           NULL, NULL);
3649
3650   view = gtk_tree_view_new_with_model (filtered);
3651
3652   for (i = 0; i < 4; i++)
3653     {
3654       if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter))
3655         {
3656           parent = gtk_tree_iter_copy (&iter);
3657           child = gtk_tree_iter_copy (&iter);
3658
3659           while (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (store),
3660                                                 child, parent, 0))
3661             {
3662
3663               swap = parent;
3664               parent = child;
3665               child = swap;
3666             }
3667
3668           gtk_tree_store_append (store, child, parent);
3669           gtk_tree_store_set (store, child,
3670                               0, "Something",
3671                               -1);
3672
3673           gtk_tree_iter_free (parent);
3674           gtk_tree_iter_free (child);
3675         }
3676       else
3677         {
3678           gtk_tree_store_append (store, &iter, NULL);
3679           gtk_tree_store_set (store, &iter,
3680                               0, "Something",
3681                               -1);
3682         }
3683
3684       /* since we inserted something, we changed the visibility conditions: */
3685       gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (filtered));
3686     }
3687 }
3688
3689 static gboolean
3690 specific_bug_621076_visible_func (GtkTreeModel *model,
3691                                   GtkTreeIter  *iter,
3692                                   gpointer      data)
3693 {
3694   gboolean visible = FALSE;
3695   gchar *str = NULL;
3696
3697   gtk_tree_model_get (model, iter, 0, &str, -1);
3698   if (str != NULL && g_str_has_prefix (str, "visible"))
3699     {
3700       visible = TRUE;
3701     }
3702   else
3703     {
3704       GtkTreeIter child_iter;
3705       gboolean valid;
3706
3707       /* Recursively check if we have a visible child */
3708       for (valid = gtk_tree_model_iter_children (model, &child_iter, iter);
3709            valid; valid = gtk_tree_model_iter_next (model, &child_iter))
3710         {
3711           if (specific_bug_621076_visible_func (model, &child_iter, data))
3712             {
3713               visible = TRUE;
3714               break;
3715             }
3716         }
3717     }
3718
3719   if (str)
3720     g_free (str);
3721
3722   return visible;
3723 }
3724
3725 static void
3726 specific_bug_621076 (void)
3727 {
3728   /* Test case for GNOME Bugzilla bug 621076, provided by Xavier Claessens */
3729
3730   /* This test case differs from has-child-filter and root-has-child-filter
3731    * in that the visible function both filters on content and model
3732    * structure.  Also, it is recursive.
3733    */
3734
3735   GtkTreeStore *store;
3736   GtkTreeModel *filter;
3737   GtkWidget *view;
3738   GtkTreeIter group_iter;
3739   GtkTreeIter item_iter;
3740   SignalMonitor *monitor;
3741
3742   g_test_bug ("621076");
3743
3744   store = gtk_tree_store_new (1, G_TYPE_STRING);
3745   filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
3746   gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (filter),
3747                                           specific_bug_621076_visible_func,
3748                                           NULL, NULL);
3749
3750   view = gtk_tree_view_new_with_model (filter);
3751   g_object_ref_sink (view);
3752
3753   monitor = signal_monitor_new (filter);
3754
3755   signal_monitor_append_signal (monitor, ROW_INSERTED, "0");
3756   gtk_tree_store_insert_with_values (store, &item_iter, NULL, -1,
3757                                      0, "visible-group-0",
3758                                      -1);
3759   signal_monitor_assert_is_empty (monitor);
3760
3761   /* visible-group-0 is not expanded, so ROW_INSERTED should not be emitted
3762    * for its children. However, ROW_HAS_CHILD_TOGGLED should be emitted on
3763    * visible-group-0 to tell the view that row can be expanded. */
3764   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "0");
3765   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "0");
3766   group_iter = item_iter;
3767   gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
3768                                      0, "visible-0:0",
3769                                      -1);
3770   signal_monitor_assert_is_empty (monitor);
3771
3772   signal_monitor_append_signal (monitor, ROW_INSERTED, "1");
3773   gtk_tree_store_insert_with_values (store, &item_iter, NULL, -1,
3774                                      0, "visible-group-1",
3775                                      -1);
3776   signal_monitor_assert_is_empty (monitor);
3777
3778   /* We are adding an hidden item inside visible-group-1, so
3779    * ROW_HAS_CHILD_TOGGLED should not be emitted.  It is emitted though,
3780    * because the signal originating at TreeStore will be propagated,
3781    * as well a generated signal because the state of the parent *could*
3782    * change by a change in the model.
3783    */
3784   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1");
3785   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1");
3786   group_iter = item_iter;
3787   gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
3788                                      0, "group-1:0",
3789                                      -1);
3790   signal_monitor_assert_is_empty (monitor);
3791
3792   /* This group is invisible and its parent too. Nothing should be emitted */
3793   group_iter = item_iter;
3794   gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
3795                                      0, "group-1:0:0",
3796                                      -1);
3797   signal_monitor_assert_is_empty (monitor);
3798
3799   /* Adding a visible item in this group hierarchy will make all nodes
3800    * in this path visible.  The first level should simply tell the view
3801    * that it now has a child, and the view will load the tree if needed
3802    * (depends on the expanded state).
3803    */
3804   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1");
3805   group_iter = item_iter;
3806   gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
3807                                      0, "visible-1:0:0:0",
3808                                      -1);
3809   signal_monitor_assert_is_empty (monitor);
3810
3811   check_level_length (GTK_TREE_MODEL_FILTER (filter), "1", 1);
3812
3813   gtk_tree_store_insert_with_values (store, &item_iter, NULL, -1,
3814                                      0, "group-2",
3815                                      -1);
3816   signal_monitor_assert_is_empty (monitor);
3817
3818   /* Parent is invisible, and adding this invisible item won't change that,
3819    * so no signal should be emitted. */
3820   group_iter = item_iter;
3821   gtk_tree_store_insert_with_values (store, NULL, &group_iter, -1,
3822                                      0, "invisible-2:0",
3823                                      -1);
3824   signal_monitor_assert_is_empty (monitor);
3825
3826   /* This makes group-2 visible, so it gets inserted and tells it has
3827    * children.
3828    */
3829   signal_monitor_append_signal (monitor, ROW_INSERTED, "2");
3830   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "2");
3831   gtk_tree_store_insert_with_values (store, NULL, &group_iter, -1,
3832                                      0, "visible-2:1",
3833                                      -1);
3834   signal_monitor_assert_is_empty (monitor);
3835
3836   /* group-2 is already visible, so this time it is a normal insertion */
3837   gtk_tree_store_insert_with_values (store, NULL, &group_iter, -1,
3838                                      0, "visible-2:2",
3839                                      -1);
3840   signal_monitor_assert_is_empty (monitor);
3841
3842
3843   gtk_tree_store_insert_with_values (store, &item_iter, NULL, -1,
3844                                      0, "group-3",
3845                                      -1);
3846   signal_monitor_assert_is_empty (monitor);
3847
3848   /* Parent is invisible, and adding this invisible item won't change that,
3849    * so no signal should be emitted. */
3850   group_iter = item_iter;
3851   gtk_tree_store_insert_with_values (store, NULL, &group_iter, -1,
3852                                      0, "invisible-3:0",
3853                                      -1);
3854   signal_monitor_assert_is_empty (monitor);
3855
3856   gtk_tree_store_insert_with_values (store, &item_iter, &group_iter, -1,
3857                                      0, "invisible-3:1",
3858                                      -1);
3859   signal_monitor_assert_is_empty (monitor);
3860
3861   /* This will make group 3 visible. */
3862   signal_monitor_append_signal (monitor, ROW_INSERTED, "3");
3863   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "3");
3864   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "3");
3865   gtk_tree_store_set (store, &item_iter, 0, "visible-3:1", -1);
3866   signal_monitor_assert_is_empty (monitor);
3867
3868   /* Make sure all groups are expanded, so the filter has the tree cached */
3869   gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
3870   while (gtk_events_pending ())
3871     gtk_main_iteration ();
3872
3873   /* Should only yield a row-changed */
3874   signal_monitor_append_signal (monitor, ROW_CHANGED, "3:0");
3875   gtk_tree_store_set (store, &item_iter, 0, "visible-3:1", -1);
3876   signal_monitor_assert_is_empty (monitor);
3877
3878   /* Now remove/hide some items. If a group loses its last item, the group
3879    * should be deleted instead of the item.
3880    */
3881
3882   signal_monitor_append_signal (monitor, ROW_DELETED, "2:1");
3883   gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &item_iter, "2:2");
3884   gtk_tree_store_remove (store, &item_iter);
3885   signal_monitor_assert_is_empty (monitor);
3886
3887   signal_monitor_append_signal (monitor, ROW_DELETED, "2:0");
3888   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "2");
3889   signal_monitor_append_signal (monitor, ROW_DELETED, "2");
3890   gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &item_iter, "2:1");
3891   gtk_tree_store_set (store, &item_iter, 0, "invisible-2:1", -1);
3892   signal_monitor_assert_is_empty (monitor);
3893
3894   signal_monitor_append_signal (monitor, ROW_DELETED, "1:0:0:0");
3895   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1:0:0");
3896   signal_monitor_append_signal (monitor, ROW_DELETED, "1:0");
3897   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "1");
3898   gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &item_iter, "1:0:0:0");
3899   gtk_tree_store_remove (store, &item_iter);
3900   signal_monitor_assert_is_empty (monitor);
3901
3902   /* Hide a group using row-changed instead of row-deleted */
3903   /* Caution: group 2 is gone, so offsets of the signals have moved. */
3904   signal_monitor_append_signal (monitor, ROW_DELETED, "2:0");
3905   signal_monitor_append_signal (monitor, ROW_HAS_CHILD_TOGGLED, "2");
3906   signal_monitor_append_signal (monitor, ROW_DELETED, "2");
3907   gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (store), &item_iter,
3908                                        "3:1");
3909   gtk_tree_store_set (store, &item_iter, 0, "invisible-3:1", -1);
3910   signal_monitor_assert_is_empty (monitor);
3911
3912 #if 0
3913   {
3914     GtkWidget *window;
3915     GtkTreeViewColumn *col;
3916
3917     gtk_tree_view_expand_all (GTK_TREE_VIEW (view));
3918
3919     col = gtk_tree_view_column_new_with_attributes ("foo",
3920         gtk_cell_renderer_text_new (),
3921         "text", 0, NULL);
3922     gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
3923
3924     window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
3925     g_signal_connect (window, "delete-event",
3926         G_CALLBACK (gtk_widget_destroy), NULL);
3927     g_signal_connect (window, "destroy",
3928         G_CALLBACK (gtk_main_quit), NULL);
3929
3930     gtk_container_add (GTK_CONTAINER (window), view);
3931
3932     gtk_widget_show (view);
3933     gtk_widget_show (window);
3934
3935     gtk_main ();
3936   }
3937 #endif
3938
3939   /* Cleanup */
3940   signal_monitor_free (monitor);
3941   g_object_unref (view);
3942   g_object_unref (store);
3943   g_object_unref (filter);
3944 }
3945
3946 /* main */
3947
3948 void
3949 register_filter_model_tests (void)
3950 {
3951   g_test_add ("/TreeModelFilter/self/verify-test-suite",
3952               FilterTest, NULL,
3953               filter_test_setup,
3954               verify_test_suite,
3955               filter_test_teardown);
3956
3957   g_test_add ("/TreeModelFilter/self/verify-test-suite/vroot/depth-1",
3958               FilterTest, gtk_tree_path_new_from_indices (2, -1),
3959               filter_test_setup,
3960               verify_test_suite_vroot,
3961               filter_test_teardown);
3962   g_test_add ("/TreeModelFilter/self/verify-test-suite/vroot/depth-2",
3963               FilterTest, gtk_tree_path_new_from_indices (2, 3, -1),
3964               filter_test_setup,
3965               verify_test_suite_vroot,
3966               filter_test_teardown);
3967
3968
3969   g_test_add ("/TreeModelFilter/filled/hide-root-level",
3970               FilterTest, NULL,
3971               filter_test_setup,
3972               filled_hide_root_level,
3973               filter_test_teardown);
3974   g_test_add ("/TreeModelFilter/filled/hide-child-levels",
3975               FilterTest, NULL,
3976               filter_test_setup,
3977               filled_hide_child_levels,
3978               filter_test_teardown);
3979   g_test_add ("/TreeModelFilter/filled/hide-child-levels/root-expanded",
3980               FilterTest, NULL,
3981               filter_test_setup,
3982               filled_hide_child_levels_root_expanded,
3983               filter_test_teardown);
3984
3985   g_test_add ("/TreeModelFilter/filled/hide-root-level/vroot",
3986               FilterTest, gtk_tree_path_new_from_indices (2, -1),
3987               filter_test_setup,
3988               filled_vroot_hide_root_level,
3989               filter_test_teardown);
3990   g_test_add ("/TreeModelFilter/filled/hide-child-levels/vroot",
3991               FilterTest, gtk_tree_path_new_from_indices (2, -1),
3992               filter_test_setup,
3993               filled_vroot_hide_child_levels,
3994               filter_test_teardown);
3995   g_test_add ("/TreeModelFilter/filled/hide-child-levels/vroot-root-expanded",
3996               FilterTest, gtk_tree_path_new_from_indices (2, -1),
3997               filter_test_setup,
3998               filled_vroot_hide_child_levels_root_expanded,
3999               filter_test_teardown);
4000
4001
4002   g_test_add ("/TreeModelFilter/empty/show-nodes",
4003               FilterTest, NULL,
4004               filter_test_setup_empty,
4005               empty_show_nodes,
4006               filter_test_teardown);
4007   g_test_add ("/TreeModelFilter/empty/show-multiple-nodes",
4008               FilterTest, NULL,
4009               filter_test_setup_empty,
4010               empty_show_multiple_nodes,
4011               filter_test_teardown);
4012
4013   g_test_add ("/TreeModelFilter/empty/show-nodes/vroot",
4014               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4015               filter_test_setup_empty,
4016               empty_vroot_show_nodes,
4017               filter_test_teardown);
4018   g_test_add ("/TreeModelFilter/empty/show-multiple-nodes/vroot",
4019               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4020               filter_test_setup_empty,
4021               empty_vroot_show_multiple_nodes,
4022               filter_test_teardown);
4023
4024
4025   g_test_add ("/TreeModelFilter/unfiltered/hide-single",
4026               FilterTest, NULL,
4027               filter_test_setup_unfiltered,
4028               unfiltered_hide_single,
4029               filter_test_teardown);
4030   g_test_add ("/TreeModelFilter/unfiltered/hide-single/root-expanded",
4031               FilterTest, NULL,
4032               filter_test_setup_unfiltered_root_expanded,
4033               unfiltered_hide_single_root_expanded,
4034               filter_test_teardown);
4035   g_test_add ("/TreeModelFilter/unfiltered/hide-single-child",
4036               FilterTest, NULL,
4037               filter_test_setup_unfiltered,
4038               unfiltered_hide_single_child,
4039               filter_test_teardown);
4040   g_test_add ("/TreeModelFilter/unfiltered/hide-single-child/root-expanded",
4041               FilterTest, NULL,
4042               filter_test_setup_unfiltered_root_expanded,
4043               unfiltered_hide_single_child_root_expanded,
4044               filter_test_teardown);
4045   g_test_add ("/TreeModelFilter/unfiltered/hide-single-multi-level",
4046               FilterTest, NULL,
4047               filter_test_setup_unfiltered,
4048               unfiltered_hide_single_multi_level,
4049               filter_test_teardown);
4050   g_test_add ("/TreeModelFilter/unfiltered/hide-single-multi-level/root-expanded",
4051               FilterTest, NULL,
4052               filter_test_setup_unfiltered_root_expanded,
4053               unfiltered_hide_single_multi_level_root_expanded,
4054               filter_test_teardown);
4055
4056   g_test_add ("/TreeModelFilter/unfiltered/hide-single/vroot",
4057               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4058               filter_test_setup_unfiltered,
4059               unfiltered_vroot_hide_single,
4060               filter_test_teardown);
4061   g_test_add ("/TreeModelFilter/unfiltered/hide-single-child/vroot",
4062               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4063               filter_test_setup_unfiltered,
4064               unfiltered_vroot_hide_single_child,
4065               filter_test_teardown);
4066   g_test_add ("/TreeModelFilter/unfiltered/hide-single-child/vroot/root-expanded",
4067               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4068               filter_test_setup_unfiltered_root_expanded,
4069               unfiltered_vroot_hide_single_child_root_expanded,
4070               filter_test_teardown);
4071   g_test_add ("/TreeModelFilter/unfiltered/hide-single-multi-level/vroot",
4072               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4073               filter_test_setup_unfiltered,
4074               unfiltered_vroot_hide_single_multi_level,
4075               filter_test_teardown);
4076   g_test_add ("/TreeModelFilter/unfiltered/hide-single-multi-level/vroot/root-expanded",
4077               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4078               filter_test_setup_unfiltered_root_expanded,
4079               unfiltered_vroot_hide_single_multi_level_root_expanded,
4080               filter_test_teardown);
4081
4082
4083
4084   g_test_add ("/TreeModelFilter/unfiltered/show-single",
4085               FilterTest, NULL,
4086               filter_test_setup_empty_unfiltered,
4087               unfiltered_show_single,
4088               filter_test_teardown);
4089   g_test_add ("/TreeModelFilter/unfiltered/show-single-child",
4090               FilterTest, NULL,
4091               filter_test_setup_empty_unfiltered,
4092               unfiltered_show_single_child,
4093               filter_test_teardown);
4094   g_test_add ("/TreeModelFilter/unfiltered/show-single-child/root-expanded",
4095               FilterTest, NULL,
4096               filter_test_setup_empty_unfiltered_root_expanded,
4097               unfiltered_show_single_child_root_expanded,
4098               filter_test_teardown);
4099   g_test_add ("/TreeModelFilter/unfiltered/show-single-multi-level",
4100               FilterTest, NULL,
4101               filter_test_setup_empty_unfiltered,
4102               unfiltered_show_single_multi_level,
4103               filter_test_teardown);
4104   g_test_add ("/TreeModelFilter/unfiltered/show-single-multi-level/root-expanded",
4105               FilterTest, NULL,
4106               filter_test_setup_empty_unfiltered_root_expanded,
4107               unfiltered_show_single_multi_level_root_expanded,
4108               filter_test_teardown);
4109
4110   g_test_add ("/TreeModelFilter/unfiltered/show-single/vroot",
4111               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4112               filter_test_setup_empty_unfiltered,
4113               unfiltered_vroot_show_single,
4114               filter_test_teardown);
4115   g_test_add ("/TreeModelFilter/unfiltered/show-single-child/vroot",
4116               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4117               filter_test_setup_empty_unfiltered,
4118               unfiltered_vroot_show_single_child,
4119               filter_test_teardown);
4120   g_test_add ("/TreeModelFilter/unfiltered/show-single-child/vroot/root-expanded",
4121               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4122               filter_test_setup_empty_unfiltered_root_expanded,
4123               unfiltered_vroot_show_single_child_root_expanded,
4124               filter_test_teardown);
4125   g_test_add ("/TreeModelFilter/unfiltered/show-single-multi-level/vroot",
4126               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4127               filter_test_setup_empty_unfiltered,
4128               unfiltered_vroot_show_single_multi_level,
4129               filter_test_teardown);
4130   g_test_add ("/TreeModelFilter/unfiltered/show-single-multi-level/vroot/root-expanded",
4131               FilterTest, gtk_tree_path_new_from_indices (2, -1),
4132               filter_test_setup_empty_unfiltered_root_expanded,
4133               unfiltered_vroot_show_single_multi_level_root_expanded,
4134               filter_test_teardown);
4135
4136   /* Inserts in child models after creation of filter model */
4137   g_test_add_func ("/TreeModelFilter/insert/before",
4138                    insert_before);
4139   g_test_add_func ("/TreeModelFilter/insert/child",
4140                    insert_child);
4141
4142   /* Removals from child model after creating of filter model */
4143   g_test_add_func ("/TreeModelFilter/remove/node",
4144                    remove_node);
4145   g_test_add_func ("/TreeModelFilter/remove/node-vroot",
4146                    remove_node_vroot);
4147   g_test_add_func ("/TreeModelFilter/remove/vroot-ancestor",
4148                    remove_vroot_ancestor);
4149
4150
4151   g_test_add_func ("/TreeModelFilter/specific/path-dependent-filter",
4152                    specific_path_dependent_filter);
4153   g_test_add_func ("/TreeModelFilter/specific/append-after-collapse",
4154                    specific_append_after_collapse);
4155   g_test_add_func ("/TreeModelFilter/specific/sort-filter-remove-node",
4156                    specific_sort_filter_remove_node);
4157   g_test_add_func ("/TreeModelFilter/specific/sort-filter-remove-root",
4158                    specific_sort_filter_remove_root);
4159   g_test_add_func ("/TreeModelFilter/specific/root-mixed-visibility",
4160                    specific_root_mixed_visibility);
4161   g_test_add_func ("/TreeModelFilter/specific/has-child-filter",
4162                    specific_has_child_filter);
4163   g_test_add_func ("/TreeModelFilter/specific/root-has-child-filter",
4164                    specific_root_has_child_filter);
4165   g_test_add_func ("/TreeModelFilter/specific/filter-add-child",
4166                    specific_filter_add_child);
4167   g_test_add_func ("/TreeModelFilter/specific/list-store-clear",
4168                    specific_list_store_clear);
4169   g_test_add_func ("/TreeModelFilter/specific/sort-ref-leaf-and-remove-ancestor",
4170                    specific_sort_ref_leaf_and_remove_ancestor);
4171   g_test_add_func ("/TreeModelFilter/specific/ref-leaf-and-remove-ancestor",
4172                    specific_ref_leaf_and_remove_ancestor);
4173   g_test_add_func ("/TreeModelFilter/specific/virtual-ref-leaf-and-remove-ancestor",
4174                    specific_virtual_ref_leaf_and_remove_ancestor);
4175
4176   g_test_add_func ("/TreeModelFilter/specific/bug-301558",
4177                    specific_bug_301558);
4178   g_test_add_func ("/TreeModelFilter/specific/bug-311955",
4179                    specific_bug_311955);
4180   g_test_add_func ("/TreeModelFilter/specific/bug-346800",
4181                    specific_bug_346800);
4182   g_test_add_func ("/TreeModelFilter/specific/bug-464173",
4183                    specific_bug_464173);
4184   g_test_add_func ("/TreeModelFilter/specific/bug-540201",
4185                    specific_bug_540201);
4186   g_test_add_func ("/TreeModelFilter/specific/bug-549287",
4187                    specific_bug_549287);
4188   g_test_add_func ("/TreeModelFilter/specific/bug-621076",
4189                    specific_bug_621076);
4190 }