src/test/test-util.c

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