bring back test_variant_return()

4 files changed, 204 insertions, 54 deletions

diff --git a/src/eggdbus/eggdbusvariant.c b/src/eggdbus/eggdbusvariant.c
index ee113ee..5f32c2c 100644
--- a/src/eggdbus/eggdbusvariant.c
+++ b/src/eggdbus/eggdbusvariant.c
@@ -362,20 +362,20 @@ egg_dbus_variant_new_for_uint16 (guint16 value)
 }
 
 EggDBusVariant *
-egg_dbus_variant_new_for_int32 (gint value)
+egg_dbus_variant_new_for_int (gint value)
 {
   EggDBusVariant *variant;
   variant = egg_dbus_variant_new ();
-  egg_dbus_variant_set_int32 (variant, value);
+  egg_dbus_variant_set_int (variant, value);
   return variant;
 }
 
 EggDBusVariant *
-egg_dbus_variant_new_for_uint32 (guint value)
+egg_dbus_variant_new_for_uint (guint value)
 {
   EggDBusVariant *variant;
   variant = egg_dbus_variant_new ();
-  egg_dbus_variant_set_uint32 (variant, value);
+  egg_dbus_variant_set_uint (variant, value);
   return variant;
 }
 
@@ -540,8 +540,8 @@ egg_dbus_variant_set_int16 (EggDBusVariant *variant,
   priv = EGG_DBUS_VARIANT_GET_PRIVATE (variant);
   if (priv->signature != NULL)
     g_value_unset (&priv->value);
-  g_value_init (&priv->value, G_TYPE_INT);
-  g_value_set_int (&priv->value, value);
+  g_value_init (&priv->value, EGG_DBUS_TYPE_INT16);
+  egg_dbus_value_set_int16 (&priv->value, value);
   set_signature (variant, "n");
 }
 
@@ -560,7 +560,7 @@ egg_dbus_variant_set_uint16 (EggDBusVariant *variant,
 }
 
 void
