/* Extensive GtkTreeModelFilter tests.

 * Copyright (C) 2009  Kristian Rietveld  <kris@gtk.org>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include <gtk/gtk.h>

/* Left to do:

 *   - Proper coverage checking to see if the unit tests cover

 *     all possible cases.

 *   - Verify if the ref counting is done properly for both the

 *     normal ref_count and the zero_ref_count.  One way to test

 *     this area is by collapsing/expanding branches on the view

 *     that is connected to the filter model.

 *   - Check if the iterator stamp is incremented at the correct times.

 */

/*

 * Model creation

 */

#define LEVEL_LENGTH 5

static void

create_tree_store_set_values (GtkTreeStore *store,

                              GtkTreeIter  *iter,

                              gboolean      visible)

{

  GtkTreePath *path;

  gchar *path_string;

  path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), iter);

  path_string = gtk_tree_path_to_string (path);

  gtk_tree_store_set (store, iter,

                      0, path_string,

                      1, visible,

                      -1);

  gtk_tree_path_free (path);

  g_free (path_string);

}

static void

create_tree_store_recurse (int           depth,

                           GtkTreeStore *store,

                           GtkTreeIter  *parent,

                           gboolean      visible)

{

  int i;

  for (i = 0; i < LEVEL_LENGTH; i++)

    {

      GtkTreeIter iter;

      gtk_tree_store_insert (store, &iter, parent, i);

      create_tree_store_set_values (store, &iter, visible);

      if (depth > 0)

        create_tree_store_recurse (depth - 1, store, &iter, visible);

    }

}

static GtkTreeStore *

create_tree_store (int      depth,

                   gboolean visible)

{

  GtkTreeStore *store;

  store = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);

  create_tree_store_recurse (depth, store, NULL, visible);

  return store;

}

/*

 * Signal monitor

 */

typedef enum

{

  ROW_INSERTED,

  ROW_DELETED,

  ROW_CHANGED,

  ROW_HAS_CHILD_TOGGLED,

  ROWS_REORDERED,

  LAST_SIGNAL

}

SignalName;

static const char *

signal_name_to_string (SignalName signal)

{

  switch (signal)

    {

      case ROW_INSERTED:

          return "row-inserted";

      case ROW_DELETED:

          return "row-deleted";

      case ROW_CHANGED:

          return "row-changed";

      case ROW_HAS_CHILD_TOGGLED:

          return "row-has-child-toggled";

      case ROWS_REORDERED:

          return "rows-reordered";

      default:

          /* Fall through */

          break;

    }

  return "(unknown)";

}

typedef struct

{

  SignalName signal;

  GtkTreePath *path;

}

Signal;

static Signal *

signal_new (SignalName signal, GtkTreePath *path)

{

  Signal *s;

  s = g_new0 (Signal, 1);

  s->signal = signal;

  s->path = gtk_tree_path_copy (path);

  return s;

}

static void

signal_free (Signal *s)

{

  if (s->path)

    gtk_tree_path_free (s->path);

  g_free (s);

}

typedef struct

{

  GQueue *queue;

  GtkTreeModel *client;

  guint signal_ids[LAST_SIGNAL];

}

SignalMonitor;

static void

signal_monitor_generic_handler (SignalMonitor *m,

                                SignalName     signal,

                                GtkTreeModel  *model,

                                GtkTreePath   *path)

{

  Signal *s;

  if (g_queue_is_empty (m->queue))

    {

      g_error ("Signal queue empty\n");

      g_assert_not_reached ();

    }

  if (m->client != model)

    {

      g_error ("Model mismatch; expected %p, got %p\n",

               m->client, model);

      g_assert_not_reached ();

    }

  s = g_queue_peek_tail (m->queue);

#if 0

  /* For debugging: output signals that are coming in.  Leaks memory. */

  g_print ("signal=%d  path=%s\n", signal, gtk_tree_path_to_string (path));

#endif

  if (s->signal != signal

      || gtk_tree_path_compare (s->path, path) != 0)

    {

      gchar *path_str, *s_path_str;

      s_path_str = gtk_tree_path_to_string (s->path);

      path_str = gtk_tree_path_to_string (path);

      g_error ("Signals don't match; expected signal %s path %s, got signal %s path %s\n",

               signal_name_to_string (s->signal), s_path_str,

               signal_name_to_string (signal), path_str);

      g_free (s_path_str);

      g_free (path_str);

      g_assert_not_reached ();

    }

  s = g_queue_pop_tail (m->queue);

  signal_free (s);

}

