[thirdparty/systemd.git] / src / test / test-strv.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering
  Copyright 2013 Thomas H.P. Andersen

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <string.h>

#include "util.h"
#include "specifier.h"
#include "strv.h"

static void test_specifier_printf(void) {
        _cleanup_free_ char *w = NULL;

        const Specifier table[] = {
                { 'a', specifier_string, (char*) "AAAA" },
                { 'b', specifier_string, (char*) "BBBB" },
                { 0, NULL, NULL }
        };

        w = specifier_printf("xxx a=%a b=%b yyy", table, NULL);
        puts(w);

        assert_se(w);
        assert_se(streq(w, "xxx a=AAAA b=BBBB yyy"));
}

static const char* const input_table_multiple[] = {
        "one",
        "two",
        "three",
        NULL,
};

static const char* const input_table_one[] = {
        "one",
        NULL,
};

static const char* const input_table_none[] = {
        NULL,
};

static const char* const input_table_quotes[] = {
        "\"",
        "'",
        "\"\"",
        "\\",
        "\\\\",
        NULL,
};
#define QUOTES_STRING                            \
        "\"\\\"\" "                              \
        "\"\\\'\" "                              \
        "\"\\\"\\\"\" "                          \
        "\"\\\\\" "                              \
        "\"\\\\\\\\\""

static const char * const input_table_spaces[] = {
        " ",
        "' '",
        "\" ",
        " \"",
        " \\\\ ",
        NULL,
};
#define SPACES_STRING                           \
        "\" \" "                                \
        "\"\\' \\'\" "                          \
        "\"\\\" \" "                            \
        "\" \\\"\" "                            \
        "\" \\\\\\\\ \""

static void test_strv_find(void) {
        assert_se(strv_find((char **)input_table_multiple, "three"));
        assert_se(!strv_find((char **)input_table_multiple, "four"));
}

static void test_strv_find_prefix(void) {
        assert_se(strv_find_prefix((char **)input_table_multiple, "o"));
        assert_se(strv_find_prefix((char **)input_table_multiple, "one"));
        assert_se(strv_find_prefix((char **)input_table_multiple, ""));
        assert_se(!strv_find_prefix((char **)input_table_multiple, "xxx"));
        assert_se(!strv_find_prefix((char **)input_table_multiple, "onee"));
}

static void test_strv_join(void) {
        _cleanup_free_ char *p = NULL, *q = NULL, *r = NULL, *s = NULL, *t = NULL;

        p = strv_join((char **)input_table_multiple, ", ");
        assert_se(p);
        assert_se(streq(p, "one, two, three"));

        q = strv_join((char **)input_table_multiple, ";");
        assert_se(q);
        assert_se(streq(q, "one;two;three"));

        r = strv_join((char **)input_table_multiple, NULL);
        assert_se(r);
        assert_se(streq(r, "one two three"));

        s = strv_join((char **)input_table_one, ", ");
        assert_se(s);
        assert_se(streq(s, "one"));

        t = strv_join((char **)input_table_none, ", ");
        assert_se(t);
        assert_se(streq(t, ""));
}

static void test_strv_quote_unquote(const char* const *split, const char *quoted) {
        _cleanup_free_ char *p;
        _cleanup_strv_free_ char **s;
        char **t;

        p = strv_join_quoted((char **)split);
        printf("-%s- --- -%s-\n", p, quoted); /* fprintf deals with NULL, puts does not */
        assert_se(p);
        assert_se(streq(p, quoted));

        s = strv_split_quoted(quoted);
        assert_se(s);
        STRV_FOREACH(t, s) {
                assert_se(*t);
                assert_se(streq(*t, *split));
                split++;
        }
}

static void test_strv_split_nulstr(void) {
        _cleanup_strv_free_ char **l = NULL;
        const char nulstr[] = "str0\0str1\0str2\0str3\0";

        l = strv_split_nulstr (nulstr);
        assert_se(l);

        assert_se(streq(l[0], "str0"));
        assert_se(streq(l[1], "str1"));
        assert_se(streq(l[2], "str2"));
        assert_se(streq(l[3], "str3"));
}

static void test_strv_parse_nulstr(void) {
        _cleanup_strv_free_ char **l = NULL;
        const char nulstr[] = "fuck\0fuck2\0fuck3\0\0fuck5\0\0xxx";

        l = strv_parse_nulstr(nulstr, sizeof(nulstr)-1);
        assert_se(l);
        puts("Parse nulstr:");
        strv_print(l);

        assert_se(streq(l[0], "fuck"));
        assert_se(streq(l[1], "fuck2"));
        assert_se(streq(l[2], "fuck3"));
        assert_se(streq(l[3], ""));
        assert_se(streq(l[4], "fuck5"));
        assert_se(streq(l[5], ""));
        assert_se(streq(l[6], "xxx"));
}

