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   gtk_tree_path_free (path);
 296
 297   assert_node_ref_count (ref_model, &grandparent1, 1);
 298   assert_node_ref_count (ref_model, &grandparent2, 2);
 299   assert_node_ref_count (ref_model, &parent1, 2);
 300   assert_node_ref_count (ref_model, &parent2, 2);
 301   assert_node_ref_count (ref_model, &iter_parent1, 1);
 302   assert_node_ref_count (ref_model, &iter_parent2, 1);
 303
 304   gtk_tree_store_remove (GTK_TREE_STORE (model), &iter_parent2);
 305
 306   assert_node_ref_count (ref_model, &grandparent1, 1);
 307   assert_node_ref_count (ref_model, &grandparent2, 2);
 308   assert_node_ref_count (ref_model, &parent1, 2);
 309   assert_level_referenced (ref_model, 1, &parent1);
 310   assert_node_ref_count (ref_model, &parent2, 2);
 311   assert_level_referenced (ref_model, 1, &parent2);
 312
 313   gtk_tree_store_remove (GTK_TREE_STORE (model), &parent1);
 314
 315   assert_node_ref_count (ref_model, &grandparent1, 1);
 316   assert_node_ref_count (ref_model, &grandparent2, 2);
 317   assert_node_ref_count (ref_model, &parent2, 2);
 318   assert_level_referenced (ref_model, 1, &parent2);
 319
 320   gtk_tree_store_remove (GTK_TREE_STORE (model), &grandparent2);
 321
 322   assert_node_ref_count (ref_model, &grandparent1, 1);
 323
 324   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
 325
 326   assert_node_ref_count (ref_model, &grandparent1, 1);
 327
 328   gtk_widget_destroy (tree_view);
 329
 330   assert_entire_model_unreferenced (ref_model);
 331
 332   g_object_unref (sort_model);
 333   g_object_unref (ref_model);
 334 }
 335
 336 static void
 337 ref_count_cleanup (void)
 338 {
 339   GtkTreeIter grandparent1, grandparent2, parent1, parent2;
 340   GtkTreeIter iter_parent1, iter_parent2;
 341   GtkTreeModel *model;
 342   GtkTreeModelRefCount *ref_model;
 343   GtkTreeModel *sort_model;
 344   GtkWidget *tree_view;
 345
 346   model = gtk_tree_model_ref_count_new ();
 347   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 348
 349   /* + grandparent1
 350    * + grandparent2
 351    *   + parent1
 352    *     + iter_parent1
 353    *   + parent2
 354    *     + iter_parent2
 355    *     + iter_parent2
 356    */
 357
 358   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
 359   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
 360   gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
 361   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
 362   gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
 363   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 364   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 365
 366   sort_model = gtk_tree_model_sort_new_with_model (model);
 367   tree_view = gtk_tree_view_new_with_model (sort_model);
 368
 369   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
 370
 371   gtk_widget_destroy (tree_view);
 372
 373   assert_node_ref_count (ref_model, &grandparent1, 0);
 374   assert_node_ref_count (ref_model, &grandparent2, 1);
 375   assert_node_ref_count (ref_model, &parent1, 1);
 376   assert_node_ref_count (ref_model, &parent2, 1);
 377   assert_node_ref_count (ref_model, &iter_parent1, 0);
 378   assert_node_ref_count (ref_model, &iter_parent2, 0);
 379
 380   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model));
 381
 382   assert_entire_model_unreferenced (ref_model);
 383
 384   g_object_unref (sort_model);
 385   g_object_unref (ref_model);
 386 }
 387
 388 static void
 389 ref_count_row_ref (void)
 390 {
 391   GtkTreeIter grandparent1, grandparent2, parent1, parent2;
 392   GtkTreeIter iter_parent1, iter_parent2;
 393   GtkTreeModel *model;
 394   GtkTreeModelRefCount *ref_model;
 395   GtkTreeModel *sort_model;
 396   GtkWidget *tree_view;
 397   GtkTreePath *path;
 398   GtkTreeRowReference *row_ref;
 399
 400   model = gtk_tree_model_ref_count_new ();
 401   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 402
 403   /* + grandparent1
 404    * + grandparent2
 405    *   + parent1
 406    *     + iter_parent1
 407    *   + parent2
 408    *     + iter_parent2
 409    *     + iter_parent2
 410    */
 411
 412   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL);
 413   gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL);
 414   gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2);
 415   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1);
 416   gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2);
 417   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 418   gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2);
 419
 420   sort_model = gtk_tree_model_sort_new_with_model (model);
 421   tree_view = gtk_tree_view_new_with_model (sort_model);
 422
 423   path = gtk_tree_path_new_from_indices (1, 1, 1, -1);
 424   row_ref = gtk_tree_row_reference_new (sort_model, path);
 425   gtk_tree_path_free (path);
 426
 427   assert_node_ref_count (ref_model, &grandparent1, 1);
 428   /* Referenced because the node is visible, its child level is built
 429    * and referenced by the row ref.
 430    */
 431   assert_node_ref_count (ref_model, &grandparent2, 3);
 432   assert_node_ref_count (ref_model, &parent1, 0);
 433   /* Referenced by the row ref and because its child level is built. */
 434   assert_node_ref_count (ref_model, &parent2, 2);
 435   assert_node_ref_count (ref_model, &iter_parent1, 0);
 436   assert_node_ref_count (ref_model, &iter_parent2, 1);
 437
 438   gtk_tree_row_reference_free (row_ref);
 439
 440   assert_node_ref_count (ref_model, &grandparent1, 1);
 441   assert_node_ref_count (ref_model, &grandparent2, 2);
 442   assert_node_ref_count (ref_model, &parent1, 0);
 443   assert_node_ref_count (ref_model, &parent2, 1);
 444   assert_node_ref_count (ref_model, &iter_parent1, 0);
 445   assert_node_ref_count (ref_model, &iter_parent2, 0);
 446
 447   path = gtk_tree_path_new_from_indices (1, 1, 1, -1);
 448   row_ref = gtk_tree_row_reference_new (sort_model, path);
 449   gtk_tree_path_free (path);
 450
 451   assert_node_ref_count (ref_model, &grandparent1, 1);
 452   /* Referenced because the node is visible, its child level is built
 453    * and referenced by the row ref.
 454    */
 455   assert_node_ref_count (ref_model, &grandparent2, 3);
 456   assert_node_ref_count (ref_model, &parent1, 0);
 457   /* Referenced by the row ref and because its child level is built. */
 458   assert_node_ref_count (ref_model, &parent2, 2);
 459   assert_node_ref_count (ref_model, &iter_parent1, 0);
 460   assert_node_ref_count (ref_model, &iter_parent2, 1);
 461
 462   gtk_tree_store_remove (GTK_TREE_STORE (model), &parent2);
 463
 464   assert_node_ref_count (ref_model, &grandparent1, 1);
 465   assert_node_ref_count (ref_model, &grandparent2, 1);
 466   assert_node_ref_count (ref_model, &parent1, 0);
 467   assert_node_ref_count (ref_model, &iter_parent1, 0);
 468
 469   gtk_tree_row_reference_free (row_ref);
 470
 471   assert_node_ref_count (ref_model, &grandparent1, 1);
 472   assert_node_ref_count (ref_model, &grandparent2, 1);
 473   assert_node_ref_count (ref_model, &parent1, 0);
 474   assert_node_ref_count (ref_model, &iter_parent1, 0);
 475
 476   gtk_widget_destroy (tree_view);
 477   g_object_unref (sort_model);
 478
 479   assert_entire_model_unreferenced (ref_model);
 480
 481   g_object_unref (ref_model);
 482 }
 483
 484 static void
 485 ref_count_reorder_single (void)
 486 {
 487   GtkTreeIter iter1, iter2, iter3, iter4, iter5;
 488   GtkTreeIter siter1, siter2, siter3, siter4, siter5;
 489   GtkTreeModel *model;
 490   GtkTreeModelRefCount *ref_model;
 491   GtkTreeModel *sort_model;
 492   GtkWidget *tree_view;
 493   GType column_types[] = { G_TYPE_INT };
 494
 495   model = gtk_tree_model_ref_count_new ();
 496   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 497
 498   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 499                                    column_types);
 500
 501   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 502                                      0, 30, -1);
 503   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 504                                      0, 40, -1);
 505   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 506                                      0, 10, -1);
 507   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 508                                      0, 20, -1);
 509   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 510                                      0, 60, -1);
 511
 512   assert_root_level_unreferenced (ref_model);
 513
 514   sort_model = gtk_tree_model_sort_new_with_model (model);
 515   tree_view = gtk_tree_view_new_with_model (sort_model);
 516
 517   assert_entire_model_referenced (ref_model, 1);
 518
 519   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
 520   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
 521   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
 522   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
 523   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
 524
 525   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
 526   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
 527
 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   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
 531
 532   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter5);
 533
 534   assert_node_ref_count (ref_model, &iter1, 3);
 535   assert_node_ref_count (ref_model, &iter2, 1);
 536   assert_node_ref_count (ref_model, &iter3, 4);
 537   assert_node_ref_count (ref_model, &iter4, 1);
 538   assert_node_ref_count (ref_model, &iter5, 2);
 539
 540   /* Sort */
 541   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 542                                         0, GTK_SORT_ASCENDING);
 543
 544   assert_node_ref_count (ref_model, &iter1, 3);
 545   assert_node_ref_count (ref_model, &iter2, 1);
 546   assert_node_ref_count (ref_model, &iter3, 4);
 547   assert_node_ref_count (ref_model, &iter4, 1);
 548   assert_node_ref_count (ref_model, &iter5, 2);
 549
 550   /* Re-translate the iters after sorting */
 551   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
 552   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
 553   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
 554   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
 555   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
 556
 557   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
 558   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
 559
 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   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
 563
 564   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter5);
 565
 566   assert_entire_model_referenced (ref_model, 1);
 567
 568   gtk_widget_destroy (tree_view);
 569   g_object_unref (sort_model);
 570
 571   assert_entire_model_unreferenced (ref_model);
 572
 573   g_object_unref (ref_model);
 574 }
 575
 576 static void
 577 ref_count_reorder_two (void)
 578 {
 579   GtkTreeIter iter1, iter2, iter3, iter4, iter5;
 580   GtkTreeIter citer1, citer2, citer3, citer4, citer5;
 581   GtkTreeIter siter1, siter2, siter3, siter4, siter5;
 582   GtkTreeIter sciter1, sciter2, sciter3, sciter4, sciter5;
 583   GtkTreeModel *model;
 584   GtkTreeModelRefCount *ref_model;
 585   GtkTreeModel *sort_model;
 586   GtkWidget *tree_view;
 587   GType column_types[] = { G_TYPE_INT };
 588
 589   model = gtk_tree_model_ref_count_new ();
 590   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 591
 592   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 593                                    column_types);
 594
 595   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 596                                      0, 30, -1);
 597   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 598                                      0, 40, -1);
 599   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 600                                      0, 10, -1);
 601   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 602                                      0, 20, -1);
 603   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 604                                      0, 60, -1);
 605
 606   /* Child level */
 607   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer1, &iter1, 0,
 608                                      0, 30, -1);
 609   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer2, &iter1, 1,
 610                                      0, 40, -1);
 611   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer3, &iter1, 2,
 612                                      0, 10, -1);
 613   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer4, &iter1, 3,
 614                                      0, 20, -1);
 615   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer5, &iter1, 4,
 616                                      0, 60, -1);
 617
 618   assert_root_level_unreferenced (ref_model);
 619
 620   sort_model = gtk_tree_model_sort_new_with_model (model);
 621   tree_view = gtk_tree_view_new_with_model (sort_model);
 622   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
 623
 624   assert_node_ref_count (ref_model, &iter1, 2);
 625   assert_node_ref_count (ref_model, &iter2, 1);
 626   assert_node_ref_count (ref_model, &iter3, 1);
 627   assert_node_ref_count (ref_model, &iter4, 1);
 628   assert_node_ref_count (ref_model, &iter5, 1);
 629
 630   assert_level_referenced (ref_model, 1, &iter1);
 631
 632   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
 633   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
 634   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
 635   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
 636   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
 637
 638   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter1, &citer1);
 639   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter2, &citer2);
 640   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter3, &citer3);
 641   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter4, &citer4);
 642   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter5, &citer5);
 643
 644   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
 645   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
 646
 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   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
 650
 651   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter5);
 652
 653   assert_node_ref_count (ref_model, &iter1, 4);
 654   assert_node_ref_count (ref_model, &iter2, 1);
 655   assert_node_ref_count (ref_model, &iter3, 4);
 656   assert_node_ref_count (ref_model, &iter4, 1);
 657   assert_node_ref_count (ref_model, &iter5, 2);
 658
 659   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter3);
 660   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter3);
 661
 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   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
 665
 666   gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter1);
 667
 668   assert_node_ref_count (ref_model, &citer1, 2);
 669   assert_node_ref_count (ref_model, &citer2, 1);
 670   assert_node_ref_count (ref_model, &citer3, 3);
 671   assert_node_ref_count (ref_model, &citer4, 1);
 672   assert_node_ref_count (ref_model, &citer5, 4);
 673
 674   /* Sort */
 675   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 676                                         0, GTK_SORT_ASCENDING);
 677
 678   assert_node_ref_count (ref_model, &iter1, 4);
 679   assert_node_ref_count (ref_model, &iter2, 1);
 680   assert_node_ref_count (ref_model, &iter3, 4);
 681   assert_node_ref_count (ref_model, &iter4, 1);
 682   assert_node_ref_count (ref_model, &iter5, 2);
 683
 684   assert_node_ref_count (ref_model, &citer1, 2);
 685   assert_node_ref_count (ref_model, &citer2, 1);
 686   assert_node_ref_count (ref_model, &citer3, 3);
 687   assert_node_ref_count (ref_model, &citer4, 1);
 688   assert_node_ref_count (ref_model, &citer5, 4);
 689
 690   /* Re-translate the iters after sorting */
 691   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
 692   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
 693   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
 694   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
 695   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
 696
 697   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter1, &citer1);
 698   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter2, &citer2);
 699   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter3, &citer3);
 700   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter4, &citer4);
 701   gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter5, &citer5);
 702
 703   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
 704   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
 705
 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   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
 709
 710   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter5);
 711
 712   assert_node_ref_count (ref_model, &iter1, 2);
 713   assert_node_ref_count (ref_model, &iter2, 1);
 714   assert_node_ref_count (ref_model, &iter3, 1);
 715   assert_node_ref_count (ref_model, &iter4, 1);
 716   assert_node_ref_count (ref_model, &iter5, 1);
 717
 718   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter3);
 719   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter3);
 720
 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   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
 724
 725   gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter1);
 726
 727   assert_level_referenced (ref_model, 1, &iter1);
 728
 729   gtk_widget_destroy (tree_view);
 730   g_object_unref (sort_model);
 731
 732   assert_entire_model_unreferenced (ref_model);
 733
 734   g_object_unref (ref_model);
 735 }
 736
 737 static void
 738 check_sort_order (GtkTreeModel *sort_model,
 739                   GtkSortType   sort_order,
 740                   const char   *parent_path)
 741 {
 742   int prev_value;
 743   GtkTreeIter siter;
 744
 745   if (!parent_path)
 746     gtk_tree_model_get_iter_first (sort_model, &siter);
 747   else
 748     {
 749       GtkTreePath *path;
 750
 751       path = gtk_tree_path_new_from_string (parent_path);
 752       gtk_tree_path_append_index (path, 0);
 753
 754       gtk_tree_model_get_iter (sort_model, &siter, path);
 755
 756       gtk_tree_path_free (path);
 757     }
 758
 759   if (sort_order == GTK_SORT_ASCENDING)
 760     prev_value = -1;
 761   else
 762     prev_value = INT_MAX;
 763
 764   do
 765     {
 766       int value;
 767
 768       gtk_tree_model_get (sort_model, &siter, 0, &value, -1);
 769       if (sort_order == GTK_SORT_ASCENDING)
 770         g_assert (prev_value <= value);
 771       else
 772         g_assert (prev_value >= value);
 773
 774       prev_value = value;
 775     }
 776   while (gtk_tree_model_iter_next (sort_model, &siter));
 777 }
 778
 779 static void
 780 rows_reordered_single_level (void)
 781 {
 782   GtkTreeIter iter1, iter2, iter3, iter4, iter5;
 783   GtkTreeModel *model;
 784   GtkTreeModelRefCount *ref_model;
 785   GtkTreeModel *sort_model;
 786   GtkWidget *tree_view;
 787   SignalMonitor *monitor;
 788   GtkTreePath *path;
 789   GType column_types[] = { G_TYPE_INT };
 790   int order[][5] =
 791     {
 792         { 2, 3, 0, 1, 4 },
 793         { 4, 3, 2, 1, 0 },
 794         { 2, 1, 4, 3, 0 }
 795     };
 796
 797   model = gtk_tree_model_ref_count_new ();
 798   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 799
 800   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 801                                    column_types);
 802
 803   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 804                                      0, 30, -1);
 805   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 806                                      0, 40, -1);
 807   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 808                                      0, 10, -1);
 809   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 810                                      0, 20, -1);
 811   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 812                                      0, 60, -1);
 813
 814   sort_model = gtk_tree_model_sort_new_with_model (model);
 815   tree_view = gtk_tree_view_new_with_model (sort_model);
 816
 817   monitor = signal_monitor_new (sort_model);
 818
 819   /* Sort */
 820   path = gtk_tree_path_new ();
 821   signal_monitor_append_signal_reordered (monitor,
 822                                           ROWS_REORDERED,
 823                                           path, order[0], 5);
 824   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 825                                         0, GTK_SORT_ASCENDING);
 826   signal_monitor_assert_is_empty (monitor);
 827   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
 828
 829   signal_monitor_append_signal_reordered (monitor,
 830                                           ROWS_REORDERED,
 831                                           path, order[1], 5);
 832   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 833                                         0, GTK_SORT_DESCENDING);
 834   signal_monitor_assert_is_empty (monitor);
 835   check_sort_order (sort_model, GTK_SORT_DESCENDING, NULL);
 836
 837   signal_monitor_append_signal_reordered (monitor,
 838                                           ROWS_REORDERED,
 839                                           path, order[2], 5);
 840   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 841                                         GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 842                                         GTK_SORT_ASCENDING);
 843   signal_monitor_assert_is_empty (monitor);
 844
 845   gtk_tree_path_free (path);
 846   signal_monitor_free (monitor);
 847
 848   gtk_widget_destroy (tree_view);
 849   g_object_unref (sort_model);
 850
 851   assert_entire_model_unreferenced (ref_model);
 852
 853   g_object_unref (ref_model);
 854 }
 855
 856 static void
 857 rows_reordered_two_levels (void)
 858 {
 859   GtkTreeIter iter1, iter2, iter3, iter4, iter5;
 860   GtkTreeIter citer1, citer2, citer3, citer4, citer5;
 861   GtkTreeModel *model;
 862   GtkTreeModelRefCount *ref_model;
 863   GtkTreeModel *sort_model;
 864   GtkWidget *tree_view;
 865   SignalMonitor *monitor;
 866   GtkTreePath *path, *child_path;
 867   GType column_types[] = { G_TYPE_INT };
 868   int order[][5] =
 869     {
 870         { 2, 3, 0, 1, 4 },
 871         { 4, 3, 2, 1, 0 },
 872         { 2, 1, 4, 3, 0 }
 873     };
 874
 875   model = gtk_tree_model_ref_count_new ();
 876   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 877
 878   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 879                                    column_types);
 880
 881   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 882                                      0, 30, -1);
 883   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 884                                      0, 40, -1);
 885   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 886                                      0, 10, -1);
 887   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 888                                      0, 20, -1);
 889   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 890                                      0, 60, -1);
 891
 892   /* Child level */
 893   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer1, &iter1, 0,
 894                                      0, 30, -1);
 895   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer2, &iter1, 1,
 896                                      0, 40, -1);
 897   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer3, &iter1, 2,
 898                                      0, 10, -1);
 899   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer4, &iter1, 3,
 900                                      0, 20, -1);
 901   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer5, &iter1, 4,
 902                                      0, 60, -1);
 903
 904   sort_model = gtk_tree_model_sort_new_with_model (model);
 905   tree_view = gtk_tree_view_new_with_model (sort_model);
 906   gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
 907
 908   monitor = signal_monitor_new (sort_model);
 909
 910   /* Sort */
 911   path = gtk_tree_path_new ();
 912   child_path = gtk_tree_path_new_from_indices (2, -1);
 913   signal_monitor_append_signal_reordered (monitor,
 914                                           ROWS_REORDERED,
 915                                           path, order[0], 5);
 916   signal_monitor_append_signal_reordered (monitor,
 917                                           ROWS_REORDERED,
 918                                           child_path, order[0], 5);
 919   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 920                                         0, GTK_SORT_ASCENDING);
 921   signal_monitor_assert_is_empty (monitor);
 922   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
 923   /* The parent node of the child level moved due to sorting */
 924   check_sort_order (sort_model, GTK_SORT_ASCENDING, "2");
 925
 926   signal_monitor_append_signal_reordered (monitor,
 927                                           ROWS_REORDERED,
 928                                           path, order[1], 5);
 929   signal_monitor_append_signal_reordered (monitor,
 930                                           ROWS_REORDERED,
 931                                           child_path, order[1], 5);
 932   gtk_tree_path_free (child_path);
 933   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 934                                         0, GTK_SORT_DESCENDING);
 935   signal_monitor_assert_is_empty (monitor);
 936   check_sort_order (sort_model, GTK_SORT_DESCENDING, NULL);
 937   /* The parent node of the child level moved due to sorting */
 938   check_sort_order (sort_model, GTK_SORT_DESCENDING, "2");
 939
 940   child_path = gtk_tree_path_new_from_indices (0, -1);
 941   signal_monitor_append_signal_reordered (monitor,
 942                                           ROWS_REORDERED,
 943                                           path, order[2], 5);
 944   signal_monitor_append_signal_reordered (monitor,
 945                                           ROWS_REORDERED,
 946                                           child_path, order[2], 5);
 947   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 948                                         GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
 949                                         GTK_SORT_ASCENDING);
 950   signal_monitor_assert_is_empty (monitor);
 951
 952   gtk_tree_path_free (path);
 953   gtk_tree_path_free (child_path);
 954   signal_monitor_free (monitor);
 955
 956   gtk_widget_destroy (tree_view);
 957   g_object_unref (sort_model);
 958
 959   g_object_unref (ref_model);
 960 }
 961
 962 static void
 963 sorted_insert (void)
 964 {
 965   GtkTreeIter iter1, iter2, iter3, iter4, iter5, new_iter;
 966   GtkTreeModel *model;
 967   GtkTreeModelRefCount *ref_model;
 968   GtkTreeModel *sort_model;
 969   GtkWidget *tree_view;
 970   SignalMonitor *monitor;
 971   GtkTreePath *path;
 972   GType column_types[] = { G_TYPE_INT };
 973   int order0[] = { 1, 2, 3, 0, 4, 5, 6 };
 974
 975   model = gtk_tree_model_ref_count_new ();
 976   ref_model = GTK_TREE_MODEL_REF_COUNT (model);
 977
 978   gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
 979                                    column_types);
 980
 981   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
 982                                      0, 30, -1);
 983   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
 984                                      0, 40, -1);
 985   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
 986                                      0, 10, -1);
 987   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
 988                                      0, 20, -1);
 989   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
 990                                      0, 60, -1);
 991
 992   sort_model = gtk_tree_model_sort_new_with_model (model);
 993   tree_view = gtk_tree_view_new_with_model (sort_model);
 994
 995   /* Sort */
 996   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
 997                                         0, GTK_SORT_ASCENDING);
 998   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
 999
