[thirdparty/systemd.git] / src / libsystemd / sd-bus / test-bus-marshal.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/>.
***/

#include <assert.h>
#include <stdlib.h>
#include <byteswap.h>
#include <math.h>

#ifdef HAVE_GLIB
#include <gio/gio.h>
#endif

#ifdef HAVE_DBUS
#include <dbus/dbus.h>
#endif

#include "log.h"
#include "util.h"

#include "sd-bus.h"
#include "bus-message.h"
#include "bus-util.h"
#include "bus-dump.h"
#include "bus-label.h"

static void test_bus_path_encode(void) {
        _cleanup_free_ char *a = NULL, *b = NULL, *c = NULL, *d = NULL, *e = NULL, *f = NULL;

        assert_se(sd_bus_path_encode("/foo/bar", "waldo", &a) >= 0 && streq(a, "/foo/bar/waldo"));
        assert_se(sd_bus_path_decode(a, "/waldo", &b) == 0 && b == NULL);
        assert_se(sd_bus_path_decode(a, "/foo/bar", &b) > 0 && streq(b, "waldo"));

        assert_se(sd_bus_path_encode("xxxx", "waldo", &c) < 0);
        assert_se(sd_bus_path_encode("/foo/", "waldo", &c) < 0);

        assert_se(sd_bus_path_encode("/foo/bar", "", &c) >= 0 && streq(c, "/foo/bar/_"));
        assert_se(sd_bus_path_decode(c, "/foo/bar", &d) > 0 && streq(d, ""));

        assert_se(sd_bus_path_encode("/foo/bar", "foo.bar", &e) >= 0 && streq(e, "/foo/bar/foo_2ebar"));
        assert_se(sd_bus_path_decode(e, "/foo/bar", &f) > 0 && streq(f, "foo.bar"));
}

static void test_bus_label_escape_one(const char *a, const char *b) {
        _cleanup_free_ char *t = NULL, *x = NULL, *y = NULL;

        assert_se(t = bus_label_escape(a));
        assert_se(streq(t, b));

        assert_se(x = bus_label_unescape(t));
        assert_se(streq(a, x));

        assert_se(y = bus_label_unescape(b));
        assert_se(streq(a, y));
}

static void test_bus_label_escape(void) {
        test_bus_label_escape_one("foo123bar", "foo123bar");
        test_bus_label_escape_one("foo.bar", "foo_2ebar");
        test_bus_label_escape_one("foo_2ebar", "foo_5f2ebar");
        test_bus_label_escape_one("", "_");
        test_bus_label_escape_one("_", "_5f");
        test_bus_label_escape_one("1", "_31");
        test_bus_label_escape_one(":1", "_3a1");
}

