]>
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"
42 static void test_streq_ptr(void) {
43 assert_se(streq_ptr(NULL
, NULL
));
44 assert_se(!streq_ptr("abc", "cdef"));
47 static void test_align_power2(void) {
50 assert_se(ALIGN_POWER2(0) == 0);
51 assert_se(ALIGN_POWER2(1) == 1);
52 assert_se(ALIGN_POWER2(2) == 2);
53 assert_se(ALIGN_POWER2(3) == 4);
54 assert_se(ALIGN_POWER2(12) == 16);
56 assert_se(ALIGN_POWER2(ULONG_MAX
) == 0);
57 assert_se(ALIGN_POWER2(ULONG_MAX
- 1) == 0);
58 assert_se(ALIGN_POWER2(ULONG_MAX
- 1024) == 0);
59 assert_se(ALIGN_POWER2(ULONG_MAX
/ 2) == ULONG_MAX
/ 2 + 1);
60 assert_se(ALIGN_POWER2(ULONG_MAX
+ 1) == 0);
62 for (i
= 1; i
< 131071; ++i
) {
63 for (p2
= 1; p2
< i
; p2
<<= 1)
66 assert_se(ALIGN_POWER2(i
) == p2
);
69 for (i
= ULONG_MAX
- 1024; i
< ULONG_MAX
; ++i
) {
70 for (p2
= 1; p2
&& p2
< i
; p2
<<= 1)
73 assert_se(ALIGN_POWER2(i
) == p2
);
77 static void test_max(void) {
80 int b
[CONST_MAX(10, 100)];
82 .a
= CONST_MAX(10, 100),
86 assert_cc(sizeof(val1
.b
) == sizeof(int) * 100);
88 /* CONST_MAX returns (void) instead of a value if the passed arguments
89 * are not of the same type or not constant expressions. */
90 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
91 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
93 assert_se(val1
.a
== 100);
94 assert_se(MAX(++d
, 0) == 1);
97 assert_cc(MAXSIZE(char[3], uint16_t) == 3);
98 assert_cc(MAXSIZE(char[3], uint32_t) == 4);
99 assert_cc(MAXSIZE(char, long) == sizeof(long));
101 assert_se(MAX(-5, 5) == 5);
102 assert_se(MAX(5, 5) == 5);
103 assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
104 assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
105 assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
106 assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
107 assert_se(LESS_BY(8, 4) == 4);
108 assert_se(LESS_BY(8, 8) == 0);
109 assert_se(LESS_BY(4, 8) == 0);
110 assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
111 assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
112 assert_se(CLAMP(-5, 0, 1) == 0);
113 assert_se(CLAMP(5, 0, 1) == 1);
114 assert_se(CLAMP(5, -10, 1) == 1);
115 assert_se(CLAMP(5, -10, 10) == 5);
116 assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
119 static void test_container_of(void) {
125 } _packed_ myval
= { };
127 assert_cc(sizeof(myval
) == 17);
128 assert_se(container_of(&myval
.v1
, struct mytype
, v1
) == &myval
);
129 assert_se(container_of(&myval
.v2
, struct mytype
, v2
) == &myval
);
130 assert_se(container_of(&container_of(&myval
.v2
,
137 static void test_alloca(void) {
138 static const uint8_t zero
[997] = { };
141 t
= alloca_align(17, 512);
142 assert_se(!((uintptr_t)t
& 0xff));
145 t
= alloca0_align(997, 1024);
146 assert_se(!((uintptr_t)t
& 0x1ff));
147 assert_se(!memcmp(t
, zero
, 997));
150 static void test_div_round_up(void) {
154 assert_se(DIV_ROUND_UP(0, 8) == 0);
155 assert_se(DIV_ROUND_UP(1, 8) == 1);
156 assert_se(DIV_ROUND_UP(8, 8) == 1);
157 assert_se(DIV_ROUND_UP(12, 8) == 2);
158 assert_se(DIV_ROUND_UP(16, 8) == 2);
160 /* test multiple evaluation */
162 assert_se(DIV_ROUND_UP(div
++, 8) == 0 && div
== 1);
163 assert_se(DIV_ROUND_UP(++div
, 8) == 1 && div
== 2);
164 assert_se(DIV_ROUND_UP(8, div
++) == 4 && div
== 3);
165 assert_se(DIV_ROUND_UP(8, ++div
) == 2 && div
== 4);
167 /* overflow test with exact division */
168 assert_se(sizeof(0U) == 4);
169 assert_se(0xfffffffaU
% 10U == 0U);
170 assert_se(0xfffffffaU
/ 10U == 429496729U);
171 assert_se(DIV_ROUND_UP(0xfffffffaU
, 10U) == 429496729U);
172 assert_se((0xfffffffaU
+ 10U - 1U) / 10U == 0U);
173 assert_se(0xfffffffaU
/ 10U + !!(0xfffffffaU
% 10U) == 429496729U);
175 /* overflow test with rounded division */
176 assert_se(0xfffffffdU
% 10U == 3U);
177 assert_se(0xfffffffdU
/ 10U == 429496729U);
178 assert_se(DIV_ROUND_UP(0xfffffffdU
, 10U) == 429496730U);
179 assert_se((0xfffffffdU
+ 10U - 1U) / 10U == 0U);
180 assert_se(0xfffffffdU
/ 10U + !!(0xfffffffdU
% 10U) == 429496730U);
183 static void test_first_word(void) {
184 assert_se(first_word("Hello", ""));
185 assert_se(first_word("Hello", "Hello"));
186 assert_se(first_word("Hello world", "Hello"));
187 assert_se(first_word("Hello\tworld", "Hello"));
188 assert_se(first_word("Hello\nworld", "Hello"));
189 assert_se(first_word("Hello\rworld", "Hello"));
190 assert_se(first_word("Hello ", "Hello"));
192 assert_se(!first_word("Hello", "Hellooo"));
193 assert_se(!first_word("Hello", "xxxxx"));
194 assert_se(!first_word("Hellooo", "Hello"));
197 static void test_close_many(void) {
199 char name0
[] = "/tmp/test-close-many.XXXXXX";
200 char name1
[] = "/tmp/test-close-many.XXXXXX";
201 char name2
[] = "/tmp/test-close-many.XXXXXX";
203 fds
[0] = mkostemp_safe(name0
, O_RDWR
|O_CLOEXEC
);
204 fds
[1] = mkostemp_safe(name1
, O_RDWR
|O_CLOEXEC
);
205 fds
[2] = mkostemp_safe(name2
, O_RDWR
|O_CLOEXEC
);
209 assert_se(fcntl(fds
[0], F_GETFD
) == -1);
210 assert_se(fcntl(fds
[1], F_GETFD
) == -1);
211 assert_se(fcntl(fds
[2], F_GETFD
) >= 0);
220 static void test_parse_boolean(void) {
221 assert_se(parse_boolean("1") == 1);
222 assert_se(parse_boolean("y") == 1);
223 assert_se(parse_boolean("Y") == 1);
224 assert_se(parse_boolean("yes") == 1);
225 assert_se(parse_boolean("YES") == 1);
226 assert_se(parse_boolean("true") == 1);
227 assert_se(parse_boolean("TRUE") == 1);
228 assert_se(parse_boolean("on") == 1);
229 assert_se(parse_boolean("ON") == 1);
231 assert_se(parse_boolean("0") == 0);
232 assert_se(parse_boolean("n") == 0);
233 assert_se(parse_boolean("N") == 0);
234 assert_se(parse_boolean("no") == 0);
235 assert_se(parse_boolean("NO") == 0);
236 assert_se(parse_boolean("false") == 0);
237 assert_se(parse_boolean("FALSE") == 0);
238 assert_se(parse_boolean("off") == 0);
239 assert_se(parse_boolean("OFF") == 0);
241 assert_se(parse_boolean("garbage") < 0);
242 assert_se(parse_boolean("") < 0);
243 assert_se(parse_boolean("full") < 0);
246 static void test_parse_pid(void) {
250 r
= parse_pid("100", &pid
);
252 assert_se(pid
== 100);
254 r
= parse_pid("0x7FFFFFFF", &pid
);
256 assert_se(pid
== 2147483647);
258 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
259 r
= parse_pid("0", &pid
);
260 assert_se(r
== -ERANGE
);
261 assert_se(pid
== 65);
263 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
264 r
= parse_pid("-100", &pid
);
265 assert_se(r
== -ERANGE
);
266 assert_se(pid
== 65);
268 pid
= 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
269 r
= parse_pid("0xFFFFFFFFFFFFFFFFF", &pid
);
270 assert_se(r
== -ERANGE
);
271 assert_se(pid
== 65);
274 static void test_parse_uid(void) {
278 r
= parse_uid("100", &uid
);
280 assert_se(uid
== 100);
283 static void test_safe_atolli(void) {
287 r
= safe_atolli("12345", &l
);
289 assert_se(l
== 12345);
291 r
= safe_atolli("junk", &l
);
292 assert_se(r
== -EINVAL
);
295 static void test_safe_atod(void) {
300 r
= safe_atod("junk", &d
);
301 assert_se(r
== -EINVAL
);
303 r
= safe_atod("0.2244", &d
);
305 assert_se(fabs(d
- 0.2244) < 0.000001);
307 r
= safe_atod("0,5", &d
);
308 assert_se(r
== -EINVAL
);
312 assert_se(*e
== ',');
314 /* Check if this really is locale independent */
315 if (setlocale(LC_NUMERIC
, "de_DE.utf8")) {
317 r
= safe_atod("0.2244", &d
);
319 assert_se(fabs(d
- 0.2244) < 0.000001);
321 r
= safe_atod("0,5", &d
);
322 assert_se(r
== -EINVAL
);
325 assert_se(fabs(strtod("0,5", &e
) - 0.5) < 0.00001);
328 /* And check again, reset */
329 assert_se(setlocale(LC_NUMERIC
, "C"));
331 r
= safe_atod("0.2244", &d
);
333 assert_se(fabs(d
- 0.2244) < 0.000001);
335 r
= safe_atod("0,5", &d
);
336 assert_se(r
== -EINVAL
);
340 assert_se(*e
== ',');
343 static void test_strappend(void) {
344 _cleanup_free_
char *t1
, *t2
, *t3
, *t4
;
346 t1
= strappend(NULL
, NULL
);
347 assert_se(streq(t1
, ""));
349 t2
= strappend(NULL
, "suf");
350 assert_se(streq(t2
, "suf"));
352 t3
= strappend("pre", NULL
);
353 assert_se(streq(t3
, "pre"));
355 t4
= strappend("pre", "suf");
356 assert_se(streq(t4
, "presuf"));
359 static void test_strstrip(void) {
361 char input
[] = " hello, waldo. ";
364 assert_se(streq(r
, "hello, waldo."));
367 static void test_delete_chars(void) {
369 char input
[] = " hello, waldo. abc";
371 r
= delete_chars(input
, WHITESPACE
);
372 assert_se(streq(r
, "hello,waldo.abc"));
375 static void test_in_charset(void) {
376 assert_se(in_charset("dddaaabbbcccc", "abcd"));
377 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
380 static void test_hexchar(void) {
381 assert_se(hexchar(0xa) == 'a');
382 assert_se(hexchar(0x0) == '0');
385 static void test_unhexchar(void) {
386 assert_se(unhexchar('a') == 0xA);
387 assert_se(unhexchar('A') == 0xA);
388 assert_se(unhexchar('0') == 0x0);
391 static void test_octchar(void) {
392 assert_se(octchar(00) == '0');
393 assert_se(octchar(07) == '7');
396 static void test_unoctchar(void) {
397 assert_se(unoctchar('0') == 00);
398 assert_se(unoctchar('7') == 07);
401 static void test_decchar(void) {
402 assert_se(decchar(0) == '0');
403 assert_se(decchar(9) == '9');
406 static void test_undecchar(void) {
407 assert_se(undecchar('0') == 0);
408 assert_se(undecchar('9') == 9);
411 static void test_cescape(void) {
412 _cleanup_free_
char *escaped
;
414 assert_se(escaped
= cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
415 assert_se(streq(escaped
, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
418 static void test_cunescape(void) {
419 _cleanup_free_
char *unescaped
;
421 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped
) < 0);
422 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX
, &unescaped
) >= 0);
423 assert_se(streq_ptr(unescaped
, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
427 /* incomplete sequences */
428 assert_se(cunescape("\\x0", 0, &unescaped
) < 0);
429 assert_se(cunescape("\\x0", UNESCAPE_RELAX
, &unescaped
) >= 0);
430 assert_se(streq_ptr(unescaped
, "\\x0"));
434 assert_se(cunescape("\\x", 0, &unescaped
) < 0);
435 assert_se(cunescape("\\x", UNESCAPE_RELAX
, &unescaped
) >= 0);
436 assert_se(streq_ptr(unescaped
, "\\x"));
440 assert_se(cunescape("\\", 0, &unescaped
) < 0);
441 assert_se(cunescape("\\", UNESCAPE_RELAX
, &unescaped
) >= 0);
442 assert_se(streq_ptr(unescaped
, "\\"));
446 assert_se(cunescape("\\11", 0, &unescaped
) < 0);
447 assert_se(cunescape("\\11", UNESCAPE_RELAX
, &unescaped
) >= 0);
448 assert_se(streq_ptr(unescaped
, "\\11"));
452 assert_se(cunescape("\\1", 0, &unescaped
) < 0);
453 assert_se(cunescape("\\1", UNESCAPE_RELAX
, &unescaped
) >= 0);
454 assert_se(streq_ptr(unescaped
, "\\1"));
458 assert_se(cunescape("\\u0000", 0, &unescaped
) < 0);
459 assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX
, &unescaped
) >= 0);
460 assert_se(streq_ptr(unescaped
, "ßßΠA"));
463 static void test_foreach_word(void) {
464 const char *word
, *state
;
467 const char test
[] = "test abc d\te f ";
468 const char * const expected
[] = {
478 FOREACH_WORD(word
, l
, test
, state
)
479 assert_se(strneq(expected
[i
++], word
, l
));
482 static void check(const char *test
, char** expected
, bool trailing
) {
483 const char *word
, *state
;
487 printf("<<<%s>>>\n", test
);
488 FOREACH_WORD_QUOTED(word
, l
, test
, state
) {
489 _cleanup_free_
char *t
= NULL
;
491 assert_se(t
= strndup(word
, l
));
492 assert_se(strneq(expected
[i
++], word
, l
));
495 printf("<<<%s>>>\n", state
);
496 assert_se(expected
[i
] == NULL
);
497 assert_se(isempty(state
) == !trailing
);
500 static void test_foreach_word_quoted(void) {
501 check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
525 static void test_default_term_for_tty(void) {
526 puts(default_term_for_tty("/dev/tty23"));
527 puts(default_term_for_tty("/dev/ttyS23"));
528 puts(default_term_for_tty("/dev/tty0"));
529 puts(default_term_for_tty("/dev/pty0"));
530 puts(default_term_for_tty("/dev/pts/0"));
531 puts(default_term_for_tty("/dev/console"));
532 puts(default_term_for_tty("tty23"));
533 puts(default_term_for_tty("ttyS23"));
534 puts(default_term_for_tty("tty0"));
535 puts(default_term_for_tty("pty0"));
536 puts(default_term_for_tty("pts/0"));
537 puts(default_term_for_tty("console"));
540 static void test_memdup_multiply(void) {
541 int org
[] = {1, 2, 3};
544 dup
= (int*)memdup_multiply(org
, sizeof(int), 3);
547 assert_se(dup
[0] == 1);
548 assert_se(dup
[1] == 2);
549 assert_se(dup
[2] == 3);
553 static void test_hostname_is_valid(void) {
554 assert_se(hostname_is_valid("foobar"));
555 assert_se(hostname_is_valid("foobar.com"));
556 assert_se(!hostname_is_valid("fööbar"));
557 assert_se(!hostname_is_valid(""));
558 assert_se(!hostname_is_valid("."));
559 assert_se(!hostname_is_valid(".."));
560 assert_se(!hostname_is_valid("foobar."));
561 assert_se(!hostname_is_valid(".foobar"));
562 assert_se(!hostname_is_valid("foo..bar"));
563 assert_se(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
566 static void test_u64log2(void) {
567 assert_se(u64log2(0) == 0);
568 assert_se(u64log2(8) == 3);
569 assert_se(u64log2(9) == 3);
570 assert_se(u64log2(15) == 3);
571 assert_se(u64log2(16) == 4);
572 assert_se(u64log2(1024*1024) == 20);
573 assert_se(u64log2(1024*1024+5) == 20);
576 static void test_protect_errno(void) {
582 assert_se(errno
== 12);
585 static void test_parse_size(void) {
588 assert_se(parse_size("111", 1024, &bytes
) == 0);
589 assert_se(bytes
== 111);
591 assert_se(parse_size("111.4", 1024, &bytes
) == 0);
592 assert_se(bytes
== 111);
594 assert_se(parse_size(" 112 B", 1024, &bytes
) == 0);
595 assert_se(bytes
== 112);
597 assert_se(parse_size(" 112.6 B", 1024, &bytes
) == 0);
598 assert_se(bytes
== 112);
600 assert_se(parse_size("3.5 K", 1024, &bytes
) == 0);
601 assert_se(bytes
== 3*1024 + 512);
603 assert_se(parse_size("3. K", 1024, &bytes
) == 0);
604 assert_se(bytes
== 3*1024);
606 assert_se(parse_size("3.0 K", 1024, &bytes
) == 0);
607 assert_se(bytes
== 3*1024);
609 assert_se(parse_size("3. 0 K", 1024, &bytes
) == -EINVAL
);
611 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes
) == 0);
612 assert_se(bytes
== 4*1024*1024 + 11 * 1024 + 512);
614 assert_se(parse_size("3B3.5G", 1024, &bytes
) == -EINVAL
);
616 assert_se(parse_size("3.5G3B", 1024, &bytes
) == 0);
617 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
619 assert_se(parse_size("3.5G 4B", 1024, &bytes
) == 0);
620 assert_se(bytes
== 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
622 assert_se(parse_size("3B3G4T", 1024, &bytes
) == -EINVAL
);
624 assert_se(parse_size("4T3G3B", 1024, &bytes
) == 0);
625 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
627 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes
) == 0);
628 assert_se(bytes
== (4ULL*1024 + 3)*1024*1024*1024 + 3);
630 assert_se(parse_size("12P", 1024, &bytes
) == 0);
631 assert_se(bytes
== 12ULL * 1024*1024*1024*1024*1024);
633 assert_se(parse_size("12P12P", 1024, &bytes
) == -EINVAL
);
635 assert_se(parse_size("3E 2P", 1024, &bytes
) == 0);
636 assert_se(bytes
== (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
638 assert_se(parse_size("12X", 1024, &bytes
) == -EINVAL
);
640 assert_se(parse_size("12.5X", 1024, &bytes
) == -EINVAL
);
642 assert_se(parse_size("12.5e3", 1024, &bytes
) == -EINVAL
);
644 assert_se(parse_size("1024E", 1024, &bytes
) == -ERANGE
);
645 assert_se(parse_size("-1", 1024, &bytes
) == -ERANGE
);
646 assert_se(parse_size("-1024E", 1024, &bytes
) == -ERANGE
);
648 assert_se(parse_size("-1024P", 1024, &bytes
) == -ERANGE
);
650 assert_se(parse_size("-10B 20K", 1024, &bytes
) == -ERANGE
);
653 static void test_config_parse_iec_off(void) {
655 assert_se(config_parse_iec_off(NULL
, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset
, NULL
) == 0);
656 assert_se(offset
== 4 * 1024 * 1024);
658 assert_se(config_parse_iec_off(NULL
, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset
, NULL
) == 0);
661 static void test_strextend(void) {
662 _cleanup_free_
char *str
= strdup("0123");
663 strextend(&str
, "456", "78", "9", NULL
);
664 assert_se(streq(str
, "0123456789"));
667 static void test_strrep(void) {
668 _cleanup_free_
char *one
, *three
, *zero
;
669 one
= strrep("waldo", 1);
670 three
= strrep("waldo", 3);
671 zero
= strrep("waldo", 0);
673 assert_se(streq(one
, "waldo"));
674 assert_se(streq(three
, "waldowaldowaldo"));
675 assert_se(streq(zero
, ""));
678 static void test_split_pair(void) {
679 _cleanup_free_
char *a
= NULL
, *b
= NULL
;
681 assert_se(split_pair("", "", &a
, &b
) == -EINVAL
);
682 assert_se(split_pair("foo=bar", "", &a
, &b
) == -EINVAL
);
683 assert_se(split_pair("", "=", &a
, &b
) == -EINVAL
);
684 assert_se(split_pair("foo=bar", "=", &a
, &b
) >= 0);
685 assert_se(streq(a
, "foo"));
686 assert_se(streq(b
, "bar"));
689 assert_se(split_pair("==", "==", &a
, &b
) >= 0);
690 assert_se(streq(a
, ""));
691 assert_se(streq(b
, ""));
695 assert_se(split_pair("===", "==", &a
, &b
) >= 0);
696 assert_se(streq(a
, ""));
697 assert_se(streq(b
, "="));
700 static void test_fstab_node_to_udev_node(void) {
703 n
= fstab_node_to_udev_node("LABEL=applé/jack");
705 assert_se(streq(n
, "/dev/disk/by-label/applé\\x2fjack"));
708 n
= fstab_node_to_udev_node("PARTLABEL=pinkié pie");
710 assert_se(streq(n
, "/dev/disk/by-partlabel/pinkié\\x20pie"));
713 n
= fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
715 assert_se(streq(n
, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
718 n
= fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
720 assert_se(streq(n
, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
723 n
= fstab_node_to_udev_node("PONIES=awesome");
725 assert_se(streq(n
, "PONIES=awesome"));
728 n
= fstab_node_to_udev_node("/dev/xda1");
730 assert_se(streq(n
, "/dev/xda1"));
734 static void test_get_files_in_directory(void) {
735 _cleanup_strv_free_
char **l
= NULL
, **t
= NULL
;
737 assert_se(get_files_in_directory("/tmp", &l
) >= 0);
738 assert_se(get_files_in_directory(".", &t
) >= 0);
739 assert_se(get_files_in_directory(".", NULL
) >= 0);
742 static void test_in_set(void) {
743 assert_se(IN_SET(1, 1));
744 assert_se(IN_SET(1, 1, 2, 3, 4));
745 assert_se(IN_SET(2, 1, 2, 3, 4));
746 assert_se(IN_SET(3, 1, 2, 3, 4));
747 assert_se(IN_SET(4, 1, 2, 3, 4));
748 assert_se(!IN_SET(0, 1));
749 assert_se(!IN_SET(0, 1, 2, 3, 4));
752 static void test_writing_tmpfile(void) {
753 char name
[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
754 _cleanup_free_
char *contents
= NULL
;
759 IOVEC_SET_STRING(iov
[0], "abc\n");
760 IOVEC_SET_STRING(iov
[1], ALPHANUMERICAL
"\n");
761 IOVEC_SET_STRING(iov
[2], "");
763 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
764 printf("tmpfile: %s", name
);
766 r
= writev(fd
, iov
, 3);
769 r
= read_full_file(name
, &contents
, &size
);
771 printf("contents: %s", contents
);
772 assert_se(streq(contents
, "abc\n" ALPHANUMERICAL
"\n"));
777 static void test_hexdump(void) {
781 hexdump(stdout
, NULL
, 0);
782 hexdump(stdout
, "", 0);
783 hexdump(stdout
, "", 1);
784 hexdump(stdout
, "x", 1);
785 hexdump(stdout
, "x", 2);
786 hexdump(stdout
, "foobar", 7);
787 hexdump(stdout
, "f\nobar", 7);
788 hexdump(stdout
, "xxxxxxxxxxxxxxxxxxxxyz", 23);
790 for (i
= 0; i
< ELEMENTSOF(data
); i
++)
793 hexdump(stdout
, data
, sizeof(data
));
796 static void test_log2i(void) {
797 assert_se(log2i(1) == 0);
798 assert_se(log2i(2) == 1);
799 assert_se(log2i(3) == 1);
800 assert_se(log2i(4) == 2);
801 assert_se(log2i(32) == 5);
802 assert_se(log2i(33) == 5);
803 assert_se(log2i(63) == 5);
804 assert_se(log2i(INT_MAX
) == sizeof(int)*8-2);
807 static void test_foreach_string(void) {
808 const char * const t
[] = {
817 FOREACH_STRING(x
, "foo", "bar", "waldo")
818 assert_se(streq_ptr(t
[i
++], x
));
822 FOREACH_STRING(x
, "zzz")
823 assert_se(streq(x
, "zzz"));
826 static void test_filename_is_valid(void) {
827 char foo
[FILENAME_MAX
+2];
830 assert_se(!filename_is_valid(""));
831 assert_se(!filename_is_valid("/bar/foo"));
832 assert_se(!filename_is_valid("/"));
833 assert_se(!filename_is_valid("."));
834 assert_se(!filename_is_valid(".."));
836 for (i
=0; i
<FILENAME_MAX
+1; i
++)
838 foo
[FILENAME_MAX
+1] = '\0';
840 assert_se(!filename_is_valid(foo
));
842 assert_se(filename_is_valid("foo_bar-333"));
843 assert_se(filename_is_valid("o.o"));
846 static void test_string_has_cc(void) {
847 assert_se(string_has_cc("abc\1", NULL
));
848 assert_se(string_has_cc("abc\x7f", NULL
));
849 assert_se(string_has_cc("abc\x7f", NULL
));
850 assert_se(string_has_cc("abc\t\x7f", "\t"));
851 assert_se(string_has_cc("abc\t\x7f", "\t"));
852 assert_se(string_has_cc("\x7f", "\t"));
853 assert_se(string_has_cc("\x7f", "\t\a"));
855 assert_se(!string_has_cc("abc\t\t", "\t"));
856 assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
857 assert_se(!string_has_cc("a\ab\tc", "\t\a"));
860 static void test_ascii_strlower(void) {
861 char a
[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
862 assert_se(streq(ascii_strlower(a
), "aabbcc jk ii od lkjjj kkd lk"));
865 static void test_files_same(void) {
866 _cleanup_close_
int fd
= -1;
867 char name
[] = "/tmp/test-files_same.XXXXXX";
868 char name_alias
[] = "/tmp/test-files_same.alias";
870 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
872 assert_se(symlink(name
, name_alias
) >= 0);
874 assert_se(files_same(name
, name
));
875 assert_se(files_same(name
, name_alias
));
881 static void test_is_valid_documentation_url(void) {
882 assert_se(documentation_url_is_valid("http://www.freedesktop.org/wiki/Software/systemd"));
883 assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
884 assert_se(documentation_url_is_valid("file:/foo/foo"));
885 assert_se(documentation_url_is_valid("man:systemd.special(7)"));
886 assert_se(documentation_url_is_valid("info:bar"));
888 assert_se(!documentation_url_is_valid("foo:"));
889 assert_se(!documentation_url_is_valid("info:"));
890 assert_se(!documentation_url_is_valid(""));
893 static void test_file_in_same_dir(void) {
896 t
= file_in_same_dir("/", "a");
897 assert_se(streq(t
, "/a"));
900 t
= file_in_same_dir("/", "/a");
901 assert_se(streq(t
, "/a"));
904 t
= file_in_same_dir("", "a");
905 assert_se(streq(t
, "a"));
908 t
= file_in_same_dir("a/", "a");
909 assert_se(streq(t
, "a/a"));
912 t
= file_in_same_dir("bar/foo", "bar");
913 assert_se(streq(t
, "bar/bar"));
917 static void test_endswith(void) {
918 assert_se(endswith("foobar", "bar"));
919 assert_se(endswith("foobar", ""));
920 assert_se(endswith("foobar", "foobar"));
921 assert_se(endswith("", ""));
923 assert_se(!endswith("foobar", "foo"));
924 assert_se(!endswith("foobar", "foobarfoofoo"));
927 static void test_close_nointr(void) {
928 char name
[] = "/tmp/test-test-close_nointr.XXXXXX";
931 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
933 assert_se(close_nointr(fd
) >= 0);
934 assert_se(close_nointr(fd
) < 0);
940 static void test_unlink_noerrno(void) {
941 char name
[] = "/tmp/test-close_nointr.XXXXXX";
944 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
946 assert_se(close_nointr(fd
) >= 0);
951 assert_se(unlink_noerrno(name
) >= 0);
952 assert_se(errno
== -42);
953 assert_se(unlink_noerrno(name
) < 0);
954 assert_se(errno
== -42);
958 static void test_readlink_and_make_absolute(void) {
959 char tempdir
[] = "/tmp/test-readlink_and_make_absolute";
960 char name
[] = "/tmp/test-readlink_and_make_absolute/original";
961 char name2
[] = "test-readlink_and_make_absolute/original";
962 char name_alias
[] = "/tmp/test-readlink_and_make_absolute-alias";
965 assert_se(mkdir_safe(tempdir
, 0755, getuid(), getgid()) >= 0);
966 assert_se(touch(name
) >= 0);
968 assert_se(symlink(name
, name_alias
) >= 0);
969 assert_se(readlink_and_make_absolute(name_alias
, &r
) >= 0);
970 assert_se(streq(r
, name
));
972 assert_se(unlink(name_alias
) >= 0);
974 assert_se(chdir(tempdir
) >= 0);
975 assert_se(symlink(name2
, name_alias
) >= 0);
976 assert_se(readlink_and_make_absolute(name_alias
, &r
) >= 0);
977 assert_se(streq(r
, name
));
979 assert_se(unlink(name_alias
) >= 0);
981 assert_se(rm_rf(tempdir
, REMOVE_ROOT
|REMOVE_PHYSICAL
) >= 0);
984 static void test_read_one_char(void) {
985 _cleanup_fclose_
FILE *file
= NULL
;
988 char name
[] = "/tmp/test-read_one_char.XXXXXX";
991 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
993 file
= fdopen(fd
, "r+");
995 assert_se(fputs("c\n", file
) >= 0);
998 assert_se(read_one_char(file
, &r
, 1000000, &need_nl
) >= 0);
1000 assert_se(r
== 'c');
1001 assert_se(read_one_char(file
, &r
, 1000000, &need_nl
) < 0);
1004 assert_se(fputs("foobar\n", file
) >= 0);
1006 assert_se(read_one_char(file
, &r
, 1000000, &need_nl
) < 0);
1009 assert_se(fputs("\n", file
) >= 0);
1011 assert_se(read_one_char(file
, &r
, 1000000, &need_nl
) < 0);
1016 static void test_ignore_signals(void) {
1017 assert_se(ignore_signals(SIGINT
, -1) >= 0);
1018 assert_se(kill(getpid(), SIGINT
) >= 0);
1019 assert_se(ignore_signals(SIGUSR1
, SIGUSR2
, SIGTERM
, SIGPIPE
, -1) >= 0);
1020 assert_se(kill(getpid(), SIGUSR1
) >= 0);
1021 assert_se(kill(getpid(), SIGUSR2
) >= 0);
1022 assert_se(kill(getpid(), SIGTERM
) >= 0);
1023 assert_se(kill(getpid(), SIGPIPE
) >= 0);
1024 assert_se(default_signals(SIGINT
, SIGUSR1
, SIGUSR2
, SIGTERM
, SIGPIPE
, -1) >= 0);
1027 static void test_strshorten(void) {
1028 char s
[] = "foobar";
1030 assert_se(strlen(strshorten(s
, 6)) == 6);
1031 assert_se(strlen(strshorten(s
, 12)) == 6);
1032 assert_se(strlen(strshorten(s
, 2)) == 2);
1033 assert_se(strlen(strshorten(s
, 0)) == 0);
1036 static void test_strjoina(void) {
1039 actual
= strjoina("", "foo", "bar");
1040 assert_se(streq(actual
, "foobar"));
1042 actual
= strjoina("foo", "bar", "baz");
1043 assert_se(streq(actual
, "foobarbaz"));
1045 actual
= strjoina("foo", "", "bar", "baz");
1046 assert_se(streq(actual
, "foobarbaz"));
1048 actual
= strjoina("foo");
1049 assert_se(streq(actual
, "foo"));
1051 actual
= strjoina(NULL
);
1052 assert_se(streq(actual
, ""));
1054 actual
= strjoina(NULL
, "foo");
1055 assert_se(streq(actual
, ""));
1057 actual
= strjoina("foo", NULL
, "bar");
1058 assert_se(streq(actual
, "foo"));
1061 static void test_is_symlink(void) {
1062 char name
[] = "/tmp/test-is_symlink.XXXXXX";
1063 char name_link
[] = "/tmp/test-is_symlink.link";
1064 _cleanup_close_
int fd
= -1;
1066 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1068 assert_se(symlink(name
, name_link
) >= 0);
1070 assert_se(is_symlink(name
) == 0);
1071 assert_se(is_symlink(name_link
) == 1);
1072 assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
1079 static void test_search_and_fopen(void) {
1080 const char *dirs
[] = {"/tmp/foo/bar", "/tmp", NULL
};
1081 char name
[] = "/tmp/test-search_and_fopen.XXXXXX";
1086 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1090 r
= search_and_fopen(basename(name
), "r", NULL
, dirs
, &f
);
1094 r
= search_and_fopen(name
, "r", NULL
, dirs
, &f
);
1098 r
= search_and_fopen(basename(name
), "r", "/", dirs
, &f
);
1102 r
= search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL
, dirs
, &f
);
1104 r
= search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL
, dirs
, &f
);
1110 r
= search_and_fopen(basename(name
), "r", NULL
, dirs
, &f
);
1115 static void test_search_and_fopen_nulstr(void) {
1116 const char dirs
[] = "/tmp/foo/bar\0/tmp\0";
1117 char name
[] = "/tmp/test-search_and_fopen.XXXXXX";
1122 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1126 r
= search_and_fopen_nulstr(basename(name
), "r", NULL
, dirs
, &f
);
1130 r
= search_and_fopen_nulstr(name
, "r", NULL
, dirs
, &f
);
1134 r
= search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL
, dirs
, &f
);
1136 r
= search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL
, dirs
, &f
);
1142 r
= search_and_fopen_nulstr(basename(name
), "r", NULL
, dirs
, &f
);
1146 static void test_glob_exists(void) {
1147 char name
[] = "/tmp/test-glob_exists.XXXXXX";
1151 fd
= mkostemp_safe(name
, O_RDWR
|O_CLOEXEC
);
1155 r
= glob_exists("/tmp/test-glob_exists*");
1160 r
= glob_exists("/tmp/test-glob_exists*");
1164 static void test_execute_directory(void) {
1165 char template_lo
[] = "/tmp/test-readlink_and_make_absolute-lo.XXXXXXX";
1166 char template_hi
[] = "/tmp/test-readlink_and_make_absolute-hi.XXXXXXX";
1167 const char * dirs
[] = {template_hi
, template_lo
, NULL
};
1168 const char *name
, *name2
, *name3
, *overridden
, *override
, *masked
, *mask
;
1170 assert_se(mkdtemp(template_lo
));
1171 assert_se(mkdtemp(template_hi
));
1173 name
= strjoina(template_lo
, "/script");
1174 name2
= strjoina(template_hi
, "/script2");
1175 name3
= strjoina(template_lo
, "/useless");
1176 overridden
= strjoina(template_lo
, "/overridden");
1177 override
= strjoina(template_hi
, "/overridden");
1178 masked
= strjoina(template_lo
, "/masked");
1179 mask
= strjoina(template_hi
, "/masked");
1181 assert_se(write_string_file(name
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works") == 0);
1182 assert_se(write_string_file(name2
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2") == 0);
1183 assert_se(write_string_file(overridden
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed") == 0);
1184 assert_se(write_string_file(override
, "#!/bin/sh\necho 'Executing '$0") == 0);
1185 assert_se(write_string_file(masked
, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed") == 0);
1186 assert_se(symlink("/dev/null", mask
) == 0);
1187 assert_se(chmod(name
, 0755) == 0);
1188 assert_se(chmod(name2
, 0755) == 0);
1189 assert_se(chmod(overridden
, 0755) == 0);
1190 assert_se(chmod(override
, 0755) == 0);
1191 assert_se(chmod(masked
, 0755) == 0);
1192 assert_se(touch(name3
) >= 0);
1194 execute_directories(dirs
, DEFAULT_TIMEOUT_USEC
, NULL
);
1196 assert_se(chdir(template_lo
) == 0);
1197 assert_se(access("it_works", F_OK
) >= 0);
1198 assert_se(access("failed", F_OK
) < 0);
1200 assert_se(chdir(template_hi
) == 0);
1201 assert_se(access("it_works2", F_OK
) >= 0);
1202 assert_se(access("failed", F_OK
) < 0);
1204 (void) rm_rf(template_lo
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
1205 (void) rm_rf(template_hi
, REMOVE_ROOT
|REMOVE_PHYSICAL
);
1208 static void test_unquote_first_word(void) {
1209 const char *p
, *original
;
1212 p
= original
= "foobar waldo";
1213 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1214 assert_se(streq(t
, "foobar"));
1216 assert_se(p
== original
+ 7);
1218 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1219 assert_se(streq(t
, "waldo"));
1221 assert_se(p
== original
+ 12);
1223 assert_se(unquote_first_word(&p
, &t
, 0) == 0);
1225 assert_se(p
== original
+ 12);
1227 p
= original
= "\"foobar\" \'waldo\'";
1228 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1229 assert_se(streq(t
, "foobar"));
1231 assert_se(p
== original
+ 9);
1233 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1234 assert_se(streq(t
, "waldo"));
1236 assert_se(p
== original
+ 16);
1238 assert_se(unquote_first_word(&p
, &t
, 0) == 0);
1240 assert_se(p
== original
+ 16);
1242 p
= original
= "\"";
1243 assert_se(unquote_first_word(&p
, &t
, 0) == -EINVAL
);
1244 assert_se(p
== original
+ 1);
1246 p
= original
= "\'";
1247 assert_se(unquote_first_word(&p
, &t
, 0) == -EINVAL
);
1248 assert_se(p
== original
+ 1);
1250 p
= original
= "\'fooo";
1251 assert_se(unquote_first_word(&p
, &t
, 0) == -EINVAL
);
1252 assert_se(p
== original
+ 5);
1254 p
= original
= "\'fooo";
1255 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_RELAX
) > 0);
1256 assert_se(streq(t
, "fooo"));
1258 assert_se(p
== original
+ 5);
1260 p
= original
= "yay\'foo\'bar";
1261 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1262 assert_se(streq(t
, "yayfoobar"));
1264 assert_se(p
== original
+ 11);
1266 p
= original
= " foobar ";
1267 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1268 assert_se(streq(t
, "foobar"));
1270 assert_se(p
== original
+ 12);
1272 p
= original
= " foo\\ba\\x6ar ";
1273 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
) > 0);
1274 assert_se(streq(t
, "foo\ba\x6ar"));
1276 assert_se(p
== original
+ 13);
1278 p
= original
= " foo\\ba\\x6ar ";
1279 assert_se(unquote_first_word(&p
, &t
, 0) > 0);
1280 assert_se(streq(t
, "foobax6ar"));
1282 assert_se(p
== original
+ 13);
1284 p
= original
= " f\\u00f6o \"pi\\U0001F4A9le\" ";
1285 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
) > 0);
1286 assert_se(streq(t
, "föo"));
1288 assert_se(p
== original
+ 13);
1290 assert_se(unquote_first_word(&p
, &t
, UNQUOTE_CUNESCAPE
) > 0);
1291 assert_se(streq(t
, "pi\360\237\222\251le"));
1293 assert_se(p
== original
+ 32);
1296 static void test_unquote_many_words(void) {
1297 const char *p
, *original
;
1300 p
= original
= "foobar waldi piep";
1301 assert_se(unquote_many_words(&p
, 0, &a
, &b
, &c
, NULL
) == 3);
1302 assert_se(p
== original
+ 17);
1303 assert_se(streq_ptr(a
, "foobar"));
1304 assert_se(streq_ptr(b
, "waldi"));
1305 assert_se(streq_ptr(c
, "piep"));
1310 p
= original
= "'foobar' wa\"ld\"i ";
1311 assert_se(unquote_many_words(&p
, 0, &a
, &b
, &c
, NULL
) == 2);
1312 assert_se(p
== original
+ 19);
1313 assert_se(streq_ptr(a
, "foobar"));
1314 assert_se(streq_ptr(b
, "waldi"));
1315 assert_se(streq_ptr(c
, NULL
));
1320 assert_se(unquote_many_words(&p
, 0, &a
, &b
, &c
, NULL
) == 0);
1321 assert_se(p
== original
);
1322 assert_se(streq_ptr(a
, NULL
));
1323 assert_se(streq_ptr(b
, NULL
));
1324 assert_se(streq_ptr(c
, NULL
));
1327 assert_se(unquote_many_words(&p
, 0, &a
, &b
, &c
, NULL
) == 0);
1328 assert_se(p
== original
+2);
1329 assert_se(streq_ptr(a
, NULL
));
1330 assert_se(streq_ptr(b
, NULL
));
1331 assert_se(streq_ptr(c
, NULL
));
1333 p
= original
= "foobar";
1334 assert_se(unquote_many_words(&p
, 0, NULL
) == 0);
1335 assert_se(p
== original
);
1337 p
= original
= "foobar waldi";
1338 assert_se(unquote_many_words(&p
, 0, &a
, NULL
) == 1);
1339 assert_se(p
== original
+7);
1340 assert_se(streq_ptr(a
, "foobar"));
1343 p
= original
= " foobar ";
1344 assert_se(unquote_many_words(&p
, 0, &a
, NULL
) == 1);
1345 assert_se(p
== original
+15);
1346 assert_se(streq_ptr(a
, "foobar"));
1350 static int parse_item(const char *key
, const char *value
) {
1353 log_info("kernel cmdline option <%s> = <%s>", key
, strna(value
));
1357 static void test_parse_proc_cmdline(void) {
1358 assert_se(parse_proc_cmdline(parse_item
) >= 0);
1361 static void test_raw_clone(void) {
1362 pid_t parent
, pid
, pid2
;
1365 log_info("before clone: getpid()→"PID_FMT
, parent
);
1366 assert_se(raw_getpid() == parent
);
1368 pid
= raw_clone(0, NULL
);
1369 assert_se(pid
>= 0);
1371 pid2
= raw_getpid();
1372 log_info("raw_clone: "PID_FMT
" getpid()→"PID_FMT
" raw_getpid()→"PID_FMT
,
1373 pid
, getpid(), pid2
);
1375 assert_se(pid2
!= parent
);
1376 _exit(EXIT_SUCCESS
);
1380 assert_se(pid2
== parent
);
1381 waitpid(pid
, &status
, __WCLONE
);
1382 assert_se(WIFEXITED(status
) && WEXITSTATUS(status
) == EXIT_SUCCESS
);
1386 static void test_same_fd(void) {
1387 _cleanup_close_pair_
int p
[2] = { -1, -1 };
1388 _cleanup_close_
int a
= -1, b
= -1, c
= -1;
1390 assert_se(pipe2(p
, O_CLOEXEC
) >= 0);
1391 assert_se((a
= dup(p
[0])) >= 0);
1392 assert_se((b
= open("/dev/null", O_RDONLY
|O_CLOEXEC
)) >= 0);
1393 assert_se((c
= dup(a
)) >= 0);
1395 assert_se(same_fd(p
[0], p
[0]) > 0);
1396 assert_se(same_fd(p
[1], p
[1]) > 0);
1397 assert_se(same_fd(a
, a
) > 0);
1398 assert_se(same_fd(b
, b
) > 0);
1400 assert_se(same_fd(a
, p
[0]) > 0);
1401 assert_se(same_fd(p
[0], a
) > 0);
1402 assert_se(same_fd(c
, p
[0]) > 0);
1403 assert_se(same_fd(p
[0], c
) > 0);
1404 assert_se(same_fd(a
, c
) > 0);
1405 assert_se(same_fd(c
, a
) > 0);
1407 assert_se(same_fd(p
[0], p
[1]) == 0);
1408 assert_se(same_fd(p
[1], p
[0]) == 0);
1409 assert_se(same_fd(p
[0], b
) == 0);
1410 assert_se(same_fd(b
, p
[0]) == 0);
1411 assert_se(same_fd(p
[1], a
) == 0);
1412 assert_se(same_fd(a
, p
[1]) == 0);
1413 assert_se(same_fd(p
[1], b
) == 0);
1414 assert_se(same_fd(b
, p
[1]) == 0);
1416 assert_se(same_fd(a
, b
) == 0);
1417 assert_se(same_fd(b
, a
) == 0);
1420 static void test_uid_ptr(void) {
1422 assert_se(UID_TO_PTR(0) != NULL
);
1423 assert_se(UID_TO_PTR(1000) != NULL
);
1425 assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
1426 assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
1429 static void test_sparse_write_one(int fd
, const char *buffer
, size_t n
) {
1432 assert_se(lseek(fd
, 0, SEEK_SET
) == 0);
1433 assert_se(ftruncate(fd
, 0) >= 0);
1434 assert_se(sparse_write(fd
, buffer
, n
, 4) == (ssize_t
) n
);
1436 assert_se(lseek(fd
, 0, SEEK_CUR
) == (off_t
) n
);
1437 assert_se(ftruncate(fd
, n
) >= 0);
1439 assert_se(lseek(fd
, 0, SEEK_SET
) == 0);
1440 assert_se(read(fd
, check
, n
) == (ssize_t
) n
);
1442 assert_se(memcmp(buffer
, check
, n
) == 0);
1445 static void test_sparse_write(void) {
1446 const char test_a
[] = "test";
1447 const char test_b
[] = "\0\0\0\0test\0\0\0\0";
1448 const char test_c
[] = "\0\0test\0\0\0\0";
1449 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";
1450 const char test_e
[] = "test\0\0\0\0test";
1451 _cleanup_close_
int fd
= -1;
1452 char fn
[] = "/tmp/sparseXXXXXX";
1454 fd
= mkostemp(fn
, O_CLOEXEC
);
1458 test_sparse_write_one(fd
, test_a
, sizeof(test_a
));
1459 test_sparse_write_one(fd
, test_b
, sizeof(test_b
));
1460 test_sparse_write_one(fd
, test_c
, sizeof(test_c
));
1461 test_sparse_write_one(fd
, test_d
, sizeof(test_d
));
1462 test_sparse_write_one(fd
, test_e
, sizeof(test_e
));
1465 static void test_shell_maybe_quote_one(const char *s
, const char *expected
) {
1466 _cleanup_free_
char *r
;
1468 assert_se(r
= shell_maybe_quote(s
));
1469 assert_se(streq(r
, expected
));
1472 static void test_shell_maybe_quote(void) {
1474 test_shell_maybe_quote_one("", "");
1475 test_shell_maybe_quote_one("\\", "\"\\\\\"");
1476 test_shell_maybe_quote_one("\"", "\"\\\"\"");
1477 test_shell_maybe_quote_one("foobar", "foobar");
1478 test_shell_maybe_quote_one("foo bar", "\"foo bar\"");
1479 test_shell_maybe_quote_one("foo \"bar\" waldo", "\"foo \\\"bar\\\" waldo\"");
1480 test_shell_maybe_quote_one("foo$bar", "\"foo\\$bar\"");
1483 static void test_parse_mode(void) {
1486 assert_se(parse_mode("-1", &m
) < 0);
1487 assert_se(parse_mode("", &m
) < 0);
1488 assert_se(parse_mode("888", &m
) < 0);
1489 assert_se(parse_mode("77777", &m
) < 0);
1491 assert_se(parse_mode("544", &m
) >= 0 && m
== 0544);
1492 assert_se(parse_mode("777", &m
) >= 0 && m
== 0777);
1493 assert_se(parse_mode("7777", &m
) >= 0 && m
== 07777);
1494 assert_se(parse_mode("0", &m
) >= 0 && m
== 0);
1497 int main(int argc
, char *argv
[]) {
1498 log_parse_environment();
1502 test_align_power2();
1504 test_container_of();
1506 test_div_round_up();
1509 test_parse_boolean();
1516 test_delete_chars();
1526 test_foreach_word();
1527 test_foreach_word_quoted();
1528 test_default_term_for_tty();
1529 test_memdup_multiply();
1530 test_hostname_is_valid();
1532 test_protect_errno();
1534 test_config_parse_iec_off();
1538 test_fstab_node_to_udev_node();
1539 test_get_files_in_directory();
1541 test_writing_tmpfile();
1544 test_foreach_string();
1545 test_filename_is_valid();
1546 test_string_has_cc();
1547 test_ascii_strlower();
1549 test_is_valid_documentation_url();
1550 test_file_in_same_dir();
1552 test_close_nointr();
1553 test_unlink_noerrno();
1554 test_readlink_and_make_absolute();
1555 test_read_one_char();
1556 test_ignore_signals();
1560 test_search_and_fopen();
1561 test_search_and_fopen_nulstr();
1563 test_execute_directory();
1564 test_unquote_first_word();
1565 test_unquote_many_words();
1566 test_parse_proc_cmdline();
1570 test_sparse_write();
1571 test_shell_maybe_quote();