]> 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 #1629 from ssahani/vxlan
[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
618234a5 23#include <errno.h>
dbd73f9e 24#include <fcntl.h>
618234a5
LP		 25#include <signal.h>
26#include <string.h>
df241a67 27#include <sys/types.h>
8852362b 28#include <sys/wait.h>
df241a67 29#include <sys/xattr.h>
618234a5 30#include <unistd.h>
539ad707 31
b5efdb8a 32#include "alloc-util.h"
618234a5
LP		 33#include "conf-parser.h"
34#include "cpu-set-util.h"
65b3903f 35#include "def.h"
4f5dd394 36#include "escape.h"
c004493c 37#include "fd-util.h"
65b3903f 38#include "fileio.h"
f4f15635 39#include "fs-util.h"
6550203e 40#include "fstab-util.h"
7d50b32a 41#include "glob-util.h"
6550203e 42#include "hexdecoct.h"
c004493c 43#include "io-util.h"
618234a5 44#include "mkdir.h"
6bedfcbb 45#include "parse-util.h"
89a5a90c 46#include "path-util.h"
4e731273 47#include "proc-cmdline.h"
0b452006 48#include "process-util.h"
618234a5 49#include "rm-rf.h"
24882e06 50#include "signal-util.h"
c573dcfe 51#include "special.h"
8fcde012 52#include "stat-util.h"
07630cea 53#include "string-util.h"
618234a5 54#include "strv.h"
6bedfcbb 55#include "user-util.h"
618234a5
LP		 56#include "util.h"
57#include "virt.h"
49cf4170 58#include "web-util.h"
7d50b32a 59#include "xattr-util.h"
539ad707
TA		 60
61static void test_streq_ptr(void) {
8354c34e
TA		 62 assert_se(streq_ptr(NULL, NULL));
63 assert_se(!streq_ptr("abc", "cdef"));
539ad707
TA		 64}
65
625e870b
DH		 66static void test_align_power2(void) {
67 unsigned long i, p2;
68
69 assert_se(ALIGN_POWER2(0) == 0);
70 assert_se(ALIGN_POWER2(1) == 1);
71 assert_se(ALIGN_POWER2(2) == 2);
72 assert_se(ALIGN_POWER2(3) == 4);
73 assert_se(ALIGN_POWER2(12) == 16);
74
75 assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
76 assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
77 assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
78 assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
79 assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
80
81 for (i = 1; i < 131071; ++i) {
82 for (p2 = 1; p2 < i; p2 <<= 1)
83 /* empty */ ;
84
85 assert_se(ALIGN_POWER2(i) == p2);
86 }
87
88 for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
89 for (p2 = 1; p2 && p2 < i; p2 <<= 1)
90 /* empty */ ;
91
92 assert_se(ALIGN_POWER2(i) == p2);
93 }
94}
95
7242d742
DH		 96static void test_max(void) {
97 static const struct {
98 int a;
99 int b[CONST_MAX(10, 100)];
100 } val1 = {
101 .a = CONST_MAX(10, 100),
102 };
103 int d = 0;
104
105 assert_cc(sizeof(val1.b) == sizeof(int) * 100);
106
107 /* CONST_MAX returns (void) instead of a value if the passed arguments
108 * are not of the same type or not constant expressions. */
109 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
7242d742
DH		 110 assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
111
112 assert_se(val1.a == 100);
113 assert_se(MAX(++d, 0) == 1);
114 assert_se(d == 1);
40a1eebd
DH		 115
116 assert_cc(MAXSIZE(char[3], uint16_t) == 3);
117 assert_cc(MAXSIZE(char[3], uint32_t) == 4);
118 assert_cc(MAXSIZE(char, long) == sizeof(long));
667a0377
DH		 119
120 assert_se(MAX(-5, 5) == 5);
121 assert_se(MAX(5, 5) == 5);
122 assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
123 assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
124 assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
125 assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
126 assert_se(LESS_BY(8, 4) == 4);
127 assert_se(LESS_BY(8, 8) == 0);
128 assert_se(LESS_BY(4, 8) == 0);
129 assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
130 assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
131 assert_se(CLAMP(-5, 0, 1) == 0);
132 assert_se(CLAMP(5, 0, 1) == 1);
133 assert_se(CLAMP(5, -10, 1) == 1);
134 assert_se(CLAMP(5, -10, 10) == 5);
135 assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
7242d742
DH		 136}
137
fb835651
DH		 138static void test_container_of(void) {
139 struct mytype {
140 uint8_t pad1[3];
141 uint64_t v1;
142 uint8_t pad2[2];
143 uint32_t v2;
144 } _packed_ myval = { };
145
146 assert_cc(sizeof(myval) == 17);
147 assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
148 assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
149 assert_se(container_of(&container_of(&myval.v2,
150 struct mytype,
151 v2)->v1,
152 struct mytype,
153 v1) == &myval);
154}
155
95d78c7e
DH		 156static void test_alloca(void) {
157 static const uint8_t zero[997] = { };
158 char *t;
159
160 t = alloca_align(17, 512);
161 assert_se(!((uintptr_t)t & 0xff));
162 memzero(t, 17);
163
164 t = alloca0_align(997, 1024);
165 assert_se(!((uintptr_t)t & 0x1ff));
166 assert_se(!memcmp(t, zero, 997));
167}
168
180a60bc
DH		 169static void test_div_round_up(void) {
170 int div;
171
172 /* basic tests */
173 assert_se(DIV_ROUND_UP(0, 8) == 0);
174 assert_se(DIV_ROUND_UP(1, 8) == 1);
175 assert_se(DIV_ROUND_UP(8, 8) == 1);
176 assert_se(DIV_ROUND_UP(12, 8) == 2);
177 assert_se(DIV_ROUND_UP(16, 8) == 2);
178
179 /* test multiple evaluation */
180 div = 0;
181 assert_se(DIV_ROUND_UP(div++, 8) == 0 && div == 1);
182 assert_se(DIV_ROUND_UP(++div, 8) == 1 && div == 2);
183 assert_se(DIV_ROUND_UP(8, div++) == 4 && div == 3);
184 assert_se(DIV_ROUND_UP(8, ++div) == 2 && div == 4);
185
186 /* overflow test with exact division */
187 assert_se(sizeof(0U) == 4);
188 assert_se(0xfffffffaU % 10U == 0U);
189 assert_se(0xfffffffaU / 10U == 429496729U);
190 assert_se(DIV_ROUND_UP(0xfffffffaU, 10U) == 429496729U);
191 assert_se((0xfffffffaU + 10U - 1U) / 10U == 0U);
192 assert_se(0xfffffffaU / 10U + !!(0xfffffffaU % 10U) == 429496729U);
193
194 /* overflow test with rounded division */
195 assert_se(0xfffffffdU % 10U == 3U);
196 assert_se(0xfffffffdU / 10U == 429496729U);
197 assert_se(DIV_ROUND_UP(0xfffffffdU, 10U) == 429496730U);
198 assert_se((0xfffffffdU + 10U - 1U) / 10U == 0U);
199 assert_se(0xfffffffdU / 10U + !!(0xfffffffdU % 10U) == 429496730U);
200}
201
539ad707 202static void test_first_word(void) {
8354c34e
TA		 203 assert_se(first_word("Hello", ""));
204 assert_se(first_word("Hello", "Hello"));
205 assert_se(first_word("Hello world", "Hello"));
206 assert_se(first_word("Hello\tworld", "Hello"));
207 assert_se(first_word("Hello\nworld", "Hello"));
208 assert_se(first_word("Hello\rworld", "Hello"));
209 assert_se(first_word("Hello ", "Hello"));
210
211 assert_se(!first_word("Hello", "Hellooo"));
212 assert_se(!first_word("Hello", "xxxxx"));
213 assert_se(!first_word("Hellooo", "Hello"));
214}
215
dbd73f9e
TA		 216static void test_close_many(void) {
217 int fds[3];
218 char name0[] = "/tmp/test-close-many.XXXXXX";
219 char name1[] = "/tmp/test-close-many.XXXXXX";
220 char name2[] = "/tmp/test-close-many.XXXXXX";
221
2d5bdf5b
LP		 222 fds[0] = mkostemp_safe(name0, O_RDWR|O_CLOEXEC);
223 fds[1] = mkostemp_safe(name1, O_RDWR|O_CLOEXEC);
224 fds[2] = mkostemp_safe(name2, O_RDWR|O_CLOEXEC);
dbd73f9e
TA		 225
226 close_many(fds, 2);
227
228 assert_se(fcntl(fds[0], F_GETFD) == -1);
229 assert_se(fcntl(fds[1], F_GETFD) == -1);
230 assert_se(fcntl(fds[2], F_GETFD) >= 0);
231
03e334a1 232 safe_close(fds[2]);
dbd73f9e
TA		 233
234 unlink(name0);
235 unlink(name1);
236 unlink(name2);
237}
238
8d99e5f5
TA		 239static void test_parse_uid(void) {
240 int r;
241 uid_t uid;
242
243 r = parse_uid("100", &uid);
244 assert_se(r == 0);
245 assert_se(uid == 100);
ff9265d0
DM		 246
247 r = parse_uid("65535", &uid);
248 assert_se(r == -ENXIO);
ef5c570e
LP		 249
250 r = parse_uid("asdsdas", &uid);
251 assert_se(r == -EINVAL);
ff9265d0
DM		 252}
253
dbd73f9e 254static void test_strappend(void) {
998b087f 255 _cleanup_free_ char *t1, *t2, *t3, *t4;
dbd73f9e 256
998b087f
TA		 257 t1 = strappend(NULL, NULL);
258 assert_se(streq(t1, ""));
dbd73f9e 259
998b087f
TA		 260 t2 = strappend(NULL, "suf");
261 assert_se(streq(t2, "suf"));
dbd73f9e 262
998b087f
TA		 263 t3 = strappend("pre", NULL);
264 assert_se(streq(t3, "pre"));
dbd73f9e 265
998b087f
TA		 266 t4 = strappend("pre", "suf");
267 assert_se(streq(t4, "presuf"));
dbd73f9e
TA		 268}
269
1ef04f0b 270static void test_strstrip(void) {
998b087f
TA		 271 char *r;
272 char input[] = " hello, waldo. ";
1ef04f0b 273
998b087f
TA		 274 r = strstrip(input);
275 assert_se(streq(r, "hello, waldo."));
1ef04f0b
TA		 276}
277
278static void test_delete_chars(void) {
998b087f
TA		 279 char *r;
280 char input[] = " hello, waldo. abc";
1ef04f0b 281
998b087f
TA		 282 r = delete_chars(input, WHITESPACE);
283 assert_se(streq(r, "hello,waldo.abc"));
1ef04f0b
TA		 284}
285
286static void test_in_charset(void) {
998b087f
TA		 287 assert_se(in_charset("dddaaabbbcccc", "abcd"));
288 assert_se(!in_charset("dddaaabbbcccc", "abc f"));
1ef04f0b
TA		 289}
290
44f4c86c
DB		 291static void test_hexchar(void) {
292 assert_se(hexchar(0xa) == 'a');
293 assert_se(hexchar(0x0) == '0');
294}
295
296static void test_unhexchar(void) {
297 assert_se(unhexchar('a') == 0xA);
298 assert_se(unhexchar('A') == 0xA);
299 assert_se(unhexchar('0') == 0x0);
300}
301
919a7f5f
TG		 302static void test_base32hexchar(void) {
303 assert_se(base32hexchar(0) == '0');
304 assert_se(base32hexchar(9) == '9');
305 assert_se(base32hexchar(10) == 'A');
306 assert_se(base32hexchar(31) == 'V');
307}
308
309static void test_unbase32hexchar(void) {
310 assert_se(unbase32hexchar('0') == 0);
311 assert_se(unbase32hexchar('9') == 9);
312 assert_se(unbase32hexchar('A') == 10);
313 assert_se(unbase32hexchar('V') == 31);
314 assert_se(unbase32hexchar('=') == -EINVAL);
315}
316
13a5d76b
TG		 317static void test_base64char(void) {
318 assert_se(base64char(0) == 'A');
319 assert_se(base64char(26) == 'a');
320 assert_se(base64char(63) == '/');
321}
322
323static void test_unbase64char(void) {
324 assert_se(unbase64char('A') == 0);
325 assert_se(unbase64char('Z') == 25);
326 assert_se(unbase64char('a') == 26);
327 assert_se(unbase64char('z') == 51);
328 assert_se(unbase64char('0') == 52);
329 assert_se(unbase64char('9') == 61);
330 assert_se(unbase64char('+') == 62);
331 assert_se(unbase64char('/') == 63);
332 assert_se(unbase64char('=') == -EINVAL);
333}
334
44f4c86c
DB		 335static void test_octchar(void) {
336 assert_se(octchar(00) == '0');
337 assert_se(octchar(07) == '7');
338}
339
340static void test_unoctchar(void) {
341 assert_se(unoctchar('0') == 00);
342 assert_se(unoctchar('7') == 07);
343}
344
345static void test_decchar(void) {
346 assert_se(decchar(0) == '0');
347 assert_se(decchar(9) == '9');
348}
349
350static void test_undecchar(void) {
351 assert_se(undecchar('0') == 0);
352 assert_se(undecchar('9') == 9);
353}
354
30494563
TG		 355static void test_unhexmem(void) {
356 const char *hex = "efa214921";
357 const char *hex_invalid = "efa214921o";
358 _cleanup_free_ char *hex2 = NULL;
359 _cleanup_free_ void *mem = NULL;
360 size_t len;
361
362 assert_se(unhexmem(hex, strlen(hex), &mem, &len) == 0);
363 assert_se(unhexmem(hex, strlen(hex) + 1, &mem, &len) == -EINVAL);
364 assert_se(unhexmem(hex_invalid, strlen(hex_invalid), &mem, &len) == -EINVAL);
365
366 assert_se((hex2 = hexmem(mem, len)));
367
368 free(mem);
369
370 assert_se(memcmp(hex, hex2, strlen(hex)) == 0);
371
372 free(hex2);
373
374 assert_se(unhexmem(hex, strlen(hex) - 1, &mem, &len) == 0);
375 assert_se((hex2 = hexmem(mem, len)));
376 assert_se(memcmp(hex, hex2, strlen(hex) - 1) == 0);
377}
378
919a7f5f
TG		 379/* https://tools.ietf.org/html/rfc4648#section-10 */
380static void test_base32hexmem(void) {
381 char *b32;
382
383 b32 = base32hexmem("", strlen(""), true);
384 assert_se(b32);
385 assert_se(streq(b32, ""));
386 free(b32);
387
388 b32 = base32hexmem("f", strlen("f"), true);
389 assert_se(b32);
390 assert_se(streq(b32, "CO======"));
391 free(b32);
392
393 b32 = base32hexmem("fo", strlen("fo"), true);
394 assert_se(b32);
395 assert_se(streq(b32, "CPNG===="));
396 free(b32);
397
398 b32 = base32hexmem("foo", strlen("foo"), true);
399 assert_se(b32);
400 assert_se(streq(b32, "CPNMU==="));
401 free(b32);
402
403 b32 = base32hexmem("foob", strlen("foob"), true);
404 assert_se(b32);
405 assert_se(streq(b32, "CPNMUOG="));
406 free(b32);
407
408 b32 = base32hexmem("fooba", strlen("fooba"), true);
409 assert_se(b32);
410 assert_se(streq(b32, "CPNMUOJ1"));
411 free(b32);
412
413 b32 = base32hexmem("foobar", strlen("foobar"), true);
414 assert_se(b32);
415 assert_se(streq(b32, "CPNMUOJ1E8======"));
416 free(b32);
417
418 b32 = base32hexmem("", strlen(""), false);
419 assert_se(b32);
420 assert_se(streq(b32, ""));
421 free(b32);
422
423 b32 = base32hexmem("f", strlen("f"), false);
424 assert_se(b32);
425 assert_se(streq(b32, "CO"));
426 free(b32);
427
428 b32 = base32hexmem("fo", strlen("fo"), false);
429 assert_se(b32);
430 assert_se(streq(b32, "CPNG"));
431 free(b32);
432
433 b32 = base32hexmem("foo", strlen("foo"), false);
434 assert_se(b32);
435 assert_se(streq(b32, "CPNMU"));
436 free(b32);
437
438 b32 = base32hexmem("foob", strlen("foob"), false);
439 assert_se(b32);
440 assert_se(streq(b32, "CPNMUOG"));
441 free(b32);
442
443 b32 = base32hexmem("fooba", strlen("fooba"), false);
444 assert_se(b32);
445 assert_se(streq(b32, "CPNMUOJ1"));
446 free(b32);
447
448 b32 = base32hexmem("foobar", strlen("foobar"), false);
449 assert_se(b32);
450 assert_se(streq(b32, "CPNMUOJ1E8"));
451 free(b32);
452}
453
454static void test_unbase32hexmem(void) {
455 void *mem;
456 size_t len;
457
458 assert_se(unbase32hexmem("", strlen(""), true, &mem, &len) == 0);
459 assert_se(streq(strndupa(mem, len), ""));
460 free(mem);
461
462 assert_se(unbase32hexmem("CO======", strlen("CO======"), true, &mem, &len) == 0);
463 assert_se(streq(strndupa(mem, len), "f"));
464 free(mem);
465
466 assert_se(unbase32hexmem("CPNG====", strlen("CPNG===="), true, &mem, &len) == 0);
467 assert_se(streq(strndupa(mem, len), "fo"));
468 free(mem);
469
470 assert_se(unbase32hexmem("CPNMU===", strlen("CPNMU==="), true, &mem, &len) == 0);
471 assert_se(streq(strndupa(mem, len), "foo"));
472 free(mem);
473
474 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), true, &mem, &len) == 0);
475 assert_se(streq(strndupa(mem, len), "foob"));
476 free(mem);
477
478 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == 0);
479 assert_se(streq(strndupa(mem, len), "fooba"));
480 free(mem);
481
482 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), true, &mem, &len) == 0);
483 assert_se(streq(strndupa(mem, len), "foobar"));
484 free(mem);
485
486 assert_se(unbase32hexmem("A", strlen("A"), true, &mem, &len) == -EINVAL);
487 assert_se(unbase32hexmem("A=======", strlen("A======="), true, &mem, &len) == -EINVAL);
488 assert_se(unbase32hexmem("AAA=====", strlen("AAA====="), true, &mem, &len) == -EINVAL);
489 assert_se(unbase32hexmem("AAAAAA==", strlen("AAAAAA=="), true, &mem, &len) == -EINVAL);
490 assert_se(unbase32hexmem("AB======", strlen("AB======"), true, &mem, &len) == -EINVAL);
491 assert_se(unbase32hexmem("AAAB====", strlen("AAAB===="), true, &mem, &len) == -EINVAL);
492 assert_se(unbase32hexmem("AAAAB===", strlen("AAAAB==="), true, &mem, &len) == -EINVAL);
493 assert_se(unbase32hexmem("AAAAAAB=", strlen("AAAAAAB="), true, &mem, &len) == -EINVAL);
494
ff9265d0
DM		 495 assert_se(unbase32hexmem("XPNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
496 assert_se(unbase32hexmem("CXNMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
497 assert_se(unbase32hexmem("CPXMUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
498 assert_se(unbase32hexmem("CPNXUOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
499 assert_se(unbase32hexmem("CPNMXOJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
500 assert_se(unbase32hexmem("CPNMUXJ1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
501 assert_se(unbase32hexmem("CPNMUOX1", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
502 assert_se(unbase32hexmem("CPNMUOJX", strlen("CPNMUOJ1"), true, &mem, &len) == -EINVAL);
503
919a7f5f
TG		 504 assert_se(unbase32hexmem("", strlen(""), false, &mem, &len) == 0);
505 assert_se(streq(strndupa(mem, len), ""));
506 free(mem);
507
508 assert_se(unbase32hexmem("CO", strlen("CO"), false, &mem, &len) == 0);
509 assert_se(streq(strndupa(mem, len), "f"));
510 free(mem);
511
512 assert_se(unbase32hexmem("CPNG", strlen("CPNG"), false, &mem, &len) == 0);
513 assert_se(streq(strndupa(mem, len), "fo"));
514 free(mem);
515
516 assert_se(unbase32hexmem("CPNMU", strlen("CPNMU"), false, &mem, &len) == 0);
517 assert_se(streq(strndupa(mem, len), "foo"));
518 free(mem);
519
520 assert_se(unbase32hexmem("CPNMUOG", strlen("CPNMUOG"), false, &mem, &len) == 0);
521 assert_se(streq(strndupa(mem, len), "foob"));
522 free(mem);
523
524 assert_se(unbase32hexmem("CPNMUOJ1", strlen("CPNMUOJ1"), false, &mem, &len) == 0);
525 assert_se(streq(strndupa(mem, len), "fooba"));
526 free(mem);
527
528 assert_se(unbase32hexmem("CPNMUOJ1E8", strlen("CPNMUOJ1E8"), false, &mem, &len) == 0);
529 assert_se(streq(strndupa(mem, len), "foobar"));
530 free(mem);
531
532 assert_se(unbase32hexmem("CPNMUOG=", strlen("CPNMUOG="), false, &mem, &len) == -EINVAL);
533 assert_se(unbase32hexmem("CPNMUOJ1E8======", strlen("CPNMUOJ1E8======"), false, &mem, &len) == -EINVAL);
534 assert_se(unbase32hexmem("A", strlen("A"), false, &mem, &len) == -EINVAL);
535 assert_se(unbase32hexmem("A", strlen("A"), false, &mem, &len) == -EINVAL);
536 assert_se(unbase32hexmem("AAA", strlen("AAA"), false, &mem, &len) == -EINVAL);
537 assert_se(unbase32hexmem("AAAAAA", strlen("AAAAAA"), false, &mem, &len) == -EINVAL);
538 assert_se(unbase32hexmem("AB", strlen("AB"), false, &mem, &len) == -EINVAL);
539 assert_se(unbase32hexmem("AAAB", strlen("AAAB"), false, &mem, &len) == -EINVAL);
540 assert_se(unbase32hexmem("AAAAB", strlen("AAAAB"), false, &mem, &len) == -EINVAL);
541 assert_se(unbase32hexmem("AAAAAAB", strlen("AAAAAAB"), false, &mem, &len) == -EINVAL);
542}
543
13a5d76b
TG		 544/* https://tools.ietf.org/html/rfc4648#section-10 */
545static void test_base64mem(void) {
546 char *b64;
547
548 b64 = base64mem("", strlen(""));
549 assert_se(b64);
550 assert_se(streq(b64, ""));
551 free(b64);
552
553 b64 = base64mem("f", strlen("f"));
554 assert_se(b64);
555 assert_se(streq(b64, "Zg=="));
556 free(b64);
557
558 b64 = base64mem("fo", strlen("fo"));
559 assert_se(b64);
560 assert_se(streq(b64, "Zm8="));
561 free(b64);
562
563 b64 = base64mem("foo", strlen("foo"));
564 assert_se(b64);
565 assert_se(streq(b64, "Zm9v"));
566 free(b64);
567
568 b64 = base64mem("foob", strlen("foob"));
569 assert_se(b64);
570 assert_se(streq(b64, "Zm9vYg=="));
571 free(b64);
572
573 b64 = base64mem("fooba", strlen("fooba"));
574 assert_se(b64);
575 assert_se(streq(b64, "Zm9vYmE="));
576 free(b64);
577
578 b64 = base64mem("foobar", strlen("foobar"));
579 assert_se(b64);
580 assert_se(streq(b64, "Zm9vYmFy"));
581 free(b64);
582}
583
584static void test_unbase64mem(void) {
585 void *mem;
586 size_t len;
587
588 assert_se(unbase64mem("", strlen(""), &mem, &len) == 0);
589 assert_se(streq(strndupa(mem, len), ""));
590 free(mem);
591
592 assert_se(unbase64mem("Zg==", strlen("Zg=="), &mem, &len) == 0);
593 assert_se(streq(strndupa(mem, len), "f"));
594 free(mem);
595
596 assert_se(unbase64mem("Zm8=", strlen("Zm8="), &mem, &len) == 0);
597 assert_se(streq(strndupa(mem, len), "fo"));
598 free(mem);
599
600 assert_se(unbase64mem("Zm9v", strlen("Zm9v"), &mem, &len) == 0);
601 assert_se(streq(strndupa(mem, len), "foo"));
602 free(mem);
603
604 assert_se(unbase64mem("Zm9vYg==", strlen("Zm9vYg=="), &mem, &len) == 0);
605 assert_se(streq(strndupa(mem, len), "foob"));
606 free(mem);
607
608 assert_se(unbase64mem("Zm9vYmE=", strlen("Zm9vYmE="), &mem, &len) == 0);
609 assert_se(streq(strndupa(mem, len), "fooba"));
610 free(mem);
611
612 assert_se(unbase64mem("Zm9vYmFy", strlen("Zm9vYmFy"), &mem, &len) == 0);
613 assert_se(streq(strndupa(mem, len), "foobar"));
614 free(mem);
615
616 assert_se(unbase64mem("A", strlen("A"), &mem, &len) == -EINVAL);
617 assert_se(unbase64mem("A====", strlen("A===="), &mem, &len) == -EINVAL);
618 assert_se(unbase64mem("AAB==", strlen("AAB=="), &mem, &len) == -EINVAL);
619 assert_se(unbase64mem("AAAB=", strlen("AAAB="), &mem, &len) == -EINVAL);
620}
621
b4ecc959
TA		 622static void test_cescape(void) {
623 _cleanup_free_ char *escaped;
e0a33e7b
LP		 624
625 assert_se(escaped = cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
927be00c 626 assert_se(streq(escaped, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
b4ecc959
TA		 627}
628
629static void test_cunescape(void) {
630 _cleanup_free_ char *unescaped;
e0a33e7b 631
527b7a42
LP		 632 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", 0, &unescaped) < 0);
633 assert_se(cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00", UNESCAPE_RELAX, &unescaped) >= 0);
f3ee6297 634 assert_se(streq_ptr(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
97b11eed 635 unescaped = mfree(unescaped);
7f769619
ZJS		 636
637 /* incomplete sequences */
527b7a42
LP		 638 assert_se(cunescape("\\x0", 0, &unescaped) < 0);
639 assert_se(cunescape("\\x0", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 640 assert_se(streq_ptr(unescaped, "\\x0"));
97b11eed 641 unescaped = mfree(unescaped);
7f769619 642
527b7a42
LP		 643 assert_se(cunescape("\\x", 0, &unescaped) < 0);
644 assert_se(cunescape("\\x", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 645 assert_se(streq_ptr(unescaped, "\\x"));
97b11eed 646 unescaped = mfree(unescaped);
7f769619 647
527b7a42
LP		 648 assert_se(cunescape("\\", 0, &unescaped) < 0);
649 assert_se(cunescape("\\", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 650 assert_se(streq_ptr(unescaped, "\\"));
97b11eed 651 unescaped = mfree(unescaped);
7f769619 652
527b7a42
LP		 653 assert_se(cunescape("\\11", 0, &unescaped) < 0);
654 assert_se(cunescape("\\11", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 655 assert_se(streq_ptr(unescaped, "\\11"));
97b11eed 656 unescaped = mfree(unescaped);
7f769619 657
527b7a42
LP		 658 assert_se(cunescape("\\1", 0, &unescaped) < 0);
659 assert_se(cunescape("\\1", UNESCAPE_RELAX, &unescaped) >= 0);
7f769619 660 assert_se(streq_ptr(unescaped, "\\1"));
97b11eed 661 unescaped = mfree(unescaped);
f3ee6297
LP		 662
663 assert_se(cunescape("\\u0000", 0, &unescaped) < 0);
664 assert_se(cunescape("\\u00DF\\U000000df\\u03a0\\U00000041", UNESCAPE_RELAX, &unescaped) >= 0);
665 assert_se(streq_ptr(unescaped, "ßßΠA"));
97b11eed 666 unescaped = mfree(unescaped);
3b51f8dd
DM		 667
668 assert_se(cunescape("\\073", 0, &unescaped) >= 0);
669 assert_se(streq_ptr(unescaped, ";"));
b4ecc959
TA		 670}
671
1ef04f0b 672static void test_foreach_word(void) {
a2a5291b 673 const char *word, *state;
1ef04f0b
TA		 674 size_t l;
675 int i = 0;
676 const char test[] = "test abc d\te f ";
677 const char * const expected[] = {
678 "test",
679 "abc",
680 "d",
681 "e",
682 "f",
683 "",
684 NULL
685 };
686
a2a5291b
ZJS		 687 FOREACH_WORD(word, l, test, state)
688 assert_se(strneq(expected[i++], word, l));
1ef04f0b
TA		 689}
690
ba774317 691static void check(const char *test, char** expected, bool trailing) {
a2a5291b 692 const char *word, *state;
539ad707 693 size_t l;
1ef04f0b 694 int i = 0;
1ef04f0b 695
ba774317 696 printf("<<<%s>>>\n", test);
a2a5291b 697 FOREACH_WORD_QUOTED(word, l, test, state) {
1ef04f0b 698 _cleanup_free_ char *t = NULL;
539ad707 699
a2a5291b
ZJS		 700 assert_se(t = strndup(word, l));
701 assert_se(strneq(expected[i++], word, l));
539ad707 702 printf("<%s>\n", t);
539ad707 703 }
ba774317 704 printf("<<<%s>>>\n", state);
e50221bf 705 assert_se(expected[i] == NULL);
ba774317
ZJS		 706 assert_se(isempty(state) == !trailing);
707}
708
709static void test_foreach_word_quoted(void) {
710 check("test a b c 'd' e '' '' hhh '' '' \"a b c\"",
711 STRV_MAKE("test",
712 "a",
713 "b",
714 "c",
715 "d",
716 "e",
717 "",
718 "",
719 "hhh",
720 "",
721 "",
722 "a b c"),
723 false);
724
725 check("test \"xxx",
726 STRV_MAKE("test"),
727 true);
728
729 check("test\\",
730 STRV_MAKE_EMPTY,
731 true);
539ad707
TA		 732}
733
0d585d82
TA		 734static void test_memdup_multiply(void) {
735 int org[] = {1, 2, 3};
736 int *dup;
737
738 dup = (int*)memdup_multiply(org, sizeof(int), 3);
739
740 assert_se(dup);
741 assert_se(dup[0] == 1);
742 assert_se(dup[1] == 2);
743 assert_se(dup[2] == 3);
744 free(dup);
745}
746
144e51ec 747static void test_u64log2(void) {
bdf7026e
TA		 748 assert_se(u64log2(0) == 0);
749 assert_se(u64log2(8) == 3);
750 assert_se(u64log2(9) == 3);
751 assert_se(u64log2(15) == 3);
752 assert_se(u64log2(16) == 4);
753 assert_se(u64log2(1024*1024) == 20);
754 assert_se(u64log2(1024*1024+5) == 20);
144e51ec
CR		 755}
756
2a371001
ZJS		 757static void test_protect_errno(void) {
758 errno = 12;
759 {
760 PROTECT_ERRNO;
761 errno = 11;
762 }
bdf7026e 763 assert_se(errno == 12);
2a371001
ZJS		 764}
765
5f05235f
FB		 766static void test_parse_cpu_set(void) {
767 cpu_set_t *c = NULL;
768 int ncpus;
769 int cpu;
770
771 /* Simple range (from CPUAffinity example) */
765d143b 772 ncpus = parse_cpu_set_and_warn("1 2", &c, NULL, "fake", 1, "CPUAffinity");
5f05235f
FB		 773 assert_se(ncpus >= 1024);
774 assert_se(CPU_ISSET_S(1, CPU_ALLOC_SIZE(ncpus), c));
775 assert_se(CPU_ISSET_S(2, CPU_ALLOC_SIZE(ncpus), c));
776 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 2);
777 c = mfree(c);
778
779 /* A more interesting range */
765d143b 780 ncpus = parse_cpu_set_and_warn("0 1 2 3 8 9 10 11", &c, NULL, "fake", 1, "CPUAffinity");
5f05235f
FB		 781 assert_se(ncpus >= 1024);
782 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
783 for (cpu = 0; cpu < 4; cpu++)
784 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
785 for (cpu = 8; cpu < 12; cpu++)
786 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
787 c = mfree(c);
788
789 /* Quoted strings */
765d143b 790 ncpus = parse_cpu_set_and_warn("8 '9' 10 \"11\"", &c, NULL, "fake", 1, "CPUAffinity");
5f05235f
FB		 791 assert_se(ncpus >= 1024);
792 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 4);
793 for (cpu = 8; cpu < 12; cpu++)
794 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
795 c = mfree(c);
796
797 /* Use commas as separators */
765d143b 798 ncpus = parse_cpu_set_and_warn("0,1,2,3 8,9,10,11", &c, NULL, "fake", 1, "CPUAffinity");
4fc66acb
FB		 799 assert_se(ncpus >= 1024);
800 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
801 for (cpu = 0; cpu < 4; cpu++)
802 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
803 for (cpu = 8; cpu < 12; cpu++)
804 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
805 c = mfree(c);
806
807 /* Commas with spaces (and trailing comma, space) */
808 ncpus = parse_cpu_set_and_warn("0, 1, 2, 3, 4, 5, 6, 7, ", &c, NULL, "fake", 1, "CPUAffinity");
809 assert_se(ncpus >= 1024);
810 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
811 for (cpu = 0; cpu < 8; cpu++)
812 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
813 c = mfree(c);
5f05235f
FB		 814
815 /* Ranges */
765d143b 816 ncpus = parse_cpu_set_and_warn("0-3,8-11", &c, NULL, "fake", 1, "CPUAffinity");
a26662ce
FB		 817 assert_se(ncpus >= 1024);
818 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
819 for (cpu = 0; cpu < 4; cpu++)
820 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
821 for (cpu = 8; cpu < 12; cpu++)
822 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
823 c = mfree(c);
824
825 /* Ranges with trailing comma, space */
826 ncpus = parse_cpu_set_and_warn("0-3 8-11, ", &c, NULL, "fake", 1, "CPUAffinity");
827 assert_se(ncpus >= 1024);
828 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 8);
829 for (cpu = 0; cpu < 4; cpu++)
830 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
831 for (cpu = 8; cpu < 12; cpu++)
832 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
833 c = mfree(c);
834
835 /* Negative range (returns empty cpu_set) */
836 ncpus = parse_cpu_set_and_warn("3-0", &c, NULL, "fake", 1, "CPUAffinity");
837 assert_se(ncpus >= 1024);
838 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 0);
839 c = mfree(c);
840
841 /* Overlapping ranges */
842 ncpus = parse_cpu_set_and_warn("0-7 4-11", &c, NULL, "fake", 1, "CPUAffinity");
843 assert_se(ncpus >= 1024);
844 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 12);
845 for (cpu = 0; cpu < 12; cpu++)
846 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
847 c = mfree(c);
848
849 /* Mix ranges and individual CPUs */
850 ncpus = parse_cpu_set_and_warn("0,1 4-11", &c, NULL, "fake", 1, "CPUAffinity");
851 assert_se(ncpus >= 1024);
852 assert_se(CPU_COUNT_S(CPU_ALLOC_SIZE(ncpus), c) == 10);
853 assert_se(CPU_ISSET_S(0, CPU_ALLOC_SIZE(ncpus), c));
854 assert_se(CPU_ISSET_S(1, CPU_ALLOC_SIZE(ncpus), c));
855 for (cpu = 4; cpu < 12; cpu++)
856 assert_se(CPU_ISSET_S(cpu, CPU_ALLOC_SIZE(ncpus), c));
857 c = mfree(c);
5f05235f
FB		 858
859 /* Garbage */
765d143b 860 ncpus = parse_cpu_set_and_warn("0 1 2 3 garbage", &c, NULL, "fake", 1, "CPUAffinity");
5f05235f
FB		 861 assert_se(ncpus < 0);
862 assert_se(!c);
863
a26662ce
FB		 864 /* Range with garbage */
865 ncpus = parse_cpu_set_and_warn("0-3 8-garbage", &c, NULL, "fake", 1, "CPUAffinity");
866 assert_se(ncpus < 0);
867 assert_se(!c);
868
5f05235f
FB		 869 /* Empty string */
870 c = NULL;
765d143b 871 ncpus = parse_cpu_set_and_warn("", &c, NULL, "fake", 1, "CPUAffinity");
5f05235f
FB		 872 assert_se(ncpus == 0); /* empty string returns 0 */
873 assert_se(!c);
874
875 /* Runnaway quoted string */
765d143b 876 ncpus = parse_cpu_set_and_warn("0 1 2 3 \"4 5 6 7 ", &c, NULL, "fake", 1, "CPUAffinity");
5f05235f
FB		 877 assert_se(ncpus < 0);
878 assert_se(!c);
879}
880
59f448cf
LP		 881static void test_config_parse_iec_uint64(void) {
882 uint64_t offset = 0;
883 assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
9480794b
ZJS		 884 assert_se(offset == 4 * 1024 * 1024);
885
59f448cf 886 assert_se(config_parse_iec_uint64(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset, NULL) == 0);
9480794b
ZJS		 887}
888
b4ecc959
TA		 889static void test_strextend(void) {
890 _cleanup_free_ char *str = strdup("0123");
891 strextend(&str, "456", "78", "9", NULL);
892 assert_se(streq(str, "0123456789"));
893}
894
895static void test_strrep(void) {
896 _cleanup_free_ char *one, *three, *zero;
897 one = strrep("waldo", 1);
898 three = strrep("waldo", 3);
899 zero = strrep("waldo", 0);
900
901 assert_se(streq(one, "waldo"));
902 assert_se(streq(three, "waldowaldowaldo"));
903 assert_se(streq(zero, ""));
904}
905
d4ac85c6
LP		 906static void test_split_pair(void) {
907 _cleanup_free_ char *a = NULL, *b = NULL;
908
909 assert_se(split_pair("", "", &a, &b) == -EINVAL);
910 assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
911 assert_se(split_pair("", "=", &a, &b) == -EINVAL);
912 assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
913 assert_se(streq(a, "foo"));
914 assert_se(streq(b, "bar"));
915 free(a);
916 free(b);
917 assert_se(split_pair("==", "==", &a, &b) >= 0);
918 assert_se(streq(a, ""));
919 assert_se(streq(b, ""));
920 free(a);
921 free(b);
922
923 assert_se(split_pair("===", "==", &a, &b) >= 0);
924 assert_se(streq(a, ""));
925 assert_se(streq(b, "="));
926}
927
22f5f628
DR		 928static void test_fstab_node_to_udev_node(void) {
929 char *n;
930
931 n = fstab_node_to_udev_node("LABEL=applé/jack");
932 puts(n);
933 assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
934 free(n);
935
936 n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
937 puts(n);
938 assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
939 free(n);
940
941 n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
942 puts(n);
943 assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
944 free(n);
945
946 n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
947 puts(n);
948 assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
949 free(n);
950
22f5f628
DR		 951 n = fstab_node_to_udev_node("PONIES=awesome");
952 puts(n);
953 assert_se(streq(n, "PONIES=awesome"));
954 free(n);
955
956 n = fstab_node_to_udev_node("/dev/xda1");
957 puts(n);
958 assert_se(streq(n, "/dev/xda1"));
959 free(n);
960}
961
893fa014
ZJS		 962static void test_get_files_in_directory(void) {
963 _cleanup_strv_free_ char **l = NULL, **t = NULL;
964
965 assert_se(get_files_in_directory("/tmp", &l) >= 0);
510b857f 966 assert_se(get_files_in_directory(".", &t) >= 0);
893fa014
ZJS		 967 assert_se(get_files_in_directory(".", NULL) >= 0);
968}
969
cabb7806
LP		 970static void test_in_set(void) {
971 assert_se(IN_SET(1, 1));
972 assert_se(IN_SET(1, 1, 2, 3, 4));
973 assert_se(IN_SET(2, 1, 2, 3, 4));
974 assert_se(IN_SET(3, 1, 2, 3, 4));
975 assert_se(IN_SET(4, 1, 2, 3, 4));
976 assert_se(!IN_SET(0, 1));
977 assert_se(!IN_SET(0, 1, 2, 3, 4));
978}
979
87b02843
ZJS		 980static void test_writing_tmpfile(void) {
981 char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
39883f62 982 _cleanup_free_ char *contents = NULL;
65b3903f
ZJS		 983 size_t size;
984 int fd, r;
65b3903f 985 struct iovec iov[3];
39883f62 986
65b3903f
ZJS		 987 IOVEC_SET_STRING(iov[0], "abc\n");
988 IOVEC_SET_STRING(iov[1], ALPHANUMERICAL "\n");
989 IOVEC_SET_STRING(iov[2], "");
990
2d5bdf5b 991 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
87b02843 992 printf("tmpfile: %s", name);
65b3903f 993
87b02843 994 r = writev(fd, iov, 3);
bdf7026e 995 assert_se(r >= 0);
65b3903f
ZJS		 996
997 r = read_full_file(name, &contents, &size);
bdf7026e 998 assert_se(r == 0);
65b3903f 999 printf("contents: %s", contents);
bdf7026e 1000 assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
40edd236
RC		 1001
1002 unlink(name);
65b3903f
ZJS		 1003}
1004
29bfbcd6
LP		 1005static void test_hexdump(void) {
1006 uint8_t data[146];
1007 unsigned i;
1008
1009 hexdump(stdout, NULL, 0);
1010 hexdump(stdout, "", 0);
1011 hexdump(stdout, "", 1);
1012 hexdump(stdout, "x", 1);
1013 hexdump(stdout, "x", 2);
1014 hexdump(stdout, "foobar", 7);
1015 hexdump(stdout, "f\nobar", 7);
1016 hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
1017
1018 for (i = 0; i < ELEMENTSOF(data); i++)
1019 data[i] = i*2;
1020
1021 hexdump(stdout, data, sizeof(data));
1022}
1023
8fe90522
ZJS		 1024static void test_log2i(void) {
1025 assert_se(log2i(1) == 0);
1026 assert_se(log2i(2) == 1);
1027 assert_se(log2i(3) == 1);
1028 assert_se(log2i(4) == 2);
1029 assert_se(log2i(32) == 5);
1030 assert_se(log2i(33) == 5);
1031 assert_se(log2i(63) == 5);
1032 assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
1033}
1034
c4a7b2c5
LP		 1035static void test_foreach_string(void) {
1036 const char * const t[] = {
1037 "foo",
1038 "bar",
1039 "waldo",
1040 NULL
1041 };
1042 const char *x;
1043 unsigned i = 0;
1044
1045 FOREACH_STRING(x, "foo", "bar", "waldo")
1046 assert_se(streq_ptr(t[i++], x));
1047
1048 assert_se(i == 3);
1049
1050 FOREACH_STRING(x, "zzz")
1051 assert_se(streq(x, "zzz"));
1052}
1053
ae6c3cc0 1054static void test_filename_is_valid(void) {
927be00c
RC		 1055 char foo[FILENAME_MAX+2];
1056 int i;
1057
ae6c3cc0
LP		 1058 assert_se(!filename_is_valid(""));
1059 assert_se(!filename_is_valid("/bar/foo"));
1060 assert_se(!filename_is_valid("/"));
1061 assert_se(!filename_is_valid("."));
1062 assert_se(!filename_is_valid(".."));
927be00c
RC		 1063
1064 for (i=0; i<FILENAME_MAX+1; i++)
1065 foo[i] = 'a';
1066 foo[FILENAME_MAX+1] = '\0';
1067
ae6c3cc0 1068 assert_se(!filename_is_valid(foo));
927be00c 1069
ae6c3cc0
LP		 1070 assert_se(filename_is_valid("foo_bar-333"));
1071 assert_se(filename_is_valid("o.o"));
927be00c
RC		 1072}
1073
1cb1767a
ZJS		 1074static void test_string_has_cc(void) {
1075 assert_se(string_has_cc("abc\1", NULL));
1076 assert_se(string_has_cc("abc\x7f", NULL));
1077 assert_se(string_has_cc("abc\x7f", NULL));
1078 assert_se(string_has_cc("abc\t\x7f", "\t"));
1079 assert_se(string_has_cc("abc\t\x7f", "\t"));
1080 assert_se(string_has_cc("\x7f", "\t"));
1081 assert_se(string_has_cc("\x7f", "\t\a"));
1082
1083 assert_se(!string_has_cc("abc\t\t", "\t"));
1084 assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
1085 assert_se(!string_has_cc("a\ab\tc", "\t\a"));
1086}
1087
927be00c
RC		 1088static void test_ascii_strlower(void) {
1089 char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
1090 assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"));
1091}
1092
1093static void test_files_same(void) {
1094 _cleanup_close_ int fd = -1;
1095 char name[] = "/tmp/test-files_same.XXXXXX";
1096 char name_alias[] = "/tmp/test-files_same.alias";
1097
1098 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1099 assert_se(fd >= 0);
1100 assert_se(symlink(name, name_alias) >= 0);
1101
1102 assert_se(files_same(name, name));
1103 assert_se(files_same(name, name_alias));
1104
1105 unlink(name);
1106 unlink(name_alias);
1107}
1108
1109static void test_is_valid_documentation_url(void) {
a2e03378
LP		 1110 assert_se(documentation_url_is_valid("http://www.freedesktop.org/wiki/Software/systemd"));
1111 assert_se(documentation_url_is_valid("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
1112 assert_se(documentation_url_is_valid("file:/foo/foo"));
1113 assert_se(documentation_url_is_valid("man:systemd.special(7)"));
1114 assert_se(documentation_url_is_valid("info:bar"));
1115
1116 assert_se(!documentation_url_is_valid("foo:"));
1117 assert_se(!documentation_url_is_valid("info:"));
1118 assert_se(!documentation_url_is_valid(""));
927be00c
RC		 1119}
1120
1121static void test_file_in_same_dir(void) {
eee84633
DH		 1122 char *t;
1123
1124 t = file_in_same_dir("/", "a");
1125 assert_se(streq(t, "/a"));
1126 free(t);
1127
1128 t = file_in_same_dir("/", "/a");
1129 assert_se(streq(t, "/a"));
1130 free(t);
1131
1132 t = file_in_same_dir("", "a");
1133 assert_se(streq(t, "a"));
1134 free(t);
1135
1136 t = file_in_same_dir("a/", "a");
1137 assert_se(streq(t, "a/a"));
1138 free(t);
1139
1140 t = file_in_same_dir("bar/foo", "bar");
1141 assert_se(streq(t, "bar/bar"));
1142 free(t);
927be00c
RC		 1143}
1144
1145static void test_endswith(void) {
1146 assert_se(endswith("foobar", "bar"));
1147 assert_se(endswith("foobar", ""));
1148 assert_se(endswith("foobar", "foobar"));
1149 assert_se(endswith("", ""));
1150
1151 assert_se(!endswith("foobar", "foo"));
1152 assert_se(!endswith("foobar", "foobarfoofoo"));
1153}
1154
ff9265d0
DM		 1155static void test_endswith_no_case(void) {
1156 assert_se(endswith_no_case("fooBAR", "bar"));
1157 assert_se(endswith_no_case("foobar", ""));
1158 assert_se(endswith_no_case("foobar", "FOOBAR"));
1159 assert_se(endswith_no_case("", ""));
1160
1161 assert_se(!endswith_no_case("foobar", "FOO"));
1162 assert_se(!endswith_no_case("foobar", "FOOBARFOOFOO"));
1163}
1164
927be00c
RC		 1165static void test_close_nointr(void) {
1166 char name[] = "/tmp/test-test-close_nointr.XXXXXX";
1167 int fd;
1168
1169 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1170 assert_se(fd >= 0);
1171 assert_se(close_nointr(fd) >= 0);
1172 assert_se(close_nointr(fd) < 0);
1173
1174 unlink(name);
1175}
1176
1177
1178static void test_unlink_noerrno(void) {
1179 char name[] = "/tmp/test-close_nointr.XXXXXX";
1180 int fd;
1181
1182 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1183 assert_se(fd >= 0);
1184 assert_se(close_nointr(fd) >= 0);
1185
1186 {
1187 PROTECT_ERRNO;
1188 errno = -42;
1189 assert_se(unlink_noerrno(name) >= 0);
1190 assert_se(errno == -42);
1191 assert_se(unlink_noerrno(name) < 0);
1192 assert_se(errno == -42);
1193 }
1194}
1195
1196static void test_readlink_and_make_absolute(void) {
1197 char tempdir[] = "/tmp/test-readlink_and_make_absolute";
1198 char name[] = "/tmp/test-readlink_and_make_absolute/original";
1199 char name2[] = "test-readlink_and_make_absolute/original";
1200 char name_alias[] = "/tmp/test-readlink_and_make_absolute-alias";
1201 char *r = NULL;
1202
684fc892 1203 assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0);
927be00c
RC		 1204 assert_se(touch(name) >= 0);
1205
1206 assert_se(symlink(name, name_alias) >= 0);
1207 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
1208 assert_se(streq(r, name));
1209 free(r);
1210 assert_se(unlink(name_alias) >= 0);
1211
1212 assert_se(chdir(tempdir) >= 0);
1213 assert_se(symlink(name2, name_alias) >= 0);
1214 assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
1215 assert_se(streq(r, name));
1216 free(r);
1217 assert_se(unlink(name_alias) >= 0);
1218
c6878637 1219 assert_se(rm_rf(tempdir, REMOVE_ROOT|REMOVE_PHYSICAL) >= 0);
927be00c
RC		 1220}
1221
927be00c
RC		 1222static void test_ignore_signals(void) {
1223 assert_se(ignore_signals(SIGINT, -1) >= 0);
1224 assert_se(kill(getpid(), SIGINT) >= 0);
1225 assert_se(ignore_signals(SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
1226 assert_se(kill(getpid(), SIGUSR1) >= 0);
1227 assert_se(kill(getpid(), SIGUSR2) >= 0);
1228 assert_se(kill(getpid(), SIGTERM) >= 0);
1229 assert_se(kill(getpid(), SIGPIPE) >= 0);
1230 assert_se(default_signals(SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
1231}
1232
1233static void test_strshorten(void) {
1234 char s[] = "foobar";
1235
1236 assert_se(strlen(strshorten(s, 6)) == 6);
1237 assert_se(strlen(strshorten(s, 12)) == 6);
1238 assert_se(strlen(strshorten(s, 2)) == 2);
1239 assert_se(strlen(strshorten(s, 0)) == 0);
1240}
1241
63c372cb 1242static void test_strjoina(void) {
8085f163
DR		 1243 char *actual;
1244
63c372cb 1245 actual = strjoina("", "foo", "bar");
8085f163
DR		 1246 assert_se(streq(actual, "foobar"));
1247
63c372cb 1248 actual = strjoina("foo", "bar", "baz");
8085f163
DR		 1249 assert_se(streq(actual, "foobarbaz"));
1250
63c372cb 1251 actual = strjoina("foo", "", "bar", "baz");
8085f163 1252 assert_se(streq(actual, "foobarbaz"));
63c372cb
LP		 1253
1254 actual = strjoina("foo");
1255 assert_se(streq(actual, "foo"));
1256
1257 actual = strjoina(NULL);
1258 assert_se(streq(actual, ""));
1259
1260 actual = strjoina(NULL, "foo");
1261 assert_se(streq(actual, ""));
1262
1263 actual = strjoina("foo", NULL, "bar");
1264 assert_se(streq(actual, "foo"));
8085f163
DR		 1265}
1266
8852362b
RC		 1267static void test_is_symlink(void) {
1268 char name[] = "/tmp/test-is_symlink.XXXXXX";
1269 char name_link[] = "/tmp/test-is_symlink.link";
1270 _cleanup_close_ int fd = -1;
1271
1272 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1273 assert_se(fd >= 0);
1274 assert_se(symlink(name, name_link) >= 0);
1275
1276 assert_se(is_symlink(name) == 0);
1277 assert_se(is_symlink(name_link) == 1);
1278 assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
1279
1280
1281 unlink(name);
1282 unlink(name_link);
1283}
1284
8852362b
RC		 1285static void test_search_and_fopen(void) {
1286 const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
1287 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1288 int fd = -1;
1289 int r;
1290 FILE *f;
1291
1292 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1293 assert_se(fd >= 0);
1294 close(fd);
1295
1296 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1297 assert_se(r >= 0);
1298 fclose(f);
1299
1300 r = search_and_fopen(name, "r", NULL, dirs, &f);
1301 assert_se(r >= 0);
1302 fclose(f);
1303
1304 r = search_and_fopen(basename(name), "r", "/", dirs, &f);
1305 assert_se(r >= 0);
1306 fclose(f);
1307
1308 r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1309 assert_se(r < 0);
1310 r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1311 assert_se(r < 0);
1312
1313 r = unlink(name);
1314 assert_se(r == 0);
1315
1316 r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1317 assert_se(r < 0);
1318}
1319
1320
1321static void test_search_and_fopen_nulstr(void) {
1322 const char dirs[] = "/tmp/foo/bar\0/tmp\0";
1323 char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1324 int fd = -1;
1325 int r;
1326 FILE *f;
1327
1328 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1329 assert_se(fd >= 0);
1330 close(fd);
1331
1332 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1333 assert_se(r >= 0);
1334 fclose(f);
1335
1336 r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
1337 assert_se(r >= 0);
1338 fclose(f);
1339
1340 r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1341 assert_se(r < 0);
1342 r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1343 assert_se(r < 0);
1344
1345 r = unlink(name);
1346 assert_se(r == 0);
1347
1348 r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1349 assert_se(r < 0);
1350}
1351
1352static void test_glob_exists(void) {
1353 char name[] = "/tmp/test-glob_exists.XXXXXX";
1354 int fd = -1;
1355 int r;
1356
1357 fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1358 assert_se(fd >= 0);
1359 close(fd);
1360
1361 r = glob_exists("/tmp/test-glob_exists*");
1362 assert_se(r == 1);
1363
1364 r = unlink(name);
1365 assert_se(r == 0);
1366 r = glob_exists("/tmp/test-glob_exists*");
1367 assert_se(r == 0);
1368}
1369
1370static void test_execute_directory(void) {
aac7766c
ZJS		 1371 char template_lo[] = "/tmp/test-readlink_and_make_absolute-lo.XXXXXXX";
1372 char template_hi[] = "/tmp/test-readlink_and_make_absolute-hi.XXXXXXX";
76f282c6 1373 const char * dirs[] = {template_hi, template_lo, NULL};
aac7766c
ZJS		 1374 const char *name, *name2, *name3, *overridden, *override, *masked, *mask;
1375
1376 assert_se(mkdtemp(template_lo));
1377 assert_se(mkdtemp(template_hi));
1378
63c372cb
LP		 1379 name = strjoina(template_lo, "/script");
1380 name2 = strjoina(template_hi, "/script2");
1381 name3 = strjoina(template_lo, "/useless");
1382 overridden = strjoina(template_lo, "/overridden");
1383 override = strjoina(template_hi, "/overridden");
1384 masked = strjoina(template_lo, "/masked");
1385 mask = strjoina(template_hi, "/masked");
e801700e 1386
4c1fc3e4
DM		 1387 assert_se(write_string_file(name, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works", WRITE_STRING_FILE_CREATE) == 0);
1388 assert_se(write_string_file(name2, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/it_works2", WRITE_STRING_FILE_CREATE) == 0);
1389 assert_se(write_string_file(overridden, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
1390 assert_se(write_string_file(override, "#!/bin/sh\necho 'Executing '$0", WRITE_STRING_FILE_CREATE) == 0);
1391 assert_se(write_string_file(masked, "#!/bin/sh\necho 'Executing '$0\ntouch $(dirname $0)/failed", WRITE_STRING_FILE_CREATE) == 0);
aac7766c 1392 assert_se(symlink("/dev/null", mask) == 0);
8852362b
RC		 1393 assert_se(chmod(name, 0755) == 0);
1394 assert_se(chmod(name2, 0755) == 0);
aac7766c
ZJS		 1395 assert_se(chmod(overridden, 0755) == 0);
1396 assert_se(chmod(override, 0755) == 0);
1397 assert_se(chmod(masked, 0755) == 0);
8852362b
RC		 1398 assert_se(touch(name3) >= 0);
1399
e801700e 1400 execute_directories(dirs, DEFAULT_TIMEOUT_USEC, NULL);
aac7766c 1401
0c0cdb06 1402 assert_se(chdir(template_lo) == 0);
e801700e 1403 assert_se(access("it_works", F_OK) >= 0);
aac7766c
ZJS		 1404 assert_se(access("failed", F_OK) < 0);
1405
0c0cdb06 1406 assert_se(chdir(template_hi) == 0);
e801700e 1407 assert_se(access("it_works2", F_OK) >= 0);
aac7766c 1408 assert_se(access("failed", F_OK) < 0);
8852362b 1409
c6878637
LP		 1410 (void) rm_rf(template_lo, REMOVE_ROOT|REMOVE_PHYSICAL);
1411 (void) rm_rf(template_hi, REMOVE_ROOT|REMOVE_PHYSICAL);
8852362b
RC		 1412}
1413
f32d2db1
LP		 1414static int parse_item(const char *key, const char *value) {
1415 assert_se(key);
1416
1417 log_info("kernel cmdline option <%s> = <%s>", key, strna(value));
1418 return 0;
1419}
1420
1421static void test_parse_proc_cmdline(void) {
1422 assert_se(parse_proc_cmdline(parse_item) >= 0);
1423}
1424
ee05e779
ZJS		 1425static void test_raw_clone(void) {
1426 pid_t parent, pid, pid2;
1427
1428 parent = getpid();
1429 log_info("before clone: getpid()→"PID_FMT, parent);
1430 assert_se(raw_getpid() == parent);
1431
1432 pid = raw_clone(0, NULL);
e50221bf 1433 assert_se(pid >= 0);
ee05e779
ZJS		 1434
1435 pid2 = raw_getpid();
1436 log_info("raw_clone: "PID_FMT" getpid()→"PID_FMT" raw_getpid()→"PID_FMT,
1437 pid, getpid(), pid2);
0289a5bc 1438 if (pid == 0) {
e50221bf 1439 assert_se(pid2 != parent);
0289a5bc
FB		 1440 _exit(EXIT_SUCCESS);
1441 } else {
1442 int status;
1443
e50221bf 1444 assert_se(pid2 == parent);
0289a5bc
FB		 1445 waitpid(pid, &status, __WCLONE);
1446 assert_se(WIFEXITED(status) && WEXITSTATUS(status) == EXIT_SUCCESS);
1447 }
ee05e779
ZJS		 1448}
1449
f7ad54a3
LP		 1450static void test_same_fd(void) {
1451 _cleanup_close_pair_ int p[2] = { -1, -1 };
1452 _cleanup_close_ int a = -1, b = -1, c = -1;
1453
1454 assert_se(pipe2(p, O_CLOEXEC) >= 0);
1455 assert_se((a = dup(p[0])) >= 0);
1456 assert_se((b = open("/dev/null", O_RDONLY|O_CLOEXEC)) >= 0);
1457 assert_se((c = dup(a)) >= 0);
1458
1459 assert_se(same_fd(p[0], p[0]) > 0);
1460 assert_se(same_fd(p[1], p[1]) > 0);
1461 assert_se(same_fd(a, a) > 0);
1462 assert_se(same_fd(b, b) > 0);
1463
1464 assert_se(same_fd(a, p[0]) > 0);
1465 assert_se(same_fd(p[0], a) > 0);
1466 assert_se(same_fd(c, p[0]) > 0);
1467 assert_se(same_fd(p[0], c) > 0);
1468 assert_se(same_fd(a, c) > 0);
1469 assert_se(same_fd(c, a) > 0);
1470
1471 assert_se(same_fd(p[0], p[1]) == 0);
1472 assert_se(same_fd(p[1], p[0]) == 0);
1473 assert_se(same_fd(p[0], b) == 0);
1474 assert_se(same_fd(b, p[0]) == 0);
1475 assert_se(same_fd(p[1], a) == 0);
1476 assert_se(same_fd(a, p[1]) == 0);
1477 assert_se(same_fd(p[1], b) == 0);
1478 assert_se(same_fd(b, p[1]) == 0);
1479
1480 assert_se(same_fd(a, b) == 0);
1481 assert_se(same_fd(b, a) == 0);
1482}
1483
8cb4ab00
LP		 1484static void test_uid_ptr(void) {
1485
1486 assert_se(UID_TO_PTR(0) != NULL);
1487 assert_se(UID_TO_PTR(1000) != NULL);
1488
1489 assert_se(PTR_TO_UID(UID_TO_PTR(0)) == 0);
1490 assert_se(PTR_TO_UID(UID_TO_PTR(1000)) == 1000);
1491}
1492
ff6a7460
LP		 1493static void test_sparse_write_one(int fd, const char *buffer, size_t n) {
1494 char check[n];
1495
1496 assert_se(lseek(fd, 0, SEEK_SET) == 0);
1497 assert_se(ftruncate(fd, 0) >= 0);
1498 assert_se(sparse_write(fd, buffer, n, 4) == (ssize_t) n);
1499
1500 assert_se(lseek(fd, 0, SEEK_CUR) == (off_t) n);
1501 assert_se(ftruncate(fd, n) >= 0);
1502
1503 assert_se(lseek(fd, 0, SEEK_SET) == 0);
1504 assert_se(read(fd, check, n) == (ssize_t) n);
1505
1506 assert_se(memcmp(buffer, check, n) == 0);
1507}
1508
1509static void test_sparse_write(void) {
1510 const char test_a[] = "test";
1511 const char test_b[] = "\0\0\0\0test\0\0\0\0";
1512 const char test_c[] = "\0\0test\0\0\0\0";
1513 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";
1514 const char test_e[] = "test\0\0\0\0test";
1515 _cleanup_close_ int fd = -1;
1516 char fn[] = "/tmp/sparseXXXXXX";
1517
1518 fd = mkostemp(fn, O_CLOEXEC);
1519 assert_se(fd >= 0);
1520 unlink(fn);
1521
1522 test_sparse_write_one(fd, test_a, sizeof(test_a));
1523 test_sparse_write_one(fd, test_b, sizeof(test_b));
1524 test_sparse_write_one(fd, test_c, sizeof(test_c));
1525 test_sparse_write_one(fd, test_d, sizeof(test_d));
1526 test_sparse_write_one(fd, test_e, sizeof(test_e));
1527}
1528
61ee6939
RM		 1529static void test_shell_escape_one(const char *s, const char *bad, const char *expected) {
1530 _cleanup_free_ char *r;
1531
1532 assert_se(r = shell_escape(s, bad));
1533 assert_se(streq_ptr(r, expected));
1534}
1535
1536static void test_shell_escape(void) {
1537 test_shell_escape_one("", "", "");
1538 test_shell_escape_one("\\", "", "\\\\");
1539 test_shell_escape_one("foobar", "", "foobar");
1540 test_shell_escape_one("foobar", "o", "f\\o\\obar");
1541 test_shell_escape_one("foo:bar,baz", ",:", "foo\\:bar\\,baz");
1542}
1543
019c7fba
LP		 1544static void test_shell_maybe_quote_one(const char *s, const char *expected) {
1545 _cleanup_free_ char *r;
1546
1547 assert_se(r = shell_maybe_quote(s));
1548 assert_se(streq(r, expected));
1549}
1550
1551static void test_shell_maybe_quote(void) {
1552
1553 test_shell_maybe_quote_one("", "");
1554 test_shell_maybe_quote_one("\\", "\"\\\\\"");
1555 test_shell_maybe_quote_one("\"", "\"\\\"\"");
1556 test_shell_maybe_quote_one("foobar", "foobar");
1557 test_shell_maybe_quote_one("foo bar", "\"foo bar\"");
1558 test_shell_maybe_quote_one("foo \"bar\" waldo", "\"foo \\\"bar\\\" waldo\"");
1559 test_shell_maybe_quote_one("foo$bar", "\"foo\\$bar\"");
1560}
1561
14bcf25c
LP		 1562static void test_tempfn(void) {
1563 char *ret = NULL, *p;
1564
1565 assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
1566 assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
1567 free(ret);
1568
1569 assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
1570 assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
1571 free(ret);
1572
1573 assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
1574 assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
1575 assert_se(strlen(p) == 16);
1576 assert_se(in_charset(p, "0123456789abcdef"));
1577 free(ret);
1578
1579 assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
1580 assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
1581 assert_se(strlen(p) == 16);
1582 assert_se(in_charset(p, "0123456789abcdef"));
1583 free(ret);
1584
1585 assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
1586 assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
1587 assert_se(strlen(p) == 16);
1588 assert_se(in_charset(p, "0123456789abcdef"));
1589 free(ret);
1590
1591 assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
1592 assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
1593 assert_se(strlen(p) == 16);
1594 assert_se(in_charset(p, "0123456789abcdef"));
1595 free(ret);
1596}
1597
c030a850
NK		 1598static void test_strcmp_ptr(void) {
1599 assert_se(strcmp_ptr(NULL, NULL) == 0);
1600 assert_se(strcmp_ptr("", NULL) > 0);
1601 assert_se(strcmp_ptr("foo", NULL) > 0);
1602 assert_se(strcmp_ptr(NULL, "") < 0);
1603 assert_se(strcmp_ptr(NULL, "bar") < 0);
1604 assert_se(strcmp_ptr("foo", "bar") > 0);
1605 assert_se(strcmp_ptr("bar", "baz") < 0);
1606 assert_se(strcmp_ptr("foo", "foo") == 0);
1607 assert_se(strcmp_ptr("", "") == 0);
1608}
1609
df241a67
LP		 1610static void test_fgetxattrat_fake(void) {
1611 char t[] = "/var/tmp/xattrtestXXXXXX";
1612 _cleanup_close_ int fd = -1;
1613 const char *x;
1614 char v[3] = {};
1615 int r;
1616
1617 assert_se(mkdtemp(t));
1618 x = strjoina(t, "/test");
1619 assert_se(touch(x) >= 0);
1620
1621 r = setxattr(x, "user.foo", "bar", 3, 0);
1622 if (r < 0 && errno == EOPNOTSUPP) /* no xattrs supported on /var/tmp... */
1623 goto cleanup;
1624 assert_se(r >= 0);
1625
1626 fd = open(t, O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY);
1627 assert_se(fd >= 0);
1628
1629 assert_se(fgetxattrat_fake(fd, "test", "user.foo", v, 3, 0) >= 0);
1630 assert_se(memcmp(v, "bar", 3) == 0);
1631
1632 safe_close(fd);
1633 fd = open("/", O_RDONLY|O_DIRECTORY|O_CLOEXEC|O_NOCTTY);
1634 assert_se(fd >= 0);
1635 assert_se(fgetxattrat_fake(fd, "usr", "user.idontexist", v, 3, 0) == -ENODATA);
1636
1637cleanup:
1638 assert_se(unlink(x) >= 0);
1639 assert_se(rmdir(t) >= 0);
1640}
1641
c573dcfe
EV		 1642static void test_runlevel_to_target(void) {
1643 assert_se(streq_ptr(runlevel_to_target(NULL), NULL));
1644 assert_se(streq_ptr(runlevel_to_target("unknown-runlevel"), NULL));
1645 assert_se(streq_ptr(runlevel_to_target("3"), SPECIAL_MULTI_USER_TARGET));
1646}
1647
539ad707 1648int main(int argc, char *argv[]) {
9480794b
ZJS		 1649 log_parse_environment();
1650 log_open();
1651
539ad707 1652 test_streq_ptr();
625e870b 1653 test_align_power2();
7242d742 1654 test_max();
fb835651 1655 test_container_of();
95d78c7e 1656 test_alloca();
180a60bc 1657 test_div_round_up();
539ad707 1658 test_first_word();
dbd73f9e 1659 test_close_many();
8d99e5f5 1660 test_parse_uid();
dbd73f9e 1661 test_strappend();
1ef04f0b
TA		 1662 test_strstrip();
1663 test_delete_chars();
1664 test_in_charset();
44f4c86c
DB		 1665 test_hexchar();
1666 test_unhexchar();
919a7f5f
TG		 1667 test_base32hexchar();
1668 test_unbase32hexchar();
13a5d76b
TG		 1669 test_base64char();
1670 test_unbase64char();
44f4c86c
DB		 1671 test_octchar();
1672 test_unoctchar();
1673 test_decchar();
1674 test_undecchar();
30494563 1675 test_unhexmem();
919a7f5f
TG		 1676 test_base32hexmem();
1677 test_unbase32hexmem();
13a5d76b
TG		 1678 test_base64mem();
1679 test_unbase64mem();
b4ecc959
TA		 1680 test_cescape();
1681 test_cunescape();
1ef04f0b 1682 test_foreach_word();
539ad707 1683 test_foreach_word_quoted();
0d585d82 1684 test_memdup_multiply();
144e51ec 1685 test_u64log2();
2a371001 1686 test_protect_errno();
5f05235f 1687 test_parse_cpu_set();
59f448cf 1688 test_config_parse_iec_uint64();
b4ecc959
TA		 1689 test_strextend();
1690 test_strrep();
d4ac85c6 1691 test_split_pair();
22f5f628 1692 test_fstab_node_to_udev_node();
893fa014 1693 test_get_files_in_directory();
cabb7806 1694 test_in_set();
87b02843 1695 test_writing_tmpfile();
29bfbcd6 1696 test_hexdump();
8fe90522 1697 test_log2i();
c4a7b2c5 1698 test_foreach_string();
ae6c3cc0 1699 test_filename_is_valid();
1cb1767a 1700 test_string_has_cc();
927be00c
RC		 1701 test_ascii_strlower();
1702 test_files_same();
1703 test_is_valid_documentation_url();
1704 test_file_in_same_dir();
1705 test_endswith();
ff9265d0 1706 test_endswith_no_case();
927be00c
RC		 1707 test_close_nointr();
1708 test_unlink_noerrno();
1709 test_readlink_and_make_absolute();
927be00c
RC		 1710 test_ignore_signals();
1711 test_strshorten();
63c372cb 1712 test_strjoina();
8852362b 1713 test_is_symlink();
8852362b
RC		 1714 test_search_and_fopen();
1715 test_search_and_fopen_nulstr();
1716 test_glob_exists();
1717 test_execute_directory();
f32d2db1 1718 test_parse_proc_cmdline();
ee05e779 1719 test_raw_clone();
f7ad54a3 1720 test_same_fd();
8cb4ab00 1721 test_uid_ptr();
ff6a7460 1722 test_sparse_write();
61ee6939 1723 test_shell_escape();
019c7fba 1724 test_shell_maybe_quote();
14bcf25c 1725 test_tempfn();
c030a850 1726 test_strcmp_ptr();
df241a67 1727 test_fgetxattrat_fake();
c573dcfe 1728 test_runlevel_to_target();
539ad707
TA		 1729
1730 return 0;
1731}
Unnamed repository; edit this file 'description' to name the repository.