[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;

        assert_se(sd_bus_open_system(&bus) >= 0);
        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(NULL, 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;
c1b9d935 LP	137
c1b9d935 LP	138	assert_se(sd_bus_open_system(&bus) >= 0);
6647dc66	139	bus->message_version = 2; /* dirty hack to enable gvariant*/
c1b9d935	140
151b9b96	141	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	142
c1b9d935	143	assert_se(sd_bus_message_append(m,
8f19720d	144	"a(usv)", 3,
c1b9d935	145	4711, "first-string-parameter", "(st)", "X", (uint64_t) 1111,
8f19720d LP	146	4712, "second-string-parameter", "(a(si))", 2, "Y", 5, "Z", 6,
8f19720d LP	147	4713, "third-string-parameter", "(uu)", 1, 2) >= 0);
c1b9d935	148
3df7a7e6	149	assert_se(bus_message_seal(m, 4711, 0) >= 0);
c1b9d935 LP	150
	151	#ifdef HAVE_GLIB
	152	{
	153	GVariant *v;
	154	char *t;
	155
	156	#if !defined(GLIB_VERSION_2_36)
	157	g_type_init();
	158	#endif
	159
	160	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);
	161	t = g_variant_print(v, TRUE);
	162	printf("%s\n", t);
	163	g_free(t);
	164	g_variant_unref(v);
	165
	166	v = g_variant_new_from_data(G_VARIANT_TYPE("(a(usv))"), m->body.data, BUS_MESSAGE_BODY_SIZE(m), false, NULL, NULL);
	167	t = g_variant_print(v, TRUE);
	168	printf("%s\n", t);
	169	g_free(t);
	170	g_variant_unref(v);
	171	}
	172	#endif
	173
6647dc66 LP	174	assert_se(bus_message_dump(m, NULL, true) >= 0);
	175
	176	assert_se(bus_message_get_blob(m, &blob, &sz) >= 0);
	177
	178	assert_se(bus_message_from_malloc(NULL, blob, sz, NULL, 0, NULL, NULL, &n) >= 0);
	179	blob = NULL;
	180
	181	assert_se(bus_message_dump(n, NULL, true) >= 0);
5877dc5a LP	182
	183	m = sd_bus_message_unref(m);
	184
151b9b96	185	assert_se(sd_bus_message_new_method_call(bus, &m, "a.x", "/a/x", "a.x", "Ax") >= 0);
5877dc5a LP	186
	187	assert_se(sd_bus_message_append(m, "as", 0) >= 0);
	188
3df7a7e6	189	assert_se(bus_message_seal(m, 4712, 0) >= 0);
5877dc5a	190	assert_se(bus_message_dump(m, NULL, true) >= 0);
c1b9d935 LP	191	}
	192
	193	int main(int argc, char *argv[]) {
	194
	195	test_bus_gvariant_is_fixed_size();
6647dc66	196	test_bus_gvariant_get_size();
c1b9d935 LP	197	test_bus_gvariant_get_alignment();
	198	test_marshal();
	199
	200	return 0;
	201	}