static void test_strv_overlap(void) {
        const char * const input_table[] = {
                "one",
                "two",
                "three",
                NULL
        };
        const char * const input_table_overlap[] = {
                "two",
                NULL
        };
        const char * const input_table_unique[] = {
                "four",
                "five",
                "six",
                NULL
        };

        assert_se(strv_overlap((char **)input_table, (char**)input_table_overlap));
        assert_se(!strv_overlap((char **)input_table, (char**)input_table_unique));
}

static void test_strv_sort(void) {
        const char* input_table[] = {
                "durian",
                "apple",
                "citrus",
                 "CAPITAL LETTERS FIRST",
                "banana",
                NULL
        };

        strv_sort((char **)input_table);

        assert_se(streq(input_table[0], "CAPITAL LETTERS FIRST"));
        assert_se(streq(input_table[1], "apple"));
        assert_se(streq(input_table[2], "banana"));
        assert_se(streq(input_table[3], "citrus"));
        assert_se(streq(input_table[4], "durian"));
}

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

        a = strv_new("without", "suffix", NULL);
        b = strv_new("with", "suffix", NULL);
        assert_se(a);
        assert_se(b);

        c = strv_merge_concat(a, b, "_suffix");
        assert_se(c);

        assert_se(streq(c[0], "without"));
        assert_se(streq(c[1], "suffix"));
        assert_se(streq(c[2], "with_suffix"));
        assert_se(streq(c[3], "suffix_suffix"));
}

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

        a = strv_new("abc", "def", "ghi", NULL);
        b = strv_new("jkl", "mno", "pqr", NULL);
        assert_se(a);
        assert_se(b);

        c = strv_merge(a, b);
        assert_se(c);

        assert_se(streq(c[0], "abc"));
        assert_se(streq(c[1], "def"));
        assert_se(streq(c[2], "ghi"));
        assert_se(streq(c[3], "jkl"));
        assert_se(streq(c[4], "mno"));
        assert_se(streq(c[5], "pqr"));

        assert_se(strv_length(c) == 6);
}

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

        a = strv_new("test", "test1", NULL);
        assert_se(a);
        b = strv_append(a, "test2");
        c = strv_append(NULL, "test3");
        assert_se(b);
        assert_se(c);

        assert_se(streq(b[0], "test"));
        assert_se(streq(b[1], "test1"));
        assert_se(streq(b[2], "test2"));
        assert_se(streq(c[0], "test3"));
}

static void test_strv_foreach_pair(void) {
        _cleanup_strv_free_ char **a = NULL;
        char **x, **y;

        a = strv_new("pair_one",   "pair_one",
                     "pair_two",   "pair_two",
                     "pair_three", "pair_three",
                     NULL);

        STRV_FOREACH_PAIR(x, y, a) {
                assert_se(streq(*x, *y));
        }
}

