[thirdparty/systemd.git] / src / libsystemd / sd-bus / test-bus-gvariant.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd 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.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#ifdef HAVE_GLIB
#include <glib.h>
#endif

#include "util.h"
#include "sd-bus.h"
#include "bus-gvariant.h"
#include "bus-util.h"
#include "bus-internal.h"
#include "bus-message.h"
#include "bus-dump.h"

static void test_bus_gvariant_is_fixed_size(void) {
        assert(bus_gvariant_is_fixed_size("") > 0);
        assert(bus_gvariant_is_fixed_size("()") > 0);
        assert(bus_gvariant_is_fixed_size("y") > 0);
        assert(bus_gvariant_is_fixed_size("u") > 0);
        assert(bus_gvariant_is_fixed_size("b") > 0);
        assert(bus_gvariant_is_fixed_size("n") > 0);
        assert(bus_gvariant_is_fixed_size("q") > 0);
        assert(bus_gvariant_is_fixed_size("i") > 0);
        assert(bus_gvariant_is_fixed_size("t") > 0);
        assert(bus_gvariant_is_fixed_size("d") > 0);
        assert(bus_gvariant_is_fixed_size("s") == 0);
        assert(bus_gvariant_is_fixed_size("o") == 0);
        assert(bus_gvariant_is_fixed_size("g") == 0);
        assert(bus_gvariant_is_fixed_size("h") > 0);
        assert(bus_gvariant_is_fixed_size("ay") == 0);
        assert(bus_gvariant_is_fixed_size("v") == 0);
        assert(bus_gvariant_is_fixed_size("(u)") > 0);
        assert(bus_gvariant_is_fixed_size("(uuuuy)") > 0);
        assert(bus_gvariant_is_fixed_size("(uusuuy)") == 0);
        assert(bus_gvariant_is_fixed_size("a{ss}") == 0);
        assert(bus_gvariant_is_fixed_size("((u)yyy(b(iiii)))") > 0);
        assert(bus_gvariant_is_fixed_size("((u)yyy(b(iiivi)))") == 0);
}

static void test_bus_gvariant_get_size(void) {
        assert(bus_gvariant_get_size("") == 0);
        assert(bus_gvariant_get_size("()") == 0);
        assert(bus_gvariant_get_size("y") == 1);
        assert(bus_gvariant_get_size("u") == 4);
        assert(bus_gvariant_get_size("b") == 1);
        assert(bus_gvariant_get_size("n") == 2);
        assert(bus_gvariant_get_size("q") == 2);
        assert(bus_gvariant_get_size("i") == 4);
        assert(bus_gvariant_get_size("t") == 8);
        assert(bus_gvariant_get_size("d") == 8);
        assert(bus_gvariant_get_size("s") < 0);
        assert(bus_gvariant_get_size("o") < 0);
        assert(bus_gvariant_get_size("g") < 0);
        assert(bus_gvariant_get_size("h") == 4);
        assert(bus_gvariant_get_size("ay") < 0);
        assert(bus_gvariant_get_size("v") < 0);
        assert(bus_gvariant_get_size("(u)") == 4);
        assert(bus_gvariant_get_size("(uuuuy)") == 20);
        assert(bus_gvariant_get_size("(uusuuy)") < 0);
        assert(bus_gvariant_get_size("a{ss}") < 0);
        assert(bus_gvariant_get_size("((u)yyy(b(iiii)))") == 28);
        assert(bus_gvariant_get_size("((u)yyy(b(iiivi)))") < 0);
        assert(bus_gvariant_get_size("((b)(t))") == 16);
        assert(bus_gvariant_get_size("((b)(b)(t))") == 16);
        assert(bus_gvariant_get_size("(bt)") == 16);
        assert(bus_gvariant_get_size("((t)(b))") == 16);
        assert(bus_gvariant_get_size("(tb)") == 16);
        assert(bus_gvariant_get_size("((b)(b))") == 2);
        assert(bus_gvariant_get_size("((t)(t))") == 16);
}