static void

signal_monitor_row_inserted (GtkTreeModel *model,

                             GtkTreePath  *path,

                             GtkTreeIter  *iter,

                             gpointer      data)

{

  signal_monitor_generic_handler (data, ROW_INSERTED,

                                  model, path);

}

static void

signal_monitor_row_deleted (GtkTreeModel *model,

                            GtkTreePath  *path,

                            gpointer      data)

{

  signal_monitor_generic_handler (data, ROW_DELETED,

                                  model, path);

}

static void

signal_monitor_row_changed (GtkTreeModel *model,

                            GtkTreePath  *path,

                            GtkTreeIter  *iter,

                            gpointer      data)

{

  signal_monitor_generic_handler (data, ROW_CHANGED,

                                  model, path);

}

static void

signal_monitor_row_has_child_toggled (GtkTreeModel *model,

                                      GtkTreePath  *path,

                                      GtkTreeIter  *iter,

                                      gpointer      data)

{

  signal_monitor_generic_handler (data, ROW_HAS_CHILD_TOGGLED,

                                  model, path);

}

static void

signal_monitor_rows_reordered (GtkTreeModel *model,

                               GtkTreePath  *path,

                               GtkTreeIter  *iter,

                               gint         *new_order,

                               gpointer      data)

{

  signal_monitor_generic_handler (data, ROWS_REORDERED,

                                  model, path);

}

static SignalMonitor *

signal_monitor_new (GtkTreeModel *client)

{

  SignalMonitor *m;

  m = g_new0 (SignalMonitor, 1);

  m->client = g_object_ref (client);

  m->queue = g_queue_new ();

  m->signal_ids[ROW_INSERTED] = g_signal_connect (client,

                                                  "row-inserted",

                                                  G_CALLBACK (signal_monitor_row_inserted),

                                                  m);

  m->signal_ids[ROW_DELETED] = g_signal_connect (client,

                                                 "row-deleted",

                                                 G_CALLBACK (signal_monitor_row_deleted),

                                                 m);

  m->signal_ids[ROW_CHANGED] = g_signal_connect (client,

                                                 "row-changed",

                                                 G_CALLBACK (signal_monitor_row_changed),

                                                 m);

  m->signal_ids[ROW_HAS_CHILD_TOGGLED] = g_signal_connect (client,

                                                           "row-has-child-toggled",

                                                           G_CALLBACK (signal_monitor_row_has_child_toggled),

                                                           m);

  m->signal_ids[ROWS_REORDERED] = g_signal_connect (client,

                                                    "rows-reordered",

                                                    G_CALLBACK (signal_monitor_rows_reordered),

                                                    m);

  return m;

}

static void

signal_monitor_free (SignalMonitor *m)

{

  int i;

  for (i = 0; i < LAST_SIGNAL; i++)

    g_signal_handler_disconnect (m->client, m->signal_ids[i]);

  g_object_unref (m->client);

  if (m->queue)

    g_queue_free (m->queue);

  g_free (m);

}

static void

signal_monitor_assert_is_empty (SignalMonitor *m)

{

  g_assert (g_queue_is_empty (m->queue));

}

static void

signal_monitor_append_signal_path (SignalMonitor *m,

                                   SignalName     signal,

                                   GtkTreePath   *path)

{

  Signal *s;

  s = signal_new (signal, path);

  g_queue_push_head (m->queue, s);

}

static void

signal_monitor_append_signal (SignalMonitor *m,

                              SignalName     signal,

                              const gchar   *path_string)

{

  Signal *s;

  GtkTreePath *path;

  path = gtk_tree_path_new_from_string (path_string);

  s = signal_new (signal, path);

  g_queue_push_head (m->queue, s);

  gtk_tree_path_free (path);

}

/*

 * Fixture

 */

typedef struct

{

  GtkWidget *tree_view;

  GtkTreeStore *store;

  GtkTreeModelFilter *filter;

  SignalMonitor *monitor;

  guint block_signals : 1;

} FilterTest;

static void

filter_test_store_signal (FilterTest *fixture)

{

  if (fixture->block_signals)

    g_signal_stop_emission_by_name (fixture->store, "row-changed");

}

static void

filter_test_setup_generic (FilterTest    *fixture,

                           gconstpointer  test_data,

                           int            depth,

                           gboolean       empty,

                           gboolean       unfiltered)

