From 5ed147db0808e5f4ef50dfd6011419c44255ea6c Mon Sep 17 00:00:00 2001 From: Danielle Madeley Date: Thu, 24 Jun 2010 20:59:05 +1000 Subject: Bumping required GLib to 2.24 for GVariant --- configure.ac | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/configure.ac b/configure.ac index e2df05d..15d1b6d 100644 --- a/configure.ac +++ b/configure.ac @@ -385,7 +385,7 @@ fi AC_SUBST(DBUS_DAEMONDIR) # Glib detection -PKG_CHECK_MODULES(DBUS_GLIB, gobject-2.0 >= 2.10, have_glib=yes, have_glib=no) +PKG_CHECK_MODULES(DBUS_GLIB, gobject-2.0 >= 2.24, have_glib=yes, have_glib=no) PKG_CHECK_MODULES(DBUS_GLIB_THREADS, gthread-2.0 >= 2.6, have_glib_threads=yes, have_glib_threads=no) if test x$have_glib = xno ; then -- cgit v1.2.3 From 5cc0676c83ee678069886daad5fc5487f098686e Mon Sep 17 00:00:00 2001 From: Danielle Madeley Date: Thu, 24 Jun 2010 20:52:26 +1000 Subject: fd.o #28715: Add dbus_g_value_build_g_variant() --- dbus/dbus-gtype-specialized.c | 127 +++++++++++++++++++++++++++++++++++ dbus/dbus-gtype-specialized.h | 2 + doc/reference/dbus-glib-sections.txt | 1 + 3 files changed, 130 insertions(+) diff --git a/dbus/dbus-gtype-specialized.c b/dbus/dbus-gtype-specialized.c index fa22eee..22ea538 100644 --- a/dbus/dbus-gtype-specialized.c +++ b/dbus/dbus-gtype-specialized.c @@ -22,6 +22,7 @@ * */ +#include "dbus-glib.h" #include "dbus-gtype-specialized-priv.h" #include "dbus-gvalue-utils.h" #include @@ -1094,3 +1095,129 @@ error: return FALSE; } +static void +_collection_iterator (const GValue *value, + gpointer user_data) +{ + GPtrArray *children = user_data; + + g_ptr_array_add (children, dbus_g_value_build_g_variant (value)); +} + +static void +_map_iterator (const GValue *kvalue, + const GValue *vvalue, + gpointer user_data) +{ + GPtrArray *children = user_data; + + g_ptr_array_add (children, + g_variant_new_dict_entry ( + dbus_g_value_build_g_variant (kvalue), + dbus_g_value_build_g_variant (vvalue))); +} + +/** + * dbus_g_value_build_g_variant: + * @value: a simple or specialized #GValue to convert to a #GVariant + * + * Recurses @value and converts its contents to a #GVariant. + * + * The value must either be a simple value (integer, string, boolean, + * object path etc.) or a specialized container registered with + * dbus_g_type_get_collection(), dbus_g_type_get_map() or + * dbus_g_type_get_struct(). Providing any other type is a programming error + * (including as a child type). + * + * Returns: a new #GVariant containing @value with a floating reference + */ +GVariant * +dbus_g_value_build_g_variant (const GValue *value) +{ + GType type; + + g_return_val_if_fail (G_IS_VALUE (value), NULL); + + type = G_VALUE_TYPE (value); + + if (dbus_g_type_is_collection (type)) + { + GVariant *variant; + GPtrArray *children; + + children = g_ptr_array_new (); + dbus_g_type_collection_value_iterate (value, _collection_iterator, + children); + + variant = g_variant_new_array (NULL, (GVariant **) children->pdata, + children->len); + g_ptr_array_free (children, TRUE); + + return variant; + } + else if (dbus_g_type_is_map (type)) + { + GVariant *variant; + GPtrArray *children; + + children = g_ptr_array_new (); + dbus_g_type_map_value_iterate (value, _map_iterator, children); + + variant = g_variant_new_array (NULL, (GVariant **) children->pdata, + children->len); + g_ptr_array_free (children, TRUE); + + return variant; + } + else if (dbus_g_type_is_struct (type)) + { + GVariant *variant, **children; + guint size, i; + + size = dbus_g_type_get_struct_size (type); + children = g_new0 (GVariant *, size); + + for (i = 0; i < size; i++) + { + GValue cvalue = { 0, }; + + g_value_init (&cvalue, dbus_g_type_get_struct_member_type (type, i)); + dbus_g_type_struct_get_member (value, i, &cvalue); + + children[i] = dbus_g_value_build_g_variant (&cvalue); + g_value_unset (&cvalue); + } + + variant = g_variant_new_tuple (children, size); + g_free (children); + + return variant; + } + else if (type == G_TYPE_BOOLEAN) + return g_variant_new_boolean (g_value_get_boolean (value)); + else if (type == G_TYPE_UCHAR) + return g_variant_new_byte (g_value_get_uchar (value)); + else if (type == G_TYPE_INT) + return g_variant_new_int32 (g_value_get_int (value)); + else if (type == G_TYPE_UINT) + return g_variant_new_uint32 (g_value_get_uint (value)); + else if (type == G_TYPE_INT64) + return g_variant_new_int64 (g_value_get_int64 (value)); + else if (type == G_TYPE_UINT64) + return g_variant_new_uint64 (g_value_get_uint64 (value)); + else if (type == G_TYPE_DOUBLE) + return g_variant_new_double (g_value_get_double (value)); + else if (type == G_TYPE_STRING) + return g_variant_new_string (g_value_get_string (value)); + else if (type == G_TYPE_STRV) + return g_variant_new_strv (g_value_get_boxed (value), -1); + else if (type == DBUS_TYPE_G_OBJECT_PATH) + return g_variant_new_object_path (g_value_get_boxed (value)); + else if (type == G_TYPE_VALUE) + return g_variant_new_variant ( + dbus_g_value_build_g_variant (g_value_get_boxed (value))); + else + { + g_error ("%s: Unknown type: %s", G_STRFUNC, g_type_name (type)); + } +} diff --git a/dbus/dbus-gtype-specialized.h b/dbus/dbus-gtype-specialized.h index 98cdde9..8c60182 100644 --- a/dbus/dbus-gtype-specialized.h +++ b/dbus/dbus-gtype-specialized.h @@ -169,6 +169,8 @@ const DBusGTypeSpecializedCollectionVtable* dbus_g_type_collection_peek_vtable ( const DBusGTypeSpecializedStructVtable* dbus_g_type_struct_peek_vtable (GType struct_type); +GVariant *dbus_g_value_build_g_variant (const GValue *value); + G_END_DECLS #endif diff --git a/doc/reference/dbus-glib-sections.txt b/doc/reference/dbus-glib-sections.txt index 1b6dc97..bbee69c 100644 --- a/doc/reference/dbus-glib-sections.txt +++ b/doc/reference/dbus-glib-sections.txt @@ -164,6 +164,7 @@ dbus_g_type_register_map dbus_g_type_map_peek_vtable dbus_g_type_collection_peek_vtable dbus_g_type_register_struct +dbus_g_value_build_g_variant DBUS_TYPE_G_BOOLEAN_ARRAY DBUS_TYPE_G_UCHAR_ARRAY DBUS_TYPE_G_UINT_ARRAY -- cgit v1.2.3 From 5456dc1f10544505a61f2608f646256e28b0047a Mon Sep 17 00:00:00 2001 From: Danielle Madeley Date: Thu, 24 Jun 2010 22:10:48 +1000 Subject: Tests for GValue-to-GVariant --- test/core/Makefile.am | 7 +- test/core/test-gvariant.c | 191 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 197 insertions(+), 1 deletion(-) create mode 100644 test/core/test-gvariant.c diff --git a/test/core/Makefile.am b/test/core/Makefile.am index 6ecd30a..8763b01 100644 --- a/test/core/Makefile.am +++ b/test/core/Makefile.am @@ -48,7 +48,8 @@ noinst_PROGRAMS = \ test-types \ test-5688 \ test-unregister \ - test-variant-recursion + test-variant-recursion \ + test-gvariant test_5688_SOURCES = \ my-object.c \ @@ -126,6 +127,10 @@ test_types_SOURCES = \ test-types.c test_types_LDADD= $(top_builddir)/dbus/libdbus-glib-1.la +test_gvariant_SOURCES = \ + test-gvariant.c +test_gvariant_LDADD=$(top_builddir)/dbus/libdbus-glib-1.la + CLEANFILES = \ $(BUILT_SOURCES) \ run-with-tmp-session-bus.conf diff --git a/test/core/test-gvariant.c b/test/core/test-gvariant.c new file mode 100644 index 0000000..6caa675 --- /dev/null +++ b/test/core/test-gvariant.c @@ -0,0 +1,191 @@ +#include +#include + +static void +test_i (void) +{ + GValue v = { 0, }; + GVariant *var, *varc; + + g_value_init (&v, G_TYPE_INT); + g_value_set_int (&v, 1984); + + var = dbus_g_value_build_g_variant (&v); + g_value_unset (&v); + + varc = g_variant_new_int32 (1984); + + g_assert (g_variant_equal (var, varc)); + + g_variant_unref (var); + g_variant_unref (varc); +} + +static void +test_s (void) +{ + GValue v = { 0, }; + GVariant *var, *varc; + + g_value_init (&v, G_TYPE_STRING); + g_value_set_static_string (&v, "Orwell"); + + var = dbus_g_value_build_g_variant (&v); + g_value_unset (&v); + + varc = g_variant_new_string ("Orwell"); + + g_assert (g_variant_equal (var, varc)); + + g_variant_unref (var); + g_variant_unref (varc); +} + +static void +test_o (void) +{ + GValue v = { 0, }; + GVariant *var, *varc; + + g_value_init (&v, DBUS_TYPE_G_OBJECT_PATH); + g_value_set_boxed (&v, "/cats/escher"); + + var = dbus_g_value_build_g_variant (&v); + g_value_unset (&v); + + varc = g_variant_new_object_path ("/cats/escher"); + + g_assert (g_variant_equal (var, varc)); + + g_variant_unref (var); + g_variant_unref (varc); +} + +static void +test_us (void) +{ + GValue v = { 0, }; + GVariant *var, *varc; + GType us = dbus_g_type_get_struct ("GValueArray", + G_TYPE_UINT, + G_TYPE_STRING, + G_TYPE_INVALID); + + g_value_init (&v, us); + g_value_take_boxed (&v, dbus_g_type_specialized_construct (us)); + dbus_g_type_struct_set (&v, + 0, 1984, + 1, "Orwell", + G_MAXUINT); + + var = dbus_g_value_build_g_variant (&v); + g_value_unset (&v); + + varc = g_variant_new ("(us)", 1984, "Orwell"); + + g_assert (g_variant_equal (var, varc)); + + g_variant_unref (var); + g_variant_unref (varc); +} + +static void +test_a_os (void) +{ + GValue v = { 0, }; + GHashTable *map; + GVariantBuilder b; + GVariant *var, *varc; + GType a_os = dbus_g_type_get_map ("GHashTable", + DBUS_TYPE_G_OBJECT_PATH, + G_TYPE_STRING); + + g_value_init (&v, a_os); + map = dbus_g_type_specialized_construct (a_os); + + g_hash_table_insert (map, + g_strdup ("/cats/escher"), g_strdup ("Escher Moonbeam")); + g_hash_table_insert (map, + g_strdup ("/cats/harvey"), g_strdup ("Harvey Nomcat")); + g_hash_table_insert (map, + g_strdup ("/cats/josh"), g_strdup ("Josh Smith")); + g_value_take_boxed (&v, map); + + var = dbus_g_value_build_g_variant (&v); + g_value_unset (&v); + + g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}")); + /* WARNING: ordering must match hash table for g_variant_equal to work */ + g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam"); + g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith"); + g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat"); + varc = g_variant_builder_end (&b); + + g_assert (g_variant_equal (var, varc)); + + g_variant_unref (var); + g_variant_unref (varc); +} + +static void +test_av (void) +{ + GValue v = { 0, }, *v2; + GVariantBuilder b; + GVariant *var, *varc; + GType av = dbus_g_type_get_collection ("GPtrArray", G_TYPE_VALUE); + GPtrArray *array; + + g_value_init (&v, av); + array = dbus_g_type_specialized_construct (av); + + v2 = g_new0 (GValue, 1); + g_value_init (v2, G_TYPE_INT); + g_value_set_int (v2, 1984); + g_ptr_array_add (array, v2); + + v2 = g_new0 (GValue, 1); + g_value_init (v2, G_TYPE_STRING); + g_value_set_static_string (v2, "Orwell"); + g_ptr_array_add (array, v2); + + v2 = g_new0 (GValue, 1); + g_value_init (v2, DBUS_TYPE_G_OBJECT_PATH); + g_value_set_boxed (v2, "/cats/escher"); + g_ptr_array_add (array, v2); + + g_value_take_boxed (&v, array); + + var = dbus_g_value_build_g_variant (&v); + g_value_unset (&v); + + g_variant_builder_init (&b, G_VARIANT_TYPE ("av")); + g_variant_builder_add (&b, "v", g_variant_new_int32 (1984)); + g_variant_builder_add (&b, "v", g_variant_new_string ("Orwell")); + g_variant_builder_add (&b, "v", g_variant_new_object_path ("/cats/escher")); + varc = g_variant_builder_end (&b); + + g_assert (g_variant_equal (var, varc)); + + g_variant_unref (var); + g_variant_unref (varc); +} + +int +main (int argc, + char **argv) +{ + g_type_init (); + dbus_g_type_specialized_init (); + + g_test_init (&argc, &argv, NULL); + + g_test_add_func ("/gvalue-to-gvariant/i", test_i); + g_test_add_func ("/gvalue-to-gvariant/s", test_s); + g_test_add_func ("/gvalue-to-gvariant/o", test_o); + g_test_add_func ("/gvalue-to-gvariant/us", test_us); + g_test_add_func ("/gvalue-to-gvariant/a{os}", test_a_os); + g_test_add_func ("/gvalue-to-gvariant/av", test_av); + + return g_test_run (); +} -- cgit v1.2.3 From 90b5e06797f2c9c5ed8918d22de35d5093bc3bd1 Mon Sep 17 00:00:00 2001 From: Danielle Madeley Date: Fri, 25 Jun 2010 14:11:40 +1000 Subject: Write a recursive equivalence function for testing the equivalence of GVariants Makes up for the limitations of g_variant_equal() --- test/core/test-gvariant.c | 114 ++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 106 insertions(+), 8 deletions(-) diff --git a/test/core/test-gvariant.c b/test/core/test-gvariant.c index 6caa675..4916655 100644 --- a/test/core/test-gvariant.c +++ b/test/core/test-gvariant.c @@ -1,6 +1,105 @@ #include #include +/** + * test_g_variant_equivalent: + * + * The function g_variant_equal() cannot be used for dictionaries because it + * cares about the ordering of dictionaries, which breaks our tests. + */ +static gboolean +test_g_variant_equivalent (GVariant *one, + GVariant *two) +{ + if (!g_variant_type_equal ( + g_variant_get_type (one), + g_variant_get_type (two))) + { + return FALSE; + } + else if (g_variant_is_of_type (one, G_VARIANT_TYPE_DICTIONARY) && + g_variant_is_of_type (two, G_VARIANT_TYPE_DICTIONARY)) + { + GHashTable *hash; + GVariantIter iter; + GVariant *child; + gboolean equal = TRUE; + + if (g_variant_n_children (one) != g_variant_n_children (two)) + return FALSE; + + /* pack @one into a hash table */ + hash = g_hash_table_new_full (g_variant_hash, g_variant_equal, + (GDestroyNotify) g_variant_unref, (GDestroyNotify) g_variant_unref); + + g_variant_iter_init (&iter, one); + while ((child = g_variant_iter_next_value (&iter))) + { + g_hash_table_insert (hash, + g_variant_get_child_value (child, 0), + g_variant_get_child_value (child, 1)); + g_variant_unref (child); + } + + /* now iterate @two to check for the keys in @hash */ + g_variant_iter_init (&iter, two); + while (equal && (child = g_variant_iter_next_value (&iter))) + { + GVariant *k, *v1, *v2; + + k = g_variant_get_child_value (child, 0); + v1 = g_variant_get_child_value (child, 1); + + v2 = g_hash_table_lookup (hash, k); + + if (v2 == NULL || !test_g_variant_equivalent (v1, v2)) + equal = FALSE; + else + g_hash_table_remove (hash, k); + + g_variant_unref (k); + g_variant_unref (v1); + g_variant_unref (child); + } + + if (g_hash_table_size (hash) > 0) + equal = FALSE; + + g_hash_table_destroy (hash); + + return equal; + } + else if (g_variant_is_container (one) && + g_variant_is_container (two)) + { + guint i, size; + gboolean equal = TRUE; + + if (g_variant_n_children (one) != g_variant_n_children (two)) + return FALSE; + + size = g_variant_n_children (one); + for (i = 0; equal && i < size; i++) + { + GVariant *child1, *child2; + + child1 = g_variant_get_child_value (one, i); + child2 = g_variant_get_child_value (two, i); + + equal = test_g_variant_equivalent (child1, child2); + + g_variant_unref (child1); + g_variant_unref (child2); + } + + return equal; + } + else + { + return g_variant_equal (one, two); + } +} + static void test_i (void) { @@ -15,7 +114,7 @@ test_i (void) varc = g_variant_new_int32 (1984); - g_assert (g_variant_equal (var, varc)); + g_assert (test_g_variant_equivalent (var, varc)); g_variant_unref (var); g_variant_unref (varc); @@ -35,7 +134,7 @@ test_s (void) varc = g_variant_new_string ("Orwell"); - g_assert (g_variant_equal (var, varc)); + g_assert (test_g_variant_equivalent (var, varc)); g_variant_unref (var); g_variant_unref (varc); @@ -55,7 +154,7 @@ test_o (void) varc = g_variant_new_object_path ("/cats/escher"); - g_assert (g_variant_equal (var, varc)); + g_assert (test_g_variant_equivalent (var, varc)); g_variant_unref (var); g_variant_unref (varc); @@ -83,7 +182,7 @@ test_us (void) varc = g_variant_new ("(us)", 1984, "Orwell"); - g_assert (g_variant_equal (var, varc)); + g_assert (test_g_variant_equivalent (var, varc)); g_variant_unref (var); g_variant_unref (varc); @@ -115,13 +214,12 @@ test_a_os (void) g_value_unset (&v); g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}")); - /* WARNING: ordering must match hash table for g_variant_equal to work */ g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam"); - g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith"); g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat"); + g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith"); varc = g_variant_builder_end (&b); - g_assert (g_variant_equal (var, varc)); + g_assert (test_g_variant_equivalent (var, varc)); g_variant_unref (var); g_variant_unref (varc); @@ -165,7 +263,7 @@ test_av (void) g_variant_builder_add (&b, "v", g_variant_new_object_path ("/cats/escher")); varc = g_variant_builder_end (&b); - g_assert (g_variant_equal (var, varc)); + g_assert (test_g_variant_equivalent (var, varc)); g_variant_unref (var); g_variant_unref (varc); -- cgit v1.2.3 From 13f7c51344111ca5266e790d2f4863fab770bfd8 Mon Sep 17 00:00:00 2001 From: Danielle Madeley Date: Fri, 25 Jun 2010 14:35:17 +1000 Subject: Test test_g_variant_equivalent itself --- test/core/test-gvariant.c | 144 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 144 insertions(+) diff --git a/test/core/test-gvariant.c b/test/core/test-gvariant.c index 4916655..3a61273 100644 --- a/test/core/test-gvariant.c +++ b/test/core/test-gvariant.c @@ -100,6 +100,135 @@ test_g_variant_equivalent (GVariant *one, } } +/* test_g_variant_equivalent tests */ +static void +test_simple_equiv (void) +{ + GVariant *v1, *v2; + + v1 = g_variant_new_int32 (1984); + v2 = g_variant_new_int32 (1984); + + g_assert (test_g_variant_equivalent (v1, v2)); + + g_variant_unref (v1); + g_variant_unref (v2); +} + +static void +test_simple_not_equiv (void) +{ + GVariant *v1, *v2; + + v1 = g_variant_new_int32 (1982); + v2 = g_variant_new_int32 (1984); + + g_assert (!test_g_variant_equivalent (v1, v2)); + + g_variant_unref (v1); + g_variant_unref (v2); +} + +static void +test_array_not_equiv (void) +{ + GVariantBuilder b; + GVariant *v1, *v2; + + g_variant_builder_init (&b, G_VARIANT_TYPE ("av")); + g_variant_builder_add (&b, "v", g_variant_new_int32 (1984)); + g_variant_builder_add (&b, "v", g_variant_new_string ("Orwell")); + g_variant_builder_add (&b, "v", g_variant_new_object_path ("/cats/escher")); + v1 = g_variant_builder_end (&b); + + g_variant_builder_init (&b, G_VARIANT_TYPE ("av")); + /* note the order has changed */ + g_variant_builder_add (&b, "v", g_variant_new_string ("Orwell")); + g_variant_builder_add (&b, "v", g_variant_new_int32 (1984)); + g_variant_builder_add (&b, "v", g_variant_new_object_path ("/cats/escher")); + v2 = g_variant_builder_end (&b); + + g_assert (!test_g_variant_equivalent (v1, v2)); + + g_variant_unref (v1); + g_variant_unref (v2); +} + +static void +test_map_equiv (void) +{ + GVariantBuilder b; + GVariant *v1, *v2; + + g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}")); + g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam"); + g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat"); + g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith"); + v1 = g_variant_builder_end (&b); + + g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}")); + /* note the order has changed */ + g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat"); + g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam"); + g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith"); + v2 = g_variant_builder_end (&b); + + g_assert (test_g_variant_equivalent (v1, v2)); + + g_variant_unref (v1); + g_variant_unref (v2); +} + +static void +test_map_not_equiv1 (void) +{ + GVariantBuilder b; + GVariant *v1, *v2; + + g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}")); + g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam"); + g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat"); + g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith"); + v1 = g_variant_builder_end (&b); + + g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}")); + g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam"); + g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat"); + g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith"); + g_variant_builder_add (&b, "{os}", "/cats/rory", "Rory Cat"); + v2 = g_variant_builder_end (&b); + + g_assert (!test_g_variant_equivalent (v1, v2)); + + g_variant_unref (v1); + g_variant_unref (v2); +} + +static void +test_map_not_equiv2 (void) +{ + GVariantBuilder b; + GVariant *v1, *v2; + + g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}")); + g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam"); + g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat"); + g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Smith"); + v1 = g_variant_builder_end (&b); + + g_variant_builder_init (&b, G_VARIANT_TYPE ("a{os}")); + g_variant_builder_add (&b, "{os}", "/cats/escher", "Escher Moonbeam"); + g_variant_builder_add (&b, "{os}", "/cats/harvey", "Harvey Nomcat"); + g_variant_builder_add (&b, "{os}", "/cats/josh", "Josh Cat"); + v2 = g_variant_builder_end (&b); + + g_assert (!test_g_variant_equivalent (v1, v2)); + + g_variant_unref (v1); + g_variant_unref (v2); +} + +/* dbus_g_value_build_g_variant tests */ static void test_i (void) { @@ -278,6 +407,21 @@ main (int argc, g_test_init (&argc, &argv, NULL); + /* test_g_variant_equivalent tests */ + g_test_add_func ("/test_g_variant_equivalent/test_simple_equiv", + test_simple_equiv); + g_test_add_func ("/test_g_variant_equivalent/test_simple_not_equiv", + test_simple_not_equiv); + g_test_add_func ("/test_g_variant_equivalent/test_array_not_equiv", + test_array_not_equiv); + g_test_add_func ("/test_g_variant_equivalent/test_map_equiv", + test_map_equiv); + g_test_add_func ("/test_g_variant_equivalent/test_map_not_equiv1", + test_map_not_equiv1); + g_test_add_func ("/test_g_variant_equivalent/test_map_not_equiv2", + test_map_not_equiv2); + + /* dbus_g_value_build_g_variant tests */ g_test_add_func ("/gvalue-to-gvariant/i", test_i); g_test_add_func ("/gvalue-to-gvariant/s", test_s); g_test_add_func ("/gvalue-to-gvariant/o", test_o); -- cgit v1.2.3 From 077d445078663e3ee6f93beacc14d866504148bf Mon Sep 17 00:00:00 2001 From: Danielle Madeley Date: Wed, 14 Jul 2010 15:43:11 +1000 Subject: Support DBUS_TYPE_G_SIGNATURE --- dbus/dbus-gtype-specialized.c | 2 ++ test/core/test-gvariant.c | 21 +++++++++++++++++++++ 2 files changed, 23 insertions(+) diff --git a/dbus/dbus-gtype-specialized.c b/dbus/dbus-gtype-specialized.c index 22ea538..fc841c6 100644 --- a/dbus/dbus-gtype-specialized.c +++ b/dbus/dbus-gtype-specialized.c @@ -1213,6 +1213,8 @@ dbus_g_value_build_g_variant (const GValue *value) return g_variant_new_strv (g_value_get_boxed (value), -1); else if (type == DBUS_TYPE_G_OBJECT_PATH) return g_variant_new_object_path (g_value_get_boxed (value)); + else if (type == DBUS_TYPE_G_SIGNATURE) + return g_variant_new_signature (g_value_get_boxed (value)); else if (type == G_TYPE_VALUE) return g_variant_new_variant ( dbus_g_value_build_g_variant (g_value_get_boxed (value))); diff --git a/test/core/test-gvariant.c b/test/core/test-gvariant.c index 3a61273..df6df7b 100644 --- a/test/core/test-gvariant.c +++ b/test/core/test-gvariant.c @@ -398,6 +398,26 @@ test_av (void) g_variant_unref (varc); } +static void +test_g (void) +{ + GValue v = { 0, }; + GVariant *var, *varc; + + g_value_init (&v, DBUS_TYPE_G_SIGNATURE); + g_value_set_boxed (&v, "a{u(ua{sa{sv}})}"); + + var = dbus_g_value_build_g_variant (&v); + g_value_unset (&v); + + varc = g_variant_new_signature ("a{u(ua{sa{sv}})}"); + + g_assert (test_g_variant_equivalent (var, varc)); + + g_variant_unref (var); + g_variant_unref (varc); +} + int main (int argc, char **argv) @@ -428,6 +448,7 @@ main (int argc, g_test_add_func ("/gvalue-to-gvariant/us", test_us); g_test_add_func ("/gvalue-to-gvariant/a{os}", test_a_os); g_test_add_func ("/gvalue-to-gvariant/av", test_av); + g_test_add_func ("/gvalue-to-gvariant/g", test_g); return g_test_run (); } -- cgit v1.2.3