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, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 /* To do:
  20  *  - All the to do items from liststore.c, plus:
  21  *  - Finish up the insertion tests; things aren't as nicely refactored
  22  *    here as in GtkListStore, so we need to check for corner cases on
  23  *    all insertion functions separately.
  24  *  - We only test in the root level, we also need all tests "duplicated"
  25  *    for child levels.
  26  *  - And we also need tests for creating these child levels, etc.
  27  */
  28
  29 #include "treemodel.h"
  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 /* setting values */
 462 static void
 463 tree_store_set_gvalue_to_transform (void)
 464 {
 465   GtkTreeStore *store;
 466   GtkTreeIter iter;
 467   GValue value = G_VALUE_INIT;
 468
 469   /* https://bugzilla.gnome.org/show_bug.cgi?id=677649 */
 470   store = gtk_tree_store_new (1, G_TYPE_LONG);
 471   gtk_tree_store_append (store, &iter, NULL);
 472
 473   g_value_init (&value, G_TYPE_INT);
 474   g_value_set_int (&value, 42);
 475   gtk_tree_store_set_value (store, &iter, 0, &value);
 476 }
 477
 478 /* removal */
 479 static void
 480 tree_store_test_remove_begin (TreeStore     *fixture,
 481                               gconstpointer  user_data)
 482 {
 483   int new_order[5] = { -1, 1, 2, 3, 4 };
 484   GtkTreePath *path;
 485   GtkTreeIter iter;
 486
 487   /* Remove node at 0 */
 488   path = gtk_tree_path_new_from_indices (0, -1);
 489   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &iter, path);
 490   gtk_tree_path_free (path);
 491
 492   g_assert (gtk_tree_store_remove (fixture->store, &iter) == TRUE);
 493   g_assert (!gtk_tree_store_iter_is_valid (fixture->store, &fixture->iter[0]));
 494   g_assert (iters_equal (&iter, &fixture->iter[1]));
 495
 496   check_model (fixture, new_order, 0);
 497 }
 498
 499 static void
 500 tree_store_test_remove_middle (TreeStore     *fixture,
 501                                gconstpointer  user_data)
 502 {
 503   int new_order[5] = { 0, 1, -1, 3, 4 };
 504   GtkTreePath *path;
 505   GtkTreeIter iter;
 506
 507   /* Remove node at 2 */
 508   path = gtk_tree_path_new_from_indices (2, -1);
 509   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &iter, path);
 510   gtk_tree_path_free (path);
 511
 512   g_assert (gtk_tree_store_remove (fixture->store, &iter) == TRUE);
 513   g_assert (!gtk_tree_store_iter_is_valid (fixture->store, &fixture->iter[2]));
 514   g_assert (iters_equal (&iter, &fixture->iter[3]));
 515
 516   check_model (fixture, new_order, 2);
 517 }
 518
 519 static void
 520 tree_store_test_remove_end (TreeStore     *fixture,
 521                             gconstpointer  user_data)
 522 {
 523   int new_order[5] = { 0, 1, 2, 3, -1 };
 524   GtkTreePath *path;
 525   GtkTreeIter iter;
 526
 527   /* Remove node at 4 */
 528   path = gtk_tree_path_new_from_indices (4, -1);
 529   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &iter, path);
 530   gtk_tree_path_free (path);
 531
 532   g_assert (gtk_tree_store_remove (fixture->store, &iter) == FALSE);
 533   g_assert (!gtk_tree_store_iter_is_valid (fixture->store, &fixture->iter[4]));
 534
 535   check_model (fixture, new_order, 4);
 536 }
 537
 538 static void
 539 tree_store_test_clear (TreeStore     *fixture,
 540                        gconstpointer  user_data)
 541 {
 542   int i;
 543
 544   gtk_tree_store_clear (fixture->store);
 545
 546   g_assert (gtk_tree_model_iter_n_children (GTK_TREE_MODEL (fixture->store), NULL) == 0);
 547
 548   for (i = 0; i < 5; i++)
 549     g_assert (!gtk_tree_store_iter_is_valid (fixture->store, &fixture->iter[i]));
 550 }
 551
 552 /* reorder */
 553
 554 static void
 555 tree_store_test_reorder (TreeStore     *fixture,
 556                          gconstpointer  user_data)
 557 {
 558   int new_order[5] = { 4, 1, 0, 2, 3 };
 559
 560   gtk_tree_store_reorder (fixture->store, NULL, new_order);
 561   check_model (fixture, new_order, -1);
 562 }
 563
 564 /* swapping */
 565
 566 static void
 567 tree_store_test_swap_begin (TreeStore     *fixture,
 568                             gconstpointer  user_data)
 569 {
 570   /* We swap nodes 0 and 1 at the beginning */
 571   int new_order[5] = { 1, 0, 2, 3, 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, "0"));
 577   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_b, "1"));
 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_next (TreeStore     *fixture,
 585                                   gconstpointer  user_data)
 586 {
 587   /* We swap nodes 2 and 3 in the middle that are next to each other */
 588   int new_order[5] = { 0, 1, 3, 2, 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, "2"));
 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_middle_apart (TreeStore     *fixture,
 602                                    gconstpointer  user_data)
 603 {
 604   /* We swap nodes 1 and 3 in the middle that are apart from each other */
 605   int new_order[5] = { 0, 3, 2, 1, 4 };
 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, "1"));
 611   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_b, "3"));
 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_end (TreeStore     *fixture,
 619                           gconstpointer  user_data)
 620 {
 621   /* We swap nodes 3 and 4 at the end */
 622   int new_order[5] = { 0, 1, 2, 4, 3 };
 623
 624   GtkTreeIter iter_a;
 625   GtkTreeIter iter_b;
 626
 627   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_a, "3"));
 628   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter_b, "4"));
 629
 630   gtk_tree_store_swap (fixture->store, &iter_a, &iter_b);
 631   check_model (fixture, new_order, -1);
 632 }
 633
 634 static void
 635 tree_store_test_swap_single (void)
 636 {
 637   GtkTreeIter iter;
 638   GtkTreeIter iter_copy;
 639   GtkTreeStore *store;
 640
 641   store = gtk_tree_store_new (1, G_TYPE_INT);
 642
 643   /* Check if swap on a store with a single node does not corrupt
 644    * the store.
 645    */
 646
 647   gtk_tree_store_append (store, &iter, NULL);
 648   iter_copy = iter;
 649
 650   gtk_tree_store_swap (store, &iter, &iter);
 651   g_assert (iters_equal (&iter, &iter_copy));
 652   g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
 653   g_assert (iters_equal (&iter, &iter_copy));
 654
 655   g_object_unref (store);
 656 }
 657
 658 /* move after */
 659
 660 static void
 661 tree_store_test_move_after_from_start (TreeStore     *fixture,
 662                                        gconstpointer  user_data)
 663 {
 664   /* We move node 0 after 2 */
 665   int new_order[5] = { 1, 2, 0, 3, 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, "0"));
 671   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "2"));
 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_next (TreeStore     *fixture,
 679                                  gconstpointer  user_data)
 680 {
 681   /* We move node 2 after 3 */
 682   int new_order[5] = { 0, 1, 3, 2, 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, "2"));
 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_apart (TreeStore     *fixture,
 696                                   gconstpointer  user_data)
 697 {
 698   /* We move node 1 after 3 */
 699   int new_order[5] = { 0, 2, 3, 1, 4 };
 700
 701   GtkTreeIter iter;
 702   GtkTreeIter position;
 703
 704   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "1"));
 705   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "3"));
 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_end (TreeStore     *fixture,
 713                                 gconstpointer  user_data)
 714 {
 715   /* We move node 2 after 4 */
 716   int new_order[5] = { 0, 1, 3, 4, 2 };
 717
 718   GtkTreeIter iter;
 719   GtkTreeIter position;
 720
 721   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
 722   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "4"));
 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_from_end (TreeStore     *fixture,
 730                                      gconstpointer  user_data)
 731 {
 732   /* We move node 4 after 1 */
 733   int new_order[5] = { 0, 1, 4, 2, 3 };
 734
 735   GtkTreeIter iter;
 736   GtkTreeIter position;
 737
 738   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "4"));
 739   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "1"));
 740
 741   gtk_tree_store_move_after (fixture->store, &iter, &position);
 742   check_model (fixture, new_order, -1);
 743 }
 744
 745 static void
 746 tree_store_test_move_after_change_ends (TreeStore     *fixture,
 747                                         gconstpointer  user_data)
 748 {
 749   /* We move 0 after 4, this will cause both the head and tail ends to
 750    * change.
 751    */
 752   int new_order[5] = { 1, 2, 3, 4, 0 };
 753
 754   GtkTreeIter iter;
 755   GtkTreeIter position;
 756
 757   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "0"));
 758   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "4"));
 759
 760   gtk_tree_store_move_after (fixture->store, &iter, &position);
 761   check_model (fixture, new_order, -1);
 762 }
 763
 764 static void
 765 tree_store_test_move_after_NULL (TreeStore     *fixture,
 766                                  gconstpointer  user_data)
 767 {
 768   /* We move node 2, NULL should prepend */
 769   int new_order[5] = { 2, 0, 1, 3, 4 };
 770
 771   GtkTreeIter iter;
 772
 773   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
 774
 775   gtk_tree_store_move_after (fixture->store, &iter, NULL);
 776   check_model (fixture, new_order, -1);
 777 }
 778
 779 static void
 780 tree_store_test_move_after_single (void)
 781 {
 782   GtkTreeIter iter;
 783   GtkTreeIter iter_copy;
 784   GtkTreeStore *store;
 785
 786   store = gtk_tree_store_new (1, G_TYPE_INT);
 787
 788   /* Check if move-after on a store with a single node does not corrupt
 789    * the store.
 790    */
 791
 792   gtk_tree_store_append (store, &iter, NULL);
 793   iter_copy = iter;
 794
 795   gtk_tree_store_move_after (store, &iter, NULL);
 796   g_assert (iters_equal (&iter, &iter_copy));
 797   g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
 798   g_assert (iters_equal (&iter, &iter_copy));
 799
 800   gtk_tree_store_move_after (store, &iter, &iter);
 801   g_assert (iters_equal (&iter, &iter_copy));
 802   g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
 803   g_assert (iters_equal (&iter, &iter_copy));
 804
 805   g_object_unref (store);
 806 }
 807
 808 /* move before */
 809
 810 static void
 811 tree_store_test_move_before_next (TreeStore     *fixture,
 812                                   gconstpointer  user_data)
 813 {
 814   /* We move node 3 before 2 */
 815   int new_order[5] = { 0, 1, 3, 2, 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, "3"));
 821   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "2"));
 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_apart (TreeStore     *fixture,
 829                                    gconstpointer  user_data)
 830 {
 831   /* We move node 1 before 3 */
 832   int new_order[5] = { 0, 2, 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, "1"));
 838   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "3"));
 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_to_start (TreeStore     *fixture,
 846                                       gconstpointer  user_data)
 847 {
 848   /* We move node 2 before 0 */
 849   int new_order[5] = { 2, 0, 1, 3, 4 };
 850
 851   GtkTreeIter iter;
 852   GtkTreeIter position;
 853
 854   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
 855   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "0"));
 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_from_end (TreeStore     *fixture,
 863                                       gconstpointer  user_data)
 864 {
 865   /* We move node 4 before 2 (replace end) */
 866   int new_order[5] = { 0, 1, 4, 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, "2"));
 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_change_ends (TreeStore     *fixture,
 880                                          gconstpointer  user_data)
 881 {
 882   /* We move node 4 before 0 */
 883   int new_order[5] = { 4, 0, 1, 2, 3 };
 884
 885   GtkTreeIter iter;
 886   GtkTreeIter position;
 887
 888   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "4"));
 889   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &position, "0"));
 890
 891   gtk_tree_store_move_before (fixture->store, &iter, &position);
 892   check_model (fixture, new_order, -1);
 893 }
 894
 895 static void
 896 tree_store_test_move_before_NULL (TreeStore     *fixture,
 897                                   gconstpointer  user_data)
 898 {
 899   /* We move node 2, NULL should append */
 900   int new_order[5] = { 0, 1, 3, 4, 2 };
 901
 902   GtkTreeIter iter;
 903
 904   g_assert (gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store), &iter, "2"));
 905
 906   gtk_tree_store_move_before (fixture->store, &iter, NULL);
 907   check_model (fixture, new_order, -1);
 908 }
 909
 910 static void
 911 tree_store_test_move_before_single (void)
 912 {
 913   GtkTreeIter iter;
 914   GtkTreeIter iter_copy;
 915   GtkTreeStore *store;
 916
 917   store = gtk_tree_store_new (1, G_TYPE_INT);
 918
 919   /* Check if move-after on a store with a single node does not corrupt
 920    * the store.
 921    */
 922
 923   gtk_tree_store_append (store, &iter, NULL);
 924   iter_copy = iter;
 925
 926   gtk_tree_store_move_before (store, &iter, NULL);
 927   g_assert (iters_equal (&iter, &iter_copy));
 928   g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
 929   g_assert (iters_equal (&iter, &iter_copy));
 930
 931   gtk_tree_store_move_before (store, &iter, &iter);
 932   g_assert (iters_equal (&iter, &iter_copy));
 933   g_assert (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (store), &iter));
 934   g_assert (iters_equal (&iter, &iter_copy));
 935
 936   g_object_unref (store);
 937 }
 938
 939
 940 /* iter invalidation */
 941
 942 static void
 943 tree_store_test_iter_previous_invalid (TreeStore     *fixture,
 944                                        gconstpointer  user_data)
 945 {
 946   GtkTreeIter iter;
 947
 948   gtk_tree_model_get_iter_first (GTK_TREE_MODEL (fixture->store), &iter);
 949
 950   g_assert (gtk_tree_model_iter_previous (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_next_invalid (TreeStore     *fixture,
 958                                    gconstpointer  user_data)
 959 {
 960   GtkTreePath *path;
 961   GtkTreeIter iter;
 962
 963   path = gtk_tree_path_new_from_indices (4, -1);
 964   gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &iter, path);
 965   gtk_tree_path_free (path);
 966
 967   g_assert (gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store),
 968                                       &iter) == FALSE);
 969   g_assert (gtk_tree_store_iter_is_valid (fixture->store, &iter) == FALSE);
 970   g_assert (iter.stamp == 0);
 971 }
 972
 973 static void
 974 tree_store_test_iter_children_invalid (TreeStore     *fixture,
 975                                        gconstpointer  user_data)
 976 {
 977   GtkTreeIter iter, child;
 978
 979   gtk_tree_model_get_iter_first (GTK_TREE_MODEL (fixture->store), &iter);
 980   g_assert (gtk_tree_store_iter_is_valid (fixture->store, &iter) == TRUE);
 981
 982   g_assert (gtk_tree_model_iter_children (GTK_TREE_MODEL (fixture->store),
 983                                           &child, &iter) == FALSE);
 984   g_assert (gtk_tree_store_iter_is_valid (fixture->store, &child) == FALSE);
 985   g_assert (child.stamp == 0);
 986 }
 987
 988 static void
 989 tree_store_test_iter_nth_child_invalid (TreeStore     *fixture,
 990                                         gconstpointer  user_data)
 991 {
 992   GtkTreeIter iter, child;
 993
 994   gtk_tree_model_get_iter_first (GTK_TREE_MODEL (fixture->store), &iter);
 995   g_assert (gtk_tree_store_iter_is_valid (fixture->store, &iter) == TRUE);
 996
 997   g_assert (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (fixture->store),
 998                                            &child, &iter, 0) == FALSE);
 999   g_assert (gtk_tree_store_iter_is_valid (fixture->store, &child) == FALSE);