int main(int argc, char *argv[]) {
        _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *copy = NULL;
        int r, boolean;
        const char *x, *x2, *y, *z, *a, *b, *c, *d, *a_signature;
        uint8_t u, v;
        void *buffer = NULL;
        size_t sz;
        char *h;
        const int32_t integer_array[] = { -1, -2, 0, 1, 2 }, *return_array;
        char *s;
        _cleanup_free_ char *first = NULL, *second = NULL, *third = NULL;
        _cleanup_fclose_ FILE *ms = NULL;
        size_t first_size = 0, second_size = 0, third_size = 0;
        _cleanup_bus_unref_ sd_bus *bus = NULL;
        double dbl;
        uint64_t u64;

        r = sd_bus_default_system(&bus);
        if (r < 0)
                return EXIT_TEST_SKIP;

        r = sd_bus_message_new_method_call(bus, &m, "foobar.waldo", "/", "foobar.waldo", "Piep");
        assert_se(r >= 0);

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

        r = sd_bus_message_append(m, "s", "a string");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "s", NULL);
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "asg", 2, "string #1", "string #2", "sba(tt)ss");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "sass", "foobar", 5, "foo", "bar", "waldo", "piep", "pap", "after");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "a{yv}", 2, 3, "s", "foo", 5, "s", "waldo");
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3");
        assert_se(r >= 0);

        r = sd_bus_message_open_container(m, 'a', "s");
        assert_se(r >= 0);

        r = sd_bus_message_append_basic(m, 's', "foobar");
        assert_se(r >= 0);

        r = sd_bus_message_append_basic(m, 's', "waldo");
        assert_se(r >= 0);

        r = sd_bus_message_close_container(m);
        assert_se(r >= 0);

        r = sd_bus_message_append_string_space(m, 5, &s);
        assert_se(r >= 0);
        strcpy(s, "hallo");

        r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array));
        assert_se(r >= 0);

        r = sd_bus_message_append_array(m, 'u', NULL, 0);
        assert_se(r >= 0);

        r = sd_bus_message_append(m, "a(stdo)", 1, "foo", 815ULL, 47.0, "/");
        assert_se(r >= 0);

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

        bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);

        ms = open_memstream(&first, &first_size);
        bus_message_dump(m, ms, 0);
        fflush(ms);
        assert_se(!ferror(ms));

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

        h = hexmem(buffer, sz);
        assert_se(h);

        log_info("message size = %zu, contents =\n%s", sz, h);
        free(h);

#ifdef HAVE_GLIB
        {
                GDBusMessage *g;
                char *p;

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

                g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL);
                p = g_dbus_message_print(g, 0);
                log_info("%s", p);
                g_free(p);
                g_object_unref(g);
        }
#endif

#ifdef HAVE_DBUS
        {
                DBusMessage *w;
                DBusError error;

                dbus_error_init(&error);

                w = dbus_message_demarshal(buffer, sz, &error);
                if (!w)
                        log_error("%s", error.message);
                else
                        dbus_message_unref(w);
        }
