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