gtk2/testsuite/gtk/expression.c

/*
 * Copyright © 2019 Benjamin Otte
 *
 * 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.1 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, see <http://www.gnu.org/licenses/>.
 *
 * Authors: Benjamin Otte <otte@gnome.org>
 */

#include <locale.h>

#include <gtk/gtk.h>

static void
inc_counter (gpointer data)
{
  guint *counter = data;

  *counter += 1;
}

static void
test_property (void)
{
  GValue value = G_VALUE_INIT;
  GtkExpression *expr;
  GtkExpressionWatch *watch;
  GtkStringFilter *filter;
  guint counter = 0;
  gboolean ret;

  filter = gtk_string_filter_new (NULL);
  expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");
  watch = gtk_expression_watch (expr, filter, inc_counter, &counter, NULL);

  ret = gtk_expression_evaluate (expr, filter, &value);
  g_assert_true (ret);
  g_assert_cmpstr (g_value_get_string (&value), ==, NULL);
  g_value_unset (&value);

  gtk_string_filter_set_search (filter, "Hello World");
  g_assert_cmpint (counter, ==, 1);
  counter = 0;

  ret = gtk_expression_evaluate (expr, filter , &value);
  g_assert_true (ret);
  g_assert_cmpstr (g_value_get_string (&value), ==, "Hello World");
  g_value_unset (&value);

  gtk_expression_watch_unwatch (watch);
  g_assert_cmpint (counter, ==, 0);

  gtk_expression_unref (expr);
  g_object_unref (filter);
}

static void
test_interface_property (void)
{
  GtkExpression *expr;

  expr = gtk_property_expression_new (GTK_TYPE_ORIENTABLE, NULL, "orientation");
  g_assert_cmpstr (gtk_property_expression_get_pspec (expr)->name, ==, "orientation");
  gtk_expression_unref (expr);
}

static char *
print_filter_info (GtkStringFilter         *filter,
                   const char              *search,
                   gboolean                 ignore_case,
                   GtkStringFilterMatchMode match_mode)
{
  g_assert_cmpstr (search, ==, gtk_string_filter_get_search (filter));
  g_assert_cmpint (ignore_case, ==, gtk_string_filter_get_ignore_case (filter));
  g_assert_cmpint (match_mode, ==, gtk_string_filter_get_match_mode (filter));

  return g_strdup ("OK");
}

static void
test_cclosure (void)
{
  GValue value = G_VALUE_INIT;
  GtkExpression *expr, *pexpr[3];
  GtkExpressionWatch *watch;
  GtkStringFilter *filter;
  guint counter = 0;
  gboolean ret;

  filter = GTK_STRING_FILTER (gtk_string_filter_new (NULL));
  pexpr[0] = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");
  pexpr[1] = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "ignore-case");
  pexpr[2] = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "match-mode");
  expr = gtk_cclosure_expression_new (G_TYPE_STRING,
                                      NULL,
                                      3,
                                      pexpr,
                                      G_CALLBACK (print_filter_info),
                                      NULL,
                                      NULL);
  watch = gtk_expression_watch (expr, filter, inc_counter, &counter, NULL);

  ret = gtk_expression_evaluate (expr, filter, &value);
  g_assert_true (ret);
  g_assert_cmpstr (g_value_get_string (&value), ==, "OK");
  g_value_unset (&value);

  gtk_string_filter_set_search (filter, "Hello World");
  g_assert_cmpint (counter, ==, 1);
  ret = gtk_expression_evaluate (expr, filter , &value);
  g_assert_true (ret);
  g_assert_cmpstr (g_value_get_string (&value), ==, "OK");
  g_value_unset (&value);

  gtk_string_filter_set_ignore_case (filter, FALSE);
  g_assert_cmpint (counter, ==, 2);
  ret = gtk_expression_evaluate (expr, filter , &value);
  g_assert_true (ret);
  g_assert_cmpstr (g_value_get_string (&value), ==, "OK");
  g_value_unset (&value);

  gtk_string_filter_set_search (filter, "Hello");
  gtk_string_filter_set_ignore_case (filter, TRUE);
  gtk_string_filter_set_match_mode (filter, GTK_STRING_FILTER_MATCH_MODE_EXACT);
  g_assert_cmpint (counter, ==, 5);
  ret = gtk_expression_evaluate (expr, filter , &value);
  g_assert_true (ret);
  g_assert_cmpstr (g_value_get_string (&value), ==, "OK");
  g_value_unset (&value);

  gtk_expression_watch_unwatch (watch);
  g_assert_cmpint (counter, ==, 5);

  gtk_expression_unref (expr);
  g_object_unref (filter);
}

