[thirdparty/systemd.git] / src / locale / test-keymap-util.c

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

#include "alloc-util.h"
#include "keymap-util.h"
#include "log.h"
#include "string-util.h"

static void test_find_language_fallback(void) {
        _cleanup_free_ char *ans = NULL, *ans2 = NULL;

        log_info("/*** %s ***/", __func__);

        assert_se(find_language_fallback("foobar", &ans) == 0);
        assert_se(ans == NULL);

        assert_se(find_language_fallback("csb", &ans) == 0);
        assert_se(ans == NULL);

        assert_se(find_language_fallback("csb_PL", &ans) == 1);
        assert_se(streq(ans, "csb:pl"));

        assert_se(find_language_fallback("szl_PL", &ans2) == 1);
        assert_se(streq(ans2, "szl:pl"));
}

static void test_find_converted_keymap(void) {
        _cleanup_free_ char *ans = NULL, *ans2 = NULL;
        int r;

        log_info("/*** %s ***/", __func__);

        assert_se(find_converted_keymap("pl", "foobar", &ans) == 0);
        assert_se(ans == NULL);

        r = find_converted_keymap("pl", NULL, &ans);
        if (r == 0) {
                log_info("Skipping rest of %s: keymaps are not installed", __func__);
                return;
        }

        assert_se(r == 1);
        assert_se(streq(ans, "pl"));

        assert_se(find_converted_keymap("pl", "dvorak", &ans2) == 1);
        assert_se(streq(ans2, "pl-dvorak"));
}

static void test_find_legacy_keymap(void) {
        Context c = {};
        _cleanup_free_ char *ans = NULL, *ans2 = NULL;

        log_info("/*** %s ***/", __func__);

        c.x11_layout = (char*) "foobar";
        assert_se(find_legacy_keymap(&c, &ans) == 0);
        assert_se(ans == NULL);

        c.x11_layout = (char*) "pl";
        assert_se(find_legacy_keymap(&c, &ans) == 1);
        assert_se(streq(ans, "pl2"));

        c.x11_layout = (char*) "pl,ru";
        assert_se(find_legacy_keymap(&c, &ans2) == 1);
        assert_se(streq(ans, "pl2"));
}

static void test_vconsole_convert_to_x11(void) {
        _cleanup_(context_clear) Context c = {};

        log_info("/*** %s ***/", __func__);

        log_info("/* test emptying first (:) */");
        assert_se(free_and_strdup(&c.x11_layout, "foo") >= 0);
        assert_se(free_and_strdup(&c.x11_variant, "bar") >= 0);
        assert_se(vconsole_convert_to_x11(&c) == 1);
        assert_se(c.x11_layout == NULL);
        assert_se(c.x11_variant == NULL);

        log_info("/* test emptying second (:) */");

        assert_se(vconsole_convert_to_x11(&c) == 0);
        assert_se(c.x11_layout == NULL);
        assert_se(c.x11_variant == NULL);

        log_info("/* test without variant, new mapping (es:) */");
        assert_se(free_and_strdup(&c.vc_keymap, "es") >= 0);

        assert_se(vconsole_convert_to_x11(&c) == 1);
        assert_se(streq(c.x11_layout, "es"));
        assert_se(c.x11_variant == NULL);

        log_info("/* test with known variant, new mapping (es:dvorak) */");
        assert_se(free_and_strdup(&c.vc_keymap, "es-dvorak") >= 0);

        assert_se(vconsole_convert_to_x11(&c) == 0); // FIXME
        assert_se(streq(c.x11_layout, "es"));
        assert_se(c.x11_variant == NULL); // FIXME: "dvorak"

        log_info("/* test with old mapping (fr:latin9) */");
        assert_se(free_and_strdup(&c.vc_keymap, "fr-latin9") >= 0);

        assert_se(vconsole_convert_to_x11(&c) == 1);
        assert_se(streq(c.x11_layout, "fr"));
        assert_se(streq(c.x11_variant, "latin9"));

        log_info("/* test with a compound mapping (ru,us) */");
        assert_se(free_and_strdup(&c.vc_keymap, "ru") >= 0);

        assert_se(vconsole_convert_to_x11(&c) == 1);
        assert_se(streq(c.x11_layout, "ru,us"));
        assert_se(c.x11_variant == NULL);

        log_info("/* test with a simple mapping (us) */");
        assert_se(free_and_strdup(&c.vc_keymap, "us") >= 0);

        assert_se(vconsole_convert_to_x11(&c) == 1);
        assert_se(streq(c.x11_layout, "us"));
        assert_se(c.x11_variant == NULL);
}

