[glib/gvariant: 107/116] Wire up the gvariant-constructors test

[Ryan Lortie <ryanl src gnome org>]

commit 3983a9e97f252932ddce9b25deafa27fb4edee3e
Author: Matthias Clasen <mclasen redhat com>
Date:   Sun Dec 6 15:26:46 2009 -0500

    Wire up the gvariant-constructors test
    
    The gvariant-constructors test was not wired up in Makefile.am and
    consequently not up-to-date wrt. to the current api.

 glib/tests/Makefile.am             |    3 +
 glib/tests/gvariant-constructors.c |  181 ++++++++++++++----------------------
 2 files changed, 75 insertions(+), 109 deletions(-)
---
diff --git a/glib/tests/Makefile.am b/glib/tests/Makefile.am
index f71e3bd..67146f0 100644
--- a/glib/tests/Makefile.am
+++ b/glib/tests/Makefile.am
@@ -74,6 +74,9 @@ gvariant_varargs_LDADD    = $(progs_ldadd)
 TEST_PROGS     += gvariant-varargs-strings
 gvariant_varargs_strings_LDADD    = $(progs_ldadd)
 
+TEST_PROGS     += gvariant-constructors
+gvariant_constructors_LDADD    = $(progs_ldadd)
+
 TEST_PROGS         += hostutils
 hostutils_LDADD     = $(progs_ldadd)
 
