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