src/test/test-util.c

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