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