{

  const GtkTreePath *vroot = test_data;

  GtkTreeModel *filter;

  fixture->store = create_tree_store (depth, !empty);

  g_signal_connect_swapped (fixture->store, "row-changed",

                            G_CALLBACK (filter_test_store_signal), fixture);

  /* Please forgive me for casting const away. */

  filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (fixture->store),

                                      (GtkTreePath *)vroot);

  fixture->filter = GTK_TREE_MODEL_FILTER (filter);

  if (!unfiltered)

    gtk_tree_model_filter_set_visible_column (fixture->filter, 1);

  /* We need a tree view that's listening to get ref counting from that

   * side.

   */

  fixture->tree_view = gtk_tree_view_new_with_model (filter);

  fixture->monitor = signal_monitor_new (filter);

}

static void

filter_test_setup (FilterTest    *fixture,

                   gconstpointer  test_data)

{

  filter_test_setup_generic (fixture, test_data, 3, FALSE, FALSE);

}

static void

filter_test_setup_empty (FilterTest    *fixture,

                         gconstpointer  test_data)

{

  filter_test_setup_generic (fixture, test_data, 3, TRUE, FALSE);

}

static void

filter_test_setup_unfiltered (FilterTest    *fixture,

                              gconstpointer  test_data)

{

  filter_test_setup_generic (fixture, test_data, 3, FALSE, TRUE);

}

static void

filter_test_setup_empty_unfiltered (FilterTest    *fixture,

                                    gconstpointer  test_data)

{

  filter_test_setup_generic (fixture, test_data, 3, TRUE, TRUE);

}

static GtkTreePath *

strip_virtual_root (GtkTreePath *path,

                    GtkTreePath *root_path)

{

  GtkTreePath *real_path;

  if (root_path)

    {

      int j;

      int depth = gtk_tree_path_get_depth (path);

      int root_depth = gtk_tree_path_get_depth (root_path);

      real_path = gtk_tree_path_new ();

      for (j = 0; j < depth - root_depth; j++)

        gtk_tree_path_append_index (real_path,

                                    gtk_tree_path_get_indices (path)[root_depth + j]);

    }

  else

    real_path = gtk_tree_path_copy (path);

  return real_path;

}

static void

filter_test_append_refilter_signals_recurse (FilterTest  *fixture,

                                             GtkTreePath *store_path,

                                             GtkTreePath *filter_path,

                                             int          depth,

                                             GtkTreePath *root_path)

{

  int i;

  int rows_deleted = 0;

  GtkTreeIter iter;

  gtk_tree_path_down (store_path);

  gtk_tree_path_down (filter_path);

  gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),

                           &iter, store_path);

  for (i = 0; i < LEVEL_LENGTH; i++)

    {

      gboolean visible;

      GtkTreePath *real_path;

      gtk_tree_model_get (GTK_TREE_MODEL (fixture->store), &iter,

                          1, &visible,

                          -1);

      if (root_path &&

          (!gtk_tree_path_is_descendant (store_path, root_path)

           || !gtk_tree_path_compare (store_path, root_path)))

        {

          if (!gtk_tree_path_compare (store_path, root_path))

            {

              if (depth > 1

                  && gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store),

                                                    &iter))

                {

                  GtkTreePath *store_copy;

                  GtkTreePath *filter_copy;

                  store_copy = gtk_tree_path_copy (store_path);

                  filter_copy = gtk_tree_path_copy (filter_path);

                  filter_test_append_refilter_signals_recurse (fixture,

                                                               store_copy,

                                                               filter_copy,

                                                               depth - 1,

                                                               root_path);

                  gtk_tree_path_free (store_copy);

                  gtk_tree_path_free (filter_copy);

                }

            }

          gtk_tree_path_next (store_path);

          gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);

          if (visible)

            gtk_tree_path_next (filter_path);

          continue;

        }

      real_path = strip_virtual_root (filter_path, root_path);

      if (visible)

        {

          /* This row will be inserted */

          signal_monitor_append_signal_path (fixture->monitor, ROW_CHANGED,

                                             real_path);

          signal_monitor_append_signal_path (fixture->monitor,

                                             ROW_HAS_CHILD_TOGGLED,

                                             real_path);

          if (depth > 1

              && gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store),

                                                &iter))

            {

              GtkTreePath *store_copy;

              GtkTreePath *filter_copy;

              store_copy = gtk_tree_path_copy (store_path);

              filter_copy = gtk_tree_path_copy (filter_path);

              filter_test_append_refilter_signals_recurse (fixture,

                                                           store_copy,

                                                           filter_copy,

                                                           depth - 1,

                                                           root_path);

              gtk_tree_path_free (store_copy);

              gtk_tree_path_free (filter_copy);

            }

          gtk_tree_path_next (filter_path);

        }

      else

        {

          /* This row will be deleted */

          rows_deleted++;

          signal_monitor_append_signal_path (fixture->monitor, ROW_DELETED,

                                             real_path);

        }

      gtk_tree_path_free (real_path);

      gtk_tree_path_next (store_path);

      gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &iter);

    }

  if (rows_deleted == LEVEL_LENGTH

      && gtk_tree_path_get_depth (filter_path) > 1)

    {

      GtkTreePath *real_path;

      gtk_tree_path_up (store_path);

      gtk_tree_path_up (filter_path);

      /* A row-has-child-toggled will be emitted on the parent */

      if (!root_path

          || (root_path

              && gtk_tree_path_is_descendant (store_path, root_path)

              && gtk_tree_path_compare (store_path, root_path)))

        {

          real_path = strip_virtual_root (filter_path, root_path);

          signal_monitor_append_signal_path (fixture->monitor,

                                             ROW_HAS_CHILD_TOGGLED,

                                             real_path);

          gtk_tree_path_free (real_path);

        }

    }

}

