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