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

/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "sd-bus.h"

#include "alloc-util.h"
#include "bus-common-errors.h"
#include "bus-error.h"
#include "errno-list.h"
#include "errno-util.h"
#include "string-util.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_has_names_sentinel(&error, SD_BUS_ERROR_NOT_SUPPORTED, NULL));
        assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_NOT_SUPPORTED));
        assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_NOT_SUPPORTED, SD_BUS_ERROR_FILE_NOT_FOUND));
        assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND, SD_BUS_ERROR_NOT_SUPPORTED, NULL));
        assert_se(!sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
        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_has_names(&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_has_names(&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_has_names(&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_safe(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);
}

static void test_sd_bus_error_set_errnof(void) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_free_ char *str = NULL;

        assert_se(sd_bus_error_set_errnof(NULL, 0, NULL) == 0);
        assert_se(sd_bus_error_set_errnof(NULL, ENOANO, NULL) == -ENOANO);

        assert_se(sd_bus_error_set_errnof(&error, 0, NULL) == 0);
        assert_se(!bus_error_is_dirty(&error));

        assert_se(sd_bus_error_set_errnof(&error, EACCES, NULL) == -EACCES);
        assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_ACCESS_DENIED));
        errno = EACCES;
        assert_se(asprintf(&str, "%m") >= 0);
        assert_se(streq(error.message, str));
        assert_se(error._need_free == 0);

        str = mfree(str);
        sd_bus_error_free(&error);

        assert_se(sd_bus_error_set_errnof(&error, ENOANO, NULL) == -ENOANO);
        assert_se(sd_bus_error_has_name(&error, "System.Error.ENOANO"));
        errno = ENOANO;
        assert_se(asprintf(&str, "%m") >= 0);
        assert_se(streq(error.message, str));
        assert_se(error._need_free == 1);

        str = mfree(str);
        sd_bus_error_free(&error);

        assert_se(sd_bus_error_set_errnof(&error, 100000, NULL) == -100000);
        assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FAILED));
        errno = 100000;
        assert_se(asprintf(&str, "%m") >= 0);
        assert_se(streq(error.message, str));
        assert_se(error._need_free == 1);

        str = mfree(str);
        sd_bus_error_free(&error);

        assert_se(sd_bus_error_set_errnof(NULL, 0, "hoge %s: %m", "foo") == 0);
        assert_se(sd_bus_error_set_errnof(NULL, ENOANO, "hoge %s: %m", "foo") == -ENOANO);

        assert_se(sd_bus_error_set_errnof(&error, 0, "hoge %s: %m", "foo") == 0);
        assert_se(!bus_error_is_dirty(&error));

        assert_se(sd_bus_error_set_errnof(&error, EACCES, "hoge %s: %m", "foo") == -EACCES);
        assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_ACCESS_DENIED));
        errno = EACCES;
        assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
        assert_se(streq(error.message, str));
        assert_se(error._need_free == 1);

        str = mfree(str);
        sd_bus_error_free(&error);

        assert_se(sd_bus_error_set_errnof(&error, ENOANO, "hoge %s: %m", "foo") == -ENOANO);
        assert_se(sd_bus_error_has_name(&error, "System.Error.ENOANO"));
        errno = ENOANO;
        assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
        assert_se(streq(error.message, str));
        assert_se(error._need_free == 1);

        str = mfree(str);
        sd_bus_error_free(&error);

        assert_se(sd_bus_error_set_errnof(&error, 100000, "hoge %s: %m", "foo") == -100000);
        assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FAILED));
        errno = 100000;
        assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
        assert_se(streq(error.message, str));
        assert_se(error._need_free == 1);
}

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

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

        return 0;
}
Commit	Line	Data
db9ecf05	1	/* SPDX-License-Identifier: LGPL-2.1-or-later */
780896a4 LP	2
780896a4 LP	3	#include "sd-bus.h"
cf0fbc49	4
6969a671	5	#include "alloc-util.h"
cf0fbc49	6	#include "bus-common-errors.h"
057171ef	7	#include "bus-error.h"
5f86c1f4	8	#include "errno-list.h"
4bbccb02	9	#include "errno-util.h"
6969a671	10	#include "string-util.h"
780896a4	11
4a0a7417	12	static void test_error(void) {
4afd3348	13	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL, second = SD_BUS_ERROR_NULL;
79f8d3d2 LP	14	const sd_bus_error const_error = SD_BUS_ERROR_MAKE_CONST(SD_BUS_ERROR_FILE_EXISTS, "const error");
	15	const sd_bus_error temporarily_const_error = {
	16	.name = SD_BUS_ERROR_ACCESS_DENIED,
	17	.message = "oh! no",
61b315de	18	._need_free = -1,
79f8d3d2	19	};
780896a4 LP	20
780896a4 LP	21	assert_se(!sd_bus_error_is_set(&error));
15411c0c	22	assert_se(sd_bus_error_set(&error, SD_BUS_ERROR_NOT_SUPPORTED, "xxx") == -EOPNOTSUPP);
780896a4 LP	23	assert_se(streq(error.name, SD_BUS_ERROR_NOT_SUPPORTED));
	24	assert_se(streq(error.message, "xxx"));
	25	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_NOT_SUPPORTED));
