[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 "macro.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_se(bus_gvariant_is_fixed_size("") > 0);
        assert_se(bus_gvariant_is_fixed_size("()") > 0);
        assert_se(bus_gvariant_is_fixed_size("y") > 0);
        assert_se(bus_gvariant_is_fixed_size("u") > 0);
        assert_se(bus_gvariant_is_fixed_size("b") > 0);
        assert_se(bus_gvariant_is_fixed_size("n") > 0);
        assert_se(bus_gvariant_is_fixed_size("q") > 0);
        assert_se(bus_gvariant_is_fixed_size("i") > 0);
        assert_se(bus_gvariant_is_fixed_size("t") > 0);
        assert_se(bus_gvariant_is_fixed_size("d") > 0);
        assert_se(bus_gvariant_is_fixed_size("s") == 0);
        assert_se(bus_gvariant_is_fixed_size("o") == 0);
        assert_se(bus_gvariant_is_fixed_size("g") == 0);
        assert_se(bus_gvariant_is_fixed_size("h") > 0);
        assert_se(bus_gvariant_is_fixed_size("ay") == 0);
        assert_se(bus_gvariant_is_fixed_size("v") == 0);
        assert_se(bus_gvariant_is_fixed_size("(u)") > 0);
        assert_se(bus_gvariant_is_fixed_size("(uuuuy)") > 0);
        assert_se(bus_gvariant_is_fixed_size("(uusuuy)") == 0);
        assert_se(bus_gvariant_is_fixed_size("a{ss}") == 0);
        assert_se(bus_gvariant_is_fixed_size("((u)yyy(b(iiii)))") > 0);
        assert_se(bus_gvariant_is_fixed_size("((u)yyy(b(iiivi)))") == 0);
}

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

static void test_bus_gvariant_get_alignment(void) {
        assert_se(bus_gvariant_get_alignment("") == 1);
        assert_se(bus_gvariant_get_alignment("()") == 1);
        assert_se(bus_gvariant_get_alignment("y") == 1);
        assert_se(bus_gvariant_get_alignment("b") == 1);
        assert_se(bus_gvariant_get_alignment("u") == 4);
        assert_se(bus_gvariant_get_alignment("s") == 1);
        assert_se(bus_gvariant_get_alignment("o") == 1);
        assert_se(bus_gvariant_get_alignment("g") == 1);
        assert_se(bus_gvariant_get_alignment("v") == 8);
        assert_se(bus_gvariant_get_alignment("h") == 4);
        assert_se(bus_gvariant_get_alignment("i") == 4);
        assert_se(bus_gvariant_get_alignment("t") == 8);
        assert_se(bus_gvariant_get_alignment("x") == 8);
        assert_se(bus_gvariant_get_alignment("q") == 2);
        assert_se(bus_gvariant_get_alignment("n") == 2);
        assert_se(bus_gvariant_get_alignment("d") == 8);
        assert_se(bus_gvariant_get_alignment("ay") == 1);
        assert_se(bus_gvariant_get_alignment("as") == 1);
        assert_se(bus_gvariant_get_alignment("au") == 4);
        assert_se(bus_gvariant_get_alignment("an") == 2);
        assert_se(bus_gvariant_get_alignment("ans") == 2);
        assert_se(bus_gvariant_get_alignment("ant") == 8);
        assert_se(bus_gvariant_get_alignment("(ss)") == 1);
        assert_se(bus_gvariant_get_alignment("(ssu)") == 4);
        assert_se(bus_gvariant_get_alignment("a(ssu)") == 4);
        assert_se(bus_gvariant_get_alignment("(u)") == 4);
        assert_se(bus_gvariant_get_alignment("(uuuuy)") == 4);
        assert_se(bus_gvariant_get_alignment("(uusuuy)") == 4);
        assert_se(bus_gvariant_get_alignment("a{ss}") == 1);
        assert_se(bus_gvariant_get_alignment("((u)yyy(b(iiii)))") == 4);
        assert_se(bus_gvariant_get_alignment("((u)yyy(b(iiivi)))") == 8);
        assert_se(bus_gvariant_get_alignment("((b)(t))") == 8);
        assert_se(bus_gvariant_get_alignment("((b)(b)(t))") == 8);
        assert_se(bus_gvariant_get_alignment("(bt)") == 8);
        assert_se(bus_gvariant_get_alignment("((t)(b))") == 8);
        assert_se(bus_gvariant_get_alignment("(tb)") == 8);
        assert_se(bus_gvariant_get_alignment("((b)(b))") == 1);
        assert_se(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, BUS_MESSAGE_DUMP_WITH_HEADER) >= 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, BUS_MESSAGE_DUMP_WITH_HEADER) >= 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, BUS_MESSAGE_DUMP_WITH_HEADER) >= 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"