static void test_x11_convert_to_vconsole(void) {
        _cleanup_(context_clear) Context c = {};
        int r;

        log_info("/*** %s ***/", __func__);

        log_info("/* test emptying first (:) */");
        assert_se(free_and_strdup(&c.vc_keymap, "foobar") >= 0);
        assert_se(x11_convert_to_vconsole(&c) == 1);
        assert_se(c.vc_keymap == NULL);

        log_info("/* test emptying second (:) */");

        assert_se(x11_convert_to_vconsole(&c) == 0);
        assert_se(c.vc_keymap == NULL);

        log_info("/* test without variant, new mapping (es:) */");
        assert_se(free_and_strdup(&c.x11_layout, "es") >= 0);

        assert_se(x11_convert_to_vconsole(&c) == 1);
        assert_se(streq(c.vc_keymap, "es"));

        log_info("/* test with unknown variant, new mapping (es:foobar) */");
        assert_se(free_and_strdup(&c.x11_variant, "foobar") >= 0);

        assert_se(x11_convert_to_vconsole(&c) == 0);
        assert_se(streq(c.vc_keymap, "es"));

        log_info("/* test with known variant, new mapping (es:dvorak) */");
        assert_se(free_and_strdup(&c.x11_variant, "dvorak") >= 0);

        r = x11_convert_to_vconsole(&c);
        if (r == 0) {
                log_info("Skipping rest of %s: keymaps are not installed", __func__);
                return;
        }

        assert_se(r == 1);
        assert_se(streq(c.vc_keymap, "es-dvorak"));

        log_info("/* test with old mapping (fr:latin9) */");
        assert_se(free_and_strdup(&c.x11_layout, "fr") >= 0);
        assert_se(free_and_strdup(&c.x11_variant, "latin9") >= 0);

        assert_se(x11_convert_to_vconsole(&c) == 1);
        assert_se(streq(c.vc_keymap, "fr-latin9"));

        log_info("/* test with a compound mapping (us,ru:) */");
        assert_se(free_and_strdup(&c.x11_layout, "us,ru") >= 0);
        assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);

        assert_se(x11_convert_to_vconsole(&c) == 1);
        assert_se(streq(c.vc_keymap, "us"));

        log_info("/* test with a compound mapping (ru,us:) */");
        assert_se(free_and_strdup(&c.x11_layout, "ru,us") >= 0);
        assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);

        assert_se(x11_convert_to_vconsole(&c) == 1);
        assert_se(streq(c.vc_keymap, "ru"));

        /* https://bugzilla.redhat.com/show_bug.cgi?id=1333998 */
        log_info("/* test with a simple new mapping (ru:) */");
        assert_se(free_and_strdup(&c.x11_layout, "ru") >= 0);
        assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);

        assert_se(x11_convert_to_vconsole(&c) == 0);
        assert_se(streq(c.vc_keymap, "ru"));
}

