#define GLIB_DISABLE_DEPRECATION_WARNINGS

#include <glib-object.h>

#include <stdlib.h>

static void

test_param_value (void)

{

  GParamSpec *p, *p2;

  GParamSpec *pp;

  GValue value = G_VALUE_INIT;

  g_value_init (&value, G_TYPE_PARAM);

  g_assert (G_VALUE_HOLDS_PARAM (&value));

  p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);

  g_value_take_param (&value, p);

  p2 = g_value_get_param (&value);

  g_assert (p2 == p);

  pp = g_param_spec_uint ("my-uint", "My UInt", "Blurb", 0, 10, 5, G_PARAM_READWRITE);

  g_value_set_param (&value, pp);

  p2 = g_value_dup_param (&value);

  g_assert (p2 == pp); /* param specs use ref/unref for copy/free */

  g_param_spec_unref (p2);

  g_value_unset (&value);

  g_param_spec_unref (pp);

}

static gint destroy_count;

static void

my_destroy (gpointer data)

{

  destroy_count++;

}

static void

test_param_qdata (void)

{

  GParamSpec *p;

  gchar *bla;

  GQuark q;

  q = g_quark_from_string ("bla");

  p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);

  g_param_spec_set_qdata (p, q, "bla");

  bla = g_param_spec_get_qdata (p, q);

  g_assert_cmpstr (bla, ==, "bla");

  g_assert_cmpint (destroy_count, ==, 0);

  g_param_spec_set_qdata_full (p, q, "bla", my_destroy);

  g_param_spec_set_qdata_full (p, q, "blabla", my_destroy);

  g_assert_cmpint (destroy_count, ==, 1);

  g_assert_cmpstr (g_param_spec_steal_qdata (p, q), ==, "blabla");

  g_assert_cmpint (destroy_count, ==, 1);

  g_assert (g_param_spec_get_qdata (p, q) == NULL);

  g_param_spec_ref_sink (p);

  g_param_spec_unref (p);

}

static void

test_param_validate (void)

{

  GParamSpec *p;

  GValue value = G_VALUE_INIT;

  p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);

  g_value_init (&value, G_TYPE_INT);

  g_value_set_int (&value, 100);

  g_assert (!g_param_value_defaults (p, &value));

  g_assert (g_param_value_validate (p, &value));

  g_assert_cmpint (g_value_get_int (&value), ==, 20);

  g_param_value_set_default (p, &value);

  g_assert (g_param_value_defaults (p, &value));

  g_assert_cmpint (g_value_get_int (&value), ==, 10);

  g_param_spec_unref (p);

}

static void

test_param_strings (void)

{

  GParamSpec *p;

  /* test canonicalization */

  p = g_param_spec_int ("my_int:bla", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);

  g_assert_cmpstr (g_param_spec_get_name (p), ==, "my-int-bla");

  g_assert_cmpstr (g_param_spec_get_nick (p), ==, "My Int");

  g_assert_cmpstr (g_param_spec_get_blurb (p), ==, "Blurb");

  g_param_spec_unref (p);

  /* test nick defaults to name */

  p = g_param_spec_int ("my-int", NULL, NULL, 0, 20, 10, G_PARAM_READWRITE);

  g_assert_cmpstr (g_param_spec_get_name (p), ==, "my-int");

  g_assert_cmpstr (g_param_spec_get_nick (p), ==, "my-int");

  g_assert (g_param_spec_get_blurb (p) == NULL);

  g_param_spec_unref (p);

}

static void

test_param_convert (void)

{

  GParamSpec *p;

  GValue v1 = G_VALUE_INIT;

  GValue v2 = G_VALUE_INIT;

  p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);

  g_value_init (&v1, G_TYPE_UINT);

  g_value_set_uint (&v1, 43);

  g_value_init (&v2, G_TYPE_INT);

  g_value_set_int (&v2, -4);

  g_assert (!g_param_value_convert (p, &v1, &v2, TRUE));

  g_assert_cmpint (g_value_get_int (&v2), ==, -4);

  g_assert (g_param_value_convert (p, &v1, &v2, FALSE));

  g_assert_cmpint (g_value_get_int (&v2), ==, 20);

  g_param_spec_unref (p);

}

static void

test_value_transform (void)