static void

filter_test_append_refilter_signals (FilterTest *fixture,

                                     int         depth)

{

  /* A special function that walks the tree store like the

   * model validation functions below.

   */

  GtkTreePath *path;

  GtkTreePath *filter_path;

  path = gtk_tree_path_new ();

  filter_path = gtk_tree_path_new ();

  filter_test_append_refilter_signals_recurse (fixture,

                                               path,

                                               filter_path,

                                               depth,

                                               NULL);

  gtk_tree_path_free (path);

  gtk_tree_path_free (filter_path);

}

static void

filter_test_append_refilter_signals_with_vroot (FilterTest  *fixture,

                                                int          depth,

                                                GtkTreePath *root_path)

{

  /* A special function that walks the tree store like the

   * model validation functions below.

   */

  GtkTreePath *path;

  GtkTreePath *filter_path;

  path = gtk_tree_path_new ();

  filter_path = gtk_tree_path_new ();

  filter_test_append_refilter_signals_recurse (fixture,

                                               path,

                                               filter_path,

                                               depth,

                                               root_path);

  gtk_tree_path_free (path);

  gtk_tree_path_free (filter_path);

}

static void

filter_test_enable_filter (FilterTest *fixture)

{

  gtk_tree_model_filter_set_visible_column (fixture->filter, 1);

  gtk_tree_model_filter_refilter (fixture->filter);

}

static void

filter_test_block_signals (FilterTest *fixture)

{

  fixture->block_signals = TRUE;

}

static void

filter_test_unblock_signals (FilterTest *fixture)

{

  fixture->block_signals = FALSE;

}

static void

filter_test_teardown (FilterTest    *fixture,

                      gconstpointer  test_data)

{

  signal_monitor_free (fixture->monitor);

  g_object_unref (fixture->filter);

  g_object_unref (fixture->store);

}

/*

 * Model structure validation

 */

static void

check_filter_model_recurse (FilterTest  *fixture,

                            GtkTreePath *store_parent_path,

                            GtkTreePath *filter_parent_path)

{

  int i;

  GtkTreeIter store_iter;

  GtkTreeIter filter_iter;

  gboolean store_has_next, filter_has_next;

  gtk_tree_path_down (store_parent_path);

  gtk_tree_path_down (filter_parent_path);

  store_has_next = gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store),

                                            &store_iter, store_parent_path);

  filter_has_next = gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->filter),

                                             &filter_iter, filter_parent_path);

  for (i = 0; i < LEVEL_LENGTH; i++)

    {

      gboolean visible;

      g_return_if_fail (store_has_next == TRUE);

      gtk_tree_model_get (GTK_TREE_MODEL (fixture->store),

                          &store_iter,

                          1, &visible,

                          -1);

      if (visible)

        {

          GtkTreePath *tmp;

          gchar *filter_str, *store_str;

          g_return_if_fail (filter_has_next == TRUE);

          /* Verify path */

          tmp = gtk_tree_model_get_path (GTK_TREE_MODEL (fixture->filter),

                                         &filter_iter);

          g_return_if_fail (gtk_tree_path_compare (tmp, filter_parent_path) == 0);

          /* Verify model content */

          gtk_tree_model_get (GTK_TREE_MODEL (fixture->store),

                              &store_iter,

                              0, &store_str,

                              -1);

          gtk_tree_model_get (GTK_TREE_MODEL (fixture->filter),

                              &filter_iter,

                              0, &filter_str,

                              -1);

          g_return_if_fail (g_strcmp0 (store_str, filter_str) == 0);

          g_free (store_str);

          g_free (filter_str);

          if (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->filter),

                                             &filter_iter))

            {

              g_return_if_fail (gtk_tree_model_iter_has_child (GTK_TREE_MODEL (fixture->store), &store_iter));

              check_filter_model_recurse (fixture,

                                          gtk_tree_path_copy (store_parent_path),

                                          tmp);

            }

          gtk_tree_path_next (filter_parent_path);

          filter_has_next = gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->filter), &filter_iter);

        }

      gtk_tree_path_next (store_parent_path);

      store_has_next = gtk_tree_model_iter_next (GTK_TREE_MODEL (fixture->store), &store_iter);

    }

  /* Both models should have no more content! */

  g_return_if_fail (store_has_next == FALSE);

  g_return_if_fail (filter_has_next == FALSE);

  gtk_tree_path_free (store_parent_path);

  gtk_tree_path_free (filter_parent_path);

}

