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

/* SPDX-License-Identifier: LGPL-2.1+ */

#include "sd-bus.h"

#include "bus-common-errors.h"
#include "bus-error.h"
#include "bus-util.h"
#include "errno-list.h"

static void test_error(void) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL, second = SD_BUS_ERROR_NULL;
        const sd_bus_error const_error = SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FILE_EXISTS, "const error");
        const sd_bus_error temporarily_const_error = {
                .name = SD_BUS_ERROR_ACCESS_DENIED,
                .message = "oh! no",
                ._need_free = -1
        };

        assert_se(!sd_bus_error_is_set(&error));
        assert_se(sd_bus_error_set(&error, SD_BUS_ERROR_NOT_SUPPORTED, "xxx") == -EOPNOTSUPP);
        assert_se(streq(error.name, SD_BUS_ERROR_NOT_SUPPORTED));
        assert_se(streq(error.message, "xxx"));
        assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
        assert_se(sd_bus_error_get_errno(&error) == EOPNOTSUPP);
        assert_se(sd_bus_error_is_set(&error));
        sd_bus_error_free(&error);

        /* Check with no error */
        assert_se(!sd_bus_error_is_set(&error));
        assert_se(sd_bus_error_setf(&error, NULL, "yyy %i", -1) == 0);
        assert_se(error.name == NULL);
        assert_se(error.message == NULL);
        assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
        assert_se(sd_bus_error_get_errno(&error) == 0);
        assert_se(!sd_bus_error_is_set(&error));

        assert_se(sd_bus_error_setf(&error, SD_BUS_ERROR_FILE_NOT_FOUND, "yyy %i", -1) == -ENOENT);
        assert_se(streq(error.name, SD_BUS_ERROR_FILE_NOT_FOUND));
        assert_se(streq(error.message, "yyy -1"));
        assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
        assert_se(sd_bus_error_get_errno(&error) == ENOENT);
        assert_se(sd_bus_error_is_set(&error));

        assert_se(!sd_bus_error_is_set(&second));
        assert_se(second._need_free == 0);
        assert_se(error._need_free > 0);
        assert_se(sd_bus_error_copy(&second, &error) == -ENOENT);
        assert_se(second._need_free > 0);
        assert_se(streq(error.name, second.name));
        assert_se(streq(error.message, second.message));
        assert_se(sd_bus_error_get_errno(&second) == ENOENT);
        assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_NOT_FOUND));
        assert_se(sd_bus_error_is_set(&second));

        sd_bus_error_free(&error);
        sd_bus_error_free(&second);

        assert_se(!sd_bus_error_is_set(&second));
        assert_se(const_error._need_free == 0);
        assert_se(sd_bus_error_copy(&second, &const_error) == -EEXIST);
        assert_se(second._need_free == 0);
        assert_se(streq(const_error.name, second.name));
        assert_se(streq(const_error.message, second.message));
        assert_se(sd_bus_error_get_errno(&second) == EEXIST);
        assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_EXISTS));
        assert_se(sd_bus_error_is_set(&second));
        sd_bus_error_free(&second);

        assert_se(!sd_bus_error_is_set(&second));
        assert_se(temporarily_const_error._need_free < 0);
        assert_se(sd_bus_error_copy(&second, &temporarily_const_error) == -EACCES);
        assert_se(second._need_free > 0);
        assert_se(streq(temporarily_const_error.name, second.name));
        assert_se(streq(temporarily_const_error.message, second.message));
        assert_se(sd_bus_error_get_errno(&second) == EACCES);
        assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_ACCESS_DENIED));
        assert_se(sd_bus_error_is_set(&second));

        assert_se(!sd_bus_error_is_set(&error));
        assert_se(sd_bus_error_set_const(&error, "System.Error.EUCLEAN", "Hallo") == -EUCLEAN);
        assert_se(streq(error.name, "System.Error.EUCLEAN"));
        assert_se(streq(error.message, "Hallo"));
        assert_se(sd_bus_error_has_name(&error, "System.Error.EUCLEAN"));
        assert_se(sd_bus_error_get_errno(&error) == EUCLEAN);
        assert_se(sd_bus_error_is_set(&error));
        sd_bus_error_free(&error);

        assert_se(!sd_bus_error_is_set(&error));
        assert_se(sd_bus_error_set_errno(&error, EBUSY) == -EBUSY);
        assert_se(streq(error.name, "System.Error.EBUSY"));
        assert_se(streq(error.message, strerror(EBUSY)));
        assert_se(sd_bus_error_has_name(&error, "System.Error.EBUSY"));
        assert_se(sd_bus_error_get_errno(&error) == EBUSY);
        assert_se(sd_bus_error_is_set(&error));
        sd_bus_error_free(&error);

        assert_se(!sd_bus_error_is_set(&error));
        assert_se(sd_bus_error_set_errnof(&error, EIO, "Waldi %c", 'X') == -EIO);
        assert_se(streq(error.name, SD_BUS_ERROR_IO_ERROR));
        assert_se(streq(error.message, "Waldi X"));
        assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
        assert_se(sd_bus_error_get_errno(&error) == EIO);
        assert_se(sd_bus_error_is_set(&error));
        sd_bus_error_free(&error);

        /* Check with no error */
        assert_se(!sd_bus_error_is_set(&error));
        assert_se(sd_bus_error_set_errnof(&error, 0, "Waldi %c", 'X') == 0);
        assert_se(error.name == NULL);
        assert_se(error.message == NULL);
        assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
        assert_se(sd_bus_error_get_errno(&error) == 0);
        assert_se(!sd_bus_error_is_set(&error));
}

