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 "strv.h"
  35 #include "def.h"
  36 #include "fileio.h"
  37 #include "conf-parser.h"
  38
  39 static void test_streq_ptr(void) {
  40         assert_se(streq_ptr(NULL, NULL));
  41         assert_se(!streq_ptr("abc", "cdef"));
  42 }
  43
  44 static void test_align_power2(void) {
  45         unsigned long i, p2;
  46
  47         assert_se(ALIGN_POWER2(0) == 0);
  48         assert_se(ALIGN_POWER2(1) == 1);
  49         assert_se(ALIGN_POWER2(2) == 2);
  50         assert_se(ALIGN_POWER2(3) == 4);
  51         assert_se(ALIGN_POWER2(12) == 16);
  52
  53         assert_se(ALIGN_POWER2(ULONG_MAX) == 0);
  54         assert_se(ALIGN_POWER2(ULONG_MAX - 1) == 0);
  55         assert_se(ALIGN_POWER2(ULONG_MAX - 1024) == 0);
  56         assert_se(ALIGN_POWER2(ULONG_MAX / 2) == ULONG_MAX / 2 + 1);
  57         assert_se(ALIGN_POWER2(ULONG_MAX + 1) == 0);
  58
  59         for (i = 1; i < 131071; ++i) {
  60                 for (p2 = 1; p2 < i; p2 <<= 1)
  61                         /* empty */ ;
  62
  63                 assert_se(ALIGN_POWER2(i) == p2);
  64         }
  65
  66         for (i = ULONG_MAX - 1024; i < ULONG_MAX; ++i) {
  67                 for (p2 = 1; p2 && p2 < i; p2 <<= 1)
  68                         /* empty */ ;
  69
  70                 assert_se(ALIGN_POWER2(i) == p2);
  71         }
  72 }
  73
  74 static void test_max(void) {
  75         static const struct {
  76                 int a;
  77                 int b[CONST_MAX(10, 100)];
  78         } val1 = {
  79                 .a = CONST_MAX(10, 100),
  80         };
  81         int d = 0;
  82
  83         assert_cc(sizeof(val1.b) == sizeof(int) * 100);
  84
  85         /* CONST_MAX returns (void) instead of a value if the passed arguments
  86          * are not of the same type or not constant expressions. */
  87         assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 10)), int));
  88         assert_cc(__builtin_types_compatible_p(typeof(CONST_MAX(1, 1U)), void));
  89
  90         assert_se(val1.a == 100);
  91         assert_se(MAX(++d, 0) == 1);
  92         assert_se(d == 1);
  93
  94         assert_cc(MAXSIZE(char[3], uint16_t) == 3);
  95         assert_cc(MAXSIZE(char[3], uint32_t) == 4);
  96         assert_cc(MAXSIZE(char, long) == sizeof(long));
  97
  98         assert_se(MAX(-5, 5) == 5);
  99         assert_se(MAX(5, 5) == 5);
 100         assert_se(MAX(MAX(1, MAX(2, MAX(3, 4))), 5) == 5);
 101         assert_se(MAX(MAX(1, MAX(2, MAX(3, 2))), 1) == 3);
 102         assert_se(MAX(MIN(1, MIN(2, MIN(3, 4))), 5) == 5);
 103         assert_se(MAX(MAX(1, MIN(2, MIN(3, 2))), 1) == 2);
 104         assert_se(LESS_BY(8, 4) == 4);
 105         assert_se(LESS_BY(8, 8) == 0);
 106         assert_se(LESS_BY(4, 8) == 0);
 107         assert_se(LESS_BY(16, LESS_BY(8, 4)) == 12);
 108         assert_se(LESS_BY(4, LESS_BY(8, 4)) == 0);
 109         assert_se(CLAMP(-5, 0, 1) == 0);
 110         assert_se(CLAMP(5, 0, 1) == 1);
 111         assert_se(CLAMP(5, -10, 1) == 1);
 112         assert_se(CLAMP(5, -10, 10) == 5);
 113         assert_se(CLAMP(CLAMP(0, -10, 10), CLAMP(-5, 10, 20), CLAMP(100, -5, 20)) == 10);
 114 }
 115
 116 static void test_container_of(void) {
 117         struct mytype {
 118                 uint8_t pad1[3];
 119                 uint64_t v1;
 120                 uint8_t pad2[2];
 121                 uint32_t v2;
 122         } _packed_ myval = { };
 123
 124         assert_cc(sizeof(myval) == 17);
 125         assert_se(container_of(&myval.v1, struct mytype, v1) == &myval);
 126         assert_se(container_of(&myval.v2, struct mytype, v2) == &myval);
 127         assert_se(container_of(&container_of(&myval.v2,
 128                                              struct mytype,
 129                                              v2)->v1,
 130                                struct mytype,
 131                                v1) == &myval);
 132 }
 133
 134 static void test_alloca(void) {
 135         static const uint8_t zero[997] = { };
 136         char *t;
 137
 138         t = alloca_align(17, 512);
 139         assert_se(!((uintptr_t)t & 0xff));
 140         memzero(t, 17);
 141
 142         t = alloca0_align(997, 1024);
 143         assert_se(!((uintptr_t)t & 0x1ff));
 144         assert_se(!memcmp(t, zero, 997));
 145 }
 146
 147 static void test_first_word(void) {
 148         assert_se(first_word("Hello", ""));
 149         assert_se(first_word("Hello", "Hello"));
 150         assert_se(first_word("Hello world", "Hello"));
 151         assert_se(first_word("Hello\tworld", "Hello"));
 152         assert_se(first_word("Hello\nworld", "Hello"));
 153         assert_se(first_word("Hello\rworld", "Hello"));
 154         assert_se(first_word("Hello ", "Hello"));
 155
 156         assert_se(!first_word("Hello", "Hellooo"));
 157         assert_se(!first_word("Hello", "xxxxx"));
 158         assert_se(!first_word("Hellooo", "Hello"));
 159 }
 160
 161 static void test_close_many(void) {
 162         int fds[3];
 163         char name0[] = "/tmp/test-close-many.XXXXXX";
 164         char name1[] = "/tmp/test-close-many.XXXXXX";
 165         char name2[] = "/tmp/test-close-many.XXXXXX";
 166
 167         fds[0] = mkostemp_safe(name0, O_RDWR|O_CLOEXEC);
 168         fds[1] = mkostemp_safe(name1, O_RDWR|O_CLOEXEC);
 169         fds[2] = mkostemp_safe(name2, O_RDWR|O_CLOEXEC);
 170
 171         close_many(fds, 2);
 172
 173         assert_se(fcntl(fds[0], F_GETFD) == -1);
 174         assert_se(fcntl(fds[1], F_GETFD) == -1);
 175         assert_se(fcntl(fds[2], F_GETFD) >= 0);
 176
 177         safe_close(fds[2]);
 178
 179         unlink(name0);
 180         unlink(name1);
 181         unlink(name2);
 182 }
 183
 184 static void test_parse_boolean(void) {
 185         assert_se(parse_boolean("1") == 1);
 186         assert_se(parse_boolean("y") == 1);
 187         assert_se(parse_boolean("Y") == 1);
 188         assert_se(parse_boolean("yes") == 1);
 189         assert_se(parse_boolean("YES") == 1);
 190         assert_se(parse_boolean("true") == 1);
 191         assert_se(parse_boolean("TRUE") == 1);
 192         assert_se(parse_boolean("on") == 1);
 193         assert_se(parse_boolean("ON") == 1);
 194
 195         assert_se(parse_boolean("0") == 0);
 196         assert_se(parse_boolean("n") == 0);
 197         assert_se(parse_boolean("N") == 0);
 198         assert_se(parse_boolean("no") == 0);
 199         assert_se(parse_boolean("NO") == 0);
 200         assert_se(parse_boolean("false") == 0);
 201         assert_se(parse_boolean("FALSE") == 0);
 202         assert_se(parse_boolean("off") == 0);
 203         assert_se(parse_boolean("OFF") == 0);
 204
 205         assert_se(parse_boolean("garbage") < 0);
 206         assert_se(parse_boolean("") < 0);
 207         assert_se(parse_boolean("full") < 0);
 208 }
 209
 210 static void test_parse_pid(void) {
 211         int r;
 212         pid_t pid;
 213
 214         r = parse_pid("100", &pid);
 215         assert_se(r == 0);
 216         assert_se(pid == 100);
 217
 218         r = parse_pid("0x7FFFFFFF", &pid);
 219         assert_se(r == 0);
 220         assert_se(pid == 2147483647);
 221
 222         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
 223         r = parse_pid("0", &pid);
 224         assert_se(r == -ERANGE);
 225         assert_se(pid == 65);
 226
 227         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
 228         r = parse_pid("-100", &pid);
 229         assert_se(r == -ERANGE);
 230         assert_se(pid == 65);
 231
 232         pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
 233         r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
 234         assert_se(r == -ERANGE);
 235         assert_se(pid == 65);
 236 }
 237
 238 static void test_parse_uid(void) {
 239         int r;
 240         uid_t uid;
 241
 242         r = parse_uid("100", &uid);
 243         assert_se(r == 0);
 244         assert_se(uid == 100);
 245 }
 246
 247 static void test_safe_atolli(void) {
 248         int r;
 249         long long l;
 250
 251         r = safe_atolli("12345", &l);
 252         assert_se(r == 0);
 253         assert_se(l == 12345);
 254
 255         r = safe_atolli("junk", &l);
 256         assert_se(r == -EINVAL);
 257 }
 258
 259 static void test_safe_atod(void) {
 260         int r;
 261         double d;
 262         char *e;
 263
 264         r = safe_atod("junk", &d);
 265         assert_se(r == -EINVAL);
 266
 267         r = safe_atod("0.2244", &d);
 268         assert_se(r == 0);
 269         assert_se(fabs(d - 0.2244) < 0.000001);
 270
 271         r = safe_atod("0,5", &d);
 272         assert_se(r == -EINVAL);
 273
 274         errno = 0;
 275         strtod("0,5", &e);
 276         assert_se(*e == ',');
 277
 278         /* Check if this really is locale independent */
 279         if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
 280
 281                 r = safe_atod("0.2244", &d);
 282                 assert_se(r == 0);
 283                 assert_se(fabs(d - 0.2244) < 0.000001);
 284
 285                 r = safe_atod("0,5", &d);
 286                 assert_se(r == -EINVAL);
 287
 288                 errno = 0;
 289                 assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
 290         }
 291
 292         /* And check again, reset */
 293         assert_se(setlocale(LC_NUMERIC, "C"));
 294
 295         r = safe_atod("0.2244", &d);
 296         assert_se(r == 0);
 297         assert_se(fabs(d - 0.2244) < 0.000001);
 298
 299         r = safe_atod("0,5", &d);
 300         assert_se(r == -EINVAL);
 301
 302         errno = 0;
 303         strtod("0,5", &e);
 304         assert_se(*e == ',');
 305 }
 306
 307 static void test_strappend(void) {
 308         _cleanup_free_ char *t1, *t2, *t3, *t4;
 309
 310         t1 = strappend(NULL, NULL);
 311         assert_se(streq(t1, ""));
 312
 313         t2 = strappend(NULL, "suf");
 314         assert_se(streq(t2, "suf"));
 315
 316         t3 = strappend("pre", NULL);
 317         assert_se(streq(t3, "pre"));
 318
 319         t4 = strappend("pre", "suf");
 320         assert_se(streq(t4, "presuf"));
 321 }
 322
 323 static void test_strstrip(void) {
 324         char *r;
 325         char input[] = "   hello, waldo.   ";
 326
 327         r = strstrip(input);
 328         assert_se(streq(r, "hello, waldo."));
 329 }
 330
 331 static void test_delete_chars(void) {
 332         char *r;
 333         char input[] = "   hello, waldo.   abc";
 334
 335         r = delete_chars(input, WHITESPACE);
 336         assert_se(streq(r, "hello,waldo.abc"));
 337 }
 338
 339 static void test_in_charset(void) {
 340         assert_se(in_charset("dddaaabbbcccc", "abcd"));
 341         assert_se(!in_charset("dddaaabbbcccc", "abc f"));
 342 }
 343
 344 static void test_hexchar(void) {
 345         assert_se(hexchar(0xa) == 'a');
 346         assert_se(hexchar(0x0) == '0');
 347 }
 348
 349 static void test_unhexchar(void) {
 350         assert_se(unhexchar('a') == 0xA);
 351         assert_se(unhexchar('A') == 0xA);
 352         assert_se(unhexchar('0') == 0x0);
 353 }
 354
 355 static void test_octchar(void) {
 356         assert_se(octchar(00) == '0');
 357         assert_se(octchar(07) == '7');
 358 }
 359
 360 static void test_unoctchar(void) {
 361         assert_se(unoctchar('0') == 00);
 362         assert_se(unoctchar('7') == 07);
 363 }
 364
 365 static void test_decchar(void) {
 366         assert_se(decchar(0) == '0');
 367         assert_se(decchar(9) == '9');
 368 }
 369
 370 static void test_undecchar(void) {
 371         assert_se(undecchar('0') == 0);
 372         assert_se(undecchar('9') == 9);
 373 }
 374
 375 static void test_cescape(void) {
 376         _cleanup_free_ char *escaped;
 377
 378         assert_se(escaped = cescape("abc\\\"\b\f\n\r\t\v\a\003\177\234\313"));
 379         assert_se(streq(escaped, "abc\\\\\\\"\\b\\f\\n\\r\\t\\v\\a\\003\\177\\234\\313"));
 380 }
 381
 382 static void test_cunescape(void) {
 383         _cleanup_free_ char *unescaped;
 384
 385         assert_se(unescaped = cunescape("abc\\\\\\\"\\b\\f\\a\\n\\r\\t\\v\\003\\177\\234\\313\\000\\x00"));
 386         assert_se(streq(unescaped, "abc\\\"\b\f\a\n\r\t\v\003\177\234\313\\000\\x00"));
 387 }
 388
 389 static void test_foreach_word(void) {
 390         const char *word, *state;
 391         size_t l;
 392         int i = 0;
 393         const char test[] = "test abc d\te   f   ";
 394         const char * const expected[] = {
 395                 "test",
 396                 "abc",
 397                 "d",
 398                 "e",
 399                 "f",
 400                 "",
 401                 NULL
 402         };
 403
 404         FOREACH_WORD(word, l, test, state)
 405                 assert_se(strneq(expected[i++], word, l));
 406 }
 407
 408 static void test_foreach_word_quoted(void) {
 409         const char *word, *state;
 410         size_t l;
 411         int i = 0;
 412         const char test[] = "test a b c 'd' e '' '' hhh '' '' \"a b c\"";
 413         const char * const expected[] = {
 414                 "test",
 415                 "a",
 416                 "b",
 417                 "c",
 418                 "d",
 419                 "e",
 420                 "",
 421                 "",
 422                 "hhh",
 423                 "",
 424                 "",
 425                 "a b c",
 426                 NULL
 427         };
 428
 429         printf("<%s>\n", test);
 430         FOREACH_WORD_QUOTED(word, l, test, state) {
 431                 _cleanup_free_ char *t = NULL;
 432
 433                 assert_se(t = strndup(word, l));
 434                 assert_se(strneq(expected[i++], word, l));
 435                 printf("<%s>\n", t);
 436         }
 437         assert_se(isempty(state));
 438 }
 439
 440 static void test_default_term_for_tty(void) {
 441         puts(default_term_for_tty("/dev/tty23"));
 442         puts(default_term_for_tty("/dev/ttyS23"));
 443         puts(default_term_for_tty("/dev/tty0"));
 444         puts(default_term_for_tty("/dev/pty0"));
 445         puts(default_term_for_tty("/dev/pts/0"));
 446         puts(default_term_for_tty("/dev/console"));
 447         puts(default_term_for_tty("tty23"));
 448         puts(default_term_for_tty("ttyS23"));
 449         puts(default_term_for_tty("tty0"));
 450         puts(default_term_for_tty("pty0"));
 451         puts(default_term_for_tty("pts/0"));
 452         puts(default_term_for_tty("console"));
 453 }
 454
 455 static void test_memdup_multiply(void) {
 456         int org[] = {1, 2, 3};
 457         int *dup;
 458
 459         dup = (int*)memdup_multiply(org, sizeof(int), 3);
 460
 461         assert_se(dup);
 462         assert_se(dup[0] == 1);
 463         assert_se(dup[1] == 2);
 464         assert_se(dup[2] == 3);
 465         free(dup);
 466 }
 467
 468 static void test_hostname_is_valid(void) {
 469         assert_se(hostname_is_valid("foobar"));
 470         assert_se(hostname_is_valid("foobar.com"));
 471         assert_se(!hostname_is_valid("fööbar"));
 472         assert_se(!hostname_is_valid(""));
 473         assert_se(!hostname_is_valid("."));
 474         assert_se(!hostname_is_valid(".."));
 475         assert_se(!hostname_is_valid("foobar."));
 476         assert_se(!hostname_is_valid(".foobar"));
 477         assert_se(!hostname_is_valid("foo..bar"));
 478         assert_se(!hostname_is_valid("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
 479 }
 480
 481 static void test_u64log2(void) {
 482         assert_se(u64log2(0) == 0);
 483         assert_se(u64log2(8) == 3);
 484         assert_se(u64log2(9) == 3);
 485         assert_se(u64log2(15) == 3);
 486         assert_se(u64log2(16) == 4);
 487         assert_se(u64log2(1024*1024) == 20);
 488         assert_se(u64log2(1024*1024+5) == 20);
 489 }
 490
 491 static void test_get_process_comm(void) {
 492         struct stat st;
 493         _cleanup_free_ char *a = NULL, *c = NULL, *d = NULL, *f = NULL, *i = NULL;
 494         unsigned long long b;
 495         pid_t e;
 496         uid_t u;
 497         gid_t g;
 498         dev_t h;
 499         int r;
 500
 501         if (stat("/proc/1/comm", &st) == 0) {
 502                 assert_se(get_process_comm(1, &a) >= 0);
 503                 log_info("pid1 comm: '%s'", a);
 504         } else {
 505                 log_warning("/proc/1/comm does not exist.");
 506         }
 507
 508         assert_se(get_starttime_of_pid(1, &b) >= 0);
 509         log_info("pid1 starttime: '%llu'", b);
 510
 511         assert_se(get_process_cmdline(1, 0, true, &c) >= 0);
 512         log_info("pid1 cmdline: '%s'", c);
 513
 514         assert_se(get_process_cmdline(1, 8, false, &d) >= 0);
 515         log_info("pid1 cmdline truncated: '%s'", d);
 516
 517         assert_se(get_parent_of_pid(1, &e) >= 0);
 518         log_info("pid1 ppid: "PID_FMT, e);
 519         assert_se(e == 0);
 520
 521         assert_se(is_kernel_thread(1) == 0);
 522
 523         r = get_process_exe(1, &f);
 524         assert_se(r >= 0 || r == -EACCES);
 525         log_info("pid1 exe: '%s'", strna(f));
 526
 527         assert_se(get_process_uid(1, &u) == 0);
 528         log_info("pid1 uid: "UID_FMT, u);
 529         assert_se(u == 0);
 530
 531         assert_se(get_process_gid(1, &g) == 0);
 532         log_info("pid1 gid: "GID_FMT, g);
 533         assert_se(g == 0);
 534
 535         assert_se(get_ctty_devnr(1, &h) == -ENOENT);
 536
 537         getenv_for_pid(1, "PATH", &i);
 538         log_info("pid1 $PATH: '%s'", strna(i));
 539 }
 540
 541 static void test_protect_errno(void) {
 542         errno = 12;
 543         {
 544                 PROTECT_ERRNO;
 545                 errno = 11;
 546         }
 547         assert_se(errno == 12);
 548 }
 549
 550 static void test_parse_size(void) {
 551         off_t bytes;
 552
 553         assert_se(parse_size("111", 1024, &bytes) == 0);
 554         assert_se(bytes == 111);
 555
 556         assert_se(parse_size("111.4", 1024, &bytes) == 0);
 557         assert_se(bytes == 111);
 558
 559         assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
 560         assert_se(bytes == 112);
 561
 562         assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
 563         assert_se(bytes == 112);
 564
 565         assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
 566         assert_se(bytes == 3*1024 + 512);
 567
 568         assert_se(parse_size("3. K", 1024, &bytes) == 0);
 569         assert_se(bytes == 3*1024);
 570
 571         assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
 572         assert_se(bytes == 3*1024);
 573
 574         assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
 575
 576         assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
 577         assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
 578
 579         assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
 580
 581         assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
 582         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
 583
 584         assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
 585         assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
 586
 587         assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
 588
 589         assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
 590         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 591
 592         assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
 593         assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
 594
 595         assert_se(parse_size("12P", 1024, &bytes) == 0);
 596         assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
 597
 598         assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
 599
 600         assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
 601         assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
 602
 603         assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
 604
 605         assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
 606
 607         assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
 608
 609         assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
 610         assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
 611         assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
 612
 613         assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
 614
 615         assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
 616 }
 617
 618 static void test_config_parse_iec_off(void) {
 619         off_t offset = 0;
 620         assert_se(config_parse_iec_off(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4M", &offset, NULL) == 0);
 621         assert_se(offset == 4 * 1024 * 1024);
 622
 623         assert_se(config_parse_iec_off(NULL, "/this/file", 11, "Section", 22, "Size", 0, "4.5M", &offset, NULL) == 0);
 624 }
 625
 626 static void test_strextend(void) {
 627         _cleanup_free_ char *str = strdup("0123");
 628         strextend(&str, "456", "78", "9", NULL);
 629         assert_se(streq(str, "0123456789"));
 630 }
 631
 632 static void test_strrep(void) {
 633         _cleanup_free_ char *one, *three, *zero;
 634         one = strrep("waldo", 1);
 635         three = strrep("waldo", 3);
 636         zero = strrep("waldo", 0);
 637
 638         assert_se(streq(one, "waldo"));
 639         assert_se(streq(three, "waldowaldowaldo"));
 640         assert_se(streq(zero, ""));
 641 }
 642
 643 static void test_split_pair(void) {
 644         _cleanup_free_ char *a = NULL, *b = NULL;
 645
 646         assert_se(split_pair("", "", &a, &b) == -EINVAL);
 647         assert_se(split_pair("foo=bar", "", &a, &b) == -EINVAL);
 648         assert_se(split_pair("", "=", &a, &b) == -EINVAL);
 649         assert_se(split_pair("foo=bar", "=", &a, &b) >= 0);
 650         assert_se(streq(a, "foo"));
 651         assert_se(streq(b, "bar"));
 652         free(a);
 653         free(b);
 654         assert_se(split_pair("==", "==", &a, &b) >= 0);
 655         assert_se(streq(a, ""));
 656         assert_se(streq(b, ""));
 657         free(a);
 658         free(b);
 659
 660         assert_se(split_pair("===", "==", &a, &b) >= 0);
 661         assert_se(streq(a, ""));
 662         assert_se(streq(b, "="));
 663 }
 664
 665 static void test_fstab_node_to_udev_node(void) {
 666         char *n;
 667
 668         n = fstab_node_to_udev_node("LABEL=applé/jack");
 669         puts(n);
 670         assert_se(streq(n, "/dev/disk/by-label/applé\\x2fjack"));
 671         free(n);
 672
 673         n = fstab_node_to_udev_node("PARTLABEL=pinkié pie");
 674         puts(n);
 675         assert_se(streq(n, "/dev/disk/by-partlabel/pinkié\\x20pie"));
 676         free(n);
 677
 678         n = fstab_node_to_udev_node("UUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
 679         puts(n);
 680         assert_se(streq(n, "/dev/disk/by-uuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
 681         free(n);
 682
 683         n = fstab_node_to_udev_node("PARTUUID=037b9d94-148e-4ee4-8d38-67bfe15bb535");
 684         puts(n);
 685         assert_se(streq(n, "/dev/disk/by-partuuid/037b9d94-148e-4ee4-8d38-67bfe15bb535"));
 686         free(n);
 687
 688         n = fstab_node_to_udev_node("PONIES=awesome");
 689         puts(n);
 690         assert_se(streq(n, "PONIES=awesome"));
 691         free(n);
 692
 693         n = fstab_node_to_udev_node("/dev/xda1");
 694         puts(n);
 695         assert_se(streq(n, "/dev/xda1"));
 696         free(n);
 697 }
 698
 699 static void test_get_files_in_directory(void) {
 700         _cleanup_strv_free_ char **l = NULL, **t = NULL;
 701
 702         assert_se(get_files_in_directory("/tmp", &l) >= 0);
 703         assert_se(get_files_in_directory(".", &t) >= 0);
 704         assert_se(get_files_in_directory(".", NULL) >= 0);
 705 }
 706
 707 static void test_in_set(void) {
 708         assert_se(IN_SET(1, 1));
 709         assert_se(IN_SET(1, 1, 2, 3, 4));
 710         assert_se(IN_SET(2, 1, 2, 3, 4));
 711         assert_se(IN_SET(3, 1, 2, 3, 4));
 712         assert_se(IN_SET(4, 1, 2, 3, 4));
 713         assert_se(!IN_SET(0, 1));
 714         assert_se(!IN_SET(0, 1, 2, 3, 4));
 715 }
 716
 717 static void test_writing_tmpfile(void) {
 718         char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
 719         _cleanup_free_ char *contents = NULL;
 720         size_t size;
 721         int fd, r;
 722         struct iovec iov[3];
 723
 724         IOVEC_SET_STRING(iov[0], "abc\n");
 725         IOVEC_SET_STRING(iov[1], ALPHANUMERICAL "\n");
 726         IOVEC_SET_STRING(iov[2], "");
 727
 728         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
 729         printf("tmpfile: %s", name);
 730
 731         r = writev(fd, iov, 3);
 732         assert_se(r >= 0);
 733
 734         r = read_full_file(name, &contents, &size);
 735         assert_se(r == 0);
 736         printf("contents: %s", contents);
 737         assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
 738
 739         unlink(name);
 740 }
 741
 742 static void test_hexdump(void) {
 743         uint8_t data[146];
 744         unsigned i;
 745
 746         hexdump(stdout, NULL, 0);
 747         hexdump(stdout, "", 0);
 748         hexdump(stdout, "", 1);
 749         hexdump(stdout, "x", 1);
 750         hexdump(stdout, "x", 2);
 751         hexdump(stdout, "foobar", 7);
 752         hexdump(stdout, "f\nobar", 7);
 753         hexdump(stdout, "xxxxxxxxxxxxxxxxxxxxyz", 23);
 754
 755         for (i = 0; i < ELEMENTSOF(data); i++)
 756                 data[i] = i*2;
 757
 758         hexdump(stdout, data, sizeof(data));
 759 }
 760
 761 static void test_log2i(void) {
 762         assert_se(log2i(1) == 0);
 763         assert_se(log2i(2) == 1);
 764         assert_se(log2i(3) == 1);
 765         assert_se(log2i(4) == 2);
 766         assert_se(log2i(32) == 5);
 767         assert_se(log2i(33) == 5);
 768         assert_se(log2i(63) == 5);
 769         assert_se(log2i(INT_MAX) == sizeof(int)*8-2);
 770 }
 771
 772 static void test_foreach_string(void) {
 773         const char * const t[] = {
 774                 "foo",
 775                 "bar",
 776                 "waldo",
 777                 NULL
 778         };
 779         const char *x;
 780         unsigned i = 0;
 781
 782         FOREACH_STRING(x, "foo", "bar", "waldo")
 783                 assert_se(streq_ptr(t[i++], x));
 784
 785         assert_se(i == 3);
 786
 787         FOREACH_STRING(x, "zzz")
 788                 assert_se(streq(x, "zzz"));
 789 }
 790
 791 static void test_filename_is_safe(void) {
 792         char foo[FILENAME_MAX+2];
 793         int i;
 794
 795         assert_se(!filename_is_safe(""));
 796         assert_se(!filename_is_safe("/bar/foo"));
 797         assert_se(!filename_is_safe("/"));
 798         assert_se(!filename_is_safe("."));
 799         assert_se(!filename_is_safe(".."));
 800
 801         for (i=0; i<FILENAME_MAX+1; i++)
 802                 foo[i] = 'a';
 803         foo[FILENAME_MAX+1] = '\0';
 804
 805         assert_se(!filename_is_safe(foo));
 806
 807         assert_se(filename_is_safe("foo_bar-333"));
 808         assert_se(filename_is_safe("o.o"));
 809 }
 810
 811 static void test_string_has_cc(void) {
 812         assert_se(string_has_cc("abc\1", NULL));
 813         assert_se(string_has_cc("abc\x7f", NULL));
 814         assert_se(string_has_cc("abc\x7f", NULL));
 815         assert_se(string_has_cc("abc\t\x7f", "\t"));
 816         assert_se(string_has_cc("abc\t\x7f", "\t"));
 817         assert_se(string_has_cc("\x7f", "\t"));
 818         assert_se(string_has_cc("\x7f", "\t\a"));
 819
 820         assert_se(!string_has_cc("abc\t\t", "\t"));
 821         assert_se(!string_has_cc("abc\t\t\a", "\t\a"));
 822         assert_se(!string_has_cc("a\ab\tc", "\t\a"));
 823 }
 824
 825 static void test_ascii_strlower(void) {
 826         char a[] = "AabBcC Jk Ii Od LKJJJ kkd LK";
 827         assert_se(streq(ascii_strlower(a), "aabbcc jk ii od lkjjj kkd lk"));
 828 }
 829
 830 static void test_files_same(void) {
 831         _cleanup_close_ int fd = -1;
 832         char name[] = "/tmp/test-files_same.XXXXXX";
 833         char name_alias[] = "/tmp/test-files_same.alias";
 834
 835         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
 836         assert_se(fd >= 0);
 837         assert_se(symlink(name, name_alias) >= 0);
 838
 839         assert_se(files_same(name, name));
 840         assert_se(files_same(name, name_alias));
 841
 842         unlink(name);
 843         unlink(name_alias);
 844 }
 845
 846 static void test_is_valid_documentation_url(void) {
 847         assert_se(is_valid_documentation_url("http://www.freedesktop.org/wiki/Software/systemd"));
 848         assert_se(is_valid_documentation_url("https://www.kernel.org/doc/Documentation/binfmt_misc.txt"));
 849         assert_se(is_valid_documentation_url("file:foo"));
 850         assert_se(is_valid_documentation_url("man:systemd.special(7)"));
 851         assert_se(is_valid_documentation_url("info:bar"));
 852
 853         assert_se(!is_valid_documentation_url("foo:"));
 854         assert_se(!is_valid_documentation_url("info:"));
 855         assert_se(!is_valid_documentation_url(""));
 856 }
 857
 858 static void test_file_in_same_dir(void) {
 859         char *t;
 860
 861         t = file_in_same_dir("/", "a");
 862         assert_se(streq(t, "/a"));
 863         free(t);
 864
 865         t = file_in_same_dir("/", "/a");
 866         assert_se(streq(t, "/a"));
 867         free(t);
 868
 869         t = file_in_same_dir("", "a");
 870         assert_se(streq(t, "a"));
 871         free(t);
 872
 873         t = file_in_same_dir("a/", "a");
 874         assert_se(streq(t, "a/a"));
 875         free(t);
 876
 877         t = file_in_same_dir("bar/foo", "bar");
 878         assert_se(streq(t, "bar/bar"));
 879         free(t);
 880 }
 881
 882 static void test_endswith(void) {
 883         assert_se(endswith("foobar", "bar"));
 884         assert_se(endswith("foobar", ""));
 885         assert_se(endswith("foobar", "foobar"));
 886         assert_se(endswith("", ""));
 887
 888         assert_se(!endswith("foobar", "foo"));
 889         assert_se(!endswith("foobar", "foobarfoofoo"));
 890 }
 891
 892 static void test_close_nointr(void) {
 893         char name[] = "/tmp/test-test-close_nointr.XXXXXX";
 894         int fd;
 895
 896         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
 897         assert_se(fd >= 0);
 898         assert_se(close_nointr(fd) >= 0);
 899         assert_se(close_nointr(fd) < 0);
 900
 901         unlink(name);
 902 }
 903
 904
 905 static void test_unlink_noerrno(void) {
 906         char name[] = "/tmp/test-close_nointr.XXXXXX";
 907         int fd;
 908
 909         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
 910         assert_se(fd >= 0);
 911         assert_se(close_nointr(fd) >= 0);
 912
 913         {
 914                 PROTECT_ERRNO;
 915                 errno = -42;
 916                 assert_se(unlink_noerrno(name) >= 0);
 917                 assert_se(errno == -42);
 918                 assert_se(unlink_noerrno(name) < 0);
 919                 assert_se(errno == -42);
 920         }
 921 }
 922
 923 static void test_readlink_and_make_absolute(void) {
 924         char tempdir[] = "/tmp/test-readlink_and_make_absolute";
 925         char name[] = "/tmp/test-readlink_and_make_absolute/original";
 926         char name2[] = "test-readlink_and_make_absolute/original";
 927         char name_alias[] = "/tmp/test-readlink_and_make_absolute-alias";
 928         char *r = NULL;
 929
 930         assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0);
 931         assert_se(touch(name) >= 0);
 932
 933         assert_se(symlink(name, name_alias) >= 0);
 934         assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
 935         assert_se(streq(r, name));
 936         free(r);
 937         assert_se(unlink(name_alias) >= 0);
 938
 939         assert_se(chdir(tempdir) >= 0);
 940         assert_se(symlink(name2, name_alias) >= 0);
 941         assert_se(readlink_and_make_absolute(name_alias, &r) >= 0);
 942         assert_se(streq(r, name));
 943         free(r);
 944         assert_se(unlink(name_alias) >= 0);
 945
 946         assert_se(rm_rf_dangerous(tempdir, false, true, false) >= 0);
 947 }
 948
 949 static void test_read_one_char(void) {
 950         _cleanup_fclose_ FILE *file = NULL;
 951         char r;
 952         bool need_nl;
 953         char name[] = "/tmp/test-read_one_char.XXXXXX";
 954         int fd;
 955
 956         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
 957         assert_se(fd >= 0);
 958         file = fdopen(fd, "r+");
 959         assert_se(file);
 960         assert_se(fputs("c\n", file) >= 0);
 961         rewind(file);
 962
 963         assert_se(read_one_char(file, &r, 1000000, &need_nl) >= 0);
 964         assert_se(!need_nl);
 965         assert_se(r == 'c');
 966         assert_se(read_one_char(file, &r, 1000000, &need_nl) < 0);
 967
 968         rewind(file);
 969         assert_se(fputs("foobar\n", file) >= 0);
 970         rewind(file);
 971         assert_se(read_one_char(file, &r, 1000000, &need_nl) < 0);
 972
 973         rewind(file);
 974         assert_se(fputs("\n", file) >= 0);
 975         rewind(file);
 976         assert_se(read_one_char(file, &r, 1000000, &need_nl) < 0);
 977
 978         unlink(name);
 979 }
 980
 981 static void test_ignore_signals(void) {
 982         assert_se(ignore_signals(SIGINT, -1) >= 0);
 983         assert_se(kill(getpid(), SIGINT) >= 0);
 984         assert_se(ignore_signals(SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
 985         assert_se(kill(getpid(), SIGUSR1) >= 0);
 986         assert_se(kill(getpid(), SIGUSR2) >= 0);
 987         assert_se(kill(getpid(), SIGTERM) >= 0);
 988         assert_se(kill(getpid(), SIGPIPE) >= 0);
 989         assert_se(default_signals(SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
 990 }
 991
 992 static void test_strshorten(void) {
 993         char s[] = "foobar";
 994
 995         assert_se(strlen(strshorten(s, 6)) == 6);
 996         assert_se(strlen(strshorten(s, 12)) == 6);
 997         assert_se(strlen(strshorten(s, 2)) == 2);
 998         assert_se(strlen(strshorten(s, 0)) == 0);
 999 }
1000
1001 static void test_strappenda(void) {
1002         char *actual;
1003
1004         actual = strappenda("", "foo", "bar");
1005         assert_se(streq(actual, "foobar"));
1006
1007         actual = strappenda("foo", "bar", "baz");
1008         assert_se(streq(actual, "foobarbaz"));
1009
1010         actual = strappenda("foo", "", "bar", "baz");
1011         assert_se(streq(actual, "foobarbaz"));
1012 }
1013
1014 static void test_is_symlink(void) {
1015         char name[] = "/tmp/test-is_symlink.XXXXXX";
1016         char name_link[] = "/tmp/test-is_symlink.link";
1017         _cleanup_close_ int fd = -1;
1018
1019         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1020         assert_se(fd >= 0);
1021         assert_se(symlink(name, name_link) >= 0);
1022
1023         assert_se(is_symlink(name) == 0);
1024         assert_se(is_symlink(name_link) == 1);
1025         assert_se(is_symlink("/a/file/which/does/not/exist/i/guess") < 0);
1026
1027
1028         unlink(name);
1029         unlink(name_link);
1030 }
1031
1032 static void test_pid_is_unwaited(void) {
1033         pid_t pid;
1034
1035         pid = fork();
1036         assert_se(pid >= 0);
1037         if (pid == 0) {
1038                 _exit(EXIT_SUCCESS);
1039         } else {
1040                 int status;
1041
1042                 waitpid(pid, &status, 0);
1043                 assert_se(!pid_is_unwaited(pid));
1044         }
1045         assert_se(pid_is_unwaited(getpid()));
1046         assert_se(!pid_is_unwaited(-1));
1047 }
1048
1049 static void test_pid_is_alive(void) {
1050         pid_t pid;
1051
1052         pid = fork();
1053         assert_se(pid >= 0);
1054         if (pid == 0) {
1055                 _exit(EXIT_SUCCESS);
1056         } else {
1057                 int status;
1058
1059                 waitpid(pid, &status, 0);
1060                 assert_se(!pid_is_alive(pid));
1061         }
1062         assert_se(pid_is_alive(getpid()));
1063         assert_se(!pid_is_alive(-1));
1064 }
1065
1066 static void test_search_and_fopen(void) {
1067         const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
1068         char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1069         int fd = -1;
1070         int r;
1071         FILE *f;
1072
1073         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1074         assert_se(fd >= 0);
1075         close(fd);
1076
1077         r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1078         assert_se(r >= 0);
1079         fclose(f);
1080
1081         r = search_and_fopen(name, "r", NULL, dirs, &f);
1082         assert_se(r >= 0);
1083         fclose(f);
1084
1085         r = search_and_fopen(basename(name), "r", "/", dirs, &f);
1086         assert_se(r >= 0);
1087         fclose(f);
1088
1089         r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1090         assert_se(r < 0);
1091         r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1092         assert_se(r < 0);
1093
1094         r = unlink(name);
1095         assert_se(r == 0);
1096
1097         r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
1098         assert_se(r < 0);
1099 }
1100
1101
1102 static void test_search_and_fopen_nulstr(void) {
1103         const char dirs[] = "/tmp/foo/bar\0/tmp\0";
1104         char name[] = "/tmp/test-search_and_fopen.XXXXXX";
1105         int fd = -1;
1106         int r;
1107         FILE *f;
1108
1109         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1110         assert_se(fd >= 0);
1111         close(fd);
1112
1113         r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1114         assert_se(r >= 0);
1115         fclose(f);
1116
1117         r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
1118         assert_se(r >= 0);
1119         fclose(f);
1120
1121         r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
1122         assert_se(r < 0);
1123         r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
1124         assert_se(r < 0);
1125
1126         r = unlink(name);
1127         assert_se(r == 0);
1128
1129         r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
1130         assert_se(r < 0);
1131 }
1132
1133 static void test_glob_exists(void) {
1134         char name[] = "/tmp/test-glob_exists.XXXXXX";
1135         int fd = -1;
1136         int r;
1137
1138         fd = mkostemp_safe(name, O_RDWR|O_CLOEXEC);
1139         assert_se(fd >= 0);
1140         close(fd);
1141
1142         r = glob_exists("/tmp/test-glob_exists*");
1143         assert_se(r == 1);
1144
1145         r = unlink(name);
1146         assert_se(r == 0);
1147         r = glob_exists("/tmp/test-glob_exists*");
1148         assert_se(r == 0);
1149 }
1150
1151 static void test_execute_directory(void) {
1152         char name[] = "/tmp/test-execute_directory/script1";
1153         char name2[] = "/tmp/test-execute_directory/script2";
1154         char name3[] = "/tmp/test-execute_directory/useless";
1155         char tempdir[] = "/tmp/test-execute_directory/";
1156
1157         assert_se(mkdir_safe(tempdir, 0755, getuid(), getgid()) >= 0);
1158         assert_se(write_string_file(name, "#!/bin/sh\necho 'Executing '$0\ntouch /tmp/test-execute_directory/it_works") == 0);
1159         assert_se(write_string_file(name2, "#!/bin/sh\necho 'Executing '$0\ntouch /tmp/test-execute_directory/it_works2") == 0);
1160         assert_se(chmod(name, 0755) == 0);
1161         assert_se(chmod(name2, 0755) == 0);
1162         assert_se(touch(name3) >= 0);
1163
1164         execute_directory(tempdir, NULL, DEFAULT_TIMEOUT_USEC, NULL);
1165         assert_se(access("/tmp/test-execute_directory/it_works", F_OK) >= 0);
1166         assert_se(access("/tmp/test-execute_directory/it_works2", F_OK) >= 0);
1167
1168         rm_rf_dangerous(tempdir, false, true, false);
1169 }
1170
1171 static void test_unquote_first_word(void) {
1172         const char *p, *original;
1173         char *t;
1174
1175         p = original = "foobar waldo";
1176         assert_se(unquote_first_word(&p, &t) > 0);
1177         assert_se(streq(t, "foobar"));
1178         free(t);
1179         assert_se(p == original + 7);
1180
1181         assert_se(unquote_first_word(&p, &t) > 0);
1182         assert_se(streq(t, "waldo"));
1183         free(t);
1184         assert_se(p == original + 12);
1185
1186         assert_se(unquote_first_word(&p, &t) == 0);
1187         assert_se(!t);
1188         assert_se(p == original + 12);
1189
1190         p = original = "\"foobar\" \'waldo\'";
1191         assert_se(unquote_first_word(&p, &t) > 0);
1192         assert_se(streq(t, "foobar"));
1193         free(t);
1194         assert_se(p == original + 9);
1195
1196         assert_se(unquote_first_word(&p, &t) > 0);
1197         assert_se(streq(t, "waldo"));
1198         free(t);
1199         assert_se(p == original + 16);
1200
1201         assert_se(unquote_first_word(&p, &t) == 0);
1202         assert_se(!t);
1203         assert_se(p == original + 16);
1204
1205         p = original = "\"";
1206         assert_se(unquote_first_word(&p, &t) == -EINVAL);
1207         assert_se(p == original + 1);
1208
1209         p = original = "\'";
1210         assert_se(unquote_first_word(&p, &t) == -EINVAL);
1211         assert_se(p == original + 1);
1212
1213         p = original = "yay\'foo\'bar";
1214         assert_se(unquote_first_word(&p, &t) > 0);
1215         assert_se(streq(t, "yayfoobar"));
1216         free(t);
1217         assert_se(p == original + 11);
1218
1219         p = original = "   foobar   ";
1220         assert_se(unquote_first_word(&p, &t) > 0);
1221         assert_se(streq(t, "foobar"));
1222         free(t);
1223         assert_se(p == original + 12);
1224 }
1225
1226 static void test_unquote_many_words(void) {
1227         const char *p, *original;
1228         char *a, *b, *c;
1229
1230         p = original = "foobar waldi piep";
1231         assert_se(unquote_many_words(&p, &a, &b, &c, NULL) == 3);
1232         assert_se(p == original + 17);
1233         assert_se(streq_ptr(a, "foobar"));
1234         assert_se(streq_ptr(b, "waldi"));
1235         assert_se(streq_ptr(c, "piep"));
1236         free(a);
1237         free(b);
1238         free(c);
1239
1240         p = original = "'foobar' wa\"ld\"i   ";
1241         assert_se(unquote_many_words(&p, &a, &b, &c, NULL) == 2);
1242         assert_se(p == original + 19);
1243         assert_se(streq_ptr(a, "foobar"));
1244         assert_se(streq_ptr(b, "waldi"));
1245         assert_se(streq_ptr(c, NULL));
1246         free(a);
1247         free(b);
1248
1249         p = original = "";
1250         assert_se(unquote_many_words(&p, &a, &b, &c, NULL) == 0);
1251         assert_se(p == original);
1252         assert_se(streq_ptr(a, NULL));
1253         assert_se(streq_ptr(b, NULL));
1254         assert_se(streq_ptr(c, NULL));
1255
1256         p = original = "  ";
1257         assert_se(unquote_many_words(&p, &a, &b, &c, NULL) == 0);
1258         assert_se(p == original+2);
1259         assert_se(streq_ptr(a, NULL));
1260         assert_se(streq_ptr(b, NULL));
1261         assert_se(streq_ptr(c, NULL));
1262
1263         p = original = "foobar";
1264         assert_se(unquote_many_words(&p, NULL) == 0);
1265         assert_se(p == original);
1266
1267         p = original = "foobar waldi";
1268         assert_se(unquote_many_words(&p, &a, NULL) == 1);
1269         assert_se(p == original+7);
1270         assert_se(streq_ptr(a, "foobar"));
1271         free(a);
1272
1273         p = original = "     foobar    ";
1274         assert_se(unquote_many_words(&p, &a, NULL) == 1);
1275         assert_se(p == original+15);
1276         assert_se(streq_ptr(a, "foobar"));
1277         free(a);
1278 }
1279
1280 int main(int argc, char *argv[]) {
1281         log_parse_environment();
1282         log_open();
1283
1284         test_streq_ptr();
1285         test_align_power2();
1286         test_max();
1287         test_container_of();
1288         test_alloca();
1289         test_first_word();
1290         test_close_many();
1291         test_parse_boolean();
1292         test_parse_pid();
1293         test_parse_uid();
1294         test_safe_atolli();
1295         test_safe_atod();
1296         test_strappend();
1297         test_strstrip();
1298         test_delete_chars();
1299         test_in_charset();
1300         test_hexchar();
1301         test_unhexchar();
1302         test_octchar();
1303         test_unoctchar();
1304         test_decchar();
1305         test_undecchar();
1306         test_cescape();
1307         test_cunescape();
1308         test_foreach_word();
1309         test_foreach_word_quoted();
1310         test_default_term_for_tty();
1311         test_memdup_multiply();
1312         test_hostname_is_valid();
1313         test_u64log2();
1314         test_get_process_comm();
1315         test_protect_errno();
1316         test_parse_size();
1317         test_config_parse_iec_off();
1318         test_strextend();
1319         test_strrep();
1320         test_split_pair();
1321         test_fstab_node_to_udev_node();
1322         test_get_files_in_directory();
1323         test_in_set();
1324         test_writing_tmpfile();
1325         test_hexdump();
1326         test_log2i();
1327         test_foreach_string();
1328         test_filename_is_safe();
1329         test_string_has_cc();
1330         test_ascii_strlower();
1331         test_files_same();
1332         test_is_valid_documentation_url();
1333         test_file_in_same_dir();
1334         test_endswith();
1335         test_close_nointr();
1336         test_unlink_noerrno();
1337         test_readlink_and_make_absolute();
1338         test_read_one_char();
1339         test_ignore_signals();
1340         test_strshorten();
1341         test_strappenda();
1342         test_is_symlink();
1343         test_pid_is_unwaited();
1344         test_pid_is_alive();
1345         test_search_and_fopen();
1346         test_search_and_fopen_nulstr();
1347         test_glob_exists();
1348         test_execute_directory();
1349         test_unquote_first_word();
1350         test_unquote_many_words();
1351
1352         return 0;
1353 }