int main(int argc, char *argv[]) {
        test_specifier_printf();
        test_strv_foreach_pair();
        test_strv_find();
        test_strv_find_prefix();
        test_strv_join();

        test_strv_quote_unquote(input_table_multiple, "\"one\" \"two\" \"three\"");
        test_strv_quote_unquote(input_table_one, "\"one\"");
        test_strv_quote_unquote(input_table_none, "");
        test_strv_quote_unquote(input_table_quotes, QUOTES_STRING);
        test_strv_quote_unquote(input_table_spaces, SPACES_STRING);

        test_strv_split_nulstr();
        test_strv_parse_nulstr();
        test_strv_overlap();
        test_strv_sort();
        test_strv_merge();
        test_strv_merge_concat();
        test_strv_append();

        return 0;
}
Commit	Line	Data
	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2010 Lennart Poettering
	7	Copyright 2013 Thomas H.P. Andersen
	8
	9	systemd is free software; you can redistribute it and/or modify it
	10	under the terms of the GNU Lesser General Public License as published by
	11	the Free Software Foundation; either version 2.1 of the License, or
	12	(at your option) any later version.
	13
	14	systemd is distributed in the hope that it will be useful, but
	15	WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License
	20	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	21	***/
	22
	23	#include <string.h>
	24
	25	#include "util.h"
	26	#include "specifier.h"
	27	#include "strv.h"
	28
	29	static void test_specifier_printf(void) {
	30	_cleanup_free_ char *w = NULL;
	31
	32	const Specifier table[] = {
	33	{ 'a', specifier_string, (char*) "AAAA" },
	34	{ 'b', specifier_string, (char*) "BBBB" },
	35	{ 0, NULL, NULL }
	36	};
	37
	38	w = specifier_printf("xxx a=%a b=%b yyy", table, NULL);
	39	puts(w);
	40
	41	assert_se(w);
	42	assert_se(streq(w, "xxx a=AAAA b=BBBB yyy"));
	43	}
	44
	45	static const char* const input_table_multiple[] = {
	46	"one",
	47	"two",
	48	"three",
	49	NULL,
	50	};
	51
	52	static const char* const input_table_one[] = {
	53	"one",
	54	NULL,
	55	};
	56
	57	static const char* const input_table_none[] = {
	58	NULL,
	59	};
	60
	61	static const char* const input_table_quotes[] = {
	62	"\"",
	63	"'",
	64	"\"\"",
	65	"\\",
	66	"\\\\",
	67	NULL,
	68	};
	69	#define QUOTES_STRING \
	70	"\"\\\"\" " \
	71	"\"\\\'\" " \
	72	"\"\\\"\\\"\" " \
	73	"\"\\\\\" " \
	74	"\"\\\\\\\\\""
	75
	76	static const char * const input_table_spaces[] = {
	77	" ",
	78	"' '",
	79	"\" ",
	80	" \"",
	81	" \\\\ ",
	82	NULL,
	83	};
	84	#define SPACES_STRING \
	85	"\" \" " \
	86	"\"\\' \\'\" " \
	87	"\"\\\" \" " \
	88	"\" \\\"\" " \
	89	"\" \\\\\\\\ \""
	90
	91	static void test_strv_find(void) {
	92	assert_se(strv_find((char **)input_table_multiple, "three"));
	93	assert_se(!strv_find((char **)input_table_multiple, "four"));
	94	}
	95
	96	static void test_strv_find_prefix(void) {
	97	assert_se(strv_find_prefix((char **)input_table_multiple, "o"));
	98	assert_se(strv_find_prefix((char **)input_table_multiple, "one"));
	99	assert_se(strv_find_prefix((char **)input_table_multiple, ""));
	100	assert_se(!strv_find_prefix((char **)input_table_multiple, "xxx"));
	101	assert_se(!strv_find_prefix((char **)input_table_multiple, "onee"));
	102	}
	103
	104	static void test_strv_join(void) {
	105	_cleanup_free_ char p = NULL, q = NULL, r = NULL, s = NULL, *t = NULL;
	106
	107	p = strv_join((char **)input_table_multiple, ", ");
	108	assert_se(p);
	109	assert_se(streq(p, "one, two, three"));
	110
	111	q = strv_join((char **)input_table_multiple, ";");
	112	assert_se(q);
	113	assert_se(streq(q, "one;two;three"));
	114
	115	r = strv_join((char **)input_table_multiple, NULL);
	116	assert_se(r);
	117	assert_se(streq(r, "one two three"));
	118
	119	s = strv_join((char **)input_table_one, ", ");
	120	assert_se(s);
	121	assert_se(streq(s, "one"));
	122
	123	t = strv_join((char **)input_table_none, ", ");
	124	assert_se(t);
	125	assert_se(streq(t, ""));
	126	}
	127
	128	static void test_strv_quote_unquote(const char* const split, const char quoted) {
	129	_cleanup_free_ char *p;
	130	_cleanup_strv_free_ char **s;
	131	char **t;
	132
	133	p = strv_join_quoted((char **)split);
	134	printf("-%s- --- -%s-\n", p, quoted); /* fprintf deals with NULL, puts does not */
	135	assert_se(p);
	136	assert_se(streq(p, quoted));
	137
	138	s = strv_split_quoted(quoted);
	139	assert_se(s);
	140	STRV_FOREACH(t, s) {
	141	assert_se(*t);
	142	assert_se(streq(t, split));
	143	split++;
	144	}
	145	}
	146
	147	static void test_strv_split_nulstr(void) {
	148	_cleanup_strv_free_ char **l = NULL;
	149	const char nulstr[] = "str0\0str1\0str2\0str3\0";
	150
	151	l = strv_split_nulstr (nulstr);
	152	assert_se(l);
	153
	154	assert_se(streq(l[0], "str0"));
	155	assert_se(streq(l[1], "str1"));
	156	assert_se(streq(l[2], "str2"));
	157	assert_se(streq(l[3], "str3"));
	158	}
	159
	160	static void test_strv_parse_nulstr(void) {
	161	_cleanup_strv_free_ char **l = NULL;
	162	const char nulstr[] = "fuck\0fuck2\0fuck3\0\0fuck5\0\0xxx";
	163
	164	l = strv_parse_nulstr(nulstr, sizeof(nulstr)-1);
	165	assert_se(l);
	166	puts("Parse nulstr:");
	167	strv_print(l);
	168
	169	assert_se(streq(l[0], "fuck"));
	170	assert_se(streq(l[1], "fuck2"));
	171	assert_se(streq(l[2], "fuck3"));
	172	assert_se(streq(l[3], ""));
	173	assert_se(streq(l[4], "fuck5"));
	174	assert_se(streq(l[5], ""));
	175	assert_se(streq(l[6], "xxx"));
	176	}
	177
	178	static void test_strv_overlap(void) {
	179	const char * const input_table[] = {
	180	"one",
	181	"two",
	182	"three",
	183	NULL
	184	};
	185	const char * const input_table_overlap[] = {
	186	"two",
	187	NULL
	188	};
	189	const char * const input_table_unique[] = {
	190	"four",
	191	"five",
	192	"six",
	193	NULL
	194	};
	195
	196	assert_se(strv_overlap((char )input_table, (char)input_table_overlap));
	197	assert_se(!strv_overlap((char )input_table, (char)input_table_unique));
	198	}
	199
	200	static void test_strv_sort(void) {
	201	const char* input_table[] = {
	202	"durian",
	203	"apple",
	204	"citrus",
	205	"CAPITAL LETTERS FIRST",
	206	"banana",
	207	NULL
	208	};
	209
	210	strv_sort((char **)input_table);
	211
	212	assert_se(streq(input_table[0], "CAPITAL LETTERS FIRST"));
	213	assert_se(streq(input_table[1], "apple"));
	214	assert_se(streq(input_table[2], "banana"));
	215	assert_se(streq(input_table[3], "citrus"));
	216	assert_se(streq(input_table[4], "durian"));
	217	}
	218
	219	static void test_strv_merge_concat(void) {
	220	_cleanup_strv_free_ char a = NULL, b = NULL, **c = NULL;
	221
	222	a = strv_new("without", "suffix", NULL);
	223	b = strv_new("with", "suffix", NULL);
	224	assert_se(a);
	225	assert_se(b);
	226
	227	c = strv_merge_concat(a, b, "_suffix");
	228	assert_se(c);
	229
	230	assert_se(streq(c[0], "without"));
	231	assert_se(streq(c[1], "suffix"));
	232	assert_se(streq(c[2], "with_suffix"));
	233	assert_se(streq(c[3], "suffix_suffix"));
	234	}
	235
	236	static void test_strv_merge(void) {
	237	_cleanup_strv_free_ char a = NULL, b = NULL, **c = NULL;
	238
	239	a = strv_new("abc", "def", "ghi", NULL);
	240	b = strv_new("jkl", "mno", "pqr", NULL);
	241	assert_se(a);
	242	assert_se(b);
	243
	244	c = strv_merge(a, b);
	245	assert_se(c);
	246
	247	assert_se(streq(c[0], "abc"));
	248	assert_se(streq(c[1], "def"));
	249	assert_se(streq(c[2], "ghi"));
	250	assert_se(streq(c[3], "jkl"));
	251	assert_se(streq(c[4], "mno"));
	252	assert_se(streq(c[5], "pqr"));
	253
	254	assert_se(strv_length(c) == 6);
	255	}
	256
	257	static void test_strv_append(void) {
	258	_cleanup_strv_free_ char a = NULL, b = NULL, **c = NULL;
	259
	260	a = strv_new("test", "test1", NULL);
	261	assert_se(a);
	262	b = strv_append(a, "test2");
	263	c = strv_append(NULL, "test3");
	264	assert_se(b);
	265	assert_se(c);
	266
	267	assert_se(streq(b[0], "test"));
	268	assert_se(streq(b[1], "test1"));
	269	assert_se(streq(b[2], "test2"));
	270	assert_se(streq(c[0], "test3"));
	271	}
	272
	273	static void test_strv_foreach_pair(void) {
	274	_cleanup_strv_free_ char **a = NULL;
	275	char x, y;
	276
	277	a = strv_new("pair_one", "pair_one",
	278	"pair_two", "pair_two",
	279	"pair_three", "pair_three",
	280	NULL);
	281
	282	STRV_FOREACH_PAIR(x, y, a) {
	283	assert_se(streq(x, y));
	284	}
	285	}
	286
	287	int main(int argc, char *argv[]) {
	288	test_specifier_printf();
	289	test_strv_foreach_pair();
	290	test_strv_find();
	291	test_strv_find_prefix();
	292	test_strv_join();
	293
	294	test_strv_quote_unquote(input_table_multiple, "\"one\" \"two\" \"three\"");
	295	test_strv_quote_unquote(input_table_one, "\"one\"");
	296	test_strv_quote_unquote(input_table_none, "");
	297	test_strv_quote_unquote(input_table_quotes, QUOTES_STRING);
	298	test_strv_quote_unquote(input_table_spaces, SPACES_STRING);
	299
	300	test_strv_split_nulstr();
	301	test_strv_parse_nulstr();
	302	test_strv_overlap();
	303	test_strv_sort();
	304	test_strv_merge();
	305	test_strv_merge_concat();
	306	test_strv_append();
	307
	308	return 0;
	309	}