#endif

        m = sd_bus_message_unref(m);

        r = bus_message_from_malloc(bus, buffer, sz, NULL, 0, NULL, NULL, &m);
        assert_se(r >= 0);

        bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);

        fclose(ms);
        ms = open_memstream(&second, &second_size);
        bus_message_dump(m, ms, 0);
        fflush(ms);
        assert_se(!ferror(ms));
        assert_se(first_size == second_size);
        assert_se(memcmp(first, second, first_size) == 0);

        assert_se(sd_bus_message_rewind(m, true) >= 0);

        r = sd_bus_message_read(m, "ssasg", &x, &x2, 2, &y, &z, &a_signature);
        assert_se(r > 0);
        assert_se(streq(x, "a string"));
        assert_se(streq(x2, ""));
        assert_se(streq(y, "string #1"));
        assert_se(streq(z, "string #2"));
        assert_se(streq(a_signature, "sba(tt)ss"));

        r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d);
        assert_se(r > 0);
        assert_se(streq(x, "foobar"));
        assert_se(streq(y, "foo"));
        assert_se(streq(z, "bar"));
        assert_se(streq(a, "waldo"));
        assert_se(streq(b, "piep"));
        assert_se(streq(c, "pap"));
        assert_se(streq(d, "after"));

        r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y);
        assert_se(r > 0);
        assert_se(u == 3);
        assert_se(streq(x, "foo"));
        assert_se(v == 5);
        assert_se(streq(y, "waldo"));

        r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d);
        assert_se(r > 0);
        assert_se(boolean);
        assert_se(streq(x, "aaa"));
        assert_se(streq(y, "1"));
        assert_se(streq(a, "bbb"));
        assert_se(streq(b, "2"));
        assert_se(streq(c, "ccc"));
        assert_se(streq(d, "3"));

        assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0);

        r = sd_bus_message_read(m, "as", 2, &x, &y);
        assert_se(r > 0);
        assert_se(streq(x, "foobar"));
        assert_se(streq(y, "waldo"));

        r = sd_bus_message_read_basic(m, 's', &s);
        assert_se(r > 0);
        assert_se(streq(s, "hallo"));

        r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz);
        assert_se(r > 0);
        assert_se(sz == sizeof(integer_array));
        assert_se(memcmp(integer_array, return_array, sz) == 0);

        r = sd_bus_message_read_array(m, 'u', (const void**) &return_array, &sz);
        assert_se(r > 0);
        assert_se(sz == 0);

        r = sd_bus_message_read(m, "a(stdo)", 1, &x, &u64, &dbl, &y);
        assert_se(r > 0);
        assert_se(streq(x, "foo"));
        assert_se(u64 == 815ULL);
        assert_se(fabs(dbl - 47.0) < 0.1);
        assert_se(streq(y, "/"));

        r = sd_bus_message_peek_type(m, NULL, NULL);
        assert_se(r == 0);

        r = sd_bus_message_new_method_call(bus, &copy, "foobar.waldo", "/", "foobar.waldo", "Piep");
        assert_se(r >= 0);

        r = sd_bus_message_rewind(m, true);
        assert_se(r >= 0);

        r = sd_bus_message_copy(copy, m, true);
        assert_se(r >= 0);

        r = bus_message_seal(copy, 4712, 0);
        assert_se(r >= 0);

        fclose(ms);
        ms = open_memstream(&third, &third_size);
        bus_message_dump(copy, ms, 0);
        fflush(ms);
        assert_se(!ferror(ms));

        printf("<%.*s>\n", (int) first_size, first);
        printf("<%.*s>\n", (int) third_size, third);

        assert_se(first_size == third_size);
        assert_se(memcmp(first, third, third_size) == 0);

        r = sd_bus_message_rewind(m, true);
        assert_se(r >= 0);

        assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);

        r = sd_bus_message_skip(m, "ssasg");
        assert_se(r > 0);

        assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);

        r = sd_bus_message_skip(m, "sass");
        assert_se(r >= 0);

        assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0);

        r = sd_bus_message_skip(m, "a{yv}");
        assert_se(r >= 0);

        assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0);

        r = sd_bus_message_read(m, "b", &boolean);
        assert_se(r > 0);
        assert_se(boolean);

        r = sd_bus_message_enter_container(m, 0, NULL);
        assert_se(r > 0);

        r = sd_bus_message_read(m, "(ss)", &x, &y);
        assert_se(r > 0);

        r = sd_bus_message_read(m, "(ss)", &a, &b);
        assert_se(r > 0);

        r = sd_bus_message_read(m, "(ss)", &c, &d);
        assert_se(r > 0);

        r = sd_bus_message_read(m, "(ss)", &x, &y);
        assert_se(r == 0);

        r = sd_bus_message_exit_container(m);
        assert_se(r >= 0);

        assert_se(streq(x, "aaa"));
        assert_se(streq(y, "1"));
        assert_se(streq(a, "bbb"));
        assert_se(streq(b, "2"));
        assert_se(streq(c, "ccc"));
        assert_se(streq(d, "3"));

        test_bus_label_escape();
        test_bus_path_encode();

        return 0;
}
Commit	Line	Data
de1c301e 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	#include <assert.h>
	23	#include <stdlib.h>
	24	#include <byteswap.h>
6cd37a5e	25	#include <math.h>
de1c301e LP	26
	27	#ifdef HAVE_GLIB
	28	#include <gio/gio.h>
	29	#endif
	30
22703094	31	#ifdef HAVE_DBUS
718db961	32	#include <dbus/dbus.h>
22703094	33	#endif
de1c301e LP	34
	35	#include "log.h"
	36	#include "util.h"
	37
	38	#include "sd-bus.h"
	39	#include "bus-message.h"