static char *
make_string (void)
{
  return g_strdup ("Hello");
}

static void
test_closure (void)
{
  GValue value = G_VALUE_INIT;
  GtkExpression *expr;
  GClosure *closure;
  gboolean ret;

  closure = g_cclosure_new (G_CALLBACK (make_string), NULL, NULL);
  expr = gtk_closure_expression_new (G_TYPE_STRING, closure, 0, NULL);
  ret = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_true (ret);
  g_assert_cmpstr (g_value_get_string (&value), ==, "Hello");
  g_value_unset (&value);

  gtk_expression_unref (expr);
}

static void
test_constant (void)
{
  GtkExpression *expr;
  GValue value = G_VALUE_INIT;
  const GValue *v;
  gboolean res;

  expr = gtk_constant_expression_new (G_TYPE_INT, 22);
  g_assert_cmpint (gtk_expression_get_value_type (expr), ==, G_TYPE_INT);
  g_assert_true (gtk_expression_is_static (expr));

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_true (res);
  g_assert_cmpint (g_value_get_int (&value), ==, 22);

  v = gtk_constant_expression_get_value (expr);
  g_assert_cmpint (g_value_get_int (v), ==, 22);

  gtk_expression_unref (expr);
}

/* Test that object expressions fail to evaluate when
 * the object is gone.
 */
static void
test_object (void)
{
  GtkExpression *expr;
  GObject *obj;
  GValue value = G_VALUE_INIT;
  gboolean res;
  GObject *o;

  obj = G_OBJECT (gtk_string_filter_new (NULL));

  expr = gtk_object_expression_new (obj);
  g_assert_true (!gtk_expression_is_static (expr));
  g_assert_cmpint (gtk_expression_get_value_type (expr), ==, GTK_TYPE_STRING_FILTER);

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_true (res);
  g_assert_true (g_value_get_object (&value) == obj);
  g_value_unset (&value);

  o = gtk_object_expression_get_object (expr);
  g_assert_true (o == obj);

  g_clear_object (&obj);
  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_false (res);

  gtk_expression_unref (expr);
}

/* Some basic tests that nested expressions work; in particular test
 * that watching works when things change deeper in the expression tree
 *
 * The setup we use is GtkFilterListModel -> GtkFilter -> "search" property,
 * which gives us an expression tree like
 *
 * GtkPropertyExpression "search"
 *    -> GtkPropertyExpression "filter"
 *         -> GtkObjectExpression listmodel
 *
 * We test setting both the search property and the filter property.
 */
static void
test_nested (void)
{
  GtkExpression *list_expr;
  GtkExpression *filter_expr;
  GtkExpression *expr;
  GtkStringFilter *filter;
  GListModel *list;
  GtkFilterListModel *filtered;
  GValue value = G_VALUE_INIT;
  gboolean res;
  GtkExpressionWatch *watch;
  guint counter = 0;

  filter = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter, "word");
  list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter)));

  list_expr = gtk_object_expression_new (G_OBJECT (filtered));
  filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL, list_expr, "filter");
  expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, filter_expr, "search");

  g_assert_true (!gtk_expression_is_static (expr));
  g_assert_cmpint (gtk_expression_get_value_type (expr), ==, G_TYPE_STRING);

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "word");
  g_value_unset (&value);

  watch = gtk_expression_watch (expr, NULL, inc_counter, &counter, NULL);
  gtk_string_filter_set_search (GTK_STRING_FILTER (filter), "salad");
  g_assert_cmpint (counter, ==, 1);
  counter = 0;

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "salad");
  g_value_unset (&value);

  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
  g_assert_cmpint (counter, ==, 0);

  g_clear_object (&filter);
  filter = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter, "salad");
  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
  g_assert_cmpint (counter, ==, 1);
  counter = 0;

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "salad");
  g_value_unset (&value);

  gtk_string_filter_set_search (filter, "bar");
  g_assert_cmpint (counter, ==, 1);
  counter = 0;

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "bar");
  g_value_unset (&value);

  gtk_filter_list_model_set_filter (filtered, NULL);
  g_assert_cmpint (counter, ==, 1);
  counter = 0;

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_false (res);

  gtk_expression_watch_unwatch (watch);
  g_assert_cmpint (counter, ==, 0);

  g_object_unref (filtered);
  gtk_expression_unref (expr);
}