extern const sd_bus_error_map __start_SYSTEMD_BUS_ERROR_MAP[];
extern const sd_bus_error_map __stop_SYSTEMD_BUS_ERROR_MAP[];

static void dump_mapping_table(void) {
        const sd_bus_error_map *m;

        printf("----- errno mappings ------\n");
        m = ALIGN_TO_PTR(__start_SYSTEMD_BUS_ERROR_MAP, sizeof(void*));
        while (m < __stop_SYSTEMD_BUS_ERROR_MAP) {

                if (m->code == BUS_ERROR_MAP_END_MARKER) {
                        m = ALIGN_TO_PTR(m + 1, sizeof(void*));
                        continue;
                }

                printf("%s -> %i/%s\n", strna(m->name), m->code, strna(errno_to_name(m->code)));
                m++;
        }
        printf("---------------------------\n");
}

static void test_errno_mapping_standard(void) {
        assert_se(sd_bus_error_set(NULL, "System.Error.EUCLEAN", NULL) == -EUCLEAN);
        assert_se(sd_bus_error_set(NULL, "System.Error.EBUSY", NULL) == -EBUSY);
        assert_se(sd_bus_error_set(NULL, "System.Error.EINVAL", NULL) == -EINVAL);
        assert_se(sd_bus_error_set(NULL, "System.Error.WHATSIT", NULL) == -EIO);
}

BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors[] = {
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error", 5),
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-2", 52),
        SD_BUS_ERROR_MAP_END
};

BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors2[] = {
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-3", 33),
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-4", 44),
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-33", 333),
        SD_BUS_ERROR_MAP_END
};

static const sd_bus_error_map test_errors3[] = {
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-88", 888),
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-99", 999),
        SD_BUS_ERROR_MAP_END
};

static const sd_bus_error_map test_errors4[] = {
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-77", 777),
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-78", 778),
        SD_BUS_ERROR_MAP_END
};

static const sd_bus_error_map test_errors_bad1[] = {
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", 0),
        SD_BUS_ERROR_MAP_END
};

static const sd_bus_error_map test_errors_bad2[] = {
        SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", -1),
        SD_BUS_ERROR_MAP_END
};

