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