]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/test/test-util.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bus: fix use-after-free in slot-release
[thirdparty/systemd.git] / src / test / test-util.c
CommitLineData
539ad707
TA		 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>
dbd73f9e
TA		 24#include <unistd.h>
25#include <fcntl.h>
d6dd604b 26#include <locale.h>
2a371001 27#include <errno.h>
927be00c 28#include <signal.h>
8e211000 29#include <math.h>
8852362b 30#include <sys/wait.h>
539ad707
TA		 31
32#include "util.h"
927be00c 33#include "mkdir.h"
893fa014 34#include "strv.h"
65b3903f
ZJS		 35#include "def.h"
36#include "fileio.h"
9480794b 37#include "conf-parser.h"
539ad707
TA		 38
39static void test_streq_ptr(void) {
8354c34e
TA		 40 assert_se(streq_ptr(NULL, NULL));
41 assert_se(!streq_ptr("abc", "cdef"));
539ad707
TA		 42}
43
625e870b
DH		 44static void test_align_power2(void) {
45 unsigned long i, p2;
46
47 assert_se(ALIGN_POWER2(0) == 0);
48 assert_se(ALIGN_POWER2(1) == 1);
49 assert_se(ALIGN_POWER2(2) == 2);
50 assert_se(ALIGN_POWER2(3) == 4);
51 assert_se(ALIGN_POWER2(12) == 16);
52
53 assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
54 assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
55 assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
56 assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
57 assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
58
59 for (i = 1; i < 131071; ++i) {
60 for (p2 = 1; p2 < i; p2 <<= 1)
61 /* empty */ ;
62
63 assert_se(ALIGN_POWER2(i) == p2);
64 }
65
66 for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
67 for (p2 = 1; p2 && p2 < i; p2 <<= 1)
68 /* empty */ ;
69
70 assert_se(ALIGN_POWER2(i) == p2);
71 }
72}
73
7242d742
DH		 74static void test_max(void) {
75 static const struct {
76 int a;
77 int b[CONST_MAX(10, 100)];
78 } val1 = {
79 .a = CONST_MAX(10, 100),
80 };
81 int d = 0;
82
83 assert_cc(sizeof(val1.b) == sizeof(int) * 100);
84
85 /* CONST_MAX returns (void) instead of a value if the passed arguments
86 * are not of the same type or not constant expressions. */
87 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
7242d742
DH		 88 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
89
90 assert_se(val1.a == 100);
91 assert_se(MAX(++d, 0) == 1);
92 assert_se(d == 1);
40a1eebd
DH		 93
94 assert_cc(MAXSIZE(char[3], uint16_t) == 3);
95 assert_cc(MAXSIZE(char[3], uint32_t) == 4);
96 assert_cc(MAXSIZE(char, long) == sizeof(long));
7242d742
DH		 97}
98
fb835651
DH		 99static void test_container_of(void) {
100 struct mytype {
101 uint8_t pad1[3];
102 uint64_t v1;
103 uint8_t pad2[2];
104 uint32_t v2;
105 } _packed_ myval = { };
106
107 assert_cc(sizeof(myval) == 17);
108 assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
109 assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
110 assert_se(container_of(&container_of(&myval.v2,
111 struct mytype,
112 v2)->v1,
113 struct mytype,
114 v1) == &myval);
115}
116
539ad707 117static void test_first_word(void) {
8354c34e
TA		 118 assert_se(first_word("Hello", ""));
119 assert_se(first_word("Hello", "Hello"));
120 assert_se(first_word("Hello world", "Hello"));
121 assert_se(first_word("Hello\tworld", "Hello"));
122 assert_se(first_word("Hello\nworld", "Hello"));
123 assert_se(first_word("Hello\rworld", "Hello"));
124 assert_se(first_word("Hello ", "Hello"));
125
126 assert_se(!first_word("Hello", "Hellooo"));
127 assert_se(!first_word("Hello", "xxxxx"));
128 assert_se(!first_word("Hellooo", "Hello"));
129}
130
dbd73f9e
TA		 131static void test_close_many(void) {
132 int fds[3];
133 char name0[] = "/tmp/test-close-many.XXXXXX";
134 char name1[] = "/tmp/test-close-many.XXXXXX";
135 char name2[] = "/tmp/test-close-many.XXXXXX";
136
2d5bdf5b
LP		 137 fds[0] = mkostemp_safe(name0, O_RDWR|O_CLOEXEC);
138 fds[1] = mkostemp_safe(name1, O_RDWR|O_CLOEXEC);
139 fds[2] = mkostemp_safe(name2, O_RDWR|O_CLOEXEC);
dbd73f9e
TA		 140
141 close_many(fds, 2);
142
143 assert_se(fcntl(fds[0], F_GETFD) == -1);
144 assert_se(fcntl(fds[1], F_GETFD) == -1);
145 assert_se(fcntl(fds[2], F_GETFD) >= 0);
146
03e334a1 147 safe_close(fds[2]);
dbd73f9e
TA		 148
149 unlink(name0);
150 unlink(name1);
151 unlink(name2);
152}
153
8354c34e
TA		 154static void test_parse_boolean(void) {
155 assert_se(parse_boolean("1") == 1);
156 assert_se(parse_boolean("y") == 1);
157 assert_se(parse_boolean("Y") == 1);
158 assert_se(parse_boolean("yes") == 1);
159 assert_se(parse_boolean("YES") == 1);
160 assert_se(parse_boolean("true") == 1);
161 assert_se(parse_boolean("TRUE") == 1);
162 assert_se(parse_boolean("on") == 1);
163 assert_se(parse_boolean("ON") == 1);
164
165 assert_se(parse_boolean("0") == 0);
166 assert_se(parse_boolean("n") == 0);
167 assert_se(parse_boolean("N") == 0);
168 assert_se(parse_boolean("no") == 0);
169 assert_se(parse_boolean("NO") == 0);
170 assert_se(parse_boolean("false") == 0);
171 assert_se(parse_boolean("FALSE") == 0);
172 assert_se(parse_boolean("off") == 0);
173 assert_se(parse_boolean("OFF") == 0);
174
175 assert_se(parse_boolean("garbage") < 0);
176 assert_se(parse_boolean("") < 0);
0f625d0b 177 assert_se(parse_boolean("full") < 0);
539ad707
TA		 178}
179
8d99e5f5
TA		 180static void test_parse_pid(void) {
181 int r;
182 pid_t pid;
183
184 r = parse_pid("100", &pid);
185 assert_se(r == 0);
186 assert_se(pid == 100);
187
188 r = parse_pid("0x7FFFFFFF", &pid);
189 assert_se(r == 0);
190 assert_se(pid == 2147483647);
191
192 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
193 r = parse_pid("0", &pid);
194 assert_se(r == -ERANGE);
195 assert_se(pid == 65);
196
197 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
198 r = parse_pid("-100", &pid);
199 assert_se(r == -ERANGE);
200 assert_se(pid == 65);
201
202 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
203 r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
204 assert(r == -ERANGE);
205 assert_se(pid == 65);
206}
207
208static void test_parse_uid(void) {
209 int r;
210 uid_t uid;
211
212 r = parse_uid("100", &uid);
213 assert_se(r == 0);
214 assert_se(uid == 100);
215}
216
217static void test_safe_atolli(void) {
218 int r;
219 long long l;
220
221 r = safe_atolli("12345", &l);
222 assert_se(r == 0);
223 assert_se(l == 12345);
224
225 r = safe_atolli("junk", &l);
226 assert_se(r == -EINVAL);
227}
228
229static void test_safe_atod(void) {
230 int r;
231 double d;
d6dd604b
LP		 232 char *e;
233
234 r = safe_atod("junk", &d);
235 assert_se(r == -EINVAL);
8d99e5f5
TA		 236
237 r = safe_atod("0.2244", &d);
238 assert_se(r == 0);
8e211000 239 assert_se(fabs(d - 0.2244) < 0.000001);
8d99e5f5 240
d6dd604b 241 r = safe_atod("0,5", &d);
8d99e5f5 242 assert_se(r == -EINVAL);
d6dd604b
LP		 243
244 errno = 0;
245 strtod("0,5", &e);
246 assert_se(*e == ',');
247
248 /* Check if this really is locale independent */
926446f4 249 if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
d6dd604b 250
926446f4
DH		 251 r = safe_atod("0.2244", &d);
252 assert_se(r == 0);
253 assert_se(fabs(d - 0.2244) < 0.000001);
d6dd604b 254
926446f4
DH		 255 r = safe_atod("0,5", &d);
256 assert_se(r == -EINVAL);
d6dd604b 257
926446f4
DH		 258 errno = 0;
259 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
260 }
d6dd604b
LP		 261
262 /* And check again, reset */
926446f4 263 assert_se(setlocale(LC_NUMERIC, "C"));
d6dd604b
LP		 264
265 r = safe_atod("0.2244", &d);
266 assert_se(r == 0);
8e211000 267 assert_se(fabs(d - 0.2244) < 0.000001);
d6dd604b
LP		 268
269 r = safe_atod("0,5", &d);
270 assert_se(r == -EINVAL);
271
272 errno = 0;
273 strtod("0,5", &e);
274 assert_se(*e == ',');
8d99e5f5
TA		 275}
276
dbd73f9e 277static void test_strappend(void) {
998b087f 278 _cleanup_free_ char *t1, *t2, *t3, *t4;
dbd73f9e 279
998b087f
TA		 280 t1 = strappend(NULL, NULL);
281 assert_se(streq(t1, ""));
dbd73f9e 282
998b087f
TA		 283 t2 = strappend(NULL, "suf");
284 assert_se(streq(t2, "suf"));
dbd73f9e 285
998b087f
TA		 286 t3 = strappend("pre", NULL);
287 assert_se(streq(t3, "pre"));
dbd73f9e 288
998b087f
TA		 289 t4 = strappend("pre", "suf");
290 assert_se(streq(t4, "presuf"));
dbd73f9e
TA		 291}
292
1ef04f0b 293static void test_strstrip(void) {
998b087f
TA		 294 char *r;
295 char input[] = " hello, waldo. ";
1ef04f0b 296
998b087f
TA		 297 r = strstrip(input);
298 assert_se(streq(r, "hello, waldo."));
1ef04f0b
TA		 299}
300
301static void test_delete_chars(void) {
998b087f
TA		 302 char *r;
303 char input[] = " hello, waldo. abc";
1ef04f0b 304
998b087f
TA		 305 r = delete_chars(input, WHITESPACE);
306 assert_se(streq(r, "hello,waldo.abc"));
1ef04f0b
TA		 307}
308
309static void test_in_charset(void) {
998b087f
TA		 310 assert_se(in_charset("dddaaabbbcccc", "abcd"));
311 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
1ef04f0b
TA		 312}
313
44f4c86c
DB		 314static void test_hexchar(void) {
315 assert_se(hexchar(0xa) == 'a');
316 assert_se(hexchar(0x0) == '0');
317}
318
319static void test_unhexchar(void) {
320 assert_se(unhexchar('a') == 0xA);
321 assert_se(unhexchar('A') == 0xA);
322 assert_se(unhexchar('0') == 0x0);
323}
324
325static void test_octchar(void) {
326 assert_se(octchar(00) == '0');
327 assert_se(octchar(07) == '7');
328}
329
330static void test_unoctchar(void) {
331 assert_se(unoctchar('0') == 00);
332 assert_se(unoctchar('7') == 07);
333}
334
335static void test_decchar(void) {
336 assert_se(decchar(0) == '0');
337 assert_se(decchar(9) == '9');
338}
339
340static void test_undecchar(void) {
341 assert_se(undecchar('0') == 0);
342 assert_se(undecchar('9') == 9);
343}
344
b4ecc959
TA		 345static void test_cescape(void) {
346 _cleanup_free_ char *escaped;
e0a33e7b
LP		 347
348 assert_se(escaped = cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
927be00c 349 assert_se(streq(escaped, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
b4ecc959
TA		 350}
351
352static void test_cunescape(void) {
353 _cleanup_free_ char *unescaped;
e0a33e7b
LP		 354
355 assert_se(unescaped = cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00"));
356 assert_se(streq(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
b4ecc959
TA		 357}
358
1ef04f0b 359static void test_foreach_word(void) {
a2a5291b 360 const char *word, *state;
1ef04f0b
TA		 361 size_t l;
362 int i = 0;
363 const char test[] = "test abc d\te f ";
364 const char * const expected[] = {
365 "test",
366 "abc",
367 "d",
368 "e",
369 "f",
370 "",
371 NULL
372 };
373
a2a5291b
ZJS		 374 FOREACH_WORD(word, l, test, state)
375 assert_se(strneq(expected[i++], word, l));
1ef04f0b
TA		 376}
377
539ad707 378static void test_foreach_word_quoted(void) {
a2a5291b 379 const char *word, *state;
539ad707 380 size_t l;
1ef04f0b
TA		 381 int i = 0;
382 const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
383 const char * const expected[] = {
384 "test",
385 "a",
386 "b",
387 "c",
388 "d",
389 "e",
390 "",
391 "",
392 "hhh",
393 "",
394 "",
395 "a b c",
396 NULL
397 };
398
539ad707 399 printf("<%s>\n", test);
a2a5291b 400 FOREACH_WORD_QUOTED(word, l, test, state) {
1ef04f0b 401 _cleanup_free_ char *t = NULL;
539ad707 402
a2a5291b
ZJS		 403 assert_se(t = strndup(word, l));
404 assert_se(strneq(expected[i++], word, l));
539ad707 405 printf("<%s>\n", t);
539ad707 406 }
b2fadec6 407 assert(isempty(state));
539ad707
TA		 408}
409
410static void test_default_term_for_tty(void) {
411 puts(default_term_for_tty("/dev/tty23"));
412 puts(default_term_for_tty("/dev/ttyS23"));
413 puts(default_term_for_tty("/dev/tty0"));
414 puts(default_term_for_tty("/dev/pty0"));
415 puts(default_term_for_tty("/dev/pts/0"));
416 puts(default_term_for_tty("/dev/console"));
417 puts(default_term_for_tty("tty23"));
418 puts(default_term_for_tty("ttyS23"));
419 puts(default_term_for_tty("tty0"));
420 puts(default_term_for_tty("pty0"));
421 puts(default_term_for_tty("pts/0"));
422 puts(default_term_for_tty("console"));
423}
424
0d585d82
TA		 425static void test_memdup_multiply(void) {
426 int org[] = {1, 2, 3};
427 int *dup;
428
429 dup = (int*)memdup_multiply(org, sizeof(int), 3);
430
431 assert_se(dup);
432 assert_se(dup[0] == 1);
433 assert_se(dup[1] == 2);
434 assert_se(dup[2] == 3);
435 free(dup);
436}
437
aa3c5cf8
LP		 438static void test_hostname_is_valid(void) {
439 assert(hostname_is_valid("foobar"));
440 assert(hostname_is_valid("foobar.com"));
441 assert(!hostname_is_valid("fööbar"));
442 assert(!hostname_is_valid(""));
443 assert(!hostname_is_valid("."));
444 assert(!hostname_is_valid(".."));
445 assert(!hostname_is_valid("foobar."));
446 assert(!hostname_is_valid(".foobar"));
447 assert(!hostname_is_valid("foo..bar"));
448 assert(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
449}
450
144e51ec
CR		 451static void test_u64log2(void) {
452 assert(u64log2(0) == 0);
453 assert(u64log2(8) == 3);
454 assert(u64log2(9) == 3);
455 assert(u64log2(15) == 3);
456 assert(u64log2(16) == 4);
457 assert(u64log2(1024*1024) == 20);
458 assert(u64log2(1024*1024+5) == 20);
459}
460
49aa47c7 461static void test_get_process_comm(void) {
143bfdaf 462 struct stat st;
49aa47c7
LP		 463 _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
464 unsigned long long b;
465 pid_t e;
466 uid_t u;
467 gid_t g;
468 dev_t h;
469 int r;
470
143bfdaf
HHPF		 471 if (stat("/proc/1/comm", &st) == 0) {
472 assert_se(get_process_comm(1, &a) >= 0);
473 log_info("pid1 comm: '%s'", a);
474 } else {
475 log_warning("/proc/1/comm does not exist.");
476 }
49aa47c7
LP		 477
478 assert_se(get_starttime_of_pid(1, &b) >= 0);
479 log_info("pid1 starttime: '%llu'", b);
480
481 assert_se(get_process_cmdline(1, 0, true, &c) >= 0);
482 log_info("pid1 cmdline: '%s'", c);
483
484 assert_se(get_process_cmdline(1, 8, false, &d) >= 0);
485 log_info("pid1 cmdline truncated: '%s'", d);
486
487 assert_se(get_parent_of_pid(1, &e) >= 0);
de0671ee 488 log_info("pid1 ppid: "PID_FMT, e);
49aa47c7
LP		 489 assert_se(e == 0);
490
491 assert_se(is_kernel_thread(1) == 0);
492
493 r = get_process_exe(1, &f);
494 assert_se(r >= 0 || r == -EACCES);
495 log_info("pid1 exe: '%s'", strna(f));
496
497 assert_se(get_process_uid(1, &u) == 0);
de0671ee 498 log_info("pid1 uid: "UID_FMT, u);
49aa47c7
LP		 499 assert_se(u == 0);
500
501 assert_se(get_process_gid(1, &g) == 0);
de0671ee 502 log_info("pid1 gid: "GID_FMT, g);
49aa47c7
LP		 503 assert_se(g == 0);
504
505 assert(get_ctty_devnr(1, &h) == -ENOENT);
506
507 getenv_for_pid(1, "PATH", &i);
508 log_info("pid1 $PATH: '%s'", strna(i));
509}
510
2a371001
ZJS		 511static void test_protect_errno(void) {
512 errno = 12;
513 {
514 PROTECT_ERRNO;
515 errno = 11;
516 }
517 assert(errno == 12);
518}
519
5556b5fe 520static void test_parse_size(void) {
b32ff512
ZJS		 521 off_t bytes;
522
5556b5fe 523 assert_se(parse_size("111", 1024, &bytes) == 0);
b32ff512
ZJS		 524 assert_se(bytes == 111);
525
9480794b
ZJS		 526 assert_se(parse_size("111.4", 1024, &bytes) == 0);
527 assert_se(bytes == 111);
528
5556b5fe 529 assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
b32ff512
ZJS		 530 assert_se(bytes == 112);
531
9480794b
ZJS		 532 assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
533 assert_se(bytes == 112);
534
535 assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
536 assert_se(bytes == 3*1024 + 512);
537
538 assert_se(parse_size("3. K", 1024, &bytes) == 0);
539 assert_se(bytes == 3*1024);
540
541 assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
b32ff512
ZJS		 542 assert_se(bytes == 3*1024);
543
840292be 544 assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
b32ff512 545
9480794b
ZJS		 546 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
547 assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
548
840292be
ZJS		 549 assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
550
551 assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
9480794b 552 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
b32ff512 553
840292be
ZJS		 554 assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
555 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
556
557 assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
558
559 assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
560 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
561
562 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
b32ff512
ZJS		 563 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
564
5556b5fe 565 assert_se(parse_size("12P", 1024, &bytes) == 0);
b32ff512
ZJS		 566 assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
567
840292be
ZJS		 568 assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
569
5556b5fe 570 assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
b32ff512
ZJS		 571 assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
572
5556b5fe 573 assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
b32ff512 574
9480794b
ZJS		 575 assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
576
577 assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
578
5556b5fe
LP		 579 assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
580 assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
581 assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
b32ff512 582
5556b5fe 583 assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
b32ff512 584
5556b5fe 585 assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
b32ff512
ZJS		 586}
587
9480794b
ZJS		 588static void test_config_parse_iec_off(void) {
589 off_t offset = 0;
590 assert_se(config_parse_iec_off(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
591 assert_se(offset == 4 * 1024 * 1024);
592
593 assert_se(config_parse_iec_off(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset, NULL) == 0);
594}
595
b4ecc959
TA		 596static void test_strextend(void) {
597 _cleanup_free_ char *str = strdup("0123");
598 strextend(&str, "456", "78", "9", NULL);
599 assert_se(streq(str, "0123456789"));
600}
601
602static void test_strrep(void) {
603 _cleanup_free_ char *one, *three, *zero;
604 one = strrep("waldo", 1);
605 three = strrep("waldo", 3);
606 zero = strrep("waldo", 0);
607
608 assert_se(streq(one, "waldo"));
609 assert_se(streq(three, "waldowaldowaldo"));
610 assert_se(streq(zero, ""));
611}
612
d4ac85c6
LP		 613static void test_split_pair(void) {
614 _cleanup_free_ char *a = NULL, *b = NULL;
615
616 assert_se(split_pair("", "", &a, &b) == -EINVAL);
617 assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
618 assert_se(split_pair("", "=", &a, &b) == -EINVAL);
619 assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
620 assert_se(streq(a, "foo"));
621 assert_se(streq(b, "bar"));
622 free(a);
623 free(b);
624 assert_se(split_pair("==", "==", &a, &b) >= 0);
625 assert_se(streq(a, ""));
626 assert_se(streq(b, ""));
627 free(a);
628 free(b);
629
630 assert_se(split_pair("===", "==", &a, &b) >= 0);
631 assert_se(streq(a, ""));
632 assert_se(streq(b, "="));
633}
634
22f5f628
DR		 635static void test_fstab_node_to_udev_node(void) {
636 char *n;
637
638 n = fstab_node_to_udev_node("LABEL=applé/jack");
639 puts(n);
640 assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
641 free(n);
642
643 n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
644 puts(n);
645 assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
646 free(n);
647
648 n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
649 puts(n);
650 assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
651 free(n);
652
653 n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
654 puts(n);
655 assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
656 free(n);
657
22f5f628
DR		 658 n = fstab_node_to_udev_node("PONIES=awesome");
659 puts(n);
660 assert_se(streq(n, "PONIES=awesome"));
661 free(n);
662
663 n = fstab_node_to_udev_node("/dev/xda1");
664 puts(n);
665 assert_se(streq(n, "/dev/xda1"));
666 free(n);
667}
668
893fa014
ZJS		 669static void test_get_files_in_directory(void) {
670 _cleanup_strv_free_ char **l = NULL, **t = NULL;
671
672 assert_se(get_files_in_directory("/tmp", &l) >= 0);
510b857f 673 assert_se(get_files_in_directory(".", &t) >= 0);
893fa014
ZJS		 674 assert_se(get_files_in_directory(".", NULL) >= 0);
675}
676
cabb7806
LP		 677static void test_in_set(void) {
678 assert_se(IN_SET(1, 1));
679 assert_se(IN_SET(1, 1, 2, 3, 4));
680 assert_se(IN_SET(2, 1, 2, 3, 4));
681 assert_se(IN_SET(3, 1, 2, 3, 4));
682 assert_se(IN_SET(4, 1, 2, 3, 4));
683 assert_se(!IN_SET(0, 1));
684 assert_se(!IN_SET(0, 1, 2, 3, 4));
685}
686
87b02843
ZJS		 687static void test_writing_tmpfile(void) {
688 char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
39883f62 689 _cleanup_free_ char *contents = NULL;
65b3903f
ZJS		 690 size_t size;
691 int fd, r;
65b3903f 692 struct iovec iov[3];
39883f62 693
65b3903f
ZJS		 694 IOVEC_SET_STRING(iov[0], "abc\n");
695 IOVEC_SET_STRING(iov[1], ALPHANUMERICAL "\n");
696 IOVEC_SET_STRING(iov[2], "");
697
2d5bdf5b 698 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
87b02843 699 printf("tmpfile: %s", name);
65b3903f 700
87b02843
ZJS		 701 r = writev(fd, iov, 3);
702 assert(r >= 0);
65b3903f
ZJS		 703
704 r = read_full_file(name, &contents, &size);
705 assert(r == 0);
706 printf("contents: %s", contents);
707 assert(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
40edd236
RC		 708
709 unlink(name);
65b3903f
ZJS		 710}
711
29bfbcd6
LP		 712static void test_hexdump(void) {
713 uint8_t data[146];
714 unsigned i;
715
716 hexdump(stdout, NULL, 0);
717 hexdump(stdout, "", 0);
718 hexdump(stdout, "", 1);
719 hexdump(stdout, "x", 1);
720 hexdump(stdout, "x", 2);
721 hexdump(stdout, "foobar", 7);
722 hexdump(stdout, "f\nobar", 7);
723 hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
724
725 for (i = 0; i < ELEMENTSOF(data); i++)
726 data[i] = i*2;
727
728 hexdump(stdout, data, sizeof(data));
729}
730
8fe90522
ZJS		 731static void test_log2i(void) {
732 assert_se(log2i(1) == 0);
733 assert_se(log2i(2) == 1);
734 assert_se(log2i(3) == 1);
735 assert_se(log2i(4) == 2);
736 assert_se(log2i(32) == 5);
737 assert_se(log2i(33) == 5);
738 assert_se(log2i(63) == 5);
739 assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
740}
741
c4a7b2c5
LP		 742static void test_foreach_string(void) {
743 const char * const t[] = {
744 "foo",
745 "bar",
746 "waldo",
747 NULL
748 };
749 const char *x;
750 unsigned i = 0;
751
752 FOREACH_STRING(x, "foo", "bar", "waldo")
753 assert_se(streq_ptr(t[i++], x));
754
755 assert_se(i == 3);
756
757 FOREACH_STRING(x, "zzz")
758 assert_se(streq(x, "zzz"));
759}
760
927be00c
RC		 761static void test_filename_is_safe(void) {
762 char foo[FILENAME_MAX+2];
763 int i;
764
765 assert_se(!filename_is_safe(""));
766 assert_se(!filename_is_safe("/bar/foo"));
767 assert_se(!filename_is_safe("/"));
768 assert_se(!filename_is_safe("."));
769 assert_se(!filename_is_safe(".."));
770
771 for (i=0; i<FILENAME_MAX+1; i++)
772 foo[i] = 'a';
773 foo[FILENAME_MAX+1] = '\0';
774
775 assert_se(!filename_is_safe(foo));
776
777 assert_se(filename_is_safe("foo_bar-333"));
778 assert_se(filename_is_safe("o.o"));
779}
780
1cb1767a
ZJS		 781static void test_string_has_cc(void) {
782 assert_se(string_has_cc("abc\1", NULL));
783 assert_se(string_has_cc("abc\x7f", NULL));
784 assert_se(string_has_cc("abc\x7f", NULL));
785 assert_se(string_has_cc("abc\t\x7f", "\t"));
786 assert_se(string_has_cc("abc\t\x7f", "\t"));
787 assert_se(string_has_cc("\x7f", "\t"));
788 assert_se(string_has_cc("\x7f", "\t\a"));
789
790 assert_se(!string_has_cc("abc\t\t", "\t"));
791 assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
792 assert_se(!string_has_cc("a\ab\tc", "\t\a"));
793}
794
927be00c
RC		 795static void test_ascii_strlower(void) {
796 char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
797 assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"));
798}
799
800static void test_files_same(void) {
801 _cleanup_close_ int fd = -1;
802 char name[] = "/tmp/test-files_same.XXXXXX";
803 char name_alias[] = "/tmp/test-files_same.alias";
804
805 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
806 assert_se(fd >= 0);
807 assert_se(symlink(name, name_alias) >= 0);
808
809 assert_se(files_same(name, name));
810 assert_se(files_same(name, name_alias));
811
812 unlink(name);
813 unlink(name_alias);
814}
815
816static void test_is_valid_documentation_url(void) {
817 assert_se(is_valid_documentation_url("http://www.freedesktop.org/wiki/Software/systemd"));
818 assert_se(is_valid_documentation_url("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
819 assert_se(is_valid_documentation_url("file:foo"));
820 assert_se(is_valid_documentation_url("man:systemd.special(7)"));
821 assert_se(is_valid_documentation_url("info:bar"));
822
823 assert_se(!is_valid_documentation_url("foo:"));
824 assert_se(!is_valid_documentation_url("info:"));
825 assert_se(!is_valid_documentation_url(""));
826}
827
828static void test_file_in_same_dir(void) {
829 assert_se(streq(file_in_same_dir("/", "a"), "/a"));
830 assert_se(streq(file_in_same_dir("/", "/a"), "/a"));
831 assert_se(streq(file_in_same_dir("", "a"), "a"));
832 assert_se(streq(file_in_same_dir("a/", "a"), "a/a"));
833 assert_se(streq(file_in_same_dir("bar/foo", "bar"), "bar/bar"));
834}
835
836static void test_endswith(void) {
837 assert_se(endswith("foobar", "bar"));
838 assert_se(endswith("foobar", ""));
839 assert_se(endswith("foobar", "foobar"));
840 assert_se(endswith("", ""));
841
842 assert_se(!endswith("foobar", "foo"));
843 assert_se(!endswith("foobar", "foobarfoofoo"));
844}
845
846static void test_close_nointr(void) {
847 char name[] = "/tmp/test-test-close_nointr.XXXXXX";
848 int fd;
849
850 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
851 assert_se(fd >= 0);
852 assert_se(close_nointr(fd) >= 0);
853 assert_se(close_nointr(fd) < 0);
854
855 unlink(name);
856}
857
858
859static void test_unlink_noerrno(void) {
860 char name[] = "/tmp/test-close_nointr.XXXXXX";
861 int fd;
862
863 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
864 assert_se(fd >= 0);
865 assert_se(close_nointr(fd) >= 0);
866
867 {
868 PROTECT_ERRNO;
869 errno = -42;
870 assert_se(unlink_noerrno(name) >= 0);
871 assert_se(errno == -42);
872 assert_se(unlink_noerrno(name) < 0);
873 assert_se(errno == -42);
874 }
875}
876
877static void test_readlink_and_make_absolute(void) {
878 char tempdir[] = "/tmp/test-readlink_and_make_absolute";
879 char name[] = "/tmp/test-readlink_and_make_absolute/original";
880 char name2[] = "test-readlink_and_make_absolute/original";
881 char name_alias[] = "/tmp/test-readlink_and_make_absolute-alias";
882 char *r = NULL;
883
684fc892 884 assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0);
927be00c
RC		 885 assert_se(touch(name) >= 0);
886
887 assert_se(symlink(name, name_alias) >= 0);
888 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
889 assert_se(streq(r, name));
890 free(r);
891 assert_se(unlink(name_alias) >= 0);
892
893 assert_se(chdir(tempdir) >= 0);
894 assert_se(symlink(name2, name_alias) >= 0);
895 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
896 assert_se(streq(r, name));
897 free(r);
898 assert_se(unlink(name_alias) >= 0);
899
900 assert_se(rm_rf_dangerous(tempdir, false, true, false) >= 0);
901}
902
903static void test_read_one_char(void) {
904 char r;
905 bool need_nl;
906 char name[] = "/tmp/test-read_one_char.XXXXXX";
907 _cleanup_close_ int fd = -1;
908 FILE *file;
909
910 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
911 assert_se(fd >= 0);
912 file = fdopen(fd, "r+");
913 assert_se(file);
914 assert_se(fputs("c\n", file) >= 0);
915 rewind(file);
916
917 assert_se(read_one_char(file, &r, 1000000, &need_nl) >= 0);
918 assert_se(!need_nl);
919 assert_se(r == 'c');
920 assert_se(read_one_char(file, &r, 1000000, &need_nl) < 0);
921
922 rewind(file);
923 assert_se(fputs("foobar\n", file) >= 0);
924 rewind(file);
925 assert_se(read_one_char(file, &r, 1000000, &need_nl) < 0);
926
927 rewind(file);
928 assert_se(fputs("\n", file) >= 0);
929 rewind(file);
930 assert_se(read_one_char(file, &r, 1000000, &need_nl) < 0);
931
932 unlink(name);
933}
934
935static void test_ignore_signals(void) {
936 assert_se(ignore_signals(SIGINT, -1) >= 0);
937 assert_se(kill(getpid(), SIGINT) >= 0);
938 assert_se(ignore_signals(SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
939 assert_se(kill(getpid(), SIGUSR1) >= 0);
940 assert_se(kill(getpid(), SIGUSR2) >= 0);
941 assert_se(kill(getpid(), SIGTERM) >= 0);
942 assert_se(kill(getpid(), SIGPIPE) >= 0);
943 assert_se(default_signals(SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
944}
945
946static void test_strshorten(void) {
947 char s[] = "foobar";
948
949 assert_se(strlen(strshorten(s, 6)) == 6);
950 assert_se(strlen(strshorten(s, 12)) == 6);
951 assert_se(strlen(strshorten(s, 2)) == 2);
952 assert_se(strlen(strshorten(s, 0)) == 0);
953}
954
8085f163
DR		 955static void test_strappenda(void) {
956 char *actual;
957
958 actual = strappenda("", "foo", "bar");
959 assert_se(streq(actual, "foobar"));
960
961 actual = strappenda("foo", "bar", "baz");
962 assert_se(streq(actual, "foobarbaz"));
963
964 actual = strappenda("foo", "", "bar", "baz");
965 assert_se(streq(actual, "foobarbaz"));
966}
967
8852362b
RC		 968static void test_is_symlink(void) {
969 char name[] = "/tmp/test-is_symlink.XXXXXX";
970 char name_link[] = "/tmp/test-is_symlink.link";
971 _cleanup_close_ int fd = -1;
972
973 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
974 assert_se(fd >= 0);
975 assert_se(symlink(name, name_link) >= 0);
976
977 assert_se(is_symlink(name) == 0);
978 assert_se(is_symlink(name_link) == 1);
979 assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
980
981
982 unlink(name);
983 unlink(name_link);
984}
985
986static void test_pid_is_unwaited(void) {
987 pid_t pid;
988
989 pid = fork();
990 assert_se(pid >= 0);
991 if (pid == 0) {
992 _exit(EXIT_SUCCESS);
993 } else {
994 int status;
995
996 waitpid(pid, &status, 0);
997 assert_se(!pid_is_unwaited(pid));
998 }
999 assert_se(pid_is_unwaited(getpid()));
1000 assert_se(!pid_is_unwaited(-1));
1001}
1002
1003static void test_pid_is_alive(void) {
1004 pid_t pid;
1005
1006 pid = fork();
1007 assert_se(pid >= 0);
1008 if (pid == 0) {
1009 _exit(EXIT_SUCCESS);
1010 } else {
1011 int status;
1012
1013 waitpid(pid, &status, 0);
1014 assert_se(!pid_is_alive(pid));
1015 }
1016 assert_se(pid_is_alive(getpid()));
1017 assert_se(!pid_is_alive(-1));
1018}
1019
1020static void test_search_and_fopen(void) {
1021 const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
1022 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1023 int fd = -1;
1024 int r;
1025 FILE *f;
1026
1027 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1028 assert_se(fd >= 0);
1029 close(fd);
1030
1031 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1032 assert_se(r >= 0);
1033 fclose(f);
1034
1035 r = search_and_fopen(name, "r", NULL, dirs, &f);
1036 assert_se(r >= 0);
1037 fclose(f);
1038
1039 r = search_and_fopen(basename(name), "r", "/", dirs, &f);
1040 assert_se(r >= 0);
1041 fclose(f);
1042
1043 r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1044 assert_se(r < 0);
1045 r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1046 assert_se(r < 0);
1047
1048 r = unlink(name);
1049 assert_se(r == 0);
1050
1051 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1052 assert_se(r < 0);
1053}
1054
1055
1056static void test_search_and_fopen_nulstr(void) {
1057 const char dirs[] = "/tmp/foo/bar\0/tmp\0";
1058 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1059 int fd = -1;
1060 int r;
1061 FILE *f;
1062
1063 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1064 assert_se(fd >= 0);
1065 close(fd);
1066
1067 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1068 assert_se(r >= 0);
1069 fclose(f);
1070
1071 r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
1072 assert_se(r >= 0);
1073 fclose(f);
1074
1075 r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1076 assert_se(r < 0);
1077 r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1078 assert_se(r < 0);
1079
1080 r = unlink(name);
1081 assert_se(r == 0);
1082
1083 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1084 assert_se(r < 0);
1085}
1086
1087static void test_glob_exists(void) {
1088 char name[] = "/tmp/test-glob_exists.XXXXXX";
1089 int fd = -1;
1090 int r;
1091
1092 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1093 assert_se(fd >= 0);
1094 close(fd);
1095
1096 r = glob_exists("/tmp/test-glob_exists*");
1097 assert_se(r == 1);
1098
1099 r = unlink(name);
1100 assert_se(r == 0);
1101 r = glob_exists("/tmp/test-glob_exists*");
1102 assert_se(r == 0);
1103}
1104
1105static void test_execute_directory(void) {
1106 char name[] = "/tmp/test-execute_directory/script1";
1107 char name2[] = "/tmp/test-execute_directory/script2";
1108 char name3[] = "/tmp/test-execute_directory/useless";
1109 char tempdir[] = "/tmp/test-execute_directory/";
1110
1111 assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0);
1112 assert_se(write_string_file(name, "#!/bin/sh\necho 'Executing '$0\ntouch /tmp/test-execute_directory/it_works") == 0);
1113 assert_se(write_string_file(name2, "#!/bin/sh\necho 'Executing '$0\ntouch /tmp/test-execute_directory/it_works2") == 0);
1114 assert_se(chmod(name, 0755) == 0);
1115 assert_se(chmod(name2, 0755) == 0);
1116 assert_se(touch(name3) >= 0);
1117
1118 execute_directory(tempdir, NULL, DEFAULT_TIMEOUT_USEC, NULL);
1119 assert_se(access("/tmp/test-execute_directory/it_works", F_OK) >= 0);
1120 assert_se(access("/tmp/test-execute_directory/it_works2", F_OK) >= 0);
1121
1122 rm_rf_dangerous(tempdir, false, true, false);
1123}
1124
7629889c
LP		 1125static void test_unquote_first_word(void) {
1126 const char *p, *original;
1127 char *t;
1128
1129 p = original = "foobar waldo";
1130 assert_se(unquote_first_word(&p, &t) > 0);
1131 assert_se(streq(t, "foobar"));
1132 free(t);
1133 assert_se(p == original + 7);
1134
1135 assert_se(unquote_first_word(&p, &t) > 0);
1136 assert_se(streq(t, "waldo"));
1137 free(t);
1138 assert_se(p == original + 12);
1139
1140 assert_se(unquote_first_word(&p, &t) == 0);
1141 assert_se(!t);
1142 assert_se(p == original + 12);
1143
1144 p = original = "\"foobar\" \'waldo\'";
1145 assert_se(unquote_first_word(&p, &t) > 0);
1146 assert_se(streq(t, "foobar"));
1147 free(t);
1148 assert_se(p == original + 9);
1149
1150 assert_se(unquote_first_word(&p, &t) > 0);
1151 assert_se(streq(t, "waldo"));
1152 free(t);
1153 assert_se(p == original + 16);
1154
1155 assert_se(unquote_first_word(&p, &t) == 0);
1156 assert_se(!t);
1157 assert_se(p == original + 16);
1158
1159 p = original = "\"";
1160 assert_se(unquote_first_word(&p, &t) == -EINVAL);
1161 assert_se(p == original + 1);
1162
1163 p = original = "\'";
1164 assert_se(unquote_first_word(&p, &t) == -EINVAL);
1165 assert_se(p == original + 1);
1166
1167 p = original = "yay\'foo\'bar";
1168 assert_se(unquote_first_word(&p, &t) > 0);
1169 assert_se(streq(t, "yayfoobar"));
1170 free(t);
1171 assert_se(p == original + 11);
1172
1173 p = original = " foobar ";
1174 assert_se(unquote_first_word(&p, &t) > 0);
1175 assert_se(streq(t, "foobar"));
1176 free(t);
1177 assert_se(p == original + 12);
1178}
1179
1180static void test_unquote_many_words(void) {
1181 const char *p, *original;
1182 char *a, *b, *c;
1183
1184 p = original = "foobar waldi piep";
1185 assert_se(unquote_many_words(&p, &a, &b, &c, NULL) == 3);
1186 assert_se(p == original + 17);
1187 assert_se(streq_ptr(a, "foobar"));
1188 assert_se(streq_ptr(b, "waldi"));
1189 assert_se(streq_ptr(c, "piep"));
1190 free(a);
1191 free(b);
1192 free(c);
1193
1194 p = original = "'foobar' wa\"ld\"i ";
1195 assert_se(unquote_many_words(&p, &a, &b, &c, NULL) == 2);
1196 assert_se(p == original + 19);
1197 assert_se(streq_ptr(a, "foobar"));
1198 assert_se(streq_ptr(b, "waldi"));
1199 assert_se(streq_ptr(c, NULL));
1200 free(a);
1201 free(b);
1202
1203 p = original = "";
1204 assert_se(unquote_many_words(&p, &a, &b, &c, NULL) == 0);
1205 assert_se(p == original);
1206 assert_se(streq_ptr(a, NULL));
1207 assert_se(streq_ptr(b, NULL));
1208 assert_se(streq_ptr(c, NULL));
1209
1210 p = original = " ";
1211 assert_se(unquote_many_words(&p, &a, &b, &c, NULL) == 0);
1212 assert_se(p == original+2);
1213 assert_se(streq_ptr(a, NULL));
1214 assert_se(streq_ptr(b, NULL));
1215 assert_se(streq_ptr(c, NULL));
1216
1217 p = original = "foobar";
1218 assert_se(unquote_many_words(&p, NULL) == 0);
1219 assert_se(p == original);
1220
1221 p = original = "foobar waldi";
1222 assert_se(unquote_many_words(&p, &a, NULL) == 1);
1223 assert_se(p == original+7);
1224 assert_se(streq_ptr(a, "foobar"));
1225
1226 p = original = " foobar ";
1227 assert_se(unquote_many_words(&p, &a, NULL) == 1);
1228 assert_se(p == original+15);
1229 assert_se(streq_ptr(a, "foobar"));
1230}
1231
539ad707 1232int main(int argc, char *argv[]) {
9480794b
ZJS		 1233 log_parse_environment();
1234 log_open();
1235
539ad707 1236 test_streq_ptr();
625e870b 1237 test_align_power2();
7242d742 1238 test_max();
fb835651 1239 test_container_of();
539ad707 1240 test_first_word();
dbd73f9e 1241 test_close_many();
8354c34e 1242 test_parse_boolean();
8d99e5f5
TA		 1243 test_parse_pid();
1244 test_parse_uid();
1245 test_safe_atolli();
1246 test_safe_atod();
dbd73f9e 1247 test_strappend();
1ef04f0b
TA		 1248 test_strstrip();
1249 test_delete_chars();
1250 test_in_charset();
44f4c86c
DB		 1251 test_hexchar();
1252 test_unhexchar();
1253 test_octchar();
1254 test_unoctchar();
1255 test_decchar();
1256 test_undecchar();
b4ecc959
TA		 1257 test_cescape();
1258 test_cunescape();
1ef04f0b 1259 test_foreach_word();
539ad707 1260 test_foreach_word_quoted();
1ef04f0b 1261 test_default_term_for_tty();
0d585d82 1262 test_memdup_multiply();
aa3c5cf8 1263 test_hostname_is_valid();
144e51ec 1264 test_u64log2();
49aa47c7 1265 test_get_process_comm();
2a371001 1266 test_protect_errno();
5556b5fe 1267 test_parse_size();
9480794b 1268 test_config_parse_iec_off();
b4ecc959
TA		 1269 test_strextend();
1270 test_strrep();
d4ac85c6 1271 test_split_pair();
22f5f628 1272 test_fstab_node_to_udev_node();
893fa014 1273 test_get_files_in_directory();
cabb7806 1274 test_in_set();
87b02843 1275 test_writing_tmpfile();
29bfbcd6 1276 test_hexdump();
8fe90522 1277 test_log2i();
c4a7b2c5 1278 test_foreach_string();
927be00c 1279 test_filename_is_safe();
1cb1767a 1280 test_string_has_cc();
927be00c
RC		 1281 test_ascii_strlower();
1282 test_files_same();
1283 test_is_valid_documentation_url();
1284 test_file_in_same_dir();
1285 test_endswith();
1286 test_close_nointr();
1287 test_unlink_noerrno();
1288 test_readlink_and_make_absolute();
1289 test_read_one_char();
1290 test_ignore_signals();
1291 test_strshorten();
8085f163 1292 test_strappenda();
8852362b
RC		 1293 test_is_symlink();
1294 test_pid_is_unwaited();
1295 test_pid_is_alive();
1296 test_search_and_fopen();
1297 test_search_and_fopen_nulstr();
1298 test_glob_exists();
1299 test_execute_directory();
7629889c
LP		 1300 test_unquote_first_word();
1301 test_unquote_many_words();
539ad707
TA		 1302
1303 return 0;
1304}
Unnamed repository; edit this file 'description' to name the repository.