2b07ec31 ZJS	26	assert_se(sd_bus_error_has_names_sentinel(&error, SD_BUS_ERROR_NOT_SUPPORTED, NULL));
	27	assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_NOT_SUPPORTED));
	28	assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_NOT_SUPPORTED, SD_BUS_ERROR_FILE_NOT_FOUND));
	29	assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND, SD_BUS_ERROR_NOT_SUPPORTED, NULL));
	30	assert_se(!sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
15411c0c	31	assert_se(sd_bus_error_get_errno(&error) == EOPNOTSUPP);
780896a4 LP	32	assert_se(sd_bus_error_is_set(&error));
	33	sd_bus_error_free(&error);
	34
5cb06d0c	35	/* Check with no error */
780896a4	36	assert_se(!sd_bus_error_is_set(&error));
5cb06d0c ZJS	37	assert_se(sd_bus_error_setf(&error, NULL, "yyy %i", -1) == 0);
	38	assert_se(error.name == NULL);
	39	assert_se(error.message == NULL);
	40	assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
2b07ec31	41	assert_se(!sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
5cb06d0c ZJS	42	assert_se(sd_bus_error_get_errno(&error) == 0);
	43	assert_se(!sd_bus_error_is_set(&error));
	44
780896a4 LP	45	assert_se(sd_bus_error_setf(&error, SD_BUS_ERROR_FILE_NOT_FOUND, "yyy %i", -1) == -ENOENT);
	46	assert_se(streq(error.name, SD_BUS_ERROR_FILE_NOT_FOUND));
	47	assert_se(streq(error.message, "yyy -1"));
	48	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
2b07ec31	49	assert_se(sd_bus_error_has_names(&error, SD_BUS_ERROR_FILE_NOT_FOUND));
780896a4 LP	50	assert_se(sd_bus_error_get_errno(&error) == ENOENT);
	51	assert_se(sd_bus_error_is_set(&error));
	52
	53	assert_se(!sd_bus_error_is_set(&second));
79f8d3d2 LP	54	assert_se(second._need_free == 0);
79f8d3d2 LP	55	assert_se(error._need_free > 0);
780896a4	56	assert_se(sd_bus_error_copy(&second, &error) == -ENOENT);
79f8d3d2	57	assert_se(second._need_free > 0);
780896a4 LP	58	assert_se(streq(error.name, second.name));
	59	assert_se(streq(error.message, second.message));
	60	assert_se(sd_bus_error_get_errno(&second) == ENOENT);
	61	assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_NOT_FOUND));
2b07ec31	62	assert_se(sd_bus_error_has_names(&second, SD_BUS_ERROR_FILE_NOT_FOUND));
780896a4 LP	63	assert_se(sd_bus_error_is_set(&second));
	64
	65	sd_bus_error_free(&error);