/* This test uses the same setup as the last test, but
 * passes the filter as the "this" object when creating
 * the watch.
 *
 * So when we set a new filter and the old one gets desroyed,
 * the watch should invalidate itself because its this object
 * is gone.
 */
static void
test_nested_this_destroyed (void)
{
  GtkExpression *list_expr;
  GtkExpression *filter_expr;
  GtkExpression *expr;
  GtkStringFilter *filter;
  GListModel *list;
  GtkFilterListModel *filtered;
  GValue value = G_VALUE_INIT;
  gboolean res;
  GtkExpressionWatch *watch;
  guint counter = 0;

  filter = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter, "word");
  list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter)));

  list_expr = gtk_object_expression_new (G_OBJECT (filtered));
  filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL, list_expr, "filter");
  expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, filter_expr, "search");

  watch = gtk_expression_watch (expr, filter, inc_counter, &counter, NULL);
  gtk_expression_watch_ref (watch);
  res = gtk_expression_watch_evaluate (watch, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "word");
  g_value_unset (&value);

  g_clear_object (&filter);
  g_assert_cmpint (counter, ==, 0);

  filter = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter, "salad");
  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter));
  g_assert_cmpint (counter, ==, 1);
  counter = 0;

  res = gtk_expression_watch_evaluate (watch, &value);
  g_assert_false (res);

  gtk_string_filter_set_search (filter, "bar");
  g_assert_cmpint (counter, ==, 0);

  gtk_filter_list_model_set_filter (filtered, NULL);
  g_assert_cmpint (counter, ==, 0);

  res = gtk_expression_watch_evaluate (watch, &value);
  g_assert_false (res);
  g_assert_false (G_IS_VALUE (&value));

  /* We unwatch on purpose here to make sure it doesn't do bad things. */
  gtk_expression_watch_unwatch (watch);
  gtk_expression_watch_unref (watch);
  g_assert_cmpint (counter, ==, 0);

  g_object_unref (filtered);
  g_object_unref (filter);
  gtk_expression_unref (expr);
}

/* Test that property expressions fail to evaluate if the
 * expression evaluates to an object of the wrong type
 */
static void
test_type_mismatch (void)
{
  GtkFilter *filter;
  GtkExpression *expr;
  GValue value = G_VALUE_INIT;
  gboolean res;

  filter = GTK_FILTER (gtk_any_filter_new ());

  expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_constant_expression_new (GTK_TYPE_ANY_FILTER, filter), "search");

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_false (res);
  g_assert_false (G_IS_VALUE (&value));

  gtk_expression_unref (expr);
  g_object_unref (filter);
}

/* Some basic tests around 'this' */
static void
test_this (void)
{
  GtkStringFilter *filter;
  GtkStringFilter *filter2;
  GtkExpression *expr;
  GValue value = G_VALUE_INIT;
  gboolean res;

  expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");

  filter = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter, "word");

  filter2 = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter2, "sausage");

  res = gtk_expression_evaluate (expr, filter, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "word");
  g_value_unset (&value);

  res = gtk_expression_evaluate (expr, filter2, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "sausage");
  g_value_unset (&value);

  gtk_expression_unref (expr);
  g_object_unref (filter2);
  g_object_unref (filter);
}

