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