{

  GValue src = G_VALUE_INIT;

  GValue dest = G_VALUE_INIT;

#define CHECK_INT_CONVERSION(type, getter, value)                       \

  g_assert (g_value_type_transformable (G_TYPE_INT, type));             \

  g_value_init (&src, G_TYPE_INT);                                      \

  g_value_init (&dest, type);                                           \

  g_value_set_int (&src, value);                                        \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  /* Keep a check for an integer in the range of 0-127 so we're

   * still testing g_value_get_char().  See

   * https://bugzilla.gnome.org/show_bug.cgi?id=659870

   * for why it is broken.

   */

  CHECK_INT_CONVERSION(G_TYPE_CHAR, char, 124)

  CHECK_INT_CONVERSION(G_TYPE_CHAR, schar, -124)

  CHECK_INT_CONVERSION(G_TYPE_CHAR, schar, 124)

  CHECK_INT_CONVERSION(G_TYPE_UCHAR, uchar, 0)

  CHECK_INT_CONVERSION(G_TYPE_UCHAR, uchar, 255)

  CHECK_INT_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_INT_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_INT_CONVERSION(G_TYPE_UINT, uint, 0)

  CHECK_INT_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_INT_CONVERSION(G_TYPE_LONG, long, -12345678)

  CHECK_INT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_INT_CONVERSION(G_TYPE_INT64, int64, -12345678)

  CHECK_INT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_INT_CONVERSION(G_TYPE_FLOAT, float, 12345678)

  CHECK_INT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)

#define CHECK_UINT_CONVERSION(type, getter, value)                      \

  g_assert (g_value_type_transformable (G_TYPE_UINT, type));            \

  g_value_init (&src, G_TYPE_UINT);                                     \

  g_value_init (&dest, type);                                           \

  g_value_set_uint (&src, value);                                       \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  CHECK_UINT_CONVERSION(G_TYPE_CHAR, char, 124)

  CHECK_UINT_CONVERSION(G_TYPE_CHAR, char, 124)

  CHECK_UINT_CONVERSION(G_TYPE_UCHAR, uchar, 0)

  CHECK_UINT_CONVERSION(G_TYPE_UCHAR, uchar, 255)

  CHECK_UINT_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_UINT_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_UINT_CONVERSION(G_TYPE_UINT, uint, 0)

  CHECK_UINT_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_UINT_CONVERSION(G_TYPE_LONG, long, 12345678)

  CHECK_UINT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_UINT_CONVERSION(G_TYPE_INT64, int64, 12345678)

  CHECK_UINT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_UINT_CONVERSION(G_TYPE_FLOAT, float, 12345678)

  CHECK_UINT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)

#define CHECK_LONG_CONVERSION(type, getter, value)                      \

  g_assert (g_value_type_transformable (G_TYPE_LONG, type));            \

  g_value_init (&src, G_TYPE_LONG);                                     \

  g_value_init (&dest, type);                                           \

  g_value_set_long (&src, value);                                       \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  CHECK_LONG_CONVERSION(G_TYPE_CHAR, schar, -124)

  CHECK_LONG_CONVERSION(G_TYPE_CHAR, schar, 124)

  CHECK_LONG_CONVERSION(G_TYPE_UCHAR, uchar, 0)

  CHECK_LONG_CONVERSION(G_TYPE_UCHAR, uchar, 255)

  CHECK_LONG_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_LONG_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_LONG_CONVERSION(G_TYPE_UINT, uint, 0)

  CHECK_LONG_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_LONG_CONVERSION(G_TYPE_LONG, long, -12345678)

  CHECK_LONG_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_LONG_CONVERSION(G_TYPE_INT64, int64, -12345678)

  CHECK_LONG_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_LONG_CONVERSION(G_TYPE_FLOAT, float, 12345678)

  CHECK_LONG_CONVERSION(G_TYPE_DOUBLE, double, 12345678)

#define CHECK_ULONG_CONVERSION(type, getter, value)                     \

  g_assert (g_value_type_transformable (G_TYPE_ULONG, type));           \

  g_value_init (&src, G_TYPE_ULONG);                                    \

  g_value_init (&dest, type);                                           \

  g_value_set_ulong (&src, value);                                      \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  CHECK_ULONG_CONVERSION(G_TYPE_CHAR, char, 124)

  CHECK_ULONG_CONVERSION(G_TYPE_CHAR, char, 124)

  CHECK_ULONG_CONVERSION(G_TYPE_UCHAR, uchar, 0)

  CHECK_ULONG_CONVERSION(G_TYPE_UCHAR, uchar, 255)

  CHECK_ULONG_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_ULONG_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_ULONG_CONVERSION(G_TYPE_UINT, uint, 0)

  CHECK_ULONG_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_ULONG_CONVERSION(G_TYPE_LONG, long, 12345678)

  CHECK_ULONG_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_ULONG_CONVERSION(G_TYPE_INT64, int64, 12345678)

  CHECK_ULONG_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_ULONG_CONVERSION(G_TYPE_FLOAT, float, 12345678)

  CHECK_ULONG_CONVERSION(G_TYPE_DOUBLE, double, 12345678)