/* Check that even for static expressions, watches can be created
 * and destroying the "this" argument does invalidate the
 * expression.
 */
static void
test_constant_watch_this_destroyed (void)
{
  GtkExpression *expr;
  GObject *this;
  guint counter = 0;

  this = g_object_new (G_TYPE_OBJECT, NULL);
  expr = gtk_constant_expression_new (G_TYPE_INT, 42);
  gtk_expression_watch (expr, this, inc_counter, &counter, NULL);
  g_assert_cmpint (counter, ==, 0);

  g_clear_object (&this);
  g_assert_cmpint (counter, ==, 1);

  gtk_expression_unref (expr);
}

/* Basic test of gtk_expression_bind */
static void
test_bind (void)
{
  GtkStringFilter *target;
  GtkStringFilter *source;
  GtkExpression *expr;
  GtkExpressionWatch *watch;
  GValue value = G_VALUE_INIT;
  gboolean res;

  expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, NULL, "search");

  target = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (target, "word");
  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "word");

  source = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (source, "sausage");

  watch = gtk_expression_bind (expr, target, "search", source);
  gtk_expression_watch_ref (watch);
  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "sausage");

  gtk_string_filter_set_search (source, "salad");
  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "salad");
  res = gtk_expression_watch_evaluate (watch, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "salad"); 
  g_value_unset (&value);

  g_object_unref (source);
  g_assert_cmpstr (gtk_string_filter_get_search (target), ==, "salad");
  res = gtk_expression_watch_evaluate (watch, &value);
  g_assert_false (res);
  g_assert_false (G_IS_VALUE (&value));

  g_object_unref (target);
  gtk_expression_watch_unref (watch);
}

/* Another test of bind, this time we watch ourselves */
static void
test_bind_self (void)
{
  GtkStringFilter *filter;
  GtkExpression *expr;

  expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER,
                                      NULL,
                                      "ignore-case");

  filter = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter, "word");
  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "word");

  gtk_expression_bind (expr, filter, "search", filter);
  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "TRUE");

  g_object_unref (filter);
}

/* Test bind does the right memory management if the target's
 * dispose() kills the source */
static void
test_bind_child (void)
{
  GtkStringFilter *filter;
  GtkFilterListModel *child, *target;
  GtkExpression *expr;

  expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL,
                                      NULL,
                                      "filter");

  filter = gtk_string_filter_new (NULL);
  child = gtk_filter_list_model_new (NULL, GTK_FILTER (filter));
  target = gtk_filter_list_model_new (G_LIST_MODEL (child), NULL);

  gtk_expression_bind (expr, target, "filter", child);
  g_assert_true (gtk_filter_list_model_get_filter (child) == gtk_filter_list_model_get_filter (target));

  filter = gtk_string_filter_new (NULL);
  gtk_filter_list_model_set_filter (child, GTK_FILTER (filter));
  g_assert_true (GTK_FILTER (filter) == gtk_filter_list_model_get_filter (target));
  g_assert_true (gtk_filter_list_model_get_filter (child) == gtk_filter_list_model_get_filter (target));
  g_object_unref (filter);

  g_object_unref (target);
}

