mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-12-27 07:56:14 +01:00
95cad9c3e0
There are other tests in glib/tests/ that are licensed under a BSD-style license, and other tests that don't have any license header. https://bugzilla.gnome.org/show_bug.cgi?id=776504
4665 lines
132 KiB
C
4665 lines
132 KiB
C
/*
|
|
* Copyright © 2010 Codethink Limited
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* See the included COPYING file for more information.
|
|
*
|
|
* Author: Ryan Lortie <desrt@desrt.ca>
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <glib/gvariant-internal.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <glib.h>
|
|
|
|
#define BASIC "bynqiuxthdsog?"
|
|
#define N_BASIC (G_N_ELEMENTS (BASIC) - 1)
|
|
|
|
#define INVALIDS "cefjklpwz&@^$"
|
|
#define N_INVALIDS (G_N_ELEMENTS (INVALIDS) - 1)
|
|
|
|
/* see comment in gvariant-serialiser.c about this madness.
|
|
*
|
|
* we use this to get testing of non-strictly-aligned GVariant instances
|
|
* on machines that can tolerate it. it is necessary to support this
|
|
* because some systems have malloc() that returns non-8-aligned
|
|
* pointers. it is necessary to have special support in the tests
|
|
* because on most machines malloc() is 8-aligned.
|
|
*/
|
|
#define ALIGN_BITS (sizeof (struct { char a; union { \
|
|
guint64 x; void *y; gdouble z; } b; }) - 9)
|
|
|
|
static gboolean
|
|
randomly (gdouble prob)
|
|
{
|
|
return g_test_rand_double_range (0, 1) < prob;
|
|
}
|
|
|
|
/* corecursion */
|
|
static GVariantType *
|
|
append_tuple_type_string (GString *, GString *, gboolean, gint);
|
|
|
|
/* append a random GVariantType to a GString
|
|
* append a description of the type to another GString
|
|
* return what the type is
|
|
*/
|
|
static GVariantType *
|
|
append_type_string (GString *string,
|
|
GString *description,
|
|
gboolean definite,
|
|
gint depth)
|
|
{
|
|
if (!depth-- || randomly (0.3))
|
|
{
|
|
gchar b = BASIC[g_test_rand_int_range (0, N_BASIC - definite)];
|
|
g_string_append_c (string, b);
|
|
g_string_append_c (description, b);
|
|
|
|
switch (b)
|
|
{
|
|
case 'b':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_BOOLEAN);
|
|
case 'y':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_BYTE);
|
|
case 'n':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_INT16);
|
|
case 'q':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_UINT16);
|
|
case 'i':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_INT32);
|
|
case 'u':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_UINT32);
|
|
case 'x':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_INT64);
|
|
case 't':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_UINT64);
|
|
case 'h':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_HANDLE);
|
|
case 'd':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_DOUBLE);
|
|
case 's':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_STRING);
|
|
case 'o':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_OBJECT_PATH);
|
|
case 'g':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_SIGNATURE);
|
|
case '?':
|
|
return g_variant_type_copy (G_VARIANT_TYPE_BASIC);
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GVariantType *result;
|
|
|
|
switch (g_test_rand_int_range (0, definite ? 5 : 7))
|
|
{
|
|
case 0:
|
|
{
|
|
GVariantType *element;
|
|
|
|
g_string_append_c (string, 'a');
|
|
g_string_append (description, "a of ");
|
|
element = append_type_string (string, description,
|
|
definite, depth);
|
|
result = g_variant_type_new_array (element);
|
|
g_variant_type_free (element);
|
|
}
|
|
|
|
g_assert (g_variant_type_is_array (result));
|
|
break;
|
|
|
|
case 1:
|
|
{
|
|
GVariantType *element;
|
|
|
|
g_string_append_c (string, 'm');
|
|
g_string_append (description, "m of ");
|
|
element = append_type_string (string, description,
|
|
definite, depth);
|
|
result = g_variant_type_new_maybe (element);
|
|
g_variant_type_free (element);
|
|
}
|
|
|
|
g_assert (g_variant_type_is_maybe (result));
|
|
break;
|
|
|
|
case 2:
|
|
result = append_tuple_type_string (string, description,
|
|
definite, depth);
|
|
|
|
g_assert (g_variant_type_is_tuple (result));
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
GVariantType *key, *value;
|
|
|
|
g_string_append_c (string, '{');
|
|
g_string_append (description, "e of [");
|
|
key = append_type_string (string, description, definite, 0);
|
|
g_string_append (description, ", ");
|
|
value = append_type_string (string, description, definite, depth);
|
|
g_string_append_c (description, ']');
|
|
g_string_append_c (string, '}');
|
|
result = g_variant_type_new_dict_entry (key, value);
|
|
g_variant_type_free (key);
|
|
g_variant_type_free (value);
|
|
}
|
|
|
|
g_assert (g_variant_type_is_dict_entry (result));
|
|
break;
|
|
|
|
case 4:
|
|
g_string_append_c (string, 'v');
|
|
g_string_append_c (description, 'V');
|
|
result = g_variant_type_copy (G_VARIANT_TYPE_VARIANT);
|
|
g_assert (g_variant_type_equal (result, G_VARIANT_TYPE_VARIANT));
|
|
break;
|
|
|
|
case 5:
|
|
g_string_append_c (string, '*');
|
|
g_string_append_c (description, 'S');
|
|
result = g_variant_type_copy (G_VARIANT_TYPE_ANY);
|
|
g_assert (g_variant_type_equal (result, G_VARIANT_TYPE_ANY));
|
|
break;
|
|
|
|
case 6:
|
|
g_string_append_c (string, 'r');
|
|
g_string_append_c (description, 'R');
|
|
result = g_variant_type_copy (G_VARIANT_TYPE_TUPLE);
|
|
g_assert (g_variant_type_is_tuple (result));
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
static GVariantType *
|
|
append_tuple_type_string (GString *string,
|
|
GString *description,
|
|
gboolean definite,
|
|
gint depth)
|
|
{
|
|
GVariantType *result, *other_result;
|
|
GVariantType **types;
|
|
gint size;
|
|
gint i;
|
|
|
|
g_string_append_c (string, '(');
|
|
g_string_append (description, "t of [");
|
|
|
|
size = g_test_rand_int_range (0, 20);
|
|
types = g_new (GVariantType *, size + 1);
|
|
|
|
for (i = 0; i < size; i++)
|
|
{
|
|
types[i] = append_type_string (string, description, definite, depth);
|
|
|
|
if (i < size - 1)
|
|
g_string_append (description, ", ");
|
|
}
|
|
|
|
types[i] = NULL;
|
|
|
|
g_string_append_c (description, ']');
|
|
g_string_append_c (string, ')');
|
|
|
|
result = g_variant_type_new_tuple ((gpointer) types, size);
|
|
other_result = g_variant_type_new_tuple ((gpointer) types, -1);
|
|
g_assert (g_variant_type_equal (result, other_result));
|
|
g_variant_type_free (other_result);
|
|
for (i = 0; i < size; i++)
|
|
g_variant_type_free (types[i]);
|
|
g_free (types);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* given a valid type string, make it invalid */
|
|
static gchar *
|
|
invalid_mutation (const gchar *type_string)
|
|
{
|
|
gboolean have_parens, have_braces;
|
|
|
|
/* it's valid, so '(' implies ')' and same for '{' and '}' */
|
|
have_parens = strchr (type_string, '(') != NULL;
|
|
have_braces = strchr (type_string, '{') != NULL;
|
|
|
|
if (have_parens && have_braces && randomly (0.3))
|
|
{
|
|
/* swap a paren and a brace */
|
|
gchar *pp, *bp;
|
|
gint np, nb;
|
|
gchar p, b;
|
|
gchar *new;
|
|
|
|
new = g_strdup (type_string);
|
|
|
|
if (randomly (0.5))
|
|
p = '(', b = '{';
|
|
else
|
|
p = ')', b = '}';
|
|
|
|
np = nb = 0;
|
|
pp = bp = new - 1;
|
|
|
|
/* count number of parens/braces */
|
|
while ((pp = strchr (pp + 1, p))) np++;
|
|
while ((bp = strchr (bp + 1, b))) nb++;
|
|
|
|
/* randomly pick one of each */
|
|
np = g_test_rand_int_range (0, np) + 1;
|
|
nb = g_test_rand_int_range (0, nb) + 1;
|
|
|
|
/* find it */
|
|
pp = bp = new - 1;
|
|
while (np--) pp = strchr (pp + 1, p);
|
|
while (nb--) bp = strchr (bp + 1, b);
|
|
|
|
/* swap */
|
|
g_assert (*bp == b && *pp == p);
|
|
*bp = p;
|
|
*pp = b;
|
|
|
|
return new;
|
|
}
|
|
|
|
if ((have_parens || have_braces) && randomly (0.3))
|
|
{
|
|
/* drop a paren/brace */
|
|
gchar *new;
|
|
gchar *pp;
|
|
gint np;
|
|
gchar p;
|
|
|
|
if (have_parens)
|
|
if (randomly (0.5)) p = '('; else p = ')';
|
|
else
|
|
if (randomly (0.5)) p = '{'; else p = '}';
|
|
|
|
new = g_strdup (type_string);
|
|
|
|
np = 0;
|
|
pp = new - 1;
|
|
while ((pp = strchr (pp + 1, p))) np++;
|
|
np = g_test_rand_int_range (0, np) + 1;
|
|
pp = new - 1;
|
|
while (np--) pp = strchr (pp + 1, p);
|
|
g_assert (*pp == p);
|
|
|
|
while (*pp)
|
|
{
|
|
*pp = *(pp + 1);
|
|
pp++;
|
|
}
|
|
|
|
return new;
|
|
}
|
|
|
|
/* else, perform a random mutation at a random point */
|
|
{
|
|
gint length, n;
|
|
gchar *new;
|
|
gchar p;
|
|
|
|
if (randomly (0.3))
|
|
{
|
|
/* insert a paren/brace */
|
|
if (randomly (0.5))
|
|
if (randomly (0.5)) p = '('; else p = ')';
|
|
else
|
|
if (randomly (0.5)) p = '{'; else p = '}';
|
|
}
|
|
else if (randomly (0.5))
|
|
{
|
|
/* insert junk */
|
|
p = INVALIDS[g_test_rand_int_range (0, N_INVALIDS)];
|
|
}
|
|
else
|
|
{
|
|
/* truncate */
|
|
p = '\0';
|
|
}
|
|
|
|
|
|
length = strlen (type_string);
|
|
new = g_malloc (length + 2);
|
|
n = g_test_rand_int_range (0, length);
|
|
memcpy (new, type_string, n);
|
|
new[n] = p;
|
|
memcpy (new + n + 1, type_string + n, length - n);
|
|
new[length + 1] = '\0';
|
|
|
|
return new;
|
|
}
|
|
}
|
|
|
|
/* describe a type using the same language as is generated
|
|
* while generating the type with append_type_string
|
|
*/
|
|
static gchar *
|
|
describe_type (const GVariantType *type)
|
|
{
|
|
gchar *result;
|
|
|
|
if (g_variant_type_is_container (type))
|
|
{
|
|
g_assert (!g_variant_type_is_basic (type));
|
|
|
|
if (g_variant_type_is_array (type))
|
|
{
|
|
gchar *subtype = describe_type (g_variant_type_element (type));
|
|
result = g_strdup_printf ("a of %s", subtype);
|
|
g_free (subtype);
|
|
}
|
|
else if (g_variant_type_is_maybe (type))
|
|
{
|
|
gchar *subtype = describe_type (g_variant_type_element (type));
|
|
result = g_strdup_printf ("m of %s", subtype);
|
|
g_free (subtype);
|
|
}
|
|
else if (g_variant_type_is_tuple (type))
|
|
{
|
|
if (!g_variant_type_equal (type, G_VARIANT_TYPE_TUPLE))
|
|
{
|
|
const GVariantType *sub;
|
|
GString *string;
|
|
gint length;
|
|
gint i;
|
|
|
|
string = g_string_new ("t of [");
|
|
|
|
length = g_variant_type_n_items (type);
|
|
sub = g_variant_type_first (type);
|
|
for (i = 0; i < length; i++)
|
|
{
|
|
gchar *subtype = describe_type (sub);
|
|
g_string_append (string, subtype);
|
|
g_free (subtype);
|
|
|
|
if ((sub = g_variant_type_next (sub)))
|
|
g_string_append (string, ", ");
|
|
}
|
|
g_assert (sub == NULL);
|
|
g_string_append_c (string, ']');
|
|
|
|
result = g_string_free (string, FALSE);
|
|
}
|
|
else
|
|
result = g_strdup ("R");
|
|
}
|
|
else if (g_variant_type_is_dict_entry (type))
|
|
{
|
|
gchar *key, *value, *key2, *value2;
|
|
|
|
key = describe_type (g_variant_type_key (type));
|
|
value = describe_type (g_variant_type_value (type));
|
|
key2 = describe_type (g_variant_type_first (type));
|
|
value2 = describe_type (
|
|
g_variant_type_next (g_variant_type_first (type)));
|
|
g_assert (g_variant_type_next (g_variant_type_next (
|
|
g_variant_type_first (type))) == NULL);
|
|
g_assert_cmpstr (key, ==, key2);
|
|
g_assert_cmpstr (value, ==, value2);
|
|
result = g_strjoin ("", "e of [", key, ", ", value, "]", NULL);
|
|
g_free (key2);
|
|
g_free (value2);
|
|
g_free (key);
|
|
g_free (value);
|
|
}
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_VARIANT))
|
|
{
|
|
result = g_strdup ("V");
|
|
}
|
|
else
|
|
g_assert_not_reached ();
|
|
}
|
|
else
|
|
{
|
|
if (g_variant_type_is_definite (type))
|
|
{
|
|
g_assert (g_variant_type_is_basic (type));
|
|
|
|
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
|
|
result = g_strdup ("b");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
|
|
result = g_strdup ("y");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
|
|
result = g_strdup ("n");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
|
|
result = g_strdup ("q");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
|
|
result = g_strdup ("i");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
|
|
result = g_strdup ("u");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
|
|
result = g_strdup ("x");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
|
|
result = g_strdup ("t");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
|
|
result = g_strdup ("h");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
|
|
result = g_strdup ("d");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
|
|
result = g_strdup ("s");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH))
|
|
result = g_strdup ("o");
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
|
|
result = g_strdup ("g");
|
|
else
|
|
g_assert_not_reached ();
|
|
}
|
|
else
|
|
{
|
|
if (g_variant_type_equal (type, G_VARIANT_TYPE_ANY))
|
|
{
|
|
result = g_strdup ("S");
|
|
}
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_BASIC))
|
|
{
|
|
result = g_strdup ("?");
|
|
}
|
|
else
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* given a type string, replace one of the indefinite type characters in
|
|
* it with a matching type (possibly the same type).
|
|
*/
|
|
static gchar *
|
|
generate_subtype (const gchar *type_string)
|
|
{
|
|
GVariantType *replacement;
|
|
GString *result, *junk;
|
|
gint length, n = 0, l;
|
|
|
|
result = g_string_new (NULL);
|
|
junk = g_string_new (NULL);
|
|
|
|
/* count the number of indefinite type characters */
|
|
for (length = 0; type_string[length]; length++)
|
|
n += type_string[length] == 'r' ||
|
|
type_string[length] == '?' ||
|
|
type_string[length] == '*';
|
|
/* length now is strlen (type_string) */
|
|
|
|
/* pick one at random to replace */
|
|
n = g_test_rand_int_range (0, n) + 1;
|
|
|
|
/* find it */
|
|
l = -1;
|
|
while (n--) l += strcspn (type_string + l + 1, "r?*") + 1;
|
|
g_assert (type_string[l] == 'r' ||
|
|
type_string[l] == '?' ||
|
|
type_string[l] == '*');
|
|
|
|
/* store up to that point in a GString */
|
|
g_string_append_len (result, type_string, l);
|
|
|
|
/* then store the replacement in the GString */
|
|
if (type_string[l] == 'r')
|
|
replacement = append_tuple_type_string (result, junk, FALSE, 3);
|
|
|
|
else if (type_string[l] == '?')
|
|
replacement = append_type_string (result, junk, FALSE, 0);
|
|
|
|
else if (type_string[l] == '*')
|
|
replacement = append_type_string (result, junk, FALSE, 3);
|
|
|
|
else
|
|
g_assert_not_reached ();
|
|
|
|
/* ensure the replacement has the proper type */
|
|
g_assert (g_variant_type_is_subtype_of (replacement,
|
|
(gpointer) &type_string[l]));
|
|
|
|
/* store the rest from the original type string */
|
|
g_string_append (result, type_string + l + 1);
|
|
|
|
g_variant_type_free (replacement);
|
|
g_string_free (junk, TRUE);
|
|
|
|
return g_string_free (result, FALSE);
|
|
}
|
|
|
|
struct typestack
|
|
{
|
|
const GVariantType *type;
|
|
struct typestack *parent;
|
|
};
|
|
|
|
/* given an indefinite type string, replace one of the indefinite
|
|
* characters in it with a matching type and ensure that the result is a
|
|
* subtype of the original. repeat.
|
|
*/
|
|
static void
|
|
subtype_check (const gchar *type_string,
|
|
struct typestack *parent_ts)
|
|
{
|
|
struct typestack ts, *node;
|
|
gchar *subtype;
|
|
gint depth = 0;
|
|
|
|
subtype = generate_subtype (type_string);
|
|
|
|
ts.type = G_VARIANT_TYPE (subtype);
|
|
ts.parent = parent_ts;
|
|
|
|
for (node = &ts; node; node = node->parent)
|
|
{
|
|
/* this type should be a subtype of each parent type */
|
|
g_assert (g_variant_type_is_subtype_of (ts.type, node->type));
|
|
|
|
/* it should only be a supertype when it is exactly equal */
|
|
g_assert (g_variant_type_is_subtype_of (node->type, ts.type) ==
|
|
g_variant_type_equal (ts.type, node->type));
|
|
|
|
depth++;
|
|
}
|
|
|
|
if (!g_variant_type_is_definite (ts.type) && depth < 5)
|
|
{
|
|
/* the type is still indefinite and we haven't repeated too many
|
|
* times. go once more.
|
|
*/
|
|
|
|
subtype_check (subtype, &ts);
|
|
}
|
|
|
|
g_free (subtype);
|
|
}
|
|
|
|
static void
|
|
test_gvarianttype (void)
|
|
{
|
|
gint i;
|
|
|
|
for (i = 0; i < 2000; i++)
|
|
{
|
|
GString *type_string, *description;
|
|
GVariantType *type, *other_type;
|
|
const GVariantType *ctype;
|
|
gchar *invalid;
|
|
gchar *desc;
|
|
|
|
type_string = g_string_new (NULL);
|
|
description = g_string_new (NULL);
|
|
|
|
/* generate a random type, its type string and a description
|
|
*
|
|
* exercises type constructor functions and g_variant_type_copy()
|
|
*/
|
|
type = append_type_string (type_string, description, FALSE, 6);
|
|
|
|
/* convert the type string to a type and ensure that it is equal
|
|
* to the one produced with the type constructor routines
|
|
*/
|
|
ctype = G_VARIANT_TYPE (type_string->str);
|
|
g_assert (g_variant_type_equal (ctype, type));
|
|
g_assert (g_variant_type_hash (ctype) == g_variant_type_hash (type));
|
|
g_assert (g_variant_type_is_subtype_of (ctype, type));
|
|
g_assert (g_variant_type_is_subtype_of (type, ctype));
|
|
|
|
/* check if the type is indefinite */
|
|
if (!g_variant_type_is_definite (type))
|
|
{
|
|
struct typestack ts = { type, NULL };
|
|
|
|
/* if it is indefinite, then replace one of the indefinite
|
|
* characters with a matching type and ensure that the result
|
|
* is a subtype of the original type. repeat.
|
|
*/
|
|
subtype_check (type_string->str, &ts);
|
|
}
|
|
else
|
|
/* ensure that no indefinite characters appear */
|
|
g_assert (strcspn (type_string->str, "r?*") == type_string->len);
|
|
|
|
|
|
/* describe the type.
|
|
*
|
|
* exercises the type iterator interface
|
|
*/
|
|
desc = describe_type (type);
|
|
|
|
/* make sure the description matches */
|
|
g_assert_cmpstr (desc, ==, description->str);
|
|
g_free (desc);
|
|
|
|
/* make an invalid mutation to the type and make sure the type
|
|
* validation routines catch it */
|
|
invalid = invalid_mutation (type_string->str);
|
|
g_assert (g_variant_type_string_is_valid (type_string->str));
|
|
g_assert (!g_variant_type_string_is_valid (invalid));
|
|
g_free (invalid);
|
|
|
|
/* concatenate another type to the type string and ensure that
|
|
* the result is recognised as being invalid
|
|
*/
|
|
other_type = append_type_string (type_string, description, FALSE, 2);
|
|
|
|
g_string_free (description, TRUE);
|
|
g_string_free (type_string, TRUE);
|
|
g_variant_type_free (other_type);
|
|
g_variant_type_free (type);
|
|
}
|
|
}
|
|
|
|
#define ALIGNED(x, y) (((x + (y - 1)) / y) * y)
|
|
|
|
/* do our own calculation of the fixed_size and alignment of a type
|
|
* using a simple algorithm to make sure the "fancy" one in the
|
|
* implementation is correct.
|
|
*/
|
|
static void
|
|
calculate_type_info (const GVariantType *type,
|
|
gsize *fixed_size,
|
|
guint *alignment)
|
|
{
|
|
if (g_variant_type_is_array (type) ||
|
|
g_variant_type_is_maybe (type))
|
|
{
|
|
calculate_type_info (g_variant_type_element (type), NULL, alignment);
|
|
|
|
if (fixed_size)
|
|
*fixed_size = 0;
|
|
}
|
|
else if (g_variant_type_is_tuple (type) ||
|
|
g_variant_type_is_dict_entry (type))
|
|
{
|
|
if (g_variant_type_n_items (type))
|
|
{
|
|
const GVariantType *sub;
|
|
gboolean variable;
|
|
gsize size;
|
|
guint al;
|
|
|
|
variable = FALSE;
|
|
size = 0;
|
|
al = 0;
|
|
|
|
sub = g_variant_type_first (type);
|
|
do
|
|
{
|
|
gsize this_fs;
|
|
guint this_al;
|
|
|
|
calculate_type_info (sub, &this_fs, &this_al);
|
|
|
|
al = MAX (al, this_al);
|
|
|
|
if (!this_fs)
|
|
{
|
|
variable = TRUE;
|
|
size = 0;
|
|
}
|
|
|
|
if (!variable)
|
|
{
|
|
size = ALIGNED (size, this_al);
|
|
size += this_fs;
|
|
}
|
|
}
|
|
while ((sub = g_variant_type_next (sub)));
|
|
|
|
size = ALIGNED (size, al);
|
|
|
|
if (alignment)
|
|
*alignment = al;
|
|
|
|
if (fixed_size)
|
|
*fixed_size = size;
|
|
}
|
|
else
|
|
{
|
|
if (fixed_size)
|
|
*fixed_size = 1;
|
|
|
|
if (alignment)
|
|
*alignment = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
gint fs, al;
|
|
|
|
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN) ||
|
|
g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
|
|
{
|
|
al = fs = 1;
|
|
}
|
|
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16) ||
|
|
g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
|
|
{
|
|
al = fs = 2;
|
|
}
|
|
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32) ||
|
|
g_variant_type_equal (type, G_VARIANT_TYPE_UINT32) ||
|
|
g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
|
|
{
|
|
al = fs = 4;
|
|
}
|
|
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64) ||
|
|
g_variant_type_equal (type, G_VARIANT_TYPE_UINT64) ||
|
|
g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
|
|
{
|
|
al = fs = 8;
|
|
}
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING) ||
|
|
g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH) ||
|
|
g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
|
|
{
|
|
al = 1;
|
|
fs = 0;
|
|
}
|
|
else if (g_variant_type_equal (type, G_VARIANT_TYPE_VARIANT))
|
|
{
|
|
al = 8;
|
|
fs = 0;
|
|
}
|
|
else
|
|
g_assert_not_reached ();
|
|
|
|
if (fixed_size)
|
|
*fixed_size = fs;
|
|
|
|
if (alignment)
|
|
*alignment = al;
|
|
}
|
|
}
|
|
|
|
/* same as the describe_type() function above, but iterates over
|
|
* typeinfo instead of types.
|
|
*/
|
|
static gchar *
|
|
describe_info (GVariantTypeInfo *info)
|
|
{
|
|
gchar *result;
|
|
|
|
switch (g_variant_type_info_get_type_char (info))
|
|
{
|
|
case G_VARIANT_TYPE_INFO_CHAR_MAYBE:
|
|
{
|
|
gchar *element;
|
|
|
|
element = describe_info (g_variant_type_info_element (info));
|
|
result = g_strdup_printf ("m of %s", element);
|
|
g_free (element);
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_ARRAY:
|
|
{
|
|
gchar *element;
|
|
|
|
element = describe_info (g_variant_type_info_element (info));
|
|
result = g_strdup_printf ("a of %s", element);
|
|
g_free (element);
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_TUPLE:
|
|
{
|
|
const gchar *sep = "";
|
|
GString *string;
|
|
gint length;
|
|
gint i;
|
|
|
|
string = g_string_new ("t of [");
|
|
length = g_variant_type_info_n_members (info);
|
|
|
|
for (i = 0; i < length; i++)
|
|
{
|
|
const GVariantMemberInfo *minfo;
|
|
gchar *subtype;
|
|
|
|
g_string_append (string, sep);
|
|
sep = ", ";
|
|
|
|
minfo = g_variant_type_info_member_info (info, i);
|
|
subtype = describe_info (minfo->type_info);
|
|
g_string_append (string, subtype);
|
|
g_free (subtype);
|
|
}
|
|
|
|
g_string_append_c (string, ']');
|
|
|
|
result = g_string_free (string, FALSE);
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_DICT_ENTRY:
|
|
{
|
|
const GVariantMemberInfo *keyinfo, *valueinfo;
|
|
gchar *key, *value;
|
|
|
|
g_assert_cmpint (g_variant_type_info_n_members (info), ==, 2);
|
|
keyinfo = g_variant_type_info_member_info (info, 0);
|
|
valueinfo = g_variant_type_info_member_info (info, 1);
|
|
key = describe_info (keyinfo->type_info);
|
|
value = describe_info (valueinfo->type_info);
|
|
result = g_strjoin ("", "e of [", key, ", ", value, "]", NULL);
|
|
g_free (key);
|
|
g_free (value);
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_VARIANT:
|
|
result = g_strdup ("V");
|
|
break;
|
|
|
|
default:
|
|
result = g_strdup (g_variant_type_info_get_type_string (info));
|
|
g_assert_cmpint (strlen (result), ==, 1);
|
|
break;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* check that the O(1) method of calculating offsets meshes with the
|
|
* results of simple iteration.
|
|
*/
|
|
static void
|
|
check_offsets (GVariantTypeInfo *info,
|
|
const GVariantType *type)
|
|
{
|
|
gint flavour;
|
|
gint length;
|
|
|
|
length = g_variant_type_info_n_members (info);
|
|
g_assert_cmpint (length, ==, g_variant_type_n_items (type));
|
|
|
|
/* the 'flavour' is the low order bits of the ending point of
|
|
* variable-size items in the tuple. this lets us test that the type
|
|
* info is correct for various starting alignments.
|
|
*/
|
|
for (flavour = 0; flavour < 8; flavour++)
|
|
{
|
|
const GVariantType *subtype;
|
|
gsize last_offset_index;
|
|
gsize last_offset;
|
|
gsize position;
|
|
gint i;
|
|
|
|
subtype = g_variant_type_first (type);
|
|
last_offset_index = -1;
|
|
last_offset = 0;
|
|
position = 0;
|
|
|
|
/* go through the tuple, keeping track of our position */
|
|
for (i = 0; i < length; i++)
|
|
{
|
|
gsize fixed_size;
|
|
guint alignment;
|
|
|
|
calculate_type_info (subtype, &fixed_size, &alignment);
|
|
|
|
position = ALIGNED (position, alignment);
|
|
|
|
/* compare our current aligned position (ie: the start of this
|
|
* item) to the start offset that would be calculated if we
|
|
* used the type info
|
|
*/
|
|
{
|
|
const GVariantMemberInfo *member;
|
|
gsize start;
|
|
|
|
member = g_variant_type_info_member_info (info, i);
|
|
g_assert_cmpint (member->i, ==, last_offset_index);
|
|
|
|
/* do the calculation using the typeinfo */
|
|
start = last_offset;
|
|
start += member->a;
|
|
start &= member->b;
|
|
start |= member->c;
|
|
|
|
/* did we reach the same spot? */
|
|
g_assert_cmpint (start, ==, position);
|
|
}
|
|
|
|
if (fixed_size)
|
|
{
|
|
/* fixed size. add that size. */
|
|
position += fixed_size;
|
|
}
|
|
else
|
|
{
|
|
/* variable size. do the flavouring. */
|
|
while ((position & 0x7) != flavour)
|
|
position++;
|
|
|
|
/* and store the offset, just like it would be in the
|
|
* serialised data.
|
|
*/
|
|
last_offset = position;
|
|
last_offset_index++;
|
|
}
|
|
|
|
/* next type */
|
|
subtype = g_variant_type_next (subtype);
|
|
}
|
|
|
|
/* make sure we used up exactly all the types */
|
|
g_assert (subtype == NULL);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_gvarianttypeinfo (void)
|
|
{
|
|
gint i;
|
|
|
|
for (i = 0; i < 2000; i++)
|
|
{
|
|
GString *type_string, *description;
|
|
gsize fixed_size1, fixed_size2;
|
|
guint alignment1, alignment2;
|
|
GVariantTypeInfo *info;
|
|
GVariantType *type;
|
|
gchar *desc;
|
|
|
|
type_string = g_string_new (NULL);
|
|
description = g_string_new (NULL);
|
|
|
|
/* random type */
|
|
type = append_type_string (type_string, description, TRUE, 6);
|
|
|
|
/* create a typeinfo for it */
|
|
info = g_variant_type_info_get (type);
|
|
|
|
/* make sure the typeinfo has the right type string */
|
|
g_assert_cmpstr (g_variant_type_info_get_type_string (info), ==,
|
|
type_string->str);
|
|
|
|
/* calculate the alignment and fixed size, compare to the
|
|
* typeinfo's calculations
|
|
*/
|
|
calculate_type_info (type, &fixed_size1, &alignment1);
|
|
g_variant_type_info_query (info, &alignment2, &fixed_size2);
|
|
g_assert_cmpint (fixed_size1, ==, fixed_size2);
|
|
g_assert_cmpint (alignment1, ==, alignment2 + 1);
|
|
|
|
/* test the iteration functions over typeinfo structures by
|
|
* "describing" the typeinfo and verifying equality.
|
|
*/
|
|
desc = describe_info (info);
|
|
g_assert_cmpstr (desc, ==, description->str);
|
|
|
|
/* do extra checks for containers */
|
|
if (g_variant_type_is_array (type) ||
|
|
g_variant_type_is_maybe (type))
|
|
{
|
|
const GVariantType *element;
|
|
gsize efs1, efs2;
|
|
guint ea1, ea2;
|
|
|
|
element = g_variant_type_element (type);
|
|
calculate_type_info (element, &efs1, &ea1);
|
|
g_variant_type_info_query_element (info, &ea2, &efs2);
|
|
g_assert_cmpint (efs1, ==, efs2);
|
|
g_assert_cmpint (ea1, ==, ea2 + 1);
|
|
|
|
g_assert_cmpint (ea1, ==, alignment1);
|
|
g_assert_cmpint (0, ==, fixed_size1);
|
|
}
|
|
else if (g_variant_type_is_tuple (type) ||
|
|
g_variant_type_is_dict_entry (type))
|
|
{
|
|
/* make sure the "magic constants" are working */
|
|
check_offsets (info, type);
|
|
}
|
|
|
|
g_string_free (type_string, TRUE);
|
|
g_string_free (description, TRUE);
|
|
g_variant_type_info_unref (info);
|
|
g_variant_type_free (type);
|
|
g_free (desc);
|
|
}
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
#define MAX_FIXED_MULTIPLIER 256
|
|
#define MAX_INSTANCE_SIZE 1024
|
|
#define MAX_ARRAY_CHILDREN 128
|
|
#define MAX_TUPLE_CHILDREN 128
|
|
|
|
/* this function generates a random type such that all characteristics
|
|
* that are "interesting" to the serialiser are tested.
|
|
*
|
|
* this basically means:
|
|
* - test different alignments
|
|
* - test variable sized items and fixed sized items
|
|
* - test different fixed sizes
|
|
*/
|
|
static gchar *
|
|
random_type_string (void)
|
|
{
|
|
const guchar base_types[] = "ynix";
|
|
guchar base_type;
|
|
|
|
base_type = base_types[g_test_rand_int_range (0, 4)];
|
|
|
|
if (g_test_rand_bit ())
|
|
/* construct a fixed-sized type */
|
|
{
|
|
char type_string[MAX_FIXED_MULTIPLIER];
|
|
guint multiplier;
|
|
guint i = 0;
|
|
|
|
multiplier = g_test_rand_int_range (1, sizeof type_string - 1);
|
|
|
|
type_string[i++] = '(';
|
|
while (multiplier--)
|
|
type_string[i++] = base_type;
|
|
type_string[i++] = ')';
|
|
|
|
return g_strndup (type_string, i);
|
|
}
|
|
else
|
|
/* construct a variable-sized type */
|
|
{
|
|
char type_string[2] = { 'a', base_type };
|
|
|
|
return g_strndup (type_string, 2);
|
|
}
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
GVariantTypeInfo *type_info;
|
|
guint alignment;
|
|
gsize size;
|
|
gboolean is_fixed_sized;
|
|
|
|
guint32 seed;
|
|
|
|
#define INSTANCE_MAGIC 1287582829
|
|
guint magic;
|
|
} RandomInstance;
|
|
|
|
static RandomInstance *
|
|
random_instance (GVariantTypeInfo *type_info)
|
|
{
|
|
RandomInstance *instance;
|
|
|
|
instance = g_slice_new (RandomInstance);
|
|
|
|
if (type_info == NULL)
|
|
{
|
|
gchar *str = random_type_string ();
|
|
instance->type_info = g_variant_type_info_get (G_VARIANT_TYPE (str));
|
|
g_free (str);
|
|
}
|
|
else
|
|
instance->type_info = g_variant_type_info_ref (type_info);
|
|
|
|
instance->seed = g_test_rand_int ();
|
|
|
|
g_variant_type_info_query (instance->type_info,
|
|
&instance->alignment,
|
|
&instance->size);
|
|
|
|
instance->is_fixed_sized = instance->size != 0;
|
|
|
|
if (!instance->is_fixed_sized)
|
|
instance->size = g_test_rand_int_range (0, MAX_INSTANCE_SIZE);
|
|
|
|
instance->magic = INSTANCE_MAGIC;
|
|
|
|
return instance;
|
|
}
|
|
|
|
static void
|
|
random_instance_free (RandomInstance *instance)
|
|
{
|
|
g_variant_type_info_unref (instance->type_info);
|
|
g_slice_free (RandomInstance, instance);
|
|
}
|
|
|
|
static void
|
|
append_instance_size (RandomInstance *instance,
|
|
gsize *offset)
|
|
{
|
|
*offset += (-*offset) & instance->alignment;
|
|
*offset += instance->size;
|
|
}
|
|
|
|
static void
|
|
random_instance_write (RandomInstance *instance,
|
|
guchar *buffer)
|
|
{
|
|
GRand *rand;
|
|
gint i;
|
|
|
|
g_assert_cmpint ((gsize) buffer & ALIGN_BITS & instance->alignment, ==, 0);
|
|
|
|
rand = g_rand_new_with_seed (instance->seed);
|
|
for (i = 0; i < instance->size; i++)
|
|
buffer[i] = g_rand_int (rand);
|
|
g_rand_free (rand);
|
|
}
|
|
|
|
static void
|
|
append_instance_data (RandomInstance *instance,
|
|
guchar **buffer)
|
|
{
|
|
while (((gsize) *buffer) & instance->alignment)
|
|
*(*buffer)++ = '\0';
|
|
|
|
random_instance_write (instance, *buffer);
|
|
*buffer += instance->size;
|
|
}
|
|
|
|
static gboolean
|
|
random_instance_assert (RandomInstance *instance,
|
|
guchar *buffer,
|
|
gsize size)
|
|
{
|
|
GRand *rand;
|
|
gint i;
|
|
|
|
g_assert_cmpint ((gsize) buffer & ALIGN_BITS & instance->alignment, ==, 0);
|
|
g_assert_cmpint (size, ==, instance->size);
|
|
|
|
rand = g_rand_new_with_seed (instance->seed);
|
|
for (i = 0; i < instance->size; i++)
|
|
{
|
|
guchar byte = g_rand_int (rand);
|
|
|
|
g_assert (buffer[i] == byte);
|
|
}
|
|
g_rand_free (rand);
|
|
|
|
return i == instance->size;
|
|
}
|
|
|
|
static gboolean
|
|
random_instance_check (RandomInstance *instance,
|
|
guchar *buffer,
|
|
gsize size)
|
|
{
|
|
GRand *rand;
|
|
gint i;
|
|
|
|
g_assert_cmpint ((gsize) buffer & ALIGN_BITS & instance->alignment, ==, 0);
|
|
|
|
if (size != instance->size)
|
|
return FALSE;
|
|
|
|
rand = g_rand_new_with_seed (instance->seed);
|
|
for (i = 0; i < instance->size; i++)
|
|
if (buffer[i] != (guchar) g_rand_int (rand))
|
|
break;
|
|
g_rand_free (rand);
|
|
|
|
return i == instance->size;
|
|
}
|
|
|
|
static void
|
|
random_instance_filler (GVariantSerialised *serialised,
|
|
gpointer data)
|
|
{
|
|
RandomInstance *instance = data;
|
|
|
|
g_assert (instance->magic == INSTANCE_MAGIC);
|
|
|
|
if (serialised->type_info == NULL)
|
|
serialised->type_info = instance->type_info;
|
|
|
|
if (serialised->size == 0)
|
|
serialised->size = instance->size;
|
|
|
|
g_assert (serialised->type_info == instance->type_info);
|
|
g_assert (serialised->size == instance->size);
|
|
|
|
if (serialised->data)
|
|
random_instance_write (instance, serialised->data);
|
|
}
|
|
|
|
static gsize
|
|
calculate_offset_size (gsize body_size,
|
|
gsize n_offsets)
|
|
{
|
|
if (body_size == 0)
|
|
return 0;
|
|
|
|
if (body_size + n_offsets <= G_MAXUINT8)
|
|
return 1;
|
|
|
|
if (body_size + 2 * n_offsets <= G_MAXUINT16)
|
|
return 2;
|
|
|
|
if (body_size + 4 * n_offsets <= G_MAXUINT32)
|
|
return 4;
|
|
|
|
/* the test case won't generate anything bigger */
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
static gpointer
|
|
flavoured_malloc (gsize size, gsize flavour)
|
|
{
|
|
g_assert (flavour < 8);
|
|
|
|
if (size == 0)
|
|
return NULL;
|
|
|
|
return ((gchar *) g_malloc (size + flavour)) + flavour;
|
|
}
|
|
|
|
static void
|
|
flavoured_free (gpointer data,
|
|
gsize flavour)
|
|
{
|
|
if (!data)
|
|
return;
|
|
g_free (((gchar *) data) - flavour);
|
|
}
|
|
|
|
static gpointer
|
|
align_malloc (gsize size)
|
|
{
|
|
gpointer mem;
|
|
|
|
#ifdef HAVE_POSIX_MEMALIGN
|
|
if (posix_memalign (&mem, 8, size))
|
|
g_error ("posix_memalign failed");
|
|
#else
|
|
/* NOTE: there may be platforms that lack posix_memalign() and also
|
|
* have malloc() that returns non-8-aligned. if so, we need to try
|
|
* harder here.
|
|
*/
|
|
mem = malloc (size);
|
|
#endif
|
|
|
|
return mem;
|
|
}
|
|
|
|
static void
|
|
align_free (gpointer mem)
|
|
{
|
|
free (mem);
|
|
}
|
|
|
|
static void
|
|
append_offset (guchar **offset_ptr,
|
|
gsize offset,
|
|
guint offset_size)
|
|
{
|
|
union
|
|
{
|
|
guchar bytes[sizeof (gsize)];
|
|
gsize integer;
|
|
} tmpvalue;
|
|
|
|
tmpvalue.integer = GSIZE_TO_LE (offset);
|
|
memcpy (*offset_ptr, tmpvalue.bytes, offset_size);
|
|
*offset_ptr += offset_size;
|
|
}
|
|
|
|
static void
|
|
prepend_offset (guchar **offset_ptr,
|
|
gsize offset,
|
|
guint offset_size)
|
|
{
|
|
union
|
|
{
|
|
guchar bytes[sizeof (gsize)];
|
|
gsize integer;
|
|
} tmpvalue;
|
|
|
|
*offset_ptr -= offset_size;
|
|
tmpvalue.integer = GSIZE_TO_LE (offset);
|
|
memcpy (*offset_ptr, tmpvalue.bytes, offset_size);
|
|
}
|
|
|
|
static void
|
|
test_maybe (void)
|
|
{
|
|
GVariantTypeInfo *type_info;
|
|
RandomInstance *instance;
|
|
gsize needed_size;
|
|
guchar *data;
|
|
|
|
instance = random_instance (NULL);
|
|
|
|
{
|
|
const gchar *element;
|
|
gchar *tmp;
|
|
|
|
element = g_variant_type_info_get_type_string (instance->type_info);
|
|
tmp = g_strdup_printf ("m%s", element);
|
|
type_info = g_variant_type_info_get (G_VARIANT_TYPE (tmp));
|
|
g_free (tmp);
|
|
}
|
|
|
|
needed_size = g_variant_serialiser_needed_size (type_info,
|
|
random_instance_filler,
|
|
NULL, 0);
|
|
g_assert_cmpint (needed_size, ==, 0);
|
|
|
|
needed_size = g_variant_serialiser_needed_size (type_info,
|
|
random_instance_filler,
|
|
(gpointer *) &instance, 1);
|
|
|
|
if (instance->is_fixed_sized)
|
|
g_assert_cmpint (needed_size, ==, instance->size);
|
|
else
|
|
g_assert_cmpint (needed_size, ==, instance->size + 1);
|
|
|
|
{
|
|
guchar *ptr;
|
|
|
|
ptr = data = align_malloc (needed_size);
|
|
append_instance_data (instance, &ptr);
|
|
|
|
if (!instance->is_fixed_sized)
|
|
*ptr++ = '\0';
|
|
|
|
g_assert_cmpint (ptr - data, ==, needed_size);
|
|
}
|
|
|
|
{
|
|
guint alignment;
|
|
guint flavour;
|
|
|
|
alignment = (instance->alignment & ALIGN_BITS) + 1;
|
|
|
|
for (flavour = 0; flavour < 8; flavour += alignment)
|
|
{
|
|
GVariantSerialised serialised;
|
|
GVariantSerialised child;
|
|
|
|
serialised.type_info = type_info;
|
|
serialised.data = flavoured_malloc (needed_size, flavour);
|
|
serialised.size = needed_size;
|
|
|
|
g_variant_serialiser_serialise (serialised,
|
|
random_instance_filler,
|
|
(gpointer *) &instance, 1);
|
|
child = g_variant_serialised_get_child (serialised, 0);
|
|
g_assert (child.type_info == instance->type_info);
|
|
random_instance_assert (instance, child.data, child.size);
|
|
g_variant_type_info_unref (child.type_info);
|
|
flavoured_free (serialised.data, flavour);
|
|
}
|
|
}
|
|
|
|
g_variant_type_info_unref (type_info);
|
|
random_instance_free (instance);
|
|
align_free (data);
|
|
}
|
|
|
|
static void
|
|
test_maybes (void)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < 1000; i++)
|
|
test_maybe ();
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_array (void)
|
|
{
|
|
GVariantTypeInfo *element_info;
|
|
GVariantTypeInfo *array_info;
|
|
RandomInstance **instances;
|
|
gsize needed_size;
|
|
gsize offset_size;
|
|
guint n_children;
|
|
guchar *data;
|
|
|
|
{
|
|
gchar *element_type, *array_type;
|
|
|
|
element_type = random_type_string ();
|
|
array_type = g_strdup_printf ("a%s", element_type);
|
|
|
|
element_info = g_variant_type_info_get (G_VARIANT_TYPE (element_type));
|
|
array_info = g_variant_type_info_get (G_VARIANT_TYPE (array_type));
|
|
g_assert (g_variant_type_info_element (array_info) == element_info);
|
|
|
|
g_free (element_type);
|
|
g_free (array_type);
|
|
}
|
|
|
|
{
|
|
guint i;
|
|
|
|
n_children = g_test_rand_int_range (0, MAX_ARRAY_CHILDREN);
|
|
instances = g_new (RandomInstance *, n_children);
|
|
for (i = 0; i < n_children; i++)
|
|
instances[i] = random_instance (element_info);
|
|
}
|
|
|
|
needed_size = g_variant_serialiser_needed_size (array_info,
|
|
random_instance_filler,
|
|
(gpointer *) instances,
|
|
n_children);
|
|
|
|
{
|
|
gsize element_fixed_size;
|
|
gsize body_size = 0;
|
|
guint i;
|
|
|
|
for (i = 0; i < n_children; i++)
|
|
append_instance_size (instances[i], &body_size);
|
|
|
|
g_variant_type_info_query (element_info, NULL, &element_fixed_size);
|
|
|
|
if (!element_fixed_size)
|
|
{
|
|
offset_size = calculate_offset_size (body_size, n_children);
|
|
|
|
if (offset_size == 0)
|
|
offset_size = 1;
|
|
}
|
|
else
|
|
offset_size = 0;
|
|
|
|
g_assert_cmpint (needed_size, ==, body_size + n_children * offset_size);
|
|
}
|
|
|
|
{
|
|
guchar *offset_ptr, *body_ptr;
|
|
guint i;
|
|
|
|
body_ptr = data = align_malloc (needed_size);
|
|
offset_ptr = body_ptr + needed_size - offset_size * n_children;
|
|
|
|
for (i = 0; i < n_children; i++)
|
|
{
|
|
append_instance_data (instances[i], &body_ptr);
|
|
append_offset (&offset_ptr, body_ptr - data, offset_size);
|
|
}
|
|
|
|
g_assert (body_ptr == data + needed_size - offset_size * n_children);
|
|
g_assert (offset_ptr == data + needed_size);
|
|
}
|
|
|
|
{
|
|
guint alignment;
|
|
gsize flavour;
|
|
guint i;
|
|
|
|
g_variant_type_info_query (array_info, &alignment, NULL);
|
|
alignment = (alignment & ALIGN_BITS) + 1;
|
|
|
|
for (flavour = 0; flavour < 8; flavour += alignment)
|
|
{
|
|
GVariantSerialised serialised;
|
|
|
|
serialised.type_info = array_info;
|
|
serialised.data = flavoured_malloc (needed_size, flavour);
|
|
serialised.size = needed_size;
|
|
|
|
g_variant_serialiser_serialise (serialised, random_instance_filler,
|
|
(gpointer *) instances, n_children);
|
|
|
|
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++)
|
|
{
|
|
GVariantSerialised child;
|
|
|
|
child = g_variant_serialised_get_child (serialised, i);
|
|
g_assert (child.type_info == instances[i]->type_info);
|
|
random_instance_assert (instances[i], child.data, child.size);
|
|
g_variant_type_info_unref (child.type_info);
|
|
}
|
|
|
|
flavoured_free (serialised.data, flavour);
|
|
}
|
|
}
|
|
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < n_children; i++)
|
|
random_instance_free (instances[i]);
|
|
g_free (instances);
|
|
}
|
|
|
|
g_variant_type_info_unref (element_info);
|
|
g_variant_type_info_unref (array_info);
|
|
align_free (data);
|
|
}
|
|
|
|
static void
|
|
test_arrays (void)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < 100; i++)
|
|
test_array ();
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_tuple (void)
|
|
{
|
|
GVariantTypeInfo *type_info;
|
|
RandomInstance **instances;
|
|
gboolean fixed_size;
|
|
gsize needed_size;
|
|
gsize offset_size;
|
|
guint n_children;
|
|
guint alignment;
|
|
guchar *data;
|
|
|
|
n_children = g_test_rand_int_range (0, MAX_TUPLE_CHILDREN);
|
|
instances = g_new (RandomInstance *, n_children);
|
|
|
|
{
|
|
GString *type_string;
|
|
guint i;
|
|
|
|
fixed_size = TRUE;
|
|
alignment = 0;
|
|
|
|
type_string = g_string_new ("(");
|
|
for (i = 0; i < n_children; i++)
|
|
{
|
|
const gchar *str;
|
|
|
|
instances[i] = random_instance (NULL);
|
|
|
|
alignment |= instances[i]->alignment;
|
|
if (!instances[i]->is_fixed_sized)
|
|
fixed_size = FALSE;
|
|
|
|
str = g_variant_type_info_get_type_string (instances[i]->type_info);
|
|
g_string_append (type_string, str);
|
|
}
|
|
g_string_append_c (type_string, ')');
|
|
|
|
type_info = g_variant_type_info_get (G_VARIANT_TYPE (type_string->str));
|
|
g_string_free (type_string, TRUE);
|
|
}
|
|
|
|
needed_size = g_variant_serialiser_needed_size (type_info,
|
|
random_instance_filler,
|
|
(gpointer *) instances,
|
|
n_children);
|
|
{
|
|
gsize body_size = 0;
|
|
gsize offsets = 0;
|
|
guint i;
|
|
|
|
for (i = 0; i < n_children; i++)
|
|
{
|
|
append_instance_size (instances[i], &body_size);
|
|
|
|
if (i != n_children - 1 && !instances[i]->is_fixed_sized)
|
|
offsets++;
|
|
}
|
|
|
|
if (fixed_size)
|
|
{
|
|
body_size += (-body_size) & alignment;
|
|
|
|
g_assert ((body_size == 0) == (n_children == 0));
|
|
if (n_children == 0)
|
|
body_size = 1;
|
|
}
|
|
|
|
offset_size = calculate_offset_size (body_size, offsets);
|
|
g_assert_cmpint (needed_size, ==, body_size + offsets * offset_size);
|
|
}
|
|
|
|
{
|
|
guchar *body_ptr;
|
|
guchar *ofs_ptr;
|
|
guint i;
|
|
|
|
body_ptr = data = align_malloc (needed_size);
|
|
ofs_ptr = body_ptr + needed_size;
|
|
|
|
for (i = 0; i < n_children; i++)
|
|
{
|
|
append_instance_data (instances[i], &body_ptr);
|
|
|
|
if (i != n_children - 1 && !instances[i]->is_fixed_sized)
|
|
prepend_offset (&ofs_ptr, body_ptr - data, offset_size);
|
|
}
|
|
|
|
if (fixed_size)
|
|
{
|
|
while (((gsize) body_ptr) & alignment)
|
|
*body_ptr++ = '\0';
|
|
|
|
g_assert ((body_ptr == data) == (n_children == 0));
|
|
if (n_children == 0)
|
|
*body_ptr++ = '\0';
|
|
|
|
}
|
|
|
|
|
|
g_assert (body_ptr == ofs_ptr);
|
|
}
|
|
|
|
{
|
|
gsize flavour;
|
|
guint i;
|
|
|
|
alignment = (alignment & ALIGN_BITS) + 1;
|
|
|
|
for (flavour = 0; flavour < 8; flavour += alignment)
|
|
{
|
|
GVariantSerialised serialised;
|
|
|
|
serialised.type_info = type_info;
|
|
serialised.data = flavoured_malloc (needed_size, flavour);
|
|
serialised.size = needed_size;
|
|
|
|
g_variant_serialiser_serialise (serialised, random_instance_filler,
|
|
(gpointer *) instances, n_children);
|
|
|
|
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++)
|
|
{
|
|
GVariantSerialised child;
|
|
|
|
child = g_variant_serialised_get_child (serialised, i);
|
|
g_assert (child.type_info == instances[i]->type_info);
|
|
random_instance_assert (instances[i], child.data, child.size);
|
|
g_variant_type_info_unref (child.type_info);
|
|
}
|
|
|
|
flavoured_free (serialised.data, flavour);
|
|
}
|
|
}
|
|
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < n_children; i++)
|
|
random_instance_free (instances[i]);
|
|
g_free (instances);
|
|
}
|
|
|
|
g_variant_type_info_unref (type_info);
|
|
align_free (data);
|
|
}
|
|
|
|
static void
|
|
test_tuples (void)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < 100; i++)
|
|
test_tuple ();
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_variant (void)
|
|
{
|
|
GVariantTypeInfo *type_info;
|
|
RandomInstance *instance;
|
|
const gchar *type_string;
|
|
gsize needed_size;
|
|
guchar *data;
|
|
gsize len;
|
|
|
|
type_info = g_variant_type_info_get (G_VARIANT_TYPE_VARIANT);
|
|
instance = random_instance (NULL);
|
|
|
|
type_string = g_variant_type_info_get_type_string (instance->type_info);
|
|
len = strlen (type_string);
|
|
|
|
needed_size = g_variant_serialiser_needed_size (type_info,
|
|
random_instance_filler,
|
|
(gpointer *) &instance, 1);
|
|
|
|
g_assert_cmpint (needed_size, ==, instance->size + 1 + len);
|
|
|
|
{
|
|
guchar *ptr;
|
|
|
|
ptr = data = align_malloc (needed_size);
|
|
append_instance_data (instance, &ptr);
|
|
*ptr++ = '\0';
|
|
memcpy (ptr, type_string, len);
|
|
ptr += len;
|
|
|
|
g_assert (data + needed_size == ptr);
|
|
}
|
|
|
|
{
|
|
gsize alignment;
|
|
gsize flavour;
|
|
|
|
/* variants are always 8-aligned */
|
|
alignment = ALIGN_BITS + 1;
|
|
|
|
for (flavour = 0; flavour < 8; flavour += alignment)
|
|
{
|
|
GVariantSerialised serialised;
|
|
GVariantSerialised child;
|
|
|
|
serialised.type_info = type_info;
|
|
serialised.data = flavoured_malloc (needed_size, flavour);
|
|
serialised.size = needed_size;
|
|
|
|
g_variant_serialiser_serialise (serialised, random_instance_filler,
|
|
(gpointer *) &instance, 1);
|
|
|
|
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);
|
|
g_assert (child.type_info == instance->type_info);
|
|
random_instance_check (instance, child.data, child.size);
|
|
|
|
g_variant_type_info_unref (child.type_info);
|
|
flavoured_free (serialised.data, flavour);
|
|
}
|
|
}
|
|
|
|
g_variant_type_info_unref (type_info);
|
|
random_instance_free (instance);
|
|
align_free (data);
|
|
}
|
|
|
|
static void
|
|
test_variants (void)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < 100; i++)
|
|
test_variant ();
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_strings (void)
|
|
{
|
|
struct {
|
|
guint flags;
|
|
guint size;
|
|
gconstpointer data;
|
|
} test_cases[] = {
|
|
#define is_nval 0
|
|
#define is_string 1
|
|
#define is_objpath is_string | 2
|
|
#define is_sig is_string | 4
|
|
{ is_sig, 1, "" },
|
|
{ is_nval, 0, NULL },
|
|
{ is_nval, 13, "hello\xffworld!" },
|
|
{ is_string, 13, "hello world!" },
|
|
{ is_nval, 13, "hello world\0" },
|
|
{ is_nval, 13, "hello\0world!" },
|
|
{ is_nval, 12, "hello world!" },
|
|
{ is_nval, 13, "hello world!\xff" },
|
|
|
|
{ is_objpath, 2, "/" },
|
|
{ is_objpath, 3, "/a" },
|
|
{ is_string, 3, "//" },
|
|
{ is_objpath, 11, "/some/path" },
|
|
{ is_string, 12, "/some/path/" },
|
|
{ is_nval, 11, "/some\0path" },
|
|
{ is_string, 11, "/some\\path" },
|
|
{ is_string, 12, "/some//path" },
|
|
{ is_string, 12, "/some-/path" },
|
|
|
|
{ is_sig, 2, "i" },
|
|
{ is_sig, 2, "s" },
|
|
{ is_sig, 5, "(si)" },
|
|
{ is_string, 4, "(si" },
|
|
{ is_string, 2, "*" },
|
|
{ is_sig, 3, "ai" },
|
|
{ is_string, 3, "mi" },
|
|
{ is_string, 2, "r" },
|
|
{ is_sig, 15, "(yyy{sv}ssiai)" },
|
|
{ is_string, 16, "(yyy{yv}ssiai))" },
|
|
{ is_string, 15, "(yyy{vv}ssiai)" },
|
|
{ is_string, 15, "(yyy{sv)ssiai}" }
|
|
};
|
|
guint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (test_cases); i++)
|
|
{
|
|
guint flags;
|
|
|
|
flags = g_variant_serialiser_is_string (test_cases[i].data,
|
|
test_cases[i].size)
|
|
? 1 : 0;
|
|
|
|
flags |= g_variant_serialiser_is_object_path (test_cases[i].data,
|
|
test_cases[i].size)
|
|
? 2 : 0;
|
|
|
|
flags |= g_variant_serialiser_is_signature (test_cases[i].data,
|
|
test_cases[i].size)
|
|
? 4 : 0;
|
|
|
|
g_assert (flags == test_cases[i].flags);
|
|
}
|
|
}
|
|
|
|
typedef struct _TreeInstance TreeInstance;
|
|
struct _TreeInstance
|
|
{
|
|
GVariantTypeInfo *info;
|
|
|
|
TreeInstance **children;
|
|
gsize n_children;
|
|
|
|
union {
|
|
guint64 integer;
|
|
gdouble floating;
|
|
gchar string[200];
|
|
} data;
|
|
gsize data_size;
|
|
};
|
|
|
|
static GVariantType *
|
|
make_random_definite_type (int depth)
|
|
{
|
|
GString *description;
|
|
GString *type_string;
|
|
GVariantType *type;
|
|
|
|
description = g_string_new (NULL);
|
|
type_string = g_string_new (NULL);
|
|
type = append_type_string (type_string, description, TRUE, depth);
|
|
g_string_free (description, TRUE);
|
|
g_string_free (type_string, TRUE);
|
|
|
|
return type;
|
|
}
|
|
|
|
static void
|
|
make_random_string (gchar *string,
|
|
gsize size,
|
|
const GVariantType *type)
|
|
{
|
|
gint i;
|
|
|
|
/* create strings that are valid signature strings */
|
|
#define good_chars "bynqiuxthdsog"
|
|
|
|
for (i = 0; i < size - 1; i++)
|
|
string[i] = good_chars[g_test_rand_int_range (0, strlen (good_chars))];
|
|
string[i] = '\0';
|
|
|
|
/* in case we need an object path, prefix a '/' */
|
|
if (*g_variant_type_peek_string (type) == 'o')
|
|
string[0] = '/';
|
|
|
|
#undef good_chars
|
|
}
|
|
|
|
static TreeInstance *
|
|
tree_instance_new (const GVariantType *type,
|
|
int depth)
|
|
{
|
|
const GVariantType *child_type = NULL;
|
|
GVariantType *mytype = NULL;
|
|
TreeInstance *instance;
|
|
gboolean is_tuple_type;
|
|
|
|
if (type == NULL)
|
|
type = mytype = make_random_definite_type (depth);
|
|
|
|
instance = g_slice_new (TreeInstance);
|
|
instance->info = g_variant_type_info_get (type);
|
|
instance->children = NULL;
|
|
instance->n_children = 0;
|
|
instance->data_size = 0;
|
|
|
|
is_tuple_type = FALSE;
|
|
|
|
switch (*g_variant_type_peek_string (type))
|
|
{
|
|
case G_VARIANT_TYPE_INFO_CHAR_MAYBE:
|
|
instance->n_children = g_test_rand_int_range (0, 2);
|
|
child_type = g_variant_type_element (type);
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_ARRAY:
|
|
instance->n_children = g_test_rand_int_range (0, MAX_ARRAY_CHILDREN);
|
|
child_type = g_variant_type_element (type);
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_DICT_ENTRY:
|
|
case G_VARIANT_TYPE_INFO_CHAR_TUPLE:
|
|
instance->n_children = g_variant_type_n_items (type);
|
|
child_type = g_variant_type_first (type);
|
|
is_tuple_type = TRUE;
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_VARIANT:
|
|
instance->n_children = 1;
|
|
child_type = NULL;
|
|
break;
|
|
|
|
case 'b':
|
|
instance->data.integer = g_test_rand_int_range (0, 2);
|
|
instance->data_size = 1;
|
|
break;
|
|
|
|
case 'y':
|
|
instance->data.integer = g_test_rand_int ();
|
|
instance->data_size = 1;
|
|
break;
|
|
|
|
case 'n': case 'q':
|
|
instance->data.integer = g_test_rand_int ();
|
|
instance->data_size = 2;
|
|
break;
|
|
|
|
case 'i': case 'u': case 'h':
|
|
instance->data.integer = g_test_rand_int ();
|
|
instance->data_size = 4;
|
|
break;
|
|
|
|
case 'x': case 't':
|
|
instance->data.integer = g_test_rand_int ();
|
|
instance->data.integer <<= 32;
|
|
instance->data.integer |= (guint32) g_test_rand_int ();
|
|
instance->data_size = 8;
|
|
break;
|
|
|
|
case 'd':
|
|
instance->data.floating = g_test_rand_double ();
|
|
instance->data_size = 8;
|
|
break;
|
|
|
|
case 's': case 'o': case 'g':
|
|
instance->data_size = g_test_rand_int_range (10, 200);
|
|
make_random_string (instance->data.string, instance->data_size, type);
|
|
break;
|
|
}
|
|
|
|
if (instance->data_size == 0)
|
|
/* no data -> it is a container */
|
|
{
|
|
guint i;
|
|
|
|
instance->children = g_new (TreeInstance *, instance->n_children);
|
|
|
|
for (i = 0; i < instance->n_children; i++)
|
|
{
|
|
instance->children[i] = tree_instance_new (child_type, depth - 1);
|
|
|
|
if (is_tuple_type)
|
|
child_type = g_variant_type_next (child_type);
|
|
}
|
|
|
|
g_assert (!is_tuple_type || child_type == NULL);
|
|
}
|
|
|
|
g_variant_type_free (mytype);
|
|
|
|
return instance;
|
|
}
|
|
|
|
static void
|
|
tree_instance_free (TreeInstance *instance)
|
|
{
|
|
gint i;
|
|
|
|
g_variant_type_info_unref (instance->info);
|
|
for (i = 0; i < instance->n_children; i++)
|
|
tree_instance_free (instance->children[i]);
|
|
g_free (instance->children);
|
|
g_slice_free (TreeInstance, instance);
|
|
}
|
|
|
|
static gboolean i_am_writing_byteswapped;
|
|
|
|
static void
|
|
tree_filler (GVariantSerialised *serialised,
|
|
gpointer data)
|
|
{
|
|
TreeInstance *instance = data;
|
|
|
|
if (serialised->type_info == NULL)
|
|
serialised->type_info = instance->info;
|
|
|
|
if (instance->data_size == 0)
|
|
/* is a container */
|
|
{
|
|
if (serialised->size == 0)
|
|
serialised->size =
|
|
g_variant_serialiser_needed_size (instance->info, tree_filler,
|
|
(gpointer *) instance->children,
|
|
instance->n_children);
|
|
|
|
if (serialised->data)
|
|
g_variant_serialiser_serialise (*serialised, tree_filler,
|
|
(gpointer *) instance->children,
|
|
instance->n_children);
|
|
}
|
|
else
|
|
/* it is a leaf */
|
|
{
|
|
if (serialised->size == 0)
|
|
serialised->size = instance->data_size;
|
|
|
|
if (serialised->data)
|
|
{
|
|
switch (instance->data_size)
|
|
{
|
|
case 1:
|
|
*serialised->data = instance->data.integer;
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
guint16 value = instance->data.integer;
|
|
|
|
if (i_am_writing_byteswapped)
|
|
value = GUINT16_SWAP_LE_BE (value);
|
|
|
|
*(guint16 *) serialised->data = value;
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
{
|
|
guint32 value = instance->data.integer;
|
|
|
|
if (i_am_writing_byteswapped)
|
|
value = GUINT32_SWAP_LE_BE (value);
|
|
|
|
*(guint32 *) serialised->data = value;
|
|
}
|
|
break;
|
|
|
|
case 8:
|
|
{
|
|
guint64 value = instance->data.integer;
|
|
|
|
if (i_am_writing_byteswapped)
|
|
value = GUINT64_SWAP_LE_BE (value);
|
|
|
|
*(guint64 *) serialised->data = value;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
memcpy (serialised->data,
|
|
instance->data.string,
|
|
instance->data_size);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
check_tree (TreeInstance *instance,
|
|
GVariantSerialised serialised)
|
|
{
|
|
if (instance->info != serialised.type_info)
|
|
return FALSE;
|
|
|
|
if (instance->data_size == 0)
|
|
/* is a container */
|
|
{
|
|
gint i;
|
|
|
|
if (g_variant_serialised_n_children (serialised) !=
|
|
instance->n_children)
|
|
return FALSE;
|
|
|
|
for (i = 0; i < instance->n_children; i++)
|
|
{
|
|
GVariantSerialised child;
|
|
gpointer data = NULL;
|
|
gboolean ok;
|
|
|
|
child = g_variant_serialised_get_child (serialised, i);
|
|
if (child.size && child.data == NULL)
|
|
child.data = data = g_malloc0 (child.size);
|
|
ok = check_tree (instance->children[i], child);
|
|
g_variant_type_info_unref (child.type_info);
|
|
g_free (data);
|
|
|
|
if (!ok)
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
/* it is a leaf */
|
|
{
|
|
switch (instance->data_size)
|
|
{
|
|
case 1:
|
|
g_assert (serialised.size == 1);
|
|
return *(guint8 *) serialised.data ==
|
|
(guint8) instance->data.integer;
|
|
|
|
case 2:
|
|
g_assert (serialised.size == 2);
|
|
return *(guint16 *) serialised.data ==
|
|
(guint16) instance->data.integer;
|
|
|
|
case 4:
|
|
g_assert (serialised.size == 4);
|
|
return *(guint32 *) serialised.data ==
|
|
(guint32) instance->data.integer;
|
|
|
|
case 8:
|
|
g_assert (serialised.size == 8);
|
|
return *(guint64 *) serialised.data ==
|
|
(guint64) instance->data.integer;
|
|
|
|
default:
|
|
if (serialised.size != instance->data_size)
|
|
return FALSE;
|
|
|
|
return memcmp (serialised.data,
|
|
instance->data.string,
|
|
instance->data_size) == 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
serialise_tree (TreeInstance *tree,
|
|
GVariantSerialised *serialised)
|
|
{
|
|
GVariantSerialised empty = {0, };
|
|
|
|
*serialised = empty;
|
|
tree_filler (serialised, tree);
|
|
serialised->data = g_malloc (serialised->size);
|
|
tree_filler (serialised, tree);
|
|
}
|
|
|
|
static void
|
|
test_byteswap (void)
|
|
{
|
|
GVariantSerialised one, two;
|
|
TreeInstance *tree;
|
|
|
|
tree = tree_instance_new (NULL, 3);
|
|
serialise_tree (tree, &one);
|
|
|
|
i_am_writing_byteswapped = TRUE;
|
|
serialise_tree (tree, &two);
|
|
i_am_writing_byteswapped = FALSE;
|
|
|
|
g_variant_serialised_byteswap (two);
|
|
|
|
g_assert_cmpmem (one.data, one.size, two.data, two.size);
|
|
|
|
tree_instance_free (tree);
|
|
g_free (one.data);
|
|
g_free (two.data);
|
|
}
|
|
|
|
static void
|
|
test_byteswaps (void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < 200; i++)
|
|
test_byteswap ();
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_fuzz (gdouble *fuzziness)
|
|
{
|
|
GVariantSerialised serialised;
|
|
TreeInstance *tree;
|
|
|
|
/* make an instance */
|
|
tree = tree_instance_new (NULL, 3);
|
|
|
|
/* serialise it */
|
|
serialise_tree (tree, &serialised);
|
|
|
|
g_assert (g_variant_serialised_is_normal (serialised));
|
|
g_assert (check_tree (tree, serialised));
|
|
|
|
if (serialised.size)
|
|
{
|
|
gboolean fuzzed = FALSE;
|
|
gboolean a, b;
|
|
|
|
while (!fuzzed)
|
|
{
|
|
gint i;
|
|
|
|
for (i = 0; i < serialised.size; i++)
|
|
if (randomly (*fuzziness))
|
|
{
|
|
serialised.data[i] += g_test_rand_int_range (1, 256);
|
|
fuzzed = TRUE;
|
|
}
|
|
}
|
|
|
|
/* at least one byte in the serialised data has changed.
|
|
*
|
|
* this means that at least one of the following is true:
|
|
*
|
|
* - the serialised data now represents a different value:
|
|
* check_tree() will return FALSE
|
|
*
|
|
* - the serialised data is in non-normal form:
|
|
* g_variant_serialiser_is_normal() will return FALSE
|
|
*
|
|
* we always do both checks to increase exposure of the serialiser
|
|
* to corrupt data.
|
|
*/
|
|
a = g_variant_serialised_is_normal (serialised);
|
|
b = check_tree (tree, serialised);
|
|
|
|
g_assert (!a || !b);
|
|
}
|
|
|
|
tree_instance_free (tree);
|
|
g_free (serialised.data);
|
|
}
|
|
|
|
|
|
static void
|
|
test_fuzzes (gpointer data)
|
|
{
|
|
gdouble fuzziness;
|
|
int i;
|
|
|
|
fuzziness = GPOINTER_TO_INT (data) / 100.;
|
|
|
|
for (i = 0; i < 200; i++)
|
|
test_fuzz (&fuzziness);
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static GVariant *
|
|
tree_instance_get_gvariant (TreeInstance *tree)
|
|
{
|
|
const GVariantType *type;
|
|
GVariant *result;
|
|
|
|
type = (GVariantType *) g_variant_type_info_get_type_string (tree->info);
|
|
|
|
switch (g_variant_type_info_get_type_char (tree->info))
|
|
{
|
|
case G_VARIANT_TYPE_INFO_CHAR_MAYBE:
|
|
{
|
|
const GVariantType *child_type;
|
|
GVariant *child;
|
|
|
|
if (tree->n_children)
|
|
child = tree_instance_get_gvariant (tree->children[0]);
|
|
else
|
|
child = NULL;
|
|
|
|
child_type = g_variant_type_element (type);
|
|
|
|
if (child != NULL && randomly (0.5))
|
|
child_type = NULL;
|
|
|
|
result = g_variant_new_maybe (child_type, child);
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_ARRAY:
|
|
{
|
|
const GVariantType *child_type;
|
|
GVariant **children;
|
|
gint i;
|
|
|
|
children = g_new (GVariant *, tree->n_children);
|
|
for (i = 0; i < tree->n_children; i++)
|
|
children[i] = tree_instance_get_gvariant (tree->children[i]);
|
|
|
|
child_type = g_variant_type_element (type);
|
|
|
|
if (i > 0 && randomly (0.5))
|
|
child_type = NULL;
|
|
|
|
result = g_variant_new_array (child_type, children, tree->n_children);
|
|
g_free (children);
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_TUPLE:
|
|
{
|
|
GVariant **children;
|
|
gint i;
|
|
|
|
children = g_new (GVariant *, tree->n_children);
|
|
for (i = 0; i < tree->n_children; i++)
|
|
children[i] = tree_instance_get_gvariant (tree->children[i]);
|
|
|
|
result = g_variant_new_tuple (children, tree->n_children);
|
|
g_free (children);
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_DICT_ENTRY:
|
|
{
|
|
GVariant *key, *val;
|
|
|
|
g_assert (tree->n_children == 2);
|
|
|
|
key = tree_instance_get_gvariant (tree->children[0]);
|
|
val = tree_instance_get_gvariant (tree->children[1]);
|
|
|
|
result = g_variant_new_dict_entry (key, val);
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_VARIANT:
|
|
{
|
|
GVariant *value;
|
|
|
|
g_assert (tree->n_children == 1);
|
|
|
|
value = tree_instance_get_gvariant (tree->children[0]);
|
|
result = g_variant_new_variant (value);
|
|
}
|
|
break;
|
|
|
|
case 'b':
|
|
result = g_variant_new_boolean (tree->data.integer > 0);
|
|
break;
|
|
|
|
case 'y':
|
|
result = g_variant_new_byte (tree->data.integer);
|
|
break;
|
|
|
|
case 'n':
|
|
result = g_variant_new_int16 (tree->data.integer);
|
|
break;
|
|
|
|
case 'q':
|
|
result = g_variant_new_uint16 (tree->data.integer);
|
|
break;
|
|
|
|
case 'i':
|
|
result = g_variant_new_int32 (tree->data.integer);
|
|
break;
|
|
|
|
case 'u':
|
|
result = g_variant_new_uint32 (tree->data.integer);
|
|
break;
|
|
|
|
case 'x':
|
|
result = g_variant_new_int64 (tree->data.integer);
|
|
break;
|
|
|
|
case 't':
|
|
result = g_variant_new_uint64 (tree->data.integer);
|
|
break;
|
|
|
|
case 'h':
|
|
result = g_variant_new_handle (tree->data.integer);
|
|
break;
|
|
|
|
case 'd':
|
|
result = g_variant_new_double (tree->data.floating);
|
|
break;
|
|
|
|
case 's':
|
|
result = g_variant_new_string (tree->data.string);
|
|
break;
|
|
|
|
case 'o':
|
|
result = g_variant_new_object_path (tree->data.string);
|
|
break;
|
|
|
|
case 'g':
|
|
result = g_variant_new_signature (tree->data.string);
|
|
break;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static gboolean
|
|
tree_instance_check_gvariant (TreeInstance *tree,
|
|
GVariant *value)
|
|
{
|
|
const GVariantType *type;
|
|
|
|
type = (GVariantType *) g_variant_type_info_get_type_string (tree->info);
|
|
g_assert (g_variant_is_of_type (value, type));
|
|
|
|
switch (g_variant_type_info_get_type_char (tree->info))
|
|
{
|
|
case G_VARIANT_TYPE_INFO_CHAR_MAYBE:
|
|
{
|
|
GVariant *child;
|
|
gboolean equal;
|
|
|
|
child = g_variant_get_maybe (value);
|
|
|
|
if (child != NULL && tree->n_children == 1)
|
|
equal = tree_instance_check_gvariant (tree->children[0], child);
|
|
else if (child == NULL && tree->n_children == 0)
|
|
equal = TRUE;
|
|
else
|
|
equal = FALSE;
|
|
|
|
if (child != NULL)
|
|
g_variant_unref (child);
|
|
|
|
return equal;
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_ARRAY:
|
|
case G_VARIANT_TYPE_INFO_CHAR_TUPLE:
|
|
case G_VARIANT_TYPE_INFO_CHAR_DICT_ENTRY:
|
|
{
|
|
gsize i;
|
|
|
|
if (g_variant_n_children (value) != tree->n_children)
|
|
return FALSE;
|
|
|
|
for (i = 0; i < tree->n_children; i++)
|
|
{
|
|
GVariant *child;
|
|
gboolean equal;
|
|
|
|
child = g_variant_get_child_value (value, i);
|
|
equal = tree_instance_check_gvariant (tree->children[i], child);
|
|
g_variant_unref (child);
|
|
|
|
if (!equal)
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case G_VARIANT_TYPE_INFO_CHAR_VARIANT:
|
|
{
|
|
const gchar *str1, *str2;
|
|
GVariant *child;
|
|
gboolean equal;
|
|
|
|
child = g_variant_get_variant (value);
|
|
str1 = g_variant_get_type_string (child);
|
|
str2 = g_variant_type_info_get_type_string (tree->children[0]->info);
|
|
/* GVariant only keeps one copy of type strings around */
|
|
equal = str1 == str2 &&
|
|
tree_instance_check_gvariant (tree->children[0], child);
|
|
|
|
g_variant_unref (child);
|
|
|
|
return equal;
|
|
}
|
|
break;
|
|
|
|
case 'b':
|
|
return g_variant_get_boolean (value) == tree->data.integer;
|
|
|
|
case 'y':
|
|
return g_variant_get_byte (value) == (guchar) tree->data.integer;
|
|
|
|
case 'n':
|
|
return g_variant_get_int16 (value) == (gint16) tree->data.integer;
|
|
|
|
case 'q':
|
|
return g_variant_get_uint16 (value) == (guint16) tree->data.integer;
|
|
|
|
case 'i':
|
|
return g_variant_get_int32 (value) == (gint32) tree->data.integer;
|
|
|
|
case 'u':
|
|
return g_variant_get_uint32 (value) == (guint32) tree->data.integer;
|
|
|
|
case 'x':
|
|
return g_variant_get_int64 (value) == (gint64) tree->data.integer;
|
|
|
|
case 't':
|
|
return g_variant_get_uint64 (value) == (guint64) tree->data.integer;
|
|
|
|
case 'h':
|
|
return g_variant_get_handle (value) == (gint32) tree->data.integer;
|
|
|
|
case 'd':
|
|
{
|
|
gdouble floating = g_variant_get_double (value);
|
|
|
|
return memcmp (&floating, &tree->data.floating, sizeof floating) == 0;
|
|
}
|
|
|
|
case 's':
|
|
case 'o':
|
|
case 'g':
|
|
return strcmp (g_variant_get_string (value, NULL),
|
|
tree->data.string) == 0;
|
|
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
static void
|
|
tree_instance_build_gvariant (TreeInstance *tree,
|
|
GVariantBuilder *builder,
|
|
gboolean guess_ok)
|
|
{
|
|
const GVariantType *type;
|
|
|
|
type = (GVariantType *) g_variant_type_info_get_type_string (tree->info);
|
|
|
|
if (g_variant_type_is_container (type))
|
|
{
|
|
gsize i;
|
|
|
|
/* force GVariantBuilder to guess the type half the time */
|
|
if (guess_ok && randomly (0.5))
|
|
{
|
|
if (g_variant_type_is_array (type) && tree->n_children)
|
|
type = G_VARIANT_TYPE_ARRAY;
|
|
|
|
if (g_variant_type_is_maybe (type) && tree->n_children)
|
|
type = G_VARIANT_TYPE_MAYBE;
|
|
|
|
if (g_variant_type_is_tuple (type))
|
|
type = G_VARIANT_TYPE_TUPLE;
|
|
|
|
if (g_variant_type_is_dict_entry (type))
|
|
type = G_VARIANT_TYPE_DICT_ENTRY;
|
|
}
|
|
else
|
|
guess_ok = FALSE;
|
|
|
|
g_variant_builder_open (builder, type);
|
|
|
|
for (i = 0; i < tree->n_children; i++)
|
|
tree_instance_build_gvariant (tree->children[i], builder, guess_ok);
|
|
|
|
g_variant_builder_close (builder);
|
|
}
|
|
else
|
|
g_variant_builder_add_value (builder, tree_instance_get_gvariant (tree));
|
|
}
|
|
|
|
|
|
static gboolean
|
|
tree_instance_check_iter (TreeInstance *tree,
|
|
GVariantIter *iter)
|
|
{
|
|
GVariant *value;
|
|
|
|
value = g_variant_iter_next_value (iter);
|
|
|
|
if (g_variant_is_container (value))
|
|
{
|
|
gsize i;
|
|
|
|
iter = g_variant_iter_new (value);
|
|
g_variant_unref (value);
|
|
|
|
if (g_variant_iter_n_children (iter) != tree->n_children)
|
|
{
|
|
g_variant_iter_free (iter);
|
|
return FALSE;
|
|
}
|
|
|
|
for (i = 0; i < tree->n_children; i++)
|
|
if (!tree_instance_check_iter (tree->children[i], iter))
|
|
{
|
|
g_variant_iter_free (iter);
|
|
return FALSE;
|
|
}
|
|
|
|
g_assert (g_variant_iter_next_value (iter) == NULL);
|
|
g_variant_iter_free (iter);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
else
|
|
{
|
|
gboolean equal;
|
|
|
|
equal = tree_instance_check_gvariant (tree, value);
|
|
g_variant_unref (value);
|
|
|
|
return equal;
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_container (void)
|
|
{
|
|
TreeInstance *tree;
|
|
GVariant *value;
|
|
gchar *s1, *s2;
|
|
|
|
tree = tree_instance_new (NULL, 3);
|
|
value = g_variant_ref_sink (tree_instance_get_gvariant (tree));
|
|
|
|
s1 = g_variant_print (value, TRUE);
|
|
g_assert (tree_instance_check_gvariant (tree, value));
|
|
|
|
g_variant_get_data (value);
|
|
|
|
s2 = g_variant_print (value, TRUE);
|
|
g_assert (tree_instance_check_gvariant (tree, value));
|
|
|
|
g_assert_cmpstr (s1, ==, s2);
|
|
|
|
if (g_variant_is_container (value))
|
|
{
|
|
GVariantBuilder builder;
|
|
GVariantIter iter;
|
|
GVariant *built;
|
|
GVariant *val;
|
|
gchar *s3;
|
|
|
|
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARIANT);
|
|
tree_instance_build_gvariant (tree, &builder, TRUE);
|
|
built = g_variant_builder_end (&builder);
|
|
g_variant_ref_sink (built);
|
|
g_variant_get_data (built);
|
|
val = g_variant_get_variant (built);
|
|
|
|
s3 = g_variant_print (val, TRUE);
|
|
g_assert_cmpstr (s1, ==, s3);
|
|
|
|
g_variant_iter_init (&iter, built);
|
|
g_assert (tree_instance_check_iter (tree, &iter));
|
|
g_assert (g_variant_iter_next_value (&iter) == NULL);
|
|
|
|
g_variant_unref (built);
|
|
g_variant_unref (val);
|
|
g_free (s3);
|
|
}
|
|
|
|
tree_instance_free (tree);
|
|
g_variant_unref (value);
|
|
g_free (s2);
|
|
g_free (s1);
|
|
}
|
|
|
|
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";
|
|
GVariant *value;
|
|
|
|
/* ensure that the test data is not valid utf8... */
|
|
g_assert (!g_utf8_validate (invalid, -1, NULL));
|
|
|
|
/* load the data untrusted */
|
|
value = g_variant_new_from_data (G_VARIANT_TYPE_STRING,
|
|
invalid, sizeof invalid,
|
|
FALSE, NULL, NULL);
|
|
|
|
/* ensure that the problem is caught and we get valid UTF-8 */
|
|
g_assert (g_utf8_validate (g_variant_get_string (value, NULL), -1, NULL));
|
|
g_variant_unref (value);
|
|
|
|
|
|
/* now load it trusted */
|
|
value = g_variant_new_from_data (G_VARIANT_TYPE_STRING,
|
|
invalid, sizeof invalid,
|
|
TRUE, NULL, NULL);
|
|
|
|
/* ensure we get the invalid data (ie: make sure that time wasn't
|
|
* wasted on validating data that was marked as trusted)
|
|
*/
|
|
g_assert (g_variant_get_string (value, NULL) == invalid);
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
static void
|
|
test_containers (void)
|
|
{
|
|
gint i;
|
|
|
|
for (i = 0; i < 100; i++)
|
|
{
|
|
test_container ();
|
|
}
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_format_strings (void)
|
|
{
|
|
GVariantType *type;
|
|
const gchar *end;
|
|
|
|
g_assert (g_variant_format_string_scan ("i", NULL, &end) && *end == '\0');
|
|
g_assert (g_variant_format_string_scan ("@i", NULL, &end) && *end == '\0');
|
|
g_assert (g_variant_format_string_scan ("@ii", NULL, &end) && *end == 'i');
|
|
g_assert (g_variant_format_string_scan ("^a&s", NULL, &end) && *end == '\0');
|
|
g_assert (g_variant_format_string_scan ("(^as)", NULL, &end) &&
|
|
*end == '\0');
|
|
g_assert (!g_variant_format_string_scan ("(^s)", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("(^a)", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("(z)", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("az", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("{**}", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("{@**}", NULL, &end));
|
|
g_assert (g_variant_format_string_scan ("{@y*}", NULL, &end) &&
|
|
*end == '\0');
|
|
g_assert (g_variant_format_string_scan ("{yv}", NULL, &end) &&
|
|
*end == '\0');
|
|
g_assert (!g_variant_format_string_scan ("{&?v}", NULL, &end));
|
|
g_assert (g_variant_format_string_scan ("{@?v}", NULL, &end) &&
|
|
*end == '\0');
|
|
g_assert (!g_variant_format_string_scan ("{&@sv}", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("{@&sv}", NULL, &end));
|
|
g_assert (g_variant_format_string_scan ("{&sv}", NULL, &end) &&
|
|
*end == '\0');
|
|
g_assert (!g_variant_format_string_scan ("{vv}", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("{y}", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("{yyy}", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("{ya}", NULL, &end));
|
|
g_assert (g_variant_format_string_scan ("&s", NULL, &end) && *end == '\0');
|
|
g_assert (!g_variant_format_string_scan ("&as", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("@z", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("az", NULL, &end));
|
|
g_assert (!g_variant_format_string_scan ("a&s", NULL, &end));
|
|
|
|
type = g_variant_format_string_scan_type ("mm(@xy^a&s*?@?)", NULL, &end);
|
|
g_assert (type && *end == '\0');
|
|
g_assert (g_variant_type_equal (type, G_VARIANT_TYPE ("mm(xyas*?\?)")));
|
|
g_variant_type_free (type);
|
|
|
|
type = g_variant_format_string_scan_type ("mm(@xy^a&*?@?)", NULL, NULL);
|
|
g_assert (type == NULL);
|
|
}
|
|
|
|
static void
|
|
do_failed_test (const char *test,
|
|
const gchar *pattern)
|
|
{
|
|
g_test_trap_subprocess (test, 1000000, 0);
|
|
g_test_trap_assert_failed ();
|
|
g_test_trap_assert_stderr (pattern);
|
|
}
|
|
|
|
static void
|
|
test_invalid_varargs (void)
|
|
{
|
|
GVariant *value;
|
|
const gchar *end;
|
|
|
|
if (!g_test_undefined ())
|
|
return;
|
|
|
|
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
|
|
"*GVariant format string*");
|
|
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
|
|
"*valid_format_string*");
|
|
value = g_variant_new ("z");
|
|
g_test_assert_expected_messages ();
|
|
g_assert (value == NULL);
|
|
|
|
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
|
|
"*valid GVariant format string as a prefix*");
|
|
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
|
|
"*valid_format_string*");
|
|
value = g_variant_new_va ("z", &end, NULL);
|
|
g_test_assert_expected_messages ();
|
|
g_assert (value == NULL);
|
|
|
|
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'*");
|
|
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
|
|
"*valid_format_string*");
|
|
g_variant_get (value, "q");
|
|
g_test_assert_expected_messages ();
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
static void
|
|
check_and_free (GVariant *value,
|
|
const gchar *str)
|
|
{
|
|
gchar *valstr = g_variant_print (value, FALSE);
|
|
g_assert_cmpstr (str, ==, valstr);
|
|
g_variant_unref (value);
|
|
g_free (valstr);
|
|
}
|
|
|
|
static void
|
|
test_varargs_empty_array (void)
|
|
{
|
|
g_variant_new ("(a{s*})", NULL);
|
|
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
static void
|
|
test_varargs (void)
|
|
{
|
|
{
|
|
GVariantBuilder array;
|
|
|
|
g_variant_builder_init (&array, G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_add_parsed (&array, "{'size', <(%i, %i)> }", 800, 600);
|
|
g_variant_builder_add (&array, "{sv}", "title",
|
|
g_variant_new_string ("Test case"));
|
|
g_variant_builder_add_value (&array,
|
|
g_variant_new_dict_entry (g_variant_new_string ("temperature"),
|
|
g_variant_new_variant (
|
|
g_variant_new_double (37.5))));
|
|
check_and_free (g_variant_new ("(ma{sv}m(a{sv})ma{sv}ii)",
|
|
NULL, FALSE, NULL, &array, 7777, 8888),
|
|
"(nothing, nothing, {'size': <(800, 600)>, "
|
|
"'title': <'Test case'>, "
|
|
"'temperature': <37.5>}, "
|
|
"7777, 8888)");
|
|
|
|
check_and_free (g_variant_new ("(imimimmimmimmi)",
|
|
123,
|
|
FALSE, 321,
|
|
TRUE, 123,
|
|
FALSE, TRUE, 321,
|
|
TRUE, FALSE, 321,
|
|
TRUE, TRUE, 123),
|
|
"(123, nothing, 123, nothing, just nothing, 123)");
|
|
|
|
check_and_free (g_variant_new ("(ybnixd)",
|
|
'a', 1, 22, 33, (guint64) 44, 5.5),
|
|
"(0x61, true, 22, 33, 44, 5.5)");
|
|
|
|
check_and_free (g_variant_new ("(@y?*rv)",
|
|
g_variant_new ("y", 'a'),
|
|
g_variant_new ("y", 'b'),
|
|
g_variant_new ("y", 'c'),
|
|
g_variant_new ("(y)", 'd'),
|
|
g_variant_new ("y", 'e')),
|
|
"(0x61, 0x62, 0x63, (0x64,), <byte 0x65>)");
|
|
}
|
|
|
|
{
|
|
GVariantBuilder array;
|
|
GVariantIter iter;
|
|
GVariant *value;
|
|
gchar *number;
|
|
gboolean just;
|
|
gint i, val;
|
|
|
|
g_variant_builder_init (&array, G_VARIANT_TYPE_ARRAY);
|
|
for (i = 0; i < 100; i++)
|
|
{
|
|
number = g_strdup_printf ("%d", i);
|
|
g_variant_builder_add (&array, "s", number);
|
|
g_free (number);
|
|
}
|
|
|
|
value = g_variant_builder_end (&array);
|
|
g_variant_iter_init (&iter, value);
|
|
|
|
i = 0;
|
|
while (g_variant_iter_loop (&iter, "s", &number))
|
|
{
|
|
gchar *check = g_strdup_printf ("%d", i++);
|
|
g_assert_cmpstr (number, ==, check);
|
|
g_free (check);
|
|
}
|
|
g_assert (number == NULL);
|
|
g_assert (i == 100);
|
|
|
|
g_variant_unref (value);
|
|
|
|
g_variant_builder_init (&array, G_VARIANT_TYPE_ARRAY);
|
|
for (i = 0; i < 100; i++)
|
|
g_variant_builder_add (&array, "mi", i % 2 == 0, i);
|
|
value = g_variant_builder_end (&array);
|
|
|
|
i = 0;
|
|
g_variant_iter_init (&iter, value);
|
|
while (g_variant_iter_loop (&iter, "mi", NULL, &val))
|
|
g_assert (val == i++ || val == 0);
|
|
g_assert (i == 100);
|
|
|
|
i = 0;
|
|
g_variant_iter_init (&iter, value);
|
|
while (g_variant_iter_loop (&iter, "mi", &just, &val))
|
|
{
|
|
gint this = i++;
|
|
|
|
if (this % 2 == 0)
|
|
{
|
|
g_assert (just);
|
|
g_assert (val == this);
|
|
}
|
|
else
|
|
{
|
|
g_assert (!just);
|
|
g_assert (val == 0);
|
|
}
|
|
}
|
|
g_assert (i == 100);
|
|
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
{
|
|
const gchar *strvector[] = {"/hello", "/world", NULL};
|
|
const gchar *test_strs[] = {"/foo", "/bar", "/baz" };
|
|
GVariantBuilder builder;
|
|
GVariantIter *array;
|
|
GVariantIter tuple;
|
|
const gchar **strv;
|
|
gchar **my_strv;
|
|
GVariant *value;
|
|
gchar *str;
|
|
gint i;
|
|
|
|
g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
|
|
g_variant_builder_add (&builder, "s", "/foo");
|
|
g_variant_builder_add (&builder, "s", "/bar");
|
|
g_variant_builder_add (&builder, "s", "/baz");
|
|
value = g_variant_new("(as^as^a&s)", &builder, strvector, strvector);
|
|
g_variant_iter_init (&tuple, value);
|
|
g_variant_iter_next (&tuple, "as", &array);
|
|
|
|
i = 0;
|
|
while (g_variant_iter_loop (array, "s", &str))
|
|
g_assert_cmpstr (str, ==, test_strs[i++]);
|
|
g_assert (i == 3);
|
|
|
|
g_variant_iter_free (array);
|
|
|
|
/* start over */
|
|
g_variant_iter_init (&tuple, value);
|
|
g_variant_iter_next (&tuple, "as", &array);
|
|
|
|
i = 0;
|
|
while (g_variant_iter_loop (array, "&s", &str))
|
|
g_assert_cmpstr (str, ==, test_strs[i++]);
|
|
g_assert (i == 3);
|
|
|
|
g_variant_iter_free (array);
|
|
|
|
g_variant_iter_next (&tuple, "^a&s", &strv);
|
|
g_variant_iter_next (&tuple, "^as", &my_strv);
|
|
|
|
g_assert_cmpstr (strv[0], ==, "/hello");
|
|
g_assert_cmpstr (strv[1], ==, "/world");
|
|
g_assert (strv[2] == NULL);
|
|
g_assert_cmpstr (my_strv[0], ==, "/hello");
|
|
g_assert_cmpstr (my_strv[1], ==, "/world");
|
|
g_assert (my_strv[2] == NULL);
|
|
|
|
g_variant_unref (value);
|
|
g_strfreev (my_strv);
|
|
g_free (strv);
|
|
}
|
|
|
|
{
|
|
const gchar *strvector[] = {"/hello", "/world", NULL};
|
|
const gchar *test_strs[] = {"/foo", "/bar", "/baz" };
|
|
GVariantBuilder builder;
|
|
GVariantIter *array;
|
|
GVariantIter tuple;
|
|
const gchar **strv;
|
|
gchar **my_strv;
|
|
GVariant *value;
|
|
gchar *str;
|
|
gint i;
|
|
|
|
g_variant_builder_init (&builder, G_VARIANT_TYPE_OBJECT_PATH_ARRAY);
|
|
g_variant_builder_add (&builder, "o", "/foo");
|
|
g_variant_builder_add (&builder, "o", "/bar");
|
|
g_variant_builder_add (&builder, "o", "/baz");
|
|
value = g_variant_new("(ao^ao^a&o)", &builder, strvector, strvector);
|
|
g_variant_iter_init (&tuple, value);
|
|
g_variant_iter_next (&tuple, "ao", &array);
|
|
|
|
i = 0;
|
|
while (g_variant_iter_loop (array, "o", &str))
|
|
g_assert_cmpstr (str, ==, test_strs[i++]);
|
|
g_assert (i == 3);
|
|
|
|
g_variant_iter_free (array);
|
|
|
|
/* start over */
|
|
g_variant_iter_init (&tuple, value);
|
|
g_variant_iter_next (&tuple, "ao", &array);
|
|
|
|
i = 0;
|
|
while (g_variant_iter_loop (array, "&o", &str))
|
|
g_assert_cmpstr (str, ==, test_strs[i++]);
|
|
g_assert (i == 3);
|
|
|
|
g_variant_iter_free (array);
|
|
|
|
g_variant_iter_next (&tuple, "^a&o", &strv);
|
|
g_variant_iter_next (&tuple, "^ao", &my_strv);
|
|
|
|
g_assert_cmpstr (strv[0], ==, "/hello");
|
|
g_assert_cmpstr (strv[1], ==, "/world");
|
|
g_assert (strv[2] == NULL);
|
|
g_assert_cmpstr (my_strv[0], ==, "/hello");
|
|
g_assert_cmpstr (my_strv[1], ==, "/world");
|
|
g_assert (my_strv[2] == NULL);
|
|
|
|
g_variant_unref (value);
|
|
g_strfreev (my_strv);
|
|
g_free (strv);
|
|
}
|
|
|
|
{
|
|
const gchar *strvector[] = { "i", "ii", "iii", "iv", "v", "vi", NULL };
|
|
GVariantBuilder builder;
|
|
GVariantIter iter;
|
|
GVariantIter *i2;
|
|
GVariantIter *i3;
|
|
GVariant *value;
|
|
GVariant *sub;
|
|
gchar **strv;
|
|
gint i;
|
|
|
|
g_variant_builder_init (&builder, G_VARIANT_TYPE ("aas"));
|
|
g_variant_builder_open (&builder, G_VARIANT_TYPE ("as"));
|
|
for (i = 0; i < 6; i++)
|
|
if (i & 1)
|
|
g_variant_builder_add (&builder, "s", strvector[i]);
|
|
else
|
|
g_variant_builder_add (&builder, "&s", strvector[i]);
|
|
g_variant_builder_close (&builder);
|
|
g_variant_builder_add (&builder, "^as", strvector);
|
|
g_variant_builder_add (&builder, "^as", strvector);
|
|
value = g_variant_new ("aas", &builder);
|
|
|
|
g_variant_iter_init (&iter, value);
|
|
while (g_variant_iter_loop (&iter, "^as", &strv))
|
|
for (i = 0; i < 6; i++)
|
|
g_assert_cmpstr (strv[i], ==, strvector[i]);
|
|
|
|
g_variant_iter_init (&iter, value);
|
|
while (g_variant_iter_loop (&iter, "^a&s", &strv))
|
|
for (i = 0; i < 6; i++)
|
|
g_assert_cmpstr (strv[i], ==, strvector[i]);
|
|
|
|
g_variant_iter_init (&iter, value);
|
|
while (g_variant_iter_loop (&iter, "as", &i2))
|
|
{
|
|
gchar *str;
|
|
|
|
i = 0;
|
|
while (g_variant_iter_loop (i2, "s", &str))
|
|
g_assert_cmpstr (str, ==, strvector[i++]);
|
|
g_assert (i == 6);
|
|
}
|
|
|
|
g_variant_iter_init (&iter, value);
|
|
i3 = g_variant_iter_copy (&iter);
|
|
while (g_variant_iter_loop (&iter, "@as", &sub))
|
|
{
|
|
gchar *str = g_variant_print (sub, TRUE);
|
|
g_assert_cmpstr (str, ==,
|
|
"['i', 'ii', 'iii', 'iv', 'v', 'vi']");
|
|
g_free (str);
|
|
}
|
|
|
|
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
|
|
"*NULL has already been returned*");
|
|
g_variant_iter_next_value (&iter);
|
|
g_test_assert_expected_messages ();
|
|
|
|
while (g_variant_iter_loop (i3, "*", &sub))
|
|
{
|
|
gchar *str = g_variant_print (sub, TRUE);
|
|
g_assert_cmpstr (str, ==,
|
|
"['i', 'ii', 'iii', 'iv', 'v', 'vi']");
|
|
g_free (str);
|
|
}
|
|
|
|
g_variant_iter_free (i3);
|
|
|
|
for (i = 0; i < g_variant_n_children (value); i++)
|
|
{
|
|
gint j;
|
|
|
|
g_variant_get_child (value, i, "*", &sub);
|
|
|
|
for (j = 0; j < g_variant_n_children (sub); j++)
|
|
{
|
|
const gchar *str = NULL;
|
|
GVariant *cval;
|
|
|
|
g_variant_get_child (sub, j, "&s", &str);
|
|
g_assert_cmpstr (str, ==, strvector[j]);
|
|
|
|
cval = g_variant_get_child_value (sub, j);
|
|
g_variant_get (cval, "&s", &str);
|
|
g_assert_cmpstr (str, ==, strvector[j]);
|
|
g_variant_unref (cval);
|
|
}
|
|
|
|
g_variant_unref (sub);
|
|
}
|
|
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
{
|
|
gboolean justs[10];
|
|
GVariant *value;
|
|
|
|
GVariant *vval;
|
|
guchar byteval;
|
|
gboolean bval;
|
|
gint16 i16val;
|
|
guint16 u16val;
|
|
gint32 i32val;
|
|
guint32 u32val;
|
|
gint64 i64val;
|
|
guint64 u64val;
|
|
gdouble dval;
|
|
gint32 hval;
|
|
|
|
/* test all 'nothing' */
|
|
value = g_variant_new ("(mymbmnmqmimumxmtmhmdmv)",
|
|
FALSE, 'a',
|
|
FALSE, TRUE,
|
|
FALSE, (gint16) 123,
|
|
FALSE, (guint16) 123,
|
|
FALSE, (gint32) 123,
|
|
FALSE, (guint32) 123,
|
|
FALSE, (gint64) 123,
|
|
FALSE, (guint64) 123,
|
|
FALSE, (gint32) -1,
|
|
FALSE, (gdouble) 37.5,
|
|
NULL);
|
|
|
|
/* both NULL */
|
|
g_variant_get (value, "(mymbmnmqmimumxmtmhmdmv)",
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL);
|
|
|
|
/* NULL values */
|
|
memset (justs, 1, sizeof justs);
|
|
g_variant_get (value, "(mymbmnmqmimumxmtmhmdmv)",
|
|
&justs[0], NULL,
|
|
&justs[1], NULL,
|
|
&justs[2], NULL,
|
|
&justs[3], NULL,
|
|
&justs[4], NULL,
|
|
&justs[5], NULL,
|
|
&justs[6], NULL,
|
|
&justs[7], NULL,
|
|
&justs[8], NULL,
|
|
&justs[9], NULL,
|
|
NULL);
|
|
g_assert (!(justs[0] || justs[1] || justs[2] || justs[3] || justs[4] ||
|
|
justs[5] || justs[6] || justs[7] || justs[8] || justs[9]));
|
|
|
|
/* both non-NULL */
|
|
memset (justs, 1, sizeof justs);
|
|
byteval = i16val = u16val = i32val = u32val = i64val = u64val = hval = 88;
|
|
vval = (void *) 1;
|
|
bval = TRUE;
|
|
dval = 88.88;
|
|
g_variant_get (value, "(mymbmnmqmimumxmtmhmdmv)",
|
|
&justs[0], &byteval,
|
|
&justs[1], &bval,
|
|
&justs[2], &i16val,
|
|
&justs[3], &u16val,
|
|
&justs[4], &i32val,
|
|
&justs[5], &u32val,
|
|
&justs[6], &i64val,
|
|
&justs[7], &u64val,
|
|
&justs[8], &hval,
|
|
&justs[9], &dval,
|
|
&vval);
|
|
g_assert (!(justs[0] || justs[1] || justs[2] || justs[3] || justs[4] ||
|
|
justs[5] || justs[6] || justs[7] || justs[8] || justs[9]));
|
|
g_assert (byteval == '\0' && bval == FALSE);
|
|
g_assert (i16val == 0 && u16val == 0 && i32val == 0 &&
|
|
u32val == 0 && i64val == 0 && u64val == 0 &&
|
|
hval == 0 && dval == 0.0);
|
|
g_assert (vval == NULL);
|
|
|
|
/* NULL justs */
|
|
byteval = i16val = u16val = i32val = u32val = i64val = u64val = hval = 88;
|
|
vval = (void *) 1;
|
|
bval = TRUE;
|
|
dval = 88.88;
|
|
g_variant_get (value, "(mymbmnmqmimumxmtmhmdmv)",
|
|
NULL, &byteval,
|
|
NULL, &bval,
|
|
NULL, &i16val,
|
|
NULL, &u16val,
|
|
NULL, &i32val,
|
|
NULL, &u32val,
|
|
NULL, &i64val,
|
|
NULL, &u64val,
|
|
NULL, &hval,
|
|
NULL, &dval,
|
|
&vval);
|
|
g_assert (byteval == '\0' && bval == FALSE);
|
|
g_assert (i16val == 0 && u16val == 0 && i32val == 0 &&
|
|
u32val == 0 && i64val == 0 && u64val == 0 &&
|
|
hval == 0 && dval == 0.0);
|
|
g_assert (vval == NULL);
|
|
|
|
g_variant_unref (value);
|
|
|
|
|
|
/* test all 'just' */
|
|
value = g_variant_new ("(mymbmnmqmimumxmtmhmdmv)",
|
|
TRUE, 'a',
|
|
TRUE, TRUE,
|
|
TRUE, (gint16) 123,
|
|
TRUE, (guint16) 123,
|
|
TRUE, (gint32) 123,
|
|
TRUE, (guint32) 123,
|
|
TRUE, (gint64) 123,
|
|
TRUE, (guint64) 123,
|
|
TRUE, (gint32) -1,
|
|
TRUE, (gdouble) 37.5,
|
|
g_variant_new ("()"));
|
|
|
|
/* both NULL */
|
|
g_variant_get (value, "(mymbmnmqmimumxmtmhmdmv)",
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL);
|
|
|
|
/* NULL values */
|
|
memset (justs, 0, sizeof justs);
|
|
g_variant_get (value, "(mymbmnmqmimumxmtmhmdmv)",
|
|
&justs[0], NULL,
|
|
&justs[1], NULL,
|
|
&justs[2], NULL,
|
|
&justs[3], NULL,
|
|
&justs[4], NULL,
|
|
&justs[5], NULL,
|
|
&justs[6], NULL,
|
|
&justs[7], NULL,
|
|
&justs[8], NULL,
|
|
&justs[9], NULL,
|
|
NULL);
|
|
g_assert (justs[0] && justs[1] && justs[2] && justs[3] && justs[4] &&
|
|
justs[5] && justs[6] && justs[7] && justs[8] && justs[9]);
|
|
|
|
/* both non-NULL */
|
|
memset (justs, 0, sizeof justs);
|
|
byteval = i16val = u16val = i32val = u32val = i64val = u64val = hval = 88;
|
|
vval = (void *) 1;
|
|
bval = FALSE;
|
|
dval = 88.88;
|
|
g_variant_get (value, "(mymbmnmqmimumxmtmhmdmv)",
|
|
&justs[0], &byteval,
|
|
&justs[1], &bval,
|
|
&justs[2], &i16val,
|
|
&justs[3], &u16val,
|
|
&justs[4], &i32val,
|
|
&justs[5], &u32val,
|
|
&justs[6], &i64val,
|
|
&justs[7], &u64val,
|
|
&justs[8], &hval,
|
|
&justs[9], &dval,
|
|
&vval);
|
|
g_assert (justs[0] && justs[1] && justs[2] && justs[3] && justs[4] &&
|
|
justs[5] && justs[6] && justs[7] && justs[8] && justs[9]);
|
|
g_assert (byteval == 'a' && bval == TRUE);
|
|
g_assert (i16val == 123 && u16val == 123 && i32val == 123 &&
|
|
u32val == 123 && i64val == 123 && u64val == 123 &&
|
|
hval == -1 && dval == 37.5);
|
|
g_assert (g_variant_is_of_type (vval, G_VARIANT_TYPE_UNIT));
|
|
g_variant_unref (vval);
|
|
|
|
/* NULL justs */
|
|
byteval = i16val = u16val = i32val = u32val = i64val = u64val = hval = 88;
|
|
vval = (void *) 1;
|
|
bval = TRUE;
|
|
dval = 88.88;
|
|
g_variant_get (value, "(mymbmnmqmimumxmtmhmdmv)",
|
|
NULL, &byteval,
|
|
NULL, &bval,
|
|
NULL, &i16val,
|
|
NULL, &u16val,
|
|
NULL, &i32val,
|
|
NULL, &u32val,
|
|
NULL, &i64val,
|
|
NULL, &u64val,
|
|
NULL, &hval,
|
|
NULL, &dval,
|
|
&vval);
|
|
g_assert (byteval == 'a' && bval == TRUE);
|
|
g_assert (i16val == 123 && u16val == 123 && i32val == 123 &&
|
|
u32val == 123 && i64val == 123 && u64val == 123 &&
|
|
hval == -1 && dval == 37.5);
|
|
g_assert (g_variant_is_of_type (vval, G_VARIANT_TYPE_UNIT));
|
|
g_variant_unref (vval);
|
|
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
{
|
|
GVariant *value;
|
|
gchar *str;
|
|
|
|
value = g_variant_new ("(masas)", NULL, NULL);
|
|
g_variant_ref_sink (value);
|
|
|
|
str = g_variant_print (value, TRUE);
|
|
g_assert_cmpstr (str, ==, "(@mas nothing, @as [])");
|
|
g_variant_unref (value);
|
|
g_free (str);
|
|
|
|
do_failed_test ("/gvariant/varargs/subprocess/empty-array",
|
|
"*which type of empty array*");
|
|
}
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
hash_get (GVariant *value,
|
|
const gchar *format,
|
|
...)
|
|
{
|
|
const gchar *endptr = NULL;
|
|
gboolean hash;
|
|
va_list ap;
|
|
|
|
hash = g_str_has_suffix (format, "#");
|
|
|
|
va_start (ap, format);
|
|
g_variant_get_va (value, format, hash ? &endptr : NULL, &ap);
|
|
va_end (ap);
|
|
|
|
if (hash)
|
|
g_assert (*endptr == '#');
|
|
}
|
|
|
|
static GVariant *
|
|
hash_new (const gchar *format,
|
|
...)
|
|
{
|
|
const gchar *endptr = NULL;
|
|
GVariant *value;
|
|
gboolean hash;
|
|
va_list ap;
|
|
|
|
hash = g_str_has_suffix (format, "#");
|
|
|
|
va_start (ap, format);
|
|
value = g_variant_new_va (format, hash ? &endptr : NULL, &ap);
|
|
va_end (ap);
|
|
|
|
if (hash)
|
|
g_assert (*endptr == '#');
|
|
|
|
return value;
|
|
}
|
|
|
|
static void
|
|
test_valist (void)
|
|
{
|
|
GVariant *value;
|
|
gint32 x;
|
|
|
|
x = 0;
|
|
value = hash_new ("i", 234);
|
|
hash_get (value, "i", &x);
|
|
g_assert (x == 234);
|
|
g_variant_unref (value);
|
|
|
|
x = 0;
|
|
value = hash_new ("i#", 234);
|
|
hash_get (value, "i#", &x);
|
|
g_assert (x == 234);
|
|
g_variant_unref (value);
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_builder_memory (void)
|
|
{
|
|
GVariantBuilder *hb;
|
|
GVariantBuilder sb;
|
|
|
|
hb = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_open (hb, G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_open (hb, G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_open (hb, G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_add (hb, "s", "some value");
|
|
g_variant_builder_ref (hb);
|
|
g_variant_builder_unref (hb);
|
|
g_variant_builder_unref (hb);
|
|
|
|
hb = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_unref (hb);
|
|
|
|
hb = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_clear (hb);
|
|
g_variant_builder_unref (hb);
|
|
|
|
g_variant_builder_init (&sb, G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_open (&sb, G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_open (&sb, G_VARIANT_TYPE_ARRAY);
|
|
g_variant_builder_add (&sb, "s", "some value");
|
|
g_variant_builder_clear (&sb);
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_hashing (void)
|
|
{
|
|
GVariant *items[4096];
|
|
GHashTable *table;
|
|
gint i;
|
|
|
|
table = g_hash_table_new_full (g_variant_hash, g_variant_equal,
|
|
(GDestroyNotify ) g_variant_unref,
|
|
NULL);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (items); i++)
|
|
{
|
|
TreeInstance *tree;
|
|
gint j;
|
|
|
|
again:
|
|
tree = tree_instance_new (NULL, 0);
|
|
items[i] = tree_instance_get_gvariant (tree);
|
|
tree_instance_free (tree);
|
|
|
|
for (j = 0; j < i; j++)
|
|
if (g_variant_equal (items[i], items[j]))
|
|
{
|
|
g_variant_unref (items[i]);
|
|
goto again;
|
|
}
|
|
|
|
g_hash_table_insert (table,
|
|
g_variant_ref_sink (items[i]),
|
|
GINT_TO_POINTER (i));
|
|
}
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (items); i++)
|
|
{
|
|
gpointer result;
|
|
|
|
result = g_hash_table_lookup (table, items[i]);
|
|
g_assert_cmpint (GPOINTER_TO_INT (result), ==, i);
|
|
}
|
|
|
|
g_hash_table_unref (table);
|
|
|
|
g_variant_type_info_assert_no_infos ();
|
|
}
|
|
|
|
static void
|
|
test_gv_byteswap (void)
|
|
{
|
|
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
|
|
# define native16(x) x, 0
|
|
# define swapped16(x) 0, x
|
|
#else
|
|
# define native16(x) 0, x
|
|
# define swapped16(x) x, 0
|
|
#endif
|
|
/* all kinds of of crazy randomised testing already performed on the
|
|
* byteswapper in the /gvariant/serialiser/byteswap test and all kinds
|
|
* of crazy randomised testing performed against the serialiser
|
|
* normalisation functions in the /gvariant/serialiser/fuzz/ tests.
|
|
*
|
|
* just test a few simple cases here to make sure they each work
|
|
*/
|
|
guchar validbytes[] = { 'a', '\0', swapped16(66), 2,
|
|
0,
|
|
'b', '\0', swapped16(77), 2,
|
|
5, 11 };
|
|
guchar corruptbytes[] = { 'a', '\0', swapped16(66), 2,
|
|
0,
|
|
'b', '\0', swapped16(77), 2,
|
|
6, 11 };
|
|
guint valid_data[4], corrupt_data[4];
|
|
GVariant *value, *swapped;
|
|
gchar *string, *string2;
|
|
|
|
memcpy (valid_data, validbytes, sizeof validbytes);
|
|
memcpy (corrupt_data, corruptbytes, sizeof corruptbytes);
|
|
|
|
/* trusted */
|
|
value = g_variant_new_from_data (G_VARIANT_TYPE ("a(sn)"),
|
|
valid_data, sizeof validbytes, TRUE,
|
|
NULL, NULL);
|
|
swapped = g_variant_byteswap (value);
|
|
g_variant_unref (value);
|
|
g_assert (g_variant_get_size (swapped) == 13);
|
|
string = g_variant_print (swapped, FALSE);
|
|
g_variant_unref (swapped);
|
|
g_assert_cmpstr (string, ==, "[('a', 66), ('b', 77)]");
|
|
g_free (string);
|
|
|
|
/* untrusted but valid */
|
|
value = g_variant_new_from_data (G_VARIANT_TYPE ("a(sn)"),
|
|
valid_data, sizeof validbytes, FALSE,
|
|
NULL, NULL);
|
|
swapped = g_variant_byteswap (value);
|
|
g_variant_unref (value);
|
|
g_assert (g_variant_get_size (swapped) == 13);
|
|
string = g_variant_print (swapped, FALSE);
|
|
g_variant_unref (swapped);
|
|
g_assert_cmpstr (string, ==, "[('a', 66), ('b', 77)]");
|
|
g_free (string);
|
|
|
|
/* untrusted, invalid */
|
|
value = g_variant_new_from_data (G_VARIANT_TYPE ("a(sn)"),
|
|
corrupt_data, sizeof corruptbytes, FALSE,
|
|
NULL, NULL);
|
|
string = g_variant_print (value, FALSE);
|
|
swapped = g_variant_byteswap (value);
|
|
g_variant_unref (value);
|
|
g_assert (g_variant_get_size (swapped) == 13);
|
|
value = g_variant_byteswap (swapped);
|
|
g_variant_unref (swapped);
|
|
string2 = g_variant_print (value, FALSE);
|
|
g_assert (g_variant_get_size (value) == 13);
|
|
g_variant_unref (value);
|
|
g_assert_cmpstr (string, ==, string2);
|
|
g_free (string2);
|
|
g_free (string);
|
|
}
|
|
|
|
static void
|
|
test_parser (void)
|
|
{
|
|
TreeInstance *tree;
|
|
GVariant *parsed;
|
|
GVariant *value;
|
|
gchar *pt, *p;
|
|
gchar *res;
|
|
|
|
tree = tree_instance_new (NULL, 3);
|
|
value = tree_instance_get_gvariant (tree);
|
|
tree_instance_free (tree);
|
|
|
|
pt = g_variant_print (value, TRUE);
|
|
p = g_variant_print (value, FALSE);
|
|
|
|
parsed = g_variant_parse (NULL, pt, NULL, NULL, NULL);
|
|
res = g_variant_print (parsed, FALSE);
|
|
g_assert_cmpstr (p, ==, res);
|
|
g_variant_unref (parsed);
|
|
g_free (res);
|
|
|
|
parsed = g_variant_parse (g_variant_get_type (value), p,
|
|
NULL, NULL, NULL);
|
|
res = g_variant_print (parsed, TRUE);
|
|
g_assert_cmpstr (pt, ==, res);
|
|
g_variant_unref (parsed);
|
|
g_free (res);
|
|
|
|
g_variant_unref (value);
|
|
g_free (pt);
|
|
g_free (p);
|
|
}
|
|
|
|
static void
|
|
test_parses (void)
|
|
{
|
|
gint i;
|
|
|
|
for (i = 0; i < 100; i++)
|
|
{
|
|
test_parser ();
|
|
}
|
|
|
|
/* mini test */
|
|
{
|
|
GError *error = NULL;
|
|
gchar str[128];
|
|
GVariant *val;
|
|
gchar *p, *p2;
|
|
|
|
for (i = 0; i < 127; i++)
|
|
str[i] = i + 1;
|
|
str[i] = 0;
|
|
|
|
val = g_variant_new_string (str);
|
|
p = g_variant_print (val, FALSE);
|
|
g_variant_unref (val);
|
|
|
|
val = g_variant_parse (NULL, p, NULL, NULL, &error);
|
|
p2 = g_variant_print (val, FALSE);
|
|
|
|
g_assert_cmpstr (str, ==, g_variant_get_string (val, NULL));
|
|
g_assert_cmpstr (p, ==, p2);
|
|
|
|
g_variant_unref (val);
|
|
g_free (p2);
|
|
g_free (p);
|
|
}
|
|
|
|
/* another mini test */
|
|
{
|
|
const gchar *end;
|
|
GVariant *value;
|
|
|
|
value = g_variant_parse (G_VARIANT_TYPE_INT32, "1 2 3", NULL, &end, NULL);
|
|
g_assert_cmpint (g_variant_get_int32 (value), ==, 1);
|
|
/* make sure endptr returning works */
|
|
g_assert_cmpstr (end, ==, " 2 3");
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
/* unicode mini test */
|
|
{
|
|
/* ał𝄞 */
|
|
const gchar orig[] = "a\xc5\x82\xf0\x9d\x84\x9e \t\n";
|
|
GVariant *value;
|
|
gchar *printed;
|
|
|
|
value = g_variant_new_string (orig);
|
|
printed = g_variant_print (value, FALSE);
|
|
g_variant_unref (value);
|
|
|
|
g_assert_cmpstr (printed, ==, "'a\xc5\x82\xf0\x9d\x84\x9e \\t\\n'");
|
|
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);
|
|
}
|
|
|
|
/* 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);
|
|
/* 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 ();
|
|
}
|
|
|
|
static void
|
|
test_parse_failures (void)
|
|
{
|
|
const gchar *test[] = {
|
|
"[1, 2,", "6:", "expected value",
|
|
"", "0:", "expected value",
|
|
"(1, 2,", "6:", "expected value",
|
|
"<1", "2:", "expected '>'",
|
|
"[]", "0-2:", "unable to infer",
|
|
"(,", "1:", "expected value",
|
|
"[4,'']", "1-2,3-5:", "common type",
|
|
"[4, '', 5]", "1-2,4-6:", "common type",
|
|
"['', 4, 5]", "1-3,5-6:", "common type",
|
|
"[4, 5, '']", "1-2,7-9:", "common type",
|
|
"[[4], [], ['']]", "1-4,10-14:", "common type",
|
|
"[[], [4], ['']]", "5-8,10-14:", "common type",
|
|
"just", "4:", "expected value",
|
|
"nothing", "0-7:", "unable to infer",
|
|
"just [4, '']", "6-7,9-11:", "common type",
|
|
"[[4,'']]", "2-3,4-6:", "common type",
|
|
"([4,''],)", "2-3,4-6:", "common type",
|
|
"(4)", "2:", "','",
|
|
"{}", "0-2:", "unable to infer",
|
|
"{[1,2],[3,4]}", "0-13:", "basic types",
|
|
"{[1,2]:[3,4]}", "0-13:", "basic types",
|
|
"justt", "0-5:", "unknown keyword",
|
|
"nothng", "0-6:", "unknown keyword",
|
|
"uint33", "0-6:", "unknown keyword",
|
|
"@mi just ''", "9-11:", "can not parse as",
|
|
"@ai ['']", "5-7:", "can not parse as",
|
|
"@(i) ('',)", "6-8:", "can not parse as",
|
|
"[[], 5]", "1-3,5-6:", "common type",
|
|
"[[5], 5]", "1-4,6-7:", "common type",
|
|
"5 5", "2:", "expected end of input",
|
|
"[5, [5, '']]", "5-6,8-10:", "common type",
|
|
"@i just 5", "3-9:", "can not parse as",
|
|
"@i nothing", "3-10:", "can not parse as",
|
|
"@i []", "3-5:", "can not parse as",
|
|
"@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 ']'",
|
|
"<@i []>", "4-6:", "can not parse as",
|
|
"<[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",
|
|
"{@i '', 5}", "4-6:", "can not parse as",
|
|
"{5, @i ''}", "7-9:", "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 ':'",
|
|
"@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 ']'",
|
|
"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",
|
|
"byte -1", "5-7:", "out of range for type",
|
|
"int16 32768", "6-11:", "out of range for type",
|
|
"int16 -32769", "6-12:", "out of range for type",
|
|
"uint16 -1", "7-9:", "out of range for type",
|
|
"uint16 65536", "7-12:", "out of range for type",
|
|
"2147483648", "0-10:", "out of range for type",
|
|
"-2147483649", "0-11:", "out of range for type",
|
|
"uint32 -1", "7-9:", "out of range for type",
|
|
"uint32 4294967296", "7-17:", "out of range for type",
|
|
"@x 9223372036854775808", "3-22:", "out of range for type",
|
|
"@x -9223372036854775809", "3-23:", "out of range for type",
|
|
"@t -1", "3-5:", "out of range for type",
|
|
"@t 18446744073709551616", "3-23:", "too big for any type",
|
|
"handle 2147483648", "7-17:", "out of range for type",
|
|
"handle -2147483649", "7-18:", "out of range for type",
|
|
"1.798e308", "0-9:", "too big for any type",
|
|
"37.5a488", "4-5:", "invalid character",
|
|
"0x7ffgf", "5-6:", "invalid character",
|
|
"07758", "4-5:", "invalid character",
|
|
"123a5", "3-4:", "invalid character",
|
|
"@ai 123", "4-7:", "can not parse as",
|
|
"'\"\\'", "0-4:", "unterminated string",
|
|
"'\"\\'\\", "0-5:", "unterminated string",
|
|
"boolean 4", "8-9:", "can not parse as",
|
|
"int32 true", "6-10:", "can not parse as",
|
|
"[double 5, int32 5]", "1-9,11-18:", "common type",
|
|
"string 4", "7-8:", "can not parse as"
|
|
};
|
|
gint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (test); i += 3)
|
|
{
|
|
GError *error = NULL;
|
|
GVariant *value;
|
|
|
|
value = g_variant_parse (NULL, test[i], NULL, NULL, &error);
|
|
g_assert (value == NULL);
|
|
|
|
if (!strstr (error->message, test[i+2]))
|
|
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,
|
|
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;
|
|
check_and_free (g_variant_new_parsed ("[('one', 1), (%s, 2),"
|
|
" ('three', %i)]", "two", 3),
|
|
"[('one', 1), ('two', 2), ('three', 3)]");
|
|
value = g_variant_new_parsed ("[('one', 1), (%s, 2),"
|
|
" ('three', %u)]", "two", 3);
|
|
g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE ("a(su)")));
|
|
check_and_free (value, "[('one', 1), ('two', 2), ('three', 3)]");
|
|
check_and_free (g_variant_new_parsed ("{%s:%i}", "one", 1), "{'one': 1}");
|
|
|
|
if (g_test_undefined ())
|
|
{
|
|
do_failed_test ("/gvariant/parse/subprocess/bad-format-char",
|
|
"*GVariant format string*");
|
|
|
|
do_failed_test ("/gvariant/parse/subprocess/bad-format-string",
|
|
"*can not parse as*");
|
|
|
|
do_failed_test ("/gvariant/parse/subprocess/bad-args",
|
|
"*expected GVariant of type 'i'*");
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_floating (void)
|
|
{
|
|
GVariant *value;
|
|
|
|
value = g_variant_new_int32 (42);
|
|
g_assert (g_variant_is_floating (value));
|
|
g_variant_ref_sink (value);
|
|
g_assert (!g_variant_is_floating (value));
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
static void
|
|
test_bytestring (void)
|
|
{
|
|
const gchar *test_string = "foo,bar,baz,quux,\xffoooo";
|
|
GVariant *value;
|
|
gchar **strv;
|
|
gchar *str;
|
|
const gchar *const_str;
|
|
GVariant *untrusted_empty;
|
|
|
|
strv = g_strsplit (test_string, ",", 0);
|
|
|
|
value = g_variant_new_bytestring_array ((const gchar **) strv, -1);
|
|
g_assert (g_variant_is_floating (value));
|
|
g_strfreev (strv);
|
|
|
|
str = g_variant_print (value, FALSE);
|
|
g_variant_unref (value);
|
|
|
|
value = g_variant_parse (NULL, str, NULL, NULL, NULL);
|
|
g_free (str);
|
|
|
|
strv = g_variant_dup_bytestring_array (value, NULL);
|
|
g_variant_unref (value);
|
|
|
|
str = g_strjoinv (",", strv);
|
|
g_strfreev (strv);
|
|
|
|
g_assert_cmpstr (str, ==, test_string);
|
|
g_free (str);
|
|
|
|
strv = g_strsplit (test_string, ",", 0);
|
|
value = g_variant_new ("(^aay^a&ay^ay^&ay)",
|
|
strv, strv, strv[0], strv[0]);
|
|
g_strfreev (strv);
|
|
|
|
g_variant_get_child (value, 0, "^a&ay", &strv);
|
|
str = g_strjoinv (",", strv);
|
|
g_free (strv);
|
|
g_assert_cmpstr (str, ==, test_string);
|
|
g_free (str);
|
|
|
|
g_variant_get_child (value, 0, "^aay", &strv);
|
|
str = g_strjoinv (",", strv);
|
|
g_strfreev (strv);
|
|
g_assert_cmpstr (str, ==, test_string);
|
|
g_free (str);
|
|
|
|
g_variant_get_child (value, 1, "^a&ay", &strv);
|
|
str = g_strjoinv (",", strv);
|
|
g_free (strv);
|
|
g_assert_cmpstr (str, ==, test_string);
|
|
g_free (str);
|
|
|
|
g_variant_get_child (value, 1, "^aay", &strv);
|
|
str = g_strjoinv (",", strv);
|
|
g_strfreev (strv);
|
|
g_assert_cmpstr (str, ==, test_string);
|
|
g_free (str);
|
|
|
|
g_variant_get_child (value, 2, "^ay", &str);
|
|
g_assert_cmpstr (str, ==, "foo");
|
|
g_free (str);
|
|
|
|
g_variant_get_child (value, 2, "^&ay", &str);
|
|
g_assert_cmpstr (str, ==, "foo");
|
|
|
|
g_variant_get_child (value, 3, "^ay", &str);
|
|
g_assert_cmpstr (str, ==, "foo");
|
|
g_free (str);
|
|
|
|
g_variant_get_child (value, 3, "^&ay", &str);
|
|
g_assert_cmpstr (str, ==, "foo");
|
|
g_variant_unref (value);
|
|
|
|
untrusted_empty = g_variant_new_from_data (G_VARIANT_TYPE ("ay"), NULL, 0, FALSE, NULL, NULL);
|
|
value = g_variant_get_normal_form (untrusted_empty);
|
|
const_str = g_variant_get_bytestring (value);
|
|
(void) const_str;
|
|
g_variant_unref (value);
|
|
g_variant_unref (untrusted_empty);
|
|
}
|
|
|
|
static void
|
|
test_lookup_value (void)
|
|
{
|
|
struct {
|
|
const gchar *dict, *key, *value;
|
|
} cases[] = {
|
|
{ "@a{ss} {'x': 'y'}", "x", "'y'" },
|
|
{ "@a{ss} {'x': 'y'}", "y" },
|
|
{ "@a{os} {'/x': 'y'}", "/x", "'y'" },
|
|
{ "@a{os} {'/x': 'y'}", "/y" },
|
|
{ "@a{sv} {'x': <'y'>}", "x", "'y'" },
|
|
{ "@a{sv} {'x': <5>}", "x", "5" },
|
|
{ "@a{sv} {'x': <'y'>}", "y" }
|
|
};
|
|
gint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (cases); i++)
|
|
{
|
|
GVariant *dictionary;
|
|
GVariant *value;
|
|
gchar *p;
|
|
|
|
dictionary = g_variant_parse (NULL, cases[i].dict, NULL, NULL, NULL);
|
|
value = g_variant_lookup_value (dictionary, cases[i].key, NULL);
|
|
g_variant_unref (dictionary);
|
|
|
|
if (value == NULL && cases[i].value == NULL)
|
|
continue;
|
|
|
|
g_assert (value && cases[i].value);
|
|
p = g_variant_print (value, FALSE);
|
|
g_assert_cmpstr (cases[i].value, ==, p);
|
|
g_variant_unref (value);
|
|
g_free (p);
|
|
}
|
|
}
|
|
|
|
static void
|
|
test_lookup (void)
|
|
{
|
|
const gchar *str;
|
|
GVariant *dict;
|
|
gboolean ok;
|
|
gint num;
|
|
|
|
dict = g_variant_parse (NULL,
|
|
"{'a': <5>, 'b': <'c'>}",
|
|
NULL, NULL, NULL);
|
|
|
|
ok = g_variant_lookup (dict, "a", "i", &num);
|
|
g_assert (ok);
|
|
g_assert_cmpint (num, ==, 5);
|
|
|
|
ok = g_variant_lookup (dict, "a", "&s", &str);
|
|
g_assert (!ok);
|
|
|
|
ok = g_variant_lookup (dict, "q", "&s", &str);
|
|
g_assert (!ok);
|
|
|
|
ok = g_variant_lookup (dict, "b", "i", &num);
|
|
g_assert (!ok);
|
|
|
|
ok = g_variant_lookup (dict, "b", "&s", &str);
|
|
g_assert (ok);
|
|
g_assert_cmpstr (str, ==, "c");
|
|
|
|
ok = g_variant_lookup (dict, "q", "&s", &str);
|
|
g_assert (!ok);
|
|
|
|
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 = 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 = 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 = 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);
|
|
g_variant_unref (b);
|
|
}
|
|
|
|
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;
|
|
gint32 values[5];
|
|
const gint32 *elts;
|
|
gsize n_elts;
|
|
gint i;
|
|
|
|
n_elts = 0;
|
|
a = g_variant_new_parsed ("[1,2,3,4,5]");
|
|
elts = g_variant_get_fixed_array (a, &n_elts, sizeof (gint32));
|
|
g_assert (n_elts == 5);
|
|
for (i = 0; i < 5; i++)
|
|
g_assert_cmpint (elts[i], ==, i + 1);
|
|
g_variant_unref (a);
|
|
|
|
n_elts = 0;
|
|
for (i = 0; i < 5; i++)
|
|
values[i] = i + 1;
|
|
a = g_variant_new_fixed_array (G_VARIANT_TYPE_INT32, values,
|
|
G_N_ELEMENTS (values), sizeof (values[0]));
|
|
g_assert_cmpstr (g_variant_get_type_string (a), ==, "ai");
|
|
elts = g_variant_get_fixed_array (a, &n_elts, sizeof (gint32));
|
|
g_assert (n_elts == 5);
|
|
for (i = 0; i < 5; i++)
|
|
g_assert_cmpint (elts[i], ==, i + 1);
|
|
g_variant_unref (a);
|
|
}
|
|
|
|
static void
|
|
test_check_format_string (void)
|
|
{
|
|
GVariant *value;
|
|
|
|
value = g_variant_new ("(sas)", "foo", NULL);
|
|
g_variant_ref_sink (value);
|
|
|
|
g_assert (g_variant_check_format_string (value, "(s*)", TRUE));
|
|
g_assert (g_variant_check_format_string (value, "(s*)", FALSE));
|
|
g_assert (!g_variant_check_format_string (value, "(u*)", TRUE));
|
|
g_assert (!g_variant_check_format_string (value, "(u*)", FALSE));
|
|
|
|
g_assert (g_variant_check_format_string (value, "(&s*)", FALSE));
|
|
g_test_expect_message ("GLib", G_LOG_LEVEL_CRITICAL, "*contains a '&' character*");
|
|
g_assert (!g_variant_check_format_string (value, "(&s*)", TRUE));
|
|
g_test_assert_expected_messages ();
|
|
|
|
g_assert (g_variant_check_format_string (value, "(s^as)", TRUE));
|
|
g_assert (g_variant_check_format_string (value, "(s^as)", FALSE));
|
|
|
|
g_test_expect_message ("GLib", G_LOG_LEVEL_CRITICAL, "*contains a '&' character*");
|
|
g_assert (!g_variant_check_format_string (value, "(s^a&s)", TRUE));
|
|
g_test_assert_expected_messages ();
|
|
g_assert (g_variant_check_format_string (value, "(s^a&s)", FALSE));
|
|
|
|
g_variant_unref (value);
|
|
|
|
/* Do it again with a type that will let us put a '&' after a '^' */
|
|
value = g_variant_new ("(say)", "foo", NULL);
|
|
g_variant_ref_sink (value);
|
|
|
|
g_assert (g_variant_check_format_string (value, "(s*)", TRUE));
|
|
g_assert (g_variant_check_format_string (value, "(s*)", FALSE));
|
|
g_assert (!g_variant_check_format_string (value, "(u*)", TRUE));
|
|
g_assert (!g_variant_check_format_string (value, "(u*)", FALSE));
|
|
|
|
g_assert (g_variant_check_format_string (value, "(&s*)", FALSE));
|
|
g_test_expect_message ("GLib", G_LOG_LEVEL_CRITICAL, "*contains a '&' character*");
|
|
g_assert (!g_variant_check_format_string (value, "(&s*)", TRUE));
|
|
g_test_assert_expected_messages ();
|
|
|
|
g_assert (g_variant_check_format_string (value, "(s^ay)", TRUE));
|
|
g_assert (g_variant_check_format_string (value, "(s^ay)", FALSE));
|
|
|
|
g_test_expect_message ("GLib", G_LOG_LEVEL_CRITICAL, "*contains a '&' character*");
|
|
g_assert (!g_variant_check_format_string (value, "(s^&ay)", TRUE));
|
|
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);
|
|
}
|
|
|
|
static void
|
|
verify_gvariant_checksum (const gchar *sha256,
|
|
GVariant *v)
|
|
|
|
{
|
|
gchar *checksum;
|
|
checksum = g_compute_checksum_for_data (G_CHECKSUM_SHA256,
|
|
g_variant_get_data (v),
|
|
g_variant_get_size (v));
|
|
g_assert_cmpstr (sha256, ==, checksum);
|
|
g_free (checksum);
|
|
}
|
|
|
|
static void
|
|
verify_gvariant_checksum_va (const gchar *sha256,
|
|
const gchar *fmt,
|
|
...)
|
|
{
|
|
va_list args;
|
|
GVariant *v;
|
|
|
|
va_start (args, fmt);
|
|
|
|
v = g_variant_new_va (fmt, NULL, &args);
|
|
g_variant_ref_sink (v);
|
|
#if G_BYTE_ORDER == G_BIG_ENDIAN
|
|
{
|
|
GVariant *byteswapped = g_variant_byteswap (v);
|
|
g_variant_unref (v);
|
|
v = byteswapped;
|
|
}
|
|
#endif
|
|
|
|
va_end (args);
|
|
|
|
verify_gvariant_checksum (sha256, v);
|
|
|
|
g_variant_unref (v);
|
|
}
|
|
|
|
static void
|
|
test_checksum_basic (void)
|
|
{
|
|
verify_gvariant_checksum_va ("e8a4b2ee7ede79a3afb332b5b6cc3d952a65fd8cffb897f5d18016577c33d7cc",
|
|
"u", 42);
|
|
verify_gvariant_checksum_va ("c53e363c33b00cfce298229ee83856b8a98c2e6126cab13f65899f62473b0df5",
|
|
"s", "moocow");
|
|
verify_gvariant_checksum_va ("2b4c342f5433ebe591a1da77e013d1b72475562d48578dca8b84bac6651c3cb9",
|
|
"y", 9);
|
|
verify_gvariant_checksum_va ("12a3ae445661ce5dee78d0650d33362dec29c4f82af05e7e57fb595bbbacf0ca",
|
|
"t", G_MAXUINT64);
|
|
verify_gvariant_checksum_va ("e25a59b24440eb6c833aa79c93b9840e6eab6966add0dacf31df7e9e7000f5b3",
|
|
"d", 3.14159);
|
|
verify_gvariant_checksum_va ("4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a",
|
|
"b", TRUE);
|
|
verify_gvariant_checksum_va ("ca2fd00fa001190744c15c317643ab092e7048ce086a243e2be9437c898de1bb",
|
|
"q", G_MAXUINT16);
|
|
}
|
|
|
|
static void
|
|
test_checksum_nested (void)
|
|
{
|
|
static const char* const strv[] = {"foo", "bar", "baz", NULL};
|
|
|
|
verify_gvariant_checksum_va ("31fbc92f08fddaca716188fe4b5d44ae122fc6306fd3c6925af53cfa47ea596d",
|
|
"(uu)", 41, 43);
|
|
verify_gvariant_checksum_va ("01759d683cead856d1d386d59af0578841698a424a265345ad5413122f220de8",
|
|
"(su)", "moocow", 79);
|
|
verify_gvariant_checksum_va ("52b3ae95f19b3e642ea1d01185aea14a09004c1d1712672644427403a8a0afe6",
|
|
"(qyst)", G_MAXUINT16, 9, "moocow", G_MAXUINT64);
|
|
verify_gvariant_checksum_va ("6fc6f4524161c3ae0d316812d7088e3fcd372023edaea2d7821093be40ae1060",
|
|
"(@ay)", g_variant_new_bytestring ("\xFF\xFF\xFF"));
|
|
verify_gvariant_checksum_va ("572aca386e1a983dd23bb6eb6e3dfa72eef9ca7c7744581aa800e18d7d9d0b0b",
|
|
"(^as)", strv);
|
|
verify_gvariant_checksum_va ("4bddf6174c791bb44fc6a4106573031690064df34b741033a0122ed8dc05bcf3",
|
|
"(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 void
|
|
test_stack_builder_init (void)
|
|
{
|
|
GVariantBuilder builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_BYTESTRING);
|
|
GVariant *variant;
|
|
|
|
g_variant_builder_add_value (&builder, g_variant_new_byte ('g'));
|
|
g_variant_builder_add_value (&builder, g_variant_new_byte ('l'));
|
|
g_variant_builder_add_value (&builder, g_variant_new_byte ('i'));
|
|
g_variant_builder_add_value (&builder, g_variant_new_byte ('b'));
|
|
g_variant_builder_add_value (&builder, g_variant_new_byte ('\0'));
|
|
|
|
variant = g_variant_ref_sink (g_variant_builder_end (&builder));
|
|
g_assert_nonnull (variant);
|
|
g_assert (g_variant_type_equal (g_variant_get_type (variant),
|
|
G_VARIANT_TYPE_BYTESTRING));
|
|
g_assert_cmpuint (g_variant_n_children (variant), ==, 5);
|
|
g_assert_cmpstr (g_variant_get_bytestring (variant), ==, "glib");
|
|
g_variant_unref (variant);
|
|
}
|
|
|
|
static GVariant *
|
|
get_asv (void)
|
|
{
|
|
GVariantBuilder builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT);
|
|
|
|
g_variant_builder_add (&builder, "{s@v}", "foo", g_variant_new_variant (g_variant_new_string ("FOO")));
|
|
g_variant_builder_add (&builder, "{s@v}", "bar", g_variant_new_variant (g_variant_new_string ("BAR")));
|
|
|
|
return g_variant_ref_sink (g_variant_builder_end (&builder));
|
|
}
|
|
|
|
static void
|
|
test_stack_dict_init (void)
|
|
{
|
|
GVariant *asv = get_asv ();
|
|
GVariantDict dict = G_VARIANT_DICT_INIT (asv);
|
|
GVariant *variant;
|
|
GVariantIter iter;
|
|
gchar *key;
|
|
GVariant *value;
|
|
|
|
g_variant_dict_insert_value (&dict, "baz", g_variant_new_string ("BAZ"));
|
|
g_variant_dict_insert_value (&dict, "quux", g_variant_new_string ("QUUX"));
|
|
|
|
variant = g_variant_ref_sink (g_variant_dict_end (&dict));
|
|
g_assert_nonnull (variant);
|
|
g_assert (g_variant_type_equal (g_variant_get_type (variant),
|
|
G_VARIANT_TYPE_VARDICT));
|
|
g_assert_cmpuint (g_variant_n_children (variant), ==, 4);
|
|
|
|
g_variant_iter_init (&iter, variant);
|
|
while (g_variant_iter_next (&iter, "{sv}", &key, &value))
|
|
{
|
|
gchar *strup = g_ascii_strup (key, -1);
|
|
|
|
g_assert_cmpstr (strup, ==, g_variant_get_string (value, NULL));
|
|
g_free (key);
|
|
g_free (strup);
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
g_variant_unref (asv);
|
|
g_variant_unref (variant);
|
|
}
|
|
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
gint i;
|
|
|
|
g_test_init (&argc, &argv, NULL);
|
|
|
|
g_test_add_func ("/gvariant/type", test_gvarianttype);
|
|
g_test_add_func ("/gvariant/typeinfo", test_gvarianttypeinfo);
|
|
g_test_add_func ("/gvariant/serialiser/maybe", test_maybes);
|
|
g_test_add_func ("/gvariant/serialiser/array", test_arrays);
|
|
g_test_add_func ("/gvariant/serialiser/tuple", test_tuples);
|
|
g_test_add_func ("/gvariant/serialiser/variant", test_variants);
|
|
g_test_add_func ("/gvariant/serialiser/strings", test_strings);
|
|
g_test_add_func ("/gvariant/serialiser/byteswap", test_byteswaps);
|
|
|
|
for (i = 1; i <= 20; i += 4)
|
|
{
|
|
char *testname;
|
|
|
|
testname = g_strdup_printf ("/gvariant/serialiser/fuzz/%d%%", i);
|
|
g_test_add_data_func (testname, GINT_TO_POINTER (i),
|
|
(gpointer) test_fuzzes);
|
|
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/byteswap", test_gv_byteswap);
|
|
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/stack-builder-init", test_stack_builder_init);
|
|
g_test_add_func ("/gvariant/stack-dict-init", test_stack_dict_init);
|
|
return g_test_run ();
|
|
}
|