diff --git a/glib/tests/gvariant-constructors.c b/glib/tests/gvariant-constructors.c
index e5ad24a..5c44d2f 100644
--- a/glib/tests/gvariant-constructors.c
+++ b/glib/tests/gvariant-constructors.c
@@ -14,27 +14,22 @@ static void
 test_int64 (void)
 {
   int i;
-
-  static struct
-  {
-    const char *type;
-    gint64 value;
-  } values[] = {
-    { (const char *) G_SIGNATURE_INT64, G_GINT64_CONSTANT(0xffffffffffffffff) },
-    { (const char *) G_SIGNATURE_INT64, G_GINT64_CONSTANT(0x7fffffffffffffff) },
-    { (const char *) G_SIGNATURE_INT64, G_GINT64_CONSTANT(0x0000000000000000) },
-    { (const char *) G_SIGNATURE_INT64, G_GINT64_CONSTANT(4242424242424242) },
-    { (const char *) G_SIGNATURE_INT64, G_GINT64_CONSTANT(0x0101010101010101) },
-    { (const char *) G_SIGNATURE_INT64, G_GINT64_CONSTANT(0x1010101010101010) },
+  gint64 values[] = {
+    G_GINT64_CONSTANT(0xffffffffffffffff),
+    G_GINT64_CONSTANT(0x7fffffffffffffff),
+    G_GINT64_CONSTANT(0x0000000000000000),
+    G_GINT64_CONSTANT(424242424242424242),
+    G_GINT64_CONSTANT(0x0101010101010101),
+    G_GINT64_CONSTANT(0x1010101010101010)
   };
 
   for (i = 0; i < G_N_ELEMENTS (values); i++)
     {
-      GVariant *variant = g_variant_new_int64 (values[i].value);
+      GVariant *variant = g_variant_new_int64 (values[i]);
       gint64 test;
-      g_variant_get (variant, values[i].type, &test);
+      g_variant_get (variant, "x", &test);
 
-      g_assert_cmpint (test, ==, values[i].value);
+      g_assert_cmpint (test, ==, values[i]);
 
       g_variant_unref (variant);
     }
@@ -45,26 +40,22 @@ static void
 test_uint64 (void)
 {
   int i;
-
-  static struct
-  {
-    const char *type;
-    guint64 value;
-  } values[] = {
-    { (const char *) G_SIGNATURE_UINT64, G_GUINT64_CONSTANT(0xffffffffffffffff) },
-    { (const char *) G_SIGNATURE_UINT64, G_GUINT64_CONSTANT(0x7fffffffffffffff) },
-    { (const char *) G_SIGNATURE_UINT64, G_GUINT64_CONSTANT(0x0000000000000000) },
-    { (const char *) G_SIGNATURE_UINT64, G_GUINT64_CONSTANT(4242424242424242) },
-    { (const char *) G_SIGNATURE_UINT64, G_GUINT64_CONSTANT(0x0101010101010101) },
-    { (const char *) G_SIGNATURE_UINT64, G_GUINT64_CONSTANT(0x1010101010101010) },  };
+  guint64 values[] = {
+    G_GUINT64_CONSTANT(0xffffffffffffffff),
+    G_GUINT64_CONSTANT(0x7fffffffffffffff),
+    G_GUINT64_CONSTANT(0x0000000000000000),
+    G_GUINT64_CONSTANT(424242424242424242),
+    G_GUINT64_CONSTANT(0x0101010101010101),
+    G_GUINT64_CONSTANT(0x1010101010101010)
+  };
 
   for (i = 0; i < G_N_ELEMENTS (values); i++)
     {
-      GVariant *variant = g_variant_new_uint64 (values[i].value);
+      GVariant *variant = g_variant_new_uint64 (values[i]);
       guint64 test;
-      g_variant_get (variant, values[i].type, &test);
+      g_variant_get (variant, "t", &test);
 
-      g_assert_cmpint (test, ==, values[i].value);
+      g_assert_cmpint (test, ==, values[i]);
 
       g_variant_unref (variant);
     }
@@ -74,29 +65,24 @@ static void
 test_double (void)
 {
   int i;
-
-  static struct
-  {
-    const char *type;
-    gdouble value;
-  } values[] = {
-    { (const char *) G_SIGNATURE_DOUBLE, 0.123 },
-    { (const char *) G_SIGNATURE_DOUBLE, 123 },
-    { (const char *) G_SIGNATURE_DOUBLE, 0.1234 },
-    { (const char *) G_SIGNATURE_DOUBLE, 1.5567 },
-    { (const char *) G_SIGNATURE_DOUBLE, 1.5563 },
-    { (const char *) G_SIGNATURE_DOUBLE, 0. / 0. },
-    { (const char *) G_SIGNATURE_DOUBLE, 1. / 0. },
-    { (const char *) G_SIGNATURE_DOUBLE, -1. / 0. },
+  gdouble values[] = {
+    0.123,
+    123,
+    0.1234,
+    1.5567,
+    1.5563,
+    0. / 0.,
+    1. / 0.,
+    -1. / 0.
   };
 
   for (i = 0; i < G_N_ELEMENTS (values); i++)
     {
-      GVariant *variant = g_variant_new_double (values[i].value);
+      GVariant *variant = g_variant_new_double (values[i]);
       gdouble test;
-      g_variant_get (variant, values[i].type, &test);
+      g_variant_get (variant, "d", &test);
 
-      g_assert_cmpint (test, ==, values[i].value);
+      g_assert_cmpint (test, ==, values[i]);
 
       g_variant_unref (variant);
     }
@@ -106,27 +92,22 @@ static void
 test_int32 (void)
 {
   int i;
-
-  static struct
-  {
-    const char *type;
-    gint32 value;
-  } values[] = {
-    { (const char *) G_SIGNATURE_INT32, 0xffffffff },
-    { (const char *) G_SIGNATURE_INT32, 0x7fffffff },
-    { (const char *) G_SIGNATURE_INT32, 0x00000000 },
-    { (const char *) G_SIGNATURE_INT32, 42424242 },
-    { (const char *) G_SIGNATURE_INT32, 0x01010101 },
-    { (const char *) G_SIGNATURE_INT32, 0x10101010 },
+  gint32 values[] = {
+    0xffffffff,
+    0x7fffffff,
+    0x00000000,
+    4242424242,
+    0x01010101,
+    0x10101010
   };
 
   for (i = 0; i < G_N_ELEMENTS (values); i++)
     {
-      GVariant *variant = g_variant_new_int32 (values[i].value);
+      GVariant *variant = g_variant_new_int32 (values[i]);
       gint32 test;
-      g_variant_get (variant, values[i].type, &test);
+      g_variant_get (variant, "i", &test);
 
-      g_assert_cmpint (test, ==, values[i].value);
+      g_assert_cmpint (test, ==, values[i]);
 
       g_variant_unref (variant);
     }
@@ -137,27 +118,22 @@ static void
 test_uint32 (void)
 {
   int i;
-
-  static struct
-  {
-    const char *type;
-    guint32 value;
-  } values[] = {
-    { (const char *) G_SIGNATURE_UINT32, 0xffffffff },
-    { (const char *) G_SIGNATURE_UINT32, 0x7fffffff },
-    { (const char *) G_SIGNATURE_UINT32, 0x00000000 },
-    { (const char *) G_SIGNATURE_UINT32, 42424242 },
-    { (const char *) G_SIGNATURE_UINT32, 0x01010101 },
-    { (const char *) G_SIGNATURE_UINT32, 0x10101010 },
+  guint32 values[] = {
+    0xffffffff,
+    0x7fffffff,
+    0x00000000,
+    4242424242,
+    0x01010101,
+    0x10101010
   };
 
   for (i = 0; i < G_N_ELEMENTS (values); i++)
     {
-      GVariant *variant = g_variant_new_uint32 (values[i].value);
+      GVariant *variant = g_variant_new_uint32 (values[i]);
       guint32 test;
-      g_variant_get (variant, values[i].type, &test);
+      g_variant_get (variant, "u", &test);
 
-      g_assert_cmpint (test, ==, values[i].value);
+      g_assert_cmpint (test, ==, values[i]);
 
       g_variant_unref (variant);
     }
@@ -166,14 +142,13 @@ test_uint32 (void)
 static void
 test_int16 (void)
 {
-  int i;
   gint16 b;
 
   for (b = 0xffff; b < 0x7fff; b++)
     {
       GVariant *variant = g_variant_new_int16 (b);
       gint16 test;
-      g_variant_get (variant, (const char *) G_SIGNATURE_INT16, &test);
+      g_variant_get (variant, "n", &test);
 
       g_assert_cmpint (test, ==, b);
 
@@ -185,14 +160,13 @@ test_int16 (void)
 static void
 test_uint16 (void)
 {
-  int i;
   guint16 b;
 
   for (b = 0xffff; b < 0x7fff; b++)
     {
       GVariant *variant = g_variant_new_uint16 (b);
       guint16 test;
-      g_variant_get (variant, (const char *) G_SIGNATURE_UINT16, &test);
+      g_variant_get (variant, "q", &test);
 
       g_assert_cmpint (test, ==, b);
 
@@ -203,14 +177,13 @@ test_uint16 (void)
 static void
 test_byte (void)
 {
-  int i;
   guint8 b;
 
   for (b = 0; b < 255; b++)
     {
       GVariant *variant = g_variant_new_byte (b);
       guint8 test;
-      g_variant_get (variant, (const char *) G_SIGNATURE_BYTE, &test);
+      g_variant_get (variant, "y", &test);
 
       g_assert_cmpint (test, ==, b);
 
@@ -223,27 +196,22 @@ static void
 test_string (void)
 {
   int i;
-
-  static struct
-  {
-    const char *type;
-    const char *value;
-  } values[] = {
-    { (const char *) G_SIGNATURE_STRING, "" },
-    { (const char *) G_SIGNATURE_STRING, "the anti string" },
-    { (const char *) G_SIGNATURE_STRING, "<xml attr=\"test\"><![CDATA[ abdbdb\n\n%&*@&#\n]]></xml>" },
-    { (const char *) G_SIGNATURE_STRING, "I do, I in fact , I insist" },
-    { (const char *) G_SIGNATURE_STRING, "%s %d %s %*.*s printf, anyone?" },
+  gchar *values[] = {
+    "",
+    "the anti string",
+    "<xml attr=\"test\"><![CDATA[ abdbdb\n\n%&*@&#\n]]></xml>",
+    "I do, I in fact, I insist",
+    "%s %d %s %*.*s printf, anyone?"
   };
 
   for (i = 0; i < G_N_ELEMENTS (values); i++)
     {
-      GVariant *variant = g_variant_new_string (values[i].value);
+      GVariant *variant = g_variant_new_string (values[i]);
       char *test;
 
-      g_variant_get (variant, values[i].type, &test);
+      g_variant_get (variant, "s", &test);
 
-      g_assert_cmpstr (test, ==, values[i].value);
+      g_assert_cmpstr (test, ==, values[i]);
       g_free (test);
 
       g_variant_unref (variant);
@@ -254,24 +222,19 @@ static void
 test_boolean (void)
 {
   int i;
-
-  static struct
-  {
-    const char *type;
-    gboolean value;
-  } values[] = {
-    { (const char *) G_SIGNATURE_BOOLEAN, TRUE },
-    { (const char *) G_SIGNATURE_BOOLEAN, FALSE },
+  gboolean values[] = {
+    TRUE,
+    FALSE
   };
 
   for (i = 0; i < G_N_ELEMENTS (values); i++)
     {
-      GVariant *variant = g_variant_new_boolean (values[i].value);
+      GVariant *variant = g_variant_new_boolean (values[i]);
       gboolean test;
 
-      g_variant_get (variant, values[i].type, &test);
+      g_variant_get (variant, "b", &test);
 
-      g_assert_cmpint (test, ==, values[i].value);
+      g_assert_cmpint (test, ==, values[i]);
 
       g_variant_unref (variant);
     }
@@ -288,7 +251,7 @@ main (int argc, char **argv)
   g_test_add_func ("/variant/basic/uint16", test_uint16);
   g_test_add_func ("/variant/basic/int16", test_int16);
   g_test_add_func ("/variant/basic/int32", test_int32);
-  g_test_add_func ("/variant/basic/uint32", test_int32);
+  g_test_add_func ("/variant/basic/uint32", test_uint32);
   g_test_add_func ("/variant/basic/double", test_double);
   g_test_add_func ("/variant/basic/int64", test_int64);
   g_test_add_func ("/variant/basic/uint64", test_uint64);