static void test_errno_mapping_custom(void) {
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error", NULL) == -5);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-x", NULL) == -EIO);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-33", NULL) == -333);

        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -EIO);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -EIO);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -EIO);

        assert_se(sd_bus_error_add_map(test_errors3) > 0);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -888);
        assert_se(sd_bus_error_add_map(test_errors4) > 0);
        assert_se(sd_bus_error_add_map(test_errors4) == 0);
        assert_se(sd_bus_error_add_map(test_errors3) == 0);

        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -999);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -777);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-78", NULL) == -778);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
        assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-y", NULL) == -EIO);

        assert_se(sd_bus_error_set(NULL, BUS_ERROR_NO_SUCH_UNIT, NULL) == -ENOENT);

        assert_se(sd_bus_error_add_map(test_errors_bad1) == -EINVAL);
        assert_se(sd_bus_error_add_map(test_errors_bad2) == -EINVAL);
}

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

        test_error();
        test_errno_mapping_standard();
        test_errno_mapping_custom();

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
780896a4 LP	2
780896a4 LP	3	#include "sd-bus.h"
cf0fbc49 TA	4
cf0fbc49 TA	5	#include "bus-common-errors.h"
057171ef	6	#include "bus-error.h"
780896a4	7	#include "bus-util.h"
5f86c1f4	8	#include "errno-list.h"
780896a4	9
4a0a7417	10	static void test_error(void) {
4afd3348	11	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL, second = SD_BUS_ERROR_NULL;
79f8d3d2 LP	12	const sd_bus_error const_error = SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FILE_EXISTS, "const error");
	13	const sd_bus_error temporarily_const_error = {
	14	.name = SD_BUS_ERROR_ACCESS_DENIED,
	15	.message = "oh! no",
	16	._need_free = -1
	17	};
780896a4 LP	18
780896a4 LP	19	assert_se(!sd_bus_error_is_set(&error));
15411c0c	20	assert_se(sd_bus_error_set(&error, SD_BUS_ERROR_NOT_SUPPORTED, "xxx") == -EOPNOTSUPP);
780896a4 LP	21	assert_se(streq(error.name, SD_BUS_ERROR_NOT_SUPPORTED));
	22	assert_se(streq(error.message, "xxx"));
	23	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
15411c0c	24	assert_se(sd_bus_error_get_errno(&error) == EOPNOTSUPP);
780896a4 LP	25	assert_se(sd_bus_error_is_set(&error));
	26	sd_bus_error_free(&error);
	27
5cb06d0c	28	/* Check with no error */
780896a4	29	assert_se(!sd_bus_error_is_set(&error));
5cb06d0c ZJS	30	assert_se(sd_bus_error_setf(&error, NULL, "yyy %i", -1) == 0);
	31	assert_se(error.name == NULL);
	32	assert_se(error.message == NULL);
	33	assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
	34	assert_se(sd_bus_error_get_errno(&error) == 0);
	35	assert_se(!sd_bus_error_is_set(&error));
	36
780896a4 LP	37	assert_se(sd_bus_error_setf(&error, SD_BUS_ERROR_FILE_NOT_FOUND, "yyy %i", -1) == -ENOENT);
	38	assert_se(streq(error.name, SD_BUS_ERROR_FILE_NOT_FOUND));
	39	assert_se(streq(error.message, "yyy -1"));
	40	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
	41	assert_se(sd_bus_error_get_errno(&error) == ENOENT);
	42	assert_se(sd_bus_error_is_set(&error));
	43
	44	assert_se(!sd_bus_error_is_set(&second));
79f8d3d2 LP	45	assert_se(second._need_free == 0);
79f8d3d2 LP	46	assert_se(error._need_free > 0);
780896a4	47	assert_se(sd_bus_error_copy(&second, &error) == -ENOENT);
79f8d3d2	48	assert_se(second._need_free > 0);
780896a4 LP	49	assert_se(streq(error.name, second.name));
	50	assert_se(streq(error.message, second.message));
	51	assert_se(sd_bus_error_get_errno(&second) == ENOENT);
	52	assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_NOT_FOUND));
	53	assert_se(sd_bus_error_is_set(&second));
	54
	55	sd_bus_error_free(&error);