static void test_bus_gvariant_get_alignment(void) {
        assert(bus_gvariant_get_alignment("") == 1);
        assert(bus_gvariant_get_alignment("()") == 1);
        assert(bus_gvariant_get_alignment("y") == 1);
        assert(bus_gvariant_get_alignment("b") == 1);
        assert(bus_gvariant_get_alignment("u") == 4);
        assert(bus_gvariant_get_alignment("s") == 1);
        assert(bus_gvariant_get_alignment("o") == 1);
        assert(bus_gvariant_get_alignment("g") == 1);
        assert(bus_gvariant_get_alignment("v") == 8);
        assert(bus_gvariant_get_alignment("h") == 4);
        assert(bus_gvariant_get_alignment("i") == 4);
        assert(bus_gvariant_get_alignment("t") == 8);
        assert(bus_gvariant_get_alignment("x") == 8);
        assert(bus_gvariant_get_alignment("q") == 2);
        assert(bus_gvariant_get_alignment("n") == 2);
        assert(bus_gvariant_get_alignment("d") == 8);
        assert(bus_gvariant_get_alignment("ay") == 1);
        assert(bus_gvariant_get_alignment("as") == 1);
        assert(bus_gvariant_get_alignment("au") == 4);
        assert(bus_gvariant_get_alignment("an") == 2);
        assert(bus_gvariant_get_alignment("ans") == 2);
        assert(bus_gvariant_get_alignment("ant") == 8);
        assert(bus_gvariant_get_alignment("(ss)") == 1);
        assert(bus_gvariant_get_alignment("(ssu)") == 4);
        assert(bus_gvariant_get_alignment("a(ssu)") == 4);
        assert(bus_gvariant_get_alignment("(u)") == 4);
        assert(bus_gvariant_get_alignment("(uuuuy)") == 4);
        assert(bus_gvariant_get_alignment("(uusuuy)") == 4);
        assert(bus_gvariant_get_alignment("a{ss}") == 1);
        assert(bus_gvariant_get_alignment("((u)yyy(b(iiii)))") == 4);
        assert(bus_gvariant_get_alignment("((u)yyy(b(iiivi)))") == 8);
        assert(bus_gvariant_get_alignment("((b)(t))") == 8);
        assert(bus_gvariant_get_alignment("((b)(b)(t))") == 8);
        assert(bus_gvariant_get_alignment("(bt)") == 8);
        assert(bus_gvariant_get_alignment("((t)(b))") == 8);
        assert(bus_gvariant_get_alignment("(tb)") == 8);
        assert(bus_gvariant_get_alignment("((b)(b))") == 1);
        assert(bus_gvariant_get_alignment("((t)(t))") == 8);
}

static void test_marshal(void) {
        _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *n = NULL;
        _cleanup_bus_unref_ sd_bus *bus = NULL;
        _cleanup_free_ void *blob;
        size_t sz;
        int r;

        r = sd_bus_open_system(&bus);
        if (r < 0)
                exit(EXIT_TEST_SKIP);

        bus->message_version = 2; /* dirty hack to enable gvariant*/

        assert_se(sd_bus_message_new_method_call(bus, &m, "a.service.name", "/an/object/path/which/is/really/really/long/so/that/we/hit/the/eight/bit/boundary/by/quite/some/margin/to/test/this/stuff/that/it/really/works", "an.interface.name", "AMethodName") >= 0);

        assert_se(sd_bus_message_append(m,
                                        "a(usv)", 3,
                                        4711, "first-string-parameter", "(st)", "X", (uint64_t) 1111,
                                        4712, "second-string-parameter", "(a(si))", 2, "Y", 5, "Z", 6,
                                        4713, "third-string-parameter", "(uu)", 1, 2) >= 0);

        assert_se(bus_message_seal(m, 4711, 0) >= 0);

#ifdef HAVE_GLIB
        {
                GVariant *v;
                char *t;

#if !defined(GLIB_VERSION_2_36)
                g_type_init();
#endif

                v = g_variant_new_from_data(G_VARIANT_TYPE("(yyyyuuua(yv))"), m->header, sizeof(struct bus_header) + BUS_MESSAGE_FIELDS_SIZE(m), false, NULL, NULL);
                t = g_variant_print(v, TRUE);
                printf("%s\n", t);
                g_free(t);
                g_variant_unref(v);

                v = g_variant_new_from_data(G_VARIANT_TYPE("(a(usv))"), m->body.data, BUS_MESSAGE_BODY_SIZE(m), false, NULL, NULL);
                t = g_variant_print(v, TRUE);
                printf("%s\n", t);
                g_free(t);
                g_variant_unref(v);
        }
#endif

        assert_se(bus_message_dump(m, NULL, true) >= 0);

        assert_se(bus_message_get_blob(m, &blob, &sz) >= 0);

        assert_se(bus_message_from_malloc(bus, blob, sz, NULL, 0, NULL, NULL, &n) >= 0);
        blob = NULL;

        assert_se(bus_message_dump(n, NULL, true) >= 0);

        m = sd_bus_message_unref(m);

        assert_se(sd_bus_message_new_method_call(bus, &m, "a.x", "/a/x", "a.x", "Ax") >= 0);

        assert_se(sd_bus_message_append(m, "as", 0) >= 0);

        assert_se(bus_message_seal(m, 4712, 0) >= 0);
        assert_se(bus_message_dump(m, NULL, true) >= 0);
}

