// Copyright 2016 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// While not much will work if launchpad isn't already working, this test
// provides a place for testing aspects of launchpad that aren't necessarily
// normally used.

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

#include <elfload/elfload.h>

#include <launchpad/launchpad.h>
#include <launchpad/vmo.h>

#include <zircon/process.h>
#include <zircon/processargs.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/object.h>

#include <lib/fdio/util.h>

#include <unittest/unittest.h>

#include "util.h"

static bool stdio_pipe_test(void)
{
    BEGIN_TEST;

    int fds[2];
    ASSERT_EQ(pipe(fds), 0, "pipe creation failed");

    ASSERT_GT(write(fds[1], "hello", 5), 0, "pipe write failed");

    char buffer[5];
    ASSERT_GT(read(fds[0], buffer, 5), 0, "pipe read failed");

    ASSERT_EQ(strncmp(buffer, "hello", 5), 0, "Incorrect buffer read from pipe");

    ASSERT_EQ(lseek(fds[0], 0, SEEK_SET), -1, "lseek should have failed");
    ASSERT_EQ(errno, ESPIPE, "lseek error should have been pipe-related");

    ASSERT_EQ(close(fds[0]), 0, "");
    ASSERT_EQ(close(fds[1]), 0, "");

    END_TEST;
}


static bool stdio_launchpad_pipe_test(void)
{
    BEGIN_TEST;

    // TODO(kulakowski): Consider another helper process
    const char* file = "/boot/bin/lsusb";
    launchpad_t* lp = NULL;

    zx_handle_t fdio_job = zx_job_default();
    ASSERT_NE(fdio_job, ZX_HANDLE_INVALID, "no fdio job object");

    zx_handle_t job_copy = ZX_HANDLE_INVALID;
    ASSERT_EQ(zx_handle_duplicate(fdio_job, ZX_RIGHT_SAME_RIGHTS, &job_copy),
              ZX_OK, "zx_handle_duplicate failed");

    ASSERT_EQ(launchpad_create(job_copy,
                               "launchpad_pipe_stdio_test", &lp),
              ZX_OK, "launchpad_create failed");
    ASSERT_EQ(launchpad_set_args(lp, 1, &file),
              ZX_OK, "launchpad_arguments failed");
    ASSERT_EQ(launchpad_add_vdso_vmo(lp), ZX_OK,
              "launchpad_add_vdso_vmo failed");
    ASSERT_EQ(launchpad_clone(lp, LP_CLONE_FDIO_NAMESPACE),
              ZX_OK, "launchpad_clone failed");

    zx_handle_t vmo;
    ASSERT_EQ(launchpad_vmo_from_file(file, &vmo), ZX_OK, "");
    ASSERT_EQ(launchpad_elf_load(lp, vmo),
              ZX_OK, "launchpad_elf_load failed");

    ASSERT_EQ(launchpad_load_vdso(lp, ZX_HANDLE_INVALID),
              ZX_OK, "launchpad_load_vdso failed");

    // stdio pipe fds [ours, theirs]
    int stdin_fds[2];
    int stdout_fds[2];
    int stderr_fds[2];

    ASSERT_EQ(stdio_pipe(stdin_fds, true), 0, "stdin pipe creation failed");
    ASSERT_EQ(stdio_pipe(stdout_fds, false), 0, "stdout pipe creation failed");
    ASSERT_EQ(stdio_pipe(stderr_fds, false), 0, "stderr pipe creation failed");

    // Transfer the child's stdio pipes
    ASSERT_EQ(launchpad_transfer_fd(lp, stdin_fds[1], 0), ZX_OK,
              "failed to transfer stdin pipe to child process");
    ASSERT_EQ(launchpad_transfer_fd(lp, stdout_fds[1], 1), ZX_OK,
              "failed to transfer stdout pipe to child process");
    ASSERT_EQ(launchpad_transfer_fd(lp, stderr_fds[1], 2), ZX_OK,
              "failed to transfer stderr pipe to child process");

    // Start the process
    zx_handle_t p = ZX_HANDLE_INVALID;
    zx_status_t status = launchpad_go(lp, &p, NULL);
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_NE(p, ZX_HANDLE_INVALID, "process handle != 0");

    // Read the stdio
    uint8_t* out = NULL;
    size_t out_size = 0;
    uint8_t* err = NULL;
    size_t err_size = 0;

    ASSERT_GE(read_to_end(stdout_fds[0], &out, &out_size), 0, "reading stdout failed");
    ASSERT_GE(read_to_end(stderr_fds[0], &err, &err_size), 0, "reading stderr failed");

    ASSERT_EQ(strncmp((char*)out, "ID   ", 5), 0, "Got wrong stdout");
    ASSERT_EQ(err_size, (size_t)0, "Got wrong stderr");

    free(out);
    free(err);

    close(stdin_fds[0]);
    close(stdout_fds[0]);
    close(stderr_fds[0]);

    // Wait for the process to finish
    zx_status_t r;

    r = zx_object_wait_one(p, ZX_PROCESS_TERMINATED,
                           ZX_TIME_INFINITE, NULL);
    ASSERT_EQ(r, ZX_OK, "zx_object_wait_one failed");

    // read the return code
    zx_info_process_t proc_info;
    size_t actual = 0;
    zx_object_get_info(p, ZX_INFO_PROCESS, &proc_info,
                       sizeof(proc_info), &actual, NULL);
    ASSERT_EQ(actual, (size_t)1, "Must get one and only one process info");
    ASSERT_EQ(proc_info.return_code, 0, "lsusb must return 0");

    zx_handle_close(p);

    END_TEST;
}

BEGIN_TEST_CASE(launchpad_tests)
RUN_TEST(stdio_pipe_test);
RUN_TEST(stdio_launchpad_pipe_test);
END_TEST_CASE(launchpad_tests)

int main(int argc, char **argv)
{
    bool success = unittest_run_all_tests(argc, argv);

    return success ? 0 : -1;
}