]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/test/test-util.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #756 from ldzhong/fix
[thirdparty/systemd.git] / src / test / test-util.c
CommitLineData
539ad707
TA		 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 <string.h>
dbd73f9e
TA		 24#include <unistd.h>
25#include <fcntl.h>
d6dd604b 26#include <locale.h>
2a371001 27#include <errno.h>
927be00c 28#include <signal.h>
8e211000 29#include <math.h>
8852362b 30#include <sys/wait.h>
539ad707
TA		 31
32#include "util.h"
927be00c 33#include "mkdir.h"
c6878637 34#include "rm-rf.h"
893fa014 35#include "strv.h"
65b3903f
ZJS		 36#include "def.h"
37#include "fileio.h"
9480794b 38#include "conf-parser.h"
0eb3cc88 39#include "virt.h"
0b452006 40#include "process-util.h"
958b66ea 41#include "hostname-util.h"
24882e06 42#include "signal-util.h"
539ad707
TA		 43
44static void test_streq_ptr(void) {
8354c34e
TA		 45 assert_se(streq_ptr(NULL, NULL));
46 assert_se(!streq_ptr("abc", "cdef"));
539ad707
TA		 47}
48
625e870b
DH		 49static 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
7242d742
DH		 79static 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));
7242d742
DH		 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);
40a1eebd
DH		 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));
667a0377
DH		 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);
7242d742
DH		 119}
120
fb835651
DH		 121static 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
95d78c7e
DH		 139static 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
180a60bc
DH		 152static 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
539ad707 185static void test_first_word(void) {
8354c34e
TA		 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
dbd73f9e
TA		 199static 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
2d5bdf5b
LP		 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);
dbd73f9e
TA		 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
03e334a1 215 safe_close(fds[2]);
dbd73f9e
TA		 216
217 unlink(name0);
218 unlink(name1);
219 unlink(name2);
220}
221
8354c34e
TA		 222static 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);
0f625d0b 245 assert_se(parse_boolean("full") < 0);
539ad707
TA		 246}
247
8d99e5f5
TA		 248static 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);
bdf7026e 272 assert_se(r == -ERANGE);
8d99e5f5
TA		 273 assert_se(pid == 65);
274}
275
276static void test_parse_uid(void) {
277 int r;
278 uid_t uid;
279
280 r = parse_uid("100", &uid);
281 assert_se(r == 0);
282 assert_se(uid == 100);
283}
284
285static void test_safe_atolli(void) {
286 int r;
287 long long l;
288
289 r = safe_atolli("12345", &l);
290 assert_se(r == 0);
291 assert_se(l == 12345);
292
293 r = safe_atolli("junk", &l);
294 assert_se(r == -EINVAL);
295}
296
297static void test_safe_atod(void) {
298 int r;
299 double d;
d6dd604b
LP		 300 char *e;
301
302 r = safe_atod("junk", &d);
303 assert_se(r == -EINVAL);
8d99e5f5
TA		 304
305 r = safe_atod("0.2244", &d);
306 assert_se(r == 0);
8e211000 307 assert_se(fabs(d - 0.2244) < 0.000001);
8d99e5f5 308
d6dd604b 309 r = safe_atod("0,5", &d);
8d99e5f5 310 assert_se(r == -EINVAL);
d6dd604b
LP		 311
312 errno = 0;
313 strtod("0,5", &e);
314 assert_se(*e == ',');
315
316 /* Check if this really is locale independent */
926446f4 317 if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
d6dd604b 318
926446f4
DH		 319 r = safe_atod("0.2244", &d);
320 assert_se(r == 0);
321 assert_se(fabs(d - 0.2244) < 0.000001);
d6dd604b 322
926446f4
DH		 323 r = safe_atod("0,5", &d);
324 assert_se(r == -EINVAL);
d6dd604b 325
926446f4
DH		 326 errno = 0;
327 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
328 }
d6dd604b
LP		 329
330 /* And check again, reset */
926446f4 331 assert_se(setlocale(LC_NUMERIC, "C"));
d6dd604b
LP		 332
333 r = safe_atod("0.2244", &d);
334 assert_se(r == 0);
8e211000 335 assert_se(fabs(d - 0.2244) < 0.000001);
d6dd604b
LP		 336
337 r = safe_atod("0,5", &d);
338 assert_se(r == -EINVAL);
339
340 errno = 0;
341 strtod("0,5", &e);
342 assert_se(*e == ',');
8d99e5f5
TA		 343}
344
dbd73f9e 345static void test_strappend(void) {
998b087f 346 _cleanup_free_ char *t1, *t2, *t3, *t4;
dbd73f9e 347
998b087f
TA		 348 t1 = strappend(NULL, NULL);
349 assert_se(streq(t1, ""));
dbd73f9e 350
998b087f
TA		 351 t2 = strappend(NULL, "suf");
352 assert_se(streq(t2, "suf"));
dbd73f9e 353
998b087f
TA		 354 t3 = strappend("pre", NULL);
355 assert_se(streq(t3, "pre"));
dbd73f9e 356
998b087f
TA		 357 t4 = strappend("pre", "suf");
358 assert_se(streq(t4, "presuf"));
dbd73f9e
TA		 359}
360
1ef04f0b 361static void test_strstrip(void) {
998b087f
TA		 362 char *r;
363 char input[] = " hello, waldo. ";
1ef04f0b 364
998b087f
TA		 365 r = strstrip(input);
366 assert_se(streq(r, "hello, waldo."));
1ef04f0b
TA		 367}
368
369static void test_delete_chars(void) {
998b087f
TA		 370 char *r;
371 char input[] = " hello, waldo. abc";
1ef04f0b 372
998b087f
TA		 373 r = delete_chars(input, WHITESPACE);
374 assert_se(streq(r, "hello,waldo.abc"));
1ef04f0b
TA		 375}
376
377static void test_in_charset(void) {
998b087f
TA		 378 assert_se(in_charset("dddaaabbbcccc", "abcd"));
379 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
1ef04f0b
TA		 380}
381
44f4c86c
DB		 382static void test_hexchar(void) {
383 assert_se(hexchar(0xa) == 'a');
384 assert_se(hexchar(0x0) == '0');
385}
386
387static void test_unhexchar(void) {
388 assert_se(unhexchar('a') == 0xA);
389 assert_se(unhexchar('A') == 0xA);
390 assert_se(unhexchar('0') == 0x0);
391}
392
919a7f5f
TG		 393static void test_base32hexchar(void) {
394 assert_se(base32hexchar(0) == '0');
395 assert_se(base32hexchar(9) == '9');
396 assert_se(base32hexchar(10) == 'A');
397 assert_se(base32hexchar(31) == 'V');
398}
399
400static void test_unbase32hexchar(void) {
401 assert_se(unbase32hexchar('0') == 0);
402 assert_se(unbase32hexchar('9') == 9);
403 assert_se(unbase32hexchar('A') == 10);
404 assert_se(unbase32hexchar('V') == 31);
405 assert_se(unbase32hexchar('=') == -EINVAL);
406}
407
13a5d76b
TG		 408static void test_base64char(void) {
409 assert_se(base64char(0) == 'A');
410 assert_se(base64char(26) == 'a');
411 assert_se(base64char(63) == '/');
412}
413
414static void test_unbase64char(void) {
415 assert_se(unbase64char('A') == 0);
416 assert_se(unbase64char('Z') == 25);
417 assert_se(unbase64char('a') == 26);
418 assert_se(unbase64char('z') == 51);
419 assert_se(unbase64char('0') == 52);
420 assert_se(unbase64char('9') == 61);
421 assert_se(unbase64char('+') == 62);
422 assert_se(unbase64char('/') == 63);
423 assert_se(unbase64char('=') == -EINVAL);
424}
425
44f4c86c
DB		 426static void test_octchar(void) {
427 assert_se(octchar(00) == '0');
428 assert_se(octchar(07) == '7');
429}
430
431static void test_unoctchar(void) {
432 assert_se(unoctchar('0') == 00);
433 assert_se(unoctchar('7') == 07);
434}
435
436static void test_decchar(void) {
437 assert_se(decchar(0) == '0');
438 assert_se(decchar(9) == '9');
439}
440
441static void test_undecchar(void) {
442 assert_se(undecchar('0') == 0);
443 assert_se(undecchar('9') == 9);
444}
445
30494563
TG		 446static void test_unhexmem(void) {
447 const char *hex = "efa214921";
448 const char *hex_invalid = "efa214921o";
449 _cleanup_free_ char *hex2 = NULL;
450 _cleanup_free_ void *mem = NULL;
451 size_t len;
452
453 assert_se(unhexmem(hex, strlen(hex), &mem, &len) == 0);
454 assert_se(unhexmem(hex, strlen(hex) + 1, &mem, &len) == -EINVAL);
455 assert_se(unhexmem(hex_invalid, strlen(hex_invalid), &mem, &len) == -EINVAL);
456
457 assert_se((hex2 = hexmem(mem, len)));
458
459 free(mem);
460
461 assert_se(memcmp(hex, hex2, strlen(hex)) == 0);
462
463 free(hex2);
464
465 assert_se(unhexmem(hex, strlen(hex) - 1, &mem, &len) == 0);
466 assert_se((hex2 = hexmem(mem, len)));
467 assert_se(memcmp(hex, hex2, strlen(hex) - 1) == 0);
468}
469
919a7f5f
TG		 470/* https://tools.ietf.org/html/rfc4648#section-10 */
471static void test_base32hexmem(void) {
472 char *b32;
473
474 b32 = base32hexmem("", strlen(""), true);
475 assert_se(b32);
476 assert_se(streq(b32, ""));
477 free(b32);
478
479 b32 = base32hexmem("f", strlen("f"), true);
480 assert_se(b32);
481 assert_se(streq(b32, "CO======"));
482 free(b32);
483
484 b32 = base32hexmem("fo", strlen("fo"), true);
485 assert_se(b32);
486 assert_se(streq(b32, "CPNG===="));
487 free(b32);
488
489 b32 = base32hexmem("foo", strlen("foo"), true);
490 assert_se(b32);
491 assert_se(streq(b32, "CPNMU==="));
492 free(b32);
493
494 b32 = base32hexmem("foob", strlen("foob"), true);
495 assert_se(b32);
496 assert_se(streq(b32, "CPNMUOG="));
497 free(b32);
498
499 b32 = base32hexmem("fooba", strlen("fooba"), true);
500 assert_se(b32);
501 assert_se(streq(b32, "CPNMUOJ1"));
502 free(b32);
503
504 b32 = base32hexmem("foobar", strlen("foobar"), true);
505 assert_se(b32);
506 assert_se(streq(b32, "CPNMUOJ1E8======"));
507 free(b32);
508
509 b32 = base32hexmem("", strlen(""), false);
510 assert_se(b32);
511 assert_se(streq(b32, ""));
512 free(b32);
513
514 b32 = base32hexmem("f", strlen("f"), false);
515 assert_se(b32);
516 assert_se(streq(b32, "CO"));
517 free(b32);
518
519 b32 = base32hexmem("fo", strlen("fo"), false);
520 assert_se(b32);
521 assert_se(streq(b32, "CPNG"));
522 free(b32);
523
524 b32 = base32hexmem("foo", strlen("foo"), false);
525 assert_se(b32);
526 assert_se(streq(b32, "CPNMU"));
527 free(b32);
528
529 b32 = base32hexmem("foob", strlen("foob"), false);
530 assert_se(b32);
531 assert_se(streq(b32, "CPNMUOG"));
532 free(b32);
533
534 b32 = base32hexmem("fooba", strlen("fooba"), false);
535 assert_se(b32);
536 assert_se(streq(b32, "CPNMUOJ1"));
537 free(b32);
538
539 b32 = base32hexmem("foobar", strlen("foobar"), false);
540 assert_se(b32);
541 assert_se(streq(b32, "CPNMUOJ1E8"));
542 free(b32);
543}
544
545static void test_unbase32hexmem(void) {
546 void *mem;
547 size_t len;
548
549 assert_se(unbase32hexmem("", strlen(""), true, &mem, &len) == 0);
550 assert_se(streq(strndupa(mem, len), ""));
551 free(mem);
552
553 assert_se(unbase32hexmem("CO======", strlen("CO======"), true, &mem, &len) == 0);
554 assert_se(streq(strndupa(mem, len), "f"));
555 free(mem);
556
557 assert_se(unbase32hexmem("CPNG====", strlen("CPNG===="), true, &mem, &len) == 0);
558 assert_se(streq(strndupa(mem, len), "fo"));
559 free(mem);
560
561 assert_se(unbase32hexmem("CPNMU===", strlen("CPNMU==="), true, &mem, &len) == 0);
562 assert_se(streq(strndupa(mem, len), "foo"));
563 free(mem);
564
565 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), true, &mem, &len) == 0);
566 assert_se(streq(strndupa(mem, len), "foob"));
567 free(mem);
568
569 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == 0);
570 assert_se(streq(strndupa(mem, len), "fooba"));
571 free(mem);
572
573 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), true, &mem, &len) == 0);
574 assert_se(streq(strndupa(mem, len), "foobar"));
575 free(mem);
576
577 assert_se(unbase32hexmem("A", strlen("A"), true, &mem, &len) == -EINVAL);
578 assert_se(unbase32hexmem("A=======", strlen("A======="), true, &mem, &len) == -EINVAL);
579 assert_se(unbase32hexmem("AAA=====", strlen("AAA====="), true, &mem, &len) == -EINVAL);
580 assert_se(unbase32hexmem("AAAAAA==", strlen("AAAAAA=="), true, &mem, &len) == -EINVAL);
581 assert_se(unbase32hexmem("AB======", strlen("AB======"), true, &mem, &len) == -EINVAL);
582 assert_se(unbase32hexmem("AAAB====", strlen("AAAB===="), true, &mem, &len) == -EINVAL);
583 assert_se(unbase32hexmem("AAAAB===", strlen("AAAAB==="), true, &mem, &len) == -EINVAL);
584 assert_se(unbase32hexmem("AAAAAAB=", strlen("AAAAAAB="), true, &mem, &len) == -EINVAL);
585
586 assert_se(unbase32hexmem("", strlen(""), false, &mem, &len) == 0);
587 assert_se(streq(strndupa(mem, len), ""));
588 free(mem);
589
590 assert_se(unbase32hexmem("CO", strlen("CO"), false, &mem, &len) == 0);
591 assert_se(streq(strndupa(mem, len), "f"));
592 free(mem);
593
594 assert_se(unbase32hexmem("CPNG", strlen("CPNG"), false, &mem, &len) == 0);
595 assert_se(streq(strndupa(mem, len), "fo"));
596 free(mem);
597
598 assert_se(unbase32hexmem("CPNMU", strlen("CPNMU"), false, &mem, &len) == 0);
599 assert_se(streq(strndupa(mem, len), "foo"));
600 free(mem);
601
602 assert_se(unbase32hexmem("CPNMUOG", strlen("CPNMUOG"), false, &mem, &len) == 0);
603 assert_se(streq(strndupa(mem, len), "foob"));
604 free(mem);
605
606 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), false, &mem, &len) == 0);
607 assert_se(streq(strndupa(mem, len), "fooba"));
608 free(mem);
609
610 assert_se(unbase32hexmem("CPNMUOJ1E8", strlen("CPNMUOJ1E8"), false, &mem, &len) == 0);
611 assert_se(streq(strndupa(mem, len), "foobar"));
612 free(mem);
613
614 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), false, &mem, &len) == -EINVAL);
615 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), false, &mem, &len) == -EINVAL);
616 assert_se(unbase32hexmem("A", strlen("A"), false, &mem, &len) == -EINVAL);
617 assert_se(unbase32hexmem("A", strlen("A"), false, &mem, &len) == -EINVAL);
618 assert_se(unbase32hexmem("AAA", strlen("AAA"), false, &mem, &len) == -EINVAL);
619 assert_se(unbase32hexmem("AAAAAA", strlen("AAAAAA"), false, &mem, &len) == -EINVAL);
620 assert_se(unbase32hexmem("AB", strlen("AB"), false, &mem, &len) == -EINVAL);
621 assert_se(unbase32hexmem("AAAB", strlen("AAAB"), false, &mem, &len) == -EINVAL);
622 assert_se(unbase32hexmem("AAAAB", strlen("AAAAB"), false, &mem, &len) == -EINVAL);
623 assert_se(unbase32hexmem("AAAAAAB", strlen("AAAAAAB"), false, &mem, &len) == -EINVAL);
624}
625
13a5d76b
TG		 626/* https://tools.ietf.org/html/rfc4648#section-10 */
627static void test_base64mem(void) {
628 char *b64;
629
630 b64 = base64mem("", strlen(""));
631 assert_se(b64);
632 assert_se(streq(b64, ""));
633 free(b64);
634
635 b64 = base64mem("f", strlen("f"));
636 assert_se(b64);
637 assert_se(streq(b64, "Zg=="));
638 free(b64);
639
640 b64 = base64mem("fo", strlen("fo"));
641 assert_se(b64);
642 assert_se(streq(b64, "Zm8="));
643 free(b64);
644
645 b64 = base64mem("foo", strlen("foo"));
646 assert_se(b64);
647 assert_se(streq(b64, "Zm9v"));
648 free(b64);
649
650 b64 = base64mem("foob", strlen("foob"));
651 assert_se(b64);
652 assert_se(streq(b64, "Zm9vYg=="));
653 free(b64);
654
655 b64 = base64mem("fooba", strlen("fooba"));
656 assert_se(b64);
657 assert_se(streq(b64, "Zm9vYmE="));
658 free(b64);
659
660 b64 = base64mem("foobar", strlen("foobar"));
661 assert_se(b64);
662 assert_se(streq(b64, "Zm9vYmFy"));
663 free(b64);
664}
665
666static void test_unbase64mem(void) {
667 void *mem;
668 size_t len;
669
670 assert_se(unbase64mem("", strlen(""), &mem, &len) == 0);
671 assert_se(streq(strndupa(mem, len), ""));
672 free(mem);
673
674 assert_se(unbase64mem("Zg==", strlen("Zg=="), &mem, &len) == 0);
675 assert_se(streq(strndupa(mem, len), "f"));
676 free(mem);
677
678 assert_se(unbase64mem("Zm8=", strlen("Zm8="), &mem, &len) == 0);
679 assert_se(streq(strndupa(mem, len), "fo"));
680 free(mem);
681
682 assert_se(unbase64mem("Zm9v", strlen("Zm9v"), &mem, &len) == 0);
683 assert_se(streq(strndupa(mem, len), "foo"));
684 free(mem);
685
686 assert_se(unbase64mem("Zm9vYg==", strlen("Zm9vYg=="), &mem, &len) == 0);
687 assert_se(streq(strndupa(mem, len), "foob"));
688 free(mem);
689
690 assert_se(unbase64mem("Zm9vYmE=", strlen("Zm9vYmE="), &mem, &len) == 0);
691 assert_se(streq(strndupa(mem, len), "fooba"));
692 free(mem);
693
694 assert_se(unbase64mem("Zm9vYmFy", strlen("Zm9vYmFy"), &mem, &len) == 0);
695 assert_se(streq(strndupa(mem, len), "foobar"));
696 free(mem);
697
698 assert_se(unbase64mem("A", strlen("A"), &mem, &len) == -EINVAL);
699 assert_se(unbase64mem("A====", strlen("A===="), &mem, &len) == -EINVAL);
700 assert_se(unbase64mem("AAB==", strlen("AAB=="), &mem, &len) == -EINVAL);
701 assert_se(unbase64mem("AAAB=", strlen("AAAB="), &mem, &len) == -EINVAL);
702}
703
b4ecc959
TA		 704static void test_cescape(void) {
705 _cleanup_free_ char *escaped;
e0a33e7b
LP		 706
707 assert_se(escaped = cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
927be00c 708 assert_se(streq(escaped, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
b4ecc959
TA		 709}
710
711static void test_cunescape(void) {
712 _cleanup_free_ char *unescaped;
e0a33e7b 713
527b7a42
LP		 714 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped) < 0);
715 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX, &unescaped) >= 0);
f3ee6297 716 assert_se(streq_ptr(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
527b7a42
LP		 717 free(unescaped);
718 unescaped = NULL;
7f769619
ZJS		 719
720 /* incomplete sequences */
527b7a42
LP		 721 assert_se(cunescape("\\x0", 0, &unescaped) < 0);
722 assert_se(cunescape("\\x0", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 723 assert_se(streq_ptr(unescaped, "\\x0"));
527b7a42
LP		 724 free(unescaped);
725 unescaped = NULL;
7f769619 726
527b7a42
LP		 727 assert_se(cunescape("\\x", 0, &unescaped) < 0);
728 assert_se(cunescape("\\x", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 729 assert_se(streq_ptr(unescaped, "\\x"));
527b7a42
LP		 730 free(unescaped);
731 unescaped = NULL;
7f769619 732
527b7a42
LP		 733 assert_se(cunescape("\\", 0, &unescaped) < 0);
734 assert_se(cunescape("\\", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 735 assert_se(streq_ptr(unescaped, "\\"));
527b7a42
LP		 736 free(unescaped);
737 unescaped = NULL;
7f769619 738
527b7a42
LP		 739 assert_se(cunescape("\\11", 0, &unescaped) < 0);
740 assert_se(cunescape("\\11", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 741 assert_se(streq_ptr(unescaped, "\\11"));
527b7a42
LP		 742 free(unescaped);
743 unescaped = NULL;
7f769619 744
527b7a42
LP		 745 assert_se(cunescape("\\1", 0, &unescaped) < 0);
746 assert_se(cunescape("\\1", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 747 assert_se(streq_ptr(unescaped, "\\1"));
f3ee6297
LP		 748 free(unescaped);
749 unescaped = NULL;
750
751 assert_se(cunescape("\\u0000", 0, &unescaped) < 0);
752 assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX, &unescaped) >= 0);
753 assert_se(streq_ptr(unescaped, "ßßΠA"));
602ee553
TA		 754 free(unescaped);
755 unescaped = NULL;
3b51f8dd
DM		 756
757 assert_se(cunescape("\\073", 0, &unescaped) >= 0);
758 assert_se(streq_ptr(unescaped, ";"));
b4ecc959
TA		 759}
760
1ef04f0b 761static void test_foreach_word(void) {
a2a5291b 762 const char *word, *state;
1ef04f0b
TA		 763 size_t l;
764 int i = 0;
765 const char test[] = "test abc d\te f ";
766 const char * const expected[] = {
767 "test",
768 "abc",
769 "d",
770 "e",
771 "f",
772 "",
773 NULL
774 };
775
a2a5291b
ZJS		 776 FOREACH_WORD(word, l, test, state)
777 assert_se(strneq(expected[i++], word, l));
1ef04f0b
TA		 778}
779
ba774317 780static void check(const char *test, char** expected, bool trailing) {
a2a5291b 781 const char *word, *state;
539ad707 782 size_t l;
1ef04f0b 783 int i = 0;
1ef04f0b 784
ba774317 785 printf("<<<%s>>>\n", test);
a2a5291b 786 FOREACH_WORD_QUOTED(word, l, test, state) {
1ef04f0b 787 _cleanup_free_ char *t = NULL;
539ad707 788
a2a5291b
ZJS		 789 assert_se(t = strndup(word, l));
790 assert_se(strneq(expected[i++], word, l));
539ad707 791 printf("<%s>\n", t);
539ad707 792 }
ba774317 793 printf("<<<%s>>>\n", state);
e50221bf 794 assert_se(expected[i] == NULL);
ba774317
ZJS		 795 assert_se(isempty(state) == !trailing);
796}
797
798static void test_foreach_word_quoted(void) {
799 check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
800 STRV_MAKE("test",
801 "a",
802 "b",
803 "c",
804 "d",
805 "e",
806 "",
807 "",
808 "hhh",
809 "",
810 "",
811 "a b c"),
812 false);
813
814 check("test \"xxx",
815 STRV_MAKE("test"),
816 true);
817
818 check("test\\",
819 STRV_MAKE_EMPTY,
820 true);
539ad707
TA		 821}
822
0d585d82
TA		 823static void test_memdup_multiply(void) {
824 int org[] = {1, 2, 3};
825 int *dup;
826
827 dup = (int*)memdup_multiply(org, sizeof(int), 3);
828
829 assert_se(dup);
830 assert_se(dup[0] == 1);
831 assert_se(dup[1] == 2);
832 assert_se(dup[2] == 3);
833 free(dup);
834}
835
aa3c5cf8 836static void test_hostname_is_valid(void) {
bdf7026e
TA		 837 assert_se(hostname_is_valid("foobar"));
838 assert_se(hostname_is_valid("foobar.com"));
839 assert_se(!hostname_is_valid("fööbar"));
840 assert_se(!hostname_is_valid(""));
841 assert_se(!hostname_is_valid("."));
842 assert_se(!hostname_is_valid(".."));
843 assert_se(!hostname_is_valid("foobar."));
844 assert_se(!hostname_is_valid(".foobar"));
845 assert_se(!hostname_is_valid("foo..bar"));
846 assert_se(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
aa3c5cf8
LP		 847}
848
139e5336
MP		 849static void test_read_hostname_config(void) {
850 char path[] = "/tmp/hostname.XXXXXX";
851 char *hostname;
852 int fd;
853
854 fd = mkostemp_safe(path, O_RDWR|O_CLOEXEC);
855 assert(fd > 0);
856 close(fd);
857
858 /* simple hostname */
4c1fc3e4 859 write_string_file(path, "foo", WRITE_STRING_FILE_CREATE);
139e5336
MP		 860 assert_se(read_hostname_config(path, &hostname) == 0);
861 assert_se(streq(hostname, "foo"));
862 free(hostname);
e136009d 863 hostname = NULL;
139e5336
MP		 864
865 /* with comment */
4c1fc3e4 866 write_string_file(path, "# comment\nfoo", WRITE_STRING_FILE_CREATE);
139e5336 867 assert_se(read_hostname_config(path, &hostname) == 0);
e136009d 868 assert_se(hostname);
139e5336
MP		 869 assert_se(streq(hostname, "foo"));
870 free(hostname);
e136009d 871 hostname = NULL;
139e5336
MP		 872
873 /* with comment and extra whitespace */
4c1fc3e4 874 write_string_file(path, "# comment\n\n foo ", WRITE_STRING_FILE_CREATE);
139e5336 875 assert_se(read_hostname_config(path, &hostname) == 0);
e136009d 876 assert_se(hostname);
139e5336
MP		 877 assert_se(streq(hostname, "foo"));
878 free(hostname);
e136009d 879 hostname = NULL;
139e5336
MP		 880
881 /* cleans up name */
4c1fc3e4 882 write_string_file(path, "!foo/bar.com", WRITE_STRING_FILE_CREATE);
139e5336 883 assert_se(read_hostname_config(path, &hostname) == 0);
e136009d 884 assert_se(hostname);
139e5336
MP		 885 assert_se(streq(hostname, "foobar.com"));
886 free(hostname);
e136009d 887 hostname = NULL;
139e5336
MP		 888
889 /* no value set */
890 hostname = (char*) 0x1234;
4c1fc3e4 891 write_string_file(path, "# nothing here\n", WRITE_STRING_FILE_CREATE);
139e5336
MP		 892 assert_se(read_hostname_config(path, &hostname) == -ENOENT);
893 assert_se(hostname == (char*) 0x1234); /* does not touch argument on error */
894
895 /* nonexisting file */
896 assert_se(read_hostname_config("/non/existing", &hostname) == -ENOENT);
897 assert_se(hostname == (char*) 0x1234); /* does not touch argument on error */
898
899 unlink(path);
900}
901
144e51ec 902static void test_u64log2(void) {
bdf7026e
TA		 903 assert_se(u64log2(0) == 0);
904 assert_se(u64log2(8) == 3);
905 assert_se(u64log2(9) == 3);
906 assert_se(u64log2(15) == 3);
907 assert_se(u64log2(16) == 4);
908 assert_se(u64log2(1024*1024) == 20);
909 assert_se(u64log2(1024*1024+5) == 20);
144e51ec
CR		 910}
911
2a371001
ZJS		 912static void test_protect_errno(void) {
913 errno = 12;
914 {
915 PROTECT_ERRNO;
916 errno = 11;
917 }
bdf7026e 918 assert_se(errno == 12);
2a371001
ZJS		 919}
920
5556b5fe 921static void test_parse_size(void) {
b32ff512
ZJS		 922 off_t bytes;
923
5556b5fe 924 assert_se(parse_size("111", 1024, &bytes) == 0);
b32ff512
ZJS		 925 assert_se(bytes == 111);
926
9480794b
ZJS		 927 assert_se(parse_size("111.4", 1024, &bytes) == 0);
928 assert_se(bytes == 111);
929
5556b5fe 930 assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
b32ff512
ZJS		 931 assert_se(bytes == 112);
932
9480794b
ZJS		 933 assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
934 assert_se(bytes == 112);
935
936 assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
937 assert_se(bytes == 3*1024 + 512);
938
939 assert_se(parse_size("3. K", 1024, &bytes) == 0);
940 assert_se(bytes == 3*1024);
941
942 assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
b32ff512
ZJS		 943 assert_se(bytes == 3*1024);
944
840292be 945 assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
b32ff512 946
9480794b
ZJS		 947 assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
948 assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
949
840292be
ZJS		 950 assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
951
952 assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
9480794b 953 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
b32ff512 954
840292be
ZJS		 955 assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
956 assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
957
958 assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
959
960 assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
961 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
962
963 assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
b32ff512
ZJS		 964 assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
965
5556b5fe 966 assert_se(parse_size("12P", 1024, &bytes) == 0);
b32ff512
ZJS		 967 assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
968
840292be
ZJS		 969 assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
970
5556b5fe 971 assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
b32ff512
ZJS		 972 assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
973
5556b5fe 974 assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
b32ff512 975
9480794b
ZJS		 976 assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
977
978 assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
979
5556b5fe
LP		 980 assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
981 assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
982 assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
b32ff512 983
5556b5fe 984 assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
b32ff512 985
5556b5fe 986 assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
b32ff512
ZJS		 987}
988
9480794b
ZJS		 989static void test_config_parse_iec_off(void) {
990 off_t offset = 0;
991 assert_se(config_parse_iec_off(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
992 assert_se(offset == 4 * 1024 * 1024);
993
994 assert_se(config_parse_iec_off(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset, NULL) == 0);
995}
996
b4ecc959
TA		 997static void test_strextend(void) {
998 _cleanup_free_ char *str = strdup("0123");
999 strextend(&str, "456", "78", "9", NULL);
1000 assert_se(streq(str, "0123456789"));
1001}
1002
1003static void test_strrep(void) {
1004 _cleanup_free_ char *one, *three, *zero;
1005 one = strrep("waldo", 1);
1006 three = strrep("waldo", 3);
1007 zero = strrep("waldo", 0);
1008
1009 assert_se(streq(one, "waldo"));
1010 assert_se(streq(three, "waldowaldowaldo"));
1011 assert_se(streq(zero, ""));
1012}
1013
d4ac85c6
LP		 1014static void test_split_pair(void) {
1015 _cleanup_free_ char *a = NULL, *b = NULL;
1016
1017 assert_se(split_pair("", "", &a, &b) == -EINVAL);
1018 assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
1019 assert_se(split_pair("", "=", &a, &b) == -EINVAL);
1020 assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
1021 assert_se(streq(a, "foo"));
1022 assert_se(streq(b, "bar"));
1023 free(a);
1024 free(b);
1025 assert_se(split_pair("==", "==", &a, &b) >= 0);
1026 assert_se(streq(a, ""));
1027 assert_se(streq(b, ""));
1028 free(a);
1029 free(b);
1030
1031 assert_se(split_pair("===", "==", &a, &b) >= 0);
1032 assert_se(streq(a, ""));
1033 assert_se(streq(b, "="));
1034}
1035
22f5f628
DR		 1036static void test_fstab_node_to_udev_node(void) {
1037 char *n;
1038
1039 n = fstab_node_to_udev_node("LABEL=applé/jack");
1040 puts(n);
1041 assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
1042 free(n);
1043
1044 n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
1045 puts(n);
1046 assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
1047 free(n);
1048
1049 n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1050 puts(n);
1051 assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1052 free(n);
1053
1054 n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
1055 puts(n);
1056 assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
1057 free(n);
1058
22f5f628
DR		 1059 n = fstab_node_to_udev_node("PONIES=awesome");
1060 puts(n);
1061 assert_se(streq(n, "PONIES=awesome"));
1062 free(n);
1063
1064 n = fstab_node_to_udev_node("/dev/xda1");
1065 puts(n);
1066 assert_se(streq(n, "/dev/xda1"));
1067 free(n);
1068}
1069
893fa014
ZJS		 1070static void test_get_files_in_directory(void) {
1071 _cleanup_strv_free_ char **l = NULL, **t = NULL;
1072
1073 assert_se(get_files_in_directory("/tmp", &l) >= 0);
510b857f 1074 assert_se(get_files_in_directory(".", &t) >= 0);
893fa014
ZJS		 1075 assert_se(get_files_in_directory(".", NULL) >= 0);
1076}
1077
cabb7806
LP		 1078static void test_in_set(void) {
1079 assert_se(IN_SET(1, 1));
1080 assert_se(IN_SET(1, 1, 2, 3, 4));
1081 assert_se(IN_SET(2, 1, 2, 3, 4));
1082 assert_se(IN_SET(3, 1, 2, 3, 4));
1083 assert_se(IN_SET(4, 1, 2, 3, 4));
1084 assert_se(!IN_SET(0, 1));
1085 assert_se(!IN_SET(0, 1, 2, 3, 4));
1086}
1087
87b02843
ZJS		 1088static void test_writing_tmpfile(void) {
1089 char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
39883f62 1090 _cleanup_free_ char *contents = NULL;
65b3903f
ZJS		 1091 size_t size;
1092 int fd, r;
65b3903f 1093 struct iovec iov[3];
39883f62 1094
65b3903f
ZJS		 1095 IOVEC_SET_STRING(iov[0], "abc\n");
1096 IOVEC_SET_STRING(iov[1], ALPHANUMERICAL "\n");
1097 IOVEC_SET_STRING(iov[2], "");
1098
2d5bdf5b 1099 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
87b02843 1100 printf("tmpfile: %s", name);
65b3903f 1101
87b02843 1102 r = writev(fd, iov, 3);
bdf7026e 1103 assert_se(r >= 0);
65b3903f
ZJS		 1104
1105 r = read_full_file(name, &contents, &size);
bdf7026e 1106 assert_se(r == 0);
65b3903f 1107 printf("contents: %s", contents);
bdf7026e 1108 assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
40edd236
RC		 1109
1110 unlink(name);
65b3903f
ZJS		 1111}
1112
29bfbcd6
LP		 1113static void test_hexdump(void) {
1114 uint8_t data[146];
1115 unsigned i;
1116
1117 hexdump(stdout, NULL, 0);
1118 hexdump(stdout, "", 0);
1119 hexdump(stdout, "", 1);
1120 hexdump(stdout, "x", 1);
1121 hexdump(stdout, "x", 2);
1122 hexdump(stdout, "foobar", 7);
1123 hexdump(stdout, "f\nobar", 7);
1124 hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
1125
1126 for (i = 0; i < ELEMENTSOF(data); i++)
1127 data[i] = i*2;
1128
1129 hexdump(stdout, data, sizeof(data));
1130}
1131
8fe90522
ZJS		 1132static void test_log2i(void) {
1133 assert_se(log2i(1) == 0);
1134 assert_se(log2i(2) == 1);
1135 assert_se(log2i(3) == 1);
1136 assert_se(log2i(4) == 2);
1137 assert_se(log2i(32) == 5);
1138 assert_se(log2i(33) == 5);
1139 assert_se(log2i(63) == 5);
1140 assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
1141}
1142
c4a7b2c5
LP		 1143static void test_foreach_string(void) {
1144 const char * const t[] = {
1145 "foo",
1146 "bar",
1147 "waldo",
1148 NULL
1149 };
1150 const char *x;
1151 unsigned i = 0;
1152
1153 FOREACH_STRING(x, "foo", "bar", "waldo")
1154 assert_se(streq_ptr(t[i++], x));
1155
1156 assert_se(i == 3);
1157
1158 FOREACH_STRING(x, "zzz")
1159 assert_se(streq(x, "zzz"));
1160}
1161
ae6c3cc0 1162static void test_filename_is_valid(void) {
927be00c
RC		 1163 char foo[FILENAME_MAX+2];
1164 int i;
1165
ae6c3cc0
LP		 1166 assert_se(!filename_is_valid(""));
1167 assert_se(!filename_is_valid("/bar/foo"));
1168 assert_se(!filename_is_valid("/"));
1169 assert_se(!filename_is_valid("."));
1170 assert_se(!filename_is_valid(".."));
927be00c
RC		 1171
1172 for (i=0; i<FILENAME_MAX+1; i++)
1173 foo[i] = 'a';
1174 foo[FILENAME_MAX+1] = '\0';
1175
ae6c3cc0 1176 assert_se(!filename_is_valid(foo));
927be00c 1177
ae6c3cc0
LP		 1178 assert_se(filename_is_valid("foo_bar-333"));
1179 assert_se(filename_is_valid("o.o"));
927be00c
RC		 1180}
1181
1cb1767a
ZJS		 1182static void test_string_has_cc(void) {
1183 assert_se(string_has_cc("abc\1", NULL));
1184 assert_se(string_has_cc("abc\x7f", NULL));
1185 assert_se(string_has_cc("abc\x7f", NULL));
1186 assert_se(string_has_cc("abc\t\x7f", "\t"));
1187 assert_se(string_has_cc("abc\t\x7f", "\t"));
1188 assert_se(string_has_cc("\x7f", "\t"));
1189 assert_se(string_has_cc("\x7f", "\t\a"));
1190
1191 assert_se(!string_has_cc("abc\t\t", "\t"));
1192 assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
1193 assert_se(!string_has_cc("a\ab\tc", "\t\a"));
1194}
1195
927be00c
RC		 1196static void test_ascii_strlower(void) {
1197 char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
1198 assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"));
1199}
1200
1201static void test_files_same(void) {
1202 _cleanup_close_ int fd = -1;
1203 char name[] = "/tmp/test-files_same.XXXXXX";
1204 char name_alias[] = "/tmp/test-files_same.alias";
1205
1206 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1207 assert_se(fd >= 0);
1208 assert_se(symlink(name, name_alias) >= 0);
1209
1210 assert_se(files_same(name, name));
1211 assert_se(files_same(name, name_alias));
1212
1213 unlink(name);
1214 unlink(name_alias);
1215}
1216
1217static void test_is_valid_documentation_url(void) {
a2e03378
LP		 1218 assert_se(documentation_url_is_valid("http://www.freedesktop.org/wiki/Software/systemd"));
1219 assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
1220 assert_se(documentation_url_is_valid("file:/foo/foo"));
1221 assert_se(documentation_url_is_valid("man:systemd.special(7)"));
1222 assert_se(documentation_url_is_valid("info:bar"));
1223
1224 assert_se(!documentation_url_is_valid("foo:"));
1225 assert_se(!documentation_url_is_valid("info:"));
1226 assert_se(!documentation_url_is_valid(""));
927be00c
RC		 1227}
1228
1229static void test_file_in_same_dir(void) {
eee84633
DH		 1230 char *t;
1231
1232 t = file_in_same_dir("/", "a");
1233 assert_se(streq(t, "/a"));
1234 free(t);
1235
1236 t = file_in_same_dir("/", "/a");
1237 assert_se(streq(t, "/a"));
1238 free(t);
1239
1240 t = file_in_same_dir("", "a");
1241 assert_se(streq(t, "a"));
1242 free(t);
1243
1244 t = file_in_same_dir("a/", "a");
1245 assert_se(streq(t, "a/a"));
1246 free(t);
1247
1248 t = file_in_same_dir("bar/foo", "bar");
1249 assert_se(streq(t, "bar/bar"));
1250 free(t);
927be00c
RC		 1251}
1252
1253static void test_endswith(void) {
1254 assert_se(endswith("foobar", "bar"));
1255 assert_se(endswith("foobar", ""));
1256 assert_se(endswith("foobar", "foobar"));
1257 assert_se(endswith("", ""));
1258
1259 assert_se(!endswith("foobar", "foo"));
1260 assert_se(!endswith("foobar", "foobarfoofoo"));
1261}
1262
1263static void test_close_nointr(void) {
1264 char name[] = "/tmp/test-test-close_nointr.XXXXXX";
1265 int fd;
1266
1267 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1268 assert_se(fd >= 0);
1269 assert_se(close_nointr(fd) >= 0);
1270 assert_se(close_nointr(fd) < 0);
1271
1272 unlink(name);
1273}
1274
1275
1276static void test_unlink_noerrno(void) {
1277 char name[] = "/tmp/test-close_nointr.XXXXXX";
1278 int fd;
1279
1280 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1281 assert_se(fd >= 0);
1282 assert_se(close_nointr(fd) >= 0);
1283
1284 {
1285 PROTECT_ERRNO;
1286 errno = -42;
1287 assert_se(unlink_noerrno(name) >= 0);
1288 assert_se(errno == -42);
1289 assert_se(unlink_noerrno(name) < 0);
1290 assert_se(errno == -42);
1291 }
1292}
1293
1294static void test_readlink_and_make_absolute(void) {
1295 char tempdir[] = "/tmp/test-readlink_and_make_absolute";
1296 char name[] = "/tmp/test-readlink_and_make_absolute/original";
1297 char name2[] = "test-readlink_and_make_absolute/original";
1298 char name_alias[] = "/tmp/test-readlink_and_make_absolute-alias";
1299 char *r = NULL;
1300
684fc892 1301 assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0);
927be00c
RC		 1302 assert_se(touch(name) >= 0);
1303
1304 assert_se(symlink(name, name_alias) >= 0);
1305 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
1306 assert_se(streq(r, name));
1307 free(r);
1308 assert_se(unlink(name_alias) >= 0);
1309
1310 assert_se(chdir(tempdir) >= 0);
1311 assert_se(symlink(name2, name_alias) >= 0);
1312 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
1313 assert_se(streq(r, name));
1314 free(r);
1315 assert_se(unlink(name_alias) >= 0);
1316
c6878637 1317 assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
927be00c
RC		 1318}
1319
927be00c
RC		 1320static void test_ignore_signals(void) {
1321 assert_se(ignore_signals(SIGINT, -1) >= 0);
1322 assert_se(kill(getpid(), SIGINT) >= 0);
1323 assert_se(ignore_signals(SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
1324 assert_se(kill(getpid(), SIGUSR1) >= 0);
1325 assert_se(kill(getpid(), SIGUSR2) >= 0);
1326 assert_se(kill(getpid(), SIGTERM) >= 0);
1327 assert_se(kill(getpid(), SIGPIPE) >= 0);
1328 assert_se(default_signals(SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
1329}
1330
1331static void test_strshorten(void) {
1332 char s[] = "foobar";
1333
1334 assert_se(strlen(strshorten(s, 6)) == 6);
1335 assert_se(strlen(strshorten(s, 12)) == 6);
1336 assert_se(strlen(strshorten(s, 2)) == 2);
1337 assert_se(strlen(strshorten(s, 0)) == 0);
1338}
1339
63c372cb 1340static void test_strjoina(void) {
8085f163
DR		 1341 char *actual;
1342
63c372cb 1343 actual = strjoina("", "foo", "bar");
8085f163
DR		 1344 assert_se(streq(actual, "foobar"));
1345
63c372cb 1346 actual = strjoina("foo", "bar", "baz");
8085f163
DR		 1347 assert_se(streq(actual, "foobarbaz"));
1348
63c372cb 1349 actual = strjoina("foo", "", "bar", "baz");
8085f163 1350 assert_se(streq(actual, "foobarbaz"));
63c372cb
LP		 1351
1352 actual = strjoina("foo");
1353 assert_se(streq(actual, "foo"));
1354
1355 actual = strjoina(NULL);
1356 assert_se(streq(actual, ""));
1357
1358 actual = strjoina(NULL, "foo");
1359 assert_se(streq(actual, ""));
1360
1361 actual = strjoina("foo", NULL, "bar");
1362 assert_se(streq(actual, "foo"));
8085f163
DR		 1363}
1364
8852362b
RC		 1365static void test_is_symlink(void) {
1366 char name[] = "/tmp/test-is_symlink.XXXXXX";
1367 char name_link[] = "/tmp/test-is_symlink.link";
1368 _cleanup_close_ int fd = -1;
1369
1370 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1371 assert_se(fd >= 0);
1372 assert_se(symlink(name, name_link) >= 0);
1373
1374 assert_se(is_symlink(name) == 0);
1375 assert_se(is_symlink(name_link) == 1);
1376 assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
1377
1378
1379 unlink(name);
1380 unlink(name_link);
1381}
1382
8852362b
RC		 1383static void test_search_and_fopen(void) {
1384 const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
1385 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1386 int fd = -1;
1387 int r;
1388 FILE *f;
1389
1390 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1391 assert_se(fd >= 0);
1392 close(fd);
1393
1394 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1395 assert_se(r >= 0);
1396 fclose(f);
1397
1398 r = search_and_fopen(name, "r", NULL, dirs, &f);
1399 assert_se(r >= 0);
1400 fclose(f);
1401
1402 r = search_and_fopen(basename(name), "r", "/", dirs, &f);
1403 assert_se(r >= 0);
1404 fclose(f);
1405
1406 r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1407 assert_se(r < 0);
1408 r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1409 assert_se(r < 0);
1410
1411 r = unlink(name);
1412 assert_se(r == 0);
1413
1414 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1415 assert_se(r < 0);
1416}
1417
1418
1419static void test_search_and_fopen_nulstr(void) {
1420 const char dirs[] = "/tmp/foo/bar\0/tmp\0";
1421 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1422 int fd = -1;
1423 int r;
1424 FILE *f;
1425
1426 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1427 assert_se(fd >= 0);
1428 close(fd);
1429
1430 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1431 assert_se(r >= 0);
1432 fclose(f);
1433
1434 r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
1435 assert_se(r >= 0);
1436 fclose(f);
1437
1438 r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1439 assert_se(r < 0);
1440 r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1441 assert_se(r < 0);
1442
1443 r = unlink(name);
1444 assert_se(r == 0);
1445
1446 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1447 assert_se(r < 0);
1448}
1449
1450static void test_glob_exists(void) {
1451 char name[] = "/tmp/test-glob_exists.XXXXXX";
1452 int fd = -1;
1453 int r;
1454
1455 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1456 assert_se(fd >= 0);
1457 close(fd);
1458
1459 r = glob_exists("/tmp/test-glob_exists*");
1460 assert_se(r == 1);
1461
1462 r = unlink(name);
1463 assert_se(r == 0);
1464 r = glob_exists("/tmp/test-glob_exists*");
1465 assert_se(r == 0);
1466}
1467
1468static void test_execute_directory(void) {
aac7766c
ZJS		 1469 char template_lo[] = "/tmp/test-readlink_and_make_absolute-lo.XXXXXXX";
1470 char template_hi[] = "/tmp/test-readlink_and_make_absolute-hi.XXXXXXX";
76f282c6 1471 const char * dirs[] = {template_hi, template_lo, NULL};
aac7766c
ZJS		 1472 const char *name, *name2, *name3, *overridden, *override, *masked, *mask;
1473
1474 assert_se(mkdtemp(template_lo));
1475 assert_se(mkdtemp(template_hi));
1476
63c372cb
LP		 1477 name = strjoina(template_lo, "/script");
1478 name2 = strjoina(template_hi, "/script2");
1479 name3 = strjoina(template_lo, "/useless");
1480 overridden = strjoina(template_lo, "/overridden");
1481 override = strjoina(template_hi, "/overridden");
1482 masked = strjoina(template_lo, "/masked");
1483 mask = strjoina(template_hi, "/masked");
e801700e 1484
4c1fc3e4
DM		 1485 assert_se(write_string_file(name, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works", WRITE_STRING_FILE_CREATE) == 0);
1486 assert_se(write_string_file(name2, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2", WRITE_STRING_FILE_CREATE) == 0);
1487 assert_se(write_string_file(overridden, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
1488 assert_se(write_string_file(override, "#!/bin/sh\necho 'Executing '$0", WRITE_STRING_FILE_CREATE) == 0);
1489 assert_se(write_string_file(masked, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
aac7766c 1490 assert_se(symlink("/dev/null", mask) == 0);
8852362b
RC		 1491 assert_se(chmod(name, 0755) == 0);
1492 assert_se(chmod(name2, 0755) == 0);
aac7766c
ZJS		 1493 assert_se(chmod(overridden, 0755) == 0);
1494 assert_se(chmod(override, 0755) == 0);
1495 assert_se(chmod(masked, 0755) == 0);
8852362b
RC		 1496 assert_se(touch(name3) >= 0);
1497
e801700e 1498 execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL);
aac7766c 1499
0c0cdb06 1500 assert_se(chdir(template_lo) == 0);
e801700e 1501 assert_se(access("it_works", F_OK) >= 0);
aac7766c
ZJS		 1502 assert_se(access("failed", F_OK) < 0);
1503
0c0cdb06 1504 assert_se(chdir(template_hi) == 0);
e801700e 1505 assert_se(access("it_works2", F_OK) >= 0);
aac7766c 1506 assert_se(access("failed", F_OK) < 0);
8852362b 1507
c6878637
LP		 1508 (void) rm_rf(template_lo, REMOVE_ROOT|REMOVE_PHYSICAL);
1509 (void) rm_rf(template_hi, REMOVE_ROOT|REMOVE_PHYSICAL);
8852362b
RC		 1510}
1511
7629889c
LP		 1512static void test_unquote_first_word(void) {
1513 const char *p, *original;
1514 char *t;
1515
1516 p = original = "foobar waldo";
4034a06d 1517 assert_se(unquote_first_word(&p, &t, 0) > 0);
7629889c
LP		 1518 assert_se(streq(t, "foobar"));
1519 free(t);
1520 assert_se(p == original + 7);
1521
4034a06d 1522 assert_se(unquote_first_word(&p, &t, 0) > 0);
7629889c
LP		 1523 assert_se(streq(t, "waldo"));
1524 free(t);
1525 assert_se(p == original + 12);
1526
4034a06d 1527 assert_se(unquote_first_word(&p, &t, 0) == 0);
7629889c
LP		 1528 assert_se(!t);
1529 assert_se(p == original + 12);
1530
1531 p = original = "\"foobar\" \'waldo\'";
4034a06d 1532 assert_se(unquote_first_word(&p, &t, 0) > 0);
7629889c
LP		 1533 assert_se(streq(t, "foobar"));
1534 free(t);
1535 assert_se(p == original + 9);
1536
4034a06d 1537 assert_se(unquote_first_word(&p, &t, 0) > 0);
7629889c
LP		 1538 assert_se(streq(t, "waldo"));
1539 free(t);
1540 assert_se(p == original + 16);
1541
4034a06d 1542 assert_se(unquote_first_word(&p, &t, 0) == 0);
7629889c
LP		 1543 assert_se(!t);
1544 assert_se(p == original + 16);
1545
1546 p = original = "\"";
4034a06d 1547 assert_se(unquote_first_word(&p, &t, 0) == -EINVAL);
7629889c
LP		 1548 assert_se(p == original + 1);
1549
1550 p = original = "\'";
4034a06d 1551 assert_se(unquote_first_word(&p, &t, 0) == -EINVAL);
7629889c
LP		 1552 assert_se(p == original + 1);
1553
f32d2db1 1554 p = original = "\'fooo";
4034a06d 1555 assert_se(unquote_first_word(&p, &t, 0) == -EINVAL);
f32d2db1
LP		 1556 assert_se(p == original + 5);
1557
1558 p = original = "\'fooo";
4034a06d 1559 assert_se(unquote_first_word(&p, &t, UNQUOTE_RELAX) > 0);
f32d2db1 1560 assert_se(streq(t, "fooo"));
e1ba963f 1561 free(t);
f32d2db1
LP		 1562 assert_se(p == original + 5);
1563
7629889c 1564 p = original = "yay\'foo\'bar";
4034a06d 1565 assert_se(unquote_first_word(&p, &t, 0) > 0);
7629889c
LP		 1566 assert_se(streq(t, "yayfoobar"));
1567 free(t);
1568 assert_se(p == original + 11);
1569
1570 p = original = " foobar ";
4034a06d 1571 assert_se(unquote_first_word(&p, &t, 0) > 0);
7629889c
LP		 1572 assert_se(streq(t, "foobar"));
1573 free(t);
1574 assert_se(p == original + 12);
4034a06d
LP		 1575
1576 p = original = " foo\\ba\\x6ar ";
1577 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE) > 0);
1578 assert_se(streq(t, "foo\ba\x6ar"));
1579 free(t);
1580 assert_se(p == original + 13);
1581
1582 p = original = " foo\\ba\\x6ar ";
1583 assert_se(unquote_first_word(&p, &t, 0) > 0);
1584 assert_se(streq(t, "foobax6ar"));
1585 free(t);
1586 assert_se(p == original + 13);
8ebac1f9
LP		 1587
1588 p = original = " f\\u00f6o \"pi\\U0001F4A9le\" ";
1589 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE) > 0);
1590 assert_se(streq(t, "föo"));
1591 free(t);
1592 assert_se(p == original + 13);
1593
1594 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE) > 0);
1595 assert_se(streq(t, "pi\360\237\222\251le"));
1596 free(t);
1597 assert_se(p == original + 32);
d6293c07
FB		 1598
1599 p = original = "fooo\\";
1600 assert_se(unquote_first_word(&p, &t, UNQUOTE_RELAX) > 0);
1601 assert_se(streq(t, "fooo"));
1602 free(t);
1603 assert_se(p == original + 5);
1604
1605 p = original = "fooo\\";
1606 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE_RELAX) > 0);
1607 assert_se(streq(t, "fooo\\"));
1608 free(t);
1609 assert_se(p == original + 5);
1610
1611 p = original = "fooo\\";
1612 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE_RELAX|UNQUOTE_RELAX) > 0);
1613 assert_se(streq(t, "fooo\\"));
1614 free(t);
1615 assert_se(p == original + 5);
1616
1617 p = original = "fooo\\";
1618 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE|UNQUOTE_CUNESCAPE_RELAX) > 0);
1619 assert_se(streq(t, "fooo\\"));
1620 free(t);
1621 assert_se(p == original + 5);
1622
1623 p = original = "\"foo\\";
1624 assert_se(unquote_first_word(&p, &t, 0) == -EINVAL);
1625 assert_se(p == original + 5);
1626
1627 p = original = "\"foo\\";
1628 assert_se(unquote_first_word(&p, &t, UNQUOTE_RELAX) > 0);
1629 assert_se(streq(t, "foo"));
1630 free(t);
1631 assert_se(p == original + 5);
1632
1633 p = original = "\"foo\\";
1634 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE_RELAX) == -EINVAL);
1635 assert_se(p == original + 5);
1636
1637 p = original = "\"foo\\";
1638 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE_RELAX|UNQUOTE_RELAX) > 0);
1639 assert_se(streq(t, "foo\\"));
1640 free(t);
1641 assert_se(p == original + 5);
1642
1643 p = original = "\"foo\\";
1644 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE|UNQUOTE_CUNESCAPE_RELAX|UNQUOTE_RELAX) > 0);
1645 assert_se(streq(t, "foo\\"));
1646 free(t);
1647 assert_se(p == original + 5);
1648
1649 p = original = "fooo\\ bar quux";
1650 assert_se(unquote_first_word(&p, &t, UNQUOTE_RELAX) > 0);
1651 assert_se(streq(t, "fooo bar"));
1652 free(t);
1653 assert_se(p == original + 10);
1654
1655 p = original = "fooo\\ bar quux";
1656 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE_RELAX) > 0);
1657 assert_se(streq(t, "fooo bar"));
1658 free(t);
1659 assert_se(p == original + 10);
1660
1661 p = original = "fooo\\ bar quux";
1662 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE_RELAX|UNQUOTE_RELAX) > 0);
1663 assert_se(streq(t, "fooo bar"));
1664 free(t);
1665 assert_se(p == original + 10);
1666
1667 p = original = "fooo\\ bar quux";
1668 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE) == -EINVAL);
1669 assert_se(p == original + 5);
1670
1671 p = original = "fooo\\ bar quux";
1672 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE|UNQUOTE_CUNESCAPE_RELAX) > 0);
1673 assert_se(streq(t, "fooo\\ bar"));
1674 free(t);
1675 assert_se(p == original + 10);
1676
1677 p = original = "\\w+@\\K[\\d.]+";
1678 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE) == -EINVAL);
1679 assert_se(p == original + 1);
1680
1681 p = original = "\\w+@\\K[\\d.]+";
1682 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE|UNQUOTE_CUNESCAPE_RELAX) > 0);
1683 assert_se(streq(t, "\\w+@\\K[\\d.]+"));
1684 free(t);
1685 assert_se(p == original + 12);
1686
1687 p = original = "\\w+\\b";
1688 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE|UNQUOTE_CUNESCAPE_RELAX) > 0);
1689 assert_se(streq(t, "\\w+\b"));
1690 free(t);
1691 assert_se(p == original + 5);
14e685c2
RM		 1692
1693 p = original = "-N ''";
1694 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE) > 0);
1695 assert_se(streq(t, "-N"));
1696 free(t);
1697 assert_se(p == original + 3);
1698
1699 assert_se(unquote_first_word(&p, &t, UNQUOTE_CUNESCAPE) > 0);
1700 assert_se(streq(t, ""));
1701 free(t);
1702 assert_se(p == original + 5);
7629889c
LP		 1703}
1704
b59292b2
FB		 1705static void test_unquote_first_word_and_warn(void) {
1706 const char *p, *original;
1707 char *t;
1708
1709 p = original = "foobar waldo";
1710 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) > 0);
1711 assert_se(streq(t, "foobar"));
1712 free(t);
1713 assert_se(p == original + 7);
1714
1715 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) > 0);
1716 assert_se(streq(t, "waldo"));
1717 free(t);
1718 assert_se(p == original + 12);
1719
1720 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) == 0);
1721 assert_se(!t);
1722 assert_se(p == original + 12);
1723
1724 p = original = "\"foobar\" \'waldo\'";
1725 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) > 0);
1726 assert_se(streq(t, "foobar"));
1727 free(t);
1728 assert_se(p == original + 9);
1729
1730 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) > 0);
1731 assert_se(streq(t, "waldo"));
1732 free(t);
1733 assert_se(p == original + 16);
1734
1735 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) == 0);
1736 assert_se(!t);
1737 assert_se(p == original + 16);
1738
1739 p = original = "\"";
1740 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) == -EINVAL);
1741 assert_se(p == original + 1);
1742
1743 p = original = "\'";
1744 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) == -EINVAL);
1745 assert_se(p == original + 1);
1746
1747 p = original = "\'fooo";
1748 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) == -EINVAL);
1749 assert_se(p == original + 5);
1750
1751 p = original = "\'fooo";
1752 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_RELAX, NULL, "fake", 1, original) > 0);
1753 assert_se(streq(t, "fooo"));
1754 free(t);
1755 assert_se(p == original + 5);
1756
1757 p = original = " foo\\ba\\x6ar ";
1758 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE, NULL, "fake", 1, original) > 0);
1759 assert_se(streq(t, "foo\ba\x6ar"));
1760 free(t);
1761 assert_se(p == original + 13);
1762
1763 p = original = " foo\\ba\\x6ar ";
1764 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) > 0);
1765 assert_se(streq(t, "foobax6ar"));
1766 free(t);
1767 assert_se(p == original + 13);
1768
1769 p = original = " f\\u00f6o \"pi\\U0001F4A9le\" ";
1770 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE, NULL, "fake", 1, original) > 0);
1771 assert_se(streq(t, "föo"));
1772 free(t);
1773 assert_se(p == original + 13);
1774
1775 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE, NULL, "fake", 1, original) > 0);
1776 assert_se(streq(t, "pi\360\237\222\251le"));
1777 free(t);
1778 assert_se(p == original + 32);
1779
1780 p = original = "fooo\\";
1781 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_RELAX, NULL, "fake", 1, original) > 0);
1782 assert_se(streq(t, "fooo"));
1783 free(t);
1784 assert_se(p == original + 5);
1785
1786 p = original = "fooo\\";
1787 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) > 0);
1788 assert_se(streq(t, "fooo\\"));
1789 free(t);
1790 assert_se(p == original + 5);
1791
1792 p = original = "fooo\\";
1793 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE, NULL, "fake", 1, original) > 0);
1794 assert_se(streq(t, "fooo\\"));
1795 free(t);
1796 assert_se(p == original + 5);
1797
1798 p = original = "\"foo\\";
1799 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) == -EINVAL);
1800 assert_se(p == original + 5);
1801
1802 p = original = "\"foo\\";
1803 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_RELAX, NULL, "fake", 1, original) > 0);
1804 assert_se(streq(t, "foo"));
1805 free(t);
1806 assert_se(p == original + 5);
1807
1808 p = original = "\"foo\\";
1809 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE, NULL, "fake", 1, original) == -EINVAL);
1810 assert_se(p == original + 5);
1811
1812 p = original = "\"foo\\";
1813 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE|UNQUOTE_RELAX, NULL, "fake", 1, original) > 0);
1814 assert_se(streq(t, "foo"));
1815 free(t);
1816 assert_se(p == original + 5);
1817
1818 p = original = "fooo\\ bar quux";
1819 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_RELAX, NULL, "fake", 1, original) > 0);
1820 assert_se(streq(t, "fooo bar"));
1821 free(t);
1822 assert_se(p == original + 10);
1823
1824 p = original = "fooo\\ bar quux";
1825 assert_se(unquote_first_word_and_warn(&p, &t, 0, NULL, "fake", 1, original) > 0);
1826 assert_se(streq(t, "fooo bar"));
1827 free(t);
1828 assert_se(p == original + 10);
1829
1830 p = original = "fooo\\ bar quux";
1831 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE, NULL, "fake", 1, original) > 0);
1832 assert_se(streq(t, "fooo\\ bar"));
1833 free(t);
1834 assert_se(p == original + 10);
1835
1836 p = original = "\\w+@\\K[\\d.]+";
1837 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE, NULL, "fake", 1, original) > 0);
1838 assert_se(streq(t, "\\w+@\\K[\\d.]+"));
1839 free(t);
1840 assert_se(p == original + 12);
1841
1842 p = original = "\\w+\\b";
1843 assert_se(unquote_first_word_and_warn(&p, &t, UNQUOTE_CUNESCAPE, NULL, "fake", 1, original) > 0);
1844 assert_se(streq(t, "\\w+\b"));
1845 free(t);
1846 assert_se(p == original + 5);
1847}
1848
7629889c
LP		 1849static void test_unquote_many_words(void) {
1850 const char *p, *original;
1851 char *a, *b, *c;
1852
1853 p = original = "foobar waldi piep";
4034a06d 1854 assert_se(unquote_many_words(&p, 0, &a, &b, &c, NULL) == 3);
7629889c
LP		 1855 assert_se(p == original + 17);
1856 assert_se(streq_ptr(a, "foobar"));
1857 assert_se(streq_ptr(b, "waldi"));
1858 assert_se(streq_ptr(c, "piep"));
1859 free(a);
1860 free(b);
1861 free(c);
1862
1863 p = original = "'foobar' wa\"ld\"i ";
4034a06d 1864 assert_se(unquote_many_words(&p, 0, &a, &b, &c, NULL) == 2);
7629889c
LP		 1865 assert_se(p == original + 19);
1866 assert_se(streq_ptr(a, "foobar"));
1867 assert_se(streq_ptr(b, "waldi"));
1868 assert_se(streq_ptr(c, NULL));
1869 free(a);
1870 free(b);
1871
1872 p = original = "";
4034a06d 1873 assert_se(unquote_many_words(&p, 0, &a, &b, &c, NULL) == 0);
7629889c
LP		 1874 assert_se(p == original);
1875 assert_se(streq_ptr(a, NULL));
1876 assert_se(streq_ptr(b, NULL));
1877 assert_se(streq_ptr(c, NULL));
1878
1879 p = original = " ";
4034a06d 1880 assert_se(unquote_many_words(&p, 0, &a, &b, &c, NULL) == 0);
7629889c
LP		 1881 assert_se(p == original+2);
1882 assert_se(streq_ptr(a, NULL));
1883 assert_se(streq_ptr(b, NULL));
1884 assert_se(streq_ptr(c, NULL));
1885
1886 p = original = "foobar";
4034a06d 1887 assert_se(unquote_many_words(&p, 0, NULL) == 0);
7629889c
LP		 1888 assert_se(p == original);
1889
1890 p = original = "foobar waldi";
4034a06d 1891 assert_se(unquote_many_words(&p, 0, &a, NULL) == 1);
7629889c
LP		 1892 assert_se(p == original+7);
1893 assert_se(streq_ptr(a, "foobar"));
eee84633 1894 free(a);
7629889c
LP		 1895
1896 p = original = " foobar ";
4034a06d 1897 assert_se(unquote_many_words(&p, 0, &a, NULL) == 1);
7629889c
LP		 1898 assert_se(p == original+15);
1899 assert_se(streq_ptr(a, "foobar"));
eee84633 1900 free(a);
7629889c
LP		 1901}
1902
f32d2db1
LP		 1903static int parse_item(const char *key, const char *value) {
1904 assert_se(key);
1905
1906 log_info("kernel cmdline option <%s> = <%s>", key, strna(value));
1907 return 0;
1908}
1909
1910static void test_parse_proc_cmdline(void) {
1911 assert_se(parse_proc_cmdline(parse_item) >= 0);
1912}
1913
ee05e779
ZJS		 1914static void test_raw_clone(void) {
1915 pid_t parent, pid, pid2;
1916
1917 parent = getpid();
1918 log_info("before clone: getpid()→"PID_FMT, parent);
1919 assert_se(raw_getpid() == parent);
1920
1921 pid = raw_clone(0, NULL);
e50221bf 1922 assert_se(pid >= 0);
ee05e779
ZJS		 1923
1924 pid2 = raw_getpid();
1925 log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" raw_getpid()→"PID_FMT,
1926 pid, getpid(), pid2);
0289a5bc 1927 if (pid == 0) {
e50221bf 1928 assert_se(pid2 != parent);
0289a5bc
FB		 1929 _exit(EXIT_SUCCESS);
1930 } else {
1931 int status;
1932
e50221bf 1933 assert_se(pid2 == parent);
0289a5bc
FB		 1934 waitpid(pid, &status, __WCLONE);
1935 assert_se(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
1936 }
ee05e779
ZJS		 1937}
1938
f7ad54a3
LP		 1939static void test_same_fd(void) {
1940 _cleanup_close_pair_ int p[2] = { -1, -1 };
1941 _cleanup_close_ int a = -1, b = -1, c = -1;
1942
1943 assert_se(pipe2(p, O_CLOEXEC) >= 0);
1944 assert_se((a = dup(p[0])) >= 0);
1945 assert_se((b = open("/dev/null", O_RDONLY|O_CLOEXEC)) >= 0);
1946 assert_se((c = dup(a)) >= 0);
1947
1948 assert_se(same_fd(p[0], p[0]) > 0);
1949 assert_se(same_fd(p[1], p[1]) > 0);
1950 assert_se(same_fd(a, a) > 0);
1951 assert_se(same_fd(b, b) > 0);
1952
1953 assert_se(same_fd(a, p[0]) > 0);
1954 assert_se(same_fd(p[0], a) > 0);
1955 assert_se(same_fd(c, p[0]) > 0);
1956 assert_se(same_fd(p[0], c) > 0);
1957 assert_se(same_fd(a, c) > 0);
1958 assert_se(same_fd(c, a) > 0);
1959
1960 assert_se(same_fd(p[0], p[1]) == 0);
1961 assert_se(same_fd(p[1], p[0]) == 0);
1962 assert_se(same_fd(p[0], b) == 0);
1963 assert_se(same_fd(b, p[0]) == 0);
1964 assert_se(same_fd(p[1], a) == 0);
1965 assert_se(same_fd(a, p[1]) == 0);
1966 assert_se(same_fd(p[1], b) == 0);
1967 assert_se(same_fd(b, p[1]) == 0);
1968
1969 assert_se(same_fd(a, b) == 0);
1970 assert_se(same_fd(b, a) == 0);
1971}
1972
8cb4ab00
LP		 1973static void test_uid_ptr(void) {
1974
1975 assert_se(UID_TO_PTR(0) != NULL);
1976 assert_se(UID_TO_PTR(1000) != NULL);
1977
1978 assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
1979 assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
1980}
1981
ff6a7460
LP		 1982static void test_sparse_write_one(int fd, const char *buffer, size_t n) {
1983 char check[n];
1984
1985 assert_se(lseek(fd, 0, SEEK_SET) == 0);
1986 assert_se(ftruncate(fd, 0) >= 0);
1987 assert_se(sparse_write(fd, buffer, n, 4) == (ssize_t) n);
1988
1989 assert_se(lseek(fd, 0, SEEK_CUR) == (off_t) n);
1990 assert_se(ftruncate(fd, n) >= 0);
1991
1992 assert_se(lseek(fd, 0, SEEK_SET) == 0);
1993 assert_se(read(fd, check, n) == (ssize_t) n);
1994
1995 assert_se(memcmp(buffer, check, n) == 0);
1996}
1997
1998static void test_sparse_write(void) {
1999 const char test_a[] = "test";
2000 const char test_b[] = "\0\0\0\0test\0\0\0\0";
2001 const char test_c[] = "\0\0test\0\0\0\0";
2002 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";
2003 const char test_e[] = "test\0\0\0\0test";
2004 _cleanup_close_ int fd = -1;
2005 char fn[] = "/tmp/sparseXXXXXX";
2006
2007 fd = mkostemp(fn, O_CLOEXEC);
2008 assert_se(fd >= 0);
2009 unlink(fn);
2010
2011 test_sparse_write_one(fd, test_a, sizeof(test_a));
2012 test_sparse_write_one(fd, test_b, sizeof(test_b));
2013 test_sparse_write_one(fd, test_c, sizeof(test_c));
2014 test_sparse_write_one(fd, test_d, sizeof(test_d));
2015 test_sparse_write_one(fd, test_e, sizeof(test_e));
2016}
2017
019c7fba
LP		 2018static void test_shell_maybe_quote_one(const char *s, const char *expected) {
2019 _cleanup_free_ char *r;
2020
2021 assert_se(r = shell_maybe_quote(s));
2022 assert_se(streq(r, expected));
2023}
2024
2025static void test_shell_maybe_quote(void) {
2026
2027 test_shell_maybe_quote_one("", "");
2028 test_shell_maybe_quote_one("\\", "\"\\\\\"");
2029 test_shell_maybe_quote_one("\"", "\"\\\"\"");
2030 test_shell_maybe_quote_one("foobar", "foobar");
2031 test_shell_maybe_quote_one("foo bar", "\"foo bar\"");
2032 test_shell_maybe_quote_one("foo \"bar\" waldo", "\"foo \\\"bar\\\" waldo\"");
2033 test_shell_maybe_quote_one("foo$bar", "\"foo\\$bar\"");
2034}
2035
2ff7b0a5
LP		 2036static void test_parse_mode(void) {
2037 mode_t m;
2038
2039 assert_se(parse_mode("-1", &m) < 0);
2040 assert_se(parse_mode("", &m) < 0);
2041 assert_se(parse_mode("888", &m) < 0);
2042 assert_se(parse_mode("77777", &m) < 0);
2043
2044 assert_se(parse_mode("544", &m) >= 0 && m == 0544);
2045 assert_se(parse_mode("777", &m) >= 0 && m == 0777);
2046 assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
2047 assert_se(parse_mode("0", &m) >= 0 && m == 0);
2048}
2049
14bcf25c
LP		 2050static void test_tempfn(void) {
2051 char *ret = NULL, *p;
2052
2053 assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
2054 assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
2055 free(ret);
2056
2057 assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
2058 assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
2059 free(ret);
2060
2061 assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
2062 assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
2063 assert_se(strlen(p) == 16);
2064 assert_se(in_charset(p, "0123456789abcdef"));
2065 free(ret);
2066
2067 assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
2068 assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
2069 assert_se(strlen(p) == 16);
2070 assert_se(in_charset(p, "0123456789abcdef"));
2071 free(ret);
2072
2073 assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
2074 assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
2075 assert_se(strlen(p) == 16);
2076 assert_se(in_charset(p, "0123456789abcdef"));
2077 free(ret);
2078
2079 assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
2080 assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
2081 assert_se(strlen(p) == 16);
2082 assert_se(in_charset(p, "0123456789abcdef"));
2083 free(ret);
2084}
2085
539ad707 2086int main(int argc, char *argv[]) {
9480794b
ZJS		 2087 log_parse_environment();
2088 log_open();
2089
539ad707 2090 test_streq_ptr();
625e870b 2091 test_align_power2();
7242d742 2092 test_max();
fb835651 2093 test_container_of();
95d78c7e 2094 test_alloca();
180a60bc 2095 test_div_round_up();
539ad707 2096 test_first_word();
dbd73f9e 2097 test_close_many();
8354c34e 2098 test_parse_boolean();
8d99e5f5
TA		 2099 test_parse_pid();
2100 test_parse_uid();
2101 test_safe_atolli();
2102 test_safe_atod();
dbd73f9e 2103 test_strappend();
1ef04f0b
TA		 2104 test_strstrip();
2105 test_delete_chars();
2106 test_in_charset();
44f4c86c
DB		 2107 test_hexchar();
2108 test_unhexchar();
919a7f5f
TG		 2109 test_base32hexchar();
2110 test_unbase32hexchar();
13a5d76b
TG		 2111 test_base64char();
2112 test_unbase64char();
44f4c86c
DB		 2113 test_octchar();
2114 test_unoctchar();
2115 test_decchar();
2116 test_undecchar();
30494563 2117 test_unhexmem();
919a7f5f
TG		 2118 test_base32hexmem();
2119 test_unbase32hexmem();
13a5d76b
TG		 2120 test_base64mem();
2121 test_unbase64mem();
b4ecc959
TA		 2122 test_cescape();
2123 test_cunescape();
1ef04f0b 2124 test_foreach_word();
539ad707 2125 test_foreach_word_quoted();
0d585d82 2126 test_memdup_multiply();
aa3c5cf8 2127 test_hostname_is_valid();
139e5336 2128 test_read_hostname_config();
144e51ec 2129 test_u64log2();
2a371001 2130 test_protect_errno();
5556b5fe 2131 test_parse_size();
9480794b 2132 test_config_parse_iec_off();
b4ecc959
TA		 2133 test_strextend();
2134 test_strrep();
d4ac85c6 2135 test_split_pair();
22f5f628 2136 test_fstab_node_to_udev_node();
893fa014 2137 test_get_files_in_directory();
cabb7806 2138 test_in_set();
87b02843 2139 test_writing_tmpfile();
29bfbcd6 2140 test_hexdump();
8fe90522 2141 test_log2i();
c4a7b2c5 2142 test_foreach_string();
ae6c3cc0 2143 test_filename_is_valid();
1cb1767a 2144 test_string_has_cc();
927be00c
RC		 2145 test_ascii_strlower();
2146 test_files_same();
2147 test_is_valid_documentation_url();
2148 test_file_in_same_dir();
2149 test_endswith();
2150 test_close_nointr();
2151 test_unlink_noerrno();
2152 test_readlink_and_make_absolute();
927be00c
RC		 2153 test_ignore_signals();
2154 test_strshorten();
63c372cb 2155 test_strjoina();
8852362b 2156 test_is_symlink();
8852362b
RC		 2157 test_search_and_fopen();
2158 test_search_and_fopen_nulstr();
2159 test_glob_exists();
2160 test_execute_directory();
7629889c 2161 test_unquote_first_word();
b59292b2 2162 test_unquote_first_word_and_warn();
7629889c 2163 test_unquote_many_words();
f32d2db1 2164 test_parse_proc_cmdline();
ee05e779 2165 test_raw_clone();
f7ad54a3 2166 test_same_fd();
8cb4ab00 2167 test_uid_ptr();
ff6a7460 2168 test_sparse_write();
019c7fba 2169 test_shell_maybe_quote();
2ff7b0a5 2170 test_parse_mode();
14bcf25c 2171 test_tempfn();
539ad707
TA		 2172
2173 return 0;
2174}
Unnamed repository; edit this file 'description' to name the repository.