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

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


#include "env-util.h"
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "serialize.h"
#include "string-util.h"
#include "strv.h"
#include "util.h"

static void test_strv_env_delete(void) {
        _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;

        a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
        assert_se(a);

        b = strv_new("PIEP", "FOO");
        assert_se(b);

        c = strv_new("SCHLUMPF");
        assert_se(c);

        d = strv_env_delete(a, 2, b, c);
        assert_se(d);

        assert_se(streq(d[0], "WALDO=WALDO"));
        assert_se(streq(d[1], "WALDO="));
        assert_se(strv_length(d) == 2);
}

static void test_strv_env_get(void) {
        char **l;

        l = STRV_MAKE("ONE_OR_TWO=1", "THREE=3", "ONE_OR_TWO=2", "FOUR=4");

        assert_se(streq(strv_env_get(l, "ONE_OR_TWO"), "2"));
        assert_se(streq(strv_env_get(l, "THREE"), "3"));
        assert_se(streq(strv_env_get(l, "FOUR"), "4"));
}

static void test_strv_env_unset(void) {
        _cleanup_strv_free_ char **l = NULL;

        l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
        assert_se(l);

        assert_se(strv_env_unset(l, "SCHLUMPF") == l);

        assert_se(streq(l[0], "PIEP"));
        assert_se(streq(l[1], "NANANANA=YES"));
        assert_se(strv_length(l) == 2);
}

static void test_strv_env_set(void) {
        _cleanup_strv_free_ char **l = NULL, **r = NULL;

        l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
        assert_se(l);

        r = strv_env_set(l, "WALDO=WALDO");
        assert_se(r);

        assert_se(streq(r[0], "PIEP"));
        assert_se(streq(r[1], "SCHLUMPF=SMURFF"));
        assert_se(streq(r[2], "NANANANA=YES"));
        assert_se(streq(r[3], "WALDO=WALDO"));
        assert_se(strv_length(r) == 4);
}

static void test_strv_env_merge(void) {
        _cleanup_strv_free_ char **a = NULL, **b = NULL, **r = NULL;

        a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
        assert_se(a);

        b = strv_new("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES");
        assert_se(b);

        r = strv_env_merge(2, a, b);
        assert_se(r);
        assert_se(streq(r[0], "FOO="));
        assert_se(streq(r[1], "WALDO="));
        assert_se(streq(r[2], "PIEP"));
        assert_se(streq(r[3], "SCHLUMPF=SMURFF"));
        assert_se(streq(r[4], "PIEP="));
        assert_se(streq(r[5], "NANANANA=YES"));
        assert_se(strv_length(r) == 6);

        assert_se(strv_env_clean(r) == r);
        assert_se(streq(r[0], "FOO="));
        assert_se(streq(r[1], "WALDO="));
        assert_se(streq(r[2], "SCHLUMPF=SMURFF"));
        assert_se(streq(r[3], "PIEP="));
        assert_se(streq(r[4], "NANANANA=YES"));
        assert_se(strv_length(r) == 5);
}

static void test_env_strv_get_n(void) {
        const char *_env[] = {
                "FOO=NO NO NO",
                "FOO=BAR BAR",
                "BAR=waldo",
                "PATH=unset",
                NULL
        };
        char **env = (char**) _env;

        assert_se(streq(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR"));
        assert_se(streq(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
        assert_se(streq(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR"));
        assert_se(streq(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));

        assert_se(streq(strv_env_get_n(env, "PATH__", 4, 0), "unset"));
        assert_se(streq(strv_env_get_n(env, "PATH", 4, 0), "unset"));
        assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
        assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));

        env[3] = NULL; /* kill our $PATH */

        assert_se(!strv_env_get_n(env, "PATH__", 4, 0));
        assert_se(!strv_env_get_n(env, "PATH", 4, 0));
        assert_se(streq_ptr(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT),
                            getenv("PATH")));
        assert_se(streq_ptr(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT),
                            getenv("PATH")));
}

static void test_replace_env(bool braceless) {
        const char *env[] = {
                "FOO=BAR BAR",
                "BAR=waldo",
                NULL
        };
        _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL;
        unsigned flags = REPLACE_ENV_ALLOW_BRACELESS*braceless;

        t = replace_env("FOO=$FOO=${FOO}", (char**) env, flags);
        assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"));

        s = replace_env("BAR=$BAR=${BAR}", (char**) env, flags);
        assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"));

        q = replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags);
        assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="));

        r = replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags);
        assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"));

        p = replace_env("${BAR}$BAR$BAR", (char**) env, flags);
        assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"));
}