0c0cdb06	27	#include "macro.h"
c1b9d935 LP	28	#include "sd-bus.h"
	29	#include "bus-gvariant.h"
	30	#include "bus-util.h"
	31	#include "bus-internal.h"
	32	#include "bus-message.h"
6647dc66	33	#include "bus-dump.h"
c1b9d935 LP	34
c1b9d935 LP	35	static void test_bus_gvariant_is_fixed_size(void) {
0c0cdb06 RC	36	assert_se(bus_gvariant_is_fixed_size("") > 0);
	37	assert_se(bus_gvariant_is_fixed_size("()") > 0);
	38	assert_se(bus_gvariant_is_fixed_size("y") > 0);
	39	assert_se(bus_gvariant_is_fixed_size("u") > 0);
	40	assert_se(bus_gvariant_is_fixed_size("b") > 0);
	41	assert_se(bus_gvariant_is_fixed_size("n") > 0);
	42	assert_se(bus_gvariant_is_fixed_size("q") > 0);
	43	assert_se(bus_gvariant_is_fixed_size("i") > 0);
	44	assert_se(bus_gvariant_is_fixed_size("t") > 0);
	45	assert_se(bus_gvariant_is_fixed_size("d") > 0);
	46	assert_se(bus_gvariant_is_fixed_size("s") == 0);
	47	assert_se(bus_gvariant_is_fixed_size("o") == 0);
	48	assert_se(bus_gvariant_is_fixed_size("g") == 0);
	49	assert_se(bus_gvariant_is_fixed_size("h") > 0);
	50	assert_se(bus_gvariant_is_fixed_size("ay") == 0);
	51	assert_se(bus_gvariant_is_fixed_size("v") == 0);
	52	assert_se(bus_gvariant_is_fixed_size("(u)") > 0);
	53	assert_se(bus_gvariant_is_fixed_size("(uuuuy)") > 0);
	54	assert_se(bus_gvariant_is_fixed_size("(uusuuy)") == 0);
	55	assert_se(bus_gvariant_is_fixed_size("a{ss}") == 0);
	56	assert_se(bus_gvariant_is_fixed_size("((u)yyy(b(iiii)))") > 0);
	57	assert_se(bus_gvariant_is_fixed_size("((u)yyy(b(iiivi)))") == 0);
c1b9d935 LP	58	}
c1b9d935 LP	59
6647dc66	60	static void test_bus_gvariant_get_size(void) {
0c0cdb06 RC	61	assert_se(bus_gvariant_get_size("") == 0);
	62	assert_se(bus_gvariant_get_size("()") == 0);
	63	assert_se(bus_gvariant_get_size("y") == 1);
	64	assert_se(bus_gvariant_get_size("u") == 4);
	65	assert_se(bus_gvariant_get_size("b") == 1);
	66	assert_se(bus_gvariant_get_size("n") == 2);
	67	assert_se(bus_gvariant_get_size("q") == 2);
	68	assert_se(bus_gvariant_get_size("i") == 4);
	69	assert_se(bus_gvariant_get_size("t") == 8);
	70	assert_se(bus_gvariant_get_size("d") == 8);
	71	assert_se(bus_gvariant_get_size("s") < 0);
	72	assert_se(bus_gvariant_get_size("o") < 0);
	73	assert_se(bus_gvariant_get_size("g") < 0);
	74	assert_se(bus_gvariant_get_size("h") == 4);
	75	assert_se(bus_gvariant_get_size("ay") < 0);
	76	assert_se(bus_gvariant_get_size("v") < 0);
	77	assert_se(bus_gvariant_get_size("(u)") == 4);
	78	assert_se(bus_gvariant_get_size("(uuuuy)") == 20);
	79	assert_se(bus_gvariant_get_size("(uusuuy)") < 0);
	80	assert_se(bus_gvariant_get_size("a{ss}") < 0);
	81	assert_se(bus_gvariant_get_size("((u)yyy(b(iiii)))") == 28);
	82	assert_se(bus_gvariant_get_size("((u)yyy(b(iiivi)))") < 0);
	83	assert_se(bus_gvariant_get_size("((b)(t))") == 16);
	84	assert_se(bus_gvariant_get_size("((b)(b)(t))") == 16);
	85	assert_se(bus_gvariant_get_size("(bt)") == 16);
	86	assert_se(bus_gvariant_get_size("((t)(b))") == 16);
	87	assert_se(bus_gvariant_get_size("(tb)") == 16);
	88	assert_se(bus_gvariant_get_size("((b)(b))") == 2);
	89	assert_se(bus_gvariant_get_size("((t)(t))") == 16);
6647dc66 LP	90	}
6647dc66 LP	91
c1b9d935	92	static void test_bus_gvariant_get_alignment(void) {
0c0cdb06 RC	93	assert_se(bus_gvariant_get_alignment("") == 1);
	94	assert_se(bus_gvariant_get_alignment("()") == 1);
	95	assert_se(bus_gvariant_get_alignment("y") == 1);
	96	assert_se(bus_gvariant_get_alignment("b") == 1);
	97	assert_se(bus_gvariant_get_alignment("u") == 4);
	98	assert_se(bus_gvariant_get_alignment("s") == 1);
	99	assert_se(bus_gvariant_get_alignment("o") == 1);
	100	assert_se(bus_gvariant_get_alignment("g") == 1);
	101	assert_se(bus_gvariant_get_alignment("v") == 8);
	102	assert_se(bus_gvariant_get_alignment("h") == 4);
	103	assert_se(bus_gvariant_get_alignment("i") == 4);
	104	assert_se(bus_gvariant_get_alignment("t") == 8);
	105	assert_se(bus_gvariant_get_alignment("x") == 8);
	106	assert_se(bus_gvariant_get_alignment("q") == 2);
	107	assert_se(bus_gvariant_get_alignment("n") == 2);
	108	assert_se(bus_gvariant_get_alignment("d") == 8);
	109	assert_se(bus_gvariant_get_alignment("ay") == 1);
	110	assert_se(bus_gvariant_get_alignment("as") == 1);
	111	assert_se(bus_gvariant_get_alignment("au") == 4);
	112	assert_se(bus_gvariant_get_alignment("an") == 2);
	113	assert_se(bus_gvariant_get_alignment("ans") == 2);
	114	assert_se(bus_gvariant_get_alignment("ant") == 8);
	115	assert_se(bus_gvariant_get_alignment("(ss)") == 1);
	116	assert_se(bus_gvariant_get_alignment("(ssu)") == 4);
	117	assert_se(bus_gvariant_get_alignment("a(ssu)") == 4);
	118	assert_se(bus_gvariant_get_alignment("(u)") == 4);
	119	assert_se(bus_gvariant_get_alignment("(uuuuy)") == 4);
	120	assert_se(bus_gvariant_get_alignment("(uusuuy)") == 4);
	121	assert_se(bus_gvariant_get_alignment("a{ss}") == 1);
	122	assert_se(bus_gvariant_get_alignment("((u)yyy(b(iiii)))") == 4);
	123	assert_se(bus_gvariant_get_alignment("((u)yyy(b(iiivi)))") == 8);
	124	assert_se(bus_gvariant_get_alignment("((b)(t))") == 8);
	125	assert_se(bus_gvariant_get_alignment("((b)(b)(t))") == 8);
	126	assert_se(bus_gvariant_get_alignment("(bt)") == 8);
	127	assert_se(bus_gvariant_get_alignment("((t)(b))") == 8);
	128	assert_se(bus_gvariant_get_alignment("(tb)") == 8);
	129	assert_se(bus_gvariant_get_alignment("((b)(b))") == 1);
	130	assert_se(bus_gvariant_get_alignment("((t)(t))") == 8);
c1b9d935 LP	131	}
	132
	133	static void test_marshal(void) {
6647dc66	134	_cleanup_bus_message_unref_ sd_bus_message m = NULL, n = NULL;
954871d8	135	_cleanup_bus_unref_ sd_bus *bus = NULL;
6647dc66 LP	136	_cleanup_free_ void *blob;
6647dc66 LP	137	size_t sz;
2a0958d2 LP	138	int r;
	139
	140	r = sd_bus_open_system(&bus);
	141	if (r < 0)
	142	exit(EXIT_TEST_SKIP);
c1b9d935	143
ad67ef27	144	bus->message_version = 2; /* dirty hack to enable gvariant */
c1b9d935	145
151b9b96	146	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	147
c1b9d935	148	assert_se(sd_bus_message_append(m,
8f19720d	149	"a(usv)", 3,
c1b9d935	150	4711, "first-string-parameter", "(st)", "X", (uint64_t) 1111,
8f19720d LP	151	4712, "second-string-parameter", "(a(si))", 2, "Y", 5, "Z", 6,
8f19720d LP	152	4713, "third-string-parameter", "(uu)", 1, 2) >= 0);
c1b9d935	153
3df7a7e6	154	assert_se(bus_message_seal(m, 4711, 0) >= 0);
c1b9d935 LP	155
	156	#ifdef HAVE_GLIB
	157	{
	158	GVariant *v;
	159	char *t;
	160
	161	#if !defined(GLIB_VERSION_2_36)
	162	g_type_init();
	163	#endif
	164
954871d8	165	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);
c1b9d935 LP	166	t = g_variant_print(v, TRUE);
	167	printf("%s\n", t);
	168	g_free(t);
	169	g_variant_unref(v);
	170
954871d8	171	v = g_variant_new_from_data(G_VARIANT_TYPE("(a(usv))"), m->body.data, BUS_MESSAGE_BODY_SIZE(m), false, NULL, NULL);
c1b9d935 LP	172	t = g_variant_print(v, TRUE);
	173	printf("%s\n", t);
	174	g_free(t);
	175	g_variant_unref(v);
	176	}
	177	#endif
	178