int main(int argc, char *argv[]) {

        test_bus_gvariant_is_fixed_size();
        test_bus_gvariant_get_size();
        test_bus_gvariant_get_alignment();
        test_marshal();

        return 0;
}
Commit	Line	Data
c1b9d935 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#ifdef HAVE_GLIB
	23	#include <glib.h>
	24	#endif
	25
	26	#include "util.h"
	27	#include "sd-bus.h"
	28	#include "bus-gvariant.h"
	29	#include "bus-util.h"
	30	#include "bus-internal.h"
	31	#include "bus-message.h"
6647dc66	32	#include "bus-dump.h"
c1b9d935 LP	33
	34	static void test_bus_gvariant_is_fixed_size(void) {
	35	assert(bus_gvariant_is_fixed_size("") > 0);
6647dc66	36	assert(bus_gvariant_is_fixed_size("()") > 0);
c1b9d935 LP	37	assert(bus_gvariant_is_fixed_size("y") > 0);
	38	assert(bus_gvariant_is_fixed_size("u") > 0);
	39	assert(bus_gvariant_is_fixed_size("b") > 0);
	40	assert(bus_gvariant_is_fixed_size("n") > 0);
	41	assert(bus_gvariant_is_fixed_size("q") > 0);
	42	assert(bus_gvariant_is_fixed_size("i") > 0);
	43	assert(bus_gvariant_is_fixed_size("t") > 0);
	44	assert(bus_gvariant_is_fixed_size("d") > 0);
	45	assert(bus_gvariant_is_fixed_size("s") == 0);
	46	assert(bus_gvariant_is_fixed_size("o") == 0);
	47	assert(bus_gvariant_is_fixed_size("g") == 0);
	48	assert(bus_gvariant_is_fixed_size("h") > 0);
	49	assert(bus_gvariant_is_fixed_size("ay") == 0);
	50	assert(bus_gvariant_is_fixed_size("v") == 0);
	51	assert(bus_gvariant_is_fixed_size("(u)") > 0);
	52	assert(bus_gvariant_is_fixed_size("(uuuuy)") > 0);
	53	assert(bus_gvariant_is_fixed_size("(uusuuy)") == 0);
	54	assert(bus_gvariant_is_fixed_size("a{ss}") == 0);
	55	assert(bus_gvariant_is_fixed_size("((u)yyy(b(iiii)))") > 0);
	56	assert(bus_gvariant_is_fixed_size("((u)yyy(b(iiivi)))") == 0);
	57	}
	58
