[thirdparty/systemd.git] / src / test / test-proc-cmdline.c

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

#include "alloc-util.h"
#include "env-util.h"
#include "log.h"
#include "macro.h"
#include "proc-cmdline.h"
#include "special.h"
#include "string-util.h"
#include "util.h"

static int obj;

static int parse_item(const char *key, const char *value, void *data) {
        assert_se(key);
        assert_se(data == &obj);

        log_info("kernel cmdline option <%s> = <%s>", key, strna(value));
        return 0;
}

static void test_proc_cmdline_parse(void) {
        log_info("/* %s */", __func__);

        assert_se(proc_cmdline_parse(parse_item, &obj, PROC_CMDLINE_STRIP_RD_PREFIX) >= 0);
}

static void test_proc_cmdline_override(void) {
        log_info("/* %s */", __func__);

        assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\"") == 0);

        /* Test if the override works */
        _cleanup_free_ char *line = NULL, *value = NULL;
        assert_se(proc_cmdline(&line) >= 0);

        /* Test if parsing makes uses of the override */
        assert_se(streq(line, "foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\""));
        assert_se(proc_cmdline_get_key("foo_bar", 0, &value) > 0 && streq_ptr(value, "quux"));
        value = mfree(value);

        assert_se(proc_cmdline_get_key("some_arg_with_space", 0, &value) > 0 && streq_ptr(value, "foo bar"));
        value = mfree(value);

        assert_se(proc_cmdline_get_key("and_one_more", 0, &value) > 0 && streq_ptr(value, "zzz aaa"));
        value = mfree(value);
}

static int parse_item_given(const char *key, const char *value, void *data) {
        assert_se(key);
        assert_se(data);

        bool *strip = data;

        log_info("%s: option <%s> = <%s>", __func__, key, strna(value));
        if (proc_cmdline_key_streq(key, "foo_bar"))
                assert_se(streq(value, "quux"));
        else if (proc_cmdline_key_streq(key, "wuff-piep"))
                assert_se(streq(value, "tuet "));
        else if (proc_cmdline_key_streq(key, "space"))
                assert_se(streq(value, "x y z"));
        else if (proc_cmdline_key_streq(key, "miepf"))
                assert_se(streq(value, "uuu"));
        else if (in_initrd() && *strip && proc_cmdline_key_streq(key, "zumm"))
                assert_se(!value);
        else if (in_initrd() && !*strip && proc_cmdline_key_streq(key, "rd.zumm"))
                assert_se(!value);
        else
                assert_not_reached("Bad key!");

        return 0;
}

static void test_proc_cmdline_given(bool flip_initrd) {
        log_info("/* %s (flip: %s) */", __func__, yes_no(flip_initrd));

        if (flip_initrd)
                in_initrd_force(!in_initrd());

        bool t = true, f = false;
        assert_se(proc_cmdline_parse_given("foo_bar=quux wuff-piep=\"tuet \" rd.zumm space='x y z' miepf=\"uuu\"",
                                           parse_item_given, &t, PROC_CMDLINE_STRIP_RD_PREFIX) >= 0);

        assert_se(proc_cmdline_parse_given("foo_bar=quux wuff-piep=\"tuet \" rd.zumm space='x y z' miepf=\"uuu\"",
                                           parse_item_given, &f, 0) >= 0);

        if (flip_initrd)
                in_initrd_force(!in_initrd());
}

