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