6647dc66 LP	59	static void test_bus_gvariant_get_size(void) {
	60	assert(bus_gvariant_get_size("") == 0);
	61	assert(bus_gvariant_get_size("()") == 0);
	62	assert(bus_gvariant_get_size("y") == 1);
	63	assert(bus_gvariant_get_size("u") == 4);
	64	assert(bus_gvariant_get_size("b") == 1);
	65	assert(bus_gvariant_get_size("n") == 2);
	66	assert(bus_gvariant_get_size("q") == 2);
	67	assert(bus_gvariant_get_size("i") == 4);
	68	assert(bus_gvariant_get_size("t") == 8);
	69	assert(bus_gvariant_get_size("d") == 8);
	70	assert(bus_gvariant_get_size("s") < 0);
	71	assert(bus_gvariant_get_size("o") < 0);
	72	assert(bus_gvariant_get_size("g") < 0);
	73	assert(bus_gvariant_get_size("h") == 4);
	74	assert(bus_gvariant_get_size("ay") < 0);
	75	assert(bus_gvariant_get_size("v") < 0);
	76	assert(bus_gvariant_get_size("(u)") == 4);
	77	assert(bus_gvariant_get_size("(uuuuy)") == 20);
	78	assert(bus_gvariant_get_size("(uusuuy)") < 0);
	79	assert(bus_gvariant_get_size("a{ss}") < 0);
	80	assert(bus_gvariant_get_size("((u)yyy(b(iiii)))") == 28);
	81	assert(bus_gvariant_get_size("((u)yyy(b(iiivi)))") < 0);
	82	assert(bus_gvariant_get_size("((b)(t))") == 16);
	83	assert(bus_gvariant_get_size("((b)(b)(t))") == 16);
	84	assert(bus_gvariant_get_size("(bt)") == 16);
	85	assert(bus_gvariant_get_size("((t)(b))") == 16);
	86	assert(bus_gvariant_get_size("(tb)") == 16);
	87	assert(bus_gvariant_get_size("((b)(b))") == 2);
	88	assert(bus_gvariant_get_size("((t)(t))") == 16);
	89	}
	90
