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

   1 /* Extensive GtkTreeModelSort 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 #include "treemodel.h"
  23 #include "gtktreemodelrefcount.h"
  24
  25
  26 static void
  27 ref_count_single_level (void)
  28 {
  29   GtkTreeIter iter;
  30   GtkTreeModel *model;
  31   GtkTreeModelRefCount *ref_model;
  32   GtkTreeModel *sort_model;
  33   GtkWidget *tree_view;
  34
  35   model = gtk_tree_model_ref_count_new ();
  36   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
  37
  38   gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  39   gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  40   gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  41   gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  42   gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL);
  43
  44   assert_root_level_unreferenced (ref_model);
  45
  46   sort_model = gtk_tree_model_sort_new_with_model (model);
  47   tree_view = gtk_tree_view_new_with_model (sort_model);
  48
  49   assert_entire_model_referenced (ref_model, 1);
  50
  51   gtk_widget_destroy (tree_view);
  52
  53   assert_entire_model_unreferenced (ref_model);
  54
  55   g_object_unref (sort_model);
  56   g_object_unref (ref_model);
  57 }
  58
  59 static void
  60 ref_count_two_levels (void)
  61 {
  62   GtkTreeIter parent1, parent2, iter;
  63   GtkTreeModel *model;
  64   GtkTreeModelRefCount *ref_model;
  65   GtkTreeModel *sort_model;
  66   GtkWidget *tree_view;
  67
  68   model = gtk_tree_model_ref_count_new ();
  69   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
  70
  71   gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, NULL);
  72   gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, NULL);
  73   gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &parent2);
  74   gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &parent2);
  75   gtk_tree_store_append (GTK_TREE_STORE (model), &iter, &parent2);
  76
  77   assert_entire_model_unreferenced (ref_model);
  78
  79   sort_model = gtk_tree_model_sort_new_with_model (model);
  80   tree_view = gtk_tree_view_new_with_model (sort_model);
  81
  82   assert_root_level_referenced (ref_model, 1);
  83   assert_node_ref_count (ref_model, &iter, 0);
  84
  85   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
  86
  87   assert_node_ref_count (ref_model, &parent1, 1);
  88   assert_node_ref_count (ref_model, &parent2, 2);
  89   assert_node_ref_count (ref_model, &iter, 1);
  90
  91   gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view));
  92
  93   assert_node_ref_count (ref_model, &parent1, 1);
  94   assert_node_ref_count (ref_model, &parent2, 2);
  95   assert_node_ref_count (ref_model, &iter, 0);
  96
  97   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
  98
  99   assert_root_level_referenced (ref_model, 1);
 100   assert_node_ref_count (ref_model, &iter, 0);
 101
 102   gtk_widget_destroy (tree_view);
 103
 104   assert_entire_model_unreferenced (ref_model);
 105
 106   g_object_unref (sort_model);
 107   g_object_unref (ref_model);
 108 }
 109
 110 static void
 111 ref_count_three_levels (void)
 112 {
 113   GtkTreeIter grandparent1, grandparent2, parent1, parent2;
 114   GtkTreeIter iter_parent1, iter_parent2;
 115   GtkTreeModel *model;
 116   GtkTreeModelRefCount *ref_model;
 117   GtkTreeModel *sort_model;
 118   GtkTreePath *path;
 119   GtkWidget *tree_view;
 120
 121   model = gtk_tree_model_ref_count_new ();
 122   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 123
 124   /* + grandparent1
 125    * + grandparent2
 126    *   + parent1
 127    *     + iter_parent1
 128    *   + parent2
 129    *     + iter_parent2
 130    *     + iter_parent2
 131    */
 132
 133   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
 134   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
 135   gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
 136   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
 137   gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
 138   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 139   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 140
 141   assert_entire_model_unreferenced (ref_model);
 142
 143   sort_model = gtk_tree_model_sort_new_with_model (model);
 144   tree_view = gtk_tree_view_new_with_model (sort_model);
 145
 146   assert_root_level_referenced (ref_model, 1);
 147   assert_node_ref_count (ref_model, &parent1, 0);
 148   assert_node_ref_count (ref_model, &parent2, 0);
 149   assert_level_unreferenced (ref_model, &parent1);
 150   assert_level_unreferenced (ref_model, &parent2);
 151
 152   path = gtk_tree_path_new_from_indices (1, -1);
 153   gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
 154
 155   assert_node_ref_count (ref_model, &grandparent1, 1);
 156   assert_node_ref_count (ref_model, &grandparent2, 2);
 157   assert_node_ref_count (ref_model, &parent1, 1);
 158   assert_node_ref_count (ref_model, &parent2, 1);
 159   assert_node_ref_count (ref_model, &iter_parent1, 0);
 160   assert_node_ref_count (ref_model, &iter_parent2, 0);
 161
 162   gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
 163
 164   assert_node_ref_count (ref_model, &grandparent1, 1);
 165   assert_node_ref_count (ref_model, &grandparent2, 2);
 166   assert_node_ref_count (ref_model, &parent1, 2);
 167   assert_node_ref_count (ref_model, &parent2, 2);
 168   assert_node_ref_count (ref_model, &iter_parent1, 1);
 169   assert_node_ref_count (ref_model, &iter_parent2, 1);
 170
 171   gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view));
 172
 173   assert_node_ref_count (ref_model, &grandparent1, 1);
 174   assert_node_ref_count (ref_model, &grandparent2, 2);
 175   assert_node_ref_count (ref_model, &parent1, 1);
 176   assert_node_ref_count (ref_model, &parent2, 1);
 177   assert_node_ref_count (ref_model, &iter_parent1, 0);
 178   assert_node_ref_count (ref_model, &iter_parent2, 0);
 179
 180   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
 181
 182   assert_root_level_referenced (ref_model, 1);
 183   assert_node_ref_count (ref_model, &parent1, 0);
 184   assert_node_ref_count (ref_model, &parent2, 0);
 185
 186   gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
 187
 188   assert_node_ref_count (ref_model, &grandparent1, 1);
 189   assert_node_ref_count (ref_model, &grandparent2, 2);
 190   assert_node_ref_count (ref_model, &parent1, 1);
 191   assert_node_ref_count (ref_model, &parent2, 1);
 192   assert_node_ref_count (ref_model, &iter_parent1, 0);
 193   assert_node_ref_count (ref_model, &iter_parent2, 0);
 194
 195   gtk_tree_path_append_index (path, 1);
 196   gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, FALSE);
 197
 198   assert_node_ref_count (ref_model, &grandparent1, 1);
 199   assert_node_ref_count (ref_model, &grandparent2, 2);
 200   assert_node_ref_count (ref_model, &parent1, 1);
 201   assert_node_ref_count (ref_model, &parent2, 2);
 202   assert_node_ref_count (ref_model, &iter_parent1, 0);
 203   assert_node_ref_count (ref_model, &iter_parent2, 1);
 204
 205   gtk_tree_view_collapse_row (GTK_TREE_VIEW (tree_view), path);
 206
 207   assert_node_ref_count (ref_model, &grandparent1, 1);
 208   assert_node_ref_count (ref_model, &grandparent2, 2);
 209   assert_node_ref_count (ref_model, &parent1, 1);
 210   assert_node_ref_count (ref_model, &parent2, 2);
 211   assert_node_ref_count (ref_model, &iter_parent1, 0);
 212   assert_node_ref_count (ref_model, &iter_parent2, 0);
 213
 214   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
 215
 216   assert_node_ref_count (ref_model, &grandparent1, 1);
 217   assert_node_ref_count (ref_model, &grandparent2, 2);
 218   assert_node_ref_count (ref_model, &parent1, 1);
 219   assert_node_ref_count (ref_model, &parent2, 1);
 220   assert_node_ref_count (ref_model, &iter_parent1, 0);
 221   assert_node_ref_count (ref_model, &iter_parent2, 0);
 222
 223   gtk_tree_path_up (path);
 224   gtk_tree_view_collapse_row (GTK_TREE_VIEW (tree_view), path);
 225   gtk_tree_path_free (path);
 226
 227   assert_node_ref_count (ref_model, &grandparent1, 1);
 228   assert_node_ref_count (ref_model, &grandparent2, 2);
 229   assert_node_ref_count (ref_model, &parent1, 0);
 230   assert_node_ref_count (ref_model, &parent2, 0);
 231   assert_node_ref_count (ref_model, &iter_parent1, 0);
 232   assert_node_ref_count (ref_model, &iter_parent2, 0);
 233
 234   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
 235
 236   assert_node_ref_count (ref_model, &grandparent1, 1);
 237   assert_node_ref_count (ref_model, &grandparent2, 1);
 238   assert_node_ref_count (ref_model, &parent1, 0);
 239   assert_node_ref_count (ref_model, &parent2, 0);
 240   assert_node_ref_count (ref_model, &iter_parent1, 0);
 241   assert_node_ref_count (ref_model, &iter_parent2, 0);
 242
 243   gtk_widget_destroy (tree_view);
 244
 245   assert_entire_model_unreferenced (ref_model);
 246
 247   g_object_unref (sort_model);
 248   g_object_unref (ref_model);
 249 }
 250
 251 static void
 252 ref_count_delete_row (void)
 253 {
 254   GtkTreeIter grandparent1, grandparent2, parent1, parent2;
 255   GtkTreeIter iter_parent1, iter_parent2;
 256   GtkTreeModel *model;
 257   GtkTreeModelRefCount *ref_model;
 258   GtkTreeModel *sort_model;
 259   GtkTreePath *path;
 260   GtkWidget *tree_view;
 261
 262   model = gtk_tree_model_ref_count_new ();
 263   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 264
 265   /* + grandparent1
 266    * + grandparent2
 267    *   + parent1
 268    *     + iter_parent1
 269    *   + parent2
 270    *     + iter_parent2
 271    *     + iter_parent2
 272    */
 273
 274   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
 275   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
 276   gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
 277   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
 278   gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
 279   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 280   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 281
 282   assert_entire_model_unreferenced (ref_model);
 283
 284   sort_model = gtk_tree_model_sort_new_with_model (model);
 285   tree_view = gtk_tree_view_new_with_model (sort_model);
 286
 287   assert_root_level_referenced (ref_model, 1);
 288   assert_node_ref_count (ref_model, &parent1, 0);
 289   assert_node_ref_count (ref_model, &parent2, 0);
 290   assert_level_unreferenced (ref_model, &parent1);
 291   assert_level_unreferenced (ref_model, &parent2);
 292
 293   path = gtk_tree_path_new_from_indices (1, -1);
 294   gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE);
 295
 296   assert_node_ref_count (ref_model, &grandparent1, 1);
 297   assert_node_ref_count (ref_model, &grandparent2, 2);
 298   assert_node_ref_count (ref_model, &parent1, 2);
 299   assert_node_ref_count (ref_model, &parent2, 2);
 300   assert_node_ref_count (ref_model, &iter_parent1, 1);
 301   assert_node_ref_count (ref_model, &iter_parent2, 1);
 302
 303   gtk_tree_store_remove (GTK_TREE_STORE (model), &iter_parent2);
 304
 305   assert_node_ref_count (ref_model, &grandparent1, 1);
 306   assert_node_ref_count (ref_model, &grandparent2, 2);
 307   assert_node_ref_count (ref_model, &parent1, 2);
 308   assert_level_referenced (ref_model, 1, &parent1);
 309   assert_node_ref_count (ref_model, &parent2, 2);
 310   assert_level_referenced (ref_model, 1, &parent2);
 311
 312   gtk_tree_store_remove (GTK_TREE_STORE (model), &parent1);
 313
 314   assert_node_ref_count (ref_model, &grandparent1, 1);
 315   assert_node_ref_count (ref_model, &grandparent2, 2);
 316   assert_node_ref_count (ref_model, &parent2, 2);
 317   assert_level_referenced (ref_model, 1, &parent2);
 318
 319   gtk_tree_store_remove (GTK_TREE_STORE (model), &grandparent2);
 320
 321   assert_node_ref_count (ref_model, &grandparent1, 1);
 322
 323   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
 324
 325   assert_node_ref_count (ref_model, &grandparent1, 1);
 326
 327   gtk_widget_destroy (tree_view);
 328
 329   assert_entire_model_unreferenced (ref_model);
 330
 331   g_object_unref (sort_model);
 332   g_object_unref (ref_model);
 333 }
 334
 335 static void
 336 ref_count_cleanup (void)
 337 {
 338   GtkTreeIter grandparent1, grandparent2, parent1, parent2;
 339   GtkTreeIter iter_parent1, iter_parent2;
 340   GtkTreeModel *model;
 341   GtkTreeModelRefCount *ref_model;
 342   GtkTreeModel *sort_model;
 343   GtkWidget *tree_view;
 344
 345   model = gtk_tree_model_ref_count_new ();
 346   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 347
 348   /* + grandparent1
 349    * + grandparent2
 350    *   + parent1
 351    *     + iter_parent1
 352    *   + parent2
 353    *     + iter_parent2
 354    *     + iter_parent2
 355    */
 356
 357   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
 358   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
 359   gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
 360   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
 361   gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
 362   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 363   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 364
 365   sort_model = gtk_tree_model_sort_new_with_model (model);
 366   tree_view = gtk_tree_view_new_with_model (sort_model);
 367
 368   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
 369
 370   gtk_widget_destroy (tree_view);
 371
 372   assert_node_ref_count (ref_model, &grandparent1, 0);
 373   assert_node_ref_count (ref_model, &grandparent2, 1);
 374   assert_node_ref_count (ref_model, &parent1, 1);
 375   assert_node_ref_count (ref_model, &parent2, 1);
 376   assert_node_ref_count (ref_model, &iter_parent1, 0);
 377   assert_node_ref_count (ref_model, &iter_parent2, 0);
 378
 379   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
 380
 381   assert_entire_model_unreferenced (ref_model);
 382
 383   g_object_unref (sort_model);
 384   g_object_unref (ref_model);
 385 }
 386
 387 static void
 388 ref_count_row_ref (void)
 389 {
 390   GtkTreeIter grandparent1, grandparent2, parent1, parent2;
 391   GtkTreeIter iter_parent1, iter_parent2;
 392   GtkTreeModel *model;
 393   GtkTreeModelRefCount *ref_model;
 394   GtkTreeModel *sort_model;
 395   GtkWidget *tree_view;
 396   GtkTreePath *path;
 397   GtkTreeRowReference *row_ref;
 398
 399   model = gtk_tree_model_ref_count_new ();
 400   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 401
 402   /* + grandparent1
 403    * + grandparent2
 404    *   + parent1
 405    *     + iter_parent1
 406    *   + parent2
 407    *     + iter_parent2
 408    *     + iter_parent2
 409    */
 410
 411   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
 412   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
 413   gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
 414   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
 415   gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
 416   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 417   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 418
 419   sort_model = gtk_tree_model_sort_new_with_model (model);
 420   tree_view = gtk_tree_view_new_with_model (sort_model);
 421
 422   path = gtk_tree_path_new_from_indices (1, 1, 1, -1);
 423   row_ref = gtk_tree_row_reference_new (sort_model, path);
 424   gtk_tree_path_free (path);
 425
 426   assert_node_ref_count (ref_model, &grandparent1, 1);
 427   /* Referenced because the node is visible, its child level is built
 428    * and referenced by the row ref.
 429    */
 430   assert_node_ref_count (ref_model, &grandparent2, 3);
 431   assert_node_ref_count (ref_model, &parent1, 0);
 432   /* Referenced by the row ref and because its child level is built. */
 433   assert_node_ref_count (ref_model, &parent2, 2);
 434   assert_node_ref_count (ref_model, &iter_parent1, 0);
 435   assert_node_ref_count (ref_model, &iter_parent2, 1);
 436
 437   gtk_tree_row_reference_free (row_ref);
 438
 439   assert_node_ref_count (ref_model, &grandparent1, 1);
 440   assert_node_ref_count (ref_model, &grandparent2, 2);
 441   assert_node_ref_count (ref_model, &parent1, 0);
 442   assert_node_ref_count (ref_model, &parent2, 1);
 443   assert_node_ref_count (ref_model, &iter_parent1, 0);
 444   assert_node_ref_count (ref_model, &iter_parent2, 0);
 445
 446   path = gtk_tree_path_new_from_indices (1, 1, 1, -1);
 447   row_ref = gtk_tree_row_reference_new (sort_model, path);
 448   gtk_tree_path_free (path);
 449
 450   assert_node_ref_count (ref_model, &grandparent1, 1);
 451   /* Referenced because the node is visible, its child level is built
 452    * and referenced by the row ref.
 453    */
 454   assert_node_ref_count (ref_model, &grandparent2, 3);
 455   assert_node_ref_count (ref_model, &parent1, 0);
 456   /* Referenced by the row ref and because its child level is built. */
 457   assert_node_ref_count (ref_model, &parent2, 2);
 458   assert_node_ref_count (ref_model, &iter_parent1, 0);
 459   assert_node_ref_count (ref_model, &iter_parent2, 1);
 460
 461   gtk_tree_store_remove (GTK_TREE_STORE (model), &parent2);
 462
 463   assert_node_ref_count (ref_model, &grandparent1, 1);
 464   assert_node_ref_count (ref_model, &grandparent2, 1);
 465   assert_node_ref_count (ref_model, &parent1, 0);
 466   assert_node_ref_count (ref_model, &iter_parent1, 0);
 467
 468   gtk_tree_row_reference_free (row_ref);
 469
 470   assert_node_ref_count (ref_model, &grandparent1, 1);
 471   assert_node_ref_count (ref_model, &grandparent2, 1);
 472   assert_node_ref_count (ref_model, &parent1, 0);
 473   assert_node_ref_count (ref_model, &iter_parent1, 0);
 474
 475   gtk_widget_destroy (tree_view);
 476   g_object_unref (sort_model);
 477
 478   assert_entire_model_unreferenced (ref_model);
 479
 480   g_object_unref (ref_model);
 481 }
 482
 483 static void
 484 ref_count_reorder_single (void)
 485 {
 486   GtkTreeIter iter1, iter2, iter3, iter4, iter5;
 487   GtkTreeIter siter1, siter2, siter3, siter4, siter5;
 488   GtkTreeModel *model;
 489   GtkTreeModelRefCount *ref_model;
 490   GtkTreeModel *sort_model;
 491   GtkWidget *tree_view;
 492   GType column_types[] = { G_TYPE_INT };
 493
 494   model = gtk_tree_model_ref_count_new ();
 495   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 496
 497   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 498                                    column_types);
 499
 500   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 501                                      0, 30, -1);
 502   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 503                                      0, 40, -1);
 504   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 505                                      0, 10, -1);
 506   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 507                                      0, 20, -1);
 508   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 509                                      0, 60, -1);
 510
 511   assert_root_level_unreferenced (ref_model);
 512
 513   sort_model = gtk_tree_model_sort_new_with_model (model);
 514   tree_view = gtk_tree_view_new_with_model (sort_model);
 515
 516   assert_entire_model_referenced (ref_model, 1);
 517
 518   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
 519   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
 520   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
 521   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
 522   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
 523
 524   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
 525   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
 526
 527   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
 528   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
 529   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
 530
 531   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter5);
 532
 533   assert_node_ref_count (ref_model, &iter1, 3);
 534   assert_node_ref_count (ref_model, &iter2, 1);
 535   assert_node_ref_count (ref_model, &iter3, 4);
 536   assert_node_ref_count (ref_model, &iter4, 1);
 537   assert_node_ref_count (ref_model, &iter5, 2);
 538
 539   /* Sort */
 540   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 541                                         0, GTK_SORT_ASCENDING);
 542
 543   assert_node_ref_count (ref_model, &iter1, 3);
 544   assert_node_ref_count (ref_model, &iter2, 1);
 545   assert_node_ref_count (ref_model, &iter3, 4);
 546   assert_node_ref_count (ref_model, &iter4, 1);
 547   assert_node_ref_count (ref_model, &iter5, 2);
 548
 549   /* Re-translate the iters after sorting */
 550   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
 551   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
 552   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
 553   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
 554   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
 555
 556   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
 557   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
 558
 559   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
 560   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
 561   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
 562
 563   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter5);
 564
 565   assert_entire_model_referenced (ref_model, 1);
 566
 567   gtk_widget_destroy (tree_view);
 568   g_object_unref (sort_model);
 569
 570   assert_entire_model_unreferenced (ref_model);
 571
 572   g_object_unref (ref_model);
 573 }
 574
 575 static void
 576 ref_count_reorder_two (void)
 577 {
 578   GtkTreeIter iter1, iter2, iter3, iter4, iter5;
 579   GtkTreeIter citer1, citer2, citer3, citer4, citer5;
 580   GtkTreeIter siter1, siter2, siter3, siter4, siter5;
 581   GtkTreeIter sciter1, sciter2, sciter3, sciter4, sciter5;
 582   GtkTreeModel *model;
 583   GtkTreeModelRefCount *ref_model;
 584   GtkTreeModel *sort_model;
 585   GtkWidget *tree_view;
 586   GType column_types[] = { G_TYPE_INT };
 587
 588   model = gtk_tree_model_ref_count_new ();
 589   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 590
 591   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 592                                    column_types);
 593
 594   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 595                                      0, 30, -1);
 596   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 597                                      0, 40, -1);
 598   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 599                                      0, 10, -1);
 600   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 601                                      0, 20, -1);
 602   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 603                                      0, 60, -1);
 604
 605   /* Child level */
 606   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer1, &iter1, 0,
 607                                      0, 30, -1);
 608   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer2, &iter1, 1,
 609                                      0, 40, -1);
 610   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer3, &iter1, 2,
 611                                      0, 10, -1);
 612   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer4, &iter1, 3,
 613                                      0, 20, -1);
 614   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer5, &iter1, 4,
 615                                      0, 60, -1);
 616
 617   assert_root_level_unreferenced (ref_model);
 618
 619   sort_model = gtk_tree_model_sort_new_with_model (model);
 620   tree_view = gtk_tree_view_new_with_model (sort_model);
 621   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
 622
 623   assert_node_ref_count (ref_model, &iter1, 2);
 624   assert_node_ref_count (ref_model, &iter2, 1);
 625   assert_node_ref_count (ref_model, &iter3, 1);
 626   assert_node_ref_count (ref_model, &iter4, 1);
 627   assert_node_ref_count (ref_model, &iter5, 1);
 628
 629   assert_level_referenced (ref_model, 1, &iter1);
 630
 631   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
 632   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
 633   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
 634   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
 635   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
 636
 637   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter1, &citer1);
 638   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter2, &citer2);
 639   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter3, &citer3);
 640   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter4, &citer4);
 641   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter5, &citer5);
 642
 643   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
 644   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
 645
 646   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
 647   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
 648   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
 649
 650   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter5);
 651
 652   assert_node_ref_count (ref_model, &iter1, 4);
 653   assert_node_ref_count (ref_model, &iter2, 1);
 654   assert_node_ref_count (ref_model, &iter3, 4);
 655   assert_node_ref_count (ref_model, &iter4, 1);
 656   assert_node_ref_count (ref_model, &iter5, 2);
 657
 658   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter3);
 659   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter3);
 660
 661   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
 662   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
 663   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
 664
 665   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter1);
 666
 667   assert_node_ref_count (ref_model, &citer1, 2);
 668   assert_node_ref_count (ref_model, &citer2, 1);
 669   assert_node_ref_count (ref_model, &citer3, 3);
 670   assert_node_ref_count (ref_model, &citer4, 1);
 671   assert_node_ref_count (ref_model, &citer5, 4);
 672
 673   /* Sort */
 674   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 675                                         0, GTK_SORT_ASCENDING);
 676
 677   assert_node_ref_count (ref_model, &iter1, 4);
 678   assert_node_ref_count (ref_model, &iter2, 1);
 679   assert_node_ref_count (ref_model, &iter3, 4);
 680   assert_node_ref_count (ref_model, &iter4, 1);
 681   assert_node_ref_count (ref_model, &iter5, 2);
 682
 683   assert_node_ref_count (ref_model, &citer1, 2);
 684   assert_node_ref_count (ref_model, &citer2, 1);
 685   assert_node_ref_count (ref_model, &citer3, 3);
 686   assert_node_ref_count (ref_model, &citer4, 1);
 687   assert_node_ref_count (ref_model, &citer5, 4);
 688
 689   /* Re-translate the iters after sorting */
 690   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
 691   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
 692   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
 693   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
 694   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
 695
 696   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter1, &citer1);
 697   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter2, &citer2);
 698   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter3, &citer3);
 699   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter4, &citer4);
 700   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter5, &citer5);
 701
 702   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
 703   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
 704
 705   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
 706   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
 707   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
 708
 709   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter5);
 710
 711   assert_node_ref_count (ref_model, &iter1, 2);
 712   assert_node_ref_count (ref_model, &iter2, 1);
 713   assert_node_ref_count (ref_model, &iter3, 1);
 714   assert_node_ref_count (ref_model, &iter4, 1);
 715   assert_node_ref_count (ref_model, &iter5, 1);
 716
 717   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter3);
 718   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter3);
 719
 720   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
 721   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
 722   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
 723
 724   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter1);
 725
 726   assert_level_referenced (ref_model, 1, &iter1);
 727
 728   gtk_widget_destroy (tree_view);
 729   g_object_unref (sort_model);
 730
 731   assert_entire_model_unreferenced (ref_model);
 732
 733   g_object_unref (ref_model);
 734 }
 735
 736 static void
 737 check_sort_order (GtkTreeModel *sort_model,
 738                   GtkSortType   sort_order,
 739                   const char   *parent_path)
 740 {
 741   int prev_value;
 742   GtkTreeIter siter;
 743
 744   if (!parent_path)
 745     gtk_tree_model_get_iter_first (sort_model, &siter);
 746   else
 747     {
 748       GtkTreePath *path;
 749
 750       path = gtk_tree_path_new_from_string (parent_path);
 751       gtk_tree_path_append_index (path, 0);
 752
 753       gtk_tree_model_get_iter (sort_model, &siter, path);
 754
 755       gtk_tree_path_free (path);
 756     }
 757
 758   if (sort_order == GTK_SORT_ASCENDING)
 759     prev_value = -1;
 760   else
 761     prev_value = INT_MAX;
 762
 763   do
 764     {
 765       int value;
 766
 767       gtk_tree_model_get (sort_model, &siter, 0, &value, -1);
 768       if (sort_order == GTK_SORT_ASCENDING)
 769         g_assert (prev_value <= value);
 770       else
 771         g_assert (prev_value >= value);
 772
 773       prev_value = value;
 774     }
 775   while (gtk_tree_model_iter_next (sort_model, &siter));
 776 }
 777
 778 static void
 779 rows_reordered_single_level (void)
 780 {
 781   GtkTreeIter iter1, iter2, iter3, iter4, iter5;
 782   GtkTreeModel *model;
 783   GtkTreeModelRefCount *ref_model;
 784   GtkTreeModel *sort_model;
 785   GtkWidget *tree_view;
 786   SignalMonitor *monitor;
 787   GtkTreePath *path;
 788   GType column_types[] = { G_TYPE_INT };
 789   int order[][5] =
 790     {
 791         { 2, 3, 0, 1, 4 },
 792         { 4, 3, 2, 1, 0 },
 793         { 2, 1, 4, 3, 0 }
 794     };
 795
 796   model = gtk_tree_model_ref_count_new ();
 797   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 798
 799   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 800                                    column_types);
 801
 802   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 803                                      0, 30, -1);
 804   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 805                                      0, 40, -1);
 806   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 807                                      0, 10, -1);
 808   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 809                                      0, 20, -1);
 810   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 811                                      0, 60, -1);
 812
 813   sort_model = gtk_tree_model_sort_new_with_model (model);
 814   tree_view = gtk_tree_view_new_with_model (sort_model);
 815
 816   monitor = signal_monitor_new (sort_model);
 817
 818   /* Sort */
 819   path = gtk_tree_path_new ();
 820   signal_monitor_append_signal_reordered (monitor,
 821                                           ROWS_REORDERED,
 822                                           path, order[0], 5);
 823   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 824                                         0, GTK_SORT_ASCENDING);
 825   signal_monitor_assert_is_empty (monitor);
 826   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
 827
 828   signal_monitor_append_signal_reordered (monitor,
 829                                           ROWS_REORDERED,
 830                                           path, order[1], 5);
 831   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 832                                         0, GTK_SORT_DESCENDING);
 833   signal_monitor_assert_is_empty (monitor);
 834   check_sort_order (sort_model, GTK_SORT_DESCENDING, NULL);
 835
 836   signal_monitor_append_signal_reordered (monitor,
 837                                           ROWS_REORDERED,
 838                                           path, order[2], 5);
 839   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 840                                         GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 841                                         GTK_SORT_ASCENDING);
 842   signal_monitor_assert_is_empty (monitor);
 843
 844   gtk_tree_path_free (path);
 845   signal_monitor_free (monitor);
 846
 847   gtk_widget_destroy (tree_view);
 848   g_object_unref (sort_model);
 849
 850   assert_entire_model_unreferenced (ref_model);
 851
 852   g_object_unref (ref_model);
 853 }
 854
 855 static void
 856 rows_reordered_two_levels (void)
 857 {
 858   GtkTreeIter iter1, iter2, iter3, iter4, iter5;
 859   GtkTreeIter citer1, citer2, citer3, citer4, citer5;
 860   GtkTreeModel *model;
 861   GtkTreeModelRefCount *ref_model;
 862   GtkTreeModel *sort_model;
 863   GtkWidget *tree_view;
 864   SignalMonitor *monitor;
 865   GtkTreePath *path, *child_path;
 866   GType column_types[] = { G_TYPE_INT };
 867   int order[][5] =
 868     {
 869         { 2, 3, 0, 1, 4 },
 870         { 4, 3, 2, 1, 0 },
 871         { 2, 1, 4, 3, 0 }
 872     };
 873
 874   model = gtk_tree_model_ref_count_new ();
 875   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 876
 877   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 878                                    column_types);
 879
 880   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 881                                      0, 30, -1);
 882   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 883                                      0, 40, -1);
 884   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 885                                      0, 10, -1);
 886   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 887                                      0, 20, -1);
 888   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 889                                      0, 60, -1);
 890
 891   /* Child level */
 892   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer1, &iter1, 0,
 893                                      0, 30, -1);
 894   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer2, &iter1, 1,
 895                                      0, 40, -1);
 896   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer3, &iter1, 2,
 897                                      0, 10, -1);
 898   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer4, &iter1, 3,
 899                                      0, 20, -1);
 900   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer5, &iter1, 4,
 901                                      0, 60, -1);
 902
 903   sort_model = gtk_tree_model_sort_new_with_model (model);
 904   tree_view = gtk_tree_view_new_with_model (sort_model);
 905   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
 906
 907   monitor = signal_monitor_new (sort_model);
 908
 909   /* Sort */
 910   path = gtk_tree_path_new ();
 911   child_path = gtk_tree_path_new_from_indices (2, -1);
 912   signal_monitor_append_signal_reordered (monitor,
 913                                           ROWS_REORDERED,
 914                                           path, order[0], 5);
 915   signal_monitor_append_signal_reordered (monitor,
 916                                           ROWS_REORDERED,
 917                                           child_path, order[0], 5);
 918   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 919                                         0, GTK_SORT_ASCENDING);
 920   signal_monitor_assert_is_empty (monitor);
 921   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
 922   /* The parent node of the child level moved due to sorting */
 923   check_sort_order (sort_model, GTK_SORT_ASCENDING, "2");
 924
 925   signal_monitor_append_signal_reordered (monitor,
 926                                           ROWS_REORDERED,
 927                                           path, order[1], 5);
 928   signal_monitor_append_signal_reordered (monitor,
 929                                           ROWS_REORDERED,
 930                                           child_path, order[1], 5);
 931   gtk_tree_path_free (child_path);
 932   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 933                                         0, GTK_SORT_DESCENDING);
 934   signal_monitor_assert_is_empty (monitor);
 935   check_sort_order (sort_model, GTK_SORT_DESCENDING, NULL);
 936   /* The parent node of the child level moved due to sorting */
 937   check_sort_order (sort_model, GTK_SORT_DESCENDING, "2");
 938
 939   child_path = gtk_tree_path_new_from_indices (0, -1);
 940   signal_monitor_append_signal_reordered (monitor,
 941                                           ROWS_REORDERED,
 942                                           path, order[2], 5);
 943   signal_monitor_append_signal_reordered (monitor,
 944                                           ROWS_REORDERED,
 945                                           child_path, order[2], 5);
 946   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 947                                         GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 948                                         GTK_SORT_ASCENDING);
 949   signal_monitor_assert_is_empty (monitor);
 950
 951   gtk_tree_path_free (path);
 952   gtk_tree_path_free (child_path);
 953   signal_monitor_free (monitor);
 954
 955   gtk_widget_destroy (tree_view);
 956   g_object_unref (sort_model);
 957
 958   g_object_unref (ref_model);
 959 }
 960
 961 static void
 962 sorted_insert (void)
 963 {
 964   GtkTreeIter iter1, iter2, iter3, iter4, iter5, new_iter;
 965   GtkTreeModel *model;
 966   GtkTreeModelRefCount *ref_model;
 967   GtkTreeModel *sort_model;
 968   GtkWidget *tree_view;
 969   SignalMonitor *monitor;
 970   GtkTreePath *path;
 971   GType column_types[] = { G_TYPE_INT };
 972   int order0[] = { 1, 2, 3, 0, 4, 5, 6 };
 973
 974   model = gtk_tree_model_ref_count_new ();
 975   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 976
 977   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 978                                    column_types);
 979
 980   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 981                                      0, 30, -1);
 982   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 983                                      0, 40, -1);
 984   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 985                                      0, 10, -1);
 986   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 987                                      0, 20, -1);
 988   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 989                                      0, 60, -1);
 990
 991   sort_model = gtk_tree_model_sort_new_with_model (model);
 992   tree_view = gtk_tree_view_new_with_model (sort_model);
 993
 994   /* Sort */
 995   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 996                                         0, GTK_SORT_ASCENDING);
 997   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
 998
 999   monitor = signal_monitor_new (sort_model);