d55192ad	179	assert_se(bus_message_dump(m, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0);
6647dc66 LP	180
	181	assert_se(bus_message_get_blob(m, &blob, &sz) >= 0);
	182
2a0958d2	183	assert_se(bus_message_from_malloc(bus, blob, sz, NULL, 0, NULL, NULL, &n) >= 0);
6647dc66 LP	184	blob = NULL;
6647dc66 LP	185
d55192ad	186	assert_se(bus_message_dump(n, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0);
5877dc5a LP	187
	188	m = sd_bus_message_unref(m);
	189
151b9b96	190	assert_se(sd_bus_message_new_method_call(bus, &m, "a.x", "/a/x", "a.x", "Ax") >= 0);
5877dc5a LP	191
	192	assert_se(sd_bus_message_append(m, "as", 0) >= 0);
	193
3df7a7e6	194	assert_se(bus_message_seal(m, 4712, 0) >= 0);
d55192ad	195	assert_se(bus_message_dump(m, NULL, BUS_MESSAGE_DUMP_WITH_HEADER) >= 0);
c1b9d935 LP	196	}
	197
	198	int main(int argc, char *argv[]) {
	199
	200	test_bus_gvariant_is_fixed_size();
6647dc66	201	test_bus_gvariant_get_size();
c1b9d935 LP	202	test_bus_gvariant_get_alignment();
	203	test_marshal();
	204
	205	return 0;
	206	}