src/test/test-fileio.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <fcntl.h>
   4 #include <stdio.h>
   5 #include <unistd.h>
   6
   7 #include "alloc-util.h"
   8 #include "ctype.h"
   9 #include "def.h"
  10 #include "env-util.h"
  11 #include "fd-util.h"
  12 #include "fileio.h"
  13 #include "fs-util.h"
  14 #include "io-util.h"
  15 #include "parse-util.h"
  16 #include "process-util.h"
  17 #include "string-util.h"
  18 #include "strv.h"
  19 #include "tests.h"
  20 #include "util.h"
  21
  22 static void test_parse_env_file(void) {
  23         _cleanup_(unlink_tempfilep) char
  24                 t[] = "/tmp/test-fileio-in-XXXXXX",
  25                 p[] = "/tmp/test-fileio-out-XXXXXX";
  26         FILE *f;
  27         _cleanup_free_ char *one = NULL, *two = NULL, *three = NULL, *four = NULL, *five = NULL,
  28                         *six = NULL, *seven = NULL, *eight = NULL, *nine = NULL, *ten = NULL;
  29         _cleanup_strv_free_ char **a = NULL, **b = NULL;
  30         char **i;
  31         unsigned k;
  32         int r;
  33
  34         assert_se(fmkostemp_safe(t, "w", &f) == 0);
  35         fputs("one=BAR   \n"
  36               "# comment\n"
  37               " # comment \n"
  38               " ; comment \n"
  39               "  two   =   bar    \n"
  40               "invalid line\n"
  41               "invalid line #comment\n"
  42               "three = \"333\n"
  43               "xxxx\"\n"
  44               "four = \'44\\\"44\'\n"
  45               "five = \'55\\\'55\' \"FIVE\" cinco   \n"
  46               "six = seis sechs\\\n"
  47               " sis\n"
  48               "seven=\"sevenval\" #nocomment\n"
  49               "eight=eightval #nocomment\n"
  50               "export nine=nineval\n"
  51               "ten=ignored\n"
  52               "ten=ignored\n"
  53               "ten=", f);
  54
  55         fflush(f);
  56         fclose(f);
  57
  58         r = load_env_file(NULL, t, &a);
  59         assert_se(r >= 0);
  60
  61         STRV_FOREACH(i, a)
  62                 log_info("Got: <%s>", *i);
  63
  64         assert_se(streq_ptr(a[0], "one=BAR"));
  65         assert_se(streq_ptr(a[1], "two=bar"));
  66         assert_se(streq_ptr(a[2], "three=333\nxxxx"));
  67         assert_se(streq_ptr(a[3], "four=44\"44"));
  68         assert_se(streq_ptr(a[4], "five=55\'55FIVEcinco"));
  69         assert_se(streq_ptr(a[5], "six=seis sechs sis"));
  70         assert_se(streq_ptr(a[6], "seven=sevenval#nocomment"));
  71         assert_se(streq_ptr(a[7], "eight=eightval #nocomment"));
  72         assert_se(streq_ptr(a[8], "export nine=nineval"));
  73         assert_se(streq_ptr(a[9], "ten="));
  74         assert_se(a[10] == NULL);
  75
  76         strv_env_clean(a);
  77
  78         k = 0;
  79         STRV_FOREACH(i, b) {
  80                 log_info("Got2: <%s>", *i);
  81                 assert_se(streq(*i, a[k++]));
  82         }
  83
  84         r = parse_env_file(
  85                         NULL, t,
  86                        "one", &one,
  87                        "two", &two,
  88                        "three", &three,
  89                        "four", &four,
  90                        "five", &five,
  91                        "six", &six,
  92                        "seven", &seven,
  93                        "eight", &eight,
  94                        "export nine", &nine,
  95                        "ten", &ten);
  96
  97         assert_se(r >= 0);
  98
  99         log_info("one=[%s]", strna(one));
 100         log_info("two=[%s]", strna(two));
 101         log_info("three=[%s]", strna(three));
 102         log_info("four=[%s]", strna(four));
 103         log_info("five=[%s]", strna(five));
 104         log_info("six=[%s]", strna(six));
 105         log_info("seven=[%s]", strna(seven));
 106         log_info("eight=[%s]", strna(eight));
 107         log_info("export nine=[%s]", strna(nine));
 108         log_info("ten=[%s]", strna(nine));
 109
 110         assert_se(streq(one, "BAR"));
 111         assert_se(streq(two, "bar"));
 112         assert_se(streq(three, "333\nxxxx"));
 113         assert_se(streq(four, "44\"44"));
 114         assert_se(streq(five, "55\'55FIVEcinco"));
 115         assert_se(streq(six, "seis sechs sis"));
 116         assert_se(streq(seven, "sevenval#nocomment"));
 117         assert_se(streq(eight, "eightval #nocomment"));
 118         assert_se(streq(nine, "nineval"));
 119         assert_se(ten == NULL);
 120
 121         {
 122                 /* prepare a temporary file to write the environment to */
 123                 _cleanup_close_ int fd = mkostemp_safe(p);
 124                 assert_se(fd >= 0);
 125         }
 126
 127         r = write_env_file(p, a);
 128         assert_se(r >= 0);
 129
 130         r = load_env_file(NULL, p, &b);
 131         assert_se(r >= 0);
 132 }
 133
 134 static void test_parse_multiline_env_file(void) {
 135         _cleanup_(unlink_tempfilep) char
 136                 t[] = "/tmp/test-fileio-in-XXXXXX",
 137                 p[] = "/tmp/test-fileio-out-XXXXXX";
 138         FILE *f;
 139         _cleanup_strv_free_ char **a = NULL, **b = NULL;
 140         char **i;
 141         int r;
 142
 143         assert_se(fmkostemp_safe(t, "w", &f) == 0);
 144         fputs("one=BAR\\\n"
 145               "    VAR\\\n"
 146               "\tGAR\n"
 147               "#comment\n"
 148               "two=\"bar\\\n"
 149               "    var\\\n"
 150               "\tgar\"\n"
 151               "#comment\n"
 152               "tri=\"bar \\\n"
 153               "    var \\\n"
 154               "\tgar \"\n", f);
 155
 156         fflush(f);
 157         fclose(f);
 158
 159         r = load_env_file(NULL, t, &a);
 160         assert_se(r >= 0);
 161
 162         STRV_FOREACH(i, a)
 163                 log_info("Got: <%s>", *i);
 164
 165         assert_se(streq_ptr(a[0], "one=BAR    VAR\tGAR"));
 166         assert_se(streq_ptr(a[1], "two=bar    var\tgar"));
 167         assert_se(streq_ptr(a[2], "tri=bar     var \tgar "));
 168         assert_se(a[3] == NULL);
 169
 170         {
 171                 _cleanup_close_ int fd = mkostemp_safe(p);
 172                 assert_se(fd >= 0);
 173         }
 174
 175         r = write_env_file(p, a);
 176         assert_se(r >= 0);
 177
 178         r = load_env_file(NULL, p, &b);
 179         assert_se(r >= 0);
 180 }
 181
 182 static void test_merge_env_file(void) {
 183         _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
 184         _cleanup_fclose_ FILE *f = NULL;
 185         _cleanup_strv_free_ char **a = NULL;
 186         char **i;
 187         int r;
 188
 189         assert_se(fmkostemp_safe(t, "w", &f) == 0);
 190         log_info("/* %s (%s) */", __func__, t);
 191
 192         r = write_string_stream(f,
 193                                 "one=1   \n"
 194                                 "twelve=${one}2\n"
 195                                 "twentyone=2${one}\n"
 196                                 "one=2\n"
 197                                 "twentytwo=2${one}\n"
 198                                 "xxx_minus_three=$xxx - 3\n"
 199                                 "xxx=0x$one$one$one\n"
 200                                 "yyy=${one:-fallback}\n"
 201                                 "zzz=${one:+replacement}\n"
 202                                 "zzzz=${foobar:-${nothing}}\n"
 203                                 "zzzzz=${nothing:+${nothing}}\n"
 204                                 , WRITE_STRING_FILE_AVOID_NEWLINE);
 205         assert(r >= 0);
 206
 207         r = merge_env_file(&a, NULL, t);
 208         assert_se(r >= 0);
 209         strv_sort(a);
 210
 211         STRV_FOREACH(i, a)
 212                 log_info("Got: <%s>", *i);
 213
 214         assert_se(streq(a[0], "one=2"));
 215         assert_se(streq(a[1], "twelve=12"));
 216         assert_se(streq(a[2], "twentyone=21"));
 217         assert_se(streq(a[3], "twentytwo=22"));
 218         assert_se(streq(a[4], "xxx=0x222"));
 219         assert_se(streq(a[5], "xxx_minus_three= - 3"));
 220         assert_se(streq(a[6], "yyy=2"));
 221         assert_se(streq(a[7], "zzz=replacement"));
 222         assert_se(streq(a[8], "zzzz="));
 223         assert_se(streq(a[9], "zzzzz="));
 224         assert_se(a[10] == NULL);
 225
 226         r = merge_env_file(&a, NULL, t);
 227         assert_se(r >= 0);
 228         strv_sort(a);
 229
 230         STRV_FOREACH(i, a)
 231                 log_info("Got2: <%s>", *i);
 232
 233         assert_se(streq(a[0], "one=2"));
 234         assert_se(streq(a[1], "twelve=12"));
 235         assert_se(streq(a[2], "twentyone=21"));
 236         assert_se(streq(a[3], "twentytwo=22"));
 237         assert_se(streq(a[4], "xxx=0x222"));
 238         assert_se(streq(a[5], "xxx_minus_three=0x222 - 3"));
 239         assert_se(streq(a[6], "yyy=2"));
 240         assert_se(streq(a[7], "zzz=replacement"));
 241         assert_se(streq(a[8], "zzzz="));
 242         assert_se(streq(a[9], "zzzzz="));
 243         assert_se(a[10] == NULL);
 244 }
 245
 246 static void test_merge_env_file_invalid(void) {
 247         _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
 248         _cleanup_fclose_ FILE *f = NULL;
 249         _cleanup_strv_free_ char **a = NULL;
 250         char **i;
 251         int r;
 252
 253         assert_se(fmkostemp_safe(t, "w", &f) == 0);
 254         log_info("/* %s (%s) */", __func__, t);
 255
 256         r = write_string_stream(f,
 257                                 "unset one   \n"
 258                                 "unset one=   \n"
 259                                 "unset one=1   \n"
 260                                 "one   \n"
 261                                 "one =  \n"
 262                                 "one two =\n"
 263                                 "\x20two=\n"
 264                                 "#comment=comment\n"
 265                                 ";comment2=comment2\n"
 266                                 "#\n"
 267                                 "\n\n"                  /* empty line */
 268                                 , WRITE_STRING_FILE_AVOID_NEWLINE);
 269         assert(r >= 0);
 270
 271         r = merge_env_file(&a, NULL, t);
 272         assert_se(r >= 0);
 273
 274         STRV_FOREACH(i, a)
 275                 log_info("Got: <%s>", *i);
 276
 277         assert_se(strv_isempty(a));
 278 }
 279
 280 static void test_executable_is_script(void) {
 281         _cleanup_(unlink_tempfilep) char t[] = "/tmp/test-fileio-XXXXXX";
 282         _cleanup_fclose_ FILE *f = NULL;
 283         char *command;
 284         int r;
 285
 286         assert_se(fmkostemp_safe(t, "w", &f) == 0);
 287         fputs("#! /bin/script -a -b \ngoo goo", f);
 288         fflush(f);
 289
 290         r = executable_is_script(t, &command);
 291         assert_se(r > 0);
 292         assert_se(streq(command, "/bin/script"));
 293         free(command);
 294
 295         r = executable_is_script("/bin/sh", &command);
 296         assert_se(r == 0);
 297
 298         r = executable_is_script("/usr/bin/yum", &command);
 299         assert_se(r > 0 || r == -ENOENT);
 300         if (r > 0) {
 301                 assert_se(startswith(command, "/"));
 302                 free(command);
 303         }
 304 }
 305
 306 static void test_status_field(void) {
 307         _cleanup_free_ char *t = NULL, *p = NULL, *s = NULL, *z = NULL;
 308         unsigned long long total = 0, buffers = 0;
 309         int r;
 310
 311         assert_se(get_proc_field("/proc/self/status", "Threads", WHITESPACE, &t) == 0);
 312         puts(t);
 313         assert_se(streq(t, "1"));
 314
 315         r = get_proc_field("/proc/meminfo", "MemTotal", WHITESPACE, &p);
 316         if (r != -ENOENT) {
 317                 assert_se(r == 0);
 318                 puts(p);
 319                 assert_se(safe_atollu(p, &total) == 0);
 320         }
 321
 322         r = get_proc_field("/proc/meminfo", "Buffers", WHITESPACE, &s);
 323         if (r != -ENOENT) {
 324                 assert_se(r == 0);
 325                 puts(s);
 326                 assert_se(safe_atollu(s, &buffers) == 0);
 327         }
 328
 329         if (p)
 330                 assert_se(buffers < total);
 331
 332         /* Seccomp should be a good test for field full of zeros. */
 333         r = get_proc_field("/proc/meminfo", "Seccomp", WHITESPACE, &z);
 334         if (r != -ENOENT) {
 335                 assert_se(r == 0);
 336                 puts(z);
 337                 assert_se(safe_atollu(z, &buffers) == 0);
 338         }
 339 }
 340
 341 static void test_capeff(void) {
 342         int pid, p;
 343
 344         for (pid = 0; pid < 2; pid++) {
 345                 _cleanup_free_ char *capeff = NULL;
 346                 int r;
 347
 348                 r = get_process_capeff(0, &capeff);
 349                 log_info("capeff: '%s' (r=%d)", capeff, r);
 350
 351                 if (IN_SET(r, -ENOENT, -EPERM))
 352                         return;
 353
 354                 assert_se(r == 0);
 355                 assert_se(*capeff);
 356                 p = capeff[strspn(capeff, HEXDIGITS)];
 357                 assert_se(!p || isspace(p));
 358         }
 359 }
 360
 361 static void test_write_string_stream(void) {
 362         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_stream-XXXXXX";
 363         _cleanup_fclose_ FILE *f = NULL;
 364         int fd;
 365         char buf[64];
 366
 367         fd = mkostemp_safe(fn);
 368         assert_se(fd >= 0);
 369
 370         f = fdopen(fd, "r");
 371         assert_se(f);
 372         assert_se(write_string_stream(f, "boohoo", 0) < 0);
 373         f = safe_fclose(f);
 374
 375         f = fopen(fn, "r+");
 376         assert_se(f);
 377
 378         assert_se(write_string_stream(f, "boohoo", 0) == 0);
 379         rewind(f);
 380
 381         assert_se(fgets(buf, sizeof(buf), f));
 382         assert_se(streq(buf, "boohoo\n"));
 383         f = safe_fclose(f);
 384
 385         f = fopen(fn, "w+");
 386         assert_se(f);
 387
 388         assert_se(write_string_stream(f, "boohoo", WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
 389         rewind(f);
 390
 391         assert_se(fgets(buf, sizeof(buf), f));
 392         printf(">%s<", buf);
 393         assert_se(streq(buf, "boohoo"));
 394 }
 395
 396 static void test_write_string_file(void) {
 397         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file-XXXXXX";
 398         char buf[64] = {};
 399         _cleanup_close_ int fd;
 400
 401         fd = mkostemp_safe(fn);
 402         assert_se(fd >= 0);
 403
 404         assert_se(write_string_file(fn, "boohoo", WRITE_STRING_FILE_CREATE) == 0);
 405
 406         assert_se(read(fd, buf, sizeof(buf)) == 7);
 407         assert_se(streq(buf, "boohoo\n"));
 408 }
 409
 410 static void test_write_string_file_no_create(void) {
 411         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-write_string_file_no_create-XXXXXX";
 412         _cleanup_close_ int fd;
 413         char buf[64] = {0};
 414
 415         fd = mkostemp_safe(fn);
 416         assert_se(fd >= 0);
 417
 418         assert_se(write_string_file("/a/file/which/does/not/exists/i/guess", "boohoo", 0) < 0);
 419         assert_se(write_string_file(fn, "boohoo", 0) == 0);
 420
 421         assert_se(read(fd, buf, sizeof(buf)) == STRLEN("boohoo\n"));
 422         assert_se(streq(buf, "boohoo\n"));
 423 }
 424
 425 static void test_write_string_file_verify(void) {
 426         _cleanup_free_ char *buf = NULL, *buf2 = NULL;
 427         int r;
 428
 429         assert_se(read_one_line_file("/proc/cmdline", &buf) >= 0);
 430         assert_se(buf2 = strjoin(buf, "\n"));
 431
 432         r = write_string_file("/proc/cmdline", buf, 0);
 433         assert_se(IN_SET(r, -EACCES, -EIO));
 434         r = write_string_file("/proc/cmdline", buf2, 0);
 435         assert_se(IN_SET(r, -EACCES, -EIO));
 436
 437         assert_se(write_string_file("/proc/cmdline", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
 438         assert_se(write_string_file("/proc/cmdline", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE) == 0);
 439
 440         r = write_string_file("/proc/cmdline", buf, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE);
 441         assert_se(IN_SET(r, -EACCES, -EIO));
 442         assert_se(write_string_file("/proc/cmdline", buf2, WRITE_STRING_FILE_VERIFY_ON_FAILURE|WRITE_STRING_FILE_AVOID_NEWLINE) == 0);
 443 }
 444
 445 static void test_load_env_file_pairs(void) {
 446         _cleanup_(unlink_tempfilep) char fn[] = "/tmp/test-load_env_file_pairs-XXXXXX";
 447         int fd, r;
 448         _cleanup_fclose_ FILE *f = NULL;
 449         _cleanup_strv_free_ char **l = NULL;
 450         char **k, **v;
 451
 452         fd = mkostemp_safe(fn);
 453         assert_se(fd >= 0);
 454
 455         r = write_string_file(fn,
 456                         "NAME=\"Arch Linux\"\n"
 457                         "ID=arch\n"
 458                         "PRETTY_NAME=\"Arch Linux\"\n"
 459                         "ANSI_COLOR=\"0;36\"\n"
 460                         "HOME_URL=\"https://www.archlinux.org/\"\n"
 461                         "SUPPORT_URL=\"https://bbs.archlinux.org/\"\n"
 462                         "BUG_REPORT_URL=\"https://bugs.archlinux.org/\"\n",
 463                         WRITE_STRING_FILE_CREATE);
 464         assert_se(r == 0);
 465
 466         f = fdopen(fd, "r");
 467         assert_se(f);
 468
 469         r = load_env_file_pairs(f, fn, &l);
 470         assert_se(r >= 0);
 471
 472         assert_se(strv_length(l) == 14);
 473         STRV_FOREACH_PAIR(k, v, l) {
 474                 assert_se(STR_IN_SET(*k, "NAME", "ID", "PRETTY_NAME", "ANSI_COLOR", "HOME_URL", "SUPPORT_URL", "BUG_REPORT_URL"));
 475                 printf("%s=%s\n", *k, *v);
 476                 if (streq(*k, "NAME")) assert_se(streq(*v, "Arch Linux"));
 477                 if (streq(*k, "ID")) assert_se(streq(*v, "arch"));
 478                 if (streq(*k, "PRETTY_NAME")) assert_se(streq(*v, "Arch Linux"));
 479                 if (streq(*k, "ANSI_COLOR")) assert_se(streq(*v, "0;36"));
 480                 if (streq(*k, "HOME_URL")) assert_se(streq(*v, "https://www.archlinux.org/"));
 481                 if (streq(*k, "SUPPORT_URL")) assert_se(streq(*v, "https://bbs.archlinux.org/"));
 482                 if (streq(*k, "BUG_REPORT_URL")) assert_se(streq(*v, "https://bugs.archlinux.org/"));
 483         }
 484 }
 485
 486 static void test_search_and_fopen(void) {
 487         const char *dirs[] = {"/tmp/foo/bar", "/tmp", NULL};
 488
 489         char name[] = "/tmp/test-search_and_fopen.XXXXXX";
 490         int fd, r;
 491         FILE *f;
 492
 493         fd = mkostemp_safe(name);
 494         assert_se(fd >= 0);
 495         close(fd);
 496
 497         r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
 498         assert_se(r >= 0);
 499         fclose(f);
 500
 501         r = search_and_fopen(name, "r", NULL, dirs, &f);
 502         assert_se(r >= 0);
 503         fclose(f);
 504
 505         r = search_and_fopen(basename(name), "r", "/", dirs, &f);
 506         assert_se(r >= 0);
 507         fclose(f);
 508
 509         r = search_and_fopen("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
 510         assert_se(r < 0);
 511         r = search_and_fopen("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
 512         assert_se(r < 0);
 513
 514         r = unlink(name);
 515         assert_se(r == 0);
 516
 517         r = search_and_fopen(basename(name), "r", NULL, dirs, &f);
 518         assert_se(r < 0);
 519 }
 520
 521 static void test_search_and_fopen_nulstr(void) {
 522         const char dirs[] = "/tmp/foo/bar\0/tmp\0";
 523
 524         _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-search_and_fopen.XXXXXX";
 525         int fd, r;
 526         FILE *f;
 527
 528         fd = mkostemp_safe(name);
 529         assert_se(fd >= 0);
 530         close(fd);
 531
 532         r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
 533         assert_se(r >= 0);
 534         fclose(f);
 535
 536         r = search_and_fopen_nulstr(name, "r", NULL, dirs, &f);
 537         assert_se(r >= 0);
 538         fclose(f);
 539
 540         r = search_and_fopen_nulstr("/a/file/which/does/not/exist/i/guess", "r", NULL, dirs, &f);
 541         assert_se(r < 0);
 542         r = search_and_fopen_nulstr("afilewhichdoesnotexistiguess", "r", NULL, dirs, &f);
 543         assert_se(r < 0);
 544
 545         r = unlink(name);
 546         assert_se(r == 0);
 547
 548         r = search_and_fopen_nulstr(basename(name), "r", NULL, dirs, &f);
 549         assert_se(r < 0);
 550 }
 551
 552 static void test_writing_tmpfile(void) {
 553         _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-systemd_writing_tmpfile.XXXXXX";
 554         _cleanup_free_ char *contents = NULL;
 555         size_t size;
 556         _cleanup_close_ int fd = -1;
 557         struct iovec iov[3];
 558         int r;
 559
 560         iov[0] = IOVEC_MAKE_STRING("abc\n");
 561         iov[1] = IOVEC_MAKE_STRING(ALPHANUMERICAL "\n");
 562         iov[2] = IOVEC_MAKE_STRING("");
 563
 564         fd = mkostemp_safe(name);
 565         printf("tmpfile: %s", name);
 566
 567         r = writev(fd, iov, 3);
 568         assert_se(r >= 0);
 569
 570         r = read_full_file(name, &contents, &size);
 571         assert_se(r == 0);
 572         printf("contents: %s", contents);
 573         assert_se(streq(contents, "abc\n" ALPHANUMERICAL "\n"));
 574 }
 575
 576 static void test_tempfn(void) {
 577         char *ret = NULL, *p;
 578
 579         assert_se(tempfn_xxxxxx("/foo/bar/waldo", NULL, &ret) >= 0);
 580         assert_se(streq_ptr(ret, "/foo/bar/.#waldoXXXXXX"));
 581         free(ret);
 582
 583         assert_se(tempfn_xxxxxx("/foo/bar/waldo", "[miau]", &ret) >= 0);
 584         assert_se(streq_ptr(ret, "/foo/bar/.#[miau]waldoXXXXXX"));
 585         free(ret);
 586
 587         assert_se(tempfn_random("/foo/bar/waldo", NULL, &ret) >= 0);
 588         assert_se(p = startswith(ret, "/foo/bar/.#waldo"));
 589         assert_se(strlen(p) == 16);
 590         assert_se(in_charset(p, "0123456789abcdef"));
 591         free(ret);
 592
 593         assert_se(tempfn_random("/foo/bar/waldo", "[wuff]", &ret) >= 0);
 594         assert_se(p = startswith(ret, "/foo/bar/.#[wuff]waldo"));
 595         assert_se(strlen(p) == 16);
 596         assert_se(in_charset(p, "0123456789abcdef"));
 597         free(ret);
 598
 599         assert_se(tempfn_random_child("/foo/bar/waldo", NULL, &ret) >= 0);
 600         assert_se(p = startswith(ret, "/foo/bar/waldo/.#"));
 601         assert_se(strlen(p) == 16);
 602         assert_se(in_charset(p, "0123456789abcdef"));
 603         free(ret);
 604
 605         assert_se(tempfn_random_child("/foo/bar/waldo", "[kikiriki]", &ret) >= 0);
 606         assert_se(p = startswith(ret, "/foo/bar/waldo/.#[kikiriki]"));
 607         assert_se(strlen(p) == 16);
 608         assert_se(in_charset(p, "0123456789abcdef"));
 609         free(ret);
 610 }
 611
 612 static const char buffer[] =
 613         "Some test data\n"
 614         "With newlines, and a NUL byte\0"
 615         "\n"
 616         "an empty line\n"
 617         "an ignored line\n"
 618         "and a very long line that is supposed to be truncated, because it is so long\n";
 619
 620 static void test_read_line_one_file(FILE *f) {
 621         _cleanup_free_ char *line = NULL;
 622
 623         assert_se(read_line(f, (size_t) -1, &line) == 15 && streq(line, "Some test data"));
 624         line = mfree(line);
 625
 626         assert_se(read_line(f, 1024, &line) == 30 && streq(line, "With newlines, and a NUL byte"));
 627         line = mfree(line);
 628
 629         assert_se(read_line(f, 1024, &line) == 1 && streq(line, ""));
 630         line = mfree(line);
 631
 632         assert_se(read_line(f, 1024, &line) == 14 && streq(line, "an empty line"));
 633         line = mfree(line);
 634
 635         assert_se(read_line(f, (size_t) -1, NULL) == 16);
 636
 637         assert_se(read_line(f, 16, &line) == -ENOBUFS);
 638         line = mfree(line);
 639
 640         /* read_line() stopped when it hit the limit, that means when we continue reading we'll read at the first
 641          * character after the previous limit. Let's make use of tha to continue our test. */
 642         assert_se(read_line(f, 1024, &line) == 61 && streq(line, "line that is supposed to be truncated, because it is so long"));
 643         line = mfree(line);
 644
 645         assert_se(read_line(f, 1024, &line) == 1 && streq(line, ""));
 646         line = mfree(line);
 647
 648         assert_se(read_line(f, 1024, &line) == 0 && streq(line, ""));
 649 }
 650
 651 static void test_read_line(void) {
 652         _cleanup_fclose_ FILE *f = NULL;
 653
 654         f = fmemopen((void*) buffer, sizeof(buffer), "re");
 655         assert_se(f);
 656
 657         test_read_line_one_file(f);
 658 }
 659
 660 static void test_read_line2(void) {
 661         _cleanup_(unlink_tempfilep) char name[] = "/tmp/test-fileio.XXXXXX";
 662         int fd;
 663         _cleanup_fclose_ FILE *f = NULL;
 664
 665         fd = mkostemp_safe(name);
 666         assert_se(fd >= 0);
 667         assert_se((size_t) write(fd, buffer, sizeof(buffer)) == sizeof(buffer));
 668
 669         assert_se(lseek(fd, 0, SEEK_SET) == 0);
 670         assert_se(f = fdopen(fd, "r"));
 671
 672         test_read_line_one_file(f);
 673 }
 674
 675 static void test_read_line3(void) {
 676         _cleanup_fclose_ FILE *f = NULL;
 677         _cleanup_free_ char *line = NULL;
 678         int r;
 679
 680         f = fopen("/proc/cmdline", "re");
 681         if (!f && IN_SET(errno, ENOENT, EPERM))
 682                 return;
 683         assert_se(f);
 684
 685         r = read_line(f, LINE_MAX, &line);
 686         assert_se((size_t) r == strlen(line) + 1);
 687         assert_se(read_line(f, LINE_MAX, NULL) == 0);
 688 }
 689
 690 int main(int argc, char *argv[]) {
 691         test_setup_logging(LOG_DEBUG);
 692
 693         test_parse_env_file();
 694         test_parse_multiline_env_file();
 695         test_merge_env_file();
 696         test_merge_env_file_invalid();
 697         test_executable_is_script();
 698         test_status_field();
 699         test_capeff();
 700         test_write_string_stream();
 701         test_write_string_file();
 702         test_write_string_file_no_create();
 703         test_write_string_file_verify();
 704         test_load_env_file_pairs();
 705         test_search_and_fopen();
 706         test_search_and_fopen_nulstr();
 707         test_writing_tmpfile();
 708         test_tempfn();
 709         test_read_line();
 710         test_read_line2();
 711         test_read_line3();
 712
 713         return 0;
 714 }