79f8d3d2 LP	66	sd_bus_error_free(&second);
	67
	68	assert_se(!sd_bus_error_is_set(&second));
	69	assert_se(const_error._need_free == 0);
	70	assert_se(sd_bus_error_copy(&second, &const_error) == -EEXIST);
	71	assert_se(second._need_free == 0);
	72	assert_se(streq(const_error.name, second.name));
	73	assert_se(streq(const_error.message, second.message));
	74	assert_se(sd_bus_error_get_errno(&second) == EEXIST);
	75	assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_FILE_EXISTS));
	76	assert_se(sd_bus_error_is_set(&second));
	77	sd_bus_error_free(&second);
	78
	79	assert_se(!sd_bus_error_is_set(&second));
	80	assert_se(temporarily_const_error._need_free < 0);
	81	assert_se(sd_bus_error_copy(&second, &temporarily_const_error) == -EACCES);
	82	assert_se(second._need_free > 0);
	83	assert_se(streq(temporarily_const_error.name, second.name));
	84	assert_se(streq(temporarily_const_error.message, second.message));
	85	assert_se(sd_bus_error_get_errno(&second) == EACCES);
	86	assert_se(sd_bus_error_has_name(&second, SD_BUS_ERROR_ACCESS_DENIED));
	87	assert_se(sd_bus_error_is_set(&second));
780896a4 LP	88
780896a4 LP	89	assert_se(!sd_bus_error_is_set(&error));
763e20e6 LP	90	assert_se(sd_bus_error_set_const(&error, "System.Error.EUCLEAN", "Hallo") == -EUCLEAN);
763e20e6 LP	91	assert_se(streq(error.name, "System.Error.EUCLEAN"));
780896a4	92	assert_se(streq(error.message, "Hallo"));
763e20e6	93	assert_se(sd_bus_error_has_name(&error, "System.Error.EUCLEAN"));
780896a4 LP	94	assert_se(sd_bus_error_get_errno(&error) == EUCLEAN);
	95	assert_se(sd_bus_error_is_set(&error));
	96	sd_bus_error_free(&error);
	97
	98	assert_se(!sd_bus_error_is_set(&error));
	99	assert_se(sd_bus_error_set_errno(&error, EBUSY) == -EBUSY);
763e20e6	100	assert_se(streq(error.name, "System.Error.EBUSY"));
4bbccb02	101	assert_se(streq(error.message, strerror_safe(EBUSY)));
763e20e6	102	assert_se(sd_bus_error_has_name(&error, "System.Error.EBUSY"));
780896a4 LP	103	assert_se(sd_bus_error_get_errno(&error) == EBUSY);
	104	assert_se(sd_bus_error_is_set(&error));
	105	sd_bus_error_free(&error);
	106
	107	assert_se(!sd_bus_error_is_set(&error));
	108	assert_se(sd_bus_error_set_errnof(&error, EIO, "Waldi %c", 'X') == -EIO);
	109	assert_se(streq(error.name, SD_BUS_ERROR_IO_ERROR));
	110	assert_se(streq(error.message, "Waldi X"));
	111	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
	112	assert_se(sd_bus_error_get_errno(&error) == EIO);
	113	assert_se(sd_bus_error_is_set(&error));
5cb06d0c ZJS	114	sd_bus_error_free(&error);
	115
	116	/* Check with no error */
	117	assert_se(!sd_bus_error_is_set(&error));
	118	assert_se(sd_bus_error_set_errnof(&error, 0, "Waldi %c", 'X') == 0);
	119	assert_se(error.name == NULL);
	120	assert_se(error.message == NULL);
	121	assert_se(!sd_bus_error_has_name(&error, SD_BUS_ERROR_IO_ERROR));
	122	assert_se(sd_bus_error_get_errno(&error) == 0);
	123	assert_se(!sd_bus_error_is_set(&error));