static void test_replace_env2(bool extended) {
        const char *env[] = {
                "FOO=foo",
                "BAR=bar",
                NULL
        };
        _cleanup_free_ char *t = NULL, *s = NULL, *q = NULL, *r = NULL, *p = NULL, *x = NULL;
        unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended;

        t = replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags);
        assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"));

        s = replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags);
        assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"));

        q = replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags);
        assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}"));

        r = replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags);
        assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"));

        p = replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags);
        assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"));

        x = replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags);
        assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"));
}

static void test_replace_env_argv(void) {
        const char *env[] = {
                "FOO=BAR BAR",
                "BAR=waldo",
                NULL
        };
        const char *line[] = {
                "FOO$FOO",
                "FOO$FOOFOO",
                "FOO${FOO}$FOO",
                "FOO${FOO}",
                "${FOO}",
                "$FOO",
                "$FOO$FOO",
                "${FOO}${BAR}",
                "${FOO",
                "FOO$$${FOO}",
                "$$FOO${FOO}",
                "${FOO:-${BAR}}",
                "${QUUX:-${FOO}}",
                "${FOO:+${BAR}}",
                "${QUUX:+${BAR}}",
                "${FOO:+|${BAR}|}}",
                "${FOO:+|${BAR}{|}",
                NULL
        };
        _cleanup_strv_free_ char **r = NULL;

        r = replace_env_argv((char**) line, (char**) env);
        assert_se(r);
        assert_se(streq(r[0], "FOO$FOO"));
        assert_se(streq(r[1], "FOO$FOOFOO"));
        assert_se(streq(r[2], "FOOBAR BAR$FOO"));
        assert_se(streq(r[3], "FOOBAR BAR"));
        assert_se(streq(r[4], "BAR BAR"));
        assert_se(streq(r[5], "BAR"));
        assert_se(streq(r[6], "BAR"));
        assert_se(streq(r[7], "BAR BARwaldo"));
        assert_se(streq(r[8], "${FOO"));
        assert_se(streq(r[9], "FOO$BAR BAR"));
        assert_se(streq(r[10], "$FOOBAR BAR"));
        assert_se(streq(r[11], "${FOO:-waldo}"));
        assert_se(streq(r[12], "${QUUX:-BAR BAR}"));
        assert_se(streq(r[13], "${FOO:+waldo}"));
        assert_se(streq(r[14], "${QUUX:+waldo}"));
        assert_se(streq(r[15], "${FOO:+|waldo|}}"));
        assert_se(streq(r[16], "${FOO:+|waldo{|}"));
        assert_se(strv_length(r) == 17);
}

static void test_env_clean(void) {
        _cleanup_strv_free_ char **e;

        e = strv_new("FOOBAR=WALDO",
                     "FOOBAR=WALDO",
                     "FOOBAR",
                     "F",
                     "X=",
                     "F=F",
                     "=",
                     "=F",
                     "",
                     "0000=000",
                     "äöüß=abcd",
                     "abcd=äöüß",
                     "xyz\n=xyz",
                     "xyz=xyz\n",
                     "another=one",
                     "another=final one");
        assert_se(e);
        assert_se(!strv_env_is_valid(e));
        assert_se(strv_env_clean(e) == e);
        assert_se(strv_env_is_valid(e));

        assert_se(streq(e[0], "FOOBAR=WALDO"));
        assert_se(streq(e[1], "X="));
        assert_se(streq(e[2], "F=F"));
        assert_se(streq(e[3], "abcd=äöüß"));
        assert_se(streq(e[4], "xyz=xyz\n"));
        assert_se(streq(e[5], "another=final one"));
        assert_se(e[6] == NULL);
}

