Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <string.h>
4 : :
5 : : #include "alloc-util.h"
6 : : #include "escape.h"
7 : : #include "nulstr-util.h"
8 : : #include "specifier.h"
9 : : #include "string-util.h"
10 : : #include "strv.h"
11 : :
12 : 4 : static void test_specifier_printf(void) {
13 : : static const Specifier table[] = {
14 : : { 'a', specifier_string, (char*) "AAAA" },
15 : : { 'b', specifier_string, (char*) "BBBB" },
16 : : { 'm', specifier_machine_id, NULL },
17 : : { 'B', specifier_boot_id, NULL },
18 : : { 'H', specifier_host_name, NULL },
19 : : { 'v', specifier_kernel_release, NULL },
20 : : {}
21 : : };
22 : :
23 : 4 : _cleanup_free_ char *w = NULL;
24 : : int r;
25 : :
26 [ + - ]: 4 : log_info("/* %s */", __func__);
27 : :
28 : 4 : r = specifier_printf("xxx a=%a b=%b yyy", table, NULL, &w);
29 [ - + ]: 4 : assert_se(r >= 0);
30 [ - + ]: 4 : assert_se(w);
31 : :
32 : 4 : puts(w);
33 [ - + ]: 4 : assert_se(streq(w, "xxx a=AAAA b=BBBB yyy"));
34 : :
35 : 4 : free(w);
36 : 4 : r = specifier_printf("machine=%m, boot=%B, host=%H, version=%v", table, NULL, &w);
37 [ - + ]: 4 : assert_se(r >= 0);
38 [ - + ]: 4 : assert_se(w);
39 : 4 : puts(w);
40 : 4 : }
41 : :
42 : 4 : static void test_str_in_set(void) {
43 [ + - ]: 4 : log_info("/* %s */", __func__);
44 : :
45 [ - + ]: 4 : assert_se(STR_IN_SET("x", "x", "y", "z"));
46 [ - + ]: 4 : assert_se(!STR_IN_SET("X", "x", "y", "z"));
47 [ - + ]: 4 : assert_se(!STR_IN_SET("", "x", "y", "z"));
48 [ - + ]: 4 : assert_se(STR_IN_SET("x", "w", "x"));
49 : 4 : }
50 : :
51 : 4 : static void test_strptr_in_set(void) {
52 [ + - ]: 4 : log_info("/* %s */", __func__);
53 : :
54 [ + - + - : 4 : assert_se(STRPTR_IN_SET("x", "x", "y", "z"));
- + ]
55 [ + - - + : 4 : assert_se(!STRPTR_IN_SET("X", "x", "y", "z"));
- + ]
56 [ + - - + : 4 : assert_se(!STRPTR_IN_SET("", "x", "y", "z"));
- + ]
57 [ + - + - : 4 : assert_se(STRPTR_IN_SET("x", "w", "x"));
- + ]
58 : :
59 [ - + # # : 4 : assert_se(!STRPTR_IN_SET(NULL, "x", "y", "z"));
- + ]
60 [ - + # # : 4 : assert_se(!STRPTR_IN_SET(NULL, ""));
- + ]
61 : : /* strv cannot contain a null, hence the result below */
62 [ - + # # : 4 : assert_se(!STRPTR_IN_SET(NULL, NULL));
- + ]
63 : 4 : }
64 : :
65 : 4 : static void test_startswith_set(void) {
66 [ + - ]: 4 : log_info("/* %s */", __func__);
67 : :
68 [ - + + - : 16 : assert_se(!STARTSWITH_SET("foo", "bar", "baz", "waldo"));
+ + - + ]
69 [ - + + - : 8 : assert_se(!STARTSWITH_SET("foo", "bar"));
+ + - + ]
70 : :
71 [ + - + - : 4 : assert_se(STARTSWITH_SET("abc", "a", "ab", "abc"));
+ - - + ]
72 [ + + + - : 8 : assert_se(STARTSWITH_SET("abc", "ax", "ab", "abc"));
+ - - + ]
73 [ + + + - : 12 : assert_se(STARTSWITH_SET("abc", "ax", "abx", "abc"));
+ - - + ]
74 [ - + + - : 16 : assert_se(!STARTSWITH_SET("abc", "ax", "abx", "abcx"));
+ + - + ]
75 : :
76 [ + + + - : 12 : assert_se(streq_ptr(STARTSWITH_SET("foobar", "hhh", "kkk", "foo", "zzz"), "bar"));
+ - - + ]
77 [ + + + - : 12 : assert_se(streq_ptr(STARTSWITH_SET("foobar", "hhh", "kkk", "", "zzz"), "foobar"));
+ - - + ]
78 [ + + + - : 16 : assert_se(streq_ptr(STARTSWITH_SET("", "hhh", "kkk", "zzz", ""), ""));
+ - - + ]
79 : 4 : }
80 : :
81 : : static const char* const input_table_multiple[] = {
82 : : "one",
83 : : "two",
84 : : "three",
85 : : NULL,
86 : : };
87 : :
88 : : static const char* const input_table_quoted[] = {
89 : : "one",
90 : : " two\t three ",
91 : : " four five",
92 : : NULL,
93 : : };
94 : :
95 : : static const char* const input_table_one[] = {
96 : : "one",
97 : : NULL,
98 : : };
99 : :
100 : : static const char* const input_table_none[] = {
101 : : NULL,
102 : : };
103 : :
104 : : static const char* const input_table_two_empties[] = {
105 : : "",
106 : : "",
107 : : NULL,
108 : : };
109 : :
110 : : static const char* const input_table_one_empty[] = {
111 : : "",
112 : : NULL,
113 : : };
114 : :
115 : 4 : static void test_strv_find(void) {
116 [ + - ]: 4 : log_info("/* %s */", __func__);
117 : :
118 [ - + ]: 4 : assert_se(strv_find((char **)input_table_multiple, "three"));
119 [ - + ]: 4 : assert_se(!strv_find((char **)input_table_multiple, "four"));
120 : 4 : }
121 : :
122 : 4 : static void test_strv_find_prefix(void) {
123 [ + - ]: 4 : log_info("/* %s */", __func__);
124 : :
125 [ - + ]: 4 : assert_se(strv_find_prefix((char **)input_table_multiple, "o"));
126 [ - + ]: 4 : assert_se(strv_find_prefix((char **)input_table_multiple, "one"));
127 [ - + ]: 4 : assert_se(strv_find_prefix((char **)input_table_multiple, ""));
128 [ - + ]: 4 : assert_se(!strv_find_prefix((char **)input_table_multiple, "xxx"));
129 [ - + ]: 4 : assert_se(!strv_find_prefix((char **)input_table_multiple, "onee"));
130 : 4 : }
131 : :
132 : 4 : static void test_strv_find_startswith(void) {
133 : : char *r;
134 : :
135 [ + - ]: 4 : log_info("/* %s */", __func__);
136 : :
137 : 4 : r = strv_find_startswith((char **)input_table_multiple, "o");
138 [ + - - + ]: 4 : assert_se(r && streq(r, "ne"));
139 : :
140 : 4 : r = strv_find_startswith((char **)input_table_multiple, "one");
141 [ + - - + ]: 4 : assert_se(r && streq(r, ""));
142 : :
143 : 4 : r = strv_find_startswith((char **)input_table_multiple, "");
144 [ + - - + ]: 4 : assert_se(r && streq(r, "one"));
145 : :
146 [ - + ]: 4 : assert_se(!strv_find_startswith((char **)input_table_multiple, "xxx"));
147 [ - + ]: 4 : assert_se(!strv_find_startswith((char **)input_table_multiple, "onee"));
148 : 4 : }
149 : :
150 : 4 : static void test_strv_join(void) {
151 : 4 : _cleanup_free_ char *p = NULL, *q = NULL, *r = NULL, *s = NULL, *t = NULL, *v = NULL, *w = NULL;
152 : :
153 [ + - ]: 4 : log_info("/* %s */", __func__);
154 : :
155 : 4 : p = strv_join((char **)input_table_multiple, ", ");
156 [ - + ]: 4 : assert_se(p);
157 [ - + ]: 4 : assert_se(streq(p, "one, two, three"));
158 : :
159 : 4 : q = strv_join((char **)input_table_multiple, ";");
160 [ - + ]: 4 : assert_se(q);
161 [ - + ]: 4 : assert_se(streq(q, "one;two;three"));
162 : :
163 : 4 : r = strv_join((char **)input_table_multiple, NULL);
164 [ - + ]: 4 : assert_se(r);
165 [ - + ]: 4 : assert_se(streq(r, "one two three"));
166 : :
167 : 4 : s = strv_join((char **)input_table_one, ", ");
168 [ - + ]: 4 : assert_se(s);
169 [ - + ]: 4 : assert_se(streq(s, "one"));
170 : :
171 : 4 : t = strv_join((char **)input_table_none, ", ");
172 [ - + ]: 4 : assert_se(t);
173 [ - + ]: 4 : assert_se(streq(t, ""));
174 : :
175 : 4 : v = strv_join((char **)input_table_two_empties, ", ");
176 [ - + ]: 4 : assert_se(v);
177 [ - + ]: 4 : assert_se(streq(v, ", "));
178 : :
179 : 4 : w = strv_join((char **)input_table_one_empty, ", ");
180 [ - + ]: 4 : assert_se(w);
181 [ - + ]: 4 : assert_se(streq(w, ""));
182 : 4 : }
183 : :
184 : 4 : static void test_strv_join_prefix(void) {
185 : 4 : _cleanup_free_ char *p = NULL, *q = NULL, *r = NULL, *s = NULL, *t = NULL, *v = NULL, *w = NULL;
186 : :
187 [ + - ]: 4 : log_info("/* %s */", __func__);
188 : :
189 : 4 : p = strv_join_prefix((char **)input_table_multiple, ", ", "foo");
190 [ - + ]: 4 : assert_se(p);
191 [ - + ]: 4 : assert_se(streq(p, "fooone, footwo, foothree"));
192 : :
193 : 4 : q = strv_join_prefix((char **)input_table_multiple, ";", "foo");
194 [ - + ]: 4 : assert_se(q);
195 [ - + ]: 4 : assert_se(streq(q, "fooone;footwo;foothree"));
196 : :
197 : 4 : r = strv_join_prefix((char **)input_table_multiple, NULL, "foo");
198 [ - + ]: 4 : assert_se(r);
199 [ - + ]: 4 : assert_se(streq(r, "fooone footwo foothree"));
200 : :
201 : 4 : s = strv_join_prefix((char **)input_table_one, ", ", "foo");
202 [ - + ]: 4 : assert_se(s);
203 [ - + ]: 4 : assert_se(streq(s, "fooone"));
204 : :
205 : 4 : t = strv_join_prefix((char **)input_table_none, ", ", "foo");
206 [ - + ]: 4 : assert_se(t);
207 [ - + ]: 4 : assert_se(streq(t, ""));
208 : :
209 : 4 : v = strv_join_prefix((char **)input_table_two_empties, ", ", "foo");
210 [ - + ]: 4 : assert_se(v);
211 [ - + ]: 4 : assert_se(streq(v, "foo, foo"));
212 : :
213 : 4 : w = strv_join_prefix((char **)input_table_one_empty, ", ", "foo");
214 [ - + ]: 4 : assert_se(w);
215 [ - + ]: 4 : assert_se(streq(w, "foo"));
216 : 4 : }
217 : :
218 : 52 : static void test_strv_unquote(const char *quoted, char **list) {
219 : 52 : _cleanup_strv_free_ char **s;
220 : 52 : _cleanup_free_ char *j;
221 : 52 : unsigned i = 0;
222 : : char **t;
223 : : int r;
224 : :
225 [ + - ]: 52 : log_info("/* %s */", __func__);
226 : :
227 : 52 : r = strv_split_extract(&s, quoted, WHITESPACE, EXTRACT_UNQUOTE);
228 [ - + ]: 52 : assert_se(r == (int) strv_length(list));
229 [ - + ]: 52 : assert_se(s);
230 : 52 : j = strv_join(s, " | ");
231 [ - + ]: 52 : assert_se(j);
232 : 52 : puts(j);
233 : :
234 [ + - + + ]: 104 : STRV_FOREACH(t, s)
235 [ - + ]: 52 : assert_se(streq(list[i++], *t));
236 : :
237 [ - + ]: 52 : assert_se(list[i] == NULL);
238 : 52 : }
239 : :
240 : 28 : static void test_invalid_unquote(const char *quoted) {
241 : 28 : char **s = NULL;
242 : : int r;
243 : :
244 [ + - ]: 28 : log_info("/* %s */", __func__);
245 : :
246 : 28 : r = strv_split_extract(&s, quoted, WHITESPACE, EXTRACT_UNQUOTE);
247 [ - + ]: 28 : assert_se(s == NULL);
248 [ - + ]: 28 : assert_se(r == -EINVAL);
249 : 28 : }
250 : :
251 : 4 : static void test_strv_split(void) {
252 : 4 : _cleanup_(strv_free_erasep) char **l = NULL;
253 : 4 : const char str[] = "one,two,three";
254 : :
255 [ + - ]: 4 : log_info("/* %s */", __func__);
256 : :
257 : 4 : l = strv_split(str, ",");
258 [ - + ]: 4 : assert_se(l);
259 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_multiple));
260 : :
261 : 4 : strv_free_erase(l);
262 : :
263 : 4 : l = strv_split(" one two\t three", WHITESPACE);
264 [ - + ]: 4 : assert_se(l);
265 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_multiple));
266 : :
267 : 4 : strv_free_erase(l);
268 : :
269 : : /* Setting NULL for separator is equivalent to WHITESPACE */
270 : 4 : l = strv_split(" one two\t three", NULL);
271 [ - + ]: 4 : assert_se(l);
272 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_multiple));
273 : :
274 : 4 : strv_free_erase(l);
275 : :
276 : 4 : l = strv_split_full(" one two\t three", NULL, 0);
277 [ - + ]: 4 : assert_se(l);
278 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_multiple));
279 : :
280 : 4 : strv_free_erase(l);
281 : :
282 : 4 : l = strv_split_full(" 'one' \" two\t three \" ' four five'", NULL, SPLIT_QUOTES);
283 [ - + ]: 4 : assert_se(l);
284 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_quoted));
285 : :
286 : 4 : strv_free_erase(l);
287 : :
288 : : /* missing last quote ignores the last element. */
289 : 4 : l = strv_split_full(" 'one' \" two\t three \" ' four five' ' ignored element ", NULL, SPLIT_QUOTES);
290 [ - + ]: 4 : assert_se(l);
291 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_quoted));
292 : :
293 : 4 : strv_free_erase(l);
294 : :
295 : : /* missing last quote, but the last element is _not_ ignored with SPLIT_RELAX. */
296 : 4 : l = strv_split_full(" 'one' \" two\t three \" ' four five", NULL, SPLIT_QUOTES | SPLIT_RELAX);
297 [ - + ]: 4 : assert_se(l);
298 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_quoted));
299 : :
300 : 4 : strv_free_erase(l);
301 : :
302 : : /* missing separator between */
303 : 4 : l = strv_split_full(" 'one' \" two\t three \"' four five'", NULL, SPLIT_QUOTES | SPLIT_RELAX);
304 [ - + ]: 4 : assert_se(l);
305 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_quoted));
306 : :
307 : 4 : strv_free_erase(l);
308 : :
309 : 4 : l = strv_split_full(" 'one' \" two\t three \"' four five", NULL, SPLIT_QUOTES | SPLIT_RELAX);
310 [ - + ]: 4 : assert_se(l);
311 [ - + ]: 4 : assert_se(strv_equal(l, (char**) input_table_quoted));
312 : 4 : }
313 : :
314 : 4 : static void test_strv_split_empty(void) {
315 : 4 : _cleanup_strv_free_ char **l = NULL;
316 : :
317 [ + - ]: 4 : log_info("/* %s */", __func__);
318 : :
319 : 4 : l = strv_split("", WHITESPACE);
320 [ - + ]: 4 : assert_se(l);
321 [ - + ]: 4 : assert_se(strv_isempty(l));
322 : :
323 : 4 : strv_free(l);
324 : 4 : l = strv_split("", NULL);
325 [ - + ]: 4 : assert_se(l);
326 [ - + ]: 4 : assert_se(strv_isempty(l));
327 : :
328 : 4 : strv_free(l);
329 : 4 : l = strv_split_full("", NULL, 0);
330 [ - + ]: 4 : assert_se(l);
331 [ - + ]: 4 : assert_se(strv_isempty(l));
332 : :
333 : 4 : strv_free(l);
334 : 4 : l = strv_split_full("", NULL, SPLIT_QUOTES);
335 [ - + ]: 4 : assert_se(l);
336 [ - + ]: 4 : assert_se(strv_isempty(l));
337 : :
338 : 4 : strv_free(l);
339 : 4 : l = strv_split_full("", WHITESPACE, SPLIT_QUOTES);
340 [ - + ]: 4 : assert_se(l);
341 [ - + ]: 4 : assert_se(strv_isempty(l));
342 : :
343 : 4 : strv_free(l);
344 : 4 : l = strv_split_full("", WHITESPACE, SPLIT_QUOTES | SPLIT_RELAX);
345 [ - + ]: 4 : assert_se(l);
346 [ - + ]: 4 : assert_se(strv_isempty(l));
347 : :
348 : 4 : strv_free(l);
349 : 4 : l = strv_split(" ", WHITESPACE);
350 [ - + ]: 4 : assert_se(l);
351 [ - + ]: 4 : assert_se(strv_isempty(l));
352 : :
353 : 4 : strv_free(l);
354 : 4 : l = strv_split(" ", NULL);
355 [ - + ]: 4 : assert_se(l);
356 [ - + ]: 4 : assert_se(strv_isempty(l));
357 : :
358 : 4 : strv_free(l);
359 : 4 : l = strv_split_full(" ", NULL, 0);
360 [ - + ]: 4 : assert_se(l);
361 [ - + ]: 4 : assert_se(strv_isempty(l));
362 : :
363 : 4 : strv_free(l);
364 : 4 : l = strv_split_full(" ", WHITESPACE, SPLIT_QUOTES);
365 [ - + ]: 4 : assert_se(l);
366 [ - + ]: 4 : assert_se(strv_isempty(l));
367 : :
368 : 4 : strv_free(l);
369 : 4 : l = strv_split_full(" ", NULL, SPLIT_QUOTES);
370 [ - + ]: 4 : assert_se(l);
371 [ - + ]: 4 : assert_se(strv_isempty(l));
372 : :
373 : 4 : strv_free(l);
374 : 4 : l = strv_split_full(" ", NULL, SPLIT_QUOTES | SPLIT_RELAX);
375 [ - + ]: 4 : assert_se(l);
376 [ - + ]: 4 : assert_se(strv_isempty(l));
377 : 4 : }
378 : :
379 : 4 : static void test_strv_split_extract(void) {
380 : 4 : _cleanup_strv_free_ char **l = NULL;
381 : 4 : const char *str = ":foo\\:bar::waldo:";
382 : : int r;
383 : :
384 [ + - ]: 4 : log_info("/* %s */", __func__);
385 : :
386 : 4 : r = strv_split_extract(&l, str, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
387 [ - + ]: 4 : assert_se(r == (int) strv_length(l));
388 [ - + ]: 4 : assert_se(streq_ptr(l[0], ""));
389 [ - + ]: 4 : assert_se(streq_ptr(l[1], "foo:bar"));
390 [ - + ]: 4 : assert_se(streq_ptr(l[2], ""));
391 [ - + ]: 4 : assert_se(streq_ptr(l[3], "waldo"));
392 [ - + ]: 4 : assert_se(streq_ptr(l[4], ""));
393 [ - + ]: 4 : assert_se(streq_ptr(l[5], NULL));
394 : 4 : }
395 : :
396 : 4 : static void test_strv_split_newlines(void) {
397 : 4 : unsigned i = 0;
398 : : char **s;
399 : 4 : _cleanup_strv_free_ char **l = NULL;
400 : 4 : const char str[] = "one\ntwo\nthree";
401 : :
402 [ + - ]: 4 : log_info("/* %s */", __func__);
403 : :
404 : 4 : l = strv_split_newlines(str);
405 [ - + ]: 4 : assert_se(l);
406 : :
407 [ + - + + ]: 16 : STRV_FOREACH(s, l) {
408 [ - + ]: 12 : assert_se(streq(*s, input_table_multiple[i++]));
409 : : }
410 : 4 : }
411 : :
412 : 4 : static void test_strv_split_nulstr(void) {
413 : 4 : _cleanup_strv_free_ char **l = NULL;
414 : 4 : const char nulstr[] = "str0\0str1\0str2\0str3\0";
415 : :
416 [ + - ]: 4 : log_info("/* %s */", __func__);
417 : :
418 : 4 : l = strv_split_nulstr (nulstr);
419 [ - + ]: 4 : assert_se(l);
420 : :
421 [ - + ]: 4 : assert_se(streq(l[0], "str0"));
422 [ - + ]: 4 : assert_se(streq(l[1], "str1"));
423 [ - + ]: 4 : assert_se(streq(l[2], "str2"));
424 [ - + ]: 4 : assert_se(streq(l[3], "str3"));
425 : 4 : }
426 : :
427 : 4 : static void test_strv_parse_nulstr(void) {
428 : 4 : _cleanup_strv_free_ char **l = NULL;
429 : 4 : const char nulstr[] = "hoge\0hoge2\0hoge3\0\0hoge5\0\0xxx";
430 : :
431 [ + - ]: 4 : log_info("/* %s */", __func__);
432 : :
433 : 4 : l = strv_parse_nulstr(nulstr, sizeof(nulstr)-1);
434 [ - + ]: 4 : assert_se(l);
435 : 4 : puts("Parse nulstr:");
436 : 4 : strv_print(l);
437 : :
438 [ - + ]: 4 : assert_se(streq(l[0], "hoge"));
439 [ - + ]: 4 : assert_se(streq(l[1], "hoge2"));
440 [ - + ]: 4 : assert_se(streq(l[2], "hoge3"));
441 [ - + ]: 4 : assert_se(streq(l[3], ""));
442 [ - + ]: 4 : assert_se(streq(l[4], "hoge5"));
443 [ - + ]: 4 : assert_se(streq(l[5], ""));
444 [ - + ]: 4 : assert_se(streq(l[6], "xxx"));
445 : 4 : }
446 : :
447 : 4 : static void test_strv_overlap(void) {
448 : 4 : const char * const input_table[] = {
449 : : "one",
450 : : "two",
451 : : "three",
452 : : NULL
453 : : };
454 : 4 : const char * const input_table_overlap[] = {
455 : : "two",
456 : : NULL
457 : : };
458 : 4 : const char * const input_table_unique[] = {
459 : : "four",
460 : : "five",
461 : : "six",
462 : : NULL
463 : : };
464 : :
465 [ + - ]: 4 : log_info("/* %s */", __func__);
466 : :
467 [ - + ]: 4 : assert_se(strv_overlap((char **)input_table, (char**)input_table_overlap));
468 [ - + ]: 4 : assert_se(!strv_overlap((char **)input_table, (char**)input_table_unique));
469 : 4 : }
470 : :
471 : 4 : static void test_strv_sort(void) {
472 : 4 : const char* input_table[] = {
473 : : "durian",
474 : : "apple",
475 : : "citrus",
476 : : "CAPITAL LETTERS FIRST",
477 : : "banana",
478 : : NULL
479 : : };
480 : :
481 [ + - ]: 4 : log_info("/* %s */", __func__);
482 : :
483 : 4 : strv_sort((char **)input_table);
484 : :
485 [ - + ]: 4 : assert_se(streq(input_table[0], "CAPITAL LETTERS FIRST"));
486 [ - + ]: 4 : assert_se(streq(input_table[1], "apple"));
487 [ - + ]: 4 : assert_se(streq(input_table[2], "banana"));
488 [ - + ]: 4 : assert_se(streq(input_table[3], "citrus"));
489 [ - + ]: 4 : assert_se(streq(input_table[4], "durian"));
490 : 4 : }
491 : :
492 : 4 : static void test_strv_extend_strv_concat(void) {
493 : 4 : _cleanup_strv_free_ char **a = NULL, **b = NULL;
494 : :
495 [ + - ]: 4 : log_info("/* %s */", __func__);
496 : :
497 : 4 : a = strv_new("without", "suffix");
498 : 4 : b = strv_new("with", "suffix");
499 [ - + ]: 4 : assert_se(a);
500 [ - + ]: 4 : assert_se(b);
501 : :
502 [ - + ]: 4 : assert_se(strv_extend_strv_concat(&a, b, "_suffix") >= 0);
503 : :
504 [ - + ]: 4 : assert_se(streq(a[0], "without"));
505 [ - + ]: 4 : assert_se(streq(a[1], "suffix"));
506 [ - + ]: 4 : assert_se(streq(a[2], "with_suffix"));
507 [ - + ]: 4 : assert_se(streq(a[3], "suffix_suffix"));
508 : 4 : }
509 : :
510 : 4 : static void test_strv_extend_strv(void) {
511 : 4 : _cleanup_strv_free_ char **a = NULL, **b = NULL, **n = NULL;
512 : :
513 [ + - ]: 4 : log_info("/* %s */", __func__);
514 : :
515 : 4 : a = strv_new("abc", "def", "ghi");
516 : 4 : b = strv_new("jkl", "mno", "abc", "pqr");
517 [ - + ]: 4 : assert_se(a);
518 [ - + ]: 4 : assert_se(b);
519 : :
520 [ - + ]: 4 : assert_se(strv_extend_strv(&a, b, true) == 3);
521 : :
522 [ - + ]: 4 : assert_se(streq(a[0], "abc"));
523 [ - + ]: 4 : assert_se(streq(a[1], "def"));
524 [ - + ]: 4 : assert_se(streq(a[2], "ghi"));
525 [ - + ]: 4 : assert_se(streq(a[3], "jkl"));
526 [ - + ]: 4 : assert_se(streq(a[4], "mno"));
527 [ - + ]: 4 : assert_se(streq(a[5], "pqr"));
528 [ - + ]: 4 : assert_se(strv_length(a) == 6);
529 : :
530 [ - + ]: 4 : assert_se(strv_extend_strv(&n, b, false) >= 0);
531 [ - + ]: 4 : assert_se(streq(n[0], "jkl"));
532 [ - + ]: 4 : assert_se(streq(n[1], "mno"));
533 [ - + ]: 4 : assert_se(streq(n[2], "abc"));
534 [ - + ]: 4 : assert_se(streq(n[3], "pqr"));
535 [ - + ]: 4 : assert_se(strv_length(n) == 4);
536 : 4 : }
537 : :
538 : 4 : static void test_strv_extend(void) {
539 : 4 : _cleanup_strv_free_ char **a = NULL, **b = NULL;
540 : :
541 [ + - ]: 4 : log_info("/* %s */", __func__);
542 : :
543 : 4 : a = strv_new("test", "test1");
544 [ - + ]: 4 : assert_se(a);
545 [ - + ]: 4 : assert_se(strv_extend(&a, "test2") >= 0);
546 [ - + ]: 4 : assert_se(strv_extend(&b, "test3") >= 0);
547 : :
548 [ - + ]: 4 : assert_se(streq(a[0], "test"));
549 [ - + ]: 4 : assert_se(streq(a[1], "test1"));
550 [ - + ]: 4 : assert_se(streq(a[2], "test2"));
551 [ - + ]: 4 : assert_se(streq(b[0], "test3"));
552 : 4 : }
553 : :
554 : 4 : static void test_strv_extendf(void) {
555 : 4 : _cleanup_strv_free_ char **a = NULL, **b = NULL;
556 : :
557 [ + - ]: 4 : log_info("/* %s */", __func__);
558 : :
559 : 4 : a = strv_new("test", "test1");
560 [ - + ]: 4 : assert_se(a);
561 [ - + ]: 4 : assert_se(strv_extendf(&a, "test2 %s %d %s", "foo", 128, "bar") >= 0);
562 [ - + ]: 4 : assert_se(strv_extendf(&b, "test3 %s %s %d", "bar", "foo", 128) >= 0);
563 : :
564 [ - + ]: 4 : assert_se(streq(a[0], "test"));
565 [ - + ]: 4 : assert_se(streq(a[1], "test1"));
566 [ - + ]: 4 : assert_se(streq(a[2], "test2 foo 128 bar"));
567 [ - + ]: 4 : assert_se(streq(b[0], "test3 bar foo 128"));
568 : 4 : }
569 : :
570 : 4 : static void test_strv_foreach(void) {
571 : 4 : _cleanup_strv_free_ char **a;
572 : 4 : unsigned i = 0;
573 : : char **check;
574 : :
575 [ + - ]: 4 : log_info("/* %s */", __func__);
576 : :
577 : 4 : a = strv_new("one", "two", "three");
578 [ - + ]: 4 : assert_se(a);
579 : :
580 [ + - + + ]: 16 : STRV_FOREACH(check, a)
581 [ - + ]: 12 : assert_se(streq(*check, input_table_multiple[i++]));
582 : 4 : }
583 : :
584 : 4 : static void test_strv_foreach_backwards(void) {
585 : 4 : _cleanup_strv_free_ char **a;
586 : 4 : unsigned i = 2;
587 : : char **check;
588 : :
589 [ + - ]: 4 : log_info("/* %s */", __func__);
590 : :
591 : 4 : a = strv_new("one", "two", "three");
592 : :
593 [ - + ]: 4 : assert_se(a);
594 : :
595 [ + - + - : 16 : STRV_FOREACH_BACKWARDS(check, a)
+ + ]
596 [ - + ]: 12 : assert_se(streq_ptr(*check, input_table_multiple[i--]));
597 : :
598 [ - + ]: 4 : STRV_FOREACH_BACKWARDS(check, (char**) NULL)
599 : : assert_not_reached("Let's see that we check empty strv right, too.");
600 : :
601 [ - + ]: 4 : STRV_FOREACH_BACKWARDS(check, (char**) { NULL })
602 : : assert_not_reached("Let's see that we check empty strv right, too.");
603 : 4 : }
604 : :
605 : 4 : static void test_strv_foreach_pair(void) {
606 : 4 : _cleanup_strv_free_ char **a = NULL;
607 : : char **x, **y;
608 : :
609 [ + - ]: 4 : log_info("/* %s */", __func__);
610 : :
611 : 4 : a = strv_new("pair_one", "pair_one",
612 : : "pair_two", "pair_two",
613 : : "pair_three", "pair_three");
614 [ + - + + : 16 : STRV_FOREACH_PAIR(x, y, a)
+ - ]
615 [ - + ]: 12 : assert_se(streq(*x, *y));
616 : 4 : }
617 : :
618 : 12 : static void test_strv_from_stdarg_alloca_one(char **l, const char *first, ...) {
619 : : char **j;
620 : : unsigned i;
621 : :
622 [ + - ]: 12 : log_info("/* %s */", __func__);
623 : :
624 [ + + + + : 20 : j = strv_from_stdarg_alloca(first);
- + - + +
+ ]
625 : :
626 : 12 : for (i = 0;; i++) {
627 [ - + ]: 24 : assert_se(streq_ptr(l[i], j[i]));
628 : :
629 [ + + ]: 24 : if (!l[i])
630 : 12 : break;
631 : : }
632 : 12 : }
633 : :
634 : 4 : static void test_strv_from_stdarg_alloca(void) {
635 [ + - ]: 4 : log_info("/* %s */", __func__);
636 : :
637 : 4 : test_strv_from_stdarg_alloca_one(STRV_MAKE("foo", "bar"), "foo", "bar", NULL);
638 : 4 : test_strv_from_stdarg_alloca_one(STRV_MAKE("foo"), "foo", NULL);
639 : 4 : test_strv_from_stdarg_alloca_one(STRV_MAKE_EMPTY, NULL);
640 : 4 : }
641 : :
642 : 4 : static void test_strv_insert(void) {
643 : 4 : _cleanup_strv_free_ char **a = NULL;
644 : :
645 [ + - ]: 4 : log_info("/* %s */", __func__);
646 : :
647 [ - + ]: 4 : assert_se(strv_insert(&a, 0, strdup("first")) == 0);
648 [ - + ]: 4 : assert_se(streq(a[0], "first"));
649 [ - + ]: 4 : assert_se(!a[1]);
650 : :
651 [ - + ]: 4 : assert_se(strv_insert(&a, 0, NULL) == 0);
652 [ - + ]: 4 : assert_se(streq(a[0], "first"));
653 [ - + ]: 4 : assert_se(!a[1]);
654 : :
655 [ - + ]: 4 : assert_se(strv_insert(&a, 1, strdup("two")) == 0);
656 [ - + ]: 4 : assert_se(streq(a[0], "first"));
657 [ - + ]: 4 : assert_se(streq(a[1], "two"));
658 [ - + ]: 4 : assert_se(!a[2]);
659 : :
660 [ - + ]: 4 : assert_se(strv_insert(&a, 4, strdup("tri")) == 0);
661 [ - + ]: 4 : assert_se(streq(a[0], "first"));
662 [ - + ]: 4 : assert_se(streq(a[1], "two"));
663 [ - + ]: 4 : assert_se(streq(a[2], "tri"));
664 [ - + ]: 4 : assert_se(!a[3]);
665 : :
666 [ - + ]: 4 : assert_se(strv_insert(&a, 1, strdup("duo")) == 0);
667 [ - + ]: 4 : assert_se(streq(a[0], "first"));
668 [ - + ]: 4 : assert_se(streq(a[1], "duo"));
669 [ - + ]: 4 : assert_se(streq(a[2], "two"));
670 [ - + ]: 4 : assert_se(streq(a[3], "tri"));
671 [ - + ]: 4 : assert_se(!a[4]);
672 : 4 : }
673 : :
674 : 4 : static void test_strv_push_prepend(void) {
675 : 4 : _cleanup_strv_free_ char **a = NULL;
676 : :
677 [ + - ]: 4 : log_info("/* %s */", __func__);
678 : :
679 : 4 : a = strv_new("foo", "bar", "three");
680 : :
681 [ - + ]: 4 : assert_se(strv_push_prepend(&a, strdup("first")) >= 0);
682 [ - + ]: 4 : assert_se(streq(a[0], "first"));
683 [ - + ]: 4 : assert_se(streq(a[1], "foo"));
684 [ - + ]: 4 : assert_se(streq(a[2], "bar"));
685 [ - + ]: 4 : assert_se(streq(a[3], "three"));
686 [ - + ]: 4 : assert_se(!a[4]);
687 : :
688 [ - + ]: 4 : assert_se(strv_consume_prepend(&a, strdup("first2")) >= 0);
689 [ - + ]: 4 : assert_se(streq(a[0], "first2"));
690 [ - + ]: 4 : assert_se(streq(a[1], "first"));
691 [ - + ]: 4 : assert_se(streq(a[2], "foo"));
692 [ - + ]: 4 : assert_se(streq(a[3], "bar"));
693 [ - + ]: 4 : assert_se(streq(a[4], "three"));
694 [ - + ]: 4 : assert_se(!a[5]);
695 : 4 : }
696 : :
697 : 4 : static void test_strv_push(void) {
698 : 4 : _cleanup_strv_free_ char **a = NULL;
699 : : char *i, *j;
700 : :
701 [ + - ]: 4 : log_info("/* %s */", __func__);
702 : :
703 [ - + ]: 4 : assert_se(i = strdup("foo"));
704 [ - + ]: 4 : assert_se(strv_push(&a, i) >= 0);
705 : :
706 [ - + ]: 4 : assert_se(i = strdup("a"));
707 [ - + ]: 4 : assert_se(j = strdup("b"));
708 [ - + ]: 4 : assert_se(strv_push_pair(&a, i, j) >= 0);
709 : :
710 [ - + ]: 4 : assert_se(streq_ptr(a[0], "foo"));
711 [ - + ]: 4 : assert_se(streq_ptr(a[1], "a"));
712 [ - + ]: 4 : assert_se(streq_ptr(a[2], "b"));
713 [ - + ]: 4 : assert_se(streq_ptr(a[3], NULL));
714 : 4 : }
715 : :
716 : 4 : static void test_strv_equal(void) {
717 : 4 : _cleanup_strv_free_ char **a = NULL;
718 : 4 : _cleanup_strv_free_ char **b = NULL;
719 : 4 : _cleanup_strv_free_ char **c = NULL;
720 : :
721 [ + - ]: 4 : log_info("/* %s */", __func__);
722 : :
723 : 4 : a = strv_new("one", "two", "three");
724 [ - + ]: 4 : assert_se(a);
725 : 4 : b = strv_new("one", "two", "three");
726 [ - + ]: 4 : assert_se(a);
727 : 4 : c = strv_new("one", "two", "three", "four");
728 [ - + ]: 4 : assert_se(a);
729 : :
730 [ - + ]: 4 : assert_se(strv_equal(a, a));
731 [ - + ]: 4 : assert_se(strv_equal(a, b));
732 [ - + ]: 4 : assert_se(strv_equal(NULL, NULL));
733 : :
734 [ - + ]: 4 : assert_se(!strv_equal(a, c));
735 [ - + ]: 4 : assert_se(!strv_equal(b, c));
736 [ - + ]: 4 : assert_se(!strv_equal(b, NULL));
737 : 4 : }
738 : :
739 : 4 : static void test_strv_is_uniq(void) {
740 : 4 : _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
741 : :
742 [ + - ]: 4 : log_info("/* %s */", __func__);
743 : :
744 : 4 : a = strv_new(NULL);
745 [ - + ]: 4 : assert_se(a);
746 [ - + ]: 4 : assert_se(strv_is_uniq(a));
747 : :
748 : 4 : b = strv_new("foo");
749 [ - + ]: 4 : assert_se(b);
750 [ - + ]: 4 : assert_se(strv_is_uniq(b));
751 : :
752 : 4 : c = strv_new("foo", "bar");
753 [ - + ]: 4 : assert_se(c);
754 [ - + ]: 4 : assert_se(strv_is_uniq(c));
755 : :
756 : 4 : d = strv_new("foo", "bar", "waldo", "bar", "piep");
757 [ - + ]: 4 : assert_se(d);
758 [ - + ]: 4 : assert_se(!strv_is_uniq(d));
759 : 4 : }
760 : :
761 : 4 : static void test_strv_reverse(void) {
762 : 4 : _cleanup_strv_free_ char **a = NULL, **b = NULL, **c = NULL, **d = NULL;
763 : :
764 [ + - ]: 4 : log_info("/* %s */", __func__);
765 : :
766 : 4 : a = strv_new(NULL);
767 [ - + ]: 4 : assert_se(a);
768 : :
769 : 4 : strv_reverse(a);
770 [ - + ]: 4 : assert_se(strv_isempty(a));
771 : :
772 : 4 : b = strv_new("foo");
773 [ - + ]: 4 : assert_se(b);
774 : 4 : strv_reverse(b);
775 [ - + ]: 4 : assert_se(streq_ptr(b[0], "foo"));
776 [ - + ]: 4 : assert_se(streq_ptr(b[1], NULL));
777 : :
778 : 4 : c = strv_new("foo", "bar");
779 [ - + ]: 4 : assert_se(c);
780 : 4 : strv_reverse(c);
781 [ - + ]: 4 : assert_se(streq_ptr(c[0], "bar"));
782 [ - + ]: 4 : assert_se(streq_ptr(c[1], "foo"));
783 [ - + ]: 4 : assert_se(streq_ptr(c[2], NULL));
784 : :
785 : 4 : d = strv_new("foo", "bar", "waldo");
786 [ - + ]: 4 : assert_se(d);
787 : 4 : strv_reverse(d);
788 [ - + ]: 4 : assert_se(streq_ptr(d[0], "waldo"));
789 [ - + ]: 4 : assert_se(streq_ptr(d[1], "bar"));
790 [ - + ]: 4 : assert_se(streq_ptr(d[2], "foo"));
791 [ - + ]: 4 : assert_se(streq_ptr(d[3], NULL));
792 : 4 : }
793 : :
794 : 4 : static void test_strv_shell_escape(void) {
795 : 4 : _cleanup_strv_free_ char **v = NULL;
796 : :
797 [ + - ]: 4 : log_info("/* %s */", __func__);
798 : :
799 : 4 : v = strv_new("foo:bar", "bar,baz", "wal\\do");
800 [ - + ]: 4 : assert_se(v);
801 [ - + ]: 4 : assert_se(strv_shell_escape(v, ",:"));
802 [ - + ]: 4 : assert_se(streq_ptr(v[0], "foo\\:bar"));
803 [ - + ]: 4 : assert_se(streq_ptr(v[1], "bar\\,baz"));
804 [ - + ]: 4 : assert_se(streq_ptr(v[2], "wal\\\\do"));
805 [ - + ]: 4 : assert_se(streq_ptr(v[3], NULL));
806 : 4 : }
807 : :
808 : 48 : static void test_strv_skip_one(char **a, size_t n, char **b) {
809 : 48 : a = strv_skip(a, n);
810 [ - + ]: 48 : assert_se(strv_equal(a, b));
811 : 48 : }
812 : :
813 : 4 : static void test_strv_skip(void) {
814 [ + - ]: 4 : log_info("/* %s */", __func__);
815 : :
816 : 4 : test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 0, STRV_MAKE("foo", "bar", "baz"));
817 : 4 : test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 1, STRV_MAKE("bar", "baz"));
818 : 4 : test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 2, STRV_MAKE("baz"));
819 : 4 : test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 3, STRV_MAKE(NULL));
820 : 4 : test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 4, STRV_MAKE(NULL));
821 : 4 : test_strv_skip_one(STRV_MAKE("foo", "bar", "baz"), 55, STRV_MAKE(NULL));
822 : :
823 : 4 : test_strv_skip_one(STRV_MAKE("quux"), 0, STRV_MAKE("quux"));
824 : 4 : test_strv_skip_one(STRV_MAKE("quux"), 1, STRV_MAKE(NULL));
825 : 4 : test_strv_skip_one(STRV_MAKE("quux"), 55, STRV_MAKE(NULL));
826 : :
827 : 4 : test_strv_skip_one(STRV_MAKE(NULL), 0, STRV_MAKE(NULL));
828 : 4 : test_strv_skip_one(STRV_MAKE(NULL), 1, STRV_MAKE(NULL));
829 : 4 : test_strv_skip_one(STRV_MAKE(NULL), 55, STRV_MAKE(NULL));
830 : 4 : }
831 : :
832 : 4 : static void test_strv_extend_n(void) {
833 : 4 : _cleanup_strv_free_ char **v = NULL;
834 : :
835 [ + - ]: 4 : log_info("/* %s */", __func__);
836 : :
837 : 4 : v = strv_new("foo", "bar");
838 [ - + ]: 4 : assert_se(v);
839 : :
840 [ - + ]: 4 : assert_se(strv_extend_n(&v, "waldo", 3) >= 0);
841 [ - + ]: 4 : assert_se(strv_extend_n(&v, "piep", 2) >= 0);
842 : :
843 [ - + ]: 4 : assert_se(streq(v[0], "foo"));
844 [ - + ]: 4 : assert_se(streq(v[1], "bar"));
845 [ - + ]: 4 : assert_se(streq(v[2], "waldo"));
846 [ - + ]: 4 : assert_se(streq(v[3], "waldo"));
847 [ - + ]: 4 : assert_se(streq(v[4], "waldo"));
848 [ - + ]: 4 : assert_se(streq(v[5], "piep"));
849 [ - + ]: 4 : assert_se(streq(v[6], "piep"));
850 [ - + ]: 4 : assert_se(v[7] == NULL);
851 : :
852 : 4 : v = strv_free(v);
853 : :
854 [ - + ]: 4 : assert_se(strv_extend_n(&v, "foo", 1) >= 0);
855 [ - + ]: 4 : assert_se(strv_extend_n(&v, "bar", 0) >= 0);
856 : :
857 [ - + ]: 4 : assert_se(streq(v[0], "foo"));
858 [ - + ]: 4 : assert_se(v[1] == NULL);
859 : 4 : }
860 : :
861 : 20 : static void test_strv_make_nulstr_one(char **l) {
862 : 20 : _cleanup_free_ char *b = NULL, *c = NULL;
863 : 20 : _cleanup_strv_free_ char **q = NULL;
864 : 20 : const char *s = NULL;
865 : : size_t n, m;
866 : 20 : unsigned i = 0;
867 : :
868 [ + - ]: 20 : log_info("/* %s */", __func__);
869 : :
870 [ - + ]: 20 : assert_se(strv_make_nulstr(l, &b, &n) >= 0);
871 [ - + ]: 20 : assert_se(q = strv_parse_nulstr(b, n));
872 [ - + ]: 20 : assert_se(strv_equal(l, q));
873 : :
874 [ - + ]: 20 : assert_se(strv_make_nulstr(q, &c, &m) >= 0);
875 [ - + ]: 20 : assert_se(m == n);
876 [ - + ]: 20 : assert_se(memcmp(b, c, m) == 0);
877 : :
878 [ + - + + ]: 44 : NULSTR_FOREACH(s, b)
879 [ - + ]: 24 : assert_se(streq(s, l[i++]));
880 [ - + ]: 20 : assert_se(i == strv_length(l));
881 : 20 : }
882 : :
883 : 4 : static void test_strv_make_nulstr(void) {
884 [ + - ]: 4 : log_info("/* %s */", __func__);
885 : :
886 : 4 : test_strv_make_nulstr_one(NULL);
887 : 4 : test_strv_make_nulstr_one(STRV_MAKE(NULL));
888 : 4 : test_strv_make_nulstr_one(STRV_MAKE("foo"));
889 : 4 : test_strv_make_nulstr_one(STRV_MAKE("foo", "bar"));
890 : 4 : test_strv_make_nulstr_one(STRV_MAKE("foo", "bar", "quuux"));
891 : 4 : }
892 : :
893 : 4 : static void test_strv_free_free(void) {
894 : : char ***t;
895 : :
896 [ + - ]: 4 : log_info("/* %s */", __func__);
897 : :
898 [ - + ]: 4 : assert_se(t = new(char**, 3));
899 [ - + ]: 4 : assert_se(t[0] = strv_new("a", "b"));
900 [ - + ]: 4 : assert_se(t[1] = strv_new("c", "d", "e"));
901 : 4 : t[2] = NULL;
902 : :
903 : 4 : t = strv_free_free(t);
904 : 4 : }
905 : :
906 : 4 : static void test_foreach_string(void) {
907 : 4 : const char * const t[] = {
908 : : "foo",
909 : : "bar",
910 : : "waldo",
911 : : NULL
912 : : };
913 : : const char *x;
914 : 4 : unsigned i = 0;
915 : :
916 [ + - ]: 4 : log_info("/* %s */", __func__);
917 : :
918 [ + + ]: 16 : FOREACH_STRING(x, "foo", "bar", "waldo")
919 [ - + ]: 12 : assert_se(streq_ptr(t[i++], x));
920 : :
921 [ - + ]: 4 : assert_se(i == 3);
922 : :
923 [ + + ]: 8 : FOREACH_STRING(x, "zzz")
924 [ - + ]: 4 : assert_se(streq(x, "zzz"));
925 : 4 : }
926 : :
927 : 4 : static void test_strv_fnmatch(void) {
928 : 4 : _cleanup_strv_free_ char **v = NULL;
929 : :
930 [ + - ]: 4 : log_info("/* %s */", __func__);
931 : :
932 [ - + ]: 4 : assert_se(!strv_fnmatch(STRV_MAKE_EMPTY, "a", 0));
933 : :
934 : 4 : v = strv_new("*\\*");
935 [ - + ]: 4 : assert_se(!strv_fnmatch(v, "\\", 0));
936 [ - + ]: 4 : assert_se(strv_fnmatch(v, "\\", FNM_NOESCAPE));
937 : 4 : }
938 : :
939 : 4 : int main(int argc, char *argv[]) {
940 : 4 : test_specifier_printf();
941 : 4 : test_str_in_set();
942 : 4 : test_strptr_in_set();
943 : 4 : test_startswith_set();
944 : 4 : test_strv_foreach();
945 : 4 : test_strv_foreach_backwards();
946 : 4 : test_strv_foreach_pair();
947 : 4 : test_strv_find();
948 : 4 : test_strv_find_prefix();
949 : 4 : test_strv_find_startswith();
950 : 4 : test_strv_join();
951 : 4 : test_strv_join_prefix();
952 : :
953 : 4 : test_strv_unquote(" foo=bar \"waldo\" zzz ", STRV_MAKE("foo=bar", "waldo", "zzz"));
954 : 4 : test_strv_unquote("", STRV_MAKE_EMPTY);
955 : 4 : test_strv_unquote(" ", STRV_MAKE_EMPTY);
956 : 4 : test_strv_unquote(" ", STRV_MAKE_EMPTY);
957 : 4 : test_strv_unquote(" x", STRV_MAKE("x"));
958 : 4 : test_strv_unquote("x ", STRV_MAKE("x"));
959 : 4 : test_strv_unquote(" x ", STRV_MAKE("x"));
960 : 4 : test_strv_unquote(" \"x\" ", STRV_MAKE("x"));
961 : 4 : test_strv_unquote(" 'x' ", STRV_MAKE("x"));
962 : 4 : test_strv_unquote(" 'x\"' ", STRV_MAKE("x\""));
963 : 4 : test_strv_unquote(" \"x'\" ", STRV_MAKE("x'"));
964 : 4 : test_strv_unquote("a '--b=c \"d e\"'", STRV_MAKE("a", "--b=c \"d e\""));
965 : :
966 : : /* trailing backslashes */
967 : 4 : test_strv_unquote(" x\\\\", STRV_MAKE("x\\"));
968 : 4 : test_invalid_unquote(" x\\");
969 : :
970 : 4 : test_invalid_unquote("a --b='c \"d e\"''");
971 : 4 : test_invalid_unquote("a --b='c \"d e\" '\"");
972 : 4 : test_invalid_unquote("a --b='c \"d e\"garbage");
973 : 4 : test_invalid_unquote("'");
974 : 4 : test_invalid_unquote("\"");
975 : 4 : test_invalid_unquote("'x'y'g");
976 : :
977 : 4 : test_strv_split();
978 : 4 : test_strv_split_empty();
979 : 4 : test_strv_split_extract();
980 : 4 : test_strv_split_newlines();
981 : 4 : test_strv_split_nulstr();
982 : 4 : test_strv_parse_nulstr();
983 : 4 : test_strv_overlap();
984 : 4 : test_strv_sort();
985 : 4 : test_strv_extend_strv();
986 : 4 : test_strv_extend_strv_concat();
987 : 4 : test_strv_extend();
988 : 4 : test_strv_extendf();
989 : 4 : test_strv_from_stdarg_alloca();
990 : 4 : test_strv_insert();
991 : 4 : test_strv_push_prepend();
992 : 4 : test_strv_push();
993 : 4 : test_strv_equal();
994 : 4 : test_strv_is_uniq();
995 : 4 : test_strv_reverse();
996 : 4 : test_strv_shell_escape();
997 : 4 : test_strv_skip();
998 : 4 : test_strv_extend_n();
999 : 4 : test_strv_make_nulstr();
1000 : 4 : test_strv_free_free();
1001 : :
1002 : 4 : test_foreach_string();
1003 : 4 : test_strv_fnmatch();
1004 : :
1005 : 4 : return 0;
1006 : : }
|