1000   g_assert (child.stamp == 0);
1001 }
1002
1003 static void
1004 tree_store_test_iter_parent_invalid (TreeStore     *fixture,
1005                                      gconstpointer  user_data)
1006 {
1007   GtkTreeIter iter, child;
1008
1009   gtk_tree_model_get_iter_first (GTK_TREE_MODEL (fixture->store), &child);
1010   g_assert (gtk_tree_store_iter_is_valid (fixture->store, &child) == TRUE);
1011
1012   g_assert (gtk_tree_model_iter_parent (GTK_TREE_MODEL (fixture->store),
1013                                         &iter, &child) == FALSE);
1014   g_assert (gtk_tree_store_iter_is_valid (fixture->store, &iter) == FALSE);
1015   g_assert (iter.stamp == 0);
1016 }
1017
1018 /* specific bugs */
1019 static void
1020 specific_bug_77977 (void)
1021 {
1022   GtkTreeStore *tree_store;
1023   GtkTreeIter iter1, iter2, iter3;
1024   GtkTreePath *path;
1025   GtkTreeRowReference *row_ref;
1026
1027   /* Stripped down version of test case for bug 77977 by Damon Chaplin */
1028
1029   g_test_bug ("77977");
1030
1031   tree_store = gtk_tree_store_new (1, G_TYPE_STRING);
1032
1033   gtk_tree_store_append (tree_store, &iter1, NULL);
1034   gtk_tree_store_set (tree_store, &iter1, 0, "Window1", -1);
1035
1036   gtk_tree_store_append (tree_store, &iter2, &iter1);
1037   gtk_tree_store_set (tree_store, &iter2, 0, "Table1", -1);
1038
1039   gtk_tree_store_append (tree_store, &iter3, &iter2);
1040   gtk_tree_store_set (tree_store, &iter3, 0, "Button1", -1);
1041
1042   path = gtk_tree_path_new_from_indices (0, 0, 0, -1);
1043   row_ref = gtk_tree_row_reference_new (GTK_TREE_MODEL (tree_store), path);
1044   gtk_tree_path_free (path);
1045
1046   gtk_tree_store_remove (tree_store, &iter1);
1047
1048   gtk_tree_row_reference_free (row_ref);
1049   g_object_unref (tree_store);
1050 }
1051
1052 /* main */
1053
1054 void
1055 register_tree_store_tests (void)
1056 {
1057   /* insertion */
1058   g_test_add_func ("/TreeStore/insert-high-values",
1059                    tree_store_test_insert_high_values);
1060   g_test_add_func ("/TreeStore/append",
1061                    tree_store_test_append);
1062   g_test_add_func ("/TreeStore/prepend",
1063                    tree_store_test_prepend);
1064   g_test_add_func ("/TreeStore/insert-after",
1065                    tree_store_test_insert_after);
1066   g_test_add_func ("/TreeStore/insert-after-NULL",
1067                    tree_store_test_insert_after_NULL);
1068   g_test_add_func ("/TreeStore/insert-before",
1069                    tree_store_test_insert_before);
1070   g_test_add_func ("/TreeStore/insert-before-NULL",
1071                    tree_store_test_insert_before_NULL);
1072
1073   /* setting values (FIXME) */
1074   g_test_add_func ("/TreeStore/set-gvalue-to-transform",
1075                    tree_store_set_gvalue_to_transform);
1076
1077   /* removal */
1078   g_test_add ("/TreeStore/remove-begin", TreeStore, NULL,
1079               tree_store_setup, tree_store_test_remove_begin,
1080               tree_store_teardown);
1081   g_test_add ("/TreeStore/remove-middle", TreeStore, NULL,
1082               tree_store_setup, tree_store_test_remove_middle,
1083               tree_store_teardown);
1084   g_test_add ("/TreeStore/remove-end", TreeStore, NULL,
1085               tree_store_setup, tree_store_test_remove_end,
1086               tree_store_teardown);
1087
1088   g_test_add ("/TreeStore/clear", TreeStore, NULL,
1089               tree_store_setup, tree_store_test_clear,
1090               tree_store_teardown);
1091
1092   /* reordering */
1093   g_test_add ("/TreeStore/reorder", TreeStore, NULL,
1094               tree_store_setup, tree_store_test_reorder,
1095               tree_store_teardown);
1096
1097   /* swapping */
1098   g_test_add ("/TreeStore/swap-begin", TreeStore, NULL,
1099               tree_store_setup, tree_store_test_swap_begin,
1100               tree_store_teardown);
1101   g_test_add ("/TreeStore/swap-middle-next", TreeStore, NULL,
1102               tree_store_setup, tree_store_test_swap_middle_next,
1103               tree_store_teardown);
1104   g_test_add ("/TreeStore/swap-middle-apart", TreeStore, NULL,
1105               tree_store_setup, tree_store_test_swap_middle_apart,
1106               tree_store_teardown);
1107   g_test_add ("/TreeStore/swap-end", TreeStore, NULL,
1108               tree_store_setup, tree_store_test_swap_end,
1109               tree_store_teardown);
1110   g_test_add_func ("/TreeStore/swap-single",
1111                    tree_store_test_swap_single);
1112
1113   /* moving */
1114   g_test_add ("/TreeStore/move-after-from-start", TreeStore, NULL,
1115               tree_store_setup, tree_store_test_move_after_from_start,
1116               tree_store_teardown);
1117   g_test_add ("/TreeStore/move-after-next", TreeStore, NULL,
1118               tree_store_setup, tree_store_test_move_after_next,
1119               tree_store_teardown);
1120   g_test_add ("/TreeStore/move-after-apart", TreeStore, NULL,
1121               tree_store_setup, tree_store_test_move_after_apart,
1122               tree_store_teardown);
1123   g_test_add ("/TreeStore/move-after-end", TreeStore, NULL,
1124               tree_store_setup, tree_store_test_move_after_end,
1125               tree_store_teardown);
1126   g_test_add ("/TreeStore/move-after-from-end", TreeStore, NULL,
1127               tree_store_setup, tree_store_test_move_after_from_end,
1128               tree_store_teardown);
1129   g_test_add ("/TreeStore/move-after-change-ends", TreeStore, NULL,
1130               tree_store_setup, tree_store_test_move_after_change_ends,
1131               tree_store_teardown);
1132   g_test_add ("/TreeStore/move-after-NULL", TreeStore, NULL,
1133               tree_store_setup, tree_store_test_move_after_NULL,
1134               tree_store_teardown);
1135   g_test_add_func ("/TreeStore/move-after-single",
1136                    tree_store_test_move_after_single);
1137
1138   g_test_add ("/TreeStore/move-before-next", TreeStore, NULL,
1139               tree_store_setup, tree_store_test_move_before_next,
1140               tree_store_teardown);
1141   g_test_add ("/TreeStore/move-before-apart", TreeStore, NULL,
1142               tree_store_setup, tree_store_test_move_before_apart,
1143               tree_store_teardown);
1144   g_test_add ("/TreeStore/move-before-to-start", TreeStore, NULL,
1145               tree_store_setup, tree_store_test_move_before_to_start,
1146               tree_store_teardown);
1147   g_test_add ("/TreeStore/move-before-from-end", TreeStore, NULL,
1148               tree_store_setup, tree_store_test_move_before_from_end,
1149               tree_store_teardown);
1150   g_test_add ("/TreeStore/move-before-change-ends", TreeStore, NULL,
1151               tree_store_setup, tree_store_test_move_before_change_ends,
1152               tree_store_teardown);
1153   g_test_add ("/TreeStore/move-before-NULL", TreeStore, NULL,
1154               tree_store_setup, tree_store_test_move_before_NULL,
1155               tree_store_teardown);
1156   g_test_add_func ("/TreeStore/move-before-single",
1157                    tree_store_test_move_before_single);
1158
1159   /* iter invalidation */
1160   g_test_add ("/TreeStore/iter-prev-invalid", TreeStore, NULL,
1161               tree_store_setup, tree_store_test_iter_previous_invalid,
1162               tree_store_teardown);
1163   g_test_add ("/TreeStore/iter-next-invalid", TreeStore, NULL,
1164               tree_store_setup, tree_store_test_iter_next_invalid,
1165               tree_store_teardown);
1166   g_test_add ("/TreeStore/iter-children-invalid", TreeStore, NULL,
1167               tree_store_setup, tree_store_test_iter_children_invalid,
1168               tree_store_teardown);
1169   g_test_add ("/TreeStore/iter-nth-child-invalid", TreeStore, NULL,
1170               tree_store_setup, tree_store_test_iter_nth_child_invalid,
1171               tree_store_teardown);
1172   g_test_add ("/TreeStore/iter-parent-invalid", TreeStore, NULL,
1173               tree_store_setup, tree_store_test_iter_parent_invalid,
1174               tree_store_teardown);
1175
1176   /* specific bugs */
1177   g_test_add_func ("/TreeStore/bug-77977", specific_bug_77977);
1178 }