static void test_proc_cmdline_get_key(void) {
        _cleanup_free_ char *value = NULL;

        log_info("/* %s */", __func__);
        assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm spaaace='ö ü ß' ticks=\"''\"") == 0);

        assert_se(proc_cmdline_get_key("", 0, &value) == -EINVAL);
        assert_se(proc_cmdline_get_key("abc", 0, NULL) == 0);
        assert_se(proc_cmdline_get_key("abc", 0, &value) == 0 && value == NULL);
        assert_se(proc_cmdline_get_key("abc", PROC_CMDLINE_VALUE_OPTIONAL, &value) == 0 && value == NULL);

        assert_se(proc_cmdline_get_key("foo_bar", 0, &value) > 0 && streq_ptr(value, "quux"));
        value = mfree(value);
        assert_se(proc_cmdline_get_key("foo_bar", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && streq_ptr(value, "quux"));
        value = mfree(value);
        assert_se(proc_cmdline_get_key("foo-bar", 0, &value) > 0 && streq_ptr(value, "quux"));
        value = mfree(value);
        assert_se(proc_cmdline_get_key("foo-bar", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && streq_ptr(value, "quux"));
        value = mfree(value);
        assert_se(proc_cmdline_get_key("foo-bar", 0, NULL) == 0);
        assert_se(proc_cmdline_get_key("foo-bar", PROC_CMDLINE_VALUE_OPTIONAL, NULL) == -EINVAL);

        assert_se(proc_cmdline_get_key("wuff-piep", 0, &value) > 0 && streq_ptr(value, "tuet"));
        value = mfree(value);
        assert_se(proc_cmdline_get_key("wuff-piep", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && streq_ptr(value, "tuet"));
        value = mfree(value);
        assert_se(proc_cmdline_get_key("wuff_piep", 0, &value) > 0 && streq_ptr(value, "tuet"));
        value = mfree(value);
        assert_se(proc_cmdline_get_key("wuff_piep", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && streq_ptr(value, "tuet"));
        value = mfree(value);
        assert_se(proc_cmdline_get_key("wuff_piep", 0, NULL) == 0);
        assert_se(proc_cmdline_get_key("wuff_piep", PROC_CMDLINE_VALUE_OPTIONAL, NULL) == -EINVAL);

        assert_se(proc_cmdline_get_key("zumm", 0, &value) == 0 && value == NULL);
        assert_se(proc_cmdline_get_key("zumm", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && value == NULL);
        assert_se(proc_cmdline_get_key("zumm", 0, NULL) > 0);

        assert_se(proc_cmdline_get_key("spaaace", 0, &value) > 0 && streq_ptr(value, "ö ü ß"));
        value = mfree(value);

        assert_se(proc_cmdline_get_key("ticks", 0, &value) > 0 && streq_ptr(value, "''"));
}

static void test_proc_cmdline_get_bool(void) {
        bool value = false;

        log_info("/* %s */", __func__);
        assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar bar-waldo=1 x_y-z=0 quux=miep") == 0);

        assert_se(proc_cmdline_get_bool("", &value) == -EINVAL);
        assert_se(proc_cmdline_get_bool("abc", &value) == 0 && value == false);
        assert_se(proc_cmdline_get_bool("foo_bar", &value) > 0 && value == true);
        assert_se(proc_cmdline_get_bool("foo-bar", &value) > 0 && value == true);
        assert_se(proc_cmdline_get_bool("bar-waldo", &value) > 0 && value == true);
        assert_se(proc_cmdline_get_bool("bar_waldo", &value) > 0 && value == true);
        assert_se(proc_cmdline_get_bool("x_y-z", &value) > 0 && value == false);
        assert_se(proc_cmdline_get_bool("x-y-z", &value) > 0 && value == false);
        assert_se(proc_cmdline_get_bool("x-y_z", &value) > 0 && value == false);
        assert_se(proc_cmdline_get_bool("x_y_z", &value) > 0 && value == false);
        assert_se(proc_cmdline_get_bool("quux", &value) == -EINVAL && value == false);
}

static void test_proc_cmdline_get_key_many(void) {
        _cleanup_free_ char *value1 = NULL, *value2 = NULL, *value3 = NULL, *value4 = NULL, *value5 = NULL, *value6 = NULL;

        log_info("/* %s */", __func__);
        assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm SPACE='one two' doubleticks=\" aaa aaa \"") == 0);

        assert_se(proc_cmdline_get_key_many(0,
                                            "wuff-piep", &value3,
                                            "foo_bar", &value1,
                                            "idontexist", &value2,
                                            "zumm", &value4,
                                            "SPACE", &value5,
                                            "doubleticks", &value6) == 4);

        assert_se(streq_ptr(value1, "quux"));
        assert_se(!value2);
        assert_se(streq_ptr(value3, "tuet"));
        assert_se(!value4);
        assert_se(streq_ptr(value5, "one two"));
        assert_se(streq_ptr(value6, " aaa aaa "));
}

static void test_proc_cmdline_key_streq(void) {
        log_info("/* %s */", __func__);

        assert_se(proc_cmdline_key_streq("", ""));
        assert_se(proc_cmdline_key_streq("a", "a"));
        assert_se(!proc_cmdline_key_streq("", "a"));
        assert_se(!proc_cmdline_key_streq("a", ""));
        assert_se(proc_cmdline_key_streq("a", "a"));
        assert_se(!proc_cmdline_key_streq("a", "b"));
        assert_se(proc_cmdline_key_streq("x-y-z", "x-y-z"));
        assert_se(proc_cmdline_key_streq("x-y-z", "x_y_z"));
        assert_se(proc_cmdline_key_streq("x-y-z", "x-y_z"));
        assert_se(proc_cmdline_key_streq("x-y-z", "x_y-z"));
        assert_se(proc_cmdline_key_streq("x_y-z", "x-y_z"));
        assert_se(!proc_cmdline_key_streq("x_y-z", "x-z_z"));
}

static void test_proc_cmdline_key_startswith(void) {
        log_info("/* %s */", __func__);

        assert_se(proc_cmdline_key_startswith("", ""));
        assert_se(proc_cmdline_key_startswith("x", ""));
        assert_se(!proc_cmdline_key_startswith("", "x"));
        assert_se(proc_cmdline_key_startswith("x", "x"));
        assert_se(!proc_cmdline_key_startswith("x", "y"));
        assert_se(!proc_cmdline_key_startswith("foo-bar", "quux"));
        assert_se(proc_cmdline_key_startswith("foo-bar", "foo"));
        assert_se(proc_cmdline_key_startswith("foo-bar", "foo-bar"));
        assert_se(proc_cmdline_key_startswith("foo-bar", "foo_bar"));
        assert_se(proc_cmdline_key_startswith("foo-bar", "foo_"));
        assert_se(!proc_cmdline_key_startswith("foo-bar", "foo_xx"));
}

static void test_runlevel_to_target(void) {
        log_info("/* %s */", __func__);

        in_initrd_force(false);
        assert_se(streq_ptr(runlevel_to_target(NULL), NULL));
        assert_se(streq_ptr(runlevel_to_target("unknown-runlevel"), NULL));
        assert_se(streq_ptr(runlevel_to_target("rd.unknown-runlevel"), NULL));
        assert_se(streq_ptr(runlevel_to_target("3"), SPECIAL_MULTI_USER_TARGET));
        assert_se(streq_ptr(runlevel_to_target("rd.rescue"), NULL));

        in_initrd_force(true);
        assert_se(streq_ptr(runlevel_to_target(NULL), NULL));
        assert_se(streq_ptr(runlevel_to_target("unknown-runlevel"), NULL));
        assert_se(streq_ptr(runlevel_to_target("rd.unknown-runlevel"), NULL));
        assert_se(streq_ptr(runlevel_to_target("3"), NULL));
        assert_se(streq_ptr(runlevel_to_target("rd.rescue"), SPECIAL_RESCUE_TARGET));
}

int main(void) {
        log_parse_environment();
        log_open();

        test_proc_cmdline_parse();
        test_proc_cmdline_override();
        test_proc_cmdline_given(false);
        /* Repeat the same thing, but now flip our ininitrdness */
        test_proc_cmdline_given(true);
        test_proc_cmdline_key_streq();
        test_proc_cmdline_key_startswith();
        test_proc_cmdline_get_key();
        test_proc_cmdline_get_bool();
        test_proc_cmdline_get_key_many();
        test_runlevel_to_target();

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
d376cbb7 RC	2
d376cbb7 RC	3	#include "alloc-util.h"
9a135c08	4	#include "env-util.h"
d376cbb7 RC	5	#include "log.h"
	6	#include "macro.h"
	7	#include "proc-cmdline.h"
	8	#include "special.h"
	9	#include "string-util.h"
dcd61450	10	#include "util.h"
d376cbb7	11
96287a49 ZJS	12	static int obj;
	13
	14	static int parse_item(const char key, const char value, void *data) {
d376cbb7	15	assert_se(key);
96287a49	16	assert_se(data == &obj);
d376cbb7 RC	17
	18	log_info("kernel cmdline option <%s> = <%s>", key, strna(value));
	19	return 0;
	20	}
	21
1d84ad94	22	static void test_proc_cmdline_parse(void) {
9a135c08 ZJS	23	log_info("/* %s */", __func__);
	24
	25	assert_se(proc_cmdline_parse(parse_item, &obj, PROC_CMDLINE_STRIP_RD_PREFIX) >= 0);
d376cbb7 RC	26	}
d376cbb7 RC	27
9a135c08 ZJS	28	static void test_proc_cmdline_override(void) {
9a135c08 ZJS	29	log_info("/* %s */", __func__);
dcd61450	30
483d713e	31	assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\"") == 0);
9a135c08 ZJS	32
	33	/* Test if the override works */
	34	_cleanup_free_ char line = NULL, value = NULL;
	35	assert_se(proc_cmdline(&line) >= 0);
	36
	37	/* Test if parsing makes uses of the override */
483d713e	38	assert_se(streq(line, "foo_bar=quux wuff-piep=tuet zumm some_arg_with_space='foo bar' and_one_more=\"zzz aaa\""));
9a135c08	39	assert_se(proc_cmdline_get_key("foo_bar", 0, &value) > 0 && streq_ptr(value, "quux"));
483d713e LP	40	value = mfree(value);
	41
	42	assert_se(proc_cmdline_get_key("some_arg_with_space", 0, &value) > 0 && streq_ptr(value, "foo bar"));
	43	value = mfree(value);
	44
	45	assert_se(proc_cmdline_get_key("and_one_more", 0, &value) > 0 && streq_ptr(value, "zzz aaa"));
	46	value = mfree(value);
9a135c08 ZJS	47	}
	48
	49	static int parse_item_given(const char key, const char value, void *data) {
	50	assert_se(key);
	51	assert_se(data);
	52
	53	bool *strip = data;
	54
	55	log_info("%s: option <%s> = <%s>", __func__, key, strna(value));
ad0cdb6b	56	if (proc_cmdline_key_streq(key, "foo_bar"))
9a135c08	57	assert_se(streq(value, "quux"));
ad0cdb6b	58	else if (proc_cmdline_key_streq(key, "wuff-piep"))
9a135c08	59	assert_se(streq(value, "tuet "));
ad0cdb6b	60	else if (proc_cmdline_key_streq(key, "space"))
483d713e	61	assert_se(streq(value, "x y z"));
ad0cdb6b	62	else if (proc_cmdline_key_streq(key, "miepf"))
483d713e	63	assert_se(streq(value, "uuu"));
ad0cdb6b	64	else if (in_initrd() && *strip && proc_cmdline_key_streq(key, "zumm"))
9a135c08	65	assert_se(!value);
ad0cdb6b	66	else if (in_initrd() && !*strip && proc_cmdline_key_streq(key, "rd.zumm"))
9a135c08 ZJS	67	assert_se(!value);
	68	else
	69	assert_not_reached("Bad key!");
	70
	71	return 0;
	72	}
	73
	74	static void test_proc_cmdline_given(bool flip_initrd) {
	75	log_info("/* %s (flip: %s) */", __func__, yes_no(flip_initrd));
	76
	77	if (flip_initrd)
	78	in_initrd_force(!in_initrd());
	79
	80	bool t = true, f = false;
483d713e	81	assert_se(proc_cmdline_parse_given("foo_bar=quux wuff-piep=\"tuet \" rd.zumm space='x y z' miepf=\"uuu\"",
9a135c08 ZJS	82	parse_item_given, &t, PROC_CMDLINE_STRIP_RD_PREFIX) >= 0);
9a135c08 ZJS	83
483d713e	84	assert_se(proc_cmdline_parse_given("foo_bar=quux wuff-piep=\"tuet \" rd.zumm space='x y z' miepf=\"uuu\"",
9a135c08 ZJS	85	parse_item_given, &f, 0) >= 0);
9a135c08 ZJS	86
9a135c08 ZJS	87	if (flip_initrd)
9a135c08 ZJS	88	in_initrd_force(!in_initrd());
d376cbb7 RC	89	}
d376cbb7 RC	90
1d84ad94 LP	91	static void test_proc_cmdline_get_key(void) {
	92	_cleanup_free_ char *value = NULL;
	93
9a135c08	94	log_info("/* %s */", __func__);
483d713e	95	assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm spaaace='ö ü ß' ticks=\"''\"") == 0);
1d84ad94 LP	96
	97	assert_se(proc_cmdline_get_key("", 0, &value) == -EINVAL);
	98	assert_se(proc_cmdline_get_key("abc", 0, NULL) == 0);
	99	assert_se(proc_cmdline_get_key("abc", 0, &value) == 0 && value == NULL);
	100	assert_se(proc_cmdline_get_key("abc", PROC_CMDLINE_VALUE_OPTIONAL, &value) == 0 && value == NULL);
	101
	102	assert_se(proc_cmdline_get_key("foo_bar", 0, &value) > 0 && streq_ptr(value, "quux"));
	103	value = mfree(value);
	104	assert_se(proc_cmdline_get_key("foo_bar", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && streq_ptr(value, "quux"));
	105	value = mfree(value);
	106	assert_se(proc_cmdline_get_key("foo-bar", 0, &value) > 0 && streq_ptr(value, "quux"));
	107	value = mfree(value);
	108	assert_se(proc_cmdline_get_key("foo-bar", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && streq_ptr(value, "quux"));
	109	value = mfree(value);
	110	assert_se(proc_cmdline_get_key("foo-bar", 0, NULL) == 0);
	111	assert_se(proc_cmdline_get_key("foo-bar", PROC_CMDLINE_VALUE_OPTIONAL, NULL) == -EINVAL);
	112
	113	assert_se(proc_cmdline_get_key("wuff-piep", 0, &value) > 0 && streq_ptr(value, "tuet"));
	114	value = mfree(value);
	115	assert_se(proc_cmdline_get_key("wuff-piep", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && streq_ptr(value, "tuet"));
	116	value = mfree(value);
	117	assert_se(proc_cmdline_get_key("wuff_piep", 0, &value) > 0 && streq_ptr(value, "tuet"));
	118	value = mfree(value);
	119	assert_se(proc_cmdline_get_key("wuff_piep", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && streq_ptr(value, "tuet"));
	120	value = mfree(value);
	121	assert_se(proc_cmdline_get_key("wuff_piep", 0, NULL) == 0);
	122	assert_se(proc_cmdline_get_key("wuff_piep", PROC_CMDLINE_VALUE_OPTIONAL, NULL) == -EINVAL);
	123
	124	assert_se(proc_cmdline_get_key("zumm", 0, &value) == 0 && value == NULL);
	125	assert_se(proc_cmdline_get_key("zumm", PROC_CMDLINE_VALUE_OPTIONAL, &value) > 0 && value == NULL);
	126	assert_se(proc_cmdline_get_key("zumm", 0, NULL) > 0);
483d713e LP	127
	128	assert_se(proc_cmdline_get_key("spaaace", 0, &value) > 0 && streq_ptr(value, "ö ü ß"));
	129	value = mfree(value);
	130
	131	assert_se(proc_cmdline_get_key("ticks", 0, &value) > 0 && streq_ptr(value, "''"));
1d84ad94 LP	132	}
	133
	134	static void test_proc_cmdline_get_bool(void) {
	135	bool value = false;
	136
9a135c08	137	log_info("/* %s */", __func__);
120bffad	138	assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar bar-waldo=1 x_y-z=0 quux=miep") == 0);
1d84ad94 LP	139
	140	assert_se(proc_cmdline_get_bool("", &value) == -EINVAL);
	141	assert_se(proc_cmdline_get_bool("abc", &value) == 0 && value == false);
	142	assert_se(proc_cmdline_get_bool("foo_bar", &value) > 0 && value == true);
	143	assert_se(proc_cmdline_get_bool("foo-bar", &value) > 0 && value == true);
	144	assert_se(proc_cmdline_get_bool("bar-waldo", &value) > 0 && value == true);
	145	assert_se(proc_cmdline_get_bool("bar_waldo", &value) > 0 && value == true);
	146	assert_se(proc_cmdline_get_bool("x_y-z", &value) > 0 && value == false);
	147	assert_se(proc_cmdline_get_bool("x-y-z", &value) > 0 && value == false);
	148	assert_se(proc_cmdline_get_bool("x-y_z", &value) > 0 && value == false);
	149	assert_se(proc_cmdline_get_bool("x_y_z", &value) > 0 && value == false);
	150	assert_se(proc_cmdline_get_bool("quux", &value) == -EINVAL && value == false);
	151	}
	152
78b30ee0	153	static void test_proc_cmdline_get_key_many(void) {
483d713e	154	_cleanup_free_ char value1 = NULL, value2 = NULL, value3 = NULL, value4 = NULL, value5 = NULL, value6 = NULL;
78b30ee0 LP	155
78b30ee0 LP	156	log_info("/* %s */", __func__);
483d713e	157	assert_se(putenv((char*) "SYSTEMD_PROC_CMDLINE=foo_bar=quux wuff-piep=tuet zumm SPACE='one two' doubleticks=\" aaa aaa \"") == 0);
78b30ee0 LP	158
	159	assert_se(proc_cmdline_get_key_many(0,
	160	"wuff-piep", &value3,
	161	"foo_bar", &value1,
	162	"idontexist", &value2,
483d713e LP	163	"zumm", &value4,
	164	"SPACE", &value5,
	165	"doubleticks", &value6) == 4);
78b30ee0 LP	166
	167	assert_se(streq_ptr(value1, "quux"));
	168	assert_se(!value2);
	169	assert_se(streq_ptr(value3, "tuet"));
	170	assert_se(!value4);
483d713e LP	171	assert_se(streq_ptr(value5, "one two"));
483d713e LP	172	assert_se(streq_ptr(value6, " aaa aaa "));
78b30ee0 LP	173	}
78b30ee0 LP	174
1d84ad94	175	static void test_proc_cmdline_key_streq(void) {
9a135c08	176	log_info("/* %s */", __func__);
1d84ad94 LP	177
	178	assert_se(proc_cmdline_key_streq("", ""));
	179	assert_se(proc_cmdline_key_streq("a", "a"));
	180	assert_se(!proc_cmdline_key_streq("", "a"));
	181	assert_se(!proc_cmdline_key_streq("a", ""));
	182	assert_se(proc_cmdline_key_streq("a", "a"));
	183	assert_se(!proc_cmdline_key_streq("a", "b"));
	184	assert_se(proc_cmdline_key_streq("x-y-z", "x-y-z"));
	185	assert_se(proc_cmdline_key_streq("x-y-z", "x_y_z"));
	186	assert_se(proc_cmdline_key_streq("x-y-z", "x-y_z"));
	187	assert_se(proc_cmdline_key_streq("x-y-z", "x_y-z"));
	188	assert_se(proc_cmdline_key_streq("x_y-z", "x-y_z"));
	189	assert_se(!proc_cmdline_key_streq("x_y-z", "x-z_z"));
	190	}
	191
	192	static void test_proc_cmdline_key_startswith(void) {
9a135c08	193	log_info("/* %s */", __func__);
1d84ad94 LP	194
	195	assert_se(proc_cmdline_key_startswith("", ""));
	196	assert_se(proc_cmdline_key_startswith("x", ""));
	197	assert_se(!proc_cmdline_key_startswith("", "x"));
	198	assert_se(proc_cmdline_key_startswith("x", "x"));
	199	assert_se(!proc_cmdline_key_startswith("x", "y"));
	200	assert_se(!proc_cmdline_key_startswith("foo-bar", "quux"));
	201	assert_se(proc_cmdline_key_startswith("foo-bar", "foo"));
	202	assert_se(proc_cmdline_key_startswith("foo-bar", "foo-bar"));
	203	assert_se(proc_cmdline_key_startswith("foo-bar", "foo_bar"));
	204	assert_se(proc_cmdline_key_startswith("foo-bar", "foo_"));
	205	assert_se(!proc_cmdline_key_startswith("foo-bar", "foo_xx"));
	206	}
	207
9a135c08 ZJS	208	static void test_runlevel_to_target(void) {
	209	log_info("/* %s */", __func__);
	210
	211	in_initrd_force(false);
	212	assert_se(streq_ptr(runlevel_to_target(NULL), NULL));
	213	assert_se(streq_ptr(runlevel_to_target("unknown-runlevel"), NULL));
	214	assert_se(streq_ptr(runlevel_to_target("rd.unknown-runlevel"), NULL));
	215	assert_se(streq_ptr(runlevel_to_target("3"), SPECIAL_MULTI_USER_TARGET));
	216	assert_se(streq_ptr(runlevel_to_target("rd.rescue"), NULL));
	217
	218	in_initrd_force(true);
	219	assert_se(streq_ptr(runlevel_to_target(NULL), NULL));
	220	assert_se(streq_ptr(runlevel_to_target("unknown-runlevel"), NULL));
	221	assert_se(streq_ptr(runlevel_to_target("rd.unknown-runlevel"), NULL));
	222	assert_se(streq_ptr(runlevel_to_target("3"), NULL));
	223	assert_se(streq_ptr(runlevel_to_target("rd.rescue"), SPECIAL_RESCUE_TARGET));
	224	}
	225
d376cbb7 RC	226	int main(void) {
	227	log_parse_environment();
	228	log_open();
	229
1d84ad94	230	test_proc_cmdline_parse();
9a135c08 ZJS	231	test_proc_cmdline_override();
	232	test_proc_cmdline_given(false);
	233	/* Repeat the same thing, but now flip our ininitrdness */
	234	test_proc_cmdline_given(true);
1d84ad94 LP	235	test_proc_cmdline_key_streq();
	236	test_proc_cmdline_key_startswith();
	237	test_proc_cmdline_get_key();
	238	test_proc_cmdline_get_bool();
78b30ee0	239	test_proc_cmdline_get_key_many();
d376cbb7 RC	240	test_runlevel_to_target();
	241
	242	return 0;
	243	}