int main(int argc, char **argv) {
        log_set_max_level(LOG_DEBUG);
        log_parse_environment();

        test_find_language_fallback();
        test_find_converted_keymap();
        test_find_legacy_keymap();

        test_vconsole_convert_to_x11();
        test_x11_convert_to_vconsole();

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
aa63b56f ZJS	2
	3	#include "alloc-util.h"
	4	#include "keymap-util.h"
	5	#include "log.h"
	6	#include "string-util.h"
	7
	8	static void test_find_language_fallback(void) {
	9	_cleanup_free_ char ans = NULL, ans2 = NULL;
aa63b56f	10
cabffaf8	11	log_info("/* %s */", __func__);
aa63b56f	12
cabffaf8	13	assert_se(find_language_fallback("foobar", &ans) == 0);
aa63b56f ZJS	14	assert_se(ans == NULL);
	15
	16	assert_se(find_language_fallback("csb", &ans) == 0);
	17	assert_se(ans == NULL);
	18
	19	assert_se(find_language_fallback("csb_PL", &ans) == 1);
	20	assert_se(streq(ans, "csb:pl"));
	21
	22	assert_se(find_language_fallback("szl_PL", &ans2) == 1);
	23	assert_se(streq(ans2, "szl:pl"));
	24	}
	25
	26	static void test_find_converted_keymap(void) {
	27	_cleanup_free_ char ans = NULL, ans2 = NULL;
	28	int r;
	29
cabffaf8	30	log_info("/* %s */", __func__);
aa63b56f ZJS	31
	32	assert_se(find_converted_keymap("pl", "foobar", &ans) == 0);
	33	assert_se(ans == NULL);
	34
	35	r = find_converted_keymap("pl", NULL, &ans);
	36	if (r == 0) {
cabffaf8	37	log_info("Skipping rest of %s: keymaps are not installed", __func__);
aa63b56f ZJS	38	return;
aa63b56f ZJS	39	}
cabffaf8	40
aa63b56f ZJS	41	assert_se(r == 1);
	42	assert_se(streq(ans, "pl"));
	43
b774852a EV	44	assert_se(find_converted_keymap("pl", "dvorak", &ans2) == 1);
b774852a EV	45	assert_se(streq(ans2, "pl-dvorak"));
aa63b56f ZJS	46	}
	47
	48	static void test_find_legacy_keymap(void) {
	49	Context c = {};
	50	_cleanup_free_ char ans = NULL, ans2 = NULL;
aa63b56f	51
cabffaf8	52	log_info("/* %s */", __func__);
aa63b56f ZJS	53
aa63b56f ZJS	54	c.x11_layout = (char*) "foobar";
cabffaf8	55	assert_se(find_legacy_keymap(&c, &ans) == 0);
aa63b56f ZJS	56	assert_se(ans == NULL);
	57
	58	c.x11_layout = (char*) "pl";
5ad327dd	59	assert_se(find_legacy_keymap(&c, &ans) == 1);
aa63b56f ZJS	60	assert_se(streq(ans, "pl2"));
	61
	62	c.x11_layout = (char*) "pl,ru";
5ad327dd	63	assert_se(find_legacy_keymap(&c, &ans2) == 1);
aa63b56f ZJS	64	assert_se(streq(ans, "pl2"));
	65	}
	66
	67	static void test_vconsole_convert_to_x11(void) {
6804d7a8	68	_cleanup_(context_clear) Context c = {};
aa63b56f	69
cabffaf8	70	log_info("/* %s */", __func__);
aa63b56f ZJS	71
	72	log_info("/* test emptying first (:) */");
	73	assert_se(free_and_strdup(&c.x11_layout, "foo") >= 0);
	74	assert_se(free_and_strdup(&c.x11_variant, "bar") >= 0);
	75	assert_se(vconsole_convert_to_x11(&c) == 1);
	76	assert_se(c.x11_layout == NULL);
	77	assert_se(c.x11_variant == NULL);
	78
	79	log_info("/* test emptying second (:) */");
	80
	81	assert_se(vconsole_convert_to_x11(&c) == 0);
	82	assert_se(c.x11_layout == NULL);
	83	assert_se(c.x11_variant == NULL);
	84
	85	log_info("/* test without variant, new mapping (es:) */");
	86	assert_se(free_and_strdup(&c.vc_keymap, "es") >= 0);
	87
	88	assert_se(vconsole_convert_to_x11(&c) == 1);
	89	assert_se(streq(c.x11_layout, "es"));
	90	assert_se(c.x11_variant == NULL);
	91
	92	log_info("/* test with known variant, new mapping (es:dvorak) */");
	93	assert_se(free_and_strdup(&c.vc_keymap, "es-dvorak") >= 0);
	94
	95	assert_se(vconsole_convert_to_x11(&c) == 0); // FIXME
	96	assert_se(streq(c.x11_layout, "es"));
	97	assert_se(c.x11_variant == NULL); // FIXME: "dvorak"
	98
	99	log_info("/* test with old mapping (fr:latin9) */");
	100	assert_se(free_and_strdup(&c.vc_keymap, "fr-latin9") >= 0);
	101
	102	assert_se(vconsole_convert_to_x11(&c) == 1);
	103	assert_se(streq(c.x11_layout, "fr"));
	104	assert_se(streq(c.x11_variant, "latin9"));
	105
	106	log_info("/* test with a compound mapping (ru,us) */");
	107	assert_se(free_and_strdup(&c.vc_keymap, "ru") >= 0);
	108
	109	assert_se(vconsole_convert_to_x11(&c) == 1);
	110	assert_se(streq(c.x11_layout, "ru,us"));
	111	assert_se(c.x11_variant == NULL);
	112
	113	log_info("/* test with a simple mapping (us) */");
	114	assert_se(free_and_strdup(&c.vc_keymap, "us") >= 0);
	115
	116	assert_se(vconsole_convert_to_x11(&c) == 1);
	117	assert_se(streq(c.x11_layout, "us"));
	118	assert_se(c.x11_variant == NULL);
	119	}
	120
	121	static void test_x11_convert_to_vconsole(void) {
6804d7a8	122	_cleanup_(context_clear) Context c = {};
cabffaf8	123	int r;
aa63b56f	124
cabffaf8	125	log_info("/* %s */", __func__);
aa63b56f ZJS	126
	127	log_info("/* test emptying first (:) */");
	128	assert_se(free_and_strdup(&c.vc_keymap, "foobar") >= 0);
	129	assert_se(x11_convert_to_vconsole(&c) == 1);
	130	assert_se(c.vc_keymap == NULL);
	131
	132	log_info("/* test emptying second (:) */");
	133
	134	assert_se(x11_convert_to_vconsole(&c) == 0);
	135	assert_se(c.vc_keymap == NULL);
	136
	137	log_info("/* test without variant, new mapping (es:) */");
	138	assert_se(free_and_strdup(&c.x11_layout, "es") >= 0);
	139
	140	assert_se(x11_convert_to_vconsole(&c) == 1);
	141	assert_se(streq(c.vc_keymap, "es"));
	142
	143	log_info("/* test with unknown variant, new mapping (es:foobar) */");
	144	assert_se(free_and_strdup(&c.x11_variant, "foobar") >= 0);
	145
	146	assert_se(x11_convert_to_vconsole(&c) == 0);
	147	assert_se(streq(c.vc_keymap, "es"));
	148
	149	log_info("/* test with known variant, new mapping (es:dvorak) */");
	150	assert_se(free_and_strdup(&c.x11_variant, "dvorak") >= 0);
	151
cabffaf8 ZJS	152	r = x11_convert_to_vconsole(&c);
	153	if (r == 0) {
	154	log_info("Skipping rest of %s: keymaps are not installed", __func__);
	155	return;
	156	}
	157
	158	assert_se(r == 1);
aa63b56f ZJS	159	assert_se(streq(c.vc_keymap, "es-dvorak"));
	160
	161	log_info("/* test with old mapping (fr:latin9) */");
	162	assert_se(free_and_strdup(&c.x11_layout, "fr") >= 0);
	163	assert_se(free_and_strdup(&c.x11_variant, "latin9") >= 0);
	164
	165	assert_se(x11_convert_to_vconsole(&c) == 1);
	166	assert_se(streq(c.vc_keymap, "fr-latin9"));
	167
	168	log_info("/* test with a compound mapping (us,ru:) */");
	169	assert_se(free_and_strdup(&c.x11_layout, "us,ru") >= 0);
	170	assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);
	171
	172	assert_se(x11_convert_to_vconsole(&c) == 1);
	173	assert_se(streq(c.vc_keymap, "us"));
	174
	175	log_info("/* test with a compound mapping (ru,us:) */");
	176	assert_se(free_and_strdup(&c.x11_layout, "ru,us") >= 0);
	177	assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);
	178
	179	assert_se(x11_convert_to_vconsole(&c) == 1);
	180	assert_se(streq(c.vc_keymap, "ru"));
03a44125 ZJS	181
	182	/* https://bugzilla.redhat.com/show_bug.cgi?id=1333998 */
	183	log_info("/* test with a simple new mapping (ru:) */");
	184	assert_se(free_and_strdup(&c.x11_layout, "ru") >= 0);
	185	assert_se(free_and_strdup(&c.x11_variant, NULL) >= 0);
	186
	187	assert_se(x11_convert_to_vconsole(&c) == 0);
	188	assert_se(streq(c.vc_keymap, "ru"));
aa63b56f ZJS	189	}
	190
	191	int main(int argc, char **argv) {
	192	log_set_max_level(LOG_DEBUG);
	193	log_parse_environment();
	194
	195	test_find_language_fallback();
	196	test_find_converted_keymap();
	197	test_find_legacy_keymap();
	198
	199	test_vconsole_convert_to_x11();
	200	test_x11_convert_to_vconsole();
	201
	202	return 0;
	203	}