/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>

#include "fd-util.h"
#include "io-util.h"
#include "iovec-util.h"
#include "tests.h"
#include "tmpfile-util.h"

static void test_sparse_write_one(int fd, const char *buffer, size_t n) {
        char check[n];

        ASSERT_OK_EQ_ERRNO(lseek(fd, 0, SEEK_SET), 0);
        ASSERT_OK_ERRNO(ftruncate(fd, 0));
        ASSERT_OK_EQ(sparse_write(fd, buffer, n, 4), (ssize_t) n);

        ASSERT_OK_EQ_ERRNO(lseek(fd, 0, SEEK_CUR), (off_t) n);
        ASSERT_OK_ERRNO(ftruncate(fd, n));

        ASSERT_OK_EQ_ERRNO(lseek(fd, 0, SEEK_SET), 0);
        ASSERT_OK_EQ_ERRNO(read(fd, check, n), (ssize_t) n);

        ASSERT_EQ(memcmp(buffer, check, n), 0);
}

TEST(sparse_write) {
        const char test_a[] = "test";
        const char test_b[] = "\0\0\0\0test\0\0\0\0";
        const char test_c[] = "\0\0test\0\0\0\0";
        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";
        const char test_e[] = "test\0\0\0\0test";
        _cleanup_close_ int fd = -EBADF;
        char fn[] = "/tmp/sparseXXXXXX";

        ASSERT_OK_ERRNO(fd = mkostemp(fn, O_CLOEXEC));
        (void) unlink(fn);

        test_sparse_write_one(fd, test_a, sizeof(test_a));
        test_sparse_write_one(fd, test_b, sizeof(test_b));
        test_sparse_write_one(fd, test_c, sizeof(test_c));
        test_sparse_write_one(fd, test_d, sizeof(test_d));
        test_sparse_write_one(fd, test_e, sizeof(test_e));
}

TEST(pwritev_full) {
        _cleanup_close_ int fd = -EBADF;
        struct iovec iovec[2 + 2 * IOV_MAX];
        char expected[3 + 2 * IOV_MAX], buf[sizeof(expected)];
        uint64_t written;
        size_t n = 0;

        ASSERT_OK(fd = open_tmpfile_unlinkable(NULL, O_RDWR|O_CLOEXEC));

        /* Nothing, or only empty iovecs, writes nothing */
        ASSERT_OK(pwritev_full(fd, NULL, 0, 0, &written));
        ASSERT_EQ(written, 0U);
        iovec[0] = (struct iovec) {};
        ASSERT_OK(pwritev_full(fd, iovec, 1, 0, &written));
        ASSERT_EQ(written, 0U);

        /* More iovecs than one pwritev() takes, some of them empty */
        iovec[n++] = IOVEC_MAKE_STRING("abc");
        iovec[n++] = (struct iovec) {};
        memcpy(expected, "abc", 3);
        for (size_t k = 0; k < 2 * IOV_MAX; k++) {
                expected[3 + k] = 'a' + k % 26;
                iovec[n++] = IOVEC_MAKE(expected + 3 + k, 1);
        }

        ASSERT_OK(pwritev_full(fd, iovec, n, 7, &written));
        ASSERT_EQ(written, sizeof(expected));
        ASSERT_EQ(pread(fd, buf, sizeof(buf), 7), (ssize_t) sizeof(buf));
        ASSERT_EQ(memcmp(buf, expected, sizeof(expected)), 0);

        /* Written iovecs are advanced past the data */
        FOREACH_ARRAY(i, iovec, n)
                ASSERT_FALSE(iovec_is_set(i));
}

TEST(pwrite_full) {
        _cleanup_close_ int fd = -EBADF;
        char buf[3];

        ASSERT_OK(fd = open_tmpfile_unlinkable(NULL, O_RDWR|O_CLOEXEC));

        ASSERT_OK(pwrite_full(fd, NULL, 0, 0));
        ASSERT_OK(pwrite_full(fd, "abc", 3, 5));
        ASSERT_EQ(pread(fd, buf, sizeof(buf), 5), (ssize_t) sizeof(buf));
        ASSERT_EQ(memcmp(buf, "abc", 3), 0);
}

DEFINE_TEST_MAIN(LOG_INFO);