/* Another test of gtk_expression_bind that exercises the subwatch code paths */
static void
test_nested_bind (void)
{
  GtkStringFilter *filter;
  GtkStringFilter *filter2;
  GtkStringFilter *filter3;
  GListModel *list;
  GtkFilterListModel *filtered;
  GtkExpression *expr;
  GtkExpression *filter_expr;
  gboolean res;
  GValue value = G_VALUE_INIT;

  filter2 = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter2, "sausage");

  list = G_LIST_MODEL (g_list_store_new (G_TYPE_OBJECT));
  filtered = gtk_filter_list_model_new (list, g_object_ref (GTK_FILTER (filter2)));

  filter_expr = gtk_property_expression_new (GTK_TYPE_FILTER_LIST_MODEL,
                                             gtk_object_expression_new (G_OBJECT (filtered)),
                                             "filter");
  expr = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_expression_ref (filter_expr), "search");

  filter = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter, "word");
  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "word");

  gtk_expression_bind (gtk_expression_ref (expr), filter, "search", NULL);

  gtk_string_filter_set_search (filter2, "sausage");
  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "sausage");

  filter3 = gtk_string_filter_new (NULL);
  gtk_string_filter_set_search (filter3, "banana");
  gtk_filter_list_model_set_filter (filtered, GTK_FILTER (filter3));

  /* check that the expressions evaluate correctly */
  res = gtk_expression_evaluate (filter_expr, NULL, &value);
  g_assert_true (res);
  g_assert_true (g_value_get_object (&value) == filter3);
  g_value_unset (&value);

  res = gtk_expression_evaluate (expr, NULL, &value);
  g_assert_true (res);
  g_assert_cmpstr (g_value_get_string (&value), ==, "banana");
  g_value_unset (&value);

  /* and the bind too */
  g_assert_cmpstr (gtk_string_filter_get_search (filter), ==, "banana");

  g_object_unref (filter);
  g_object_unref (filter2);
  g_object_unref (filter3);
  g_object_unref (filtered);

  gtk_expression_unref (expr);
  gtk_expression_unref (filter_expr);
}

static char *
some_cb (gpointer    this,
         const char *search,
         gboolean    ignore_case,
         gpointer    data)
{
  if (!search)
    return NULL;

  if (ignore_case)
    return g_utf8_strdown (search, -1);
  else
    return g_strdup (search);
}

/* Test that things work as expected when the same object is used multiple times in an
 * expression or its subexpressions.
 */
static void
test_double_bind (void)
{
  GtkStringFilter *filter1;
  GtkStringFilter *filter2;
  GtkExpression *expr;
  GtkExpression *filter_expr;
  GtkExpression *params[2];

  filter1 = gtk_string_filter_new (NULL);
  filter2 = gtk_string_filter_new (NULL);

  filter_expr = gtk_object_expression_new (G_OBJECT (filter1));

  params[0] = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_expression_ref (filter_expr), "search");
  params[1] = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_expression_ref (filter_expr), "ignore-case");
  expr = gtk_cclosure_expression_new (G_TYPE_STRING,
                                      NULL,
                                      2, params,
                                      (GCallback)some_cb,
                                      NULL, NULL);

  gtk_expression_bind (gtk_expression_ref (expr), filter2, "search", NULL);

  gtk_string_filter_set_search (filter1, "Banana");
  g_assert_cmpstr (gtk_string_filter_get_search (filter2), ==, "banana");

  gtk_string_filter_set_ignore_case (filter1, FALSE);
  g_assert_cmpstr (gtk_string_filter_get_search (filter2), ==, "Banana");

  gtk_expression_unref (expr);
  gtk_expression_unref (filter_expr);

  g_object_unref (filter1);
  g_object_unref (filter2);
}

/* Test that having multiple binds on the same object works. */
static void
test_binds (void)
{
  GtkStringFilter *filter1;
  GtkStringFilter *filter2;
  GtkStringFilter *filter3;
  GtkExpression *expr;
  GtkExpression *expr2;
  GtkExpression *filter1_expr;
  GtkExpression *filter2_expr;
  GtkExpression *params[2];

  filter1 = gtk_string_filter_new (NULL);
  filter2 = gtk_string_filter_new (NULL);
  filter3 = gtk_string_filter_new (NULL);

  filter1_expr = gtk_object_expression_new (G_OBJECT (filter1));
  filter2_expr = gtk_object_expression_new (G_OBJECT (filter2));

  params[0] = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_expression_ref (filter1_expr), "search");
  params[1] = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_expression_ref (filter2_expr), "ignore-case");
  expr = gtk_cclosure_expression_new (G_TYPE_STRING,
                                      NULL,
                                      2, params,
                                      (GCallback)some_cb,
                                      NULL, NULL);

  expr2 = gtk_property_expression_new (GTK_TYPE_STRING_FILTER, gtk_expression_ref (filter2_expr), "ignore-case");

  g_assert_true (gtk_property_expression_get_expression (expr2) == filter2_expr);
  g_assert_cmpstr (gtk_property_expression_get_pspec (expr2)->name, ==, "ignore-case");

  gtk_expression_bind (gtk_expression_ref (expr), filter3, "search", NULL);
  gtk_expression_bind (gtk_expression_ref (expr2), filter3, "ignore-case", NULL);

  gtk_string_filter_set_search (filter1, "Banana");
  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "banana");
  g_assert_true (gtk_string_filter_get_ignore_case (filter3));

  gtk_string_filter_set_ignore_case (filter2, FALSE);
  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "Banana");
  g_assert_false (gtk_string_filter_get_ignore_case (filter3));

  /* invalidate the first bind */
  g_object_unref (filter1);

  gtk_string_filter_set_ignore_case (filter2, TRUE);
  g_assert_cmpstr (gtk_string_filter_get_search (filter3), ==, "Banana");
  g_assert_true (gtk_string_filter_get_ignore_case (filter3));

  gtk_expression_unref (expr);
  gtk_expression_unref (expr2);
  gtk_expression_unref (filter1_expr);
  gtk_expression_unref (filter2_expr);

  g_object_unref (filter2);
  g_object_unref (filter3);
}

