chiark / gitweb /
core: add new .slice unit type for partitioning systems
[elogind.git] / src / test / test-strv.c
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 void test_strv_find(void) {
46         const char * const input_table[] = {
47                 "one",
48                 "two",
49                 "three",
50                 NULL
51         };
52
53         assert_se(strv_find((char **)input_table, "three"));
54         assert_se(!strv_find((char **)input_table, "four"));
55 }
56
57 static void test_strv_find_prefix(void) {
58         const char * const input_table[] = {
59                 "one",
60                 "two",
61                 "three",
62                 NULL
63         };
64
65         assert_se(strv_find_prefix((char **)input_table, "o"));
66         assert_se(strv_find_prefix((char **)input_table, "one"));
67         assert_se(strv_find_prefix((char **)input_table, ""));
68         assert_se(!strv_find_prefix((char **)input_table, "xxx"));
69         assert_se(!strv_find_prefix((char **)input_table, "onee"));
70 }
71
72 static void test_strv_join(void) {
73         _cleanup_free_ char *p = NULL, *q = NULL, *r = NULL, *s = NULL, *t = NULL;
74
75         const char * const input_table_multiple[] = {
76                 "one",
77                 "two",
78                 "three",
79                 NULL
80         };
81         const char * const input_table_one[] = {
82                 "one",
83                 NULL
84         };
85         const char * const input_table_none[] = {
86                 NULL
87         };
88
89         p = strv_join((char **)input_table_multiple, ", ");
90         assert_se(p);
91         assert_se(streq(p, "one, two, three"));
92
93         q = strv_join((char **)input_table_multiple, ";");
94         assert_se(q);
95         assert_se(streq(q, "one;two;three"));
96
97         r = strv_join((char **)input_table_multiple, NULL);
98         assert_se(r);
99         assert_se(streq(r, "one two three"));
100
101         s = strv_join((char **)input_table_one, ", ");
102         assert_se(s);
103         assert_se(streq(s, "one"));
104
105         t = strv_join((char **)input_table_none, ", ");
106         assert_se(t);
107         assert_se(streq(t, ""));
108 }
109
110 static void test_strv_split_nulstr(void) {
111         _cleanup_strv_free_ char **l = NULL;
112         const char nulstr[] = "str0\0str1\0str2\0str3\0";
113
114         l = strv_split_nulstr (nulstr);
115         assert_se(l);
116
117         assert_se(streq(l[0], "str0"));
118         assert_se(streq(l[1], "str1"));
119         assert_se(streq(l[2], "str2"));
120         assert_se(streq(l[3], "str3"));
121 }
122
123 static void test_strv_parse_nulstr(void) {
124         _cleanup_strv_free_ char **l = NULL;
125         const char nulstr[] = "fuck\0fuck2\0fuck3\0\0fuck5\0\0xxx";
126
127         l = strv_parse_nulstr(nulstr, sizeof(nulstr)-1);
128         assert_se(l);
129         puts("Parse nulstr:");
130         strv_print(l);
131
132         assert_se(streq(l[0], "fuck"));
133         assert_se(streq(l[1], "fuck2"));
134         assert_se(streq(l[2], "fuck3"));
135         assert_se(streq(l[3], ""));
136         assert_se(streq(l[4], "fuck5"));
137         assert_se(streq(l[5], ""));
138         assert_se(streq(l[6], "xxx"));
139 }
140
141 static void test_strv_overlap(void) {
142         const char * const input_table[] = {
143                 "one",
144                 "two",
145                 "three",
146                 NULL
147         };
148         const char * const input_table_overlap[] = {
149                 "two",
150                 NULL
151         };
152         const char * const input_table_unique[] = {
153                 "four",
154                 "five",
155                 "six",
156                 NULL
157         };
158
159         assert_se(strv_overlap((char **)input_table, (char**)input_table_overlap));
160         assert_se(!strv_overlap((char **)input_table, (char**)input_table_unique));
161 }
162
163 static void test_strv_sort(void) {
164         const char* input_table[] = {
165                 "durian",
166                 "apple",
167                 "citrus",
168                  "CAPITAL LETTERS FIRST",
169                 "banana",
170                 NULL
171         };
172
173         strv_sort((char **)input_table);
174
175         assert_se(streq(input_table[0], "CAPITAL LETTERS FIRST"));
176         assert_se(streq(input_table[1], "apple"));
177         assert_se(streq(input_table[2], "banana"));
178         assert_se(streq(input_table[3], "citrus"));
179         assert_se(streq(input_table[4], "durian"));
180 }
181
182 static void test_strv_merge_concat(void) {
183          _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL;
184
185         a = strv_new("without", "suffix", NULL);
186         b = strv_new("with", "suffix", NULL);
187         assert_se(a);
188         assert_se(b);
189
190         c = strv_merge_concat(a, b, "_suffix");
191         assert_se(c);
192
193         assert_se(streq(c[0], "without"));
194         assert_se(streq(c[1], "suffix"));
195         assert_se(streq(c[2], "with_suffix"));
196         assert_se(streq(c[3], "suffix_suffix"));
197 }
198
199 static void test_strv_merge(void) {
200          _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL;
201
202         a = strv_new("abc", "def", "ghi", NULL);
203         b = strv_new("jkl", "mno", "pqr", NULL);
204         assert_se(a);
205         assert_se(b);
206
207         c = strv_merge(a, b);
208         assert_se(c);
209
210         assert_se(streq(c[0], "abc"));
211         assert_se(streq(c[1], "def"));
212         assert_se(streq(c[2], "ghi"));
213         assert_se(streq(c[3], "jkl"));
214         assert_se(streq(c[4], "mno"));
215         assert_se(streq(c[5], "pqr"));
216
217         assert_se(strv_length(c) == 6);
218 }
219
220 static void test_strv_append(void) {
221         _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL;
222
223         a = strv_new("test", "test1", NULL);
224         assert_se(a);
225         b = strv_append(a, "test2");
226         c = strv_append(NULL, "test3");
227         assert_se(b);
228         assert_se(c);
229
230         assert_se(streq(b[0], "test"));
231         assert_se(streq(b[1], "test1"));
232         assert_se(streq(b[2], "test2"));
233         assert_se(streq(c[0], "test3"));
234 }
235
236 static void test_strv_foreach_pair(void) {
237         _cleanup_strv_free_ char **a = NULL;
238         char **x, **y;
239
240         a = strv_new("pair_one",   "pair_one",
241                      "pair_two",   "pair_two",
242                      "pair_three", "pair_three",
243                      NULL);
244
245         STRV_FOREACH_PAIR(x, y, a) {
246                 assert_se(streq(*x, *y));
247         }
248 }
249
250 int main(int argc, char *argv[]) {
251         test_specifier_printf();
252         test_strv_foreach_pair();
253         test_strv_find();
254         test_strv_find_prefix();
255         test_strv_join();
256         test_strv_split_nulstr();
257         test_strv_parse_nulstr();
258         test_strv_overlap();
259         test_strv_sort();
260         test_strv_merge();
261         test_strv_merge_concat();
262         test_strv_append();
263
264         return 0;
265 }