#define CHECK_INT64_CONVERSION(type, getter, value)                     \

  g_assert (g_value_type_transformable (G_TYPE_INT64, type));           \

  g_value_init (&src, G_TYPE_INT64);                                    \

  g_value_init (&dest, type);                                           \

  g_value_set_int64 (&src, value);                                      \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  CHECK_INT64_CONVERSION(G_TYPE_CHAR, schar, -124)

  CHECK_INT64_CONVERSION(G_TYPE_CHAR, schar, 124)

  CHECK_INT64_CONVERSION(G_TYPE_UCHAR, uchar, 0)

  CHECK_INT64_CONVERSION(G_TYPE_UCHAR, uchar, 255)

  CHECK_INT64_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_INT64_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_INT64_CONVERSION(G_TYPE_UINT, uint, 0)

  CHECK_INT64_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_INT64_CONVERSION(G_TYPE_LONG, long, -12345678)

  CHECK_INT64_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_INT64_CONVERSION(G_TYPE_INT64, int64, -12345678)

  CHECK_INT64_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_INT64_CONVERSION(G_TYPE_FLOAT, float, 12345678)

  CHECK_INT64_CONVERSION(G_TYPE_DOUBLE, double, 12345678)

#define CHECK_UINT64_CONVERSION(type, getter, value)                    \

  g_assert (g_value_type_transformable (G_TYPE_UINT64, type));          \

  g_value_init (&src, G_TYPE_UINT64);                                   \

  g_value_init (&dest, type);                                           \

  g_value_set_uint64 (&src, value);                                     \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  CHECK_UINT64_CONVERSION(G_TYPE_CHAR, schar, -124)

  CHECK_UINT64_CONVERSION(G_TYPE_CHAR, schar, 124)

  CHECK_UINT64_CONVERSION(G_TYPE_UCHAR, uchar, 0)

  CHECK_UINT64_CONVERSION(G_TYPE_UCHAR, uchar, 255)

  CHECK_UINT64_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_UINT64_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_UINT64_CONVERSION(G_TYPE_UINT, uint, 0)

  CHECK_UINT64_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_UINT64_CONVERSION(G_TYPE_LONG, long, -12345678)

  CHECK_UINT64_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_UINT64_CONVERSION(G_TYPE_INT64, int64, -12345678)

  CHECK_UINT64_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_UINT64_CONVERSION(G_TYPE_FLOAT, float, 12345678)

  CHECK_UINT64_CONVERSION(G_TYPE_DOUBLE, double, 12345678)