static void

check_filter_model (FilterTest *fixture)

{

  GtkTreePath *path;

  if (fixture->monitor)

    signal_monitor_assert_is_empty (fixture->monitor);

  path = gtk_tree_path_new ();

  check_filter_model_recurse (fixture, path, gtk_tree_path_copy (path));

}

static void

check_filter_model_with_root (FilterTest  *fixture,

                              GtkTreePath *path)

{

  if (fixture->monitor)

    signal_monitor_assert_is_empty (fixture->monitor);

  check_filter_model_recurse (fixture,

                              gtk_tree_path_copy (path),

                              gtk_tree_path_new ());

}

/* Helpers */

static void

check_level_length (GtkTreeModelFilter *filter,

                    const gchar        *level,

                    const int           length)

{

  if (!level)

    {

      int l = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (filter), NULL);

      g_return_if_fail (l == length);

    }

  else

    {

      int l;

      gboolean retrieved_iter = FALSE;

      GtkTreeIter iter;

      retrieved_iter = gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (filter),

                                                            &iter, level);

      g_return_if_fail (retrieved_iter);

      l = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (filter), &iter);

      g_return_if_fail (l == length);

    }

}

static void

set_path_visibility (FilterTest  *fixture,

                     const gchar *path,

                     gboolean     visible)

{

  GtkTreeIter store_iter;

  gtk_tree_model_get_iter_from_string (GTK_TREE_MODEL (fixture->store),

                                       &store_iter, path);

  gtk_tree_store_set (fixture->store, &store_iter,

                      1, visible,

                      -1);

}

#if 0

static void

insert_path_with_visibility (FilterTest  *fixture,

                             const gchar *path_string,

                             gboolean     visible)

{

  int position;

  GtkTreePath *path;

  GtkTreeIter parent, iter;

  path = gtk_tree_path_new_from_string (path_string);

  position = gtk_tree_path_get_indices (path)[gtk_tree_path_get_depth (path)];

  gtk_tree_path_up (path);

  if (gtk_tree_model_get_iter (GTK_TREE_MODEL (fixture->store), &parent, path))

    {

      gtk_tree_store_insert (fixture->store, &iter, &parent, position);

      create_tree_store_set_values (fixture->store, &iter, visible);

    }

  gtk_tree_path_free (path);

}

#endif

/*

 * The actual tests.

 */

static void

verify_test_suite (FilterTest    *fixture,

                   gconstpointer  user_data)

{

  check_filter_model (fixture);

}

static void

verify_test_suite_vroot (FilterTest    *fixture,

                         gconstpointer  user_data)

{

  check_filter_model_with_root (fixture, (GtkTreePath *)user_data);

}

static void

filled_hide_root_level (FilterTest    *fixture,

                        gconstpointer  user_data)

{

  signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "2");

  set_path_visibility (fixture, "2", FALSE);

  check_filter_model (fixture);

  check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 1);

  signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "0");

  set_path_visibility (fixture, "0", FALSE);

  check_filter_model (fixture);

  check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 2);

  signal_monitor_append_signal (fixture->monitor, ROW_DELETED, "2");

  set_path_visibility (fixture, "4", FALSE);

  check_filter_model (fixture);

  check_level_length (fixture->filter, NULL, LEVEL_LENGTH - 3);

  /* Hide remaining */