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

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

#include <string.h>

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