#include "config.h"
#include <glib/gvariant-internal.h>
+#include <glib/glib-private.h>
#include <string.h>
#include <stdlib.h>
#include <glib.h>
g_variant_serialiser_serialise (serialised, random_instance_filler,
(gpointer *) instances, n_children);
- g_assert (memcmp (serialised.data, data, serialised.size) == 0);
+ if (serialised.size)
+ g_assert (memcmp (serialised.data, data, serialised.size) == 0);
+
g_assert (g_variant_serialised_n_children (serialised) == n_children);
for (i = 0; i < n_children; i++)
g_variant_serialiser_serialise (serialised, random_instance_filler,
(gpointer *) instances, n_children);
- g_assert (memcmp (serialised.data, data, serialised.size) == 0);
+ if (serialised.size)
+ g_assert (memcmp (serialised.data, data, serialised.size) == 0);
+
g_assert (g_variant_serialised_n_children (serialised) == n_children);
for (i = 0; i < n_children; i++)
g_variant_serialiser_serialise (serialised, random_instance_filler,
(gpointer *) &instance, 1);
- g_assert (memcmp (serialised.data, data, serialised.size) == 0);
+ if (serialised.size)
+ g_assert (memcmp (serialised.data, data, serialised.size) == 0);
+
g_assert (g_variant_serialised_n_children (serialised) == 1);
child = g_variant_serialised_get_child (serialised, 0);
union {
guint64 integer;
gdouble floating;
- gchar string[32];
+ gchar string[200];
} data;
gsize data_size;
};
break;
case 's': case 'o': case 'g':
- instance->data_size = g_test_rand_int_range (10, 20);
+ instance->data_size = g_test_rand_int_range (10, 200);
make_random_string (instance->data.string, instance->data_size, type);
break;
}
serialise_tree (TreeInstance *tree,
GVariantSerialised *serialised)
{
- GVariantSerialised empty = { };
+ GVariantSerialised empty = {0, };
*serialised = empty;
tree_filler (serialised, tree);
return result;
}
+static GVariant *
+create_random_gvariant (guint depth)
+{
+ TreeInstance *tree;
+ GVariant *value;
+
+ tree = tree_instance_new (NULL, depth);
+ value = g_variant_take_ref (tree_instance_get_gvariant (tree));
+ tree_instance_free (tree);
+
+ return value;
+}
+
static gboolean
tree_instance_check_gvariant (TreeInstance *tree,
GVariant *value)
}
static void
+test_string (void)
+{
+ /* Test some different methods of creating strings */
+ GVariant *v;
+
+ v = g_variant_new_string ("foo");
+ g_assert_cmpstr (g_variant_get_string (v, NULL), ==, "foo");
+ g_variant_unref (v);
+
+
+ v = g_variant_new_take_string (g_strdup ("foo"));
+ g_assert_cmpstr (g_variant_get_string (v, NULL), ==, "foo");
+ g_variant_unref (v);
+
+ v = g_variant_new_printf ("%s %d", "foo", 123);
+ g_assert_cmpstr (g_variant_get_string (v, NULL), ==, "foo 123");
+ g_variant_unref (v);
+}
+
+static void
test_utf8 (void)
{
const gchar invalid[] = "hello\xffworld";
}
static void
-exit_on_abort (int signal)
-{
- exit (signal);
-}
-
-static gboolean
-do_failed_test (const gchar *pattern)
+do_failed_test (const char *test,
+ const gchar *pattern)
{
- if (g_test_trap_fork (1000000, G_TEST_TRAP_SILENCE_STDERR))
- {
- signal (SIGABRT, exit_on_abort);
- return TRUE;
- }
-
+ g_test_trap_subprocess (test, 1000000, 0);
g_test_trap_assert_failed ();
g_test_trap_assert_stderr (pattern);
-
- return FALSE;
}
static void
value = g_variant_new ("y", 'a');
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
- "*type of `q' but * has a type of `y'*");
+ "*type of 'q' but * has a type of 'y'*");
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*valid_format_string*");
g_variant_get (value, "q");
}
static void
+test_varargs_empty_array (void)
+{
+ g_variant_new ("(a{s*})", NULL);
+
+ g_assert_not_reached ();
+}
+
+static void
test_varargs (void)
{
{
g_variant_unref (value);
g_free (str);
- if (do_failed_test ("*which type of empty array*"))
- g_variant_new ("(a{s*})", NULL);
+ do_failed_test ("/gvariant/varargs/subprocess/empty-array",
+ "*which type of empty array*");
}
g_variant_type_info_assert_no_infos ();
}
static void
-test_gv_byteswap ()
+test_gv_byteswap (void)
{
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
# define native16(x) x, 0
g_free (printed);
}
+ /* escapes */
+ {
+ const gchar orig[] = " \342\200\254 \360\220\210\240 \a \b \f \n \r \t \v ";
+ GVariant *value;
+ gchar *printed;
+
+ value = g_variant_new_string (orig);
+ printed = g_variant_print (value, FALSE);
+ g_variant_unref (value);
+
+ g_assert_cmpstr (printed, ==, "' \\u202c \\U00010220 \\a \\b \\f \\n \\r \\t \\v '");
+ value = g_variant_parse (NULL, printed, NULL, NULL, NULL);
+ g_assert_cmpstr (g_variant_get_string (value, NULL), ==, orig);
+ g_variant_unref (value);
+ g_free (printed);
+ }
+
+#ifndef _MSC_VER
+ /* inf/nan strings are C99 features which Visual C++ does not support */
/* inf/nan mini test */
{
const gchar *tests[] = { "inf", "-inf", "nan" };
GVariant *value;
gchar *printed;
+ gchar *printed_down;
gint i;
for (i = 0; i < G_N_ELEMENTS (tests); i++)
GError *error = NULL;
value = g_variant_parse (NULL, tests[i], NULL, NULL, &error);
printed = g_variant_print (value, FALSE);
- g_assert (g_str_has_prefix (printed, tests[i]));
+ /* Canonicalize to lowercase; https://bugzilla.gnome.org/show_bug.cgi?id=704585 */
+ printed_down = g_ascii_strdown (printed, -1);
+ g_assert (g_str_has_prefix (printed_down, tests[i]));
g_free (printed);
+ g_free (printed_down);
g_variant_unref (value);
}
}
+#endif
g_variant_type_info_assert_no_infos ();
}
"[1, 2,", "6:", "expected value",
"", "0:", "expected value",
"(1, 2,", "6:", "expected value",
- "<1", "2:", "expected `>'",
+ "<1", "2:", "expected '>'",
"[]", "0-2:", "unable to infer",
"(,", "1:", "expected value",
"[4,'']", "1-2,3-5:", "common type",
"just [4, '']", "6-7,9-11:", "common type",
"[[4,'']]", "2-3,4-6:", "common type",
"([4,''],)", "2-3,4-6:", "common type",
- "(4)", "2:", "`,'",
+ "(4)", "2:", "','",
"{}", "0-2:", "unable to infer",
"{[1,2],[3,4]}", "0-13:", "basic types",
"{[1,2]:[3,4]}", "0-13:", "basic types",
"@i ()", "3-5:", "can not parse as",
"@ai (4,)", "4-8:", "can not parse as",
"@(i) []", "5-7:", "can not parse as",
- "(5 5)", "3:", "expected `,'",
- "[5 5]", "3:", "expected `,' or `]'",
- "(5, 5 5)", "6:", "expected `,' or `)'",
- "[5, 5 5]", "6:", "expected `,' or `]'",
+ "(5 5)", "3:", "expected ','",
+ "[5 5]", "3:", "expected ',' or ']'",
+ "(5, 5 5)", "6:", "expected ',' or ')'",
+ "[5, 5 5]", "6:", "expected ',' or ']'",
"<@i []>", "4-6:", "can not parse as",
- "<[5 5]>", "4:", "expected `,' or `]'",
+ "<[5 5]>", "4:", "expected ',' or ']'",
"{[4,''],5}", "2-3,4-6:", "common type",
"{5,[4,'']}", "4-5,6-8:", "common type",
"@i {1,2}", "3-8:", "can not parse as",
"@ai {}", "4-6:", "can not parse as",
"{@i '': 5}", "4-6:", "can not parse as",
"{5: @i ''}", "7-9:", "can not parse as",
- "{<4,5}", "3:", "expected `>'",
- "{4,<5}", "5:", "expected `>'",
- "{4,5,6}", "4:", "expected `}'",
- "{5 5}", "3:", "expected `:' or `,'",
- "{4: 5: 6}", "5:", "expected `,' or `}'",
- "{4:5,<6:7}", "7:", "expected `>'",
- "{4:5,6:<7}", "9:", "expected `>'",
- "{4:5,6 7}", "7:", "expected `:'",
+ "{<4,5}", "3:", "expected '>'",
+ "{4,<5}", "5:", "expected '>'",
+ "{4,5,6}", "4:", "expected '}'",
+ "{5 5}", "3:", "expected ':' or ','",
+ "{4: 5: 6}", "5:", "expected ',' or '}'",
+ "{4:5,<6:7}", "7:", "expected '>'",
+ "{4:5,6:<7}", "9:", "expected '>'",
+ "{4:5,6 7}", "7:", "expected ':'",
"@o 'foo'", "3-8:", "object path",
"@g 'zzz'", "3-8:", "signature",
"@i true", "3-7:", "can not parse as",
"@z 4", "0-2:", "invalid type",
"@a* []", "0-3:", "definite",
- "@ai [3 3]", "7:", "expected `,' or `]'",
+ "@ai [3 3]", "7:", "expected ',' or ']'",
"18446744073709551616", "0-20:", "too big for any type",
"-18446744073709551616", "0-21:", "too big for any type",
"byte 256", "5-8:", "out of range for type",
g_assert (value == NULL);
if (!strstr (error->message, test[i+2]))
- g_error ("test %d: Can't find `%s' in `%s'", i / 3,
+ g_error ("test %d: Can't find '%s' in '%s'", i / 3,
test[i+2], error->message);
if (!g_str_has_prefix (error->message, test[i+1]))
- g_error ("test %d: Expected location `%s' in `%s'", i / 3,
+ g_error ("test %d: Expected location '%s' in '%s'", i / 3,
test[i+1], error->message);
g_error_free (error);
}
static void
+test_parse_bad_format_char (void)
+{
+ g_variant_new_parsed ("%z");
+
+ g_assert_not_reached ();
+}
+
+static void
+test_parse_bad_format_string (void)
+{
+ g_variant_new_parsed ("uint32 %i", 2);
+
+ g_assert_not_reached ();
+}
+
+static void
+test_parse_bad_args (void)
+{
+ g_variant_new_parsed ("%@i", g_variant_new_uint32 (2));
+
+ g_assert_not_reached ();
+}
+
+static void
test_parse_positional (void)
{
GVariant *value;
if (g_test_undefined ())
{
- if (do_failed_test ("*GVariant format string*"))
- {
- g_variant_new_parsed ("%z");
- abort ();
- }
+ do_failed_test ("/gvariant/parse/subprocess/bad-format-char",
+ "*GVariant format string*");
- if (do_failed_test ("*can not parse as*"))
- {
- g_variant_new_parsed ("uint32 %i", 2);
- abort ();
- }
+ do_failed_test ("/gvariant/parse/subprocess/bad-format-string",
+ "*can not parse as*");
- if (do_failed_test ("*expected GVariant of type `i'*"))
- {
- g_variant_new_parsed ("%@i", g_variant_new_uint32 (2));
- abort ();
- }
+ do_failed_test ("/gvariant/parse/subprocess/bad-args",
+ "*expected GVariant of type 'i'*");
}
}
g_variant_unref (dict);
}
+static GVariant *
+untrusted (GVariant *a)
+{
+ GVariant *b;
+ const GVariantType *type;
+ GBytes *bytes;
+
+ type = g_variant_get_type (a);
+ bytes = g_variant_get_data_as_bytes (a);
+ b = g_variant_new_from_bytes (type, bytes, FALSE);
+ g_bytes_unref (bytes);
+ g_variant_unref (a);
+
+ return b;
+}
+
static void
test_compare (void)
{
GVariant *a;
GVariant *b;
- a = g_variant_new_byte (5);
+ a = untrusted (g_variant_new_byte (5));
b = g_variant_new_byte (6);
g_assert (g_variant_compare (a, b) < 0);
g_variant_unref (a);
g_variant_unref (b);
- a = g_variant_new_string ("abc");
+ a = untrusted (g_variant_new_int16 (G_MININT16));
+ b = g_variant_new_int16 (G_MAXINT16);
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_uint16 (0));
+ b = g_variant_new_uint16 (G_MAXUINT16);
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_int32 (G_MININT32));
+ b = g_variant_new_int32 (G_MAXINT32);
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_uint32 (0));
+ b = g_variant_new_uint32 (G_MAXUINT32);
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_int64 (G_MININT64));
+ b = g_variant_new_int64 (G_MAXINT64);
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_uint64 (0));
+ b = g_variant_new_uint64 (G_MAXUINT64);
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_double (G_MINDOUBLE));
+ b = g_variant_new_double (G_MAXDOUBLE);
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_string ("abc"));
b = g_variant_new_string ("abd");
g_assert (g_variant_compare (a, b) < 0);
g_variant_unref (a);
g_variant_unref (b);
- a = g_variant_new_boolean (FALSE);
+ a = untrusted (g_variant_new_object_path ("/abc"));
+ b = g_variant_new_object_path ("/abd");
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_signature ("g"));
+ b = g_variant_new_signature ("o");
+ g_assert (g_variant_compare (a, b) < 0);
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_boolean (FALSE));
b = g_variant_new_boolean (TRUE);
g_assert (g_variant_compare (a, b) < 0);
g_variant_unref (a);
}
static void
+test_equal (void)
+{
+ GVariant *a;
+ GVariant *b;
+
+ a = untrusted (g_variant_new_byte (5));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_int16 (G_MININT16));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_uint16 (0));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_int32 (G_MININT32));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_uint32 (0));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_int64 (G_MININT64));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_uint64 (0));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_double (G_MINDOUBLE));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_string ("abc"));
+ g_assert (g_variant_equal (a, a));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_object_path ("/abc"));
+ g_assert (g_variant_equal (a, a));
+ b = g_variant_get_normal_form (a);
+ a = untrusted (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_signature ("g"));
+ g_assert (g_variant_equal (a, a));
+ b = g_variant_get_normal_form (a);
+ a = untrusted (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+ a = untrusted (g_variant_new_boolean (FALSE));
+ b = g_variant_get_normal_form (a);
+ g_assert (g_variant_equal (a, b));
+ g_variant_unref (a);
+ g_variant_unref (b);
+}
+
+static void
test_fixed_array (void)
{
GVariant *a;
g_test_assert_expected_messages ();
g_assert (g_variant_check_format_string (value, "(s^&ay)", FALSE));
+ g_assert (g_variant_check_format_string (value, "r", FALSE));
+ g_assert (g_variant_check_format_string (value, "(?a?)", FALSE));
+
g_variant_unref (value);
}
"(yvu)", 254, g_variant_new ("(^as)", strv), 42);
}
+static void
+test_gbytes (void)
+{
+ GVariant *a;
+ GVariant *tuple;
+ GBytes *bytes;
+ GBytes *bytes2;
+ const guint8 values[5] = { 1, 2, 3, 4, 5 };
+ const guint8 *elts;
+ gsize n_elts;
+ gint i;
+
+ bytes = g_bytes_new (&values, 5);
+ a = g_variant_new_from_bytes (G_VARIANT_TYPE_BYTESTRING, bytes, TRUE);
+ g_bytes_unref (bytes);
+ n_elts = 0;
+ elts = g_variant_get_fixed_array (a, &n_elts, sizeof (guint8));
+ g_assert (n_elts == 5);
+ for (i = 0; i < 5; i++)
+ g_assert_cmpint (elts[i], ==, i + 1);
+
+ bytes2 = g_variant_get_data_as_bytes (a);
+ g_variant_unref (a);
+
+ bytes = g_bytes_new (&values, 5);
+ g_assert (g_bytes_equal (bytes, bytes2));
+ g_bytes_unref (bytes);
+ g_bytes_unref (bytes2);
+
+ tuple = g_variant_new_parsed ("['foo', 'bar']");
+ bytes = g_variant_get_data_as_bytes (tuple); /* force serialisation */
+ a = g_variant_get_child_value (tuple, 1);
+ bytes2 = g_variant_get_data_as_bytes (a);
+ g_assert (!g_bytes_equal (bytes, bytes2));
+
+ g_bytes_unref (bytes);
+ g_bytes_unref (bytes2);
+ g_variant_unref (a);
+ g_variant_unref (tuple);
+}
+
+typedef struct {
+ const GVariantType *type;
+ const gchar *in;
+ const gchar *out;
+} ContextTest;
+
+static void
+test_print_context (void)
+{
+ ContextTest tests[] = {
+ { NULL, "(1, 2, 3, 'abc", " ^^^^" },
+ { NULL, "[1, 2, 3, 'str']", " ^ ^^^^^" },
+ { G_VARIANT_TYPE_UINT16, "{ 'abc':'def' }", " ^^^^^^^^^^^^^^^" },
+ { NULL, "<5", " ^" },
+ { NULL, "'ab\\ux'", " ^^^^^^^" },
+ { NULL, "'ab\\U00efx'", " ^^^^^^^^^^^" }
+ };
+ GVariant *v;
+ gchar *s;
+ gint i;
+ GError *error = NULL;
+
+ for (i = 0; i < G_N_ELEMENTS (tests); i++)
+ {
+ v = g_variant_parse (tests[i].type, tests[i].in, NULL, NULL, &error);
+ g_assert_null (v);
+ s = g_variant_parse_error_print_context (error, tests[i].in);
+ g_assert (strstr (s, tests[i].out) != NULL);
+ g_free (s);
+ g_clear_error (&error);
+ }
+}
+
+static void
+test_error_quark (void)
+{
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+ g_assert (g_variant_parser_get_error_quark () == g_variant_parse_error_quark ());
+G_GNUC_END_IGNORE_DEPRECATIONS
+}
+
+static GByteArray *
+flatten_vectors (GVariantVectors *v)
+{
+ GByteArray *result;
+ guint i;
+
+ result = g_byte_array_new ();
+
+ for (i = 0; i < v->vectors->len; i++)
+ {
+ GVariantVector vec = g_array_index (v->vectors, GVariantVector, i);
+
+ if (vec.gbytes)
+ g_byte_array_append (result, vec.data.pointer, vec.size);
+ else
+ g_byte_array_append (result, v->extra_bytes->data + vec.data.offset, vec.size);
+ }
+
+ return result;
+}
+
+static void
+test_vector_serialiser (void)
+{
+ GVariantVectors vectors;
+ GByteArray *flattened;
+ GVariant *value;
+ guint i;
+
+ for (i = 0; i < 100; i++)
+ {
+ value = create_random_gvariant (4);
+
+ GLIB_PRIVATE_CALL(g_variant_to_vectors) (value, &vectors);
+ flattened = flatten_vectors (&vectors);
+ g_byte_array_free (vectors.extra_bytes, TRUE);
+ g_byte_array_free (vectors.offsets, TRUE);
+ g_array_free (vectors.vectors, TRUE);
+
+#if 0
+ if (flattened->len != g_variant_get_size (value) ||
+ memcmp (flattened->data, g_variant_get_data (value), flattened->len) != 0)
+ {
+ g_file_set_contents ("flattened", flattened->data, flattened->len, NULL);
+ g_file_set_contents ("serialised", g_variant_get_data (value), g_variant_get_size (value), NULL);
+ g_print ("type is %s\n", g_variant_get_type_string (value));
+ g_assert_not_reached ();
+ }
+#endif
+
+ g_assert_cmpint (flattened->len, ==, g_variant_get_size (value));
+ g_assert (memcmp (flattened->data, g_variant_get_data (value), flattened->len) == 0);
+
+ g_byte_array_free (flattened, TRUE);
+ g_variant_unref (value);
+ }
+}
+
int
main (int argc, char **argv)
{
g_free (testname);
}
+ g_test_add_func ("/gvariant/string", test_string);
g_test_add_func ("/gvariant/utf8", test_utf8);
g_test_add_func ("/gvariant/containers", test_containers);
g_test_add_func ("/gvariant/format-strings", test_format_strings);
g_test_add_func ("/gvariant/invalid-varargs", test_invalid_varargs);
g_test_add_func ("/gvariant/varargs", test_varargs);
+ g_test_add_func ("/gvariant/varargs/subprocess/empty-array", test_varargs_empty_array);
g_test_add_func ("/gvariant/valist", test_valist);
g_test_add_func ("/gvariant/builder-memory", test_builder_memory);
g_test_add_func ("/gvariant/hashing", test_hashing);
g_test_add_func ("/gvariant/parser", test_parses);
g_test_add_func ("/gvariant/parse-failures", test_parse_failures);
g_test_add_func ("/gvariant/parse-positional", test_parse_positional);
+ g_test_add_func ("/gvariant/parse/subprocess/bad-format-char", test_parse_bad_format_char);
+ g_test_add_func ("/gvariant/parse/subprocess/bad-format-string", test_parse_bad_format_string);
+ g_test_add_func ("/gvariant/parse/subprocess/bad-args", test_parse_bad_args);
g_test_add_func ("/gvariant/floating", test_floating);
g_test_add_func ("/gvariant/bytestring", test_bytestring);
g_test_add_func ("/gvariant/lookup-value", test_lookup_value);
g_test_add_func ("/gvariant/lookup", test_lookup);
g_test_add_func ("/gvariant/compare", test_compare);
+ g_test_add_func ("/gvariant/equal", test_equal);
g_test_add_func ("/gvariant/fixed-array", test_fixed_array);
g_test_add_func ("/gvariant/check-format-string", test_check_format_string);
g_test_add_func ("/gvariant/checksum-basic", test_checksum_basic);
g_test_add_func ("/gvariant/checksum-nested", test_checksum_nested);
+ g_test_add_func ("/gvariant/gbytes", test_gbytes);
+ g_test_add_func ("/gvariant/print-context", test_print_context);
+ g_test_add_func ("/gvariant/error-quark", test_error_quark);
+ g_test_add_func ("/gvariant/vector-serialiser", test_vector_serialiser);
+
return g_test_run ();
}
projects / platform / upstream / glib.git / blobdiff