src/test/test-util.c

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