src/test/test-util.c

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