mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-12-26 23:46:15 +01:00
f952fdf3fc
It's unnecessary, and only adds visual noise; we have been fairly inconsistent in the past, but the semi-colon-less version clearly dominates in the code base. https://bugzilla.gnome.org/show_bug.cgi?id=669355
613 lines
17 KiB
C
613 lines
17 KiB
C
#include <stdlib.h>
|
|
#include <gstdio.h>
|
|
#include <glib-object.h>
|
|
|
|
typedef struct _TestObject {
|
|
GObject parent_instance;
|
|
gint foo;
|
|
gboolean bar;
|
|
gchar *baz;
|
|
gchar *quux;
|
|
} TestObject;
|
|
|
|
typedef struct _TestObjectClass {
|
|
GObjectClass parent_class;
|
|
} TestObjectClass;
|
|
|
|
enum { PROP_0, PROP_FOO, PROP_BAR, PROP_BAZ, PROP_QUUX, N_PROPERTIES };
|
|
|
|
static GParamSpec *properties[N_PROPERTIES] = { NULL, };
|
|
|
|
static GType test_object_get_type (void);
|
|
G_DEFINE_TYPE (TestObject, test_object, G_TYPE_OBJECT)
|
|
|
|
static void
|
|
test_object_set_foo (TestObject *obj,
|
|
gint foo)
|
|
{
|
|
if (obj->foo != foo)
|
|
{
|
|
obj->foo = foo;
|
|
|
|
g_assert (properties[PROP_FOO] != NULL);
|
|
g_object_notify_by_pspec (G_OBJECT (obj), properties[PROP_FOO]);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_object_set_bar (TestObject *obj,
|
|
gboolean bar)
|
|
{
|
|
bar = !!bar;
|
|
|
|
if (obj->bar != bar)
|
|
{
|
|
obj->bar = bar;
|
|
|
|
g_assert (properties[PROP_BAR] != NULL);
|
|
g_object_notify_by_pspec (G_OBJECT (obj), properties[PROP_BAR]);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_object_set_baz (TestObject *obj,
|
|
const gchar *baz)
|
|
{
|
|
if (g_strcmp0 (obj->baz, baz) != 0)
|
|
{
|
|
g_free (obj->baz);
|
|
obj->baz = g_strdup (baz);
|
|
|
|
g_assert (properties[PROP_BAZ] != NULL);
|
|
g_object_notify_by_pspec (G_OBJECT (obj), properties[PROP_BAZ]);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_object_set_quux (TestObject *obj,
|
|
const gchar *quux)
|
|
{
|
|
if (g_strcmp0 (obj->quux, quux) != 0)
|
|
{
|
|
g_free (obj->quux);
|
|
obj->quux = g_strdup (quux);
|
|
|
|
g_assert (properties[PROP_QUUX] != NULL);
|
|
g_object_notify_by_pspec (G_OBJECT (obj), properties[PROP_QUUX]);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_object_finalize (GObject *gobject)
|
|
{
|
|
g_free (((TestObject *) gobject)->baz);
|
|
|
|
/* When the ref_count of an object is zero it is still
|
|
* possible to notify the property, but it should do
|
|
* nothing and silenty quit (bug #705570)
|
|
*/
|
|
g_object_notify (gobject, "foo");
|
|
g_object_notify_by_pspec (gobject, properties[PROP_BAR]);
|
|
|
|
G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject);
|
|
}
|
|
|
|
static void
|
|
test_object_set_property (GObject *gobject,
|
|
guint prop_id,
|
|
const GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
TestObject *tobj = (TestObject *) gobject;
|
|
|
|
g_assert_cmpint (prop_id, !=, 0);
|
|
g_assert_cmpint (prop_id, !=, N_PROPERTIES);
|
|
g_assert (pspec == properties[prop_id]);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_FOO:
|
|
test_object_set_foo (tobj, g_value_get_int (value));
|
|
break;
|
|
|
|
case PROP_BAR:
|
|
test_object_set_bar (tobj, g_value_get_boolean (value));
|
|
break;
|
|
|
|
case PROP_BAZ:
|
|
test_object_set_baz (tobj, g_value_get_string (value));
|
|
break;
|
|
|
|
case PROP_QUUX:
|
|
test_object_set_quux (tobj, g_value_get_string (value));
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_object_get_property (GObject *gobject,
|
|
guint prop_id,
|
|
GValue *value,
|
|
GParamSpec *pspec)
|
|
{
|
|
TestObject *tobj = (TestObject *) gobject;
|
|
|
|
g_assert_cmpint (prop_id, !=, 0);
|
|
g_assert_cmpint (prop_id, !=, N_PROPERTIES);
|
|
g_assert (pspec == properties[prop_id]);
|
|
|
|
switch (prop_id)
|
|
{
|
|
case PROP_FOO:
|
|
g_value_set_int (value, tobj->foo);
|
|
break;
|
|
|
|
case PROP_BAR:
|
|
g_value_set_boolean (value, tobj->bar);
|
|
break;
|
|
|
|
case PROP_BAZ:
|
|
g_value_set_string (value, tobj->baz);
|
|
break;
|
|
|
|
case PROP_QUUX:
|
|
g_value_set_string (value, tobj->quux);
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_object_class_init (TestObjectClass *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
properties[PROP_FOO] = g_param_spec_int ("foo", "Foo", "Foo",
|
|
-1, G_MAXINT,
|
|
0,
|
|
G_PARAM_READWRITE);
|
|
properties[PROP_BAR] = g_param_spec_boolean ("bar", "Bar", "Bar",
|
|
FALSE,
|
|
G_PARAM_READWRITE);
|
|
properties[PROP_BAZ] = g_param_spec_string ("baz", "Baz", "Baz",
|
|
NULL,
|
|
G_PARAM_READWRITE);
|
|
properties[PROP_QUUX] = g_param_spec_string ("quux", "quux", "quux",
|
|
NULL,
|
|
G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
|
|
|
|
gobject_class->set_property = test_object_set_property;
|
|
gobject_class->get_property = test_object_get_property;
|
|
gobject_class->finalize = test_object_finalize;
|
|
|
|
g_object_class_install_properties (gobject_class, N_PROPERTIES, properties);
|
|
}
|
|
|
|
static void
|
|
test_object_init (TestObject *self)
|
|
{
|
|
self->foo = 42;
|
|
self->bar = TRUE;
|
|
self->baz = g_strdup ("Hello");
|
|
self->quux = NULL;
|
|
}
|
|
|
|
static void
|
|
properties_install (void)
|
|
{
|
|
TestObject *obj = g_object_new (test_object_get_type (), NULL);
|
|
GParamSpec *pspec;
|
|
|
|
g_assert (properties[PROP_FOO] != NULL);
|
|
|
|
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (obj), "foo");
|
|
g_assert (properties[PROP_FOO] == pspec);
|
|
|
|
g_object_unref (obj);
|
|
}
|
|
|
|
typedef struct {
|
|
const gchar *name;
|
|
GParamSpec *pspec;
|
|
gboolean fired;
|
|
} TestNotifyClosure;
|
|
|
|
static void
|
|
on_notify (GObject *gobject,
|
|
GParamSpec *pspec,
|
|
TestNotifyClosure *clos)
|
|
{
|
|
g_assert (clos->pspec == pspec);
|
|
g_assert_cmpstr (clos->name, ==, pspec->name);
|
|
clos->fired = TRUE;
|
|
}
|
|
|
|
static void
|
|
properties_notify (void)
|
|
{
|
|
TestObject *obj = g_object_new (test_object_get_type (), NULL);
|
|
TestNotifyClosure clos;
|
|
|
|
g_assert (properties[PROP_FOO] != NULL);
|
|
g_assert (properties[PROP_QUUX] != NULL);
|
|
g_signal_connect (obj, "notify", G_CALLBACK (on_notify), &clos);
|
|
|
|
clos.name = "foo";
|
|
clos.pspec = properties[PROP_FOO];
|
|
|
|
clos.fired = FALSE;
|
|
g_object_set (obj, "foo", 47, NULL);
|
|
g_assert (clos.fired);
|
|
|
|
clos.name = "baz";
|
|
clos.pspec = properties[PROP_BAZ];
|
|
|
|
clos.fired = FALSE;
|
|
g_object_set (obj, "baz", "something new", NULL);
|
|
g_assert (clos.fired);
|
|
|
|
/* baz lacks explicit notify, so we will see this twice */
|
|
clos.fired = FALSE;
|
|
g_object_set (obj, "baz", "something new", NULL);
|
|
g_assert (clos.fired);
|
|
|
|
/* quux on the other hand, ... */
|
|
clos.name = "quux";
|
|
clos.pspec = properties[PROP_QUUX];
|
|
|
|
clos.fired = FALSE;
|
|
g_object_set (obj, "quux", "something new", NULL);
|
|
g_assert (clos.fired);
|
|
|
|
/* no change; no notify */
|
|
clos.fired = FALSE;
|
|
g_object_set (obj, "quux", "something new", NULL);
|
|
g_assert (!clos.fired);
|
|
|
|
|
|
g_object_unref (obj);
|
|
}
|
|
|
|
typedef struct {
|
|
GParamSpec *pspec[3];
|
|
gint pos;
|
|
} Notifys;
|
|
|
|
static void
|
|
on_notify2 (GObject *gobject,
|
|
GParamSpec *pspec,
|
|
Notifys *n)
|
|
{
|
|
g_assert (n->pspec[n->pos] == pspec);
|
|
n->pos++;
|
|
}
|
|
|
|
static void
|
|
properties_notify_queue (void)
|
|
{
|
|
TestObject *obj = g_object_new (test_object_get_type (), NULL);
|
|
Notifys n;
|
|
|
|
g_assert (properties[PROP_FOO] != NULL);
|
|
|
|
n.pspec[0] = properties[PROP_BAZ];
|
|
n.pspec[1] = properties[PROP_BAR];
|
|
n.pspec[2] = properties[PROP_FOO];
|
|
n.pos = 0;
|
|
|
|
g_signal_connect (obj, "notify", G_CALLBACK (on_notify2), &n);
|
|
|
|
g_object_freeze_notify (G_OBJECT (obj));
|
|
g_object_set (obj, "foo", 47, NULL);
|
|
g_object_set (obj, "bar", TRUE, "foo", 42, "baz", "abc", NULL);
|
|
g_object_thaw_notify (G_OBJECT (obj));
|
|
g_assert (n.pos == 3);
|
|
|
|
g_object_unref (obj);
|
|
}
|
|
|
|
static void
|
|
properties_construct (void)
|
|
{
|
|
TestObject *obj;
|
|
gint val;
|
|
gboolean b;
|
|
gchar *s;
|
|
|
|
g_test_bug ("630357");
|
|
|
|
/* more than 16 args triggers a realloc in g_object_new_valist() */
|
|
obj = g_object_new (test_object_get_type (),
|
|
"foo", 1,
|
|
"foo", 2,
|
|
"foo", 3,
|
|
"foo", 4,
|
|
"foo", 5,
|
|
"bar", FALSE,
|
|
"foo", 6,
|
|
"foo", 7,
|
|
"foo", 8,
|
|
"foo", 9,
|
|
"foo", 10,
|
|
"baz", "boo",
|
|
"foo", 11,
|
|
"foo", 12,
|
|
"foo", 13,
|
|
"foo", 14,
|
|
"foo", 15,
|
|
"foo", 16,
|
|
"foo", 17,
|
|
"foo", 18,
|
|
NULL);
|
|
|
|
g_object_get (obj, "foo", &val, NULL);
|
|
g_assert (val == 18);
|
|
g_object_get (obj, "bar", &b, NULL);
|
|
g_assert (!b);
|
|
g_object_get (obj, "baz", &s, NULL);
|
|
g_assert_cmpstr (s, ==, "boo");
|
|
g_free (s);
|
|
|
|
g_object_unref (obj);
|
|
}
|
|
|
|
static void
|
|
properties_testv_with_no_properties (void)
|
|
{
|
|
TestObject *test_obj;
|
|
const char *prop_names[4] = { "foo", "bar", "baz", "quux" };
|
|
GValue values_out[4] = { G_VALUE_INIT };
|
|
guint i;
|
|
|
|
/* Test newv_with_properties && getv */
|
|
test_obj = (TestObject *) g_object_new_with_properties (
|
|
test_object_get_type (), 0, NULL, NULL);
|
|
g_object_getv (G_OBJECT (test_obj), 4, prop_names, values_out);
|
|
|
|
/* It should have init values */
|
|
g_assert_cmpint (g_value_get_int (&values_out[0]), ==, 42);
|
|
g_assert_true (g_value_get_boolean (&values_out[1]));
|
|
g_assert_cmpstr (g_value_get_string (&values_out[2]), ==, "Hello");
|
|
g_assert_cmpstr (g_value_get_string (&values_out[3]), ==, NULL);
|
|
|
|
for (i = 0; i < 4; i++)
|
|
g_value_unset (&values_out[i]);
|
|
g_object_unref (test_obj);
|
|
}
|
|
|
|
static void
|
|
properties_testv_with_valid_properties (void)
|
|
{
|
|
TestObject *test_obj;
|
|
const char *prop_names[4] = { "foo", "bar", "baz", "quux" };
|
|
|
|
GValue values_in[4] = { G_VALUE_INIT };
|
|
GValue values_out[4] = { G_VALUE_INIT };
|
|
guint i;
|
|
|
|
g_value_init (&(values_in[0]), G_TYPE_INT);
|
|
g_value_set_int (&(values_in[0]), 100);
|
|
|
|
g_value_init (&(values_in[1]), G_TYPE_BOOLEAN);
|
|
g_value_set_boolean (&(values_in[1]), TRUE);
|
|
|
|
g_value_init (&(values_in[2]), G_TYPE_STRING);
|
|
g_value_set_string (&(values_in[2]), "pigs");
|
|
|
|
g_value_init (&(values_in[3]), G_TYPE_STRING);
|
|
g_value_set_string (&(values_in[3]), "fly");
|
|
|
|
/* Test newv_with_properties && getv */
|
|
test_obj = (TestObject *) g_object_new_with_properties (
|
|
test_object_get_type (), 4, prop_names, values_in);
|
|
g_object_getv (G_OBJECT (test_obj), 4, prop_names, values_out);
|
|
|
|
g_assert_cmpint (g_value_get_int (&values_out[0]), ==, 100);
|
|
g_assert_true (g_value_get_boolean (&values_out[1]));
|
|
g_assert_cmpstr (g_value_get_string (&values_out[2]), ==, "pigs");
|
|
g_assert_cmpstr (g_value_get_string (&values_out[3]), ==, "fly");
|
|
|
|
/* Test newv2 && getv */
|
|
g_value_set_string (&(values_in[2]), "Elmo knows");
|
|
g_value_set_string (&(values_in[3]), "where you live");
|
|
g_object_setv (G_OBJECT (test_obj), 4, prop_names, values_in);
|
|
|
|
g_object_getv (G_OBJECT (test_obj), 4, prop_names, values_out);
|
|
|
|
g_assert_cmpint (g_value_get_int (&values_out[0]), ==, 100);
|
|
g_assert_true (g_value_get_boolean (&values_out[1]));
|
|
|
|
g_assert_cmpstr (g_value_get_string (&values_out[2]), ==, "Elmo knows");
|
|
g_assert_cmpstr (g_value_get_string (&values_out[3]), ==, "where you live");
|
|
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
g_value_unset (&values_in[i]);
|
|
g_value_unset (&values_out[i]);
|
|
}
|
|
|
|
g_object_unref (test_obj);
|
|
}
|
|
|
|
static void
|
|
properties_testv_with_invalid_property_type (void)
|
|
{
|
|
if (g_test_subprocess ())
|
|
{
|
|
TestObject *test_obj;
|
|
const char *invalid_prop_names[1] = { "foo" };
|
|
GValue values_in[1] = { G_VALUE_INIT };
|
|
|
|
g_value_init (&(values_in[0]), G_TYPE_STRING);
|
|
g_value_set_string (&(values_in[0]), "fly");
|
|
|
|
test_obj = (TestObject *) g_object_new_with_properties (
|
|
test_object_get_type (), 1, invalid_prop_names, values_in);
|
|
/* should give a warning */
|
|
|
|
g_object_unref (test_obj);
|
|
}
|
|
g_test_trap_subprocess (NULL, 0, 0);
|
|
g_test_trap_assert_failed ();
|
|
g_test_trap_assert_stderr ("*WARNING*foo*gint*gchararray*");
|
|
}
|
|
|
|
|
|
static void
|
|
properties_testv_with_invalid_property_names (void)
|
|
{
|
|
if (g_test_subprocess ())
|
|
{
|
|
TestObject *test_obj;
|
|
const char *invalid_prop_names[4] = { "foo", "boo", "moo", "poo" };
|
|
GValue values_in[4] = { G_VALUE_INIT };
|
|
|
|
g_value_init (&(values_in[0]), G_TYPE_INT);
|
|
g_value_set_int (&(values_in[0]), 100);
|
|
|
|
g_value_init (&(values_in[1]), G_TYPE_BOOLEAN);
|
|
g_value_set_boolean (&(values_in[1]), TRUE);
|
|
|
|
g_value_init (&(values_in[2]), G_TYPE_STRING);
|
|
g_value_set_string (&(values_in[2]), "pigs");
|
|
|
|
g_value_init (&(values_in[3]), G_TYPE_STRING);
|
|
g_value_set_string (&(values_in[3]), "fly");
|
|
|
|
test_obj = (TestObject *) g_object_new_with_properties (
|
|
test_object_get_type (), 4, invalid_prop_names, values_in);
|
|
/* This call should give 3 Critical warnings. Actually, a critical warning
|
|
* shouldn't make g_object_new_with_properties to fail when a bad named
|
|
* property is given, because, it will just ignore that property. However,
|
|
* for test purposes, it is considered that the test doesn't pass.
|
|
*/
|
|
|
|
g_object_unref (test_obj);
|
|
}
|
|
|
|
g_test_trap_subprocess (NULL, 0, 0);
|
|
g_test_trap_assert_failed ();
|
|
g_test_trap_assert_stderr ("*CRITICAL*g_object_new_is_valid_property*boo*");
|
|
}
|
|
|
|
static void
|
|
properties_testv_getv (void)
|
|
{
|
|
TestObject *test_obj;
|
|
const char *prop_names[4] = { "foo", "bar", "baz", "quux" };
|
|
GValue values_out_initialized[4] = { G_VALUE_INIT };
|
|
GValue values_out_uninitialized[4] = { G_VALUE_INIT };
|
|
guint i;
|
|
|
|
g_value_init (&(values_out_initialized[0]), G_TYPE_INT);
|
|
g_value_init (&(values_out_initialized[1]), G_TYPE_BOOLEAN);
|
|
g_value_init (&(values_out_initialized[2]), G_TYPE_STRING);
|
|
g_value_init (&(values_out_initialized[3]), G_TYPE_STRING);
|
|
|
|
test_obj = (TestObject *) g_object_new_with_properties (
|
|
test_object_get_type (), 0, NULL, NULL);
|
|
|
|
/* Test g_object_getv for an initialized values array */
|
|
g_object_getv (G_OBJECT (test_obj), 4, prop_names, values_out_initialized);
|
|
/* It should have init values */
|
|
g_assert_cmpint (g_value_get_int (&values_out_initialized[0]), ==, 42);
|
|
g_assert_true (g_value_get_boolean (&values_out_initialized[1]));
|
|
g_assert_cmpstr (g_value_get_string (&values_out_initialized[2]), ==, "Hello");
|
|
g_assert_cmpstr (g_value_get_string (&values_out_initialized[3]), ==, NULL);
|
|
|
|
/* Test g_object_getv for an uninitialized values array */
|
|
g_object_getv (G_OBJECT (test_obj), 4, prop_names, values_out_uninitialized);
|
|
/* It should have init values */
|
|
g_assert_cmpint (g_value_get_int (&values_out_uninitialized[0]), ==, 42);
|
|
g_assert_true (g_value_get_boolean (&values_out_uninitialized[1]));
|
|
g_assert_cmpstr (g_value_get_string (&values_out_uninitialized[2]), ==, "Hello");
|
|
g_assert_cmpstr (g_value_get_string (&values_out_uninitialized[3]), ==, NULL);
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
g_value_unset (&values_out_initialized[i]);
|
|
g_value_unset (&values_out_uninitialized[i]);
|
|
}
|
|
g_object_unref (test_obj);
|
|
}
|
|
|
|
static void
|
|
properties_testv_notify_queue (void)
|
|
{
|
|
TestObject *test_obj;
|
|
const char *prop_names[3] = { "foo", "bar", "baz" };
|
|
GValue values_in[3] = { G_VALUE_INIT };
|
|
Notifys n;
|
|
guint i;
|
|
|
|
g_value_init (&(values_in[0]), G_TYPE_INT);
|
|
g_value_set_int (&(values_in[0]), 100);
|
|
|
|
g_value_init (&(values_in[1]), G_TYPE_BOOLEAN);
|
|
g_value_set_boolean (&(values_in[1]), TRUE);
|
|
|
|
g_value_init (&(values_in[2]), G_TYPE_STRING);
|
|
g_value_set_string (&(values_in[2]), "");
|
|
|
|
/* Test newv_with_properties && getv */
|
|
test_obj = (TestObject *) g_object_new_with_properties (
|
|
test_object_get_type (), 0, NULL, NULL);
|
|
|
|
g_assert_nonnull (properties[PROP_FOO]);
|
|
|
|
n.pspec[0] = properties[PROP_BAZ];
|
|
n.pspec[1] = properties[PROP_BAR];
|
|
n.pspec[2] = properties[PROP_FOO];
|
|
n.pos = 0;
|
|
|
|
g_signal_connect (test_obj, "notify", G_CALLBACK (on_notify2), &n);
|
|
|
|
g_object_freeze_notify (G_OBJECT (test_obj));
|
|
{
|
|
g_object_setv (G_OBJECT (test_obj), 3, prop_names, values_in);
|
|
|
|
/* Set "foo" to 70 */
|
|
g_value_set_int (&(values_in[0]), 100);
|
|
g_object_setv (G_OBJECT (test_obj), 1, prop_names, values_in);
|
|
}
|
|
g_object_thaw_notify (G_OBJECT (test_obj));
|
|
g_assert_cmpint (n.pos, ==, 3);
|
|
|
|
for (i = 0; i < 3; i++)
|
|
g_value_unset (&values_in[i]);
|
|
g_object_unref (test_obj);
|
|
}
|
|
|
|
int
|
|
main (int argc, char *argv[])
|
|
{
|
|
g_test_init (&argc, &argv, NULL);
|
|
|
|
g_test_bug_base ("http://bugzilla.gnome.org/");
|
|
|
|
g_test_add_func ("/properties/install", properties_install);
|
|
g_test_add_func ("/properties/notify", properties_notify);
|
|
g_test_add_func ("/properties/notify-queue", properties_notify_queue);
|
|
g_test_add_func ("/properties/construct", properties_construct);
|
|
|
|
g_test_add_func ("/properties/testv_with_no_properties",
|
|
properties_testv_with_no_properties);
|
|
g_test_add_func ("/properties/testv_with_valid_properties",
|
|
properties_testv_with_valid_properties);
|
|
g_test_add_func ("/properties/testv_with_invalid_property_type",
|
|
properties_testv_with_invalid_property_type);
|
|
g_test_add_func ("/properties/testv_with_invalid_property_names",
|
|
properties_testv_with_invalid_property_names);
|
|
g_test_add_func ("/properties/testv_getv", properties_testv_getv);
|
|
g_test_add_func ("/properties/testv_notify_queue",
|
|
properties_testv_notify_queue);
|
|
|
|
return g_test_run ();
|
|
}
|