#define CHECK_FLOAT_CONVERSION(type, getter, value)                    \

  g_assert (g_value_type_transformable (G_TYPE_FLOAT, type));          \

  g_value_init (&src, G_TYPE_FLOAT);                                   \

  g_value_init (&dest, type);                                          \

  g_value_set_float (&src, value);                                     \

  g_assert (g_value_transform (&src, &dest));                          \

  g_assert_cmpfloat (g_value_get_##getter (&dest), ==, value);         \

  g_value_unset (&src;;                                                \

  g_value_unset (&dest);

  CHECK_FLOAT_CONVERSION(G_TYPE_CHAR, schar, -124)

  CHECK_FLOAT_CONVERSION(G_TYPE_CHAR, schar, 124)

  CHECK_FLOAT_CONVERSION(G_TYPE_UCHAR, uchar, 0)

  CHECK_FLOAT_CONVERSION(G_TYPE_UCHAR, uchar, 255)

  CHECK_FLOAT_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_FLOAT_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_FLOAT_CONVERSION(G_TYPE_UINT, uint, 0)

  CHECK_FLOAT_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_FLOAT_CONVERSION(G_TYPE_LONG, long, -12345678)

  CHECK_FLOAT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_FLOAT_CONVERSION(G_TYPE_INT64, int64, -12345678)

  CHECK_FLOAT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_FLOAT_CONVERSION(G_TYPE_FLOAT, float, 12345678)

  CHECK_FLOAT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)

#define CHECK_DOUBLE_CONVERSION(type, getter, value)                    \

  g_assert (g_value_type_transformable (G_TYPE_DOUBLE, type));          \

  g_value_init (&src, G_TYPE_DOUBLE);                                   \

  g_value_init (&dest, type);                                           \

  g_value_set_double (&src, value);                                     \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpfloat (g_value_get_##getter (&dest), ==, value);          \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  CHECK_DOUBLE_CONVERSION(G_TYPE_CHAR, schar, -124)

  CHECK_DOUBLE_CONVERSION(G_TYPE_CHAR, schar, 124)

  CHECK_DOUBLE_CONVERSION(G_TYPE_UCHAR, uchar, 0)

  CHECK_DOUBLE_CONVERSION(G_TYPE_UCHAR, uchar, 255)

  CHECK_DOUBLE_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_DOUBLE_CONVERSION(G_TYPE_INT, int, 12345)

  CHECK_DOUBLE_CONVERSION(G_TYPE_UINT, uint, 0)

  CHECK_DOUBLE_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_DOUBLE_CONVERSION(G_TYPE_LONG, long, -12345678)

  CHECK_DOUBLE_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_DOUBLE_CONVERSION(G_TYPE_INT64, int64, -12345678)

  CHECK_DOUBLE_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_DOUBLE_CONVERSION(G_TYPE_FLOAT, float, 12345678)

  CHECK_DOUBLE_CONVERSION(G_TYPE_DOUBLE, double, 12345678)

#define CHECK_BOOLEAN_CONVERSION(type, setter, value)                   \

  g_assert (g_value_type_transformable (type, G_TYPE_BOOLEAN));         \

  g_value_init (&src, type);                                            \

  g_value_init (&dest, G_TYPE_BOOLEAN);                                 \

  g_value_set_##setter (&src, value);                                   \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpint (g_value_get_boolean (&dest), ==, TRUE);              \

  g_value_set_##setter (&src, 0);                                       \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpint (g_value_get_boolean (&dest), ==, FALSE);             \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  CHECK_BOOLEAN_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_BOOLEAN_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_BOOLEAN_CONVERSION(G_TYPE_LONG, long, -12345678)

  CHECK_BOOLEAN_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_BOOLEAN_CONVERSION(G_TYPE_INT64, int64, -12345678)

  CHECK_BOOLEAN_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

#define CHECK_STRING_CONVERSION(int_type, setter, int_value)            \

  g_assert (g_value_type_transformable (int_type, G_TYPE_STRING));      \

  g_value_init (&src, int_type);                                        \

  g_value_init (&dest, G_TYPE_STRING);                                  \

  g_value_set_##setter (&src, int_value);                               \

  g_assert (g_value_transform (&src, &dest));                           \

  g_assert_cmpstr (g_value_get_string (&dest), ==, #int_value);         \

  g_value_unset (&src;;                                                 \

  g_value_unset (&dest);

  CHECK_STRING_CONVERSION(G_TYPE_INT, int, -12345)

  CHECK_STRING_CONVERSION(G_TYPE_UINT, uint, 12345)

  CHECK_STRING_CONVERSION(G_TYPE_LONG, long, -12345678)

  CHECK_STRING_CONVERSION(G_TYPE_ULONG, ulong, 12345678)

  CHECK_STRING_CONVERSION(G_TYPE_INT64, int64, -12345678)

  CHECK_STRING_CONVERSION(G_TYPE_UINT64, uint64, 12345678)

  CHECK_STRING_CONVERSION(G_TYPE_FLOAT, float, 0.500000)

  CHECK_STRING_CONVERSION(G_TYPE_DOUBLE, double, -1.234567)

  g_assert (!g_value_type_transformable (G_TYPE_STRING, G_TYPE_CHAR));

  g_value_init (&src, G_TYPE_STRING);

  g_value_init (&dest, G_TYPE_CHAR);

  g_value_set_static_string (&src, "bla");

  g_value_set_schar (&dest, 'c');

  g_assert (!g_value_transform (&src, &dest));

  g_assert_cmpint (g_value_get_schar (&dest), ==, 'c');

  g_value_unset (&src;;

  g_value_unset (&dest);

}

/* We create some dummy objects with a simple relationship:

 *

 *           GObject

 *          /       \

 * TestObjectA     TestObjectC

 *      |

 * TestObjectB

 *

 * ie: TestObjectB is a subclass of TestObjectA and TestObjectC is

 * related to neither.

 */

static GType test_object_a_get_type (void);

typedef GObject TestObjectA; typedef GObjectClass TestObjectAClass;

G_DEFINE_TYPE (TestObjectA, test_object_a, G_TYPE_OBJECT)

static void test_object_a_class_init (TestObjectAClass *class) { }

static void test_object_a_init (TestObjectA *a) { }

static GType test_object_b_get_type (void);

typedef GObject TestObjectB; typedef GObjectClass TestObjectBClass;

G_DEFINE_TYPE (TestObjectB, test_object_b, test_object_a_get_type ())

static void test_object_b_class_init (TestObjectBClass *class) { }

static void test_object_b_init (TestObjectB *b) { }

static GType test_object_c_get_type (void);

typedef GObject TestObjectC; typedef GObjectClass TestObjectCClass;

G_DEFINE_TYPE (TestObjectC, test_object_c, G_TYPE_OBJECT)

static void test_object_c_class_init (TestObjectCClass *class) { }

static void test_object_c_init (TestObjectC *c) { }

/* We create an interface and programmatically populate it with

 * properties of each of the above type, with various flag combinations.

 *

 * Properties are named like "type-perm" where type is 'a', 'b' or 'c'

 * and perm is a series of characters, indicating the permissions:

 *

 *   - 'r': readable

 *   - 'w': writable

 *   - 'c': construct

 *   - 'C': construct-only

 *

 * It doesn't make sense to have a property that is neither readable nor

 * writable.  It is also not valid to have construct or construct-only

 * on read-only params.  Finally, it is invalid to have both construct

 * and construct-only specified, so we do not consider those cases.

 * That gives us 7 possible permissions:

 *

 *     'r', 'w', 'rw', 'wc', 'rwc', 'wC', 'rwC'

 *

 * And 9 impossible ones:

 *

 *     '', 'c', 'rc', 'C', 'rC', 'cC', 'rcC', 'wcC', rwcC'

 *

 * For a total of 16 combinations.

 *

 * That gives a total of 48 (16 * 3) possible flag/type combinations, of

 * which 27 (9 * 3) are impossible to install.

 *

 * That gives 21 (7 * 3) properties that will be installed.

 */

typedef GTypeInterface TestInterfaceInterface;

static GType test_interface_get_type (void);

//typedef struct _TestInterface TestInterface;

G_DEFINE_INTERFACE (TestInterface, test_interface, G_TYPE_OBJECT)

static void

test_interface_default_init (TestInterfaceInterface *iface)

{

  const gchar *names[] = { "a", "b", "c" };

  const gchar *perms[] = { NULL, "r",  "w",  "rw",

                           NULL, NULL, "wc", "rwc",

                           NULL, NULL, "wC", "rwC",

                           NULL, NULL, NULL, NULL };

  const GType types[] = { test_object_a_get_type (), test_object_b_get_type (), test_object_c_get_type () };

  guint i, j;

  for (i = 0; i < G_N_ELEMENTS (types); i++)

    for (j = 0; j < G_N_ELEMENTS (perms); j++)

      {

        gchar prop_name[10];

        GParamSpec *pspec;

        if (perms[j] == NULL)

          {

            if (!g_test_undefined ())

              continue;

            /* we think that this is impossible.  make sure. */

            pspec = g_param_spec_object ("xyz", "xyz", "xyz", types[i], j);

            g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,

                                   "*assertion*pspec->flags*failed*");

            g_object_interface_install_property (iface, pspec);

            g_test_assert_expected_messages ();

            g_param_spec_unref (pspec);

            continue;

          }

        /* install the property */

        g_snprintf (prop_name, sizeof prop_name, "%s-%s", names[i], perms[j]);

        pspec = g_param_spec_object (prop_name, prop_name, prop_name, types[i], j);

        g_object_interface_install_property (iface, pspec);

      }

}

/* We now have 21 properties.  Each property may be correctly

 * implemented with the following types:

 *

 *   Properties         Valid Types       Reason

 *

 *   a-r                a, b              Read only can provide subclasses

 *   a-w, wc, wC        a, GObject        Write only can accept superclasses

 *   a-rw, rwc, rwC     a                 Read-write must be exactly equal

 *

 *   b-r                b                 (as above)

 *   b-w, wc, wC        b, a, GObject

 *   b-rw, rwc, rwC     b

 *

 *   c-r                c                 (as above)

 *   c-wo, wc, wC       c, GObject

 *   c-rw, rwc, rwC     c

 *

 * We can express this in a 48-by-4 table where each row represents an

 * installed property and each column represents a type.  The value in

 * the table represents if it is valid to subclass the row's property

 * with the type of the column:

 *

 *   - 0:   invalid because the interface property doesn't exist (invalid flags)

 *   - 'v': valid

 *   - '=': invalid because of the type not being exactly equal

 *   - '<': invalid because of the type not being a subclass

 *   - '>': invalid because of the type not being a superclass

 *

 * We organise the table by interface property type ('a', 'b', 'c') then

 * by interface property flags.

 */

static gint valid_impl_types[48][4] = {

                    /* a    b    c    GObject */

    /* 'a-' */       { 0, },

    /* 'a-r' */      { 'v', 'v', '<', '<' },

    /* 'a-w' */      { 'v', '>', '>', 'v' },

    /* 'a-rw' */     { 'v', '=', '=', '=' },

    /* 'a-c */       { 0, },

    /* 'a-rc' */     { 0, },

    /* 'a-wc' */     { 'v', '>', '>', 'v' },

    /* 'a-rwc' */    { 'v', '=', '=', '=' },

    /* 'a-C */       { 0, },

    /* 'a-rC' */     { 0, },

    /* 'a-wC' */     { 'v', '>', '>', 'v' },

    /* 'a-rwC' */    { 'v', '=', '=', '=' },

    /* 'a-cC */      { 0, },

    /* 'a-rcC' */    { 0, },

    /* 'a-wcC' */    { 0, },

    /* 'a-rwcC' */   { 0, },

    /* 'b-' */       { 0, },

    /* 'b-r' */      { '<', 'v', '<', '<' },

    /* 'b-w' */      { 'v', 'v', '>', 'v' },

    /* 'b-rw' */     { '=', 'v', '=', '=' },

    /* 'b-c */       { 0, },

    /* 'b-rc' */     { 0, },

    /* 'b-wc' */     { 'v', 'v', '>', 'v' },

    /* 'b-rwc' */    { '=', 'v', '=', '=' },

    /* 'b-C */       { 0, },

    /* 'b-rC' */     { 0, },

    /* 'b-wC' */     { 'v', 'v', '>', 'v' },

    /* 'b-rwC' */    { '=', 'v', '=', '=' },

    /* 'b-cC */      { 0, },

    /* 'b-rcC' */    { 0, },

    /* 'b-wcC' */    { 0, },

    /* 'b-rwcC' */   { 0, },

    /* 'c-' */       { 0, },

    /* 'c-r' */      { '<', '<', 'v', '<' },

    /* 'c-w' */      { '>', '>', 'v', 'v' },

    /* 'c-rw' */     { '=', '=', 'v', '=' },

    /* 'c-c */       { 0, },

    /* 'c-rc' */     { 0, },

    /* 'c-wc' */     { '>', '>', 'v', 'v' },

    /* 'c-rwc' */    { '=', '=', 'v', '=' },

    /* 'c-C */       { 0, },

    /* 'c-rC' */     { 0, },

    /* 'c-wC' */     { '>', '>', 'v', 'v' },

    /* 'c-rwC' */    { '=', '=', 'v', '=' },

    /* 'c-cC */      { 0, },

    /* 'c-rcC' */    { 0, },

    /* 'c-wcC' */    { 0, },

    /* 'c-rwcC' */   { 0, }

};

/* We also try to change the flags.  We must ensure that all

 * implementations provide all functionality promised by the interface.

 * We must therefore never remove readability or writability (but we can

 * add them).  Construct-only is a restrictions that applies to

 * writability, so we can never add it unless writability was never

 * present in the first place, in which case "writable at construct

 * only" is still better than "not writable".

 *

 * The 'construct' flag is of interest only to the implementation.  It

 * may be changed at any time.

 *

 *   Properties         Valid Access      Reason

 *

 *   *-r                r, rw, rwc, rwC   Must keep readable, but can restrict newly-added writable

 *   *-w                w, rw, rwc        Must keep writable unrestricted

 *   *-rw               rw, rwc           Must not add any restrictions

 *   *-rwc              rw, rwc           Must not add any restrictions

 *   *-rwC              rw, rwc, rwC      Can remove 'construct-only' restriction

 *   *-wc               rwc, rw, w, wc    Can add readability

 *   *-wC               rwC, rw, w, wC    Can add readability or remove 'construct only' restriction

 *                        rwc, wc

 *

 * We can represent this with a 16-by-16 table.  The rows represent the

 * flags of the property on the interface.  The columns is the flags to

 * try to use when overriding the property.  The cell contents are:

 *

 *   - 0:   invalid because the interface property doesn't exist (invalid flags)

 *   - 'v': valid

 *   - 'i': invalid because the implementation flags are invalid

 *   - 'f': invalid because of the removal of functionality

 *   - 'r': invalid because of the addition of restrictions (ie: construct-only)

 *

 * We also ensure that removal of functionality is reported before

 * addition of restrictions, since this is a more basic problem.

 */

static gint valid_impl_flags[16][16] = {

                 /* ''   r    w    rw   c    rc   wc   rwc  C    rC   wC   rwC  cC   rcC  wcC  rwcC */

    /* '*-' */    { 0, },

    /* '*-r' */   { 'i', 'v', 'f', 'v', 'i', 'i', 'f', 'v', 'i', 'i', 'f', 'v', 'i', 'i', 'i', 'i' },

    /* '*-w' */   { 'i', 'f', 'v', 'v', 'i', 'i', 'v', 'v', 'i', 'i', 'r', 'r', 'i', 'i', 'i', 'i' },

    /* '*-rw' */  { 'i', 'f', 'f', 'v', 'i', 'i', 'f', 'v', 'i', 'i', 'f', 'r', 'i', 'i', 'i', 'i' },

    /* '*-c */    { 0, },

    /* '*-rc' */  { 0, },

    /* '*-wc' */  { 'i', 'f', 'v', 'v', 'i', 'i', 'v', 'v', 'i', 'i', 'r', 'r', 'i', 'i', 'i', 'i' },

    /* '*-rwc' */ { 'i', 'f', 'f', 'v', 'i', 'i', 'f', 'v', 'i', 'i', 'f', 'r', 'i', 'i', 'i', 'i' },

    /* '*-C */    { 0, },

    /* '*-rC' */  { 0, },

    /* '*-wC' */  { 'i', 'f', 'v', 'v', 'i', 'i', 'v', 'v', 'i', 'i', 'v', 'v', 'i', 'i', 'i', 'i' },

    /* '*-rwC' */ { 'i', 'f', 'f', 'v', 'i', 'i', 'f', 'v', 'i', 'i', 'f', 'v', 'i', 'i', 'i', 'i' },

};

static guint change_this_flag;

static guint change_this_type;

static guint use_this_flag;

static guint use_this_type;

typedef GObjectClass TestImplementationClass;

typedef GObject TestImplementation;

static void test_implementation_init (TestImplementation *impl) { }

static void test_implementation_iface_init (TestInterfaceInterface *iface) { }

static GType test_implementation_get_type (void);

G_DEFINE_TYPE_WITH_CODE (TestImplementation, test_implementation, G_TYPE_OBJECT,

                         G_IMPLEMENT_INTERFACE (test_interface_get_type (), test_implementation_iface_init))

static void test_implementation_class_init (TestImplementationClass *class)

{

  const gchar *names[] = { "a", "b", "c" };

  const gchar *perms[] = { NULL, "r",  "w",  "rw",

                           NULL, NULL, "wc", "rwc",

                           NULL, NULL, "wC", "rwC",

                           NULL, NULL, NULL, NULL };

  const GType types[] = { test_object_a_get_type (), test_object_b_get_type (),

                          test_object_c_get_type (), G_TYPE_OBJECT };

  gchar prop_name[10];

  GParamSpec *pspec;

  guint i, j;

  class->get_property = GINT_TO_POINTER (1);

  class->set_property = GINT_TO_POINTER (1);

  /* Install all of the non-modified properties or else GObject will

   * complain about non-implemented properties.

   */

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

    for (j = 0; j < G_N_ELEMENTS (perms); j++)

      {

        if (i == change_this_type && j == change_this_flag)

          continue;

        if (perms[j] != NULL)

          {

            /* override the property without making changes */

            g_snprintf (prop_name, sizeof prop_name, "%s-%s", names[i], perms[j]);

            g_object_class_override_property (class, 1, prop_name);

          }

      }

  /* Now try installing our modified property */

  if (perms[change_this_flag] == NULL)

    g_error ("Interface property does not exist");

  g_snprintf (prop_name, sizeof prop_name, "%s-%s", names[change_this_type], perms[change_this_flag]);

  pspec = g_param_spec_object (prop_name, prop_name, prop_name, types[use_this_type], use_this_flag);

  g_object_class_install_property (class, 1, pspec);

}

typedef struct {

  gint change_this_flag;

  gint change_this_type;

  gint use_this_flag;

  gint use_this_type;

} TestParamImplementData;

static void

test_param_implement_child (gconstpointer user_data)

{

  TestParamImplementData *data = (gpointer) user_data;

  /* GObject oddity: GObjectClass must be initialised before we can

   * initialise a GTypeInterface.

   */

  g_type_class_ref (G_TYPE_OBJECT);

  /* Bring up the interface first. */

  g_type_default_interface_ref (test_interface_get_type ());

  /* Copy the flags into the global vars so

   * test_implementation_class_init() will see them.

   */

  change_this_flag = data->change_this_flag;

  change_this_type = data->change_this_type;

  use_this_flag = data->use_this_flag;

  use_this_type = data->use_this_type;

  g_type_class_ref (test_implementation_get_type ());

}

static void

test_param_implement (void)

{

  gchar *test_path;

  for (change_this_flag = 0; change_this_flag < 16; change_this_flag++)

    for (change_this_type = 0; change_this_type < 3; change_this_type++)

      for (use_this_flag = 0; use_this_flag < 16; use_this_flag++)

        for (use_this_type = 0; use_this_type < 4; use_this_type++)

          {

            if (!g_test_undefined ())

              {

                /* only test the valid (defined) cases, e.g. under valgrind */

                if (valid_impl_flags[change_this_flag][use_this_flag] != 'v')

                  continue;

                if (valid_impl_types[change_this_type * 16 + change_this_flag][use_this_type] != 'v')

                  continue;

              }

            test_path = g_strdup_printf ("/param/implement/subprocess/%d-%d-%d-%d",

                                         change_this_flag, change_this_type,

                                         use_this_flag, use_this_type);

            g_test_trap_subprocess (test_path, G_TIME_SPAN_SECOND, 0);

            g_free (test_path);

            /* We want to ensure that any flags mismatch problems are reported first. */

            switch (valid_impl_flags[change_this_flag][use_this_flag])

              {

              case 0:

                /* make sure the other table agrees */

                g_assert (valid_impl_types[change_this_type * 16 + change_this_flag][use_this_type] == 0);

                g_test_trap_assert_failed ();

                g_test_trap_assert_stderr ("*Interface property does not exist*");

                continue;

              case 'i':

                g_test_trap_assert_failed ();

                g_test_trap_assert_stderr ("*g_object_class_install_property*");

                continue;

              case 'f':

                g_test_trap_assert_failed ();

                g_test_trap_assert_stderr ("*remove functionality*");

                continue;

              case 'r':

                g_test_trap_assert_failed ();

                g_test_trap_assert_stderr ("*introduce additional restrictions*");

                continue;

              case 'v':

                break;

              }

            /* Next, we check if there should have been a type error. */

            switch (valid_impl_types[change_this_type * 16 + change_this_flag][use_this_type])

              {

              case 0:

                /* this should have been caught above */

                g_assert_not_reached ();

              case '=':

                g_test_trap_assert_failed ();

                g_test_trap_assert_stderr ("*exactly equal*");

                continue;

              case '<':

                g_test_trap_assert_failed ();

                g_test_trap_assert_stderr ("*equal to or more restrictive*");

                continue;

              case '>':

                g_test_trap_assert_failed ();

                g_test_trap_assert_stderr ("*equal to or less restrictive*");

                continue;

              case 'v':

                break;

              }

            g_test_trap_assert_passed ();

          }

}

static void

test_param_default (void)

{

  GParamSpec *param;

  const GValue *def;

  param = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);

  def = g_param_spec_get_default_value (param);

  g_assert (G_VALUE_HOLDS (def, G_TYPE_INT));

  g_assert_cmpint (g_value_get_int (def), ==, 10);

  g_param_spec_unref (param);

}

int

main (int argc, char *argv[])

{

  TestParamImplementData data, *test_data;

  gchar *test_path;

  g_test_init (&argc, &argv, NULL);

  g_test_add_func ("/param/value", test_param_value);

  g_test_add_func ("/param/strings", test_param_strings);

  g_test_add_func ("/param/qdata", test_param_qdata);

  g_test_add_func ("/param/validate", test_param_validate);

  g_test_add_func ("/param/convert", test_param_convert);

  if (g_test_slow ())

    g_test_add_func ("/param/implement", test_param_implement);

  for (data.change_this_flag = 0; data.change_this_flag < 16; data.change_this_flag++)

    for (data.change_this_type = 0; data.change_this_type < 3; data.change_this_type++)

      for (data.use_this_flag = 0; data.use_this_flag < 16; data.use_this_flag++)

        for (data.use_this_type = 0; data.use_this_type < 4; data.use_this_type++)

          {

            test_path = g_strdup_printf ("/param/implement/subprocess/%d-%d-%d-%d",

                                         data.change_this_flag, data.change_this_type,

                                         data.use_this_flag, data.use_this_type);

            test_data = g_memdup (&data, sizeof (TestParamImplementData));

            g_test_add_data_func_full (test_path, test_data, test_param_implement_child, g_free);

            g_free (test_path);

          }

  g_test_add_func ("/value/transform", test_value_transform);

  g_test_add_func ("/param/default", test_param_default);

  return g_test_run ();

}