40ca29a1	40	#include "bus-util.h"
2b5c5383	41	#include "bus-dump.h"
a6278b88 LP	42	#include "bus-label.h"
	43
	44	static void test_bus_path_encode(void) {
	45	_cleanup_free_ char a = NULL, b = NULL, c = NULL, d = NULL, e = NULL, f = NULL;
	46
	47	assert_se(sd_bus_path_encode("/foo/bar", "waldo", &a) >= 0 && streq(a, "/foo/bar/waldo"));
	48	assert_se(sd_bus_path_decode(a, "/waldo", &b) == 0 && b == NULL);
	49	assert_se(sd_bus_path_decode(a, "/foo/bar", &b) > 0 && streq(b, "waldo"));
	50
	51	assert_se(sd_bus_path_encode("xxxx", "waldo", &c) < 0);
	52	assert_se(sd_bus_path_encode("/foo/", "waldo", &c) < 0);
	53
	54	assert_se(sd_bus_path_encode("/foo/bar", "", &c) >= 0 && streq(c, "/foo/bar/_"));
	55	assert_se(sd_bus_path_decode(c, "/foo/bar", &d) > 0 && streq(d, ""));
	56
	57	assert_se(sd_bus_path_encode("/foo/bar", "foo.bar", &e) >= 0 && streq(e, "/foo/bar/foo_2ebar"));
	58	assert_se(sd_bus_path_decode(e, "/foo/bar", &f) > 0 && streq(f, "foo.bar"));
	59	}
de1c301e	60
28383ba1 LP	61	static void test_bus_label_escape_one(const char a, const char b) {
	62	_cleanup_free_ char t = NULL, x = NULL, *y = NULL;
	63
a6278b88	64	assert_se(t = bus_label_escape(a));
28383ba1 LP	65	assert_se(streq(t, b));
28383ba1 LP	66
a6278b88	67	assert_se(x = bus_label_unescape(t));
28383ba1 LP	68	assert_se(streq(a, x));
28383ba1 LP	69
a6278b88	70	assert_se(y = bus_label_unescape(b));
28383ba1 LP	71	assert_se(streq(a, y));
	72	}
	73
	74	static void test_bus_label_escape(void) {
	75	test_bus_label_escape_one("foo123bar", "foo123bar");
	76	test_bus_label_escape_one("foo.bar", "foo_2ebar");
	77	test_bus_label_escape_one("foo_2ebar", "foo_5f2ebar");
	78	test_bus_label_escape_one("", "_");
	79	test_bus_label_escape_one("_", "_5f");
	80	test_bus_label_escape_one("1", "_31");
	81	test_bus_label_escape_one(":1", "_3a1");
	82	}
	83