c1b9d935 LP	91	static void test_bus_gvariant_get_alignment(void) {
c1b9d935 LP	92	assert(bus_gvariant_get_alignment("") == 1);
6647dc66	93	assert(bus_gvariant_get_alignment("()") == 1);
c1b9d935 LP	94	assert(bus_gvariant_get_alignment("y") == 1);
	95	assert(bus_gvariant_get_alignment("b") == 1);
	96	assert(bus_gvariant_get_alignment("u") == 4);
	97	assert(bus_gvariant_get_alignment("s") == 1);
	98	assert(bus_gvariant_get_alignment("o") == 1);
	99	assert(bus_gvariant_get_alignment("g") == 1);
	100	assert(bus_gvariant_get_alignment("v") == 8);
	101	assert(bus_gvariant_get_alignment("h") == 4);
	102	assert(bus_gvariant_get_alignment("i") == 4);
	103	assert(bus_gvariant_get_alignment("t") == 8);
	104	assert(bus_gvariant_get_alignment("x") == 8);
	105	assert(bus_gvariant_get_alignment("q") == 2);
	106	assert(bus_gvariant_get_alignment("n") == 2);
	107	assert(bus_gvariant_get_alignment("d") == 8);
	108	assert(bus_gvariant_get_alignment("ay") == 1);
	109	assert(bus_gvariant_get_alignment("as") == 1);
	110	assert(bus_gvariant_get_alignment("au") == 4);
	111	assert(bus_gvariant_get_alignment("an") == 2);
	112	assert(bus_gvariant_get_alignment("ans") == 2);
	113	assert(bus_gvariant_get_alignment("ant") == 8);
	114	assert(bus_gvariant_get_alignment("(ss)") == 1);
	115	assert(bus_gvariant_get_alignment("(ssu)") == 4);
	116	assert(bus_gvariant_get_alignment("a(ssu)") == 4);
6647dc66 LP	117	assert(bus_gvariant_get_alignment("(u)") == 4);
	118	assert(bus_gvariant_get_alignment("(uuuuy)") == 4);
	119	assert(bus_gvariant_get_alignment("(uusuuy)") == 4);
	120	assert(bus_gvariant_get_alignment("a{ss}") == 1);
	121	assert(bus_gvariant_get_alignment("((u)yyy(b(iiii)))") == 4);
	122	assert(bus_gvariant_get_alignment("((u)yyy(b(iiivi)))") == 8);
	123	assert(bus_gvariant_get_alignment("((b)(t))") == 8);
	124	assert(bus_gvariant_get_alignment("((b)(b)(t))") == 8);
	125	assert(bus_gvariant_get_alignment("(bt)") == 8);
	126	assert(bus_gvariant_get_alignment("((t)(b))") == 8);
	127	assert(bus_gvariant_get_alignment("(tb)") == 8);
	128	assert(bus_gvariant_get_alignment("((b)(b))") == 1);
	129	assert(bus_gvariant_get_alignment("((t)(t))") == 8);
c1b9d935 LP	130	}
	131
	132	static void test_marshal(void) {
6647dc66	133	_cleanup_bus_message_unref_ sd_bus_message m = NULL, n = NULL;
c1b9d935	134	_cleanup_bus_unref_ sd_bus *bus = NULL;
6647dc66 LP	135	_cleanup_free_ void *blob;
6647dc66 LP	136	size_t sz;
2a0958d2 LP	137	int r;
	138
	139	r = sd_bus_open_system(&bus);
	140	if (r < 0)
	141	exit(EXIT_TEST_SKIP);
c1b9d935	142
6647dc66	143	bus->message_version = 2; /* dirty hack to enable gvariant*/
c1b9d935	144
151b9b96	145	assert_se(sd_bus_message_new_method_call(bus, &m, "a.service.name", "/an/object/path/which/is/really/really/long/so/that/we/hit/the/eight/bit/boundary/by/quite/some/margin/to/test/this/stuff/that/it/really/works", "an.interface.name", "AMethodName") >= 0);
c1b9d935	146
c1b9d935	147	assert_se(sd_bus_message_append(m,
8f19720d	148	"a(usv)", 3,
c1b9d935	149	4711, "first-string-parameter", "(st)", "X", (uint64_t) 1111,
8f19720d LP	150	4712, "second-string-parameter", "(a(si))", 2, "Y", 5, "Z", 6,
8f19720d LP	151	4713, "third-string-parameter", "(uu)", 1, 2) >= 0);
c1b9d935	152
3df7a7e6	153	assert_se(bus_message_seal(m, 4711, 0) >= 0);
c1b9d935 LP	154
	155	#ifdef HAVE_GLIB
	156	{
	157	GVariant *v;
	158	char *t;
	159
	160	#if !defined(GLIB_VERSION_2_36)
	161	g_type_init();
	162	#endif
	163
	164	v = g_variant_new_from_data(G_VARIANT_TYPE("(yyyyuuua(yv))"), m->header, sizeof(struct bus_header) + BUS_MESSAGE_FIELDS_SIZE(m), false, NULL, NULL);
	165	t = g_variant_print(v, TRUE);
	166	printf("%s\n", t);
	167	g_free(t);
	168	g_variant_unref(v);
	169
	170	v = g_variant_new_from_data(G_VARIANT_TYPE("(a(usv))"), m->body.data, BUS_MESSAGE_BODY_SIZE(m), false, NULL, NULL);
	171	t = g_variant_print(v, TRUE);
	172	printf("%s\n", t);
	173	g_free(t);
	174	g_variant_unref(v);
	175	}
	176	#endif
	177
6647dc66 LP	178	assert_se(bus_message_dump(m, NULL, true) >= 0);
	179
	180	assert_se(bus_message_get_blob(m, &blob, &sz) >= 0);
	181
2a0958d2	182	assert_se(bus_message_from_malloc(bus, blob, sz, NULL, 0, NULL, NULL, &n) >= 0);
6647dc66 LP	183	blob = NULL;
	184
	185	assert_se(bus_message_dump(n, NULL, true) >= 0);
5877dc5a LP	186
	187	m = sd_bus_message_unref(m);
	188
151b9b96	189	assert_se(sd_bus_message_new_method_call(bus, &m, "a.x", "/a/x", "a.x", "Ax") >= 0);
5877dc5a LP	190
	191	assert_se(sd_bus_message_append(m, "as", 0) >= 0);
	192
3df7a7e6	193	assert_se(bus_message_seal(m, 4712, 0) >= 0);
5877dc5a	194	assert_se(bus_message_dump(m, NULL, true) >= 0);
c1b9d935 LP	195	}
	196
	197	int main(int argc, char *argv[]) {
	198
	199	test_bus_gvariant_is_fixed_size();
6647dc66	200	test_bus_gvariant_get_size();
c1b9d935 LP	201	test_bus_gvariant_get_alignment();
	202	test_marshal();
	203
	204	return 0;
	205	}