]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/test/test-util.c
projects / thirdparty / systemd.git / blob
? search:


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