-egg_dbus_variant_set_int32 (EggDBusVariant *variant,
+egg_dbus_variant_set_int (EggDBusVariant *variant,
                           gint          value)
 {
   EggDBusVariantPrivate *priv;
@@ -574,7 +574,7 @@ egg_dbus_variant_set_int32 (EggDBusVariant *variant,
 }
 
 void
-egg_dbus_variant_set_uint32 (EggDBusVariant *variant,
+egg_dbus_variant_set_uint (EggDBusVariant *variant,
                            guint         value)
 {
   EggDBusVariantPrivate *priv;
@@ -752,7 +752,7 @@ egg_dbus_variant_get_int16 (EggDBusVariant *variant)
   EggDBusVariantPrivate *priv;
   g_return_val_if_fail (EGG_DBUS_IS_VARIANT (variant) && egg_dbus_variant_is_int16 (variant), 0);
   priv = EGG_DBUS_VARIANT_GET_PRIVATE (variant);
-  return g_value_get_int (&priv->value);
+  return egg_dbus_value_get_int16 (&priv->value);
 }
 
 guint16
@@ -764,20 +764,20 @@ egg_dbus_variant_get_uint16 (EggDBusVariant *variant)
   return egg_dbus_value_get_uint16 (&priv->value);
 }
 
-gint32
-egg_dbus_variant_get_int32 (EggDBusVariant *variant)
+gint
+egg_dbus_variant_get_int (EggDBusVariant *variant)
 {
   EggDBusVariantPrivate *priv;
-  g_return_val_if_fail (EGG_DBUS_IS_VARIANT (variant) && egg_dbus_variant_is_int32 (variant), 0);
+  g_return_val_if_fail (EGG_DBUS_IS_VARIANT (variant) && egg_dbus_variant_is_int (variant), 0);
   priv = EGG_DBUS_VARIANT_GET_PRIVATE (variant);
   return g_value_get_int (&priv->value);
 }
 
-guint32
-egg_dbus_variant_get_uint32 (EggDBusVariant *variant)
+guint
+egg_dbus_variant_get_uint (EggDBusVariant *variant)
 {
   EggDBusVariantPrivate *priv;
-  g_return_val_if_fail (EGG_DBUS_IS_VARIANT (variant) && egg_dbus_variant_is_uint32 (variant), 0);
+  g_return_val_if_fail (EGG_DBUS_IS_VARIANT (variant) && egg_dbus_variant_is_uint (variant), 0);
   priv = EGG_DBUS_VARIANT_GET_PRIVATE (variant);
   return g_value_get_uint (&priv->value);
 }
@@ -948,7 +948,7 @@ egg_dbus_variant_is_uint16 (EggDBusVariant *variant)
 }
 
 gboolean
-egg_dbus_variant_is_int32 (EggDBusVariant *variant)
+egg_dbus_variant_is_int (EggDBusVariant *variant)
 {
   EggDBusVariantPrivate *priv;
   priv = EGG_DBUS_VARIANT_GET_PRIVATE (variant);
@@ -959,7 +959,7 @@ egg_dbus_variant_is_int32 (EggDBusVariant *variant)
 }
 
 gboolean
-egg_dbus_variant_is_uint32 (EggDBusVariant *variant)
+egg_dbus_variant_is_uint (EggDBusVariant *variant)
 {
   EggDBusVariantPrivate *priv;
   priv = EGG_DBUS_VARIANT_GET_PRIVATE (variant);
diff --git a/src/eggdbus/eggdbusvariant.h b/src/eggdbus/eggdbusvariant.h
index 0aa2b32..aadb231 100644
--- a/src/eggdbus/eggdbusvariant.h
+++ b/src/eggdbus/eggdbusvariant.h
@@ -85,8 +85,8 @@ EggDBusVariant *egg_dbus_variant_new_for_signature_array (gchar               **
 EggDBusVariant *egg_dbus_variant_new_for_byte         (guchar                   value);
 EggDBusVariant *egg_dbus_variant_new_for_int16        (gint16                   value);
 EggDBusVariant *egg_dbus_variant_new_for_uint16       (guint16                  value);
-EggDBusVariant *egg_dbus_variant_new_for_int32        (gint                     value);
-EggDBusVariant *egg_dbus_variant_new_for_uint32       (guint                    value);
+EggDBusVariant *egg_dbus_variant_new_for_int          (gint                     value);
+EggDBusVariant *egg_dbus_variant_new_for_uint         (guint                    value);
 EggDBusVariant *egg_dbus_variant_new_for_int64        (gint64                   value);
 EggDBusVariant *egg_dbus_variant_new_for_uint64       (guint64                  value);
 EggDBusVariant *egg_dbus_variant_new_for_boolean      (gboolean                 value);
@@ -118,9 +118,9 @@ void         egg_dbus_variant_set_int16             (EggDBusVariant           *v
                                                      gint16                    value);
 void         egg_dbus_variant_set_uint16            (EggDBusVariant           *variant,
                                                      guint16                   value);
-void         egg_dbus_variant_set_int32             (EggDBusVariant           *variant,
+void         egg_dbus_variant_set_int               (EggDBusVariant           *variant,
                                                      gint                      value);
-void         egg_dbus_variant_set_uint32            (EggDBusVariant           *variant,
+void         egg_dbus_variant_set_uint              (EggDBusVariant           *variant,
                                                      guint                     value);
 void         egg_dbus_variant_set_int64             (EggDBusVariant           *variant,
                                                      gint64                    value);
@@ -151,8 +151,8 @@ gchar                 **egg_dbus_variant_get_signature_array (EggDBusVariant *va
 guchar                  egg_dbus_variant_get_byte            (EggDBusVariant *variant);
 gint16                  egg_dbus_variant_get_int16           (EggDBusVariant *variant);
 guint16                 egg_dbus_variant_get_uint16          (EggDBusVariant *variant);
-gint32                  egg_dbus_variant_get_int32           (EggDBusVariant *variant);
-guint32                 egg_dbus_variant_get_uint32          (EggDBusVariant *variant);
+gint                    egg_dbus_variant_get_int             (EggDBusVariant *variant);
+guint                   egg_dbus_variant_get_uint            (EggDBusVariant *variant);
 gint64                  egg_dbus_variant_get_int64           (EggDBusVariant *variant);
 guint64                 egg_dbus_variant_get_uint64          (EggDBusVariant *variant);
 gboolean                egg_dbus_variant_get_boolean         (EggDBusVariant *variant);
@@ -173,8 +173,8 @@ gboolean     egg_dbus_variant_is_signature_array    (EggDBusVariant *variant);
 gboolean     egg_dbus_variant_is_byte               (EggDBusVariant *variant);
 gboolean     egg_dbus_variant_is_int16              (EggDBusVariant *variant);
 gboolean     egg_dbus_variant_is_uint16             (EggDBusVariant *variant);
-gboolean     egg_dbus_variant_is_int32              (EggDBusVariant *variant);
-gboolean     egg_dbus_variant_is_uint32             (EggDBusVariant *variant);
+gboolean     egg_dbus_variant_is_int                (EggDBusVariant *variant);
+gboolean     egg_dbus_variant_is_uint               (EggDBusVariant *variant);
 gboolean     egg_dbus_variant_is_int64              (EggDBusVariant *variant);
 gboolean     egg_dbus_variant_is_uint64             (EggDBusVariant *variant);
 gboolean     egg_dbus_variant_is_boolean            (EggDBusVariant *variant);
diff --git a/src/tests/testclient.c b/src/tests/testclient.c
index 4ecaf08..04ceda9 100644
--- a/src/tests/testclient.c
+++ b/src/tests/testclient.c
@@ -1657,20 +1657,21 @@ test_array_of_arrays (void)
 
 /* ---------------------------------------------------------------------------------------------------- */
 
-#if 0
 static void
 test_variant_return (void)
 {
   GError *error;
   EggDBusVariant *variant;
   EggDBusStructure *structure;
-  GArray *my_array;
-  GArray *array;
+  EggDBusArraySeq *my_seq;
+  EggDBusArraySeq *seq;
   char **strv;
   TestPoint *point;
   TestDescribedPoint *dpoint;
-  GHashTable *hash_of_points;
+  EggDBusHashMap *hash_of_points;
   const char *s;
+  gint my_int0;
+  gint my_int1;
 
   error = NULL;
 
@@ -1725,8 +1726,8 @@ test_variant_return (void)
                                                        NULL,
                                                        &error));
   g_assert_no_error (error);
-  g_assert (egg_dbus_variant_is_int32 (variant));
-  g_assert_cmpint (egg_dbus_variant_get_int32 (variant), ==, 4);
+  g_assert (egg_dbus_variant_is_int (variant));
+  g_assert_cmpint (egg_dbus_variant_get_int (variant), ==, 4);
   g_object_unref (variant);
 
   g_assert (test_frob_invoke_test_variant_return_sync (TEST_QUERY_INTERFACE_FROB (object_proxy),
@@ -1736,8 +1737,8 @@ test_variant_return (void)
                                                        NULL,
                                                        &error));
   g_assert_no_error (error);
-  g_assert (egg_dbus_variant_is_uint32 (variant));
-  g_assert_cmpuint (egg_dbus_variant_get_uint32 (variant), ==, 5);
+  g_assert (egg_dbus_variant_is_uint (variant));
+  g_assert_cmpuint (egg_dbus_variant_get_uint (variant), ==, 5);
   g_object_unref (variant);
 
   g_assert (test_frob_invoke_test_variant_return_sync (TEST_QUERY_INTERFACE_FROB (object_proxy),
@@ -1802,11 +1803,11 @@ test_variant_return (void)
                                                        NULL,
                                                        &error));
   g_assert_no_error (error);
-  g_assert (egg_dbus_variant_is_array (variant));
-  array = egg_dbus_variant_get_array (variant);
-  g_assert_cmpuint (array->len, ==, 2);
-  g_assert_cmpint (g_array_index (array, gint32, 0), ==, 4);
-  g_assert_cmpint (g_array_index (array, gint32, 1), ==, 5);
+  g_assert (egg_dbus_variant_is_seq (variant));
+  seq = egg_dbus_variant_get_seq (variant);
+  g_assert_cmpuint (seq->size, ==, 2);
+  g_assert_cmpint (seq->data.v_int[0], ==, 4);
+  g_assert_cmpint (seq->data.v_int[1], ==, 5);
   g_object_unref (variant);
 
   g_assert (test_frob_invoke_test_variant_return_sync (TEST_QUERY_INTERFACE_FROB (object_proxy),
@@ -1858,19 +1859,19 @@ test_variant_return (void)
                                                        NULL,
                                                        &error));
   g_assert_no_error (error);
-  g_assert (egg_dbus_variant_is_hash_table (variant));
-  hash_of_points = egg_dbus_variant_get_hash_table (variant);
-  g_assert (g_hash_table_lookup (hash_of_points, "non-existent-key") == NULL);
-  g_assert ((point = g_hash_table_lookup (hash_of_points, "key0")) != NULL);
+  g_assert (egg_dbus_variant_is_map (variant));
+  hash_of_points = egg_dbus_variant_get_map (variant);
+  g_assert (egg_dbus_hash_map_lookup (hash_of_points, "non-existent-key") == NULL);
+  g_assert ((point = egg_dbus_hash_map_lookup (hash_of_points, "key0")) != NULL);
   g_assert_cmpint (test_point_get_x (point), ==, 1);
   g_assert_cmpint (test_point_get_y (point), ==, 2);
-  g_assert ((point = g_hash_table_lookup (hash_of_points, "key1")) != NULL);
+  g_assert ((point = egg_dbus_hash_map_lookup (hash_of_points, "key1")) != NULL);
   g_assert_cmpint (test_point_get_x (point), ==, 3);
   g_assert_cmpint (test_point_get_y (point), ==, 4);
-  g_assert ((point = g_hash_table_lookup (hash_of_points, "key2")) != NULL);
+  g_assert ((point = egg_dbus_hash_map_lookup (hash_of_points, "key2")) != NULL);
   g_assert_cmpint (test_point_get_x (point), ==, 5);
   g_assert_cmpint (test_point_get_y (point), ==, 6);
-  g_assert ((point = g_hash_table_lookup (hash_of_points, "key3")) != NULL);
+  g_assert ((point = egg_dbus_hash_map_lookup (hash_of_points, "key3")) != NULL);
   g_assert_cmpint (test_point_get_x (point), ==, 7);
   g_assert_cmpint (test_point_get_y (point), ==, 8);
   g_object_unref (variant);
@@ -1885,22 +1886,29 @@ test_variant_return (void)
 
   structure = egg_dbus_variant_get_structure (variant);
 
+  g_assert_cmpstr (egg_dbus_structure_get_signature (structure), ==, "(iiax)");
+
   egg_dbus_structure_get_element (structure,
-                                  4, &my_array,
+                                  0, &my_int0,
+                                  1, &my_int1,
+                                  2, &my_seq,
                                   -1);
 
-  g_assert_cmpstr (egg_dbus_array_get_elem_signature (my_array), ==, "i");
-  g_assert_cmpuint (my_array->len, ==, 4);
-  g_assert_cmpint (g_array_index (my_array, gint32, 0), ==, 0);
-  g_assert_cmpint (g_array_index (my_array, gint32, 1), ==, 1);
-  g_assert_cmpint (g_array_index (my_array, gint32, 2), ==, 2);
-  g_assert_cmpint (g_array_index (my_array, gint32, 3), ==, 3);
+  g_assert_cmpint (my_int0, ==, 42);
+  g_assert_cmpint (my_int1, ==, 43);
+  g_assert_cmpuint (my_seq->element_type, ==, G_TYPE_INT64);
+  g_assert_cmpuint (my_seq->size, ==, 4);
+  g_assert_cmpint (my_seq->data.v_int64[0], ==, 0);
+  g_assert_cmpint (my_seq->data.v_int64[1], ==, 1);
+  g_assert_cmpint (my_seq->data.v_int64[2], ==, 2);
+  g_assert_cmpint (my_seq->data.v_int64[3], ==, 3);
 
   g_object_unref (variant);
 }
 
 /* ---------------------------------------------------------------------------------------------------- */
 
+#if 0
 static void
 test_variant_return2 (void)
 {
@@ -2026,7 +2034,7 @@ test_pass_variant2 (void)
   ret_double = 5.5;  g_array_append_val (array_double, ret_double);
 
   array_of_variants = g_list_append (NULL,              egg_dbus_variant_new_for_string ("foo"));
-  array_of_variants = g_list_append (array_of_variants, egg_dbus_variant_new_for_int32 (64));
+  array_of_variants = g_list_append (array_of_variants, egg_dbus_variant_new_for_int (64));
   array_of_variants = g_list_append (array_of_variants, egg_dbus_variant_new_for_boolean (TRUE));
 
   dict_of_string_to_variants = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_object_unref);
@@ -4424,7 +4432,7 @@ main (int argc, char *argv[])
   test_hash_table_of_hash_table_of_structures ();
   test_array_of_hash_table_of_structures ();
   test_array_of_arrays ();
-  /*test_variant_return ();*/
+  test_variant_return ();
   /*test_variant_return2 ();*/
   /*test_pass_variant ();*/
   /*test_pass_variant2 ();*/
diff --git a/src/tests/testfrobimpl.c b/src/tests/testfrobimpl.c
index e0bbb5c..0661274 100644
--- a/src/tests/testfrobimpl.c
+++ b/src/tests/testfrobimpl.c
@@ -1002,6 +1002,147 @@ frob_iface_handle_test_array_of_arrays (TestFrob *instance,
 }
 
 static void
+frob_iface_handle_test_variant_return (TestFrob *instance,
+                                       const gchar *desired_variant,
+                                       EggDBusMethodInvocation *method_invocation)
+{
+  EggDBusVariant *variant;
+
+  if (strcmp (desired_variant, "y") == 0)
+    {
+      variant = egg_dbus_variant_new_for_byte (1);
+    }
+  else if (strcmp (desired_variant, "b") == 0)
+    {
+      variant = egg_dbus_variant_new_for_boolean (TRUE);
+    }
+  else if (strcmp (desired_variant, "n") == 0)
+    {
+      variant = egg_dbus_variant_new_for_int16 (2);
+    }
+  else if (strcmp (desired_variant, "q") == 0)
+    {
+      variant = egg_dbus_variant_new_for_uint16 (3);
+    }
+  else if (strcmp (desired_variant, "i") == 0)
+    {
+      variant = egg_dbus_variant_new_for_int (4);
+    }
+  else if (strcmp (desired_variant, "u") == 0)
+    {
+      variant = egg_dbus_variant_new_for_uint (5);
+    }
+  else if (strcmp (desired_variant, "x") == 0)
+    {
+      variant = egg_dbus_variant_new_for_int64 (6);
+    }
+  else if (strcmp (desired_variant, "t") == 0)
+    {
+      variant = egg_dbus_variant_new_for_uint64 (7);
+    }
+  else if (strcmp (desired_variant, "d") == 0)
+    {
+      variant = egg_dbus_variant_new_for_double (7.5);
+    }
+  else if (strcmp (desired_variant, "s") == 0)
+    {
+      variant = egg_dbus_variant_new_for_string ("a string");
+    }
+  else if (strcmp (desired_variant, "o") == 0)
+    {
+      variant = egg_dbus_variant_new_for_object_path ("/some/object/path");
+    }
+  else if (strcmp (desired_variant, "ai") == 0)
+    {
+      EggDBusArraySeq *a;
+
+      a = egg_dbus_array_seq_new (G_TYPE_INT, NULL, NULL, NULL);
+      egg_dbus_array_seq_add_fixed (a, 4);
+      egg_dbus_array_seq_add_fixed (a, 5);
+      variant = egg_dbus_variant_new_for_seq (a, "i");
+      g_object_unref (a);
+    }
+  else if (strcmp (desired_variant, "as") == 0)
+    {
+      gchar *strv[] = {"a string", "another string", NULL};
+
+      variant = egg_dbus_variant_new_for_string_array (strv);
+    }
+  else if (strcmp (desired_variant, "point") == 0)
+    {
+      TestPoint *point;
+
+      point = test_point_new (1, 2);
+      variant = egg_dbus_variant_new_for_structure (EGG_DBUS_STRUCTURE (point));
+      g_object_unref (point);
+    }
+  else if (strcmp (desired_variant, "dpoint") == 0)
+    {
+      TestDescribedPoint *dpoint;
+      TestPoint *point;
+
+      point = test_point_new (3, 4);
+      dpoint = test_described_point_new ("the desc", point);
+      g_object_unref (point);
+      variant = egg_dbus_variant_new_for_structure (EGG_DBUS_STRUCTURE (dpoint));
+      g_object_unref (dpoint);
+    }
+  else if (strcmp (desired_variant, "hash_of_points") == 0)
+    {
+      EggDBusHashMap *hash_of_points;
+
+      hash_of_points = egg_dbus_hash_map_new (G_TYPE_STRING, NULL, TEST_TYPE_POINT, g_object_unref);
+      egg_dbus_hash_map_insert (hash_of_points, "key0", test_point_new (1, 2));
+      egg_dbus_hash_map_insert (hash_of_points, "key1", test_point_new (3, 4));
+      egg_dbus_hash_map_insert (hash_of_points, "key2", test_point_new (5, 6));
+      egg_dbus_hash_map_insert (hash_of_points, "key3", test_point_new (7, 8));
+      variant = egg_dbus_variant_new_for_map (hash_of_points, "s", "(ii)");
+      g_object_unref (hash_of_points);
+    }
+  else if (strcmp (desired_variant, "unregistered_struct") == 0)
+    {
+      EggDBusStructure *s;
+      EggDBusArraySeq *a;
+      GValue *elements;
+
+      a = egg_dbus_array_seq_new (G_TYPE_INT64, NULL, NULL, NULL);
+      egg_dbus_array_seq_add_fixed (a, 0);
+      egg_dbus_array_seq_add_fixed (a, 1);
+      egg_dbus_array_seq_add_fixed (a, 2);
+      egg_dbus_array_seq_add_fixed (a, 3);
+
+      elements = g_new0 (GValue, 3);
+      g_value_init (&elements[0], G_TYPE_INT);
+      g_value_set_int (&elements[0], 42);
+
+      g_value_init (&elements[1], G_TYPE_INT);
+      g_value_set_int (&elements[1], 43);
+
+      g_value_init (&elements[2], EGG_DBUS_TYPE_ARRAY_SEQ);
+      g_value_take_object (&elements[2], a);
+
+      s = egg_dbus_structure_new ("(iiax)", elements);
+
+      variant = egg_dbus_variant_new_for_structure (s);
+      g_object_unref (s);
+    }
+  else
+    {
+      egg_dbus_method_invocation_return_error (method_invocation,
+                                               TEST_ERROR,
+                                               TEST_ERROR_FLUX_CAPACITOR_FAILURE,
+                                               "desired_variant '%s' not supported",
+                                               desired_variant);
+      return;
+    }
+
+  test_frob_handle_test_variant_return_finish (method_invocation,
+                                               variant);
+
+  g_object_unref (variant);
+}
+
+static void
 test_frob_impl_frob_iface_init (TestFrobIface *iface)
 {
   iface->handle_hello_world                                  = frob_iface_handle_hello_world;
@@ -1016,4 +1157,5 @@ test_frob_impl_frob_iface_init (TestFrobIface *iface)
   iface->handle_test_hash_table_of_hash_tables_of_structures = frob_iface_handle_test_hash_table_of_hash_tables_of_structures;
   iface->handle_test_array_of_hash_tables_of_structures      = frob_iface_handle_test_array_of_hash_tables_of_structures;
   iface->handle_test_array_of_arrays                         = frob_iface_handle_test_array_of_arrays;
+  iface->handle_test_variant_return                          = frob_iface_handle_test_variant_return;
 }