/* test that binds work ok with object expressions */
static void
test_bind_object (void)
{
  GtkStringFilter *filter;
  GListStore *store;
  GtkFilterListModel *model;
  GtkExpression *expr;

  filter = gtk_string_filter_new (NULL);
  store = g_list_store_new (G_TYPE_OBJECT);
  model = gtk_filter_list_model_new (G_LIST_MODEL (store), NULL);

  expr = gtk_object_expression_new (G_OBJECT (filter));

  gtk_expression_bind (gtk_expression_ref (expr), model, "filter", NULL);

  g_assert_true (gtk_filter_list_model_get_filter (model) == GTK_FILTER (filter));

  g_object_unref (filter);

  g_assert_true (gtk_filter_list_model_get_filter (model) == GTK_FILTER (filter));

  gtk_expression_unref (expr);
  g_object_unref (model);
}

static void
test_value (void)
{
  GValue value = G_VALUE_INIT;
  GtkExpression *expr;

  expr = gtk_constant_expression_new (G_TYPE_INT, 22);

  g_value_init (&value, GTK_TYPE_EXPRESSION);
  gtk_value_take_expression (&value, expr);
  g_assert_true (G_VALUE_TYPE (&value) == GTK_TYPE_EXPRESSION);

  expr = gtk_value_dup_expression (&value);
  gtk_expression_unref (expr);

  expr = gtk_constant_expression_new (G_TYPE_INT, 23);
  gtk_value_set_expression (&value, expr);
  gtk_expression_unref (expr);

  g_value_unset (&value);
}

int
main (int argc, char *argv[])
{
  gtk_test_init (&argc, &argv, NULL);
  setlocale (LC_ALL, "C");

  g_test_add_func ("/expression/property", test_property);
  g_test_add_func ("/expression/interface-property", test_interface_property);
  g_test_add_func ("/expression/cclosure", test_cclosure);
  g_test_add_func ("/expression/closure", test_closure);
  g_test_add_func ("/expression/constant", test_constant);
  g_test_add_func ("/expression/constant-watch-this-destroyed", test_constant_watch_this_destroyed);
  g_test_add_func ("/expression/object", test_object);
  g_test_add_func ("/expression/nested", test_nested);
  g_test_add_func ("/expression/nested-this-destroyed", test_nested_this_destroyed);
  g_test_add_func ("/expression/type-mismatch", test_type_mismatch);
  g_test_add_func ("/expression/this", test_this);
  g_test_add_func ("/expression/bind", test_bind);
  g_test_add_func ("/expression/bind-self", test_bind_self);
  g_test_add_func ("/expression/bind-child", test_bind_child);
  g_test_add_func ("/expression/nested-bind", test_nested_bind);
  g_test_add_func ("/expression/double-bind", test_double_bind);
  g_test_add_func ("/expression/binds", test_binds);
  g_test_add_func ("/expression/bind-object", test_bind_object);
  g_test_add_func ("/expression/value", test_value);

  return g_test_run ();
}