1000
1001   /* Insert a new item */
1002   signal_monitor_append_signal (monitor, ROW_INSERTED, "4");
1003   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &new_iter, NULL,
1004                                      5, 0, 50, -1);
1005   signal_monitor_assert_is_empty (monitor);
1006   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
1007
1008   /* Sort the tree sort and append a new item */
1009   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
1010                                         0, GTK_SORT_ASCENDING);
1011   check_sort_order (model, GTK_SORT_ASCENDING, NULL);
1012
1013   path = gtk_tree_path_new ();
1014   signal_monitor_append_signal (monitor, ROW_INSERTED, "0");
1015   signal_monitor_append_signal_reordered (monitor,
1016                                           ROWS_REORDERED,
1017                                           path, order0, 7);
1018   signal_monitor_append_signal (monitor, ROW_CHANGED, "3");
1019   gtk_tree_store_append (GTK_TREE_STORE (model), &new_iter, NULL);
1020   gtk_tree_store_set (GTK_TREE_STORE (model), &new_iter, 0, 35, -1);
1021   check_sort_order (model, GTK_SORT_ASCENDING, NULL);
1022   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
1023
1024   gtk_tree_path_free (path);
1025   signal_monitor_free (monitor);
1026
1027   gtk_widget_destroy (tree_view);
1028   g_object_unref (sort_model);
1029
1030   g_object_unref (ref_model);
1031 }
1032
1033
1034 static void
1035 specific_bug_300089 (void)
1036 {
1037   /* Test case for GNOME Bugzilla bug 300089.  Written by
1038    * Matthias Clasen.
1039    */
1040   GtkTreeModel *sort_model, *child_model;
1041   GtkTreePath *path;
1042   GtkTreeIter iter, iter2, sort_iter;
1043
1044   g_test_bug ("300089");
1045
1046   child_model = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_STRING));
1047
1048   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
1049   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1);
1050   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
1051   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "B", -1);
1052
1053   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter);
1054   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "D", -1);
1055   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter);
1056   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "E", -1);
1057
1058   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
1059   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "C", -1);
1060
1061
1062   sort_model = GTK_TREE_MODEL (gtk_tree_model_sort_new_with_model (child_model));
1063   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
1064                                         0, GTK_SORT_ASCENDING);
1065
1066   path = gtk_tree_path_new_from_indices (1, 1, -1);
1067
1068   /* make sure a level is constructed */
1069   gtk_tree_model_get_iter (sort_model, &sort_iter, path);
1070
1071   /* change the "E" row in a way that causes it to change position */
1072   gtk_tree_model_get_iter (child_model, &iter, path);
1073   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1);
1074 }
1075
1076 static void
1077 specific_bug_364946 (void)
1078 {
1079   /* This is a test case for GNOME Bugzilla bug 364946.  It was written
1080    * by Andreas Koehler.
1081    */
1082   GtkTreeStore *store;
1083   GtkTreeIter a, aa, aaa, aab, iter;
1084   GtkTreeModel *s_model;
1085
1086   g_test_bug ("364946");
1087
1088   store = gtk_tree_store_new (1, G_TYPE_STRING);
1089
1090   gtk_tree_store_append (store, &a, NULL);
1091   gtk_tree_store_set (store, &a, 0, "0", -1);
1092
1093   gtk_tree_store_append (store, &aa, &a);
1094   gtk_tree_store_set (store, &aa, 0, "0:0", -1);
1095
1096   gtk_tree_store_append (store, &aaa, &aa);
1097   gtk_tree_store_set (store, &aaa, 0, "0:0:0", -1);
1098
1099   gtk_tree_store_append (store, &aab, &aa);
1100   gtk_tree_store_set (store, &aab, 0, "0:0:1", -1);
1101
1102   s_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
1103   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (s_model), 0,
1104                                         GTK_SORT_ASCENDING);
1105
1106   gtk_tree_model_get_iter_from_string (s_model, &iter, "0:0:0");
1107
1108   gtk_tree_store_set (store, &aaa, 0, "0:0:0", -1);
1109   gtk_tree_store_remove (store, &aaa);
1110   gtk_tree_store_remove (store, &aab);
1111
1112   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (s_model));
1113 }
1114
1115 /* main */
1116
1117 void
1118 register_sort_model_tests (void)
1119 {
1120   g_test_add_func ("/TreeModelSort/ref-count/single-level",
1121                    ref_count_single_level);
1122   g_test_add_func ("/TreeModelSort/ref-count/two-levels",
1123                    ref_count_two_levels);
1124   g_test_add_func ("/TreeModelSort/ref-count/three-levels",
1125                    ref_count_three_levels);
1126   g_test_add_func ("/TreeModelSort/ref-count/delete-row",
1127                    ref_count_delete_row);
1128   g_test_add_func ("/TreeModelSort/ref-count/cleanup",
1129                    ref_count_cleanup);
1130   g_test_add_func ("/TreeModelSort/ref-count/row-ref",
1131                    ref_count_row_ref);
1132   g_test_add_func ("/TreeModelSort/ref-count/reorder/single-level",
1133                    ref_count_reorder_single);
1134   g_test_add_func ("/TreeModelSort/ref-count/reorder/two-levels",
1135                    ref_count_reorder_two);
1136
1137   g_test_add_func ("/TreeModelSort/rows-reordered/single-level",
1138                    rows_reordered_single_level);
1139   g_test_add_func ("/TreeModelSort/rows-reordered/two-levels",
1140                    rows_reordered_two_levels);
1141   g_test_add_func ("/TreeModelSort/sorted-insert",
1142                    sorted_insert);
1143
1144   g_test_add_func ("/TreeModelSort/specific/bug-300089",
1145                    specific_bug_300089);
1146   g_test_add_func ("/TreeModelSort/specific/bug-364946",
1147                    specific_bug_364946);
1148 }