static void test_env_name_is_valid(void) {
        assert_se(env_name_is_valid("test"));

        assert_se(!env_name_is_valid(NULL));
        assert_se(!env_name_is_valid(""));
        assert_se(!env_name_is_valid("xxx\a"));
        assert_se(!env_name_is_valid("xxx\007b"));
        assert_se(!env_name_is_valid("\007\009"));
        assert_se(!env_name_is_valid("5_starting_with_a_number_is_wrong"));
        assert_se(!env_name_is_valid("#¤%&?_only_numbers_letters_and_underscore_allowed"));
}

static void test_env_value_is_valid(void) {
        assert_se(env_value_is_valid(""));
        assert_se(env_value_is_valid("głąb kapuściany"));
        assert_se(env_value_is_valid("printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
        assert_se(env_value_is_valid("tab\tcharacter"));
        assert_se(env_value_is_valid("new\nline"));
}

static void test_env_assignment_is_valid(void) {
        assert_se(env_assignment_is_valid("a="));
        assert_se(env_assignment_is_valid("b=głąb kapuściany"));
        assert_se(env_assignment_is_valid("c=\\007\\009\\011"));
        assert_se(env_assignment_is_valid("e=printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
        assert_se(env_assignment_is_valid("f=tab\tcharacter"));
        assert_se(env_assignment_is_valid("g=new\nline"));

        assert_se(!env_assignment_is_valid("="));
        assert_se(!env_assignment_is_valid("a b="));
        assert_se(!env_assignment_is_valid("a ="));
        assert_se(!env_assignment_is_valid(" b="));
        /* no dots or dashes: http://tldp.org/LDP/abs/html/gotchas.html */
        assert_se(!env_assignment_is_valid("a.b="));
        assert_se(!env_assignment_is_valid("a-b="));
        assert_se(!env_assignment_is_valid("\007=głąb kapuściany"));
        assert_se(!env_assignment_is_valid("c\009=\007\009\011"));
        assert_se(!env_assignment_is_valid("głąb=printf \"\x1b]0;<mock-chroot>\x07<mock-chroot>\""));
}

int main(int argc, char *argv[]) {
        test_strv_env_delete();
        test_strv_env_get();
        test_strv_env_unset();
        test_strv_env_set();
        test_strv_env_merge();
        test_env_strv_get_n();
        test_replace_env(false);
        test_replace_env(true);
        test_replace_env2(false);
        test_replace_env2(true);
        test_replace_env_argv();
        test_env_clean();
        test_env_name_is_valid();
        test_env_value_is_valid();
        test_env_assignment_is_valid();

        return 0;
}
Commit	Line	Data
53e1b683	1	/* SPDX-License-Identifier: LGPL-2.1+ */
c24eb49e	2
c24eb49e	3
4d1a6904	4	#include "env-util.h"
a096d8c8 ZJS	5	#include "fd-util.h"
a096d8c8 ZJS	6	#include "fileio.h"
75e7d50e	7	#include "fs-util.h"
d68c645b	8	#include "serialize.h"
07630cea LP	9	#include "string-util.h"
	10	#include "strv.h"
	11	#include "util.h"
c24eb49e	12
940bd473 TA	13	static void test_strv_env_delete(void) {
	14	_cleanup_strv_free_ char a = NULL, b = NULL, c = NULL, d = NULL;
	15
bea1a013	16	a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
9b5d6bd9 LP	17	assert_se(a);
9b5d6bd9 LP	18
bea1a013	19	b = strv_new("PIEP", "FOO");
9b5d6bd9 LP	20	assert_se(b);
9b5d6bd9 LP	21
bea1a013	22	c = strv_new("SCHLUMPF");
9b5d6bd9	23	assert_se(c);
940bd473 TA	24
940bd473 TA	25	d = strv_env_delete(a, 2, b, c);
9b5d6bd9	26	assert_se(d);
940bd473	27
9b5d6bd9 LP	28	assert_se(streq(d[0], "WALDO=WALDO"));
	29	assert_se(streq(d[1], "WALDO="));
	30	assert_se(strv_length(d) == 2);
940bd473 TA	31	}
940bd473 TA	32
6162512c RS	33	static void test_strv_env_get(void) {
	34	char **l;
	35
	36	l = STRV_MAKE("ONE_OR_TWO=1", "THREE=3", "ONE_OR_TWO=2", "FOUR=4");
	37
	38	assert_se(streq(strv_env_get(l, "ONE_OR_TWO"), "2"));
	39	assert_se(streq(strv_env_get(l, "THREE"), "3"));
	40	assert_se(streq(strv_env_get(l, "FOUR"), "4"));
	41	}
	42
940bd473 TA	43	static void test_strv_env_unset(void) {
	44	_cleanup_strv_free_ char **l = NULL;
	45
bea1a013	46	l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
9b5d6bd9	47	assert_se(l);
940bd473	48
9b5d6bd9	49	assert_se(strv_env_unset(l, "SCHLUMPF") == l);
940bd473	50
9b5d6bd9 LP	51	assert_se(streq(l[0], "PIEP"));
	52	assert_se(streq(l[1], "NANANANA=YES"));
	53	assert_se(strv_length(l) == 2);
940bd473 TA	54	}
	55
	56	static void test_strv_env_set(void) {
	57	_cleanup_strv_free_ char l = NULL, r = NULL;
	58
bea1a013	59	l = strv_new("PIEP", "SCHLUMPF=SMURFF", "NANANANA=YES");
9b5d6bd9	60	assert_se(l);
940bd473 TA	61
940bd473 TA	62	r = strv_env_set(l, "WALDO=WALDO");
9b5d6bd9	63	assert_se(r);
940bd473	64
9b5d6bd9 LP	65	assert_se(streq(r[0], "PIEP"));
	66	assert_se(streq(r[1], "SCHLUMPF=SMURFF"));
	67	assert_se(streq(r[2], "NANANANA=YES"));
	68	assert_se(streq(r[3], "WALDO=WALDO"));
	69	assert_se(strv_length(r) == 4);
940bd473 TA	70	}
940bd473 TA	71
1f28b2de TA	72	static void test_strv_env_merge(void) {
	73	_cleanup_strv_free_ char a = NULL, b = NULL, **r = NULL;
	74
bea1a013	75	a = strv_new("FOO=BAR", "WALDO=WALDO", "WALDO=", "PIEP", "SCHLUMPF=SMURF");
9b5d6bd9 LP	76	assert_se(a);
9b5d6bd9 LP	77
bea1a013	78	b = strv_new("FOO=KKK", "FOO=", "PIEP=", "SCHLUMPF=SMURFF", "NANANANA=YES");
9b5d6bd9	79	assert_se(b);
c24eb49e	80
1f28b2de	81	r = strv_env_merge(2, a, b);
9b5d6bd9 LP	82	assert_se(r);
	83	assert_se(streq(r[0], "FOO="));
	84	assert_se(streq(r[1], "WALDO="));
	85	assert_se(streq(r[2], "PIEP"));
	86	assert_se(streq(r[3], "SCHLUMPF=SMURFF"));
	87	assert_se(streq(r[4], "PIEP="));
	88	assert_se(streq(r[5], "NANANANA=YES"));
	89	assert_se(strv_length(r) == 6);
	90
	91	assert_se(strv_env_clean(r) == r);
	92	assert_se(streq(r[0], "FOO="));
	93	assert_se(streq(r[1], "WALDO="));
	94	assert_se(streq(r[2], "SCHLUMPF=SMURFF"));
	95	assert_se(streq(r[3], "PIEP="));
	96	assert_se(streq(r[4], "NANANANA=YES"));
	97	assert_se(strv_length(r) == 5);
1f28b2de TA	98	}
1f28b2de TA	99
37f3ffca RS	100	static void test_env_strv_get_n(void) {
	101	const char *_env[] = {
	102	"FOO=NO NO NO",
	103	"FOO=BAR BAR",
	104	"BAR=waldo",
	105	"PATH=unset",
	106	NULL
	107	};
	108	char env = (char) _env;
	109
	110	assert_se(streq(strv_env_get_n(env, "FOO__", 3, 0), "BAR BAR"));
	111	assert_se(streq(strv_env_get_n(env, "FOO__", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
	112	assert_se(streq(strv_env_get_n(env, "FOO", 3, 0), "BAR BAR"));
	113	assert_se(streq(strv_env_get_n(env, "FOO", 3, REPLACE_ENV_USE_ENVIRONMENT), "BAR BAR"));
	114
	115	assert_se(streq(strv_env_get_n(env, "PATH__", 4, 0), "unset"));
	116	assert_se(streq(strv_env_get_n(env, "PATH", 4, 0), "unset"));
	117	assert_se(streq(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
	118	assert_se(streq(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT), "unset"));
	119
	120	env[3] = NULL; /* kill our $PATH */
	121
	122	assert_se(!strv_env_get_n(env, "PATH__", 4, 0));
	123	assert_se(!strv_env_get_n(env, "PATH", 4, 0));
1890c538 ZJS	124	assert_se(streq_ptr(strv_env_get_n(env, "PATH__", 4, REPLACE_ENV_USE_ENVIRONMENT),
	125	getenv("PATH")));
	126	assert_se(streq_ptr(strv_env_get_n(env, "PATH", 4, REPLACE_ENV_USE_ENVIRONMENT),
	127	getenv("PATH")));
37f3ffca RS	128	}
37f3ffca RS	129
ccad1fd0 ZJS	130	static void test_replace_env(bool braceless) {
	131	const char *env[] = {
	132	"FOO=BAR BAR",
	133	"BAR=waldo",
	134	NULL
	135	};
	136	_cleanup_free_ char t = NULL, s = NULL, q = NULL, r = NULL, *p = NULL;
	137	unsigned flags = REPLACE_ENV_ALLOW_BRACELESS*braceless;
	138
	139	t = replace_env("FOO=$FOO=${FOO}", (char**) env, flags);
	140	assert_se(streq(t, braceless ? "FOO=BAR BAR=BAR BAR" : "FOO=$FOO=BAR BAR"));
	141
	142	s = replace_env("BAR=$BAR=${BAR}", (char**) env, flags);
	143	assert_se(streq(s, braceless ? "BAR=waldo=waldo" : "BAR=$BAR=waldo"));
	144
	145	q = replace_env("BARBAR=$BARBAR=${BARBAR}", (char**) env, flags);
	146	assert_se(streq(q, braceless ? "BARBAR==" : "BARBAR=$BARBAR="));
	147
a93236aa ZJS	148	r = replace_env("BAR=$BAR$BAR${BAR}${BAR}", (char**) env, flags);
a93236aa ZJS	149	assert_se(streq(r, braceless ? "BAR=waldowaldowaldowaldo" : "BAR=$BAR$BARwaldowaldo"));
ccad1fd0 ZJS	150
	151	p = replace_env("${BAR}$BAR$BAR", (char**) env, flags);
	152	assert_se(streq(p, braceless ? "waldowaldowaldo" : "waldo$BAR$BAR"));
	153	}
	154
f50ce8fc ZJS	155	static void test_replace_env2(bool extended) {
	156	const char *env[] = {
	157	"FOO=foo",
	158	"BAR=bar",
	159	NULL
	160	};
	161	_cleanup_free_ char t = NULL, s = NULL, q = NULL, r = NULL, p = NULL, x = NULL;
	162	unsigned flags = REPLACE_ENV_ALLOW_EXTENDED*extended;
	163
	164	t = replace_env("FOO=${FOO:-${BAR}}", (char**) env, flags);
	165	assert_se(streq(t, extended ? "FOO=foo" : "FOO=${FOO:-bar}"));
	166
	167	s = replace_env("BAR=${XXX:-${BAR}}", (char**) env, flags);
	168	assert_se(streq(s, extended ? "BAR=bar" : "BAR=${XXX:-bar}"));
	169
	170	q = replace_env("XXX=${XXX:+${BAR}}", (char**) env, flags);
	171	assert_se(streq(q, extended ? "XXX=" : "XXX=${XXX:+bar}"));
	172
	173	r = replace_env("FOO=${FOO:+${BAR}}", (char**) env, flags);
	174	assert_se(streq(r, extended ? "FOO=bar" : "FOO=${FOO:+bar}"));
	175
	176	p = replace_env("FOO=${FOO:-${BAR}post}", (char**) env, flags);
	177	assert_se(streq(p, extended ? "FOO=foo" : "FOO=${FOO:-barpost}"));
	178
	179	x = replace_env("XXX=${XXX:+${BAR}post}", (char**) env, flags);
	180	assert_se(streq(x, extended ? "XXX=" : "XXX=${XXX:+barpost}"));
	181	}
	182
ccad1fd0	183	static void test_replace_env_argv(void) {
c24eb49e LP	184	const char *env[] = {
	185	"FOO=BAR BAR",
	186	"BAR=waldo",
	187	NULL
	188	};
c24eb49e LP	189	const char *line[] = {
	190	"FOO$FOO",
	191	"FOO$FOOFOO",
	192	"FOO${FOO}$FOO",
	193	"FOO${FOO}",
	194	"${FOO}",
	195	"$FOO",
	196	"$FOO$FOO",
	197	"${FOO}${BAR}",
	198	"${FOO",
df553b58 MS	199	"FOO$$${FOO}",
df553b58 MS	200	"$$FOO${FOO}",
b82f58bf RS	201	"${FOO:-${BAR}}",
	202	"${QUUX:-${FOO}}",
	203	"${FOO:+${BAR}}",
	204	"${QUUX:+${BAR}}",
	205	"${FOO:+\|${BAR}\|}}",
	206	"${FOO:+\|${BAR}{\|}",
c24eb49e LP	207	NULL
c24eb49e LP	208	};
1f28b2de	209	_cleanup_strv_free_ char **r = NULL;
c24eb49e LP	210
c24eb49e LP	211	r = replace_env_argv((char) line, (char) env);
9b5d6bd9 LP	212	assert_se(r);
	213	assert_se(streq(r[0], "FOO$FOO"));
	214	assert_se(streq(r[1], "FOO$FOOFOO"));
	215	assert_se(streq(r[2], "FOOBAR BAR$FOO"));
	216	assert_se(streq(r[3], "FOOBAR BAR"));
	217	assert_se(streq(r[4], "BAR BAR"));
	218	assert_se(streq(r[5], "BAR"));
	219	assert_se(streq(r[6], "BAR"));
	220	assert_se(streq(r[7], "BAR BARwaldo"));
	221	assert_se(streq(r[8], "${FOO"));
df553b58 MS	222	assert_se(streq(r[9], "FOO$BAR BAR"));
df553b58 MS	223	assert_se(streq(r[10], "$FOOBAR BAR"));
b82f58bf RS	224	assert_se(streq(r[11], "${FOO:-waldo}"));
	225	assert_se(streq(r[12], "${QUUX:-BAR BAR}"));
	226	assert_se(streq(r[13], "${FOO:+waldo}"));
	227	assert_se(streq(r[14], "${QUUX:+waldo}"));
	228	assert_se(streq(r[15], "${FOO:+\|waldo\|}}"));
	229	assert_se(streq(r[16], "${FOO:+\|waldo{\|}"));
	230	assert_se(strv_length(r) == 17);
1f28b2de	231	}
a6ff950e	232
4d1a6904	233	static void test_env_clean(void) {
4d1a6904 LP	234	_cleanup_strv_free_ char **e;
	235
	236	e = strv_new("FOOBAR=WALDO",
	237	"FOOBAR=WALDO",
	238	"FOOBAR",
	239	"F",
	240	"X=",
	241	"F=F",
	242	"=",
	243	"=F",
	244	"",
	245	"0000=000",
	246	"äöüß=abcd",
	247	"abcd=äöüß",
	248	"xyz\n=xyz",
	249	"xyz=xyz\n",
	250	"another=one",
bea1a013	251	"another=final one");
9b5d6bd9 LP	252	assert_se(e);
	253	assert_se(!strv_env_is_valid(e));
	254	assert_se(strv_env_clean(e) == e);
	255	assert_se(strv_env_is_valid(e));
4d1a6904 LP	256
	257	assert_se(streq(e[0], "FOOBAR=WALDO"));
	258	assert_se(streq(e[1], "X="));
	259	assert_se(streq(e[2], "F=F"));
	260	assert_se(streq(e[3], "abcd=äöüß"));
b4346b9a FB	261	assert_se(streq(e[4], "xyz=xyz\n"));
	262	assert_se(streq(e[5], "another=final one"));
	263	assert_se(e[6] == NULL);
4d1a6904 LP	264	}
4d1a6904 LP	265
8354c34e TA	266	static void test_env_name_is_valid(void) {
	267	assert_se(env_name_is_valid("test"));
	268
	269	assert_se(!env_name_is_valid(NULL));
	270	assert_se(!env_name_is_valid(""));
b8c83cfc ZJS	271	assert_se(!env_name_is_valid("xxx\a"));
	272	assert_se(!env_name_is_valid("xxx\007b"));
	273	assert_se(!env_name_is_valid("\007\009"));
8354c34e TA	274	assert_se(!env_name_is_valid("5_starting_with_a_number_is_wrong"));
	275	assert_se(!env_name_is_valid("#¤%&?_only_numbers_letters_and_underscore_allowed"));
	276	}
	277
b8c83cfc ZJS	278	static void test_env_value_is_valid(void) {
	279	assert_se(env_value_is_valid(""));
	280	assert_se(env_value_is_valid("głąb kapuściany"));
	281	assert_se(env_value_is_valid("printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
b4346b9a FB	282	assert_se(env_value_is_valid("tab\tcharacter"));
b4346b9a FB	283	assert_se(env_value_is_valid("new\nline"));
b8c83cfc ZJS	284	}
	285
	286	static void test_env_assignment_is_valid(void) {
	287	assert_se(env_assignment_is_valid("a="));
	288	assert_se(env_assignment_is_valid("b=głąb kapuściany"));
	289	assert_se(env_assignment_is_valid("c=\\007\\009\\011"));
	290	assert_se(env_assignment_is_valid("e=printf \"\\x1b]0;<mock-chroot>\\x07<mock-chroot>\""));
b4346b9a FB	291	assert_se(env_assignment_is_valid("f=tab\tcharacter"));
b4346b9a FB	292	assert_se(env_assignment_is_valid("g=new\nline"));
b8c83cfc ZJS	293
	294	assert_se(!env_assignment_is_valid("="));
	295	assert_se(!env_assignment_is_valid("a b="));
	296	assert_se(!env_assignment_is_valid("a ="));
	297	assert_se(!env_assignment_is_valid(" b="));
	298	/* no dots or dashes: http://tldp.org/LDP/abs/html/gotchas.html */
	299	assert_se(!env_assignment_is_valid("a.b="));
	300	assert_se(!env_assignment_is_valid("a-b="));
	301	assert_se(!env_assignment_is_valid("\007=głąb kapuściany"));
	302	assert_se(!env_assignment_is_valid("c\009=\007\009\011"));
	303	assert_se(!env_assignment_is_valid("głąb=printf \"\x1b]0;<mock-chroot>\x07<mock-chroot>\""));
	304	}
	305
1f28b2de	306	int main(int argc, char *argv[]) {
940bd473	307	test_strv_env_delete();
6162512c	308	test_strv_env_get();
940bd473 TA	309	test_strv_env_unset();
940bd473 TA	310	test_strv_env_set();
1f28b2de	311	test_strv_env_merge();
37f3ffca	312	test_env_strv_get_n();
ccad1fd0 ZJS	313	test_replace_env(false);
ccad1fd0 ZJS	314	test_replace_env(true);
f50ce8fc ZJS	315	test_replace_env2(false);
f50ce8fc ZJS	316	test_replace_env2(true);
ccad1fd0	317	test_replace_env_argv();
4d1a6904	318	test_env_clean();
8354c34e	319	test_env_name_is_valid();
b8c83cfc ZJS	320	test_env_value_is_valid();
b8c83cfc ZJS	321	test_env_assignment_is_valid();
a6ff950e	322
5f7c426e	323	return 0;
c24eb49e	324	}