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

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