79f8d3d2 LP	56	sd_bus_error_free(&second);
	57
	58	assert_se(!sd_bus_error_is_set(&second));
	59	assert_se(const_error._need_free == 0);
	60	assert_se(sd_bus_error_copy(&second, &const_error) == -EEXIST);
	61	assert_se(second._need_free == 0);
	62	assert_se(streq(const_error.name, second.name));
	63	assert_se(streq(const_error.message, second.message));
	64	assert_se(sd_bus_error_get_errno(&second) == EEXIST);
	65	assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_EXISTS));
	66	assert_se(sd_bus_error_is_set(&second));
	67	sd_bus_error_free(&second);
	68
	69	assert_se(!sd_bus_error_is_set(&second));
	70	assert_se(temporarily_const_error._need_free < 0);
	71	assert_se(sd_bus_error_copy(&second, &temporarily_const_error) == -EACCES);
	72	assert_se(second._need_free > 0);
	73	assert_se(streq(temporarily_const_error.name, second.name));
	74	assert_se(streq(temporarily_const_error.message, second.message));
	75	assert_se(sd_bus_error_get_errno(&second) == EACCES);
	76	assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_ACCESS_DENIED));
	77	assert_se(sd_bus_error_is_set(&second));
780896a4 LP	78
780896a4 LP	79	assert_se(!sd_bus_error_is_set(&error));
763e20e6 LP	80	assert_se(sd_bus_error_set_const(&error, "System.Error.EUCLEAN", "Hallo") == -EUCLEAN);
763e20e6 LP	81	assert_se(streq(error.name, "System.Error.EUCLEAN"));
780896a4	82	assert_se(streq(error.message, "Hallo"));
763e20e6	83	assert_se(sd_bus_error_has_name(&error, "System.Error.EUCLEAN"));
780896a4 LP	84	assert_se(sd_bus_error_get_errno(&error) == EUCLEAN);
	85	assert_se(sd_bus_error_is_set(&error));
	86	sd_bus_error_free(&error);
	87
	88	assert_se(!sd_bus_error_is_set(&error));
	89	assert_se(sd_bus_error_set_errno(&error, EBUSY) == -EBUSY);
763e20e6	90	assert_se(streq(error.name, "System.Error.EBUSY"));
780896a4	91	assert_se(streq(error.message, strerror(EBUSY)));
763e20e6	92	assert_se(sd_bus_error_has_name(&error, "System.Error.EBUSY"));
780896a4 LP	93	assert_se(sd_bus_error_get_errno(&error) == EBUSY);
	94	assert_se(sd_bus_error_is_set(&error));
	95	sd_bus_error_free(&error);
	96
	97	assert_se(!sd_bus_error_is_set(&error));
	98	assert_se(sd_bus_error_set_errnof(&error, EIO, "Waldi %c", 'X') == -EIO);
	99	assert_se(streq(error.name, SD_BUS_ERROR_IO_ERROR));
	100	assert_se(streq(error.message, "Waldi X"));
	101	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
	102	assert_se(sd_bus_error_get_errno(&error) == EIO);
	103	assert_se(sd_bus_error_is_set(&error));
5cb06d0c ZJS	104	sd_bus_error_free(&error);
	105
	106	/* Check with no error */
	107	assert_se(!sd_bus_error_is_set(&error));
	108	assert_se(sd_bus_error_set_errnof(&error, 0, "Waldi %c", 'X') == 0);
	109	assert_se(error.name == NULL);
	110	assert_se(error.message == NULL);
	111	assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
	112	assert_se(sd_bus_error_get_errno(&error) == 0);
	113	assert_se(!sd_bus_error_is_set(&error));