1000   monitor = signal_monitor_new (sort_model);
1001
1002   /* Insert a new item */
1003   signal_monitor_append_signal (monitor, ROW_INSERTED, "4");
1004   gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &new_iter, NULL,
1005                                      5, 0, 50, -1);
1006   signal_monitor_assert_is_empty (monitor);
1007   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
1008
1009   /* Sort the tree sort and append a new item */
1010   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
1011                                         0, GTK_SORT_ASCENDING);
1012   check_sort_order (model, GTK_SORT_ASCENDING, NULL);
1013
1014   path = gtk_tree_path_new ();
1015   signal_monitor_append_signal (monitor, ROW_INSERTED, "0");
1016   signal_monitor_append_signal_reordered (monitor,
1017                                           ROWS_REORDERED,
1018                                           path, order0, 7);
1019   signal_monitor_append_signal (monitor, ROW_CHANGED, "3");
1020   gtk_tree_store_append (GTK_TREE_STORE (model), &new_iter, NULL);
1021   gtk_tree_store_set (GTK_TREE_STORE (model), &new_iter, 0, 35, -1);
1022   check_sort_order (model, GTK_SORT_ASCENDING, NULL);
1023   check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
1024
1025   gtk_tree_path_free (path);
1026   signal_monitor_free (monitor);
1027
1028   gtk_widget_destroy (tree_view);
1029   g_object_unref (sort_model);
1030
1031   g_object_unref (ref_model);
1032 }
1033
1034
1035 static void
1036 specific_bug_300089 (void)
1037 {
1038   /* Test case for GNOME Bugzilla bug 300089.  Written by
1039    * Matthias Clasen.
1040    */
1041   GtkTreeModel *sort_model, *child_model;
1042   GtkTreePath *path;
1043   GtkTreeIter iter, iter2, sort_iter;
1044
1045   g_test_bug ("300089");
1046
1047   child_model = GTK_TREE_MODEL (gtk_tree_store_new (1, G_TYPE_STRING));
1048
1049   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
1050   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1);
1051   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
1052   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "B", -1);
1053
1054   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter);
1055   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "D", -1);
1056   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter2, &iter);
1057   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter2, 0, "E", -1);
1058
1059   gtk_tree_store_append (GTK_TREE_STORE (child_model), &iter, NULL);
1060   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "C", -1);
1061
1062
1063   sort_model = GTK_TREE_MODEL (gtk_tree_model_sort_new_with_model (child_model));
1064   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
1065                                         0, GTK_SORT_ASCENDING);
1066
1067   path = gtk_tree_path_new_from_indices (1, 1, -1);
1068
1069   /* make sure a level is constructed */
1070   gtk_tree_model_get_iter (sort_model, &sort_iter, path);
1071
1072   /* change the "E" row in a way that causes it to change position */
1073   gtk_tree_model_get_iter (child_model, &iter, path);
1074   gtk_tree_store_set (GTK_TREE_STORE (child_model), &iter, 0, "A", -1);
1075
1076   gtk_tree_path_free (path);
1077 }
1078
1079 static void
1080 specific_bug_364946 (void)
1081 {
1082   /* This is a test case for GNOME Bugzilla bug 364946.  It was written
1083    * by Andreas Koehler.
1084    */
1085   GtkTreeStore *store;
1086   GtkTreeIter a, aa, aaa, aab, iter;
1087   GtkTreeModel *s_model;
1088
1089   g_test_bug ("364946");
1090
1091   store = gtk_tree_store_new (1, G_TYPE_STRING);
1092
1093   gtk_tree_store_append (store, &a, NULL);
1094   gtk_tree_store_set (store, &a, 0, "0", -1);
1095
1096   gtk_tree_store_append (store, &aa, &a);
1097   gtk_tree_store_set (store, &aa, 0, "0:0", -1);
1098
1099   gtk_tree_store_append (store, &aaa, &aa);
1100   gtk_tree_store_set (store, &aaa, 0, "0:0:0", -1);
1101
1102   gtk_tree_store_append (store, &aab, &aa);
1103   gtk_tree_store_set (store, &aab, 0, "0:0:1", -1);
1104
1105   s_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
1106   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (s_model), 0,
1107                                         GTK_SORT_ASCENDING);
1108
1109   gtk_tree_model_get_iter_from_string (s_model, &iter, "0:0:0");
1110
1111   gtk_tree_store_set (store, &aaa, 0, "0:0:0", -1);
1112   gtk_tree_store_remove (store, &aaa);
1113   gtk_tree_store_remove (store, &aab);
1114
1115   gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (s_model));
1116 }
1117
1118 /* main */
1119
1120 void
1121 register_sort_model_tests (void)
1122 {
1123   g_test_add_func ("/TreeModelSort/ref-count/single-level",
1124                    ref_count_single_level);
1125   g_test_add_func ("/TreeModelSort/ref-count/two-levels",
1126                    ref_count_two_levels);
1127   g_test_add_func ("/TreeModelSort/ref-count/three-levels",
1128                    ref_count_three_levels);
1129   g_test_add_func ("/TreeModelSort/ref-count/delete-row",
1130                    ref_count_delete_row);
1131   g_test_add_func ("/TreeModelSort/ref-count/cleanup",
1132                    ref_count_cleanup);
1133   g_test_add_func ("/TreeModelSort/ref-count/row-ref",
1134                    ref_count_row_ref);
1135   g_test_add_func ("/TreeModelSort/ref-count/reorder/single-level",
1136                    ref_count_reorder_single);
1137   g_test_add_func ("/TreeModelSort/ref-count/reorder/two-levels",
1138                    ref_count_reorder_two);
1139
1140   g_test_add_func ("/TreeModelSort/rows-reordered/single-level",
1141                    rows_reordered_single_level);
1142   g_test_add_func ("/TreeModelSort/rows-reordered/two-levels",
1143                    rows_reordered_two_levels);
1144   g_test_add_func ("/TreeModelSort/sorted-insert",
1145                    sorted_insert);
1146
1147   g_test_add_func ("/TreeModelSort/specific/bug-300089",
1148                    specific_bug_300089);
1149   g_test_add_func ("/TreeModelSort/specific/bug-364946",
1150                    specific_bug_364946);
1151 }