1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
7 Copyright 2013 Thomas H.P. Andersen
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.
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.
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/>.
29 #include <sys/types.h>
31 #include <sys/xattr.h>
34 #include "conf-parser.h"
35 #include "cpu-set-util.h"
42 #include "process-util.h"
44 #include "signal-util.h"
45 #include "string-util.h"
50 static void test_streq_ptr(void) {
51 assert_se(streq_ptr(NULL
, NULL
));
52 assert_se(!streq_ptr("abc", "cdef"));
55 static void test_align_power2(void) {
58 assert_se(ALIGN_POWER2(0) == 0);
59 assert_se(ALIGN_POWER2(1) == 1);
60 assert_se(ALIGN_POWER2(2) == 2);
61 assert_se(ALIGN_POWER2(3) == 4);
62 assert_se(ALIGN_POWER2(12) == 16);
64 assert_se(ALIGN_POWER2(ULONG_MAX
) == 0);
65 assert_se(ALIGN_POWER2(ULONG_MAX
- 1) == 0);
66 assert_se(ALIGN_POWER2(ULONG_MAX
- 1024) == 0);
67 assert_se(ALIGN_POWER2(ULONG_MAX
/ 2) == ULONG_MAX
/ 2 + 1);
68 assert_se(ALIGN_POWER2(ULONG_MAX
+ 1) == 0);
70 for (i
= 1; i
< 131071; ++i
) {
71 for (p2
= 1; p2
< i
; p2
<<= 1)
74 assert_se(ALIGN_POWER2(i
) == p2
);
77 for (i
= ULONG_MAX
- 1024; i
< ULONG_MAX
; ++i
) {
78 for (p2
= 1; p2
&& p2
< i
; p2
<<= 1)
81 assert_se(ALIGN_POWER2(i
) == p2
);
85 static void test_max(void) {
88 int b
[CONST_MAX(10, 100)];
90 .a
= CONST_MAX(10, 100),
94 assert_cc(sizeof(val1
.b
) == sizeof(int) * 100);
96 /* CONST_MAX returns (void) instead of a value if the passed arguments
97 * are not of the same type or not constant expressions. */
98 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
99 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
101 assert_se(val1
.a
== 100);
102 assert_se(MAX(++d
, 0) == 1);
105 assert_cc(MAXSIZE(char[3], uint16_t) == 3);
106 assert_cc(MAXSIZE(char[3], uint32_t) == 4);
107 assert_cc(MAXSIZE(char, long) == sizeof(long));
109 assert_se(MAX(-5, 5) == 5);
110 assert_se(MAX(5, 5) == 5);
111 assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
112 assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
113 assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
114 assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
115 assert_se(LESS_BY(8, 4) == 4);
116 assert_se(LESS_BY(8, 8) == 0);
117 assert_se(LESS_BY(4, 8) == 0);
118 assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
119 assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
120 assert_se(CLAMP(-5, 0, 1) == 0);
121 assert_se(CLAMP(5, 0, 1) == 1);
122 assert_se(CLAMP(5, -10, 1) == 1);
123 assert_se(CLAMP(5, -10, 10) == 5);
124 assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
127 static void test_container_of(void) {
133 } _packed_ myval
= { };
135 assert_cc(sizeof(myval
) == 17);
136 assert_se(container_of(&myval
.v1
, struct mytype
, v1
) == &myval
);
137 assert_se(container_of(&myval
.v2
, struct mytype
, v2
) == &myval
);
138 assert_se(container_of(&container_of(&myval
.v2
,
145 static void test_alloca(void) {
146 static const uint8_t zero
[997] = { };
149 t
= alloca_align(17, 512);
150 assert_se(!((uintptr_t)t
& 0xff));
153 t
= alloca0_align(997, 1024);
154 assert_se(!((uintptr_t)t
& 0x1ff));
155 assert_se(!memcmp(t
, zero
, 997));
158 static void test_div_round_up(void) {
162 assert_se(DIV_ROUND_UP(0, 8) == 0);
163 assert_se(DIV_ROUND_UP(1, 8) == 1);
164 assert_se(DIV_ROUND_UP(8, 8) == 1);
165 assert_se(DIV_ROUND_UP(12, 8) == 2);
166 assert_se(DIV_ROUND_UP(16, 8) == 2);
168 /* test multiple evaluation */
170 assert_se(DIV_ROUND_UP(div
++, 8) == 0 && div
== 1);
171 assert_se(DIV_ROUND_UP(++div
, 8) == 1 && div
== 2);
172 assert_se(DIV_ROUND_UP(8, div
++) == 4 && div
== 3);
173 assert_se(DIV_ROUND_UP(8, ++div
) == 2 && div
== 4);
175 /* overflow test with exact division */
176 assert_se(sizeof(0U) == 4);
177 assert_se(0xfffffffaU
% 10U == 0U);
178 assert_se(0xfffffffaU
/ 10U == 429496729U);
179 assert_se(DIV_ROUND_UP(0xfffffffaU
, 10U) == 429496729U);
180 assert_se((0xfffffffaU
+ 10U - 1U) / 10U == 0U);
181 assert_se(0xfffffffaU
/ 10U + !!(0xfffffffaU
% 10U) == 429496729U);
183 /* overflow test with rounded division */
184 assert_se(0xfffffffdU
% 10U == 3U);
185 assert_se(0xfffffffdU
/ 10U == 429496729U);
186 assert_se(DIV_ROUND_UP(0xfffffffdU
, 10U) == 429496730U);
187 assert_se((0xfffffffdU
+ 10U - 1U) / 10U == 0U);
188 assert_se(0xfffffffdU
/ 10U + !!(0xfffffffdU
% 10U) == 429496730U);
191 static void test_first_word(void) {
192 assert_se(first_word("Hello", ""));
193 assert_se(first_word("Hello", "Hello"));
194 assert_se(first_word("Hello world", "Hello"));
195 assert_se(first_word("Hello\tworld", "Hello"));
196 assert_se(first_word("Hello\nworld", "Hello"));
197 assert_se(first_word("Hello\rworld", "Hello"));
198 assert_se(first_word("Hello ", "Hello"));
200 assert_se(!first_word("Hello", "Hellooo"));
201 assert_se(!first_word("Hello", "xxxxx"));
202 assert_se(!first_word("Hellooo", "Hello"));
205 static void test_close_many(void) {
207 char name0
[] = "/tmp/test-close-many.XXXXXX";
208 char name1
[] = "/tmp/test-close-many.XXXXXX";
209 char name2
[] = "/tmp/test-close-many.XXXXXX";
211 fds
[0] = mkostemp_safe(name0
, O_RDWR
|O_CLOEXEC
);
212 fds
[1] = mkostemp_safe(name1
, O_RDWR
|O_CLOEXEC
);
213 fds
[2] = mkostemp_safe(name2
, O_RDWR
|O_CLOEXEC
);
217 assert_se(fcntl(fds
[0], F_GETFD
) == -1);
218 assert_se(fcntl(fds
[1], F_GETFD
) == -1);
219 assert_se(fcntl(fds
[2], F_GETFD
) >= 0);
228 static void test_parse_boolean(void) {
229 assert_se(parse_boolean("1") == 1);
230 assert_se(parse_boolean("y") == 1);
231 assert_se(parse_boolean("Y") == 1);
232 assert_se(parse_boolean("yes") == 1);
233 assert_se(parse_boolean("YES") == 1);
234 assert_se(parse_boolean("true") == 1);
235 assert_se(parse_boolean("TRUE") == 1);
236 assert_se(parse_boolean("on") == 1);
237 assert_se(parse_boolean("ON") == 1);
239 assert_se(parse_boolean("0") == 0);
240 assert_se(parse_boolean("n") == 0);
241 assert_se(parse_boolean("N") == 0);
242 assert_se(parse_boolean("no") == 0);
243 assert_se(parse_boolean("NO") == 0);
244 assert_se(parse_boolean("false") == 0);
245 assert_se(parse_boolean("FALSE") == 0);
246 assert_se(parse_boolean("off") == 0);
247 assert_se(parse_boolean("OFF") == 0);
249 assert_se(parse_boolean("garbage") < 0);
250 assert_se(parse_boolean("") < 0);
251 assert_se(parse_boolean("full") < 0);
254 static void test_parse_pid(void) {
258 r
= parse_pid("100", &pid
);
260 assert_se(pid
== 100);
262 r
= parse_pid("0x7FFFFFFF", &pid
);
264 assert_se(pid
== 2147483647);
266 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
267 r
= parse_pid("0", &pid
);
268 assert_se(r
== -ERANGE
);
269 assert_se(pid
== 65);
271 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
272 r
= parse_pid("-100", &pid
);
273 assert_se(r
== -ERANGE
);
274 assert_se(pid
== 65);
276 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
277 r
= parse_pid("0xFFFFFFFFFFFFFFFFF", &pid
);
278 assert_se(r
== -ERANGE
);
279 assert_se(pid
== 65);
281 r
= parse_pid("junk", &pid
);
282 assert_se(r
== -EINVAL
);
285 static void test_parse_uid(void) {
289 r
= parse_uid("100", &uid
);
291 assert_se(uid
== 100);
293 r
= parse_uid("65535", &uid
);
294 assert_se(r
== -ENXIO
);
296 r
= parse_uid("asdsdas", &uid
);
297 assert_se(r
== -EINVAL
);
300 static void test_safe_atou16(void) {
304 r
= safe_atou16("12345", &l
);
306 assert_se(l
== 12345);
308 r
= safe_atou16("123456", &l
);
309 assert_se(r
== -ERANGE
);
311 r
= safe_atou16("junk", &l
);
312 assert_se(r
== -EINVAL
);
315 static void test_safe_atoi16(void) {
319 r
= safe_atoi16("-12345", &l
);
321 assert_se(l
== -12345);
323 r
= safe_atoi16("36536", &l
);
324 assert_se(r
== -ERANGE
);
326 r
= safe_atoi16("junk", &l
);
327 assert_se(r
== -EINVAL
);
330 static void test_safe_atolli(void) {
334 r
= safe_atolli("12345", &l
);
336 assert_se(l
== 12345);
338 r
= safe_atolli("junk", &l
);
339 assert_se(r
== -EINVAL
);
342 static void test_safe_atod(void) {
347 r
= safe_atod("junk", &d
);
348 assert_se(r
== -EINVAL
);
350 r
= safe_atod("0.2244", &d
);
352 assert_se(fabs(d
- 0.2244) < 0.000001);
354 r
= safe_atod("0,5", &d
);
355 assert_se(r
== -EINVAL
);
359 assert_se(*e
== ',');
361 /* Check if this really is locale independent */
362 if (setlocale(LC_NUMERIC
, "de_DE.utf8")) {
364 r
= safe_atod("0.2244", &d
);
366 assert_se(fabs(d
- 0.2244) < 0.000001);
368 r
= safe_atod("0,5", &d
);
369 assert_se(r
== -EINVAL
);
372 assert_se(fabs(strtod("0,5", &e
) - 0.5) < 0.00001);
375 /* And check again, reset */
376 assert_se(setlocale(LC_NUMERIC
, "C"));
378 r
= safe_atod("0.2244", &d
);
380 assert_se(fabs(d
- 0.2244) < 0.000001);
382 r
= safe_atod("0,5", &d
);
383 assert_se(r
== -EINVAL
);
387 assert_se(*e
== ',');
390 static void test_strappend(void) {
391 _cleanup_free_
char *t1
, *t2
, *t3
, *t4
;
393 t1
= strappend(NULL
, NULL
);
394 assert_se(streq(t1
, ""));
396 t2
= strappend(NULL
, "suf");
397 assert_se(streq(t2
, "suf"));
399 t3
= strappend("pre", NULL
);
400 assert_se(streq(t3
, "pre"));
402 t4
= strappend("pre", "suf");
403 assert_se(streq(t4
, "presuf"));
406 static void test_strstrip(void) {
408 char input
[] = " hello, waldo. ";
411 assert_se(streq(r
, "hello, waldo."));
414 static void test_delete_chars(void) {
416 char input
[] = " hello, waldo. abc";
418 r
= delete_chars(input
, WHITESPACE
);
419 assert_se(streq(r
, "hello,waldo.abc"));
422 static void test_in_charset(void) {
423 assert_se(in_charset("dddaaabbbcccc", "abcd"));
424 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
427 static void test_hexchar(void) {
428 assert_se(hexchar(0xa) == 'a');
429 assert_se(hexchar(0x0) == '0');
432 static void test_unhexchar(void) {
433 assert_se(unhexchar('a') == 0xA);
434 assert_se(unhexchar('A') == 0xA);
435 assert_se(unhexchar('0') == 0x0);
438 static void test_base32hexchar(void) {
439 assert_se(base32hexchar(0) == '0');
440 assert_se(base32hexchar(9) == '9');
441 assert_se(base32hexchar(10) == 'A');
442 assert_se(base32hexchar(31) == 'V');
445 static void test_unbase32hexchar(void) {
446 assert_se(unbase32hexchar('0') == 0);
447 assert_se(unbase32hexchar('9') == 9);
448 assert_se(unbase32hexchar('A') == 10);
449 assert_se(unbase32hexchar('V') == 31);
450 assert_se(unbase32hexchar('=') == -EINVAL
);
453 static void test_base64char(void) {
454 assert_se(base64char(0) == 'A');
455 assert_se(base64char(26) == 'a');
456 assert_se(base64char(63) == '/');
459 static void test_unbase64char(void) {
460 assert_se(unbase64char('A') == 0);
461 assert_se(unbase64char('Z') == 25);
462 assert_se(unbase64char('a') == 26);
463 assert_se(unbase64char('z') == 51);
464 assert_se(unbase64char('0') == 52);
465 assert_se(unbase64char('9') == 61);
466 assert_se(unbase64char('+') == 62);
467 assert_se(unbase64char('/') == 63);
468 assert_se(unbase64char('=') == -EINVAL
);
471 static void test_octchar(void) {
472 assert_se(octchar(00) == '0');
473 assert_se(octchar(07) == '7');
476 static void test_unoctchar(void) {
477 assert_se(unoctchar('0') == 00);
478 assert_se(unoctchar('7') == 07);
481 static void test_decchar(void) {
482 assert_se(decchar(0) == '0');
483 assert_se(decchar(9) == '9');
486 static void test_undecchar(void) {
487 assert_se(undecchar('0') == 0);
488 assert_se(undecchar('9') == 9);
491 static void test_unhexmem(void) {
492 const char *hex
= "efa214921";
493 const char *hex_invalid
= "efa214921o";
494 _cleanup_free_
char *hex2
= NULL
;
495 _cleanup_free_
void *mem
= NULL
;
498 assert_se(unhexmem(hex
, strlen(hex
), &mem
, &len
) == 0);
499 assert_se(unhexmem(hex
, strlen(hex
) + 1, &mem
, &len
) == -EINVAL
);
500 assert_se(unhexmem(hex_invalid
, strlen(hex_invalid
), &mem
, &len
) == -EINVAL
);
502 assert_se((hex2
= hexmem(mem
, len
)));
506 assert_se(memcmp(hex
, hex2
, strlen(hex
)) == 0);
510 assert_se(unhexmem(hex
, strlen(hex
) - 1, &mem
, &len
) == 0);
511 assert_se((hex2
= hexmem(mem
, len
)));
512 assert_se(memcmp(hex
, hex2
, strlen(hex
) - 1) == 0);
515 /* https://tools.ietf.org/html/rfc4648#section-10 */
516 static void test_base32hexmem(void) {
519 b32
= base32hexmem("", strlen(""), true);
521 assert_se(streq(b32
, ""));
524 b32
= base32hexmem("f", strlen("f"), true);
526 assert_se(streq(b32
, "CO======"));
529 b32
= base32hexmem("fo", strlen("fo"), true);
531 assert_se(streq(b32
, "CPNG===="));
534 b32
= base32hexmem("foo", strlen("foo"), true);
536 assert_se(streq(b32
, "CPNMU==="));
539 b32
= base32hexmem("foob", strlen("foob"), true);
541 assert_se(streq(b32
, "CPNMUOG="));
544 b32
= base32hexmem("fooba", strlen("fooba"), true);
546 assert_se(streq(b32
, "CPNMUOJ1"));
549 b32
= base32hexmem("foobar", strlen("foobar"), true);
551 assert_se(streq(b32
, "CPNMUOJ1E8======"));
554 b32
= base32hexmem("", strlen(""), false);
556 assert_se(streq(b32
, ""));
559 b32
= base32hexmem("f", strlen("f"), false);
561 assert_se(streq(b32
, "CO"));
564 b32
= base32hexmem("fo", strlen("fo"), false);
566 assert_se(streq(b32
, "CPNG"));
569 b32
= base32hexmem("foo", strlen("foo"), false);
571 assert_se(streq(b32
, "CPNMU"));
574 b32
= base32hexmem("foob", strlen("foob"), false);
576 assert_se(streq(b32
, "CPNMUOG"));
579 b32
= base32hexmem("fooba", strlen("fooba"), false);
581 assert_se(streq(b32
, "CPNMUOJ1"));
584 b32
= base32hexmem("foobar", strlen("foobar"), false);
586 assert_se(streq(b32
, "CPNMUOJ1E8"));
590 static void test_unbase32hexmem(void) {
594 assert_se(unbase32hexmem("", strlen(""), true, &mem
, &len
) == 0);
595 assert_se(streq(strndupa(mem
, len
), ""));
598 assert_se(unbase32hexmem("CO======", strlen("CO======"), true, &mem
, &len
) == 0);
599 assert_se(streq(strndupa(mem
, len
), "f"));
602 assert_se(unbase32hexmem("CPNG====", strlen("CPNG===="), true, &mem
, &len
) == 0);
603 assert_se(streq(strndupa(mem
, len
), "fo"));
606 assert_se(unbase32hexmem("CPNMU===", strlen("CPNMU==="), true, &mem
, &len
) == 0);
607 assert_se(streq(strndupa(mem
, len
), "foo"));
610 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), true, &mem
, &len
) == 0);
611 assert_se(streq(strndupa(mem
, len
), "foob"));
614 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), true, &mem
, &len
) == 0);
615 assert_se(streq(strndupa(mem
, len
), "fooba"));
618 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), true, &mem
, &len
) == 0);
619 assert_se(streq(strndupa(mem
, len
), "foobar"));
622 assert_se(unbase32hexmem("A", strlen("A"), true, &mem
, &len
) == -EINVAL
);
623 assert_se(unbase32hexmem("A=======", strlen("A======="), true, &mem
, &len
) == -EINVAL
);
624 assert_se(unbase32hexmem("AAA=====", strlen("AAA====="), true, &mem
, &len
) == -EINVAL
);
625 assert_se(unbase32hexmem("AAAAAA==", strlen("AAAAAA=="), true, &mem
, &len
) == -EINVAL
);
626 assert_se(unbase32hexmem("AB======", strlen("AB======"), true, &mem
, &len
) == -EINVAL
);
627 assert_se(unbase32hexmem("AAAB====", strlen("AAAB===="), true, &mem
, &len
) == -EINVAL
);
628 assert_se(unbase32hexmem("AAAAB===", strlen("AAAAB==="), true, &mem
, &len
) == -EINVAL
);
629 assert_se(unbase32hexmem("AAAAAAB=", strlen("AAAAAAB="), true, &mem
, &len
) == -EINVAL
);
631 assert_se(unbase32hexmem("XPNMUOJ1", strlen("CPNMUOJ1"), true, &mem
, &len
) == -EINVAL
);
632 assert_se(unbase32hexmem("CXNMUOJ1", strlen("CPNMUOJ1"), true, &mem
, &len
) == -EINVAL
);
633 assert_se(unbase32hexmem("CPXMUOJ1", strlen("CPNMUOJ1"), true, &mem
, &len
) == -EINVAL
);
634 assert_se(unbase32hexmem("CPNXUOJ1", strlen("CPNMUOJ1"), true, &mem
, &len
) == -EINVAL
);
635 assert_se(unbase32hexmem("CPNMXOJ1", strlen("CPNMUOJ1"), true, &mem
, &len
) == -EINVAL
);
636 assert_se(unbase32hexmem("CPNMUXJ1", strlen("CPNMUOJ1"), true, &mem
, &len
) == -EINVAL
);
637 assert_se(unbase32hexmem("CPNMUOX1", strlen("CPNMUOJ1"), true, &mem
, &len
) == -EINVAL
);
638 assert_se(unbase32hexmem("CPNMUOJX", strlen("CPNMUOJ1"), true, &mem
, &len
) == -EINVAL
);
640 assert_se(unbase32hexmem("", strlen(""), false, &mem
, &len
) == 0);
641 assert_se(streq(strndupa(mem
, len
), ""));
644 assert_se(unbase32hexmem("CO", strlen("CO"), false, &mem
, &len
) == 0);
645 assert_se(streq(strndupa(mem
, len
), "f"));
648 assert_se(unbase32hexmem("CPNG", strlen("CPNG"), false, &mem
, &len
) == 0);
649 assert_se(streq(strndupa(mem
, len
), "fo"));
652 assert_se(unbase32hexmem("CPNMU", strlen("CPNMU"), false, &mem
, &len
) == 0);
653 assert_se(streq(strndupa(mem
, len
), "foo"));
656 assert_se(unbase32hexmem("CPNMUOG", strlen("CPNMUOG"), false, &mem
, &len
) == 0);
657 assert_se(streq(strndupa(mem
, len
), "foob"));
660 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), false, &mem
, &len
) == 0);
661 assert_se(streq(strndupa(mem
, len
), "fooba"));
664 assert_se(unbase32hexmem("CPNMUOJ1E8", strlen("CPNMUOJ1E8"), false, &mem
, &len
) == 0);
665 assert_se(streq(strndupa(mem
, len
), "foobar"));
668 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), false, &mem
, &len
) == -EINVAL
);
669 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), false, &mem
, &len
) == -EINVAL
);
670 assert_se(unbase32hexmem("A", strlen("A"), false, &mem
, &len
) == -EINVAL
);
671 assert_se(unbase32hexmem("A", strlen("A"), false, &mem
, &len
) == -EINVAL
);
672 assert_se(unbase32hexmem("AAA", strlen("AAA"), false, &mem
, &len
) == -EINVAL
);
673 assert_se(unbase32hexmem("AAAAAA", strlen("AAAAAA"), false, &mem
, &len
) == -EINVAL
);
674 assert_se(unbase32hexmem("AB", strlen("AB"), false, &mem
, &len
) == -EINVAL
);
675 assert_se(unbase32hexmem("AAAB", strlen("AAAB"), false, &mem
, &len
) == -EINVAL
);
676 assert_se(unbase32hexmem("AAAAB", strlen("AAAAB"), false, &mem
, &len
) == -EINVAL
);
677 assert_se(unbase32hexmem("AAAAAAB", strlen("AAAAAAB"), false, &mem
, &len
) == -EINVAL
);
680 /* https://tools.ietf.org/html/rfc4648#section-10 */
681 static void test_base64mem(void) {
684 b64
= base64mem("", strlen(""));
686 assert_se(streq(b64
, ""));
689 b64
= base64mem("f", strlen("f"));
691 assert_se(streq(b64
, "Zg=="));
694 b64
= base64mem("fo", strlen("fo"));
696 assert_se(streq(b64
, "Zm8="));
699 b64
= base64mem("foo", strlen("foo"));
701 assert_se(streq(b64
, "Zm9v"));
704 b64
= base64mem("foob", strlen("foob"));
706 assert_se(streq(b64
, "Zm9vYg=="));
709 b64
= base64mem("fooba", strlen("fooba"));
711 assert_se(streq(b64
, "Zm9vYmE="));
714 b64
= base64mem("foobar", strlen("foobar"));
716 assert_se(streq(b64
, "Zm9vYmFy"));
720 static void test_unbase64mem(void) {
724 assert_se(unbase64mem("", strlen(""), &mem
, &len
) == 0);
725 assert_se(streq(strndupa(mem
, len
), ""));
728 assert_se(unbase64mem("Zg==", strlen("Zg=="), &mem
, &len
) == 0);
729 assert_se(streq(strndupa(mem
, len
), "f"));
732 assert_se(unbase64mem("Zm8=", strlen("Zm8="), &mem
, &len
) == 0);
733 assert_se(streq(strndupa(mem
, len
), "fo"));
736 assert_se(unbase64mem("Zm9v", strlen("Zm9v"), &mem
, &len
) == 0);
737 assert_se(streq(strndupa(mem
, len
), "foo"));
740 assert_se(unbase64mem("Zm9vYg==", strlen("Zm9vYg=="), &mem
, &len
) == 0);
741 assert_se(streq(strndupa(mem
, len
), "foob"));
744 assert_se(unbase64mem("Zm9vYmE=", strlen("Zm9vYmE="), &mem
, &len
) == 0);
745 assert_se(streq(strndupa(mem
, len
), "fooba"));
748 assert_se(unbase64mem("Zm9vYmFy", strlen("Zm9vYmFy"), &mem
, &len
) == 0);
749 assert_se(streq(strndupa(mem
, len
), "foobar"));
752 assert_se(unbase64mem("A", strlen("A"), &mem
, &len
) == -EINVAL
);
753 assert_se(unbase64mem("A====", strlen("A===="), &mem
, &len
) == -EINVAL
);
754 assert_se(unbase64mem("AAB==", strlen("AAB=="), &mem
, &len
) == -EINVAL
);
755 assert_se(unbase64mem("AAAB=", strlen("AAAB="), &mem
, &len
) == -EINVAL
);
758 static void test_cescape(void) {
759 _cleanup_free_
char *escaped
;
761 assert_se(escaped
= cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
762 assert_se(streq(escaped
, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
765 static void test_cunescape(void) {
766 _cleanup_free_
char *unescaped
;
768 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped
) < 0);
769 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX
, &unescaped
) >= 0);
770 assert_se(streq_ptr(unescaped
, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
771 unescaped
= mfree(unescaped
);
773 /* incomplete sequences */
774 assert_se(cunescape("\\x0", 0, &unescaped
) < 0);
775 assert_se(cunescape("\\x0", UNESCAPE_RELAX
, &unescaped
) >= 0);
776 assert_se(streq_ptr(unescaped
, "\\x0"));
777 unescaped
= mfree(unescaped
);
779 assert_se(cunescape("\\x", 0, &unescaped
) < 0);
780 assert_se(cunescape("\\x", UNESCAPE_RELAX
, &unescaped
) >= 0);
781 assert_se(streq_ptr(unescaped
, "\\x"));
782 unescaped
= mfree(unescaped
);
784 assert_se(cunescape("\\", 0, &unescaped
) < 0);
785 assert_se(cunescape("\\", UNESCAPE_RELAX
, &unescaped
) >= 0);
786 assert_se(streq_ptr(unescaped
, "\\"));
787 unescaped
= mfree(unescaped
);
789 assert_se(cunescape("\\11", 0, &unescaped
) < 0);
790 assert_se(cunescape("\\11", UNESCAPE_RELAX
, &unescaped
) >= 0);
791 assert_se(streq_ptr(unescaped
, "\\11"));
792 unescaped
= mfree(unescaped
);
794 assert_se(cunescape("\\1", 0, &unescaped
) < 0);
795 assert_se(cunescape("\\1", UNESCAPE_RELAX
, &unescaped
) >= 0);
796 assert_se(streq_ptr(unescaped
, "\\1"));
797 unescaped
= mfree(unescaped
);
799 assert_se(cunescape("\\u0000", 0, &unescaped
) < 0);
800 assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX
, &unescaped
) >= 0);
801 assert_se(streq_ptr(unescaped
, "ßßΠA"));
802 unescaped
= mfree(unescaped
);
804 assert_se(cunescape("\\073", 0, &unescaped
) >= 0);
805 assert_se(streq_ptr(unescaped
, ";"));
808 static void test_foreach_word(void) {
809 const char *word
, *state
;
812 const char test
[] = "test abc d\te f ";
813 const char * const expected
[] = {
823 FOREACH_WORD(word
, l
, test
, state
)
824 assert_se(strneq(expected
[i
++], word
, l
));
827 static void check(const char *test
, char** expected
, bool trailing
) {
828 const char *word
, *state
;
832 printf("<<<%s>>>\n", test
);
833 FOREACH_WORD_QUOTED(word
, l
, test
, state
) {
834 _cleanup_free_
char *t
= NULL
;
836 assert_se(t
= strndup(word
, l
));
837 assert_se(strneq(expected
[i
++], word
, l
));
840 printf("<<<%s>>>\n", state
);
841 assert_se(expected
[i
] == NULL
);
842 assert_se(isempty(state
) == !trailing
);
845 static void test_foreach_word_quoted(void) {
846 check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
870 static void test_memdup_multiply(void) {
871 int org
[] = {1, 2, 3};
874 dup
= (int*)memdup_multiply(org
, sizeof(int), 3);
877 assert_se(dup
[0] == 1);
878 assert_se(dup
[1] == 2);
879 assert_se(dup
[2] == 3);
883 static void test_u64log2(void) {
884 assert_se(u64log2(0) == 0);
885 assert_se(u64log2(8) == 3);
886 assert_se(u64log2(9) == 3);
887 assert_se(u64log2(15) == 3);
888 assert_se(u64log2(16) == 4);
889 assert_se(u64log2(1024*1024) == 20);
890 assert_se(u64log2(1024*1024+5) == 20);
893 static void test_protect_errno(void) {
899 assert_se(errno
== 12);
902 static void test_parse_size(void) {
905 assert_se(parse_size("111", 1024, &bytes
) == 0);
906 assert_se(bytes
== 111);
908 assert_se(parse_size("111.4", 1024, &bytes
) == 0);
909 assert_se(bytes
== 111);
911 assert_se(parse_size(" 112 B", 1024, &bytes
) == 0);
912 assert_se(bytes
== 112);
914 assert_se(parse_size(" 112.6 B", 1024, &bytes
) == 0);
915 assert_se(bytes
== 112);
917 assert_se(parse_size("3.5 K", 1024, &bytes
) == 0);
918 assert_se(bytes
== 3*1024 + 512);
920 assert_se(parse_size("3. K", 1024, &bytes
) == 0);
921 assert_se(bytes
== 3*1024);
923 assert_se(parse_size("3.0 K", 1024, &bytes
) == 0);
924 assert_se(bytes
== 3*1024);
926 assert_se(parse_size("3. 0 K", 1024, &bytes
) == -EINVAL
);
928 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes
) == 0);
929 assert_se(bytes
== 4*1024*1024 + 11 * 1024 + 512);
931 assert_se(parse_size("3B3.5G", 1024, &bytes
) == -EINVAL
);
933 assert_se(parse_size("3.5G3B", 1024, &bytes
) == 0);
934 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
936 assert_se(parse_size("3.5G 4B", 1024, &bytes
) == 0);
937 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
939 assert_se(parse_size("3B3G4T", 1024, &bytes
) == -EINVAL
);
941 assert_se(parse_size("4T3G3B", 1024, &bytes
) == 0);
942 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
944 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes
) == 0);
945 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
947 assert_se(parse_size("12P", 1024, &bytes
) == 0);
948 assert_se(bytes
== 12ULL * 1024*1024*1024*1024*1024);
950 assert_se(parse_size("12P12P", 1024, &bytes
) == -EINVAL
);
952 assert_se(parse_size("3E 2P", 1024, &bytes
) == 0);
953 assert_se(bytes
== (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
955 assert_se(parse_size("12X", 1024, &bytes
) == -EINVAL
);
957 assert_se(parse_size("12.5X", 1024, &bytes
) == -EINVAL
);
959 assert_se(parse_size("12.5e3", 1024, &bytes
) == -EINVAL
);
961 assert_se(parse_size("1024E", 1024, &bytes
) == -ERANGE
);
962 assert_se(parse_size("-1", 1024, &bytes
) == -ERANGE
);
963 assert_se(parse_size("-1024E", 1024, &bytes
) == -ERANGE
);
965 assert_se(parse_size("-1024P", 1024, &bytes
) == -ERANGE
);
967 assert_se(parse_size("-10B 20K", 1024, &bytes
) == -ERANGE
);
970 static void test_parse_cpu_set(void) {
975 /* Simple range (from CPUAffinity example) */
976 ncpus
= parse_cpu_set_and_warn("1 2", &c
, NULL
, "fake", 1, "CPUAffinity");
977 assert_se(ncpus
>= 1024);
978 assert_se(CPU_ISSET_S(1, CPU_ALLOC_SIZE(ncpus
), c
));
979 assert_se(CPU_ISSET_S(2, CPU_ALLOC_SIZE(ncpus
), c
));
980 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus
), c
) == 2);
983 /* A more interesting range */
984 ncpus
= parse_cpu_set_and_warn("0 1 2 3 8 9 10 11", &c
, NULL
, "fake", 1, "CPUAffinity");
985 assert_se(ncpus
>= 1024);
986 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus
), c
) == 8);
987 for (cpu
= 0; cpu
< 4; cpu
++)
988 assert_se(CPU_ISSET_S(cpu
, CPU_ALLOC_SIZE(ncpus
), c
));
989 for (cpu
= 8; cpu
< 12; cpu
++)
990 assert_se(CPU_ISSET_S(cpu
, CPU_ALLOC_SIZE(ncpus
), c
));
994 ncpus
= parse_cpu_set_and_warn("8 '9' 10 \"11\"", &c
, NULL
, "fake", 1, "CPUAffinity");
995 assert_se(ncpus
>= 1024);
996 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus
), c
) == 4);
997 for (cpu
= 8; cpu
< 12; cpu
++)
998 assert_se(CPU_ISSET_S(cpu
, CPU_ALLOC_SIZE(ncpus
), c
));
1001 /* Use commas as separators */
1002 ncpus
= parse_cpu_set_and_warn("0,1,2,3 8,9,10,11", &c
, NULL
, "fake", 1, "CPUAffinity");
1003 assert_se(ncpus
< 0);
1007 ncpus
= parse_cpu_set_and_warn("0-3,8-11", &c
, NULL
, "fake", 1, "CPUAffinity");
1008 assert_se(ncpus
< 0);
1012 ncpus
= parse_cpu_set_and_warn("0 1 2 3 garbage", &c
, NULL
, "fake", 1, "CPUAffinity");
1013 assert_se(ncpus
< 0);
1018 ncpus
= parse_cpu_set_and_warn("", &c
, NULL
, "fake", 1, "CPUAffinity");
1019 assert_se(ncpus
== 0); /* empty string returns 0 */
1022 /* Runnaway quoted string */
1023 ncpus
= parse_cpu_set_and_warn("0 1 2 3 \"4 5 6 7 ", &c
, NULL
, "fake", 1, "CPUAffinity");
1024 assert_se(ncpus
< 0);
1028 static void test_config_parse_iec_uint64(void) {
1029 uint64_t offset
= 0;
1030 assert_se(config_parse_iec_uint64(NULL
, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset
, NULL
) == 0);
1031 assert_se(offset
== 4 * 1024 * 1024);
1033 assert_se(config_parse_iec_uint64(NULL
, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset
, NULL
) == 0);
1036 static void test_strextend(void) {
1037 _cleanup_free_
char *str
= strdup("0123");
1038 strextend(&str
, "456", "78", "9", NULL
);
1039 assert_se(streq(str
, "0123456789"));
1042 static void test_strrep(void) {
1043 _cleanup_free_
char *one
, *three
, *zero
;
1044 one
= strrep("waldo", 1);
1045 three
= strrep("waldo", 3);
1046 zero
= strrep("waldo", 0);
1048 assert_se(streq(one
, "waldo"));
1049 assert_se(streq(three
, "waldowaldowaldo"));
1050 assert_se(streq(zero
, ""));
1053 static void test_split_pair(void) {
1054 _cleanup_free_
char *a
= NULL
, *b
= NULL
;
1056 assert_se(split_pair("", "", &a
, &b
) == -EINVAL
);
1057 assert_se(split_pair("foo=bar", "", &a
, &b
) == -EINVAL
);
1058 assert_se(split_pair("", "=", &a
, &b
) == -EINVAL
);
1059 assert_se(split_pair("foo=bar", "=", &a
, &b
) >= 0);
1060 assert_se(streq(a
, "foo"));
1061 assert_se(streq(b
, "bar"));
1064 assert_se(split_pair("==", "==", &a
, &b
) >= 0);
1065 assert_se(streq(a
, ""));
1066 assert_se(streq(b
, ""));
1070 assert_se(split_pair("===", "==", &a
, &b
) >= 0);
1071 assert_se(streq(a
, ""));
1072 assert_se(streq(b
, "="));
1075 static void test_fstab_node_to_udev_node(void) {
1078 n
= fstab_node_to_udev_node("LABEL=applé/jack");
1080 assert_se(streq(n
, "/dev/disk/by-label/applé\\x2fjack"));
1083 n
= fstab_node_to_udev_node("PARTLABEL=pinkié pie");
1085 assert_se(streq(n
, "/dev/disk/by-partlabel/pinkié\\x20pie"));
1088 n
= fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1090 assert_se(streq(n
, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1093 n
= fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1095 assert_se(streq(n
, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1098 n
= fstab_node_to_udev_node("PONIES=awesome");
1100 assert_se(streq(n
, "PONIES=awesome"));
1103 n
= fstab_node_to_udev_node("/dev/xda1");
1105 assert_se(streq(n
, "/dev/xda1"));
1109 static void test_get_files_in_directory(void) {
1110 _cleanup_strv_free_
char **l
= NULL
, **t
= NULL
;
1112 assert_se(get_files_in_directory("/tmp", &l
) >= 0);
1113 assert_se(get_files_in_directory(".", &t
) >= 0);
1114 assert_se(get_files_in_directory(".", NULL
) >= 0);
1117 static void test_in_set(void) {
1118 assert_se(IN_SET(1, 1));
1119 assert_se(IN_SET(1, 1, 2, 3, 4));
1120 assert_se(IN_SET(2, 1, 2, 3, 4));
1121 assert_se(IN_SET(3, 1, 2, 3, 4));
1122 assert_se(IN_SET(4, 1, 2, 3, 4));
1123 assert_se(!IN_SET(0, 1));
1124 assert_se(!IN_SET(0, 1, 2, 3, 4));
1127 static void test_writing_tmpfile(void) {
1128 char name
[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
1129 _cleanup_free_
char *contents
= NULL
;
1132 struct iovec iov
[3];
1134 IOVEC_SET_STRING(iov
[0], "abc\n");
1135 IOVEC_SET_STRING(iov
[1], ALPHANUMERICAL
"\n");
1136 IOVEC_SET_STRING(iov
[2], "");
1138 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1139 printf("tmpfile: %s", name
);
1141 r
= writev(fd
, iov
, 3);
1144 r
= read_full_file(name
, &contents
, &size
);
1146 printf("contents: %s", contents
);
1147 assert_se(streq(contents
, "abc\n" ALPHANUMERICAL
"\n"));
1152 static void test_hexdump(void) {
1156 hexdump(stdout
, NULL
, 0);
1157 hexdump(stdout
, "", 0);
1158 hexdump(stdout
, "", 1);
1159 hexdump(stdout
, "x", 1);
1160 hexdump(stdout
, "x", 2);
1161 hexdump(stdout
, "foobar", 7);
1162 hexdump(stdout
, "f\nobar", 7);
1163 hexdump(stdout
, "xxxxxxxxxxxxxxxxxxxxyz", 23);
1165 for (i
= 0; i
< ELEMENTSOF(data
); i
++)
1168 hexdump(stdout
, data
, sizeof(data
));
1171 static void test_log2i(void) {
1172 assert_se(log2i(1) == 0);
1173 assert_se(log2i(2) == 1);
1174 assert_se(log2i(3) == 1);
1175 assert_se(log2i(4) == 2);
1176 assert_se(log2i(32) == 5);
1177 assert_se(log2i(33) == 5);
1178 assert_se(log2i(63) == 5);
1179 assert_se(log2i(INT_MAX
) == sizeof(int)*8-2);
1182 static void test_foreach_string(void) {
1183 const char * const t
[] = {
1192 FOREACH_STRING(x
, "foo", "bar", "waldo")
1193 assert_se(streq_ptr(t
[i
++], x
));
1197 FOREACH_STRING(x
, "zzz")
1198 assert_se(streq(x
, "zzz"));
1201 static void test_filename_is_valid(void) {
1202 char foo
[FILENAME_MAX
+2];
1205 assert_se(!filename_is_valid(""));
1206 assert_se(!filename_is_valid("/bar/foo"));
1207 assert_se(!filename_is_valid("/"));
1208 assert_se(!filename_is_valid("."));
1209 assert_se(!filename_is_valid(".."));
1211 for (i
=0; i
<FILENAME_MAX
+1; i
++)
1213 foo
[FILENAME_MAX
+1] = '\0';
1215 assert_se(!filename_is_valid(foo
));
1217 assert_se(filename_is_valid("foo_bar-333"));
1218 assert_se(filename_is_valid("o.o"));
1221 static void test_string_has_cc(void) {
1222 assert_se(string_has_cc("abc\1", NULL
));
1223 assert_se(string_has_cc("abc\x7f", NULL
));
1224 assert_se(string_has_cc("abc\x7f", NULL
));
1225 assert_se(string_has_cc("abc\t\x7f", "\t"));
1226 assert_se(string_has_cc("abc\t\x7f", "\t"));
1227 assert_se(string_has_cc("\x7f", "\t"));
1228 assert_se(string_has_cc("\x7f", "\t\a"));
1230 assert_se(!string_has_cc("abc\t\t", "\t"));
1231 assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
1232 assert_se(!string_has_cc("a\ab\tc", "\t\a"));
1235 static void test_ascii_strlower(void) {
1236 char a
[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
1237 assert_se(streq(ascii_strlower(a
), "aabbcc jk ii od lkjjj kkd lk"));
1240 static void test_files_same(void) {
1241 _cleanup_close_
int fd
= -1;
1242 char name
[] = "/tmp/test-files_same.XXXXXX";
1243 char name_alias
[] = "/tmp/test-files_same.alias";
1245 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1247 assert_se(symlink(name
, name_alias
) >= 0);
1249 assert_se(files_same(name
, name
));
1250 assert_se(files_same(name
, name_alias
));
1256 static void test_is_valid_documentation_url(void) {
1257 assert_se(documentation_url_is_valid("http://www.freedesktop.org/wiki/Software/systemd"));
1258 assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
1259 assert_se(documentation_url_is_valid("file:/foo/foo"));
1260 assert_se(documentation_url_is_valid("man:systemd.special(7)"));
1261 assert_se(documentation_url_is_valid("info:bar"));
1263 assert_se(!documentation_url_is_valid("foo:"));
1264 assert_se(!documentation_url_is_valid("info:"));
1265 assert_se(!documentation_url_is_valid(""));
1268 static void test_file_in_same_dir(void) {
1271 t
= file_in_same_dir("/", "a");
1272 assert_se(streq(t
, "/a"));
1275 t
= file_in_same_dir("/", "/a");
1276 assert_se(streq(t
, "/a"));
1279 t
= file_in_same_dir("", "a");
1280 assert_se(streq(t
, "a"));
1283 t
= file_in_same_dir("a/", "a");
1284 assert_se(streq(t
, "a/a"));
1287 t
= file_in_same_dir("bar/foo", "bar");
1288 assert_se(streq(t
, "bar/bar"));
1292 static void test_endswith(void) {
1293 assert_se(endswith("foobar", "bar"));
1294 assert_se(endswith("foobar", ""));
1295 assert_se(endswith("foobar", "foobar"));
1296 assert_se(endswith("", ""));
1298 assert_se(!endswith("foobar", "foo"));
1299 assert_se(!endswith("foobar", "foobarfoofoo"));
1302 static void test_endswith_no_case(void) {
1303 assert_se(endswith_no_case("fooBAR", "bar"));
1304 assert_se(endswith_no_case("foobar", ""));
1305 assert_se(endswith_no_case("foobar", "FOOBAR"));
1306 assert_se(endswith_no_case("", ""));
1308 assert_se(!endswith_no_case("foobar", "FOO"));
1309 assert_se(!endswith_no_case("foobar", "FOOBARFOOFOO"));
1312 static void test_close_nointr(void) {
1313 char name
[] = "/tmp/test-test-close_nointr.XXXXXX";
1316 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1318 assert_se(close_nointr(fd
) >= 0);
1319 assert_se(close_nointr(fd
) < 0);
1325 static void test_unlink_noerrno(void) {
1326 char name
[] = "/tmp/test-close_nointr.XXXXXX";
1329 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1331 assert_se(close_nointr(fd
) >= 0);
1336 assert_se(unlink_noerrno(name
) >= 0);
1337 assert_se(errno
== -42);
1338 assert_se(unlink_noerrno(name
) < 0);
1339 assert_se(errno
== -42);
1343 static void test_readlink_and_make_absolute(void) {
1344 char tempdir
[] = "/tmp/test-readlink_and_make_absolute";
1345 char name
[] = "/tmp/test-readlink_and_make_absolute/original";
1346 char name2
[] = "test-readlink_and_make_absolute/original";
1347 char name_alias
[] = "/tmp/test-readlink_and_make_absolute-alias";
1350 assert_se(mkdir_safe(tempdir
, 0755, getuid(), getgid()) >= 0);
1351 assert_se(touch(name
) >= 0);
1353 assert_se(symlink(name
, name_alias
) >= 0);
1354 assert_se(readlink_and_make_absolute(name_alias
, &r
) >= 0);
1355 assert_se(streq(r
, name
));
1357 assert_se(unlink(name_alias
) >= 0);
1359 assert_se(chdir(tempdir
) >= 0);
1360 assert_se(symlink(name2
, name_alias
) >= 0);
1361 assert_se(readlink_and_make_absolute(name_alias
, &r
) >= 0);
1362 assert_se(streq(r
, name
));
1364 assert_se(unlink(name_alias
) >= 0);
1366 assert_se(rm_rf(tempdir
, REMOVE_ROOT
|REMOVE_PHYSICAL
) >= 0);
1369 static void test_ignore_signals(void) {
1370 assert_se(ignore_signals(SIGINT
, -1) >= 0);
1371 assert_se(kill(getpid(), SIGINT
) >= 0);
1372 assert_se(ignore_signals(SIGUSR1
, SIGUSR2
, SIGTERM
, SIGPIPE
, -1) >= 0);
1373 assert_se(kill(getpid(), SIGUSR1
) >= 0);
1374 assert_se(kill(getpid(), SIGUSR2
) >= 0);
1375 assert_se(kill(getpid(), SIGTERM
) >= 0);
1376 assert_se(kill(getpid(), SIGPIPE
) >= 0);
1377 assert_se(default_signals(SIGINT
, SIGUSR1
, SIGUSR2
, SIGTERM
, SIGPIPE
, -1) >= 0);
1380 static void test_strshorten(void) {
1381 char s
[] = "foobar";
1383 assert_se(strlen(strshorten(s
, 6)) == 6);
1384 assert_se(strlen(strshorten(s
, 12)) == 6);
1385 assert_se(strlen(strshorten(s
, 2)) == 2);
1386 assert_se(strlen(strshorten(s
, 0)) == 0);
1389 static void test_strjoina(void) {
1392 actual
= strjoina("", "foo", "bar");
1393 assert_se(streq(actual
, "foobar"));
1395 actual
= strjoina("foo", "bar", "baz");
1396 assert_se(streq(actual
, "foobarbaz"));
1398 actual
= strjoina("foo", "", "bar", "baz");
1399 assert_se(streq(actual
, "foobarbaz"));
1401 actual
= strjoina("foo");
1402 assert_se(streq(actual
, "foo"));
1404 actual
= strjoina(NULL
);
1405 assert_se(streq(actual
, ""));
1407 actual
= strjoina(NULL
, "foo");
1408 assert_se(streq(actual
, ""));
1410 actual
= strjoina("foo", NULL
, "bar");
1411 assert_se(streq(actual
, "foo"));
1414 static void test_is_symlink(void) {
1415 char name
[] = "/tmp/test-is_symlink.XXXXXX";
1416 char name_link
[] = "/tmp/test-is_symlink.link";
1417 _cleanup_close_
int fd
= -1;
1419 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1421 assert_se(symlink(name
, name_link
) >= 0);
1423 assert_se(is_symlink(name
) == 0);
1424 assert_se(is_symlink(name_link
) == 1);
1425 assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
1432 static void test_search_and_fopen(void) {
1433 const char *dirs
[] = {"/tmp/foo/bar", "/tmp", NULL
};
1434 char name
[] = "/tmp/test-search_and_fopen.XXXXXX";
1439 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1443 r
= search_and_fopen(basename(name
), "r", NULL
, dirs
, &f
);
1447 r
= search_and_fopen(name
, "r", NULL
, dirs
, &f
);
1451 r
= search_and_fopen(basename(name
), "r", "/", dirs
, &f
);
1455 r
= search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL
, dirs
, &f
);
1457 r
= search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL
, dirs
, &f
);
1463 r
= search_and_fopen(basename(name
), "r", NULL
, dirs
, &f
);
1468 static void test_search_and_fopen_nulstr(void) {
1469 const char dirs
[] = "/tmp/foo/bar\0/tmp\0";
1470 char name
[] = "/tmp/test-search_and_fopen.XXXXXX";
1475 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1479 r
= search_and_fopen_nulstr(basename(name
), "r", NULL
, dirs
, &f
);
1483 r
= search_and_fopen_nulstr(name
, "r", NULL
, dirs
, &f
);
1487 r
= search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL
, dirs
, &f
);
1489 r
= search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL
, dirs
, &f
);
1495 r
= search_and_fopen_nulstr(basename(name
), "r", NULL
, dirs
, &f
);
1499 static void test_glob_exists(void) {
1500 char name
[] = "/tmp/test-glob_exists.XXXXXX";
1504 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1508 r
= glob_exists("/tmp/test-glob_exists*");
1513 r
= glob_exists("/tmp/test-glob_exists*");
1517 static void test_execute_directory(void) {
1518 char template_lo
[] = "/tmp/test-readlink_and_make_absolute-lo.XXXXXXX";
1519 char template_hi
[] = "/tmp/test-readlink_and_make_absolute-hi.XXXXXXX";
1520 const char * dirs
[] = {template_hi
, template_lo
, NULL
};
1521 const char *name
, *name2
, *name3
, *overridden
, *override
, *masked
, *mask
;
1523 assert_se(mkdtemp(template_lo
));
1524 assert_se(mkdtemp(template_hi
));
1526 name
= strjoina(template_lo
, "/script");
1527 name2
= strjoina(template_hi
, "/script2");
1528 name3
= strjoina(template_lo
, "/useless");
1529 overridden
= strjoina(template_lo
, "/overridden");
1530 override
= strjoina(template_hi
, "/overridden");
1531 masked
= strjoina(template_lo
, "/masked");
1532 mask
= strjoina(template_hi
, "/masked");
1534 assert_se(write_string_file(name
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works", WRITE_STRING_FILE_CREATE
) == 0);
1535 assert_se(write_string_file(name2
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2", WRITE_STRING_FILE_CREATE
) == 0);
1536 assert_se(write_string_file(overridden
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE
) == 0);
1537 assert_se(write_string_file(override
, "#!/bin/sh\necho 'Executing '$0", WRITE_STRING_FILE_CREATE
) == 0);
1538 assert_se(write_string_file(masked
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE
) == 0);
1539 assert_se(symlink("/dev/null", mask
) == 0);
1540 assert_se(chmod(name
, 0755) == 0);
1541 assert_se(chmod(name2
, 0755) == 0);
1542 assert_se(chmod(overridden
, 0755) == 0);
1543 assert_se(chmod(override
, 0755) == 0);
1544 assert_se(chmod(masked
, 0755) == 0);
1545 assert_se(touch(name3
) >= 0);
1547 execute_directories(dirs
, DEFAULT_TIMEOUT_USEC
, NULL
);
1549 assert_se(chdir(template_lo
) == 0);
1550 assert_se(access("it_works", F_OK
) >= 0);
1551 assert_se(access("failed", F_OK
) < 0);
1553 assert_se(chdir(template_hi
) == 0);
1554 assert_se(access("it_works2", F_OK
) >= 0);
1555 assert_se(access("failed", F_OK
) < 0);
1557 (void) rm_rf(template_lo
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
1558 (void) rm_rf(template_hi
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
1561 static void test_extract_first_word(void) {
1562 const char *p
, *original
;
1565 p
= original
= "foobar waldo";
1566 assert_se(extract_first_word(&p
, &t
, NULL
, 0) > 0);
1567 assert_se(streq(t
, "foobar"));
1569 assert_se(p
== original
+ 7);
1571 assert_se(extract_first_word(&p
, &t
, NULL
, 0) > 0);
1572 assert_se(streq(t
, "waldo"));
1574 assert_se(isempty(p
));
1576 assert_se(extract_first_word(&p
, &t
, NULL
, 0) == 0);
1578 assert_se(isempty(p
));
1580 p
= original
= "\"foobar\" \'waldo\'";
1581 assert_se(extract_first_word(&p
, &t
, NULL
, 0) > 0);
1582 assert_se(streq(t
, "\"foobar\""));
1584 assert_se(p
== original
+ 9);
1586 assert_se(extract_first_word(&p
, &t
, NULL
, 0) > 0);
1587 assert_se(streq(t
, "\'waldo\'"));
1589 assert_se(isempty(p
));
1591 assert_se(extract_first_word(&p
, &t
, NULL
, 0) == 0);
1593 assert_se(isempty(p
));
1595 p
= original
= "\"foobar\" \'waldo\'";
1596 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
) > 0);
1597 assert_se(streq(t
, "foobar"));
1599 assert_se(p
== original
+ 9);
1601 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
) > 0);
1602 assert_se(streq(t
, "waldo"));
1604 assert_se(isempty(p
));
1606 assert_se(extract_first_word(&p
, &t
, NULL
, 0) == 0);
1608 assert_se(isempty(p
));
1610 p
= original
= "\"";
1611 assert_se(extract_first_word(&p
, &t
, NULL
, 0) == 1);
1612 assert_se(streq(t
, "\""));
1614 assert_se(isempty(p
));
1616 p
= original
= "\"";
1617 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
) == -EINVAL
);
1618 assert_se(p
== original
+ 1);
1620 p
= original
= "\'";
1621 assert_se(extract_first_word(&p
, &t
, NULL
, 0) == 1);
1622 assert_se(streq(t
, "\'"));
1624 assert_se(isempty(p
));
1626 p
= original
= "\'";
1627 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
) == -EINVAL
);
1628 assert_se(p
== original
+ 1);
1630 p
= original
= "\'fooo";
1631 assert_se(extract_first_word(&p
, &t
, NULL
, 0) == 1);
1632 assert_se(streq(t
, "\'fooo"));
1634 assert_se(isempty(p
));
1636 p
= original
= "\'fooo";
1637 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
) == -EINVAL
);
1638 assert_se(p
== original
+ 5);
1640 p
= original
= "\'fooo";
1641 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_RELAX
) > 0);
1642 assert_se(streq(t
, "fooo"));
1644 assert_se(isempty(p
));
1646 p
= original
= "\"fooo";
1647 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_RELAX
) > 0);
1648 assert_se(streq(t
, "fooo"));
1650 assert_se(isempty(p
));
1652 p
= original
= "yay\'foo\'bar";
1653 assert_se(extract_first_word(&p
, &t
, NULL
, 0) > 0);
1654 assert_se(streq(t
, "yay\'foo\'bar"));
1656 assert_se(isempty(p
));
1658 p
= original
= "yay\'foo\'bar";
1659 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
) > 0);
1660 assert_se(streq(t
, "yayfoobar"));
1662 assert_se(isempty(p
));
1664 p
= original
= " foobar ";
1665 assert_se(extract_first_word(&p
, &t
, NULL
, 0) > 0);
1666 assert_se(streq(t
, "foobar"));
1668 assert_se(isempty(p
));
1670 p
= original
= " foo\\ba\\x6ar ";
1671 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
) > 0);
1672 assert_se(streq(t
, "foo\ba\x6ar"));
1674 assert_se(isempty(p
));
1676 p
= original
= " foo\\ba\\x6ar ";
1677 assert_se(extract_first_word(&p
, &t
, NULL
, 0) > 0);
1678 assert_se(streq(t
, "foobax6ar"));
1680 assert_se(isempty(p
));
1682 p
= original
= " f\\u00f6o \"pi\\U0001F4A9le\" ";
1683 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
) > 0);
1684 assert_se(streq(t
, "föo"));
1686 assert_se(p
== original
+ 13);
1688 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_CUNESCAPE
) > 0);
1689 assert_se(streq(t
, "pi\360\237\222\251le"));
1691 assert_se(isempty(p
));
1693 p
= original
= "fooo\\";
1694 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_RELAX
) > 0);
1695 assert_se(streq(t
, "fooo"));
1697 assert_se(isempty(p
));
1699 p
= original
= "fooo\\";
1700 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE_RELAX
) > 0);
1701 assert_se(streq(t
, "fooo\\"));
1703 assert_se(isempty(p
));
1705 p
= original
= "fooo\\";
1706 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE_RELAX
|EXTRACT_RELAX
) > 0);
1707 assert_se(streq(t
, "fooo\\"));
1709 assert_se(isempty(p
));
1711 p
= original
= "fooo\\";
1712 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
|EXTRACT_CUNESCAPE_RELAX
) > 0);
1713 assert_se(streq(t
, "fooo\\"));
1715 assert_se(isempty(p
));
1717 p
= original
= "\"foo\\";
1718 assert_se(extract_first_word(&p
, &t
, NULL
, 0) == -EINVAL
);
1719 assert_se(p
== original
+ 5);
1721 p
= original
= "\"foo\\";
1722 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_RELAX
) > 0);
1723 assert_se(streq(t
, "foo"));
1725 assert_se(isempty(p
));
1727 p
= original
= "foo::bar";
1728 assert_se(extract_first_word(&p
, &t
, ":", 0) == 1);
1729 assert_se(streq(t
, "foo"));
1731 assert_se(p
== original
+ 5);
1733 assert_se(extract_first_word(&p
, &t
, ":", 0) == 1);
1734 assert_se(streq(t
, "bar"));
1736 assert_se(isempty(p
));
1738 assert_se(extract_first_word(&p
, &t
, ":", 0) == 0);
1740 assert_se(isempty(p
));
1742 p
= original
= "foo\\:bar::waldo";
1743 assert_se(extract_first_word(&p
, &t
, ":", 0) == 1);
1744 assert_se(streq(t
, "foo:bar"));
1746 assert_se(p
== original
+ 10);
1748 assert_se(extract_first_word(&p
, &t
, ":", 0) == 1);
1749 assert_se(streq(t
, "waldo"));
1751 assert_se(isempty(p
));
1753 assert_se(extract_first_word(&p
, &t
, ":", 0) == 0);
1755 assert_se(isempty(p
));
1757 p
= original
= "\"foo\\";
1758 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_CUNESCAPE_RELAX
) == -EINVAL
);
1759 assert_se(p
== original
+ 5);
1761 p
= original
= "\"foo\\";
1762 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_CUNESCAPE_RELAX
|EXTRACT_RELAX
) > 0);
1763 assert_se(streq(t
, "foo\\"));
1765 assert_se(isempty(p
));
1767 p
= original
= "\"foo\\";
1768 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_CUNESCAPE
|EXTRACT_CUNESCAPE_RELAX
|EXTRACT_RELAX
) > 0);
1769 assert_se(streq(t
, "foo\\"));
1771 assert_se(isempty(p
));
1773 p
= original
= "fooo\\ bar quux";
1774 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_RELAX
) > 0);
1775 assert_se(streq(t
, "fooo bar"));
1777 assert_se(p
== original
+ 10);
1779 p
= original
= "fooo\\ bar quux";
1780 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE_RELAX
) > 0);
1781 assert_se(streq(t
, "fooo bar"));
1783 assert_se(p
== original
+ 10);
1785 p
= original
= "fooo\\ bar quux";
1786 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE_RELAX
|EXTRACT_RELAX
) > 0);
1787 assert_se(streq(t
, "fooo bar"));
1789 assert_se(p
== original
+ 10);
1791 p
= original
= "fooo\\ bar quux";
1792 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
) == -EINVAL
);
1793 assert_se(p
== original
+ 5);
1795 p
= original
= "fooo\\ bar quux";
1796 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
|EXTRACT_CUNESCAPE_RELAX
) > 0);
1797 assert_se(streq(t
, "fooo\\ bar"));
1799 assert_se(p
== original
+ 10);
1801 p
= original
= "\\w+@\\K[\\d.]+";
1802 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
) == -EINVAL
);
1803 assert_se(p
== original
+ 1);
1805 p
= original
= "\\w+@\\K[\\d.]+";
1806 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
|EXTRACT_CUNESCAPE_RELAX
) > 0);
1807 assert_se(streq(t
, "\\w+@\\K[\\d.]+"));
1809 assert_se(isempty(p
));
1811 p
= original
= "\\w+\\b";
1812 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
|EXTRACT_CUNESCAPE_RELAX
) > 0);
1813 assert_se(streq(t
, "\\w+\b"));
1815 assert_se(isempty(p
));
1817 p
= original
= "-N ''";
1818 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
) > 0);
1819 assert_se(streq(t
, "-N"));
1821 assert_se(p
== original
+ 3);
1823 assert_se(extract_first_word(&p
, &t
, NULL
, EXTRACT_QUOTES
) > 0);
1824 assert_se(streq(t
, ""));
1826 assert_se(isempty(p
));
1828 p
= original
= ":foo\\:bar::waldo:";
1829 assert_se(extract_first_word(&p
, &t
, ":", EXTRACT_DONT_COALESCE_SEPARATORS
) == 1);
1831 assert_se(streq(t
, ""));
1833 assert_se(p
== original
+ 1);
1835 assert_se(extract_first_word(&p
, &t
, ":", EXTRACT_DONT_COALESCE_SEPARATORS
) == 1);
1836 assert_se(streq(t
, "foo:bar"));
1838 assert_se(p
== original
+ 10);
1840 assert_se(extract_first_word(&p
, &t
, ":", EXTRACT_DONT_COALESCE_SEPARATORS
) == 1);
1842 assert_se(streq(t
, ""));
1844 assert_se(p
== original
+ 11);
1846 assert_se(extract_first_word(&p
, &t
, ":", EXTRACT_DONT_COALESCE_SEPARATORS
) == 1);
1847 assert_se(streq(t
, "waldo"));
1849 assert_se(p
== original
+ 17);
1851 assert_se(extract_first_word(&p
, &t
, ":", EXTRACT_DONT_COALESCE_SEPARATORS
) == 1);
1852 assert_se(streq(t
, ""));
1854 assert_se(p
== NULL
);
1856 assert_se(extract_first_word(&p
, &t
, ":", EXTRACT_DONT_COALESCE_SEPARATORS
) == 0);
1861 static void test_extract_first_word_and_warn(void) {
1862 const char *p
, *original
;
1865 p
= original
= "foobar waldo";
1866 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, 0, NULL
, "fake", 1, original
) > 0);
1867 assert_se(streq(t
, "foobar"));
1869 assert_se(p
== original
+ 7);
1871 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, 0, NULL
, "fake", 1, original
) > 0);
1872 assert_se(streq(t
, "waldo"));
1874 assert_se(isempty(p
));
1876 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, 0, NULL
, "fake", 1, original
) == 0);
1878 assert_se(isempty(p
));
1880 p
= original
= "\"foobar\" \'waldo\'";
1881 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
, NULL
, "fake", 1, original
) > 0);
1882 assert_se(streq(t
, "foobar"));
1884 assert_se(p
== original
+ 9);
1886 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
, NULL
, "fake", 1, original
) > 0);
1887 assert_se(streq(t
, "waldo"));
1889 assert_se(isempty(p
));
1891 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, 0, NULL
, "fake", 1, original
) == 0);
1893 assert_se(isempty(p
));
1895 p
= original
= "\"";
1896 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
, NULL
, "fake", 1, original
) == -EINVAL
);
1897 assert_se(p
== original
+ 1);
1899 p
= original
= "\'";
1900 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
, NULL
, "fake", 1, original
) == -EINVAL
);
1901 assert_se(p
== original
+ 1);
1903 p
= original
= "\'fooo";
1904 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
, NULL
, "fake", 1, original
) == -EINVAL
);
1905 assert_se(p
== original
+ 5);
1907 p
= original
= "\'fooo";
1908 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_RELAX
, NULL
, "fake", 1, original
) > 0);
1909 assert_se(streq(t
, "fooo"));
1911 assert_se(isempty(p
));
1913 p
= original
= " foo\\ba\\x6ar ";
1914 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1915 assert_se(streq(t
, "foo\ba\x6ar"));
1917 assert_se(isempty(p
));
1919 p
= original
= " foo\\ba\\x6ar ";
1920 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, 0, NULL
, "fake", 1, original
) > 0);
1921 assert_se(streq(t
, "foobax6ar"));
1923 assert_se(isempty(p
));
1925 p
= original
= " f\\u00f6o \"pi\\U0001F4A9le\" ";
1926 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1927 assert_se(streq(t
, "föo"));
1929 assert_se(p
== original
+ 13);
1931 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1932 assert_se(streq(t
, "pi\360\237\222\251le"));
1934 assert_se(isempty(p
));
1936 p
= original
= "fooo\\";
1937 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_RELAX
, NULL
, "fake", 1, original
) > 0);
1938 assert_se(streq(t
, "fooo"));
1940 assert_se(isempty(p
));
1942 p
= original
= "fooo\\";
1943 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, 0, NULL
, "fake", 1, original
) > 0);
1944 assert_se(streq(t
, "fooo\\"));
1946 assert_se(isempty(p
));
1948 p
= original
= "fooo\\";
1949 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1950 assert_se(streq(t
, "fooo\\"));
1952 assert_se(isempty(p
));
1954 p
= original
= "\"foo\\";
1955 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
, NULL
, "fake", 1, original
) == -EINVAL
);
1956 assert_se(p
== original
+ 5);
1958 p
= original
= "\"foo\\";
1959 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_RELAX
, NULL
, "fake", 1, original
) > 0);
1960 assert_se(streq(t
, "foo"));
1962 assert_se(isempty(p
));
1964 p
= original
= "\"foo\\";
1965 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_CUNESCAPE
, NULL
, "fake", 1, original
) == -EINVAL
);
1966 assert_se(p
== original
+ 5);
1968 p
= original
= "\"foo\\";
1969 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_QUOTES
|EXTRACT_CUNESCAPE
|EXTRACT_RELAX
, NULL
, "fake", 1, original
) > 0);
1970 assert_se(streq(t
, "foo"));
1972 assert_se(isempty(p
));
1974 p
= original
= "fooo\\ bar quux";
1975 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_RELAX
, NULL
, "fake", 1, original
) > 0);
1976 assert_se(streq(t
, "fooo bar"));
1978 assert_se(p
== original
+ 10);
1980 p
= original
= "fooo\\ bar quux";
1981 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, 0, NULL
, "fake", 1, original
) > 0);
1982 assert_se(streq(t
, "fooo bar"));
1984 assert_se(p
== original
+ 10);
1986 p
= original
= "fooo\\ bar quux";
1987 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1988 assert_se(streq(t
, "fooo\\ bar"));
1990 assert_se(p
== original
+ 10);
1992 p
= original
= "\\w+@\\K[\\d.]+";
1993 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1994 assert_se(streq(t
, "\\w+@\\K[\\d.]+"));
1996 assert_se(isempty(p
));
1998 p
= original
= "\\w+\\b";
1999 assert_se(extract_first_word_and_warn(&p
, &t
, NULL
, EXTRACT_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
2000 assert_se(streq(t
, "\\w+\b"));
2002 assert_se(isempty(p
));
2005 static void test_extract_many_words(void) {
2006 const char *p
, *original
;
2009 p
= original
= "foobar waldi piep";
2010 assert_se(extract_many_words(&p
, NULL
, 0, &a
, &b
, &c
, NULL
) == 3);
2011 assert_se(isempty(p
));
2012 assert_se(streq_ptr(a
, "foobar"));
2013 assert_se(streq_ptr(b
, "waldi"));
2014 assert_se(streq_ptr(c
, "piep"));
2019 p
= original
= "'foobar' wa\"ld\"i ";
2020 assert_se(extract_many_words(&p
, NULL
, 0, &a
, &b
, &c
, NULL
) == 2);
2021 assert_se(isempty(p
));
2022 assert_se(streq_ptr(a
, "'foobar'"));
2023 assert_se(streq_ptr(b
, "wa\"ld\"i"));
2024 assert_se(streq_ptr(c
, NULL
));
2028 p
= original
= "'foobar' wa\"ld\"i ";
2029 assert_se(extract_many_words(&p
, NULL
, EXTRACT_QUOTES
, &a
, &b
, &c
, NULL
) == 2);
2030 assert_se(isempty(p
));
2031 assert_se(streq_ptr(a
, "foobar"));
2032 assert_se(streq_ptr(b
, "waldi"));
2033 assert_se(streq_ptr(c
, NULL
));
2038 assert_se(extract_many_words(&p
, NULL
, 0, &a
, &b
, &c
, NULL
) == 0);
2039 assert_se(isempty(p
));
2040 assert_se(streq_ptr(a
, NULL
));
2041 assert_se(streq_ptr(b
, NULL
));
2042 assert_se(streq_ptr(c
, NULL
));
2045 assert_se(extract_many_words(&p
, NULL
, 0, &a
, &b
, &c
, NULL
) == 0);
2046 assert_se(isempty(p
));
2047 assert_se(streq_ptr(a
, NULL
));
2048 assert_se(streq_ptr(b
, NULL
));
2049 assert_se(streq_ptr(c
, NULL
));
2051 p
= original
= "foobar";
2052 assert_se(extract_many_words(&p
, NULL
, 0, NULL
) == 0);
2053 assert_se(p
== original
);
2055 p
= original
= "foobar waldi";
2056 assert_se(extract_many_words(&p
, NULL
, 0, &a
, NULL
) == 1);
2057 assert_se(p
== original
+7);
2058 assert_se(streq_ptr(a
, "foobar"));
2061 p
= original
= " foobar ";
2062 assert_se(extract_many_words(&p
, NULL
, 0, &a
, NULL
) == 1);
2063 assert_se(isempty(p
));
2064 assert_se(streq_ptr(a
, "foobar"));
2068 static int parse_item(const char *key
, const char *value
) {
2071 log_info("kernel cmdline option <%s> = <%s>", key
, strna(value
));
2075 static void test_parse_proc_cmdline(void) {
2076 assert_se(parse_proc_cmdline(parse_item
) >= 0);
2079 static void test_raw_clone(void) {
2080 pid_t parent
, pid
, pid2
;
2083 log_info("before clone: getpid()→"PID_FMT
, parent
);
2084 assert_se(raw_getpid() == parent
);
2086 pid
= raw_clone(0, NULL
);
2087 assert_se(pid
>= 0);
2089 pid2
= raw_getpid();
2090 log_info("raw_clone: "PID_FMT
" getpid()→"PID_FMT
" raw_getpid()→"PID_FMT
,
2091 pid
, getpid(), pid2
);
2093 assert_se(pid2
!= parent
);
2094 _exit(EXIT_SUCCESS
);
2098 assert_se(pid2
== parent
);
2099 waitpid(pid
, &status
, __WCLONE
);
2100 assert_se(WIFEXITED(status
) && WEXITSTATUS(status
) == EXIT_SUCCESS
);
2104 static void test_same_fd(void) {
2105 _cleanup_close_pair_
int p
[2] = { -1, -1 };
2106 _cleanup_close_
int a
= -1, b
= -1, c
= -1;
2108 assert_se(pipe2(p
, O_CLOEXEC
) >= 0);
2109 assert_se((a
= dup(p
[0])) >= 0);
2110 assert_se((b
= open("/dev/null", O_RDONLY
|O_CLOEXEC
)) >= 0);
2111 assert_se((c
= dup(a
)) >= 0);
2113 assert_se(same_fd(p
[0], p
[0]) > 0);
2114 assert_se(same_fd(p
[1], p
[1]) > 0);
2115 assert_se(same_fd(a
, a
) > 0);
2116 assert_se(same_fd(b
, b
) > 0);
2118 assert_se(same_fd(a
, p
[0]) > 0);
2119 assert_se(same_fd(p
[0], a
) > 0);
2120 assert_se(same_fd(c
, p
[0]) > 0);
2121 assert_se(same_fd(p
[0], c
) > 0);
2122 assert_se(same_fd(a
, c
) > 0);
2123 assert_se(same_fd(c
, a
) > 0);
2125 assert_se(same_fd(p
[0], p
[1]) == 0);
2126 assert_se(same_fd(p
[1], p
[0]) == 0);
2127 assert_se(same_fd(p
[0], b
) == 0);
2128 assert_se(same_fd(b
, p
[0]) == 0);
2129 assert_se(same_fd(p
[1], a
) == 0);
2130 assert_se(same_fd(a
, p
[1]) == 0);
2131 assert_se(same_fd(p
[1], b
) == 0);
2132 assert_se(same_fd(b
, p
[1]) == 0);
2134 assert_se(same_fd(a
, b
) == 0);
2135 assert_se(same_fd(b
, a
) == 0);
2138 static void test_uid_ptr(void) {
2140 assert_se(UID_TO_PTR(0) != NULL
);
2141 assert_se(UID_TO_PTR(1000) != NULL
);
2143 assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
2144 assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
2147 static void test_sparse_write_one(int fd
, const char *buffer
, size_t n
) {
2150 assert_se(lseek(fd
, 0, SEEK_SET
) == 0);
2151 assert_se(ftruncate(fd
, 0) >= 0);
2152 assert_se(sparse_write(fd
, buffer
, n
, 4) == (ssize_t
) n
);
2154 assert_se(lseek(fd
, 0, SEEK_CUR
) == (off_t
) n
);
2155 assert_se(ftruncate(fd
, n
) >= 0);
2157 assert_se(lseek(fd
, 0, SEEK_SET
) == 0);
2158 assert_se(read(fd
, check
, n
) == (ssize_t
) n
);
2160 assert_se(memcmp(buffer
, check
, n
) == 0);
2163 static void test_sparse_write(void) {
2164 const char test_a
[] = "test";
2165 const char test_b
[] = "\0\0\0\0test\0\0\0\0";
2166 const char test_c
[] = "\0\0test\0\0\0\0";
2167 const char test_d
[] = "\0\0test\0\0\0test\0\0\0\0test\0\0\0\0\0test\0\0\0test\0\0\0\0test\0\0\0\0\0\0\0\0";
2168 const char test_e
[] = "test\0\0\0\0test";
2169 _cleanup_close_
int fd
= -1;
2170 char fn
[] = "/tmp/sparseXXXXXX";
2172 fd
= mkostemp(fn
, O_CLOEXEC
);
2176 test_sparse_write_one(fd
, test_a
, sizeof(test_a
));
2177 test_sparse_write_one(fd
, test_b
, sizeof(test_b
));
2178 test_sparse_write_one(fd
, test_c
, sizeof(test_c
));
2179 test_sparse_write_one(fd
, test_d
, sizeof(test_d
));
2180 test_sparse_write_one(fd
, test_e
, sizeof(test_e
));
2183 static void test_shell_escape_one(const char *s
, const char *bad
, const char *expected
) {
2184 _cleanup_free_
char *r
;
2186 assert_se(r
= shell_escape(s
, bad
));
2187 assert_se(streq_ptr(r
, expected
));
2190 static void test_shell_escape(void) {
2191 test_shell_escape_one("", "", "");
2192 test_shell_escape_one("\\", "", "\\\\");
2193 test_shell_escape_one("foobar", "", "foobar");
2194 test_shell_escape_one("foobar", "o", "f\\o\\obar");
2195 test_shell_escape_one("foo:bar,baz", ",:", "foo\\:bar\\,baz");
2198 static void test_shell_maybe_quote_one(const char *s
, const char *expected
) {
2199 _cleanup_free_
char *r
;
2201 assert_se(r
= shell_maybe_quote(s
));
2202 assert_se(streq(r
, expected
));
2205 static void test_shell_maybe_quote(void) {
2207 test_shell_maybe_quote_one("", "");
2208 test_shell_maybe_quote_one("\\", "\"\\\\\"");
2209 test_shell_maybe_quote_one("\"", "\"\\\"\"");
2210 test_shell_maybe_quote_one("foobar", "foobar");
2211 test_shell_maybe_quote_one("foo bar", "\"foo bar\"");
2212 test_shell_maybe_quote_one("foo \"bar\" waldo", "\"foo \\\"bar\\\" waldo\"");
2213 test_shell_maybe_quote_one("foo$bar", "\"foo\\$bar\"");
2216 static void test_parse_mode(void) {
2219 assert_se(parse_mode("-1", &m
) < 0);
2220 assert_se(parse_mode("", &m
) < 0);
2221 assert_se(parse_mode("888", &m
) < 0);
2222 assert_se(parse_mode("77777", &m
) < 0);
2224 assert_se(parse_mode("544", &m
) >= 0 && m
== 0544);
2225 assert_se(parse_mode("777", &m
) >= 0 && m
== 0777);
2226 assert_se(parse_mode("7777", &m
) >= 0 && m
== 07777);
2227 assert_se(parse_mode("0", &m
) >= 0 && m
== 0);
2230 static void test_tempfn(void) {
2231 char *ret
= NULL
, *p
;
2233 assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL
, &ret
) >= 0);
2234 assert_se(streq_ptr(ret
, "/foo/bar/.#waldoXXXXXX"));
2237 assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret
) >= 0);
2238 assert_se(streq_ptr(ret
, "/foo/bar/.#[miau]waldoXXXXXX"));
2241 assert_se(tempfn_random("/foo/bar/waldo", NULL
, &ret
) >= 0);
2242 assert_se(p
= startswith(ret
, "/foo/bar/.#waldo"));
2243 assert_se(strlen(p
) == 16);
2244 assert_se(in_charset(p
, "0123456789abcdef"));
2247 assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret
) >= 0);
2248 assert_se(p
= startswith(ret
, "/foo/bar/.#[wuff]waldo"));
2249 assert_se(strlen(p
) == 16);
2250 assert_se(in_charset(p
, "0123456789abcdef"));
2253 assert_se(tempfn_random_child("/foo/bar/waldo", NULL
, &ret
) >= 0);
2254 assert_se(p
= startswith(ret
, "/foo/bar/waldo/.#"));
2255 assert_se(strlen(p
) == 16);
2256 assert_se(in_charset(p
, "0123456789abcdef"));
2259 assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret
) >= 0);
2260 assert_se(p
= startswith(ret
, "/foo/bar/waldo/.#[kikiriki]"));
2261 assert_se(strlen(p
) == 16);
2262 assert_se(in_charset(p
, "0123456789abcdef"));
2266 static void test_strcmp_ptr(void) {
2267 assert_se(strcmp_ptr(NULL
, NULL
) == 0);
2268 assert_se(strcmp_ptr("", NULL
) > 0);
2269 assert_se(strcmp_ptr("foo", NULL
) > 0);
2270 assert_se(strcmp_ptr(NULL
, "") < 0);
2271 assert_se(strcmp_ptr(NULL
, "bar") < 0);
2272 assert_se(strcmp_ptr("foo", "bar") > 0);
2273 assert_se(strcmp_ptr("bar", "baz") < 0);
2274 assert_se(strcmp_ptr("foo", "foo") == 0);
2275 assert_se(strcmp_ptr("", "") == 0);
2278 static void test_fgetxattrat_fake(void) {
2279 char t
[] = "/var/tmp/xattrtestXXXXXX";
2280 _cleanup_close_
int fd
= -1;
2285 assert_se(mkdtemp(t
));
2286 x
= strjoina(t
, "/test");
2287 assert_se(touch(x
) >= 0);
2289 r
= setxattr(x
, "user.foo", "bar", 3, 0);
2290 if (r
< 0 && errno
== EOPNOTSUPP
) /* no xattrs supported on /var/tmp... */
2294 fd
= open(t
, O_RDONLY
|O_DIRECTORY
|O_CLOEXEC
|O_NOCTTY
);
2297 assert_se(fgetxattrat_fake(fd
, "test", "user.foo", v
, 3, 0) >= 0);
2298 assert_se(memcmp(v
, "bar", 3) == 0);
2301 fd
= open("/", O_RDONLY
|O_DIRECTORY
|O_CLOEXEC
|O_NOCTTY
);
2303 assert_se(fgetxattrat_fake(fd
, "usr", "user.idontexist", v
, 3, 0) == -ENODATA
);
2306 assert_se(unlink(x
) >= 0);
2307 assert_se(rmdir(t
) >= 0);
2310 int main(int argc
, char *argv
[]) {
2311 log_parse_environment();
2315 test_align_power2();
2317 test_container_of();
2319 test_div_round_up();
2322 test_parse_boolean();
2331 test_delete_chars();
2335 test_base32hexchar();
2336 test_unbase32hexchar();
2338 test_unbase64char();
2344 test_base32hexmem();
2345 test_unbase32hexmem();
2350 test_foreach_word();
2351 test_foreach_word_quoted();
2352 test_memdup_multiply();
2354 test_protect_errno();
2356 test_parse_cpu_set();
2357 test_config_parse_iec_uint64();
2361 test_fstab_node_to_udev_node();
2362 test_get_files_in_directory();
2364 test_writing_tmpfile();
2367 test_foreach_string();
2368 test_filename_is_valid();
2369 test_string_has_cc();
2370 test_ascii_strlower();
2372 test_is_valid_documentation_url();
2373 test_file_in_same_dir();
2375 test_endswith_no_case();
2376 test_close_nointr();
2377 test_unlink_noerrno();
2378 test_readlink_and_make_absolute();
2379 test_ignore_signals();
2383 test_search_and_fopen();
2384 test_search_and_fopen_nulstr();
2386 test_execute_directory();
2387 test_extract_first_word();
2388 test_extract_first_word_and_warn();
2389 test_extract_many_words();
2390 test_parse_proc_cmdline();
2394 test_sparse_write();
2395 test_shell_escape();
2396 test_shell_maybe_quote();
2400 test_fgetxattrat_fake();