4a0a7417 ZJS	114	}
4a0a7417 ZJS	115
a8986035 LP	116	extern const sd_bus_error_map __start_SYSTEMD_BUS_ERROR_MAP[];
a8986035 LP	117	extern const sd_bus_error_map __stop_SYSTEMD_BUS_ERROR_MAP[];
5e071f20 ZJS	118
5e071f20 ZJS	119	static void dump_mapping_table(void) {
5f86c1f4	120	const sd_bus_error_map *m;
5e071f20 ZJS	121
5e071f20 ZJS	122	printf("----- errno mappings ------\n");
a8986035 LP	123	m = ALIGN_TO_PTR(__start_SYSTEMD_BUS_ERROR_MAP, sizeof(void*));
a8986035 LP	124	while (m < __stop_SYSTEMD_BUS_ERROR_MAP) {
5f86c1f4 LP	125
5f86c1f4 LP	126	if (m->code == BUS_ERROR_MAP_END_MARKER) {
a8986035	127	m = ALIGN_TO_PTR(m + 1, sizeof(void*));
5f86c1f4 LP	128	continue;
	129	}
	130
	131	printf("%s -> %i/%s\n", strna(m->name), m->code, strna(errno_to_name(m->code)));
313cefa1	132	m++;
5f86c1f4	133	}
5e071f20 ZJS	134	printf("---------------------------\n");
	135	}
	136
4a0a7417 ZJS	137	static void test_errno_mapping_standard(void) {
	138	assert_se(sd_bus_error_set(NULL, "System.Error.EUCLEAN", NULL) == -EUCLEAN);
	139	assert_se(sd_bus_error_set(NULL, "System.Error.EBUSY", NULL) == -EBUSY);
	140	assert_se(sd_bus_error_set(NULL, "System.Error.EINVAL", NULL) == -EINVAL);
	141	assert_se(sd_bus_error_set(NULL, "System.Error.WHATSIT", NULL) == -EIO);
	142	}
	143
5f86c1f4 LP	144	BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors[] = {
	145	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error", 5),
	146	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-2", 52),
	147	SD_BUS_ERROR_MAP_END
	148	};
	149
	150	BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors2[] = {
	151	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-3", 33),
	152	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-4", 44),
	153	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-33", 333),
	154	SD_BUS_ERROR_MAP_END
	155	};
	156
	157	static const sd_bus_error_map test_errors3[] = {
	158	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-88", 888),
	159	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-99", 999),
	160	SD_BUS_ERROR_MAP_END
	161	};
	162
	163	static const sd_bus_error_map test_errors4[] = {
	164	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-77", 777),
	165	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-78", 778),
	166	SD_BUS_ERROR_MAP_END
4a0a7417 ZJS	167	};
4a0a7417 ZJS	168
45ea6583 ZJS	169	static const sd_bus_error_map test_errors_bad1[] = {
	170	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", 0),
	171	SD_BUS_ERROR_MAP_END
	172	};
	173
	174	static const sd_bus_error_map test_errors_bad2[] = {
	175	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", -1),
	176	SD_BUS_ERROR_MAP_END
	177	};
	178
4a0a7417 ZJS	179	static void test_errno_mapping_custom(void) {
	180	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error", NULL) == -5);
	181	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
	182	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-x", NULL) == -EIO);
5f86c1f4 LP	183	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-33", NULL) == -333);
	184
	185	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -EIO);
	186	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -EIO);
	187	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -EIO);
	188
	189	assert_se(sd_bus_error_add_map(test_errors3) > 0);
	190	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -888);
	191	assert_se(sd_bus_error_add_map(test_errors4) > 0);
	192	assert_se(sd_bus_error_add_map(test_errors4) == 0);
	193	assert_se(sd_bus_error_add_map(test_errors3) == 0);
	194
	195	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -999);
	196	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -777);
	197	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-78", NULL) == -778);
	198	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
	199	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-y", NULL) == -EIO);
	200
	201	assert_se(sd_bus_error_set(NULL, BUS_ERROR_NO_SUCH_UNIT, NULL) == -ENOENT);
45ea6583 ZJS	202
	203	assert_se(sd_bus_error_add_map(test_errors_bad1) == -EINVAL);
	204	assert_se(sd_bus_error_add_map(test_errors_bad2) == -EINVAL);
4a0a7417 ZJS	205	}
	206
	207	int main(int argc, char *argv[]) {
5e071f20	208	dump_mapping_table();
4a0a7417 ZJS	209
	210	test_error();
	211	test_errno_mapping_standard();
	212	test_errno_mapping_custom();
780896a4 LP	213
	214	return 0;
	215	}