]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-util.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #1676 from poettering/util-lib-2
[thirdparty/systemd.git] / src / test / test-util.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7 Copyright 2013 Thomas H.P. Andersen
8
9 systemd is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
12 (at your option) any later version.
13
14 systemd is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Lesser General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <locale.h>
26 #include <math.h>
27 #include <signal.h>
28 #include <string.h>
29 #include <sys/types.h>
30 #include <sys/wait.h>
31 #include <sys/xattr.h>
32 #include <unistd.h>
33
34 #include "conf-parser.h"
35 #include "cpu-set-util.h"
36 #include "def.h"
37 #include "escape.h"
38 #include "fd-util.h"
39 #include "fileio.h"
40 #include "io-util.h"
41 #include "mkdir.h"
42 #include "process-util.h"
43 #include "rm-rf.h"
44 #include "signal-util.h"
45 #include "string-util.h"
46 #include "strv.h"
47 #include "util.h"
48 #include "virt.h"
49 #include "user-util.h"
50
51 static void test_streq_ptr(void) {
52 assert_se(streq_ptr(NULL, NULL));
53 assert_se(!streq_ptr("abc", "cdef"));
54 }
55
56 static void test_align_power2(void) {
57 unsigned long i, p2;
58
59 assert_se(ALIGN_POWER2(0) == 0);
60 assert_se(ALIGN_POWER2(1) == 1);
61 assert_se(ALIGN_POWER2(2) == 2);
62 assert_se(ALIGN_POWER2(3) == 4);
63 assert_se(ALIGN_POWER2(12) == 16);
64
65 assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
66 assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
67 assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
68 assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
69 assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
70
71 for (i = 1; i < 131071; ++i) {
72 for (p2 = 1; p2 < i; p2 <<= 1)
73 /* empty */ ;
74
75 assert_se(ALIGN_POWER2(i) == p2);
76 }
77
78 for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
79 for (p2 = 1; p2 && p2 < i; p2 <<= 1)
80 /* empty */ ;
81
82 assert_se(ALIGN_POWER2(i) == p2);
83 }
84 }
85
86 static void test_max(void) {
87 static const struct {
88 int a;
89 int b[CONST_MAX(10, 100)];
90 } val1 = {
91 .a = CONST_MAX(10, 100),
92 };
93 int d = 0;
94
95 assert_cc(sizeof(val1.b) == sizeof(int) * 100);
96
97 /* CONST_MAX returns (void) instead of a value if the passed arguments
98 * are not of the same type or not constant expressions. */
99 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
100 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
101
102 assert_se(val1.a == 100);
103 assert_se(MAX(++d, 0) == 1);
104 assert_se(d == 1);
105
106 assert_cc(MAXSIZE(char[3], uint16_t) == 3);
107 assert_cc(MAXSIZE(char[3], uint32_t) == 4);
108 assert_cc(MAXSIZE(char, long) == sizeof(long));
109
110 assert_se(MAX(-5, 5) == 5);
111 assert_se(MAX(5, 5) == 5);
112 assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
113 assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
114 assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
115 assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
116 assert_se(LESS_BY(8, 4) == 4);
117 assert_se(LESS_BY(8, 8) == 0);
118 assert_se(LESS_BY(4, 8) == 0);
119 assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
120 assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
121 assert_se(CLAMP(-5, 0, 1) == 0);
122 assert_se(CLAMP(5, 0, 1) == 1);
123 assert_se(CLAMP(5, -10, 1) == 1);
124 assert_se(CLAMP(5, -10, 10) == 5);
125 assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
126 }
127
128 static void test_container_of(void) {
129 struct mytype {
130 uint8_t pad1[3];
131 uint64_t v1;
132 uint8_t pad2[2];
133 uint32_t v2;
134 } _packed_ myval = { };
135
136 assert_cc(sizeof(myval) == 17);
137 assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
138 assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
139 assert_se(container_of(&container_of(&myval.v2,
140 struct mytype,
141 v2)->v1,
142 struct mytype,
143 v1) == &myval);
144 }
145
146 static void test_alloca(void) {
147 static const uint8_t zero[997] = { };
148 char *t;
149
150 t = alloca_align(17, 512);
151 assert_se(!((uintptr_t)t & 0xff));
152 memzero(t, 17);
153
154 t = alloca0_align(997, 1024);
155 assert_se(!((uintptr_t)t & 0x1ff));
156 assert_se(!memcmp(t, zero, 997));
157 }
158
159 static void test_div_round_up(void) {
160 int div;
161
162 /* basic tests */
163 assert_se(DIV_ROUND_UP(0, 8) == 0);
164 assert_se(DIV_ROUND_UP(1, 8) == 1);
165 assert_se(DIV_ROUND_UP(8, 8) == 1);
166 assert_se(DIV_ROUND_UP(12, 8) == 2);
167 assert_se(DIV_ROUND_UP(16, 8) == 2);
168
169 /* test multiple evaluation */
170 div = 0;
171 assert_se(DIV_ROUND_UP(div++, 8) == 0 && div == 1);
172 assert_se(DIV_ROUND_UP(++div, 8) == 1 && div == 2);
173 assert_se(DIV_ROUND_UP(8, div++) == 4 && div == 3);
174 assert_se(DIV_ROUND_UP(8, ++div) == 2 && div == 4);
175
176 /* overflow test with exact division */
177 assert_se(sizeof(0U) == 4);
178 assert_se(0xfffffffaU % 10U == 0U);
179 assert_se(0xfffffffaU / 10U == 429496729U);
180 assert_se(DIV_ROUND_UP(0xfffffffaU, 10U) == 429496729U);
181 assert_se((0xfffffffaU + 10U - 1U) / 10U == 0U);
182 assert_se(0xfffffffaU / 10U + !!(0xfffffffaU % 10U) == 429496729U);
183
184 /* overflow test with rounded division */
185 assert_se(0xfffffffdU % 10U == 3U);
186 assert_se(0xfffffffdU / 10U == 429496729U);
187 assert_se(DIV_ROUND_UP(0xfffffffdU, 10U) == 429496730U);
188 assert_se((0xfffffffdU + 10U - 1U) / 10U == 0U);
189 assert_se(0xfffffffdU / 10U + !!(0xfffffffdU % 10U) == 429496730U);
190 }
191
192 static void test_first_word(void) {
193 assert_se(first_word("Hello", ""));
194 assert_se(first_word("Hello", "Hello"));
195 assert_se(first_word("Hello world", "Hello"));
196 assert_se(first_word("Hello\tworld", "Hello"));
197 assert_se(first_word("Hello\nworld", "Hello"));
198 assert_se(first_word("Hello\rworld", "Hello"));
199 assert_se(first_word("Hello ", "Hello"));
200
201 assert_se(!first_word("Hello", "Hellooo"));
202 assert_se(!first_word("Hello", "xxxxx"));
203 assert_se(!first_word("Hellooo", "Hello"));
204 }
205
206 static void test_close_many(void) {
207 int fds[3];
208 char name0[] = "/tmp/test-close-many.XXXXXX";
209 char name1[] = "/tmp/test-close-many.XXXXXX";
210 char name2[] = "/tmp/test-close-many.XXXXXX";
211
212 fds[0] = mkostemp_safe(name0, O_RDWR|O_CLOEXEC);
213 fds[1] = mkostemp_safe(name1, O_RDWR|O_CLOEXEC);
214 fds[2] = mkostemp_safe(name2, O_RDWR|O_CLOEXEC);
215
216 close_many(fds, 2);
217
218 assert_se(fcntl(fds[0], F_GETFD) == -1);
219 assert_se(fcntl(fds[1], F_GETFD) == -1);
220 assert_se(fcntl(fds[2], F_GETFD) >= 0);
221
222 safe_close(fds[2]);
223
224 unlink(name0);
225 unlink(name1);
226 unlink(name2);
227 }
228
229 static void test_parse_boolean(void) {
230 assert_se(parse_boolean("1") == 1);
231 assert_se(parse_boolean("y") == 1);
232 assert_se(parse_boolean("Y") == 1);
233 assert_se(parse_boolean("yes") == 1);
234 assert_se(parse_boolean("YES") == 1);
235 assert_se(parse_boolean("true") == 1);
236 assert_se(parse_boolean("TRUE") == 1);
237 assert_se(parse_boolean("on") == 1);
238 assert_se(parse_boolean("ON") == 1);
239
240 assert_se(parse_boolean("0") == 0);
241 assert_se(parse_boolean("n") == 0);
242 assert_se(parse_boolean("N") == 0);
243 assert_se(parse_boolean("no") == 0);
244 assert_se(parse_boolean("NO") == 0);
245 assert_se(parse_boolean("false") == 0);
246 assert_se(parse_boolean("FALSE") == 0);
247 assert_se(parse_boolean("off") == 0);
248 assert_se(parse_boolean("OFF") == 0);
249
250 assert_se(parse_boolean("garbage") < 0);
251 assert_se(parse_boolean("") < 0);
252 assert_se(parse_boolean("full") < 0);
253 }
254
255 static void test_parse_pid(void) {
256 int r;
257 pid_t pid;
258
259 r = parse_pid("100", &pid);
260 assert_se(r == 0);
261 assert_se(pid == 100);
262
263 r = parse_pid("0x7FFFFFFF", &pid);
264 assert_se(r == 0);
265 assert_se(pid == 2147483647);
266
267 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
268 r = parse_pid("0", &pid);
269 assert_se(r == -ERANGE);
270 assert_se(pid == 65);
271
272 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
273 r = parse_pid("-100", &pid);
274 assert_se(r == -ERANGE);
275 assert_se(pid == 65);
276
277 pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
278 r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
279 assert_se(r == -ERANGE);
280 assert_se(pid == 65);
281
282 r = parse_pid("junk", &pid);
283 assert_se(r == -EINVAL);
284 }
285
286 static void test_parse_uid(void) {
287 int r;
288 uid_t uid;
289
290 r = parse_uid("100", &uid);
291 assert_se(r == 0);
292 assert_se(uid == 100);
293
294 r = parse_uid("65535", &uid);
295 assert_se(r == -ENXIO);
296
297 r = parse_uid("asdsdas", &uid);
298 assert_se(r == -EINVAL);
299 }
300
301 static void test_safe_atou16(void) {
302 int r;
303 uint16_t l;
304
305 r = safe_atou16("12345", &l);
306 assert_se(r == 0);
307 assert_se(l == 12345);
308
309 r = safe_atou16("123456", &l);
310 assert_se(r == -ERANGE);
311
312 r = safe_atou16("junk", &l);
313 assert_se(r == -EINVAL);
314 }
315
316 static void test_safe_atoi16(void) {
317 int r;
318 int16_t l;
319
320 r = safe_atoi16("-12345", &l);
321 assert_se(r == 0);
322 assert_se(l == -12345);
323
324 r = safe_atoi16("36536", &l);
325 assert_se(r == -ERANGE);
326
327 r = safe_atoi16("junk", &l);
328 assert_se(r == -EINVAL);
329 }
330
331 static void test_safe_atolli(void) {
332 int r;
333 long long l;
334
335 r = safe_atolli("12345", &l);
336 assert_se(r == 0);
337 assert_se(l == 12345);
338
339 r = safe_atolli("junk", &l);
340 assert_se(r == -EINVAL);
341 }
342
343 static void test_safe_atod(void) {
344 int r;
345 double d;
346 char *e;
347
348 r = safe_atod("junk", &d);
349 assert_se(r == -EINVAL);
350
351 r = safe_atod("0.2244", &d);
352 assert_se(r == 0);
353 assert_se(fabs(d - 0.2244) < 0.000001);
354
355 r = safe_atod("0,5", &d);
356 assert_se(r == -EINVAL);
357
358 errno = 0;
359 strtod("0,5", &e);
360 assert_se(*e == ',');
361
362 /* Check if this really is locale independent */
363 if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
364
365 r = safe_atod("0.2244", &d);
366 assert_se(r == 0);
367 assert_se(fabs(d - 0.2244) < 0.000001);
368
369 r = safe_atod("0,5", &d);
370 assert_se(r == -EINVAL);
371
372 errno = 0;
373 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
374 }
375
376 /* And check again, reset */
377 assert_se(setlocale(LC_NUMERIC, "C"));
378
379 r = safe_atod("0.2244", &d);
380 assert_se(r == 0);
381 assert_se(fabs(d - 0.2244) < 0.000001);
382
383 r = safe_atod("0,5", &d);
384 assert_se(r == -EINVAL);
385
386 errno = 0;
387 strtod("0,5", &e);
388 assert_se(*e == ',');
389 }
390
391 static void test_strappend(void) {
392 _cleanup_free_ char *t1, *t2, *t3, *t4;
393
394 t1 = strappend(NULL, NULL);
395 assert_se(streq(t1, ""));
396
397 t2 = strappend(NULL, "suf");
398 assert_se(streq(t2, "suf"));
399
400 t3 = strappend("pre", NULL);
401 assert_se(streq(t3, "pre"));
402
403 t4 = strappend("pre", "suf");
404 assert_se(streq(t4, "presuf"));
405 }
406
407 static void test_strstrip(void) {
408 char *r;
409 char input[] = " hello, waldo. ";
410
411 r = strstrip(input);
412 assert_se(streq(r, "hello, waldo."));
413 }
414
415 static void test_delete_chars(void) {
416 char *r;
417 char input[] = " hello, waldo. abc";
418
419 r = delete_chars(input, WHITESPACE);
420 assert_se(streq(r, "hello,waldo.abc"));
421 }
422
423 static void test_in_charset(void) {
424 assert_se(in_charset("dddaaabbbcccc", "abcd"));
425 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
426 }
427
428 static void test_hexchar(void) {
429 assert_se(hexchar(0xa) == 'a');
430 assert_se(hexchar(0x0) == '0');
431 }
432
433 static void test_unhexchar(void) {
434 assert_se(unhexchar('a') == 0xA);
435 assert_se(unhexchar('A') == 0xA);
436 assert_se(unhexchar('0') == 0x0);
437 }
438
439 static void test_base32hexchar(void) {
440 assert_se(base32hexchar(0) == '0');
441 assert_se(base32hexchar(9) == '9');
442 assert_se(base32hexchar(10) == 'A');
443 assert_se(base32hexchar(31) == 'V');
444 }
445
446 static void test_unbase32hexchar(void) {
447 assert_se(unbase32hexchar('0') == 0);
448 assert_se(unbase32hexchar('9') == 9);
449 assert_se(unbase32hexchar('A') == 10);
450 assert_se(unbase32hexchar('V') == 31);
451 assert_se(unbase32hexchar('=') == -EINVAL);
452 }
453
454 static void test_base64char(void) {
455 assert_se(base64char(0) == 'A');
456 assert_se(base64char(26) == 'a');
457 assert_se(base64char(63) == '/');
458 }
459
460 static void test_unbase64char(void) {
461 assert_se(unbase64char('A') == 0);
462 assert_se(unbase64char('Z') == 25);
463 assert_se(unbase64char('a') == 26);
464 assert_se(unbase64char('z') == 51);
465 assert_se(unbase64char('0') == 52);
466 assert_se(unbase64char('9') == 61);
467 assert_se(unbase64char('+') == 62);
468 assert_se(unbase64char('/') == 63);
469 assert_se(unbase64char('=') == -EINVAL);
470 }
471
472 static void test_octchar(void) {
473 assert_se(octchar(00) == '0');
474 assert_se(octchar(07) == '7');
475 }
476
477 static void test_unoctchar(void) {
478 assert_se(unoctchar('0') == 00);
479 assert_se(unoctchar('7') == 07);
480 }
481
482 static void test_decchar(void) {
483 assert_se(decchar(0) == '0');
484 assert_se(decchar(9) == '9');
485 }
486
487 static void test_undecchar(void) {
488 assert_se(undecchar('0') == 0);
489 assert_se(undecchar('9') == 9);
490 }
491
492 static void test_unhexmem(void) {
493 const char *hex = "efa214921";
494 const char *hex_invalid = "efa214921o";
495 _cleanup_free_ char *hex2 = NULL;
496 _cleanup_free_ void *mem = NULL;
497 size_t len;
498
499 assert_se(unhexmem(hex, strlen(hex), &mem, &len) == 0);
500 assert_se(unhexmem(hex, strlen(hex) + 1, &mem, &len) == -EINVAL);
501 assert_se(unhexmem(hex_invalid, strlen(hex_invalid), &mem, &len) == -EINVAL);
502
503 assert_se((hex2 = hexmem(mem, len)));
504
505 free(mem);
506
507 assert_se(memcmp(hex, hex2, strlen(hex)) == 0);
508
509 free(hex2);
510
511 assert_se(unhexmem(hex, strlen(hex) - 1, &mem, &len) == 0);
512 assert_se((hex2 = hexmem(mem, len)));
513 assert_se(memcmp(hex, hex2, strlen(hex) - 1) == 0);
514 }
515
516 /* https://tools.ietf.org/html/rfc4648#section-10 */
517 static void test_base32hexmem(void) {
518 char *b32;
519
520 b32 = base32hexmem("", strlen(""), true);
521 assert_se(b32);
522 assert_se(streq(b32, ""));
523 free(b32);
524
525 b32 = base32hexmem("f", strlen("f"), true);
526 assert_se(b32);
527 assert_se(streq(b32, "CO======"));
528 free(b32);
529
530 b32 = base32hexmem("fo", strlen("fo"), true);
531 assert_se(b32);
532 assert_se(streq(b32, "CPNG===="));
533 free(b32);
534
535 b32 = base32hexmem("foo", strlen("foo"), true);
536 assert_se(b32);
537 assert_se(streq(b32, "CPNMU==="));
538 free(b32);
539
540 b32 = base32hexmem("foob", strlen("foob"), true);
541 assert_se(b32);
542 assert_se(streq(b32, "CPNMUOG="));
543 free(b32);
544
545 b32 = base32hexmem("fooba", strlen("fooba"), true);
546 assert_se(b32);
547 assert_se(streq(b32, "CPNMUOJ1"));
548 free(b32);
549
550 b32 = base32hexmem("foobar", strlen("foobar"), true);
551 assert_se(b32);
552 assert_se(streq(b32, "CPNMUOJ1E8======"));
553 free(b32);
554
555 b32 = base32hexmem("", strlen(""), false);
556 assert_se(b32);
557 assert_se(streq(b32, ""));
558 free(b32);
559
560 b32 = base32hexmem("f", strlen("f"), false);
561 assert_se(b32);
562 assert_se(streq(b32, "CO"));
563 free(b32);
564
565 b32 = base32hexmem("fo", strlen("fo"), false);
566 assert_se(b32);
567 assert_se(streq(b32, "CPNG"));
568 free(b32);
569
570 b32 = base32hexmem("foo", strlen("foo"), false);
571 assert_se(b32);
572 assert_se(streq(b32, "CPNMU"));
573 free(b32);
574
575 b32 = base32hexmem("foob", strlen("foob"), false);
576 assert_se(b32);
577 assert_se(streq(b32, "CPNMUOG"));
578 free(b32);
579
580 b32 = base32hexmem("fooba", strlen("fooba"), false);
581 assert_se(b32);
582 assert_se(streq(b32, "CPNMUOJ1"));
583 free(b32);
584
585 b32 = base32hexmem("foobar", strlen("foobar"), false);
586 assert_se(b32);
587 assert_se(streq(b32, "CPNMUOJ1E8"));
588 free(b32);
589 }
590
591 static void test_unbase32hexmem(void) {
592 void *mem;
593 size_t len;
594
595 assert_se(unbase32hexmem("", strlen(""), true, &mem, &len) == 0);
596 assert_se(streq(strndupa(mem, len), ""));
597 free(mem);
598
599 assert_se(unbase32hexmem("CO======", strlen("CO======"), true, &mem, &len) == 0);
600 assert_se(streq(strndupa(mem, len), "f"));
601 free(mem);
602
603 assert_se(unbase32hexmem("CPNG====", strlen("CPNG===="), true, &mem, &len) == 0);
604 assert_se(streq(strndupa(mem, len), "fo"));
605 free(mem);
606
607 assert_se(unbase32hexmem("CPNMU===", strlen("CPNMU==="), true, &mem, &len) == 0);
608 assert_se(streq(strndupa(mem, len), "foo"));
609 free(mem);
610
611 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), true, &mem, &len) == 0);
612 assert_se(streq(strndupa(mem, len), "foob"));
613 free(mem);
614
615 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == 0);
616 assert_se(streq(strndupa(mem, len), "fooba"));
617 free(mem);
618
619 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), true, &mem, &len) == 0);
620 assert_se(streq(strndupa(mem, len), "foobar"));
621 free(mem);
622
623 assert_se(unbase32hexmem("A", strlen("A"), true, &mem, &len) == -EINVAL);
624 assert_se(unbase32hexmem("A=======", strlen("A======="), true, &mem, &len) == -EINVAL);
625 assert_se(unbase32hexmem("AAA=====", strlen("AAA====="), true, &mem, &len) == -EINVAL);
626 assert_se(unbase32hexmem("AAAAAA==", strlen("AAAAAA=="), true, &mem, &len) == -EINVAL);
627 assert_se(unbase32hexmem("AB======", strlen("AB======"), true, &mem, &len) == -EINVAL);
628 assert_se(unbase32hexmem("AAAB====", strlen("AAAB===="), true, &mem, &len) == -EINVAL);
629 assert_se(unbase32hexmem("AAAAB===", strlen("AAAAB==="), true, &mem, &len) == -EINVAL);
630 assert_se(unbase32hexmem("AAAAAAB=", strlen("AAAAAAB="), true, &mem, &len) == -EINVAL);
631
632 assert_se(unbase32hexmem("XPNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
633 assert_se(unbase32hexmem("CXNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
634 assert_se(unbase32hexmem("CPXMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
635 assert_se(unbase32hexmem("CPNXUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
636 assert_se(unbase32hexmem("CPNMXOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
637 assert_se(unbase32hexmem("CPNMUXJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
638 assert_se(unbase32hexmem("CPNMUOX1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
639 assert_se(unbase32hexmem("CPNMUOJX", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
640
641 assert_se(unbase32hexmem("", strlen(""), false, &mem, &len) == 0);
642 assert_se(streq(strndupa(mem, len), ""));
643 free(mem);
644
645 assert_se(unbase32hexmem("CO", strlen("CO"), false, &mem, &len) == 0);
646 assert_se(streq(strndupa(mem, len), "f"));
647 free(mem);
648
649 assert_se(unbase32hexmem("CPNG", strlen("CPNG"), false, &mem, &len) == 0);
650 assert_se(streq(strndupa(mem, len), "fo"));
651 free(mem);
652
653 assert_se(unbase32hexmem("CPNMU", strlen("CPNMU"), false, &mem, &len) == 0);
654 assert_se(streq(strndupa(mem, len), "foo"));
655 free(mem);
656
657 assert_se(unbase32hexmem("CPNMUOG", strlen("CPNMUOG"), false, &mem, &len) == 0);
658 assert_se(streq(strndupa(mem, len), "foob"));
659 free(mem);
660
661 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), false, &mem, &len) == 0);
662 assert_se(streq(strndupa(mem, len), "fooba"));
663 free(mem);
664
665 assert_se(unbase32hexmem("CPNMUOJ1E8", strlen("CPNMUOJ1E8"), false, &mem, &len) == 0);
666 assert_se(streq(strndupa(mem, len), "foobar"));
667 free(mem);
668
669 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), false, &mem, &len) == -EINVAL);
670 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), false, &mem, &len) == -EINVAL);
671 assert_se(unbase32hexmem("A", strlen("A"), false, &mem, &len) == -EINVAL);
672 assert_se(unbase32hexmem("A", strlen("A"), false, &mem, &len) == -EINVAL);
673 assert_se(unbase32hexmem("AAA", strlen("AAA"), false, &mem, &len) == -EINVAL);
674 assert_se(unbase32hexmem("AAAAAA", strlen("AAAAAA"), false, &mem, &len) == -EINVAL);
675 assert_se(unbase32hexmem("AB", strlen("AB"), false, &mem, &len) == -EINVAL);
676 assert_se(unbase32hexmem("AAAB", strlen("AAAB"), false, &mem, &len) == -EINVAL);
677 assert_se(unbase32hexmem("AAAAB", strlen("AAAAB"), false, &mem, &len) == -EINVAL);
678 assert_se(unbase32hexmem("AAAAAAB", strlen("AAAAAAB"), false, &mem, &len) == -EINVAL);
679 }
680
681 /* https://tools.ietf.org/html/rfc4648#section-10 */
682 static void test_base64mem(void) {
683 char *b64;
684
685 b64 = base64mem("", strlen(""));
686 assert_se(b64);
687 assert_se(streq(b64, ""));
688 free(b64);
689
690 b64 = base64mem("f", strlen("f"));
691 assert_se(b64);
692 assert_se(streq(b64, "Zg=="));
693 free(b64);
694
695 b64 = base64mem("fo", strlen("fo"));
696 assert_se(b64);
697 assert_se(streq(b64, "Zm8="));
698 free(b64);
699
700 b64 = base64mem("foo", strlen("foo"));
701 assert_se(b64);
702 assert_se(streq(b64, "Zm9v"));
703 free(b64);
704
705 b64 = base64mem("foob", strlen("foob"));
706 assert_se(b64);
707 assert_se(streq(b64, "Zm9vYg=="));
708 free(b64);
709
710 b64 = base64mem("fooba", strlen("fooba"));
711 assert_se(b64);
712 assert_se(streq(b64, "Zm9vYmE="));
713 free(b64);
714
715 b64 = base64mem("foobar", strlen("foobar"));
716 assert_se(b64);
717 assert_se(streq(b64, "Zm9vYmFy"));
718 free(b64);
719 }
720
721 static void test_unbase64mem(void) {
722 void *mem;
723 size_t len;
724
725 assert_se(unbase64mem("", strlen(""), &mem, &len) == 0);
726 assert_se(streq(strndupa(mem, len), ""));
727 free(mem);
728
729 assert_se(unbase64mem("Zg==", strlen("Zg=="), &mem, &len) == 0);
730 assert_se(streq(strndupa(mem, len), "f"));
731 free(mem);
732
733 assert_se(unbase64mem("Zm8=", strlen("Zm8="), &mem, &len) == 0);
734 assert_se(streq(strndupa(mem, len), "fo"));
735 free(mem);
736
737 assert_se(unbase64mem("Zm9v", strlen("Zm9v"), &mem, &len) == 0);
738 assert_se(streq(strndupa(mem, len), "foo"));
739 free(mem);
740
741 assert_se(unbase64mem("Zm9vYg==", strlen("Zm9vYg=="), &mem, &len) == 0);
742 assert_se(streq(strndupa(mem, len), "foob"));
743 free(mem);
744
745 assert_se(unbase64mem("Zm9vYmE=", strlen("Zm9vYmE="), &mem, &len) == 0);
746 assert_se(streq(strndupa(mem, len), "fooba"));
747 free(mem);
748
749 assert_se(unbase64mem("Zm9vYmFy", strlen("Zm9vYmFy"), &mem, &len) == 0);
750 assert_se(streq(strndupa(mem, len), "foobar"));
751 free(mem);
752
753 assert_se(unbase64mem("A", strlen("A"), &mem, &len) == -EINVAL);
754 assert_se(unbase64mem("A====", strlen("A===="), &mem, &len) == -EINVAL);
755 assert_se(unbase64mem("AAB==", strlen("AAB=="), &mem, &len) == -EINVAL);
756 assert_se(unbase64mem("AAAB=", strlen("AAAB="), &mem, &len) == -EINVAL);
757 }
758
759 static void test_cescape(void) {
760 _cleanup_free_ char *escaped;
761
762 assert_se(escaped = cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
763 assert_se(streq(escaped, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
764 }
765
766 static void test_cunescape(void) {
767 _cleanup_free_ char *unescaped;
768
769 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped) < 0);
770 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX, &unescaped) >= 0);
771 assert_se(streq_ptr(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
772 unescaped = mfree(unescaped);
773
774 /* incomplete sequences */
775 assert_se(cunescape("\\x0", 0, &unescaped) < 0);
776 assert_se(cunescape("\\x0", UNESCAPE_RELAX, &unescaped) >= 0);
777 assert_se(streq_ptr(unescaped, "\\x0"));
778 unescaped = mfree(unescaped);
779
780 assert_se(cunescape("\\x", 0, &unescaped) < 0);
781 assert_se(cunescape("\\x", UNESCAPE_RELAX, &unescaped) >= 0);
782 assert_se(streq_ptr(unescaped, "\\x"));
783 unescaped = mfree(unescaped);
784
785 assert_se(cunescape("\\", 0, &unescaped) < 0);
786 assert_se(cunescape("\\", UNESCAPE_RELAX, &unescaped) >= 0);
787 assert_se(streq_ptr(unescaped, "\\"));
788 unescaped = mfree(unescaped);
789
790 assert_se(cunescape("\\11", 0, &unescaped) < 0);
791 assert_se(cunescape("\\11", UNESCAPE_RELAX, &unescaped) >= 0);
792 assert_se(streq_ptr(unescaped, "\\11"));
793 unescaped = mfree(unescaped);
794
795 assert_se(cunescape("\\1", 0, &unescaped) < 0);
796 assert_se(cunescape("\\1", UNESCAPE_RELAX, &unescaped) >= 0);
797 assert_se(streq_ptr(unescaped, "\\1"));
798 unescaped = mfree(unescaped);
799
800 assert_se(cunescape("\\u0000", 0, &unescaped) < 0);
801 assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX, &unescaped) >= 0);
802 assert_se(streq_ptr(unescaped, "ßßΠA"));
803 unescaped = mfree(unescaped);
804
805 assert_se(cunescape("\\073", 0, &unescaped) >= 0);
806 assert_se(streq_ptr(unescaped, ";"));
807 }
808
809 static void test_foreach_word(void) {
810 const char *word, *state;
811 size_t l;
812 int i = 0;
813 const char test[] = "test abc d\te f ";
814 const char * const expected[] = {
815 "test",
816 "abc",
817 "d",
818 "e",
819 "f",
820 "",
821 NULL
822 };
823
824 FOREACH_WORD(word, l, test, state)
825 assert_se(strneq(expected[i++], word, l));
826 }
827
828 static void check(const char *test, char** expected, bool trailing) {
829 const char *word, *state;
830 size_t l;
831 int i = 0;
832
833 printf("<<<%s>>>\n", test);
834 FOREACH_WORD_QUOTED(word, l, test, state) {
835 _cleanup_free_ char *t = NULL;
836
837 assert_se(t = strndup(word, l));
838 assert_se(strneq(expected[i++], word, l));
839 printf("<%s>\n", t);
840 }
841 printf("<<<%s>>>\n", state);
842 assert_se(expected[i] == NULL);
843 assert_se(isempty(state) == !trailing);
844 }
845
846 static void test_foreach_word_quoted(void) {
847 check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
848 STRV_MAKE("test",
849 "a",
850 "b",
851 "c",
852 "d",
853 "e",
854 "",
855 "",
856 "hhh",
857 "",
858 "",
859 "a b c"),
860 false);
861
862 check("test \"xxx",
863 STRV_MAKE("test"),
864 true);
865
866 check("test\\",
867 STRV_MAKE_EMPTY,
868 true);
869 }
870
871 static void test_memdup_multiply(void) {
872 int org[] = {1, 2, 3};
873 int *dup;
874
875 dup = (int*)memdup_multiply(org, sizeof(int), 3);
876
877 assert_se(dup);
878 assert_se(dup[0] == 1);
879 assert_se(dup[1] == 2);
880 assert_se(dup[2] == 3);
881 free(dup);
882 }
883
884 static void test_u64log2(void) {
885 assert_se(u64log2(0) == 0);
886 assert_se(u64log2(8) == 3);
887 assert_se(u64log2(9) == 3);
888 assert_se(u64log2(15) == 3);
889 assert_se(u64log2(16) == 4);
890 assert_se(u64log2(1024*1024) == 20);
891 assert_se(u64log2(1024*1024+5) == 20);
892 }
893
894 static void test_protect_errno(void) {
895 errno = 12;
896 {
897 PROTECT_ERRNO;
898 errno = 11;
899 }
900 assert_se(errno == 12);
901 }
902
903 static void test_parse_size(void) {
904 uint64_t bytes;
905
906 assert_se(parse_size("111", 1024, &bytes) == 0);
907 assert_se(bytes == 111);
908
909 assert_se(parse_size("111.4", 1024, &bytes) == 0);
910 assert_se(bytes == 111);
911
912 assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
913 assert_se(bytes == 112);
914
915 assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
916 assert_se(bytes == 112);
917
918 assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
919 assert_se(bytes == 3*1024 + 512);
920
921 assert_se(parse_size("3. K", 1024, &bytes) == 0);
922 assert_se(bytes == 3*1024);
923
924 assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
925 assert_se(bytes == 3*1024);
926
927 assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
928
929 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
930 assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
931
932 assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
933
934 assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
935 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
936
937 assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
938 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
939
940 assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
941
942 assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
943 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
944
945 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
946 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
947
948 assert_se(parse_size("12P", 1024, &bytes) == 0);
949 assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
950
951 assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
952
953 assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
954 assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
955
956 assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
957
958 assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
959
960 assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
961
962 assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
963 assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
964 assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
965
966 assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
967
968 assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
969 }
970
971 static void test_parse_cpu_set(void) {
972 cpu_set_t *c = NULL;
973 int ncpus;
974 int cpu;
975
976 /* Simple range (from CPUAffinity example) */
977 ncpus = parse_cpu_set_and_warn("1 2", &c, NULL, "fake", 1, "CPUAffinity");
978 assert_se(ncpus >= 1024);
979 assert_se(CPU_ISSET_S(1, CPU_ALLOC_SIZE(ncpus), c));
980 assert_se(CPU_ISSET_S(2, CPU_ALLOC_SIZE(ncpus), c));
981 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 2);
982 c = mfree(c);
983
984 /* A more interesting range */
985 ncpus = parse_cpu_set_and_warn("0 1 2 3 8 9 10 11", &c, NULL, "fake", 1, "CPUAffinity");
986 assert_se(ncpus >= 1024);
987 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
988 for (cpu = 0; cpu < 4; cpu++)
989 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
990 for (cpu = 8; cpu < 12; cpu++)
991 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
992 c = mfree(c);
993
994 /* Quoted strings */
995 ncpus = parse_cpu_set_and_warn("8 '9' 10 \"11\"", &c, NULL, "fake", 1, "CPUAffinity");
996 assert_se(ncpus >= 1024);
997 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 4);
998 for (cpu = 8; cpu < 12; cpu++)
999 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
1000 c = mfree(c);
1001
1002 /* Use commas as separators */
1003 ncpus = parse_cpu_set_and_warn("0,1,2,3 8,9,10,11", &c, NULL, "fake", 1, "CPUAffinity");
1004 assert_se(ncpus < 0);
1005 assert_se(!c);
1006
1007 /* Ranges */
1008 ncpus = parse_cpu_set_and_warn("0-3,8-11", &c, NULL, "fake", 1, "CPUAffinity");
1009 assert_se(ncpus < 0);
1010 assert_se(!c);
1011
1012 /* Garbage */
1013 ncpus = parse_cpu_set_and_warn("0 1 2 3 garbage", &c, NULL, "fake", 1, "CPUAffinity");
1014 assert_se(ncpus < 0);
1015 assert_se(!c);
1016
1017 /* Empty string */
1018 c = NULL;
1019 ncpus = parse_cpu_set_and_warn("", &c, NULL, "fake", 1, "CPUAffinity");
1020 assert_se(ncpus == 0); /* empty string returns 0 */
1021 assert_se(!c);
1022
1023 /* Runnaway quoted string */
1024 ncpus = parse_cpu_set_and_warn("0 1 2 3 \"4 5 6 7 ", &c, NULL, "fake", 1, "CPUAffinity");
1025 assert_se(ncpus < 0);
1026 assert_se(!c);
1027 }
1028
1029 static void test_config_parse_iec_uint64(void) {
1030 uint64_t offset = 0;
1031 assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
1032 assert_se(offset == 4 * 1024 * 1024);
1033
1034 assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset, NULL) == 0);
1035 }
1036
1037 static void test_strextend(void) {
1038 _cleanup_free_ char *str = strdup("0123");
1039 strextend(&str, "456", "78", "9", NULL);
1040 assert_se(streq(str, "0123456789"));
1041 }
1042
1043 static void test_strrep(void) {
1044 _cleanup_free_ char *one, *three, *zero;
1045 one = strrep("waldo", 1);
1046 three = strrep("waldo", 3);
1047 zero = strrep("waldo", 0);
1048
1049 assert_se(streq(one, "waldo"));
1050 assert_se(streq(three, "waldowaldowaldo"));
1051 assert_se(streq(zero, ""));
1052 }
1053
1054 static void test_split_pair(void) {
1055 _cleanup_free_ char *a = NULL, *b = NULL;
1056
1057 assert_se(split_pair("", "", &a, &b) == -EINVAL);
1058 assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
1059 assert_se(split_pair("", "=", &a, &b) == -EINVAL);
1060 assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
1061 assert_se(streq(a, "foo"));
1062 assert_se(streq(b, "bar"));
1063 free(a);
1064 free(b);
1065 assert_se(split_pair("==", "==", &a, &b) >= 0);
1066 assert_se(streq(a, ""));
1067 assert_se(streq(b, ""));
1068 free(a);
1069 free(b);
1070
1071 assert_se(split_pair("===", "==", &a, &b) >= 0);
1072 assert_se(streq(a, ""));
1073 assert_se(streq(b, "="));
1074 }
1075
1076 static void test_fstab_node_to_udev_node(void) {
1077 char *n;
1078
1079 n = fstab_node_to_udev_node("LABEL=applé/jack");
1080 puts(n);
1081 assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
1082 free(n);
1083
1084 n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
1085 puts(n);
1086 assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
1087 free(n);
1088
1089 n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1090 puts(n);
1091 assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1092 free(n);
1093
1094 n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1095 puts(n);
1096 assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1097 free(n);
1098
1099 n = fstab_node_to_udev_node("PONIES=awesome");
1100 puts(n);
1101 assert_se(streq(n, "PONIES=awesome"));
1102 free(n);
1103
1104 n = fstab_node_to_udev_node("/dev/xda1");
1105 puts(n);
1106 assert_se(streq(n, "/dev/xda1"));
1107 free(n);
1108 }
1109
1110 static void test_get_files_in_directory(void) {
1111 _cleanup_strv_free_ char **l = NULL, **t = NULL;
1112
1113 assert_se(get_files_in_directory("/tmp", &l) >= 0);
1114 assert_se(get_files_in_directory(".", &t) >= 0);
1115 assert_se(get_files_in_directory(".", NULL) >= 0);
1116 }
1117
1118 static void test_in_set(void) {
1119 assert_se(IN_SET(1, 1));
1120 assert_se(IN_SET(1, 1, 2, 3, 4));
1121 assert_se(IN_SET(2, 1, 2, 3, 4));
1122 assert_se(IN_SET(3, 1, 2, 3, 4));
1123 assert_se(IN_SET(4, 1, 2, 3, 4));
1124 assert_se(!IN_SET(0, 1));
1125 assert_se(!IN_SET(0, 1, 2, 3, 4));
1126 }
1127
1128 static void test_writing_tmpfile(void) {
1129 char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
1130 _cleanup_free_ char *contents = NULL;
1131 size_t size;
1132 int fd, r;
1133 struct iovec iov[3];
1134
1135 IOVEC_SET_STRING(iov[0], "abc\n");
1136 IOVEC_SET_STRING(iov[1], ALPHANUMERICAL "\n");
1137 IOVEC_SET_STRING(iov[2], "");
1138
1139 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1140 printf("tmpfile: %s", name);
1141
1142 r = writev(fd, iov, 3);
1143 assert_se(r >= 0);
1144
1145 r = read_full_file(name, &contents, &size);
1146 assert_se(r == 0);
1147 printf("contents: %s", contents);
1148 assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
1149
1150 unlink(name);
1151 }
1152
1153 static void test_hexdump(void) {
1154 uint8_t data[146];
1155 unsigned i;
1156
1157 hexdump(stdout, NULL, 0);
1158 hexdump(stdout, "", 0);
1159 hexdump(stdout, "", 1);
1160 hexdump(stdout, "x", 1);
1161 hexdump(stdout, "x", 2);
1162 hexdump(stdout, "foobar", 7);
1163 hexdump(stdout, "f\nobar", 7);
1164 hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
1165
1166 for (i = 0; i < ELEMENTSOF(data); i++)
1167 data[i] = i*2;
1168
1169 hexdump(stdout, data, sizeof(data));
1170 }
1171
1172 static void test_log2i(void) {
1173 assert_se(log2i(1) == 0);
1174 assert_se(log2i(2) == 1);
1175 assert_se(log2i(3) == 1);
1176 assert_se(log2i(4) == 2);
1177 assert_se(log2i(32) == 5);
1178 assert_se(log2i(33) == 5);
1179 assert_se(log2i(63) == 5);
1180 assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
1181 }
1182
1183 static void test_foreach_string(void) {
1184 const char * const t[] = {
1185 "foo",
1186 "bar",
1187 "waldo",
1188 NULL
1189 };
1190 const char *x;
1191 unsigned i = 0;
1192
1193 FOREACH_STRING(x, "foo", "bar", "waldo")
1194 assert_se(streq_ptr(t[i++], x));
1195
1196 assert_se(i == 3);
1197
1198 FOREACH_STRING(x, "zzz")
1199 assert_se(streq(x, "zzz"));
1200 }
1201
1202 static void test_filename_is_valid(void) {
1203 char foo[FILENAME_MAX+2];
1204 int i;
1205
1206 assert_se(!filename_is_valid(""));
1207 assert_se(!filename_is_valid("/bar/foo"));
1208 assert_se(!filename_is_valid("/"));
1209 assert_se(!filename_is_valid("."));
1210 assert_se(!filename_is_valid(".."));
1211
1212 for (i=0; i<FILENAME_MAX+1; i++)
1213 foo[i] = 'a';
1214 foo[FILENAME_MAX+1] = '\0';
1215
1216 assert_se(!filename_is_valid(foo));
1217
1218 assert_se(filename_is_valid("foo_bar-333"));
1219 assert_se(filename_is_valid("o.o"));
1220 }
1221
1222 static void test_string_has_cc(void) {
1223 assert_se(string_has_cc("abc\1", NULL));
1224 assert_se(string_has_cc("abc\x7f", NULL));
1225 assert_se(string_has_cc("abc\x7f", NULL));
1226 assert_se(string_has_cc("abc\t\x7f", "\t"));
1227 assert_se(string_has_cc("abc\t\x7f", "\t"));
1228 assert_se(string_has_cc("\x7f", "\t"));
1229 assert_se(string_has_cc("\x7f", "\t\a"));
1230
1231 assert_se(!string_has_cc("abc\t\t", "\t"));
1232 assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
1233 assert_se(!string_has_cc("a\ab\tc", "\t\a"));
1234 }
1235
1236 static void test_ascii_strlower(void) {
1237 char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
1238 assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"));
1239 }
1240
1241 static void test_files_same(void) {
1242 _cleanup_close_ int fd = -1;
1243 char name[] = "/tmp/test-files_same.XXXXXX";
1244 char name_alias[] = "/tmp/test-files_same.alias";
1245
1246 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1247 assert_se(fd >= 0);
1248 assert_se(symlink(name, name_alias) >= 0);
1249
1250 assert_se(files_same(name, name));
1251 assert_se(files_same(name, name_alias));
1252
1253 unlink(name);
1254 unlink(name_alias);
1255 }
1256
1257 static void test_is_valid_documentation_url(void) {
1258 assert_se(documentation_url_is_valid("http://www.freedesktop.org/wiki/Software/systemd"));
1259 assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
1260 assert_se(documentation_url_is_valid("file:/foo/foo"));
1261 assert_se(documentation_url_is_valid("man:systemd.special(7)"));
1262 assert_se(documentation_url_is_valid("info:bar"));
1263
1264 assert_se(!documentation_url_is_valid("foo:"));
1265 assert_se(!documentation_url_is_valid("info:"));
1266 assert_se(!documentation_url_is_valid(""));
1267 }
1268
1269 static void test_file_in_same_dir(void) {
1270 char *t;
1271
1272 t = file_in_same_dir("/", "a");
1273 assert_se(streq(t, "/a"));
1274 free(t);
1275
1276 t = file_in_same_dir("/", "/a");
1277 assert_se(streq(t, "/a"));
1278 free(t);
1279
1280 t = file_in_same_dir("", "a");
1281 assert_se(streq(t, "a"));
1282 free(t);
1283
1284 t = file_in_same_dir("a/", "a");
1285 assert_se(streq(t, "a/a"));
1286 free(t);
1287
1288 t = file_in_same_dir("bar/foo", "bar");
1289 assert_se(streq(t, "bar/bar"));
1290 free(t);
1291 }
1292
1293 static void test_endswith(void) {
1294 assert_se(endswith("foobar", "bar"));
1295 assert_se(endswith("foobar", ""));
1296 assert_se(endswith("foobar", "foobar"));
1297 assert_se(endswith("", ""));
1298
1299 assert_se(!endswith("foobar", "foo"));
1300 assert_se(!endswith("foobar", "foobarfoofoo"));
1301 }
1302
1303 static void test_endswith_no_case(void) {
1304 assert_se(endswith_no_case("fooBAR", "bar"));
1305 assert_se(endswith_no_case("foobar", ""));
1306 assert_se(endswith_no_case("foobar", "FOOBAR"));
1307 assert_se(endswith_no_case("", ""));
1308
1309 assert_se(!endswith_no_case("foobar", "FOO"));
1310 assert_se(!endswith_no_case("foobar", "FOOBARFOOFOO"));
1311 }
1312
1313 static void test_close_nointr(void) {
1314 char name[] = "/tmp/test-test-close_nointr.XXXXXX";
1315 int fd;
1316
1317 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1318 assert_se(fd >= 0);
1319 assert_se(close_nointr(fd) >= 0);
1320 assert_se(close_nointr(fd) < 0);
1321
1322 unlink(name);
1323 }
1324
1325
1326 static void test_unlink_noerrno(void) {
1327 char name[] = "/tmp/test-close_nointr.XXXXXX";
1328 int fd;
1329
1330 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1331 assert_se(fd >= 0);
1332 assert_se(close_nointr(fd) >= 0);
1333
1334 {
1335 PROTECT_ERRNO;
1336 errno = -42;
1337 assert_se(unlink_noerrno(name) >= 0);
1338 assert_se(errno == -42);
1339 assert_se(unlink_noerrno(name) < 0);
1340 assert_se(errno == -42);
1341 }
1342 }
1343
1344 static void test_readlink_and_make_absolute(void) {
1345 char tempdir[] = "/tmp/test-readlink_and_make_absolute";
1346 char name[] = "/tmp/test-readlink_and_make_absolute/original";
1347 char name2[] = "test-readlink_and_make_absolute/original";
1348 char name_alias[] = "/tmp/test-readlink_and_make_absolute-alias";
1349 char *r = NULL;
1350
1351 assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0);
1352 assert_se(touch(name) >= 0);
1353
1354 assert_se(symlink(name, name_alias) >= 0);
1355 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
1356 assert_se(streq(r, name));
1357 free(r);
1358 assert_se(unlink(name_alias) >= 0);
1359
1360 assert_se(chdir(tempdir) >= 0);
1361 assert_se(symlink(name2, name_alias) >= 0);
1362 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
1363 assert_se(streq(r, name));
1364 free(r);
1365 assert_se(unlink(name_alias) >= 0);
1366
1367 assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
1368 }
1369
1370 static void test_ignore_signals(void) {
1371 assert_se(ignore_signals(SIGINT, -1) >= 0);
1372 assert_se(kill(getpid(), SIGINT) >= 0);
1373 assert_se(ignore_signals(SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
1374 assert_se(kill(getpid(), SIGUSR1) >= 0);
1375 assert_se(kill(getpid(), SIGUSR2) >= 0);
1376 assert_se(kill(getpid(), SIGTERM) >= 0);
1377 assert_se(kill(getpid(), SIGPIPE) >= 0);
1378 assert_se(default_signals(SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
1379 }
1380
1381 static void test_strshorten(void) {
1382 char s[] = "foobar";
1383
1384 assert_se(strlen(strshorten(s, 6)) == 6);
1385 assert_se(strlen(strshorten(s, 12)) == 6);
1386 assert_se(strlen(strshorten(s, 2)) == 2);
1387 assert_se(strlen(strshorten(s, 0)) == 0);
1388 }
1389
1390 static void test_strjoina(void) {
1391 char *actual;
1392
1393 actual = strjoina("", "foo", "bar");
1394 assert_se(streq(actual, "foobar"));
1395
1396 actual = strjoina("foo", "bar", "baz");
1397 assert_se(streq(actual, "foobarbaz"));
1398
1399 actual = strjoina("foo", "", "bar", "baz");
1400 assert_se(streq(actual, "foobarbaz"));
1401
1402 actual = strjoina("foo");
1403 assert_se(streq(actual, "foo"));
1404
1405 actual = strjoina(NULL);
1406 assert_se(streq(actual, ""));
1407
1408 actual = strjoina(NULL, "foo");
1409 assert_se(streq(actual, ""));
1410
1411 actual = strjoina("foo", NULL, "bar");
1412 assert_se(streq(actual, "foo"));
1413 }
1414
1415 static void test_is_symlink(void) {
1416 char name[] = "/tmp/test-is_symlink.XXXXXX";
1417 char name_link[] = "/tmp/test-is_symlink.link";
1418 _cleanup_close_ int fd = -1;
1419
1420 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1421 assert_se(fd >= 0);
1422 assert_se(symlink(name, name_link) >= 0);
1423
1424 assert_se(is_symlink(name) == 0);
1425 assert_se(is_symlink(name_link) == 1);
1426 assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
1427
1428
1429 unlink(name);
1430 unlink(name_link);
1431 }
1432
1433 static void test_search_and_fopen(void) {
1434 const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
1435 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1436 int fd = -1;
1437 int r;
1438 FILE *f;
1439
1440 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1441 assert_se(fd >= 0);
1442 close(fd);
1443
1444 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1445 assert_se(r >= 0);
1446 fclose(f);
1447
1448 r = search_and_fopen(name, "r", NULL, dirs, &f);
1449 assert_se(r >= 0);
1450 fclose(f);
1451
1452 r = search_and_fopen(basename(name), "r", "/", dirs, &f);
1453 assert_se(r >= 0);
1454 fclose(f);
1455
1456 r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1457 assert_se(r < 0);
1458 r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1459 assert_se(r < 0);
1460
1461 r = unlink(name);
1462 assert_se(r == 0);
1463
1464 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1465 assert_se(r < 0);
1466 }
1467
1468
1469 static void test_search_and_fopen_nulstr(void) {
1470 const char dirs[] = "/tmp/foo/bar\0/tmp\0";
1471 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1472 int fd = -1;
1473 int r;
1474 FILE *f;
1475
1476 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1477 assert_se(fd >= 0);
1478 close(fd);
1479
1480 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1481 assert_se(r >= 0);
1482 fclose(f);
1483
1484 r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
1485 assert_se(r >= 0);
1486 fclose(f);
1487
1488 r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1489 assert_se(r < 0);
1490 r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1491 assert_se(r < 0);
1492
1493 r = unlink(name);
1494 assert_se(r == 0);
1495
1496 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1497 assert_se(r < 0);
1498 }
1499
1500 static void test_glob_exists(void) {
1501 char name[] = "/tmp/test-glob_exists.XXXXXX";
1502 int fd = -1;
1503 int r;
1504
1505 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1506 assert_se(fd >= 0);
1507 close(fd);
1508
1509 r = glob_exists("/tmp/test-glob_exists*");
1510 assert_se(r == 1);
1511
1512 r = unlink(name);
1513 assert_se(r == 0);
1514 r = glob_exists("/tmp/test-glob_exists*");
1515 assert_se(r == 0);
1516 }
1517
1518 static void test_execute_directory(void) {
1519 char template_lo[] = "/tmp/test-readlink_and_make_absolute-lo.XXXXXXX";
1520 char template_hi[] = "/tmp/test-readlink_and_make_absolute-hi.XXXXXXX";
1521 const char * dirs[] = {template_hi, template_lo, NULL};
1522 const char *name, *name2, *name3, *overridden, *override, *masked, *mask;
1523
1524 assert_se(mkdtemp(template_lo));
1525 assert_se(mkdtemp(template_hi));
1526
1527 name = strjoina(template_lo, "/script");
1528 name2 = strjoina(template_hi, "/script2");
1529 name3 = strjoina(template_lo, "/useless");
1530 overridden = strjoina(template_lo, "/overridden");
1531 override = strjoina(template_hi, "/overridden");
1532 masked = strjoina(template_lo, "/masked");
1533 mask = strjoina(template_hi, "/masked");
1534
1535 assert_se(write_string_file(name, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works", WRITE_STRING_FILE_CREATE) == 0);
1536 assert_se(write_string_file(name2, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2", WRITE_STRING_FILE_CREATE) == 0);
1537 assert_se(write_string_file(overridden, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
1538 assert_se(write_string_file(override, "#!/bin/sh\necho 'Executing '$0", WRITE_STRING_FILE_CREATE) == 0);
1539 assert_se(write_string_file(masked, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
1540 assert_se(symlink("/dev/null", mask) == 0);
1541 assert_se(chmod(name, 0755) == 0);
1542 assert_se(chmod(name2, 0755) == 0);
1543 assert_se(chmod(overridden, 0755) == 0);
1544 assert_se(chmod(override, 0755) == 0);
1545 assert_se(chmod(masked, 0755) == 0);
1546 assert_se(touch(name3) >= 0);
1547
1548 execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL);
1549
1550 assert_se(chdir(template_lo) == 0);
1551 assert_se(access("it_works", F_OK) >= 0);
1552 assert_se(access("failed", F_OK) < 0);
1553
1554 assert_se(chdir(template_hi) == 0);
1555 assert_se(access("it_works2", F_OK) >= 0);
1556 assert_se(access("failed", F_OK) < 0);
1557
1558 (void) rm_rf(template_lo, REMOVE_ROOT|REMOVE_PHYSICAL);
1559 (void) rm_rf(template_hi, REMOVE_ROOT|REMOVE_PHYSICAL);
1560 }
1561
1562 static void test_extract_first_word(void) {
1563 const char *p, *original;
1564 char *t;
1565
1566 p = original = "foobar waldo";
1567 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1568 assert_se(streq(t, "foobar"));
1569 free(t);
1570 assert_se(p == original + 7);
1571
1572 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1573 assert_se(streq(t, "waldo"));
1574 free(t);
1575 assert_se(isempty(p));
1576
1577 assert_se(extract_first_word(&p, &t, NULL, 0) == 0);
1578 assert_se(!t);
1579 assert_se(isempty(p));
1580
1581 p = original = "\"foobar\" \'waldo\'";
1582 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1583 assert_se(streq(t, "\"foobar\""));
1584 free(t);
1585 assert_se(p == original + 9);
1586
1587 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1588 assert_se(streq(t, "\'waldo\'"));
1589 free(t);
1590 assert_se(isempty(p));
1591
1592 assert_se(extract_first_word(&p, &t, NULL, 0) == 0);
1593 assert_se(!t);
1594 assert_se(isempty(p));
1595
1596 p = original = "\"foobar\" \'waldo\'";
1597 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
1598 assert_se(streq(t, "foobar"));
1599 free(t);
1600 assert_se(p == original + 9);
1601
1602 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
1603 assert_se(streq(t, "waldo"));
1604 free(t);
1605 assert_se(isempty(p));
1606
1607 assert_se(extract_first_word(&p, &t, NULL, 0) == 0);
1608 assert_se(!t);
1609 assert_se(isempty(p));
1610
1611 p = original = "\"";
1612 assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
1613 assert_se(streq(t, "\""));
1614 free(t);
1615 assert_se(isempty(p));
1616
1617 p = original = "\"";
1618 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) == -EINVAL);
1619 assert_se(p == original + 1);
1620
1621 p = original = "\'";
1622 assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
1623 assert_se(streq(t, "\'"));
1624 free(t);
1625 assert_se(isempty(p));
1626
1627 p = original = "\'";
1628 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) == -EINVAL);
1629 assert_se(p == original + 1);
1630
1631 p = original = "\'fooo";
1632 assert_se(extract_first_word(&p, &t, NULL, 0) == 1);
1633 assert_se(streq(t, "\'fooo"));
1634 free(t);
1635 assert_se(isempty(p));
1636
1637 p = original = "\'fooo";
1638 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) == -EINVAL);
1639 assert_se(p == original + 5);
1640
1641 p = original = "\'fooo";
1642 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX) > 0);
1643 assert_se(streq(t, "fooo"));
1644 free(t);
1645 assert_se(isempty(p));
1646
1647 p = original = "\"fooo";
1648 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX) > 0);
1649 assert_se(streq(t, "fooo"));
1650 free(t);
1651 assert_se(isempty(p));
1652
1653 p = original = "yay\'foo\'bar";
1654 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1655 assert_se(streq(t, "yay\'foo\'bar"));
1656 free(t);
1657 assert_se(isempty(p));
1658
1659 p = original = "yay\'foo\'bar";
1660 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
1661 assert_se(streq(t, "yayfoobar"));
1662 free(t);
1663 assert_se(isempty(p));
1664
1665 p = original = " foobar ";
1666 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1667 assert_se(streq(t, "foobar"));
1668 free(t);
1669 assert_se(isempty(p));
1670
1671 p = original = " foo\\ba\\x6ar ";
1672 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) > 0);
1673 assert_se(streq(t, "foo\ba\x6ar"));
1674 free(t);
1675 assert_se(isempty(p));
1676
1677 p = original = " foo\\ba\\x6ar ";
1678 assert_se(extract_first_word(&p, &t, NULL, 0) > 0);
1679 assert_se(streq(t, "foobax6ar"));
1680 free(t);
1681 assert_se(isempty(p));
1682
1683 p = original = " f\\u00f6o \"pi\\U0001F4A9le\" ";
1684 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) > 0);
1685 assert_se(streq(t, "föo"));
1686 free(t);
1687 assert_se(p == original + 13);
1688
1689 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE) > 0);
1690 assert_se(streq(t, "pi\360\237\222\251le"));
1691 free(t);
1692 assert_se(isempty(p));
1693
1694 p = original = "fooo\\";
1695 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RELAX) > 0);
1696 assert_se(streq(t, "fooo"));
1697 free(t);
1698 assert_se(isempty(p));
1699
1700 p = original = "fooo\\";
1701 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE_RELAX) > 0);
1702 assert_se(streq(t, "fooo\\"));
1703 free(t);
1704 assert_se(isempty(p));
1705
1706 p = original = "fooo\\";
1707 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE_RELAX|EXTRACT_RELAX) > 0);
1708 assert_se(streq(t, "fooo\\"));
1709 free(t);
1710 assert_se(isempty(p));
1711
1712 p = original = "fooo\\";
1713 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX) > 0);
1714 assert_se(streq(t, "fooo\\"));
1715 free(t);
1716 assert_se(isempty(p));
1717
1718 p = original = "\"foo\\";
1719 assert_se(extract_first_word(&p, &t, NULL, 0) == -EINVAL);
1720 assert_se(p == original + 5);
1721
1722 p = original = "\"foo\\";
1723 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX) > 0);
1724 assert_se(streq(t, "foo"));
1725 free(t);
1726 assert_se(isempty(p));
1727
1728 p = original = "foo::bar";
1729 assert_se(extract_first_word(&p, &t, ":", 0) == 1);
1730 assert_se(streq(t, "foo"));
1731 free(t);
1732 assert_se(p == original + 5);
1733
1734 assert_se(extract_first_word(&p, &t, ":", 0) == 1);
1735 assert_se(streq(t, "bar"));
1736 free(t);
1737 assert_se(isempty(p));
1738
1739 assert_se(extract_first_word(&p, &t, ":", 0) == 0);
1740 assert_se(!t);
1741 assert_se(isempty(p));
1742
1743 p = original = "foo\\:bar::waldo";
1744 assert_se(extract_first_word(&p, &t, ":", 0) == 1);
1745 assert_se(streq(t, "foo:bar"));
1746 free(t);
1747 assert_se(p == original + 10);
1748
1749 assert_se(extract_first_word(&p, &t, ":", 0) == 1);
1750 assert_se(streq(t, "waldo"));
1751 free(t);
1752 assert_se(isempty(p));
1753
1754 assert_se(extract_first_word(&p, &t, ":", 0) == 0);
1755 assert_se(!t);
1756 assert_se(isempty(p));
1757
1758 p = original = "\"foo\\";
1759 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE_RELAX) == -EINVAL);
1760 assert_se(p == original + 5);
1761
1762 p = original = "\"foo\\";
1763 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE_RELAX|EXTRACT_RELAX) > 0);
1764 assert_se(streq(t, "foo\\"));
1765 free(t);
1766 assert_se(isempty(p));
1767
1768 p = original = "\"foo\\";
1769 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX|EXTRACT_RELAX) > 0);
1770 assert_se(streq(t, "foo\\"));
1771 free(t);
1772 assert_se(isempty(p));
1773
1774 p = original = "fooo\\ bar quux";
1775 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_RELAX) > 0);
1776 assert_se(streq(t, "fooo bar"));
1777 free(t);
1778 assert_se(p == original + 10);
1779
1780 p = original = "fooo\\ bar quux";
1781 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE_RELAX) > 0);
1782 assert_se(streq(t, "fooo bar"));
1783 free(t);
1784 assert_se(p == original + 10);
1785
1786 p = original = "fooo\\ bar quux";
1787 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE_RELAX|EXTRACT_RELAX) > 0);
1788 assert_se(streq(t, "fooo bar"));
1789 free(t);
1790 assert_se(p == original + 10);
1791
1792 p = original = "fooo\\ bar quux";
1793 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) == -EINVAL);
1794 assert_se(p == original + 5);
1795
1796 p = original = "fooo\\ bar quux";
1797 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX) > 0);
1798 assert_se(streq(t, "fooo\\ bar"));
1799 free(t);
1800 assert_se(p == original + 10);
1801
1802 p = original = "\\w+@\\K[\\d.]+";
1803 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE) == -EINVAL);
1804 assert_se(p == original + 1);
1805
1806 p = original = "\\w+@\\K[\\d.]+";
1807 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX) > 0);
1808 assert_se(streq(t, "\\w+@\\K[\\d.]+"));
1809 free(t);
1810 assert_se(isempty(p));
1811
1812 p = original = "\\w+\\b";
1813 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_CUNESCAPE|EXTRACT_CUNESCAPE_RELAX) > 0);
1814 assert_se(streq(t, "\\w+\b"));
1815 free(t);
1816 assert_se(isempty(p));
1817
1818 p = original = "-N ''";
1819 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
1820 assert_se(streq(t, "-N"));
1821 free(t);
1822 assert_se(p == original + 3);
1823
1824 assert_se(extract_first_word(&p, &t, NULL, EXTRACT_QUOTES) > 0);
1825 assert_se(streq(t, ""));
1826 free(t);
1827 assert_se(isempty(p));
1828
1829 p = original = ":foo\\:bar::waldo:";
1830 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
1831 assert_se(t);
1832 assert_se(streq(t, ""));
1833 free(t);
1834 assert_se(p == original + 1);
1835
1836 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
1837 assert_se(streq(t, "foo:bar"));
1838 free(t);
1839 assert_se(p == original + 10);
1840
1841 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
1842 assert_se(t);
1843 assert_se(streq(t, ""));
1844 free(t);
1845 assert_se(p == original + 11);
1846
1847 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
1848 assert_se(streq(t, "waldo"));
1849 free(t);
1850 assert_se(p == original + 17);
1851
1852 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 1);
1853 assert_se(streq(t, ""));
1854 free(t);
1855 assert_se(p == NULL);
1856
1857 assert_se(extract_first_word(&p, &t, ":", EXTRACT_DONT_COALESCE_SEPARATORS) == 0);
1858 assert_se(!t);
1859 assert_se(!p);
1860 }
1861
1862 static void test_extract_first_word_and_warn(void) {
1863 const char *p, *original;
1864 char *t;
1865
1866 p = original = "foobar waldo";
1867 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
1868 assert_se(streq(t, "foobar"));
1869 free(t);
1870 assert_se(p == original + 7);
1871
1872 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
1873 assert_se(streq(t, "waldo"));
1874 free(t);
1875 assert_se(isempty(p));
1876
1877 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) == 0);
1878 assert_se(!t);
1879 assert_se(isempty(p));
1880
1881 p = original = "\"foobar\" \'waldo\'";
1882 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) > 0);
1883 assert_se(streq(t, "foobar"));
1884 free(t);
1885 assert_se(p == original + 9);
1886
1887 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) > 0);
1888 assert_se(streq(t, "waldo"));
1889 free(t);
1890 assert_se(isempty(p));
1891
1892 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) == 0);
1893 assert_se(!t);
1894 assert_se(isempty(p));
1895
1896 p = original = "\"";
1897 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) == -EINVAL);
1898 assert_se(p == original + 1);
1899
1900 p = original = "\'";
1901 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) == -EINVAL);
1902 assert_se(p == original + 1);
1903
1904 p = original = "\'fooo";
1905 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) == -EINVAL);
1906 assert_se(p == original + 5);
1907
1908 p = original = "\'fooo";
1909 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
1910 assert_se(streq(t, "fooo"));
1911 free(t);
1912 assert_se(isempty(p));
1913
1914 p = original = " foo\\ba\\x6ar ";
1915 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
1916 assert_se(streq(t, "foo\ba\x6ar"));
1917 free(t);
1918 assert_se(isempty(p));
1919
1920 p = original = " foo\\ba\\x6ar ";
1921 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
1922 assert_se(streq(t, "foobax6ar"));
1923 free(t);
1924 assert_se(isempty(p));
1925
1926 p = original = " f\\u00f6o \"pi\\U0001F4A9le\" ";
1927 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
1928 assert_se(streq(t, "föo"));
1929 free(t);
1930 assert_se(p == original + 13);
1931
1932 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
1933 assert_se(streq(t, "pi\360\237\222\251le"));
1934 free(t);
1935 assert_se(isempty(p));
1936
1937 p = original = "fooo\\";
1938 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
1939 assert_se(streq(t, "fooo"));
1940 free(t);
1941 assert_se(isempty(p));
1942
1943 p = original = "fooo\\";
1944 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
1945 assert_se(streq(t, "fooo\\"));
1946 free(t);
1947 assert_se(isempty(p));
1948
1949 p = original = "fooo\\";
1950 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
1951 assert_se(streq(t, "fooo\\"));
1952 free(t);
1953 assert_se(isempty(p));
1954
1955 p = original = "\"foo\\";
1956 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES, NULL, "fake", 1, original) == -EINVAL);
1957 assert_se(p == original + 5);
1958
1959 p = original = "\"foo\\";
1960 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
1961 assert_se(streq(t, "foo"));
1962 free(t);
1963 assert_se(isempty(p));
1964
1965 p = original = "\"foo\\";
1966 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE, NULL, "fake", 1, original) == -EINVAL);
1967 assert_se(p == original + 5);
1968
1969 p = original = "\"foo\\";
1970 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_QUOTES|EXTRACT_CUNESCAPE|EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
1971 assert_se(streq(t, "foo"));
1972 free(t);
1973 assert_se(isempty(p));
1974
1975 p = original = "fooo\\ bar quux";
1976 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_RELAX, NULL, "fake", 1, original) > 0);
1977 assert_se(streq(t, "fooo bar"));
1978 free(t);
1979 assert_se(p == original + 10);
1980
1981 p = original = "fooo\\ bar quux";
1982 assert_se(extract_first_word_and_warn(&p, &t, NULL, 0, NULL, "fake", 1, original) > 0);
1983 assert_se(streq(t, "fooo bar"));
1984 free(t);
1985 assert_se(p == original + 10);
1986
1987 p = original = "fooo\\ bar quux";
1988 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
1989 assert_se(streq(t, "fooo\\ bar"));
1990 free(t);
1991 assert_se(p == original + 10);
1992
1993 p = original = "\\w+@\\K[\\d.]+";
1994 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
1995 assert_se(streq(t, "\\w+@\\K[\\d.]+"));
1996 free(t);
1997 assert_se(isempty(p));
1998
1999 p = original = "\\w+\\b";
2000 assert_se(extract_first_word_and_warn(&p, &t, NULL, EXTRACT_CUNESCAPE, NULL, "fake", 1, original) > 0);
2001 assert_se(streq(t, "\\w+\b"));
2002 free(t);
2003 assert_se(isempty(p));
2004 }
2005
2006 static void test_extract_many_words(void) {
2007 const char *p, *original;
2008 char *a, *b, *c;
2009
2010 p = original = "foobar waldi piep";
2011 assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 3);
2012 assert_se(isempty(p));
2013 assert_se(streq_ptr(a, "foobar"));
2014 assert_se(streq_ptr(b, "waldi"));
2015 assert_se(streq_ptr(c, "piep"));
2016 free(a);
2017 free(b);
2018 free(c);
2019
2020 p = original = "'foobar' wa\"ld\"i ";
2021 assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 2);
2022 assert_se(isempty(p));
2023 assert_se(streq_ptr(a, "'foobar'"));
2024 assert_se(streq_ptr(b, "wa\"ld\"i"));
2025 assert_se(streq_ptr(c, NULL));
2026 free(a);
2027 free(b);
2028
2029 p = original = "'foobar' wa\"ld\"i ";
2030 assert_se(extract_many_words(&p, NULL, EXTRACT_QUOTES, &a, &b, &c, NULL) == 2);
2031 assert_se(isempty(p));
2032 assert_se(streq_ptr(a, "foobar"));
2033 assert_se(streq_ptr(b, "waldi"));
2034 assert_se(streq_ptr(c, NULL));
2035 free(a);
2036 free(b);
2037
2038 p = original = "";
2039 assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 0);
2040 assert_se(isempty(p));
2041 assert_se(streq_ptr(a, NULL));
2042 assert_se(streq_ptr(b, NULL));
2043 assert_se(streq_ptr(c, NULL));
2044
2045 p = original = " ";
2046 assert_se(extract_many_words(&p, NULL, 0, &a, &b, &c, NULL) == 0);
2047 assert_se(isempty(p));
2048 assert_se(streq_ptr(a, NULL));
2049 assert_se(streq_ptr(b, NULL));
2050 assert_se(streq_ptr(c, NULL));
2051
2052 p = original = "foobar";
2053 assert_se(extract_many_words(&p, NULL, 0, NULL) == 0);
2054 assert_se(p == original);
2055
2056 p = original = "foobar waldi";
2057 assert_se(extract_many_words(&p, NULL, 0, &a, NULL) == 1);
2058 assert_se(p == original+7);
2059 assert_se(streq_ptr(a, "foobar"));
2060 free(a);
2061
2062 p = original = " foobar ";
2063 assert_se(extract_many_words(&p, NULL, 0, &a, NULL) == 1);
2064 assert_se(isempty(p));
2065 assert_se(streq_ptr(a, "foobar"));
2066 free(a);
2067 }
2068
2069 static int parse_item(const char *key, const char *value) {
2070 assert_se(key);
2071
2072 log_info("kernel cmdline option <%s> = <%s>", key, strna(value));
2073 return 0;
2074 }
2075
2076 static void test_parse_proc_cmdline(void) {
2077 assert_se(parse_proc_cmdline(parse_item) >= 0);
2078 }
2079
2080 static void test_raw_clone(void) {
2081 pid_t parent, pid, pid2;
2082
2083 parent = getpid();
2084 log_info("before clone: getpid()→"PID_FMT, parent);
2085 assert_se(raw_getpid() == parent);
2086
2087 pid = raw_clone(0, NULL);
2088 assert_se(pid >= 0);
2089
2090 pid2 = raw_getpid();
2091 log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" raw_getpid()→"PID_FMT,
2092 pid, getpid(), pid2);
2093 if (pid == 0) {
2094 assert_se(pid2 != parent);
2095 _exit(EXIT_SUCCESS);
2096 } else {
2097 int status;
2098
2099 assert_se(pid2 == parent);
2100 waitpid(pid, &status, __WCLONE);
2101 assert_se(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
2102 }
2103 }
2104
2105 static void test_same_fd(void) {
2106 _cleanup_close_pair_ int p[2] = { -1, -1 };
2107 _cleanup_close_ int a = -1, b = -1, c = -1;
2108
2109 assert_se(pipe2(p, O_CLOEXEC) >= 0);
2110 assert_se((a = dup(p[0])) >= 0);
2111 assert_se((b = open("/dev/null", O_RDONLY|O_CLOEXEC)) >= 0);
2112 assert_se((c = dup(a)) >= 0);
2113
2114 assert_se(same_fd(p[0], p[0]) > 0);
2115 assert_se(same_fd(p[1], p[1]) > 0);
2116 assert_se(same_fd(a, a) > 0);
2117 assert_se(same_fd(b, b) > 0);
2118
2119 assert_se(same_fd(a, p[0]) > 0);
2120 assert_se(same_fd(p[0], a) > 0);
2121 assert_se(same_fd(c, p[0]) > 0);
2122 assert_se(same_fd(p[0], c) > 0);
2123 assert_se(same_fd(a, c) > 0);
2124 assert_se(same_fd(c, a) > 0);
2125
2126 assert_se(same_fd(p[0], p[1]) == 0);
2127 assert_se(same_fd(p[1], p[0]) == 0);
2128 assert_se(same_fd(p[0], b) == 0);
2129 assert_se(same_fd(b, p[0]) == 0);
2130 assert_se(same_fd(p[1], a) == 0);
2131 assert_se(same_fd(a, p[1]) == 0);
2132 assert_se(same_fd(p[1], b) == 0);
2133 assert_se(same_fd(b, p[1]) == 0);
2134
2135 assert_se(same_fd(a, b) == 0);
2136 assert_se(same_fd(b, a) == 0);
2137 }
2138
2139 static void test_uid_ptr(void) {
2140
2141 assert_se(UID_TO_PTR(0) != NULL);
2142 assert_se(UID_TO_PTR(1000) != NULL);
2143
2144 assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
2145 assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
2146 }
2147
2148 static void test_sparse_write_one(int fd, const char *buffer, size_t n) {
2149 char check[n];
2150
2151 assert_se(lseek(fd, 0, SEEK_SET) == 0);
2152 assert_se(ftruncate(fd, 0) >= 0);
2153 assert_se(sparse_write(fd, buffer, n, 4) == (ssize_t) n);
2154
2155 assert_se(lseek(fd, 0, SEEK_CUR) == (off_t) n);
2156 assert_se(ftruncate(fd, n) >= 0);
2157
2158 assert_se(lseek(fd, 0, SEEK_SET) == 0);
2159 assert_se(read(fd, check, n) == (ssize_t) n);
2160
2161 assert_se(memcmp(buffer, check, n) == 0);
2162 }
2163
2164 static void test_sparse_write(void) {
2165 const char test_a[] = "test";
2166 const char test_b[] = "\0\0\0\0test\0\0\0\0";
2167 const char test_c[] = "\0\0test\0\0\0\0";
2168 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";
2169 const char test_e[] = "test\0\0\0\0test";
2170 _cleanup_close_ int fd = -1;
2171 char fn[] = "/tmp/sparseXXXXXX";
2172
2173 fd = mkostemp(fn, O_CLOEXEC);
2174 assert_se(fd >= 0);
2175 unlink(fn);
2176
2177 test_sparse_write_one(fd, test_a, sizeof(test_a));
2178 test_sparse_write_one(fd, test_b, sizeof(test_b));
2179 test_sparse_write_one(fd, test_c, sizeof(test_c));
2180 test_sparse_write_one(fd, test_d, sizeof(test_d));
2181 test_sparse_write_one(fd, test_e, sizeof(test_e));
2182 }
2183
2184 static void test_shell_escape_one(const char *s, const char *bad, const char *expected) {
2185 _cleanup_free_ char *r;
2186
2187 assert_se(r = shell_escape(s, bad));
2188 assert_se(streq_ptr(r, expected));
2189 }
2190
2191 static void test_shell_escape(void) {
2192 test_shell_escape_one("", "", "");
2193 test_shell_escape_one("\\", "", "\\\\");
2194 test_shell_escape_one("foobar", "", "foobar");
2195 test_shell_escape_one("foobar", "o", "f\\o\\obar");
2196 test_shell_escape_one("foo:bar,baz", ",:", "foo\\:bar\\,baz");
2197 }
2198
2199 static void test_shell_maybe_quote_one(const char *s, const char *expected) {
2200 _cleanup_free_ char *r;
2201
2202 assert_se(r = shell_maybe_quote(s));
2203 assert_se(streq(r, expected));
2204 }
2205
2206 static void test_shell_maybe_quote(void) {
2207
2208 test_shell_maybe_quote_one("", "");
2209 test_shell_maybe_quote_one("\\", "\"\\\\\"");
2210 test_shell_maybe_quote_one("\"", "\"\\\"\"");
2211 test_shell_maybe_quote_one("foobar", "foobar");
2212 test_shell_maybe_quote_one("foo bar", "\"foo bar\"");
2213 test_shell_maybe_quote_one("foo \"bar\" waldo", "\"foo \\\"bar\\\" waldo\"");
2214 test_shell_maybe_quote_one("foo$bar", "\"foo\\$bar\"");
2215 }
2216
2217 static void test_parse_mode(void) {
2218 mode_t m;
2219
2220 assert_se(parse_mode("-1", &m) < 0);
2221 assert_se(parse_mode("", &m) < 0);
2222 assert_se(parse_mode("888", &m) < 0);
2223 assert_se(parse_mode("77777", &m) < 0);
2224
2225 assert_se(parse_mode("544", &m) >= 0 && m == 0544);
2226 assert_se(parse_mode("777", &m) >= 0 && m == 0777);
2227 assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
2228 assert_se(parse_mode("0", &m) >= 0 && m == 0);
2229 }
2230
2231 static void test_tempfn(void) {
2232 char *ret = NULL, *p;
2233
2234 assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
2235 assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
2236 free(ret);
2237
2238 assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
2239 assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
2240 free(ret);
2241
2242 assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
2243 assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
2244 assert_se(strlen(p) == 16);
2245 assert_se(in_charset(p, "0123456789abcdef"));
2246 free(ret);
2247
2248 assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
2249 assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
2250 assert_se(strlen(p) == 16);
2251 assert_se(in_charset(p, "0123456789abcdef"));
2252 free(ret);
2253
2254 assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
2255 assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
2256 assert_se(strlen(p) == 16);
2257 assert_se(in_charset(p, "0123456789abcdef"));
2258 free(ret);
2259
2260 assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
2261 assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
2262 assert_se(strlen(p) == 16);
2263 assert_se(in_charset(p, "0123456789abcdef"));
2264 free(ret);
2265 }
2266
2267 static void test_strcmp_ptr(void) {
2268 assert_se(strcmp_ptr(NULL, NULL) == 0);
2269 assert_se(strcmp_ptr("", NULL) > 0);
2270 assert_se(strcmp_ptr("foo", NULL) > 0);
2271 assert_se(strcmp_ptr(NULL, "") < 0);
2272 assert_se(strcmp_ptr(NULL, "bar") < 0);
2273 assert_se(strcmp_ptr("foo", "bar") > 0);
2274 assert_se(strcmp_ptr("bar", "baz") < 0);
2275 assert_se(strcmp_ptr("foo", "foo") == 0);
2276 assert_se(strcmp_ptr("", "") == 0);
2277 }
2278
2279 static void test_fgetxattrat_fake(void) {
2280 char t[] = "/var/tmp/xattrtestXXXXXX";
2281 _cleanup_close_ int fd = -1;
2282 const char *x;
2283 char v[3] = {};
2284 int r;
2285
2286 assert_se(mkdtemp(t));
2287 x = strjoina(t, "/test");
2288 assert_se(touch(x) >= 0);
2289
2290 r = setxattr(x, "user.foo", "bar", 3, 0);
2291 if (r < 0 && errno == EOPNOTSUPP) /* no xattrs supported on /var/tmp... */
2292 goto cleanup;
2293 assert_se(r >= 0);
2294
2295 fd = open(t, O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY);
2296 assert_se(fd >= 0);
2297
2298 assert_se(fgetxattrat_fake(fd, "test", "user.foo", v, 3, 0) >= 0);
2299 assert_se(memcmp(v, "bar", 3) == 0);
2300
2301 safe_close(fd);
2302 fd = open("/", O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY);
2303 assert_se(fd >= 0);
2304 assert_se(fgetxattrat_fake(fd, "usr", "user.idontexist", v, 3, 0) == -ENODATA);
2305
2306 cleanup:
2307 assert_se(unlink(x) >= 0);
2308 assert_se(rmdir(t) >= 0);
2309 }
2310
2311 int main(int argc, char *argv[]) {
2312 log_parse_environment();
2313 log_open();
2314
2315 test_streq_ptr();
2316 test_align_power2();
2317 test_max();
2318 test_container_of();
2319 test_alloca();
2320 test_div_round_up();
2321 test_first_word();
2322 test_close_many();
2323 test_parse_boolean();
2324 test_parse_pid();
2325 test_parse_uid();
2326 test_safe_atou16();
2327 test_safe_atoi16();
2328 test_safe_atolli();
2329 test_safe_atod();
2330 test_strappend();
2331 test_strstrip();
2332 test_delete_chars();
2333 test_in_charset();
2334 test_hexchar();
2335 test_unhexchar();
2336 test_base32hexchar();
2337 test_unbase32hexchar();
2338 test_base64char();
2339 test_unbase64char();
2340 test_octchar();
2341 test_unoctchar();
2342 test_decchar();
2343 test_undecchar();
2344 test_unhexmem();
2345 test_base32hexmem();
2346 test_unbase32hexmem();
2347 test_base64mem();
2348 test_unbase64mem();
2349 test_cescape();
2350 test_cunescape();
2351 test_foreach_word();
2352 test_foreach_word_quoted();
2353 test_memdup_multiply();
2354 test_u64log2();
2355 test_protect_errno();
2356 test_parse_size();
2357 test_parse_cpu_set();
2358 test_config_parse_iec_uint64();
2359 test_strextend();
2360 test_strrep();
2361 test_split_pair();
2362 test_fstab_node_to_udev_node();
2363 test_get_files_in_directory();
2364 test_in_set();
2365 test_writing_tmpfile();
2366 test_hexdump();
2367 test_log2i();
2368 test_foreach_string();
2369 test_filename_is_valid();
2370 test_string_has_cc();
2371 test_ascii_strlower();
2372 test_files_same();
2373 test_is_valid_documentation_url();
2374 test_file_in_same_dir();
2375 test_endswith();
2376 test_endswith_no_case();
2377 test_close_nointr();
2378 test_unlink_noerrno();
2379 test_readlink_and_make_absolute();
2380 test_ignore_signals();
2381 test_strshorten();
2382 test_strjoina();
2383 test_is_symlink();
2384 test_search_and_fopen();
2385 test_search_and_fopen_nulstr();
2386 test_glob_exists();
2387 test_execute_directory();
2388 test_extract_first_word();
2389 test_extract_first_word_and_warn();
2390 test_extract_many_words();
2391 test_parse_proc_cmdline();
2392 test_raw_clone();
2393 test_same_fd();
2394 test_uid_ptr();
2395 test_sparse_write();
2396 test_shell_escape();
2397 test_shell_maybe_quote();
2398 test_parse_mode();
2399 test_tempfn();
2400 test_strcmp_ptr();
2401 test_fgetxattrat_fake();
2402
2403 return 0;
2404 }
Unnamed repository; edit this file 'description' to name the repository.