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