de1c301e	84	int main(int argc, char *argv[]) {
c430fee6	85	_cleanup_bus_message_unref_ sd_bus_message m = NULL, copy = NULL;
9a17484d	86	int r, boolean;
d44fdf49	87	const char x, x2, y, z, a, b, c, d, *a_signature;
de1c301e LP	88	uint8_t u, v;
	89	void *buffer = NULL;
	90	size_t sz;
	91	char *h;
b3af9646	92	const int32_t integer_array[] = { -1, -2, 0, 1, 2 }, *return_array;
f8e013f8	93	char *s;
c430fee6 LP	94	_cleanup_free_ char first = NULL, second = NULL, *third = NULL;
	95	_cleanup_fclose_ FILE *ms = NULL;
	96	size_t first_size = 0, second_size = 0, third_size = 0;
2a0958d2	97	_cleanup_bus_unref_ sd_bus *bus = NULL;
6cd37a5e LP	98	double dbl;
6cd37a5e LP	99	uint64_t u64;
de1c301e	100
2a0958d2 LP	101	r = sd_bus_default_system(&bus);
	102	if (r < 0)
	103	return EXIT_TEST_SKIP;
	104
	105	r = sd_bus_message_new_method_call(bus, &m, "foobar.waldo", "/", "foobar.waldo", "Piep");
de1c301e LP	106	assert_se(r >= 0);
de1c301e LP	107
effbc8e4 ZJS	108	r = sd_bus_message_append(m, "");
	109	assert_se(r >= 0);
	110
de1c301e LP	111	r = sd_bus_message_append(m, "s", "a string");
	112	assert_se(r >= 0);
	113
b8beb278	114	r = sd_bus_message_append(m, "s", NULL);
15912917	115	assert_se(r >= 0);
b8beb278	116
d44fdf49	117	r = sd_bus_message_append(m, "asg", 2, "string #1", "string #2", "sba(tt)ss");
de1c301e LP	118	assert_se(r >= 0);
	119
	120	r = sd_bus_message_append(m, "sass", "foobar", 5, "foo", "bar", "waldo", "piep", "pap", "after");
	121	assert_se(r >= 0);
	122
	123	r = sd_bus_message_append(m, "a{yv}", 2, 3, "s", "foo", 5, "s", "waldo");
	124	assert_se(r >= 0);
	125
	126	r = sd_bus_message_append(m, "ba(ss)", 255, 3, "aaa", "1", "bbb", "2", "ccc", "3");
	127	assert_se(r >= 0);
	128
	129	r = sd_bus_message_open_container(m, 'a', "s");
	130	assert_se(r >= 0);
	131
	132	r = sd_bus_message_append_basic(m, 's', "foobar");
	133	assert_se(r >= 0);
	134
	135	r = sd_bus_message_append_basic(m, 's', "waldo");
	136	assert_se(r >= 0);
	137
	138	r = sd_bus_message_close_container(m);
	139	assert_se(r >= 0);
	140
f8e013f8 LP	141	r = sd_bus_message_append_string_space(m, 5, &s);
	142	assert_se(r >= 0);
	143	strcpy(s, "hallo");
	144
b3af9646 LP	145	r = sd_bus_message_append_array(m, 'i', integer_array, sizeof(integer_array));
	146	assert_se(r >= 0);
	147
5e86fd7b LP	148	r = sd_bus_message_append_array(m, 'u', NULL, 0);
	149	assert_se(r >= 0);
	150
6cd37a5e LP	151	r = sd_bus_message_append(m, "a(stdo)", 1, "foo", 815ULL, 47.0, "/");
	152	assert_se(r >= 0);
	153
3df7a7e6	154	r = bus_message_seal(m, 4711, 0);
de1c301e LP	155	assert_se(r >= 0);
de1c301e LP	156
d55192ad	157	bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
c430fee6 LP	158
c430fee6 LP	159	ms = open_memstream(&first, &first_size);
d55192ad	160	bus_message_dump(m, ms, 0);
c430fee6 LP	161	fflush(ms);
c430fee6 LP	162	assert_se(!ferror(ms));
de1c301e LP	163
	164	r = bus_message_get_blob(m, &buffer, &sz);
	165	assert_se(r >= 0);
	166
	167	h = hexmem(buffer, sz);
	168	assert_se(h);
	169
de0671ee	170	log_info("message size = %zu, contents =\n%s", sz, h);
de1c301e LP	171	free(h);
	172
	173	#ifdef HAVE_GLIB
	174	{
	175	GDBusMessage *g;
	176	char *p;
	177
34f856cb	178	#if !defined(GLIB_VERSION_2_36)
de1c301e	179	g_type_init();
34f856cb	180	#endif
de1c301e LP	181
	182	g = g_dbus_message_new_from_blob(buffer, sz, 0, NULL);
	183	p = g_dbus_message_print(g, 0);
	184	log_info("%s", p);
	185	g_free(p);
	186	g_object_unref(g);
	187	}
	188	#endif
	189
22703094	190	#ifdef HAVE_DBUS
de1c301e LP	191	{
	192	DBusMessage *w;
	193	DBusError error;
	194
	195	dbus_error_init(&error);
	196
	197	w = dbus_message_demarshal(buffer, sz, &error);
c1b9d935	198	if (!w)
de1c301e	199	log_error("%s", error.message);
c1b9d935	200	else
de1c301e LP	201	dbus_message_unref(w);
de1c301e LP	202	}
22703094	203	#endif
de1c301e	204
80a46c73 LP	205	m = sd_bus_message_unref(m);
80a46c73 LP	206
2a0958d2	207	r = bus_message_from_malloc(bus, buffer, sz, NULL, 0, NULL, NULL, &m);
80a46c73 LP	208	assert_se(r >= 0);
80a46c73 LP	209
d55192ad	210	bus_message_dump(m, stdout, BUS_MESSAGE_DUMP_WITH_HEADER);
c430fee6 LP	211
	212	fclose(ms);
	213	ms = open_memstream(&second, &second_size);
d55192ad	214	bus_message_dump(m, ms, 0);
c430fee6 LP	215	fflush(ms);
	216	assert_se(!ferror(ms));
	217	assert_se(first_size == second_size);
	218	assert_se(memcmp(first, second, first_size) == 0);
de1c301e	219
9a17484d LP	220	assert_se(sd_bus_message_rewind(m, true) >= 0);
9a17484d LP	221
d44fdf49	222	r = sd_bus_message_read(m, "ssasg", &x, &x2, 2, &y, &z, &a_signature);
9a17484d LP	223	assert_se(r > 0);
9a17484d LP	224	assert_se(streq(x, "a string"));
15912917	225	assert_se(streq(x2, ""));
9a17484d LP	226	assert_se(streq(y, "string #1"));
9a17484d LP	227	assert_se(streq(z, "string #2"));
d44fdf49	228	assert_se(streq(a_signature, "sba(tt)ss"));
9a17484d LP	229
	230	r = sd_bus_message_read(m, "sass", &x, 5, &y, &z, &a, &b, &c, &d);
	231	assert_se(r > 0);
	232	assert_se(streq(x, "foobar"));
	233	assert_se(streq(y, "foo"));
	234	assert_se(streq(z, "bar"));
	235	assert_se(streq(a, "waldo"));
	236	assert_se(streq(b, "piep"));
	237	assert_se(streq(c, "pap"));
	238	assert_se(streq(d, "after"));
	239
	240	r = sd_bus_message_read(m, "a{yv}", 2, &u, "s", &x, &v, "s", &y);
	241	assert_se(r > 0);
	242	assert_se(u == 3);
	243	assert_se(streq(x, "foo"));
	244	assert_se(v == 5);
	245	assert_se(streq(y, "waldo"));
	246
	247	r = sd_bus_message_read(m, "ba(ss)", &boolean, 3, &x, &y, &a, &b, &c, &d);
	248	assert_se(r > 0);
	249	assert_se(boolean);
	250	assert_se(streq(x, "aaa"));
	251	assert_se(streq(y, "1"));
	252	assert_se(streq(a, "bbb"));
	253	assert_se(streq(b, "2"));
	254	assert_se(streq(c, "ccc"));
	255	assert_se(streq(d, "3"));
	256
c430fee6 LP	257	assert_se(sd_bus_message_verify_type(m, 'a', "s") > 0);
c430fee6 LP	258
9a17484d LP	259	r = sd_bus_message_read(m, "as", 2, &x, &y);
	260	assert_se(r > 0);
	261	assert_se(streq(x, "foobar"));
	262	assert_se(streq(y, "waldo"));
	263
f8e013f8 LP	264	r = sd_bus_message_read_basic(m, 's', &s);
	265	assert_se(r > 0);
	266	assert_se(streq(s, "hallo"));
	267
b3af9646 LP	268	r = sd_bus_message_read_array(m, 'i', (const void**) &return_array, &sz);
	269	assert_se(r > 0);
	270	assert_se(sz == sizeof(integer_array));
	271	assert_se(memcmp(integer_array, return_array, sz) == 0);
	272
5e86fd7b LP	273	r = sd_bus_message_read_array(m, 'u', (const void**) &return_array, &sz);
	274	assert_se(r > 0);
	275	assert_se(sz == 0);
	276
6cd37a5e LP	277	r = sd_bus_message_read(m, "a(stdo)", 1, &x, &u64, &dbl, &y);
	278	assert_se(r > 0);
	279	assert_se(streq(x, "foo"));
	280	assert_se(u64 == 815ULL);
	281	assert_se(fabs(dbl - 47.0) < 0.1);
	282	assert_se(streq(y, "/"));
	283
9a17484d LP	284	r = sd_bus_message_peek_type(m, NULL, NULL);
9a17484d LP	285	assert_se(r == 0);
de1c301e	286
2a0958d2	287	r = sd_bus_message_new_method_call(bus, &copy, "foobar.waldo", "/", "foobar.waldo", "Piep");
c430fee6 LP	288	assert_se(r >= 0);
	289
	290	r = sd_bus_message_rewind(m, true);
	291	assert_se(r >= 0);
	292
	293	r = sd_bus_message_copy(copy, m, true);
	294	assert_se(r >= 0);
	295
3df7a7e6	296	r = bus_message_seal(copy, 4712, 0);
c430fee6 LP	297	assert_se(r >= 0);
	298
	299	fclose(ms);
	300	ms = open_memstream(&third, &third_size);
d55192ad	301	bus_message_dump(copy, ms, 0);
c430fee6 LP	302	fflush(ms);
	303	assert_se(!ferror(ms));
	304
9b55cd56 ZJS	305	printf("<%.*s>\n", (int) first_size, first);
9b55cd56 ZJS	306	printf("<%.*s>\n", (int) third_size, third);
c430fee6 LP	307
	308	assert_se(first_size == third_size);
	309	assert_se(memcmp(first, third, third_size) == 0);
	310
9b07511d LP	311	r = sd_bus_message_rewind(m, true);
	312	assert_se(r >= 0);
	313
	314	assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
	315
d44fdf49	316	r = sd_bus_message_skip(m, "ssasg");
9b07511d LP	317	assert_se(r > 0);
	318
	319	assert_se(sd_bus_message_verify_type(m, 's', NULL) > 0);
	320
	321	r = sd_bus_message_skip(m, "sass");
	322	assert_se(r >= 0);
	323
	324	assert_se(sd_bus_message_verify_type(m, 'a', "{yv}") > 0);
	325
	326	r = sd_bus_message_skip(m, "a{yv}");
	327	assert_se(r >= 0);
	328
	329	assert_se(sd_bus_message_verify_type(m, 'b', NULL) > 0);
	330
275b39fe	331	r = sd_bus_message_read(m, "b", &boolean);
9b07511d LP	332	assert_se(r > 0);
9b07511d LP	333	assert_se(boolean);
275b39fe LP	334
	335	r = sd_bus_message_enter_container(m, 0, NULL);
	336	assert_se(r > 0);
	337
	338	r = sd_bus_message_read(m, "(ss)", &x, &y);
	339	assert_se(r > 0);
	340
	341	r = sd_bus_message_read(m, "(ss)", &a, &b);
	342	assert_se(r > 0);
	343
	344	r = sd_bus_message_read(m, "(ss)", &c, &d);
	345	assert_se(r > 0);
	346
	347	r = sd_bus_message_read(m, "(ss)", &x, &y);
	348	assert_se(r == 0);
	349
	350	r = sd_bus_message_exit_container(m);
	351	assert_se(r >= 0);
	352
9b07511d LP	353	assert_se(streq(x, "aaa"));
	354	assert_se(streq(y, "1"));
	355	assert_se(streq(a, "bbb"));
	356	assert_se(streq(b, "2"));
	357	assert_se(streq(c, "ccc"));
	358	assert_se(streq(d, "3"));
	359
28383ba1	360	test_bus_label_escape();
a6278b88	361	test_bus_path_encode();
28383ba1	362
de1c301e LP	363	return 0;
de1c301e LP	364	}