]>
git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-util.c
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/>.
38 #include "conf-parser.h"
40 #include "process-util.h"
41 #include "hostname-util.h"
42 #include "signal-util.h"
44 static void test_streq_ptr(void) {
45 assert_se(streq_ptr(NULL
, NULL
));
46 assert_se(!streq_ptr("abc", "cdef"));
49 static void test_align_power2(void) {
52 assert_se(ALIGN_POWER2(0) == 0);
53 assert_se(ALIGN_POWER2(1) == 1);
54 assert_se(ALIGN_POWER2(2) == 2);
55 assert_se(ALIGN_POWER2(3) == 4);
56 assert_se(ALIGN_POWER2(12) == 16);
58 assert_se(ALIGN_POWER2(ULONG_MAX
) == 0);
59 assert_se(ALIGN_POWER2(ULONG_MAX
- 1) == 0);
60 assert_se(ALIGN_POWER2(ULONG_MAX
- 1024) == 0);
61 assert_se(ALIGN_POWER2(ULONG_MAX
/ 2) == ULONG_MAX
/ 2 + 1);
62 assert_se(ALIGN_POWER2(ULONG_MAX
+ 1) == 0);
64 for (i
= 1; i
< 131071; ++i
) {
65 for (p2
= 1; p2
< i
; p2
<<= 1)
68 assert_se(ALIGN_POWER2(i
) == p2
);
71 for (i
= ULONG_MAX
- 1024; i
< ULONG_MAX
; ++i
) {
72 for (p2
= 1; p2
&& p2
< i
; p2
<<= 1)
75 assert_se(ALIGN_POWER2(i
) == p2
);
79 static void test_max(void) {
82 int b
[CONST_MAX(10, 100)];
84 .a
= CONST_MAX(10, 100),
88 assert_cc(sizeof(val1
.b
) == sizeof(int) * 100);
90 /* CONST_MAX returns (void) instead of a value if the passed arguments
91 * are not of the same type or not constant expressions. */
92 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
93 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
95 assert_se(val1
.a
== 100);
96 assert_se(MAX(++d
, 0) == 1);
99 assert_cc(MAXSIZE(char[3], uint16_t) == 3);
100 assert_cc(MAXSIZE(char[3], uint32_t) == 4);
101 assert_cc(MAXSIZE(char, long) == sizeof(long));
103 assert_se(MAX(-5, 5) == 5);
104 assert_se(MAX(5, 5) == 5);
105 assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
106 assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
107 assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
108 assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
109 assert_se(LESS_BY(8, 4) == 4);
110 assert_se(LESS_BY(8, 8) == 0);
111 assert_se(LESS_BY(4, 8) == 0);
112 assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
113 assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
114 assert_se(CLAMP(-5, 0, 1) == 0);
115 assert_se(CLAMP(5, 0, 1) == 1);
116 assert_se(CLAMP(5, -10, 1) == 1);
117 assert_se(CLAMP(5, -10, 10) == 5);
118 assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
121 static void test_container_of(void) {
127 } _packed_ myval
= { };
129 assert_cc(sizeof(myval
) == 17);
130 assert_se(container_of(&myval
.v1
, struct mytype
, v1
) == &myval
);
131 assert_se(container_of(&myval
.v2
, struct mytype
, v2
) == &myval
);
132 assert_se(container_of(&container_of(&myval
.v2
,
139 static void test_alloca(void) {
140 static const uint8_t zero
[997] = { };
143 t
= alloca_align(17, 512);
144 assert_se(!((uintptr_t)t
& 0xff));
147 t
= alloca0_align(997, 1024);
148 assert_se(!((uintptr_t)t
& 0x1ff));
149 assert_se(!memcmp(t
, zero
, 997));
152 static void test_div_round_up(void) {
156 assert_se(DIV_ROUND_UP(0, 8) == 0);
157 assert_se(DIV_ROUND_UP(1, 8) == 1);
158 assert_se(DIV_ROUND_UP(8, 8) == 1);
159 assert_se(DIV_ROUND_UP(12, 8) == 2);
160 assert_se(DIV_ROUND_UP(16, 8) == 2);
162 /* test multiple evaluation */
164 assert_se(DIV_ROUND_UP(div
++, 8) == 0 && div
== 1);
165 assert_se(DIV_ROUND_UP(++div
, 8) == 1 && div
== 2);
166 assert_se(DIV_ROUND_UP(8, div
++) == 4 && div
== 3);
167 assert_se(DIV_ROUND_UP(8, ++div
) == 2 && div
== 4);
169 /* overflow test with exact division */
170 assert_se(sizeof(0U) == 4);
171 assert_se(0xfffffffaU
% 10U == 0U);
172 assert_se(0xfffffffaU
/ 10U == 429496729U);
173 assert_se(DIV_ROUND_UP(0xfffffffaU
, 10U) == 429496729U);
174 assert_se((0xfffffffaU
+ 10U - 1U) / 10U == 0U);
175 assert_se(0xfffffffaU
/ 10U + !!(0xfffffffaU
% 10U) == 429496729U);
177 /* overflow test with rounded division */
178 assert_se(0xfffffffdU
% 10U == 3U);
179 assert_se(0xfffffffdU
/ 10U == 429496729U);
180 assert_se(DIV_ROUND_UP(0xfffffffdU
, 10U) == 429496730U);
181 assert_se((0xfffffffdU
+ 10U - 1U) / 10U == 0U);
182 assert_se(0xfffffffdU
/ 10U + !!(0xfffffffdU
% 10U) == 429496730U);
185 static void test_first_word(void) {
186 assert_se(first_word("Hello", ""));
187 assert_se(first_word("Hello", "Hello"));
188 assert_se(first_word("Hello world", "Hello"));
189 assert_se(first_word("Hello\tworld", "Hello"));
190 assert_se(first_word("Hello\nworld", "Hello"));
191 assert_se(first_word("Hello\rworld", "Hello"));
192 assert_se(first_word("Hello ", "Hello"));
194 assert_se(!first_word("Hello", "Hellooo"));
195 assert_se(!first_word("Hello", "xxxxx"));
196 assert_se(!first_word("Hellooo", "Hello"));
199 static void test_close_many(void) {
201 char name0
[] = "/tmp/test-close-many.XXXXXX";
202 char name1
[] = "/tmp/test-close-many.XXXXXX";
203 char name2
[] = "/tmp/test-close-many.XXXXXX";
205 fds
[0] = mkostemp_safe(name0
, O_RDWR
|O_CLOEXEC
);
206 fds
[1] = mkostemp_safe(name1
, O_RDWR
|O_CLOEXEC
);
207 fds
[2] = mkostemp_safe(name2
, O_RDWR
|O_CLOEXEC
);
211 assert_se(fcntl(fds
[0], F_GETFD
) == -1);
212 assert_se(fcntl(fds
[1], F_GETFD
) == -1);
213 assert_se(fcntl(fds
[2], F_GETFD
) >= 0);
222 static void test_parse_boolean(void) {
223 assert_se(parse_boolean("1") == 1);
224 assert_se(parse_boolean("y") == 1);
225 assert_se(parse_boolean("Y") == 1);
226 assert_se(parse_boolean("yes") == 1);
227 assert_se(parse_boolean("YES") == 1);
228 assert_se(parse_boolean("true") == 1);
229 assert_se(parse_boolean("TRUE") == 1);
230 assert_se(parse_boolean("on") == 1);
231 assert_se(parse_boolean("ON") == 1);
233 assert_se(parse_boolean("0") == 0);
234 assert_se(parse_boolean("n") == 0);
235 assert_se(parse_boolean("N") == 0);
236 assert_se(parse_boolean("no") == 0);
237 assert_se(parse_boolean("NO") == 0);
238 assert_se(parse_boolean("false") == 0);
239 assert_se(parse_boolean("FALSE") == 0);
240 assert_se(parse_boolean("off") == 0);
241 assert_se(parse_boolean("OFF") == 0);
243 assert_se(parse_boolean("garbage") < 0);
244 assert_se(parse_boolean("") < 0);
245 assert_se(parse_boolean("full") < 0);
248 static void test_parse_pid(void) {
252 r
= parse_pid("100", &pid
);
254 assert_se(pid
== 100);
256 r
= parse_pid("0x7FFFFFFF", &pid
);
258 assert_se(pid
== 2147483647);
260 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
261 r
= parse_pid("0", &pid
);
262 assert_se(r
== -ERANGE
);
263 assert_se(pid
== 65);
265 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
266 r
= parse_pid("-100", &pid
);
267 assert_se(r
== -ERANGE
);
268 assert_se(pid
== 65);
270 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
271 r
= parse_pid("0xFFFFFFFFFFFFFFFFF", &pid
);
272 assert_se(r
== -ERANGE
);
273 assert_se(pid
== 65);
276 static void test_parse_uid(void) {
280 r
= parse_uid("100", &uid
);
282 assert_se(uid
== 100);
285 static void test_safe_atolli(void) {
289 r
= safe_atolli("12345", &l
);
291 assert_se(l
== 12345);
293 r
= safe_atolli("junk", &l
);
294 assert_se(r
== -EINVAL
);
297 static void test_safe_atod(void) {
302 r
= safe_atod("junk", &d
);
303 assert_se(r
== -EINVAL
);
305 r
= safe_atod("0.2244", &d
);
307 assert_se(fabs(d
- 0.2244) < 0.000001);
309 r
= safe_atod("0,5", &d
);
310 assert_se(r
== -EINVAL
);
314 assert_se(*e
== ',');
316 /* Check if this really is locale independent */
317 if (setlocale(LC_NUMERIC
, "de_DE.utf8")) {
319 r
= safe_atod("0.2244", &d
);
321 assert_se(fabs(d
- 0.2244) < 0.000001);
323 r
= safe_atod("0,5", &d
);
324 assert_se(r
== -EINVAL
);
327 assert_se(fabs(strtod("0,5", &e
) - 0.5) < 0.00001);
330 /* And check again, reset */
331 assert_se(setlocale(LC_NUMERIC
, "C"));
333 r
= safe_atod("0.2244", &d
);
335 assert_se(fabs(d
- 0.2244) < 0.000001);
337 r
= safe_atod("0,5", &d
);
338 assert_se(r
== -EINVAL
);
342 assert_se(*e
== ',');
345 static void test_strappend(void) {
346 _cleanup_free_
char *t1
, *t2
, *t3
, *t4
;
348 t1
= strappend(NULL
, NULL
);
349 assert_se(streq(t1
, ""));
351 t2
= strappend(NULL
, "suf");
352 assert_se(streq(t2
, "suf"));
354 t3
= strappend("pre", NULL
);
355 assert_se(streq(t3
, "pre"));
357 t4
= strappend("pre", "suf");
358 assert_se(streq(t4
, "presuf"));
361 static void test_strstrip(void) {
363 char input
[] = " hello, waldo. ";
366 assert_se(streq(r
, "hello, waldo."));
369 static void test_delete_chars(void) {
371 char input
[] = " hello, waldo. abc";
373 r
= delete_chars(input
, WHITESPACE
);
374 assert_se(streq(r
, "hello,waldo.abc"));
377 static void test_in_charset(void) {
378 assert_se(in_charset("dddaaabbbcccc", "abcd"));
379 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
382 static void test_hexchar(void) {
383 assert_se(hexchar(0xa) == 'a');
384 assert_se(hexchar(0x0) == '0');
387 static void test_unhexchar(void) {
388 assert_se(unhexchar('a') == 0xA);
389 assert_se(unhexchar('A') == 0xA);
390 assert_se(unhexchar('0') == 0x0);
393 static void test_base32hexchar(void) {
394 assert_se(base32hexchar(0) == '0');
395 assert_se(base32hexchar(9) == '9');
396 assert_se(base32hexchar(10) == 'A');
397 assert_se(base32hexchar(31) == 'V');
400 static void test_unbase32hexchar(void) {
401 assert_se(unbase32hexchar('0') == 0);
402 assert_se(unbase32hexchar('9') == 9);
403 assert_se(unbase32hexchar('A') == 10);
404 assert_se(unbase32hexchar('V') == 31);
405 assert_se(unbase32hexchar('=') == -EINVAL
);
408 static void test_base64char(void) {
409 assert_se(base64char(0) == 'A');
410 assert_se(base64char(26) == 'a');
411 assert_se(base64char(63) == '/');
414 static void test_unbase64char(void) {
415 assert_se(unbase64char('A') == 0);
416 assert_se(unbase64char('Z') == 25);
417 assert_se(unbase64char('a') == 26);
418 assert_se(unbase64char('z') == 51);
419 assert_se(unbase64char('0') == 52);
420 assert_se(unbase64char('9') == 61);
421 assert_se(unbase64char('+') == 62);
422 assert_se(unbase64char('/') == 63);
423 assert_se(unbase64char('=') == -EINVAL
);
426 static void test_octchar(void) {
427 assert_se(octchar(00) == '0');
428 assert_se(octchar(07) == '7');
431 static void test_unoctchar(void) {
432 assert_se(unoctchar('0') == 00);
433 assert_se(unoctchar('7') == 07);
436 static void test_decchar(void) {
437 assert_se(decchar(0) == '0');
438 assert_se(decchar(9) == '9');
441 static void test_undecchar(void) {
442 assert_se(undecchar('0') == 0);
443 assert_se(undecchar('9') == 9);
446 static void test_unhexmem(void) {
447 const char *hex
= "efa214921";
448 const char *hex_invalid
= "efa214921o";
449 _cleanup_free_
char *hex2
= NULL
;
450 _cleanup_free_
void *mem
= NULL
;
453 assert_se(unhexmem(hex
, strlen(hex
), &mem
, &len
) == 0);
454 assert_se(unhexmem(hex
, strlen(hex
) + 1, &mem
, &len
) == -EINVAL
);
455 assert_se(unhexmem(hex_invalid
, strlen(hex_invalid
), &mem
, &len
) == -EINVAL
);
457 assert_se((hex2
= hexmem(mem
, len
)));
461 assert_se(memcmp(hex
, hex2
, strlen(hex
)) == 0);
465 assert_se(unhexmem(hex
, strlen(hex
) - 1, &mem
, &len
) == 0);
466 assert_se((hex2
= hexmem(mem
, len
)));
467 assert_se(memcmp(hex
, hex2
, strlen(hex
) - 1) == 0);
470 /* https://tools.ietf.org/html/rfc4648#section-10 */
471 static void test_base32hexmem(void) {
474 b32
= base32hexmem("", strlen(""), true);
476 assert_se(streq(b32
, ""));
479 b32
= base32hexmem("f", strlen("f"), true);
481 assert_se(streq(b32
, "CO======"));
484 b32
= base32hexmem("fo", strlen("fo"), true);
486 assert_se(streq(b32
, "CPNG===="));
489 b32
= base32hexmem("foo", strlen("foo"), true);
491 assert_se(streq(b32
, "CPNMU==="));
494 b32
= base32hexmem("foob", strlen("foob"), true);
496 assert_se(streq(b32
, "CPNMUOG="));
499 b32
= base32hexmem("fooba", strlen("fooba"), true);
501 assert_se(streq(b32
, "CPNMUOJ1"));
504 b32
= base32hexmem("foobar", strlen("foobar"), true);
506 assert_se(streq(b32
, "CPNMUOJ1E8======"));
509 b32
= base32hexmem("", strlen(""), false);
511 assert_se(streq(b32
, ""));
514 b32
= base32hexmem("f", strlen("f"), false);
516 assert_se(streq(b32
, "CO"));
519 b32
= base32hexmem("fo", strlen("fo"), false);
521 assert_se(streq(b32
, "CPNG"));
524 b32
= base32hexmem("foo", strlen("foo"), false);
526 assert_se(streq(b32
, "CPNMU"));
529 b32
= base32hexmem("foob", strlen("foob"), false);
531 assert_se(streq(b32
, "CPNMUOG"));
534 b32
= base32hexmem("fooba", strlen("fooba"), false);
536 assert_se(streq(b32
, "CPNMUOJ1"));
539 b32
= base32hexmem("foobar", strlen("foobar"), false);
541 assert_se(streq(b32
, "CPNMUOJ1E8"));
545 static void test_unbase32hexmem(void) {
549 assert_se(unbase32hexmem("", strlen(""), true, &mem
, &len
) == 0);
550 assert_se(streq(strndupa(mem
, len
), ""));
553 assert_se(unbase32hexmem("CO======", strlen("CO======"), true, &mem
, &len
) == 0);
554 assert_se(streq(strndupa(mem
, len
), "f"));
557 assert_se(unbase32hexmem("CPNG====", strlen("CPNG===="), true, &mem
, &len
) == 0);
558 assert_se(streq(strndupa(mem
, len
), "fo"));
561 assert_se(unbase32hexmem("CPNMU===", strlen("CPNMU==="), true, &mem
, &len
) == 0);
562 assert_se(streq(strndupa(mem
, len
), "foo"));
565 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), true, &mem
, &len
) == 0);
566 assert_se(streq(strndupa(mem
, len
), "foob"));
569 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), true, &mem
, &len
) == 0);
570 assert_se(streq(strndupa(mem
, len
), "fooba"));
573 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), true, &mem
, &len
) == 0);
574 assert_se(streq(strndupa(mem
, len
), "foobar"));
577 assert_se(unbase32hexmem("A", strlen("A"), true, &mem
, &len
) == -EINVAL
);
578 assert_se(unbase32hexmem("A=======", strlen("A======="), true, &mem
, &len
) == -EINVAL
);
579 assert_se(unbase32hexmem("AAA=====", strlen("AAA====="), true, &mem
, &len
) == -EINVAL
);
580 assert_se(unbase32hexmem("AAAAAA==", strlen("AAAAAA=="), true, &mem
, &len
) == -EINVAL
);
581 assert_se(unbase32hexmem("AB======", strlen("AB======"), true, &mem
, &len
) == -EINVAL
);
582 assert_se(unbase32hexmem("AAAB====", strlen("AAAB===="), true, &mem
, &len
) == -EINVAL
);
583 assert_se(unbase32hexmem("AAAAB===", strlen("AAAAB==="), true, &mem
, &len
) == -EINVAL
);
584 assert_se(unbase32hexmem("AAAAAAB=", strlen("AAAAAAB="), true, &mem
, &len
) == -EINVAL
);
586 assert_se(unbase32hexmem("", strlen(""), false, &mem
, &len
) == 0);
587 assert_se(streq(strndupa(mem
, len
), ""));
590 assert_se(unbase32hexmem("CO", strlen("CO"), false, &mem
, &len
) == 0);
591 assert_se(streq(strndupa(mem
, len
), "f"));
594 assert_se(unbase32hexmem("CPNG", strlen("CPNG"), false, &mem
, &len
) == 0);
595 assert_se(streq(strndupa(mem
, len
), "fo"));
598 assert_se(unbase32hexmem("CPNMU", strlen("CPNMU"), false, &mem
, &len
) == 0);
599 assert_se(streq(strndupa(mem
, len
), "foo"));
602 assert_se(unbase32hexmem("CPNMUOG", strlen("CPNMUOG"), false, &mem
, &len
) == 0);
603 assert_se(streq(strndupa(mem
, len
), "foob"));
606 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), false, &mem
, &len
) == 0);
607 assert_se(streq(strndupa(mem
, len
), "fooba"));
610 assert_se(unbase32hexmem("CPNMUOJ1E8", strlen("CPNMUOJ1E8"), false, &mem
, &len
) == 0);
611 assert_se(streq(strndupa(mem
, len
), "foobar"));
614 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), false, &mem
, &len
) == -EINVAL
);
615 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), false, &mem
, &len
) == -EINVAL
);
616 assert_se(unbase32hexmem("A", strlen("A"), false, &mem
, &len
) == -EINVAL
);
617 assert_se(unbase32hexmem("A", strlen("A"), false, &mem
, &len
) == -EINVAL
);
618 assert_se(unbase32hexmem("AAA", strlen("AAA"), false, &mem
, &len
) == -EINVAL
);
619 assert_se(unbase32hexmem("AAAAAA", strlen("AAAAAA"), false, &mem
, &len
) == -EINVAL
);
620 assert_se(unbase32hexmem("AB", strlen("AB"), false, &mem
, &len
) == -EINVAL
);
621 assert_se(unbase32hexmem("AAAB", strlen("AAAB"), false, &mem
, &len
) == -EINVAL
);
622 assert_se(unbase32hexmem("AAAAB", strlen("AAAAB"), false, &mem
, &len
) == -EINVAL
);
623 assert_se(unbase32hexmem("AAAAAAB", strlen("AAAAAAB"), false, &mem
, &len
) == -EINVAL
);
626 /* https://tools.ietf.org/html/rfc4648#section-10 */
627 static void test_base64mem(void) {
630 b64
= base64mem("", strlen(""));
632 assert_se(streq(b64
, ""));
635 b64
= base64mem("f", strlen("f"));
637 assert_se(streq(b64
, "Zg=="));
640 b64
= base64mem("fo", strlen("fo"));
642 assert_se(streq(b64
, "Zm8="));
645 b64
= base64mem("foo", strlen("foo"));
647 assert_se(streq(b64
, "Zm9v"));
650 b64
= base64mem("foob", strlen("foob"));
652 assert_se(streq(b64
, "Zm9vYg=="));
655 b64
= base64mem("fooba", strlen("fooba"));
657 assert_se(streq(b64
, "Zm9vYmE="));
660 b64
= base64mem("foobar", strlen("foobar"));
662 assert_se(streq(b64
, "Zm9vYmFy"));
666 static void test_unbase64mem(void) {
670 assert_se(unbase64mem("", strlen(""), &mem
, &len
) == 0);
671 assert_se(streq(strndupa(mem
, len
), ""));
674 assert_se(unbase64mem("Zg==", strlen("Zg=="), &mem
, &len
) == 0);
675 assert_se(streq(strndupa(mem
, len
), "f"));
678 assert_se(unbase64mem("Zm8=", strlen("Zm8="), &mem
, &len
) == 0);
679 assert_se(streq(strndupa(mem
, len
), "fo"));
682 assert_se(unbase64mem("Zm9v", strlen("Zm9v"), &mem
, &len
) == 0);
683 assert_se(streq(strndupa(mem
, len
), "foo"));
686 assert_se(unbase64mem("Zm9vYg==", strlen("Zm9vYg=="), &mem
, &len
) == 0);
687 assert_se(streq(strndupa(mem
, len
), "foob"));
690 assert_se(unbase64mem("Zm9vYmE=", strlen("Zm9vYmE="), &mem
, &len
) == 0);
691 assert_se(streq(strndupa(mem
, len
), "fooba"));
694 assert_se(unbase64mem("Zm9vYmFy", strlen("Zm9vYmFy"), &mem
, &len
) == 0);
695 assert_se(streq(strndupa(mem
, len
), "foobar"));
698 assert_se(unbase64mem("A", strlen("A"), &mem
, &len
) == -EINVAL
);
699 assert_se(unbase64mem("A====", strlen("A===="), &mem
, &len
) == -EINVAL
);
700 assert_se(unbase64mem("AAB==", strlen("AAB=="), &mem
, &len
) == -EINVAL
);
701 assert_se(unbase64mem("AAAB=", strlen("AAAB="), &mem
, &len
) == -EINVAL
);
704 static void test_cescape(void) {
705 _cleanup_free_
char *escaped
;
707 assert_se(escaped
= cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
708 assert_se(streq(escaped
, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
711 static void test_cunescape(void) {
712 _cleanup_free_
char *unescaped
;
714 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped
) < 0);
715 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX
, &unescaped
) >= 0);
716 assert_se(streq_ptr(unescaped
, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
720 /* incomplete sequences */
721 assert_se(cunescape("\\x0", 0, &unescaped
) < 0);
722 assert_se(cunescape("\\x0", UNESCAPE_RELAX
, &unescaped
) >= 0);
723 assert_se(streq_ptr(unescaped
, "\\x0"));
727 assert_se(cunescape("\\x", 0, &unescaped
) < 0);
728 assert_se(cunescape("\\x", UNESCAPE_RELAX
, &unescaped
) >= 0);
729 assert_se(streq_ptr(unescaped
, "\\x"));
733 assert_se(cunescape("\\", 0, &unescaped
) < 0);
734 assert_se(cunescape("\\", UNESCAPE_RELAX
, &unescaped
) >= 0);
735 assert_se(streq_ptr(unescaped
, "\\"));
739 assert_se(cunescape("\\11", 0, &unescaped
) < 0);
740 assert_se(cunescape("\\11", UNESCAPE_RELAX
, &unescaped
) >= 0);
741 assert_se(streq_ptr(unescaped
, "\\11"));
745 assert_se(cunescape("\\1", 0, &unescaped
) < 0);
746 assert_se(cunescape("\\1", UNESCAPE_RELAX
, &unescaped
) >= 0);
747 assert_se(streq_ptr(unescaped
, "\\1"));
751 assert_se(cunescape("\\u0000", 0, &unescaped
) < 0);
752 assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX
, &unescaped
) >= 0);
753 assert_se(streq_ptr(unescaped
, "ßßΠA"));
757 assert_se(cunescape("\\073", 0, &unescaped
) >= 0);
758 assert_se(streq_ptr(unescaped
, ";"));
761 static void test_foreach_word(void) {
762 const char *word
, *state
;
765 const char test
[] = "test abc d\te f ";
766 const char * const expected
[] = {
776 FOREACH_WORD(word
, l
, test
, state
)
777 assert_se(strneq(expected
[i
++], word
, l
));
780 static void check(const char *test
, char** expected
, bool trailing
) {
781 const char *word
, *state
;
785 printf("<<<%s>>>\n", test
);
786 FOREACH_WORD_QUOTED(word
, l
, test
, state
) {
787 _cleanup_free_
char *t
= NULL
;
789 assert_se(t
= strndup(word
, l
));
790 assert_se(strneq(expected
[i
++], word
, l
));
793 printf("<<<%s>>>\n", state
);
794 assert_se(expected
[i
] == NULL
);
795 assert_se(isempty(state
) == !trailing
);
798 static void test_foreach_word_quoted(void) {
799 check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
823 static void test_memdup_multiply(void) {
824 int org
[] = {1, 2, 3};
827 dup
= (int*)memdup_multiply(org
, sizeof(int), 3);
830 assert_se(dup
[0] == 1);
831 assert_se(dup
[1] == 2);
832 assert_se(dup
[2] == 3);
836 static void test_hostname_is_valid(void) {
837 assert_se(hostname_is_valid("foobar"));
838 assert_se(hostname_is_valid("foobar.com"));
839 assert_se(!hostname_is_valid("fööbar"));
840 assert_se(!hostname_is_valid(""));
841 assert_se(!hostname_is_valid("."));
842 assert_se(!hostname_is_valid(".."));
843 assert_se(!hostname_is_valid("foobar."));
844 assert_se(!hostname_is_valid(".foobar"));
845 assert_se(!hostname_is_valid("foo..bar"));
846 assert_se(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
849 static void test_read_hostname_config(void) {
850 char path
[] = "/tmp/hostname.XXXXXX";
854 fd
= mkostemp_safe(path
, O_RDWR
|O_CLOEXEC
);
858 /* simple hostname */
859 write_string_file(path
, "foo", WRITE_STRING_FILE_CREATE
);
860 assert_se(read_hostname_config(path
, &hostname
) == 0);
861 assert_se(streq(hostname
, "foo"));
866 write_string_file(path
, "# comment\nfoo", WRITE_STRING_FILE_CREATE
);
867 assert_se(read_hostname_config(path
, &hostname
) == 0);
869 assert_se(streq(hostname
, "foo"));
873 /* with comment and extra whitespace */
874 write_string_file(path
, "# comment\n\n foo ", WRITE_STRING_FILE_CREATE
);
875 assert_se(read_hostname_config(path
, &hostname
) == 0);
877 assert_se(streq(hostname
, "foo"));
882 write_string_file(path
, "!foo/bar.com", WRITE_STRING_FILE_CREATE
);
883 assert_se(read_hostname_config(path
, &hostname
) == 0);
885 assert_se(streq(hostname
, "foobar.com"));
890 hostname
= (char*) 0x1234;
891 write_string_file(path
, "# nothing here\n", WRITE_STRING_FILE_CREATE
);
892 assert_se(read_hostname_config(path
, &hostname
) == -ENOENT
);
893 assert_se(hostname
== (char*) 0x1234); /* does not touch argument on error */
895 /* nonexisting file */
896 assert_se(read_hostname_config("/non/existing", &hostname
) == -ENOENT
);
897 assert_se(hostname
== (char*) 0x1234); /* does not touch argument on error */
902 static void test_u64log2(void) {
903 assert_se(u64log2(0) == 0);
904 assert_se(u64log2(8) == 3);
905 assert_se(u64log2(9) == 3);
906 assert_se(u64log2(15) == 3);
907 assert_se(u64log2(16) == 4);
908 assert_se(u64log2(1024*1024) == 20);
909 assert_se(u64log2(1024*1024+5) == 20);
912 static void test_protect_errno(void) {
918 assert_se(errno
== 12);
921 static void test_parse_size(void) {
924 assert_se(parse_size("111", 1024, &bytes
) == 0);
925 assert_se(bytes
== 111);
927 assert_se(parse_size("111.4", 1024, &bytes
) == 0);
928 assert_se(bytes
== 111);
930 assert_se(parse_size(" 112 B", 1024, &bytes
) == 0);
931 assert_se(bytes
== 112);
933 assert_se(parse_size(" 112.6 B", 1024, &bytes
) == 0);
934 assert_se(bytes
== 112);
936 assert_se(parse_size("3.5 K", 1024, &bytes
) == 0);
937 assert_se(bytes
== 3*1024 + 512);
939 assert_se(parse_size("3. K", 1024, &bytes
) == 0);
940 assert_se(bytes
== 3*1024);
942 assert_se(parse_size("3.0 K", 1024, &bytes
) == 0);
943 assert_se(bytes
== 3*1024);
945 assert_se(parse_size("3. 0 K", 1024, &bytes
) == -EINVAL
);
947 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes
) == 0);
948 assert_se(bytes
== 4*1024*1024 + 11 * 1024 + 512);
950 assert_se(parse_size("3B3.5G", 1024, &bytes
) == -EINVAL
);
952 assert_se(parse_size("3.5G3B", 1024, &bytes
) == 0);
953 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
955 assert_se(parse_size("3.5G 4B", 1024, &bytes
) == 0);
956 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
958 assert_se(parse_size("3B3G4T", 1024, &bytes
) == -EINVAL
);
960 assert_se(parse_size("4T3G3B", 1024, &bytes
) == 0);
961 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
963 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes
) == 0);
964 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
966 assert_se(parse_size("12P", 1024, &bytes
) == 0);
967 assert_se(bytes
== 12ULL * 1024*1024*1024*1024*1024);
969 assert_se(parse_size("12P12P", 1024, &bytes
) == -EINVAL
);
971 assert_se(parse_size("3E 2P", 1024, &bytes
) == 0);
972 assert_se(bytes
== (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
974 assert_se(parse_size("12X", 1024, &bytes
) == -EINVAL
);
976 assert_se(parse_size("12.5X", 1024, &bytes
) == -EINVAL
);
978 assert_se(parse_size("12.5e3", 1024, &bytes
) == -EINVAL
);
980 assert_se(parse_size("1024E", 1024, &bytes
) == -ERANGE
);
981 assert_se(parse_size("-1", 1024, &bytes
) == -ERANGE
);
982 assert_se(parse_size("-1024E", 1024, &bytes
) == -ERANGE
);
984 assert_se(parse_size("-1024P", 1024, &bytes
) == -ERANGE
);
986 assert_se(parse_size("-10B 20K", 1024, &bytes
) == -ERANGE
);
989 static void test_config_parse_iec_off(void) {
991 assert_se(config_parse_iec_off(NULL
, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset
, NULL
) == 0);
992 assert_se(offset
== 4 * 1024 * 1024);
994 assert_se(config_parse_iec_off(NULL
, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset
, NULL
) == 0);
997 static void test_strextend(void) {
998 _cleanup_free_
char *str
= strdup("0123");
999 strextend(&str
, "456", "78", "9", NULL
);
1000 assert_se(streq(str
, "0123456789"));
1003 static void test_strrep(void) {
1004 _cleanup_free_
char *one
, *three
, *zero
;
1005 one
= strrep("waldo", 1);
1006 three
= strrep("waldo", 3);
1007 zero
= strrep("waldo", 0);
1009 assert_se(streq(one
, "waldo"));
1010 assert_se(streq(three
, "waldowaldowaldo"));
1011 assert_se(streq(zero
, ""));
1014 static void test_split_pair(void) {
1015 _cleanup_free_
char *a
= NULL
, *b
= NULL
;
1017 assert_se(split_pair("", "", &a
, &b
) == -EINVAL
);
1018 assert_se(split_pair("foo=bar", "", &a
, &b
) == -EINVAL
);
1019 assert_se(split_pair("", "=", &a
, &b
) == -EINVAL
);
1020 assert_se(split_pair("foo=bar", "=", &a
, &b
) >= 0);
1021 assert_se(streq(a
, "foo"));
1022 assert_se(streq(b
, "bar"));
1025 assert_se(split_pair("==", "==", &a
, &b
) >= 0);
1026 assert_se(streq(a
, ""));
1027 assert_se(streq(b
, ""));
1031 assert_se(split_pair("===", "==", &a
, &b
) >= 0);
1032 assert_se(streq(a
, ""));
1033 assert_se(streq(b
, "="));
1036 static void test_fstab_node_to_udev_node(void) {
1039 n
= fstab_node_to_udev_node("LABEL=applé/jack");
1041 assert_se(streq(n
, "/dev/disk/by-label/applé\\x2fjack"));
1044 n
= fstab_node_to_udev_node("PARTLABEL=pinkié pie");
1046 assert_se(streq(n
, "/dev/disk/by-partlabel/pinkié\\x20pie"));
1049 n
= fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1051 assert_se(streq(n
, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1054 n
= fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1056 assert_se(streq(n
, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1059 n
= fstab_node_to_udev_node("PONIES=awesome");
1061 assert_se(streq(n
, "PONIES=awesome"));
1064 n
= fstab_node_to_udev_node("/dev/xda1");
1066 assert_se(streq(n
, "/dev/xda1"));
1070 static void test_get_files_in_directory(void) {
1071 _cleanup_strv_free_
char **l
= NULL
, **t
= NULL
;
1073 assert_se(get_files_in_directory("/tmp", &l
) >= 0);
1074 assert_se(get_files_in_directory(".", &t
) >= 0);
1075 assert_se(get_files_in_directory(".", NULL
) >= 0);
1078 static void test_in_set(void) {
1079 assert_se(IN_SET(1, 1));
1080 assert_se(IN_SET(1, 1, 2, 3, 4));
1081 assert_se(IN_SET(2, 1, 2, 3, 4));
1082 assert_se(IN_SET(3, 1, 2, 3, 4));
1083 assert_se(IN_SET(4, 1, 2, 3, 4));
1084 assert_se(!IN_SET(0, 1));
1085 assert_se(!IN_SET(0, 1, 2, 3, 4));
1088 static void test_writing_tmpfile(void) {
1089 char name
[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
1090 _cleanup_free_
char *contents
= NULL
;
1093 struct iovec iov
[3];
1095 IOVEC_SET_STRING(iov
[0], "abc\n");
1096 IOVEC_SET_STRING(iov
[1], ALPHANUMERICAL
"\n");
1097 IOVEC_SET_STRING(iov
[2], "");
1099 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1100 printf("tmpfile: %s", name
);
1102 r
= writev(fd
, iov
, 3);
1105 r
= read_full_file(name
, &contents
, &size
);
1107 printf("contents: %s", contents
);
1108 assert_se(streq(contents
, "abc\n" ALPHANUMERICAL
"\n"));
1113 static void test_hexdump(void) {
1117 hexdump(stdout
, NULL
, 0);
1118 hexdump(stdout
, "", 0);
1119 hexdump(stdout
, "", 1);
1120 hexdump(stdout
, "x", 1);
1121 hexdump(stdout
, "x", 2);
1122 hexdump(stdout
, "foobar", 7);
1123 hexdump(stdout
, "f\nobar", 7);
1124 hexdump(stdout
, "xxxxxxxxxxxxxxxxxxxxyz", 23);
1126 for (i
= 0; i
< ELEMENTSOF(data
); i
++)
1129 hexdump(stdout
, data
, sizeof(data
));
1132 static void test_log2i(void) {
1133 assert_se(log2i(1) == 0);
1134 assert_se(log2i(2) == 1);
1135 assert_se(log2i(3) == 1);
1136 assert_se(log2i(4) == 2);
1137 assert_se(log2i(32) == 5);
1138 assert_se(log2i(33) == 5);
1139 assert_se(log2i(63) == 5);
1140 assert_se(log2i(INT_MAX
) == sizeof(int)*8-2);
1143 static void test_foreach_string(void) {
1144 const char * const t
[] = {
1153 FOREACH_STRING(x
, "foo", "bar", "waldo")
1154 assert_se(streq_ptr(t
[i
++], x
));
1158 FOREACH_STRING(x
, "zzz")
1159 assert_se(streq(x
, "zzz"));
1162 static void test_filename_is_valid(void) {
1163 char foo
[FILENAME_MAX
+2];
1166 assert_se(!filename_is_valid(""));
1167 assert_se(!filename_is_valid("/bar/foo"));
1168 assert_se(!filename_is_valid("/"));
1169 assert_se(!filename_is_valid("."));
1170 assert_se(!filename_is_valid(".."));
1172 for (i
=0; i
<FILENAME_MAX
+1; i
++)
1174 foo
[FILENAME_MAX
+1] = '\0';
1176 assert_se(!filename_is_valid(foo
));
1178 assert_se(filename_is_valid("foo_bar-333"));
1179 assert_se(filename_is_valid("o.o"));
1182 static void test_string_has_cc(void) {
1183 assert_se(string_has_cc("abc\1", NULL
));
1184 assert_se(string_has_cc("abc\x7f", NULL
));
1185 assert_se(string_has_cc("abc\x7f", NULL
));
1186 assert_se(string_has_cc("abc\t\x7f", "\t"));
1187 assert_se(string_has_cc("abc\t\x7f", "\t"));
1188 assert_se(string_has_cc("\x7f", "\t"));
1189 assert_se(string_has_cc("\x7f", "\t\a"));
1191 assert_se(!string_has_cc("abc\t\t", "\t"));
1192 assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
1193 assert_se(!string_has_cc("a\ab\tc", "\t\a"));
1196 static void test_ascii_strlower(void) {
1197 char a
[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
1198 assert_se(streq(ascii_strlower(a
), "aabbcc jk ii od lkjjj kkd lk"));
1201 static void test_files_same(void) {
1202 _cleanup_close_
int fd
= -1;
1203 char name
[] = "/tmp/test-files_same.XXXXXX";
1204 char name_alias
[] = "/tmp/test-files_same.alias";
1206 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1208 assert_se(symlink(name
, name_alias
) >= 0);
1210 assert_se(files_same(name
, name
));
1211 assert_se(files_same(name
, name_alias
));
1217 static void test_is_valid_documentation_url(void) {
1218 assert_se(documentation_url_is_valid("http://www.freedesktop.org/wiki/Software/systemd"));
1219 assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
1220 assert_se(documentation_url_is_valid("file:/foo/foo"));
1221 assert_se(documentation_url_is_valid("man:systemd.special(7)"));
1222 assert_se(documentation_url_is_valid("info:bar"));
1224 assert_se(!documentation_url_is_valid("foo:"));
1225 assert_se(!documentation_url_is_valid("info:"));
1226 assert_se(!documentation_url_is_valid(""));
1229 static void test_file_in_same_dir(void) {
1232 t
= file_in_same_dir("/", "a");
1233 assert_se(streq(t
, "/a"));
1236 t
= file_in_same_dir("/", "/a");
1237 assert_se(streq(t
, "/a"));
1240 t
= file_in_same_dir("", "a");
1241 assert_se(streq(t
, "a"));
1244 t
= file_in_same_dir("a/", "a");
1245 assert_se(streq(t
, "a/a"));
1248 t
= file_in_same_dir("bar/foo", "bar");
1249 assert_se(streq(t
, "bar/bar"));
1253 static void test_endswith(void) {
1254 assert_se(endswith("foobar", "bar"));
1255 assert_se(endswith("foobar", ""));
1256 assert_se(endswith("foobar", "foobar"));
1257 assert_se(endswith("", ""));
1259 assert_se(!endswith("foobar", "foo"));
1260 assert_se(!endswith("foobar", "foobarfoofoo"));
1263 static void test_close_nointr(void) {
1264 char name
[] = "/tmp/test-test-close_nointr.XXXXXX";
1267 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1269 assert_se(close_nointr(fd
) >= 0);
1270 assert_se(close_nointr(fd
) < 0);
1276 static void test_unlink_noerrno(void) {
1277 char name
[] = "/tmp/test-close_nointr.XXXXXX";
1280 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1282 assert_se(close_nointr(fd
) >= 0);
1287 assert_se(unlink_noerrno(name
) >= 0);
1288 assert_se(errno
== -42);
1289 assert_se(unlink_noerrno(name
) < 0);
1290 assert_se(errno
== -42);
1294 static void test_readlink_and_make_absolute(void) {
1295 char tempdir
[] = "/tmp/test-readlink_and_make_absolute";
1296 char name
[] = "/tmp/test-readlink_and_make_absolute/original";
1297 char name2
[] = "test-readlink_and_make_absolute/original";
1298 char name_alias
[] = "/tmp/test-readlink_and_make_absolute-alias";
1301 assert_se(mkdir_safe(tempdir
, 0755, getuid(), getgid()) >= 0);
1302 assert_se(touch(name
) >= 0);
1304 assert_se(symlink(name
, name_alias
) >= 0);
1305 assert_se(readlink_and_make_absolute(name_alias
, &r
) >= 0);
1306 assert_se(streq(r
, name
));
1308 assert_se(unlink(name_alias
) >= 0);
1310 assert_se(chdir(tempdir
) >= 0);
1311 assert_se(symlink(name2
, name_alias
) >= 0);
1312 assert_se(readlink_and_make_absolute(name_alias
, &r
) >= 0);
1313 assert_se(streq(r
, name
));
1315 assert_se(unlink(name_alias
) >= 0);
1317 assert_se(rm_rf(tempdir
, REMOVE_ROOT
|REMOVE_PHYSICAL
) >= 0);
1320 static void test_ignore_signals(void) {
1321 assert_se(ignore_signals(SIGINT
, -1) >= 0);
1322 assert_se(kill(getpid(), SIGINT
) >= 0);
1323 assert_se(ignore_signals(SIGUSR1
, SIGUSR2
, SIGTERM
, SIGPIPE
, -1) >= 0);
1324 assert_se(kill(getpid(), SIGUSR1
) >= 0);
1325 assert_se(kill(getpid(), SIGUSR2
) >= 0);
1326 assert_se(kill(getpid(), SIGTERM
) >= 0);
1327 assert_se(kill(getpid(), SIGPIPE
) >= 0);
1328 assert_se(default_signals(SIGINT
, SIGUSR1
, SIGUSR2
, SIGTERM
, SIGPIPE
, -1) >= 0);
1331 static void test_strshorten(void) {
1332 char s
[] = "foobar";
1334 assert_se(strlen(strshorten(s
, 6)) == 6);
1335 assert_se(strlen(strshorten(s
, 12)) == 6);
1336 assert_se(strlen(strshorten(s
, 2)) == 2);
1337 assert_se(strlen(strshorten(s
, 0)) == 0);
1340 static void test_strjoina(void) {
1343 actual
= strjoina("", "foo", "bar");
1344 assert_se(streq(actual
, "foobar"));
1346 actual
= strjoina("foo", "bar", "baz");
1347 assert_se(streq(actual
, "foobarbaz"));
1349 actual
= strjoina("foo", "", "bar", "baz");
1350 assert_se(streq(actual
, "foobarbaz"));
1352 actual
= strjoina("foo");
1353 assert_se(streq(actual
, "foo"));
1355 actual
= strjoina(NULL
);
1356 assert_se(streq(actual
, ""));
1358 actual
= strjoina(NULL
, "foo");
1359 assert_se(streq(actual
, ""));
1361 actual
= strjoina("foo", NULL
, "bar");
1362 assert_se(streq(actual
, "foo"));
1365 static void test_is_symlink(void) {
1366 char name
[] = "/tmp/test-is_symlink.XXXXXX";
1367 char name_link
[] = "/tmp/test-is_symlink.link";
1368 _cleanup_close_
int fd
= -1;
1370 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1372 assert_se(symlink(name
, name_link
) >= 0);
1374 assert_se(is_symlink(name
) == 0);
1375 assert_se(is_symlink(name_link
) == 1);
1376 assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
1383 static void test_search_and_fopen(void) {
1384 const char *dirs
[] = {"/tmp/foo/bar", "/tmp", NULL
};
1385 char name
[] = "/tmp/test-search_and_fopen.XXXXXX";
1390 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1394 r
= search_and_fopen(basename(name
), "r", NULL
, dirs
, &f
);
1398 r
= search_and_fopen(name
, "r", NULL
, dirs
, &f
);
1402 r
= search_and_fopen(basename(name
), "r", "/", dirs
, &f
);
1406 r
= search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL
, dirs
, &f
);
1408 r
= search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL
, dirs
, &f
);
1414 r
= search_and_fopen(basename(name
), "r", NULL
, dirs
, &f
);
1419 static void test_search_and_fopen_nulstr(void) {
1420 const char dirs
[] = "/tmp/foo/bar\0/tmp\0";
1421 char name
[] = "/tmp/test-search_and_fopen.XXXXXX";
1426 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1430 r
= search_and_fopen_nulstr(basename(name
), "r", NULL
, dirs
, &f
);
1434 r
= search_and_fopen_nulstr(name
, "r", NULL
, dirs
, &f
);
1438 r
= search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL
, dirs
, &f
);
1440 r
= search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL
, dirs
, &f
);
1446 r
= search_and_fopen_nulstr(basename(name
), "r", NULL
, dirs
, &f
);
1450 static void test_glob_exists(void) {
1451 char name
[] = "/tmp/test-glob_exists.XXXXXX";
1455 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1459 r
= glob_exists("/tmp/test-glob_exists*");
1464 r
= glob_exists("/tmp/test-glob_exists*");
1468 static void test_execute_directory(void) {
1469 char template_lo
[] = "/tmp/test-readlink_and_make_absolute-lo.XXXXXXX";
1470 char template_hi
[] = "/tmp/test-readlink_and_make_absolute-hi.XXXXXXX";
1471 const char * dirs
[] = {template_hi
, template_lo
, NULL
};
1472 const char *name
, *name2
, *name3
, *overridden
, *override
, *masked
, *mask
;
1474 assert_se(mkdtemp(template_lo
));
1475 assert_se(mkdtemp(template_hi
));
1477 name
= strjoina(template_lo
, "/script");
1478 name2
= strjoina(template_hi
, "/script2");
1479 name3
= strjoina(template_lo
, "/useless");
1480 overridden
= strjoina(template_lo
, "/overridden");
1481 override
= strjoina(template_hi
, "/overridden");
1482 masked
= strjoina(template_lo
, "/masked");
1483 mask
= strjoina(template_hi
, "/masked");
1485 assert_se(write_string_file(name
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works", WRITE_STRING_FILE_CREATE
) == 0);
1486 assert_se(write_string_file(name2
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2", WRITE_STRING_FILE_CREATE
) == 0);
1487 assert_se(write_string_file(overridden
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE
) == 0);
1488 assert_se(write_string_file(override
, "#!/bin/sh\necho 'Executing '$0", WRITE_STRING_FILE_CREATE
) == 0);
1489 assert_se(write_string_file(masked
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE
) == 0);
1490 assert_se(symlink("/dev/null", mask
) == 0);
1491 assert_se(chmod(name
, 0755) == 0);
1492 assert_se(chmod(name2
, 0755) == 0);
1493 assert_se(chmod(overridden
, 0755) == 0);
1494 assert_se(chmod(override
, 0755) == 0);
1495 assert_se(chmod(masked
, 0755) == 0);
1496 assert_se(touch(name3
) >= 0);
1498 execute_directories(dirs
, DEFAULT_TIMEOUT_USEC
, NULL
);
1500 assert_se(chdir(template_lo
) == 0);
1501 assert_se(access("it_works", F_OK
) >= 0);
1502 assert_se(access("failed", F_OK
) < 0);
1504 assert_se(chdir(template_hi
) == 0);
1505 assert_se(access("it_works2", F_OK
) >= 0);
1506 assert_se(access("failed", F_OK
) < 0);
1508 (void) rm_rf(template_lo
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
1509 (void) rm_rf(template_hi
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
1512 static void test_unquote_first_word(void) {
1513 const char *p
, *original
;
1516 p
= original
= "foobar waldo";
1517 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1518 assert_se(streq(t
, "foobar"));
1520 assert_se(p
== original
+ 7);
1522 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1523 assert_se(streq(t
, "waldo"));
1525 assert_se(p
== original
+ 12);
1527 assert_se(unquote_first_word(&p
, &t
, 0) == 0);
1529 assert_se(p
== original
+ 12);
1531 p
= original
= "\"foobar\" \'waldo\'";
1532 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1533 assert_se(streq(t
, "foobar"));
1535 assert_se(p
== original
+ 9);
1537 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1538 assert_se(streq(t
, "waldo"));
1540 assert_se(p
== original
+ 16);
1542 assert_se(unquote_first_word(&p
, &t
, 0) == 0);
1544 assert_se(p
== original
+ 16);
1546 p
= original
= "\"";
1547 assert_se(unquote_first_word(&p
, &t
, 0) == -EINVAL
);
1548 assert_se(p
== original
+ 1);
1550 p
= original
= "\'";
1551 assert_se(unquote_first_word(&p
, &t
, 0) == -EINVAL
);
1552 assert_se(p
== original
+ 1);
1554 p
= original
= "\'fooo";
1555 assert_se(unquote_first_word(&p
, &t
, 0) == -EINVAL
);
1556 assert_se(p
== original
+ 5);
1558 p
= original
= "\'fooo";
1559 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_RELAX
) > 0);
1560 assert_se(streq(t
, "fooo"));
1562 assert_se(p
== original
+ 5);
1564 p
= original
= "yay\'foo\'bar";
1565 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1566 assert_se(streq(t
, "yayfoobar"));
1568 assert_se(p
== original
+ 11);
1570 p
= original
= " foobar ";
1571 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1572 assert_se(streq(t
, "foobar"));
1574 assert_se(p
== original
+ 12);
1576 p
= original
= " foo\\ba\\x6ar ";
1577 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
) > 0);
1578 assert_se(streq(t
, "foo\ba\x6ar"));
1580 assert_se(p
== original
+ 13);
1582 p
= original
= " foo\\ba\\x6ar ";
1583 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1584 assert_se(streq(t
, "foobax6ar"));
1586 assert_se(p
== original
+ 13);
1588 p
= original
= " f\\u00f6o \"pi\\U0001F4A9le\" ";
1589 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
) > 0);
1590 assert_se(streq(t
, "föo"));
1592 assert_se(p
== original
+ 13);
1594 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
) > 0);
1595 assert_se(streq(t
, "pi\360\237\222\251le"));
1597 assert_se(p
== original
+ 32);
1599 p
= original
= "fooo\\";
1600 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_RELAX
) > 0);
1601 assert_se(streq(t
, "fooo"));
1603 assert_se(p
== original
+ 5);
1605 p
= original
= "fooo\\";
1606 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE_RELAX
) > 0);
1607 assert_se(streq(t
, "fooo\\"));
1609 assert_se(p
== original
+ 5);
1611 p
= original
= "fooo\\";
1612 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE_RELAX
|UNQUOTE_RELAX
) > 0);
1613 assert_se(streq(t
, "fooo\\"));
1615 assert_se(p
== original
+ 5);
1617 p
= original
= "fooo\\";
1618 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
|UNQUOTE_CUNESCAPE_RELAX
) > 0);
1619 assert_se(streq(t
, "fooo\\"));
1621 assert_se(p
== original
+ 5);
1623 p
= original
= "\"foo\\";
1624 assert_se(unquote_first_word(&p
, &t
, 0) == -EINVAL
);
1625 assert_se(p
== original
+ 5);
1627 p
= original
= "\"foo\\";
1628 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_RELAX
) > 0);
1629 assert_se(streq(t
, "foo"));
1631 assert_se(p
== original
+ 5);
1633 p
= original
= "\"foo\\";
1634 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE_RELAX
) == -EINVAL
);
1635 assert_se(p
== original
+ 5);
1637 p
= original
= "\"foo\\";
1638 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE_RELAX
|UNQUOTE_RELAX
) > 0);
1639 assert_se(streq(t
, "foo\\"));
1641 assert_se(p
== original
+ 5);
1643 p
= original
= "\"foo\\";
1644 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
|UNQUOTE_CUNESCAPE_RELAX
|UNQUOTE_RELAX
) > 0);
1645 assert_se(streq(t
, "foo\\"));
1647 assert_se(p
== original
+ 5);
1649 p
= original
= "fooo\\ bar quux";
1650 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_RELAX
) > 0);
1651 assert_se(streq(t
, "fooo bar"));
1653 assert_se(p
== original
+ 10);
1655 p
= original
= "fooo\\ bar quux";
1656 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE_RELAX
) > 0);
1657 assert_se(streq(t
, "fooo bar"));
1659 assert_se(p
== original
+ 10);
1661 p
= original
= "fooo\\ bar quux";
1662 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE_RELAX
|UNQUOTE_RELAX
) > 0);
1663 assert_se(streq(t
, "fooo bar"));
1665 assert_se(p
== original
+ 10);
1667 p
= original
= "fooo\\ bar quux";
1668 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
) == -EINVAL
);
1669 assert_se(p
== original
+ 5);
1671 p
= original
= "fooo\\ bar quux";
1672 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
|UNQUOTE_CUNESCAPE_RELAX
) > 0);
1673 assert_se(streq(t
, "fooo\\ bar"));
1675 assert_se(p
== original
+ 10);
1677 p
= original
= "\\w+@\\K[\\d.]+";
1678 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
) == -EINVAL
);
1679 assert_se(p
== original
+ 1);
1681 p
= original
= "\\w+@\\K[\\d.]+";
1682 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
|UNQUOTE_CUNESCAPE_RELAX
) > 0);
1683 assert_se(streq(t
, "\\w+@\\K[\\d.]+"));
1685 assert_se(p
== original
+ 12);
1687 p
= original
= "\\w+\\b";
1688 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
|UNQUOTE_CUNESCAPE_RELAX
) > 0);
1689 assert_se(streq(t
, "\\w+\b"));
1691 assert_se(p
== original
+ 5);
1694 static void test_unquote_first_word_and_warn(void) {
1695 const char *p
, *original
;
1698 p
= original
= "foobar waldo";
1699 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) > 0);
1700 assert_se(streq(t
, "foobar"));
1702 assert_se(p
== original
+ 7);
1704 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) > 0);
1705 assert_se(streq(t
, "waldo"));
1707 assert_se(p
== original
+ 12);
1709 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) == 0);
1711 assert_se(p
== original
+ 12);
1713 p
= original
= "\"foobar\" \'waldo\'";
1714 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) > 0);
1715 assert_se(streq(t
, "foobar"));
1717 assert_se(p
== original
+ 9);
1719 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) > 0);
1720 assert_se(streq(t
, "waldo"));
1722 assert_se(p
== original
+ 16);
1724 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) == 0);
1726 assert_se(p
== original
+ 16);
1728 p
= original
= "\"";
1729 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) == -EINVAL
);
1730 assert_se(p
== original
+ 1);
1732 p
= original
= "\'";
1733 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) == -EINVAL
);
1734 assert_se(p
== original
+ 1);
1736 p
= original
= "\'fooo";
1737 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) == -EINVAL
);
1738 assert_se(p
== original
+ 5);
1740 p
= original
= "\'fooo";
1741 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_RELAX
, NULL
, "fake", 1, original
) > 0);
1742 assert_se(streq(t
, "fooo"));
1744 assert_se(p
== original
+ 5);
1746 p
= original
= " foo\\ba\\x6ar ";
1747 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1748 assert_se(streq(t
, "foo\ba\x6ar"));
1750 assert_se(p
== original
+ 13);
1752 p
= original
= " foo\\ba\\x6ar ";
1753 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) > 0);
1754 assert_se(streq(t
, "foobax6ar"));
1756 assert_se(p
== original
+ 13);
1758 p
= original
= " f\\u00f6o \"pi\\U0001F4A9le\" ";
1759 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1760 assert_se(streq(t
, "föo"));
1762 assert_se(p
== original
+ 13);
1764 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1765 assert_se(streq(t
, "pi\360\237\222\251le"));
1767 assert_se(p
== original
+ 32);
1769 p
= original
= "fooo\\";
1770 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_RELAX
, NULL
, "fake", 1, original
) > 0);
1771 assert_se(streq(t
, "fooo"));
1773 assert_se(p
== original
+ 5);
1775 p
= original
= "fooo\\";
1776 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) > 0);
1777 assert_se(streq(t
, "fooo\\"));
1779 assert_se(p
== original
+ 5);
1781 p
= original
= "fooo\\";
1782 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1783 assert_se(streq(t
, "fooo\\"));
1785 assert_se(p
== original
+ 5);
1787 p
= original
= "\"foo\\";
1788 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) == -EINVAL
);
1789 assert_se(p
== original
+ 5);
1791 p
= original
= "\"foo\\";
1792 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_RELAX
, NULL
, "fake", 1, original
) > 0);
1793 assert_se(streq(t
, "foo"));
1795 assert_se(p
== original
+ 5);
1797 p
= original
= "\"foo\\";
1798 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
, NULL
, "fake", 1, original
) == -EINVAL
);
1799 assert_se(p
== original
+ 5);
1801 p
= original
= "\"foo\\";
1802 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
|UNQUOTE_RELAX
, NULL
, "fake", 1, original
) > 0);
1803 assert_se(streq(t
, "foo"));
1805 assert_se(p
== original
+ 5);
1807 p
= original
= "fooo\\ bar quux";
1808 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_RELAX
, NULL
, "fake", 1, original
) > 0);
1809 assert_se(streq(t
, "fooo bar"));
1811 assert_se(p
== original
+ 10);
1813 p
= original
= "fooo\\ bar quux";
1814 assert_se(unquote_first_word_and_warn(&p
, &t
, 0, NULL
, "fake", 1, original
) > 0);
1815 assert_se(streq(t
, "fooo bar"));
1817 assert_se(p
== original
+ 10);
1819 p
= original
= "fooo\\ bar quux";
1820 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1821 assert_se(streq(t
, "fooo\\ bar"));
1823 assert_se(p
== original
+ 10);
1825 p
= original
= "\\w+@\\K[\\d.]+";
1826 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1827 assert_se(streq(t
, "\\w+@\\K[\\d.]+"));
1829 assert_se(p
== original
+ 12);
1831 p
= original
= "\\w+\\b";
1832 assert_se(unquote_first_word_and_warn(&p
, &t
, UNQUOTE_CUNESCAPE
, NULL
, "fake", 1, original
) > 0);
1833 assert_se(streq(t
, "\\w+\b"));
1835 assert_se(p
== original
+ 5);
1838 static void test_unquote_many_words(void) {
1839 const char *p
, *original
;
1842 p
= original
= "foobar waldi piep";
1843 assert_se(unquote_many_words(&p
, 0, &a
, &b
, &c
, NULL
) == 3);
1844 assert_se(p
== original
+ 17);
1845 assert_se(streq_ptr(a
, "foobar"));
1846 assert_se(streq_ptr(b
, "waldi"));
1847 assert_se(streq_ptr(c
, "piep"));
1852 p
= original
= "'foobar' wa\"ld\"i ";
1853 assert_se(unquote_many_words(&p
, 0, &a
, &b
, &c
, NULL
) == 2);
1854 assert_se(p
== original
+ 19);
1855 assert_se(streq_ptr(a
, "foobar"));
1856 assert_se(streq_ptr(b
, "waldi"));
1857 assert_se(streq_ptr(c
, NULL
));
1862 assert_se(unquote_many_words(&p
, 0, &a
, &b
, &c
, NULL
) == 0);
1863 assert_se(p
== original
);
1864 assert_se(streq_ptr(a
, NULL
));
1865 assert_se(streq_ptr(b
, NULL
));
1866 assert_se(streq_ptr(c
, NULL
));
1869 assert_se(unquote_many_words(&p
, 0, &a
, &b
, &c
, NULL
) == 0);
1870 assert_se(p
== original
+2);
1871 assert_se(streq_ptr(a
, NULL
));
1872 assert_se(streq_ptr(b
, NULL
));
1873 assert_se(streq_ptr(c
, NULL
));
1875 p
= original
= "foobar";
1876 assert_se(unquote_many_words(&p
, 0, NULL
) == 0);
1877 assert_se(p
== original
);
1879 p
= original
= "foobar waldi";
1880 assert_se(unquote_many_words(&p
, 0, &a
, NULL
) == 1);
1881 assert_se(p
== original
+7);
1882 assert_se(streq_ptr(a
, "foobar"));
1885 p
= original
= " foobar ";
1886 assert_se(unquote_many_words(&p
, 0, &a
, NULL
) == 1);
1887 assert_se(p
== original
+15);
1888 assert_se(streq_ptr(a
, "foobar"));
1892 static int parse_item(const char *key
, const char *value
) {
1895 log_info("kernel cmdline option <%s> = <%s>", key
, strna(value
));
1899 static void test_parse_proc_cmdline(void) {
1900 assert_se(parse_proc_cmdline(parse_item
) >= 0);
1903 static void test_raw_clone(void) {
1904 pid_t parent
, pid
, pid2
;
1907 log_info("before clone: getpid()→"PID_FMT
, parent
);
1908 assert_se(raw_getpid() == parent
);
1910 pid
= raw_clone(0, NULL
);
1911 assert_se(pid
>= 0);
1913 pid2
= raw_getpid();
1914 log_info("raw_clone: "PID_FMT
" getpid()→"PID_FMT
" raw_getpid()→"PID_FMT
,
1915 pid
, getpid(), pid2
);
1917 assert_se(pid2
!= parent
);
1918 _exit(EXIT_SUCCESS
);
1922 assert_se(pid2
== parent
);
1923 waitpid(pid
, &status
, __WCLONE
);
1924 assert_se(WIFEXITED(status
) && WEXITSTATUS(status
) == EXIT_SUCCESS
);
1928 static void test_same_fd(void) {
1929 _cleanup_close_pair_
int p
[2] = { -1, -1 };
1930 _cleanup_close_
int a
= -1, b
= -1, c
= -1;
1932 assert_se(pipe2(p
, O_CLOEXEC
) >= 0);
1933 assert_se((a
= dup(p
[0])) >= 0);
1934 assert_se((b
= open("/dev/null", O_RDONLY
|O_CLOEXEC
)) >= 0);
1935 assert_se((c
= dup(a
)) >= 0);
1937 assert_se(same_fd(p
[0], p
[0]) > 0);
1938 assert_se(same_fd(p
[1], p
[1]) > 0);
1939 assert_se(same_fd(a
, a
) > 0);
1940 assert_se(same_fd(b
, b
) > 0);
1942 assert_se(same_fd(a
, p
[0]) > 0);
1943 assert_se(same_fd(p
[0], a
) > 0);
1944 assert_se(same_fd(c
, p
[0]) > 0);
1945 assert_se(same_fd(p
[0], c
) > 0);
1946 assert_se(same_fd(a
, c
) > 0);
1947 assert_se(same_fd(c
, a
) > 0);
1949 assert_se(same_fd(p
[0], p
[1]) == 0);
1950 assert_se(same_fd(p
[1], p
[0]) == 0);
1951 assert_se(same_fd(p
[0], b
) == 0);
1952 assert_se(same_fd(b
, p
[0]) == 0);
1953 assert_se(same_fd(p
[1], a
) == 0);
1954 assert_se(same_fd(a
, p
[1]) == 0);
1955 assert_se(same_fd(p
[1], b
) == 0);
1956 assert_se(same_fd(b
, p
[1]) == 0);
1958 assert_se(same_fd(a
, b
) == 0);
1959 assert_se(same_fd(b
, a
) == 0);
1962 static void test_uid_ptr(void) {
1964 assert_se(UID_TO_PTR(0) != NULL
);
1965 assert_se(UID_TO_PTR(1000) != NULL
);
1967 assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
1968 assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
1971 static void test_sparse_write_one(int fd
, const char *buffer
, size_t n
) {
1974 assert_se(lseek(fd
, 0, SEEK_SET
) == 0);
1975 assert_se(ftruncate(fd
, 0) >= 0);
1976 assert_se(sparse_write(fd
, buffer
, n
, 4) == (ssize_t
) n
);
1978 assert_se(lseek(fd
, 0, SEEK_CUR
) == (off_t
) n
);
1979 assert_se(ftruncate(fd
, n
) >= 0);
1981 assert_se(lseek(fd
, 0, SEEK_SET
) == 0);
1982 assert_se(read(fd
, check
, n
) == (ssize_t
) n
);
1984 assert_se(memcmp(buffer
, check
, n
) == 0);
1987 static void test_sparse_write(void) {
1988 const char test_a
[] = "test";
1989 const char test_b
[] = "\0\0\0\0test\0\0\0\0";
1990 const char test_c
[] = "\0\0test\0\0\0\0";
1991 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";
1992 const char test_e
[] = "test\0\0\0\0test";
1993 _cleanup_close_
int fd
= -1;
1994 char fn
[] = "/tmp/sparseXXXXXX";
1996 fd
= mkostemp(fn
, O_CLOEXEC
);
2000 test_sparse_write_one(fd
, test_a
, sizeof(test_a
));
2001 test_sparse_write_one(fd
, test_b
, sizeof(test_b
));
2002 test_sparse_write_one(fd
, test_c
, sizeof(test_c
));
2003 test_sparse_write_one(fd
, test_d
, sizeof(test_d
));
2004 test_sparse_write_one(fd
, test_e
, sizeof(test_e
));
2007 static void test_shell_maybe_quote_one(const char *s
, const char *expected
) {
2008 _cleanup_free_
char *r
;
2010 assert_se(r
= shell_maybe_quote(s
));
2011 assert_se(streq(r
, expected
));
2014 static void test_shell_maybe_quote(void) {
2016 test_shell_maybe_quote_one("", "");
2017 test_shell_maybe_quote_one("\\", "\"\\\\\"");
2018 test_shell_maybe_quote_one("\"", "\"\\\"\"");
2019 test_shell_maybe_quote_one("foobar", "foobar");
2020 test_shell_maybe_quote_one("foo bar", "\"foo bar\"");
2021 test_shell_maybe_quote_one("foo \"bar\" waldo", "\"foo \\\"bar\\\" waldo\"");
2022 test_shell_maybe_quote_one("foo$bar", "\"foo\\$bar\"");
2025 static void test_parse_mode(void) {
2028 assert_se(parse_mode("-1", &m
) < 0);
2029 assert_se(parse_mode("", &m
) < 0);
2030 assert_se(parse_mode("888", &m
) < 0);
2031 assert_se(parse_mode("77777", &m
) < 0);
2033 assert_se(parse_mode("544", &m
) >= 0 && m
== 0544);
2034 assert_se(parse_mode("777", &m
) >= 0 && m
== 0777);
2035 assert_se(parse_mode("7777", &m
) >= 0 && m
== 07777);
2036 assert_se(parse_mode("0", &m
) >= 0 && m
== 0);
2039 static void test_tempfn(void) {
2040 char *ret
= NULL
, *p
;
2042 assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL
, &ret
) >= 0);
2043 assert_se(streq_ptr(ret
, "/foo/bar/.#waldoXXXXXX"));
2046 assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret
) >= 0);
2047 assert_se(streq_ptr(ret
, "/foo/bar/.#[miau]waldoXXXXXX"));
2050 assert_se(tempfn_random("/foo/bar/waldo", NULL
, &ret
) >= 0);
2051 assert_se(p
= startswith(ret
, "/foo/bar/.#waldo"));
2052 assert_se(strlen(p
) == 16);
2053 assert_se(in_charset(p
, "0123456789abcdef"));
2056 assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret
) >= 0);
2057 assert_se(p
= startswith(ret
, "/foo/bar/.#[wuff]waldo"));
2058 assert_se(strlen(p
) == 16);
2059 assert_se(in_charset(p
, "0123456789abcdef"));
2062 assert_se(tempfn_random_child("/foo/bar/waldo", NULL
, &ret
) >= 0);
2063 assert_se(p
= startswith(ret
, "/foo/bar/waldo/.#"));
2064 assert_se(strlen(p
) == 16);
2065 assert_se(in_charset(p
, "0123456789abcdef"));
2068 assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret
) >= 0);
2069 assert_se(p
= startswith(ret
, "/foo/bar/waldo/.#[kikiriki]"));
2070 assert_se(strlen(p
) == 16);
2071 assert_se(in_charset(p
, "0123456789abcdef"));
2075 int main(int argc
, char *argv
[]) {
2076 log_parse_environment();
2080 test_align_power2();
2082 test_container_of();
2084 test_div_round_up();
2087 test_parse_boolean();
2094 test_delete_chars();
2098 test_base32hexchar();
2099 test_unbase32hexchar();
2101 test_unbase64char();
2107 test_base32hexmem();
2108 test_unbase32hexmem();
2113 test_foreach_word();
2114 test_foreach_word_quoted();
2115 test_memdup_multiply();
2116 test_hostname_is_valid();
2117 test_read_hostname_config();
2119 test_protect_errno();
2121 test_config_parse_iec_off();
2125 test_fstab_node_to_udev_node();
2126 test_get_files_in_directory();
2128 test_writing_tmpfile();
2131 test_foreach_string();
2132 test_filename_is_valid();
2133 test_string_has_cc();
2134 test_ascii_strlower();
2136 test_is_valid_documentation_url();
2137 test_file_in_same_dir();
2139 test_close_nointr();
2140 test_unlink_noerrno();
2141 test_readlink_and_make_absolute();
2142 test_ignore_signals();
2146 test_search_and_fopen();
2147 test_search_and_fopen_nulstr();
2149 test_execute_directory();
2150 test_unquote_first_word();
2151 test_unquote_first_word_and_warn();
2152 test_unquote_many_words();
2153 test_parse_proc_cmdline();
2157 test_sparse_write();
2158 test_shell_maybe_quote();