4a0a7417 ZJS	124	}
4a0a7417 ZJS	125
a8986035 LP	126	extern const sd_bus_error_map __start_SYSTEMD_BUS_ERROR_MAP[];
a8986035 LP	127	extern const sd_bus_error_map __stop_SYSTEMD_BUS_ERROR_MAP[];
5e071f20 ZJS	128
5e071f20 ZJS	129	static void dump_mapping_table(void) {
5f86c1f4	130	const sd_bus_error_map *m;
5e071f20 ZJS	131
5e071f20 ZJS	132	printf("----- errno mappings ------\n");
a8986035 LP	133	m = ALIGN_TO_PTR(__start_SYSTEMD_BUS_ERROR_MAP, sizeof(void*));
a8986035 LP	134	while (m < __stop_SYSTEMD_BUS_ERROR_MAP) {
5f86c1f4 LP	135
5f86c1f4 LP	136	if (m->code == BUS_ERROR_MAP_END_MARKER) {
a8986035	137	m = ALIGN_TO_PTR(m + 1, sizeof(void*));
5f86c1f4 LP	138	continue;
	139	}
	140
	141	printf("%s -> %i/%s\n", strna(m->name), m->code, strna(errno_to_name(m->code)));
313cefa1	142	m++;
5f86c1f4	143	}
5e071f20 ZJS	144	printf("---------------------------\n");
	145	}
	146
4a0a7417 ZJS	147	static void test_errno_mapping_standard(void) {
	148	assert_se(sd_bus_error_set(NULL, "System.Error.EUCLEAN", NULL) == -EUCLEAN);
	149	assert_se(sd_bus_error_set(NULL, "System.Error.EBUSY", NULL) == -EBUSY);
	150	assert_se(sd_bus_error_set(NULL, "System.Error.EINVAL", NULL) == -EINVAL);
	151	assert_se(sd_bus_error_set(NULL, "System.Error.WHATSIT", NULL) == -EIO);
	152	}
	153
5f86c1f4 LP	154	BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors[] = {
	155	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error", 5),
	156	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-2", 52),
	157	SD_BUS_ERROR_MAP_END
	158	};
	159
	160	BUS_ERROR_MAP_ELF_REGISTER const sd_bus_error_map test_errors2[] = {
	161	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-3", 33),
	162	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-4", 44),
	163	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-33", 333),
	164	SD_BUS_ERROR_MAP_END
	165	};
	166
	167	static const sd_bus_error_map test_errors3[] = {
	168	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-88", 888),
	169	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-99", 999),
	170	SD_BUS_ERROR_MAP_END
	171	};
	172
	173	static const sd_bus_error_map test_errors4[] = {
	174	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-77", 777),
	175	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-78", 778),
	176	SD_BUS_ERROR_MAP_END
4a0a7417 ZJS	177	};
4a0a7417 ZJS	178
45ea6583 ZJS	179	static const sd_bus_error_map test_errors_bad1[] = {
	180	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", 0),
	181	SD_BUS_ERROR_MAP_END
	182	};
	183
	184	static const sd_bus_error_map test_errors_bad2[] = {
	185	SD_BUS_ERROR_MAP("org.freedesktop.custom-dbus-error-1", -1),
	186	SD_BUS_ERROR_MAP_END
	187	};
	188
4a0a7417 ZJS	189	static void test_errno_mapping_custom(void) {
	190	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error", NULL) == -5);
	191	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
	192	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-x", NULL) == -EIO);
5f86c1f4 LP	193	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-33", NULL) == -333);
	194
	195	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -EIO);
	196	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -EIO);
	197	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -EIO);
	198
	199	assert_se(sd_bus_error_add_map(test_errors3) > 0);
	200	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-88", NULL) == -888);
	201	assert_se(sd_bus_error_add_map(test_errors4) > 0);
	202	assert_se(sd_bus_error_add_map(test_errors4) == 0);
	203	assert_se(sd_bus_error_add_map(test_errors3) == 0);
	204
	205	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-99", NULL) == -999);
	206	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-77", NULL) == -777);
	207	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-78", NULL) == -778);
	208	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-2", NULL) == -52);
	209	assert_se(sd_bus_error_set(NULL, "org.freedesktop.custom-dbus-error-y", NULL) == -EIO);
	210
	211	assert_se(sd_bus_error_set(NULL, BUS_ERROR_NO_SUCH_UNIT, NULL) == -ENOENT);
45ea6583 ZJS	212
	213	assert_se(sd_bus_error_add_map(test_errors_bad1) == -EINVAL);
	214	assert_se(sd_bus_error_add_map(test_errors_bad2) == -EINVAL);
4a0a7417 ZJS	215	}
4a0a7417 ZJS	216
aea4660a YW	217	static void test_sd_bus_error_set_errnof(void) {
	218	_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
	219	_cleanup_free_ char *str = NULL;
	220
	221	assert_se(sd_bus_error_set_errnof(NULL, 0, NULL) == 0);
	222	assert_se(sd_bus_error_set_errnof(NULL, ENOANO, NULL) == -ENOANO);
	223
	224	assert_se(sd_bus_error_set_errnof(&error, 0, NULL) == 0);
	225	assert_se(!bus_error_is_dirty(&error));
	226
	227	assert_se(sd_bus_error_set_errnof(&error, EACCES, NULL) == -EACCES);
	228	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_ACCESS_DENIED));
	229	errno = EACCES;
	230	assert_se(asprintf(&str, "%m") >= 0);
	231	assert_se(streq(error.message, str));
	232	assert_se(error._need_free == 0);
	233
	234	str = mfree(str);
	235	sd_bus_error_free(&error);
	236
	237	assert_se(sd_bus_error_set_errnof(&error, ENOANO, NULL) == -ENOANO);
	238	assert_se(sd_bus_error_has_name(&error, "System.Error.ENOANO"));
	239	errno = ENOANO;
	240	assert_se(asprintf(&str, "%m") >= 0);
	241	assert_se(streq(error.message, str));
	242	assert_se(error._need_free == 1);
	243
	244	str = mfree(str);
	245	sd_bus_error_free(&error);
	246
	247	assert_se(sd_bus_error_set_errnof(&error, 100000, NULL) == -100000);
	248	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FAILED));
	249	errno = 100000;
	250	assert_se(asprintf(&str, "%m") >= 0);
	251	assert_se(streq(error.message, str));
	252	assert_se(error._need_free == 1);
	253
	254	str = mfree(str);
	255	sd_bus_error_free(&error);
	256
	257	assert_se(sd_bus_error_set_errnof(NULL, 0, "hoge %s: %m", "foo") == 0);
	258	assert_se(sd_bus_error_set_errnof(NULL, ENOANO, "hoge %s: %m", "foo") == -ENOANO);
	259
	260	assert_se(sd_bus_error_set_errnof(&error, 0, "hoge %s: %m", "foo") == 0);
	261	assert_se(!bus_error_is_dirty(&error));
	262
	263	assert_se(sd_bus_error_set_errnof(&error, EACCES, "hoge %s: %m", "foo") == -EACCES);
	264	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_ACCESS_DENIED));
	265	errno = EACCES;
	266	assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
	267	assert_se(streq(error.message, str));
	268	assert_se(error._need_free == 1);
	269
	270	str = mfree(str);
	271	sd_bus_error_free(&error);
	272
	273	assert_se(sd_bus_error_set_errnof(&error, ENOANO, "hoge %s: %m", "foo") == -ENOANO);
	274	assert_se(sd_bus_error_has_name(&error, "System.Error.ENOANO"));
	275	errno = ENOANO;
	276	assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
	277	assert_se(streq(error.message, str));
	278	assert_se(error._need_free == 1);
	279
	280	str = mfree(str);
281	sd_bus_error_free(&error);
282
283	assert_se(sd_bus_error_set_errnof(&error, 100000, "hoge %s: %m", "foo") == -100000);
284	assert_se(sd_bus_error_has_name(&error, SD_BUS_ERROR_FAILED));
285	errno = 100000;
286	assert_se(asprintf(&str, "hoge %s: %m", "foo") >= 0);
287	assert_se(streq(error.message, str));
288	assert_se(error._need_free == 1);
289	}
290
4a0a7417	291	int main(int argc, char *argv[]) {
5e071f20	292	dump_mapping_table();
4a0a7417 ZJS	293
	294	test_error();
	295	test_errno_mapping_standard();
	296	test_errno_mapping_custom();
aea4660a	297	test_sd_bus_error_set_errnof();
780896a4 LP	298
	299	return 0;
	300	}