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