src/test/test-util.c

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