// Copyright 2018 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.

#include <unittest/unittest.h>

#include <fcntl.h>
#include <lib/fdio/io.h>
#include <lib/fdio/spawn.h>
#include <lib/fdio/fd.h>
#include <lib/fdio/fdio.h>
#include <lib/fdio/directory.h>
#include <lib/zx/channel.h>
#include <lib/zx/job.h>
#include <lib/zx/process.h>
#include <lib/zx/socket.h>
#include <stdlib.h>
#include <unistd.h>
#include <zircon/limits.h>
#include <zircon/processargs.h>
#include <zircon/syscalls/policy.h>

#include <string>

static constexpr char kSpawnChild[] = "bin/spawn-child";
static constexpr char kSpawnLauncher[] = "bin/spawn-launcher";

static bool has_fd(int fd) {
    zx_handle_t handle = ZX_HANDLE_INVALID;
    zx_status_t status = fdio_fd_clone(fd, &handle);
    if (status == ZX_OK) {
        zx_handle_close(handle);
        return true;
    }
    return false;
}

static int64_t join(const zx::process& process) {
    zx_status_t status = process.wait_one(ZX_TASK_TERMINATED, zx::time::infinite(), nullptr);
    ASSERT_EQ(ZX_OK, status);
    zx_info_process_t proc_info{};
    status = process.get_info(ZX_INFO_PROCESS, &proc_info, sizeof(proc_info), nullptr, nullptr);
    ASSERT_EQ(ZX_OK, status);
    return proc_info.return_code;
}

std::string new_path(const char* file) {
    const char* root_dir = getenv("TEST_ROOT_DIR");
    if (root_dir == nullptr) {
        root_dir = "";
    }
    return std::string(root_dir) + "/" + file;
}

static bool spawn_control_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);

    {
        const char* argv[] = {path.c_str(), nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(43, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--argc", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(2, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--argc", "three", "four", "five", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(5, join(process));
    }

    END_TEST;
}

static bool spawn_launcher_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string launcher_path = new_path(kSpawnLauncher);
    const std::string child_path = new_path(kSpawnChild);
    const char* argv[] = {launcher_path.c_str(), child_path.c_str(), nullptr};

    // Check that we can spawn the lancher process in a job and that the
    // launcher process can launch the child.
    {
        zx::job job;
        ASSERT_EQ(ZX_OK, zx::job::create(*zx::job::default_job(), 0, &job));

        status = fdio_spawn(job.get(), FDIO_SPAWN_CLONE_ALL, launcher_path.c_str(),
                            argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(43, join(process));
        ASSERT_EQ(ZX_OK, job.kill());
    }

    // Check that setting |ZX_POL_NEW_PROCESS| to |ZX_POL_ACTION_DENY| prevents
    // the launcher from launching the child.
    {
        zx::job job;
        ASSERT_EQ(ZX_OK, zx::job::create(*zx::job::default_job(), 0, &job));
        zx_policy_basic_t policy = {
            .condition = ZX_POL_NEW_PROCESS,
            .policy = ZX_POL_ACTION_DENY,
        };
        ASSERT_EQ(ZX_OK, job.set_policy(ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1));

        status = fdio_spawn(job.get(), FDIO_SPAWN_CLONE_ALL, launcher_path.c_str(),
                            argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(401, join(process));
        ASSERT_EQ(ZX_OK, job.kill());
    }

    END_TEST;
}

static bool spawn_invalid_args_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);
    const char* argv[] = {path.c_str(), nullptr};

    status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                        "/bogus/not/a/file", argv, process.reset_and_get_address());
    ASSERT_EQ(ZX_ERR_NOT_FOUND, status);

    status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                        path.c_str(), NULL, process.reset_and_get_address());
    ASSERT_EQ(ZX_ERR_INVALID_ARGS, status);

    status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                        path.c_str(), argv + 1, process.reset_and_get_address());
    ASSERT_EQ(ZX_ERR_INVALID_ARGS, status);

    END_TEST;
}

static bool spawn_flags_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);

    {
        // We can't actually launch a process without FDIO_SPAWN_DEFAULT_LDSVC
        // because we can't load the PT_INTERP.
        const char* argv[] = {path.c_str(), "--flags", "none", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, 0, path.c_str(), argv,
                            process.reset_and_get_address());
        ASSERT_EQ(ZX_ERR_INVALID_ARGS, status);
        EXPECT_FALSE(process.is_valid());
    }

    {
        const char* argv[] = {path.c_str(), "--flags", "none", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_DEFAULT_LDSVC,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(51, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--flags", "job", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_JOB | FDIO_SPAWN_DEFAULT_LDSVC,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(52, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--flags", "namespace", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_DEFAULT_LDSVC | FDIO_SPAWN_CLONE_NAMESPACE,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(53, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--flags", "stdio", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_DEFAULT_LDSVC | FDIO_SPAWN_CLONE_STDIO,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(54, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--flags", "environ", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_DEFAULT_LDSVC | FDIO_SPAWN_CLONE_ENVIRON,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(55, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--flags", "all", nullptr};
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(56, join(process));
    }

    END_TEST;
}

static bool spawn_environ_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);

    setenv("SPAWN_TEST_PARENT", "1", 1);

    {
        const char* argv[] = {path.c_str(), "--env", "empty", nullptr};
        const char* env[] = {nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_DEFAULT_LDSVC,
                                path.c_str(), argv, env, 0, nullptr,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(61, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--env", "one", nullptr};
        const char* env[] = {"SPAWN_TEST_CHILD=1", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_DEFAULT_LDSVC,
                                path.c_str(), argv, env, 0, nullptr,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(62, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--env", "one", nullptr};
        const char* env[] = {"SPAWN_TEST_CHILD=1", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, env, 0, nullptr,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(62, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--env", "two", nullptr};
        const char* env[] = {"SPAWN_TEST_CHILD=1", "SPAWN_TEST_CHILD2=1", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, env, 0, nullptr,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(63, join(process));
    }

    {
        const char* argv[] = {path.c_str(), "--env", "clone", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 0, nullptr,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(64, join(process));
    }

    unsetenv("SPAWN_TEST_PARENT");

    END_TEST;
}

static bool spawn_actions_fd_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);

    {
        const char* argv[] = {nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 0, nullptr,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_ERR_INVALID_ARGS, status);
    }

    {
        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_SET_NAME;
        action.name.data = "spawn-child-name";

        const char* argv[] = {nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 1, &action,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(42, join(process));

        char name[ZX_MAX_NAME_LEN];
        ASSERT_EQ(ZX_OK, process.get_property(ZX_PROP_NAME, name, sizeof(name)));
        EXPECT_TRUE(!strcmp("spawn-child-name", name));
    }

    {
        zx_handle_t socket = ZX_HANDLE_INVALID;
        int fd;
        status = fdio_pipe_half(&fd, &socket);
        ASSERT_GE(status, ZX_OK);

        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_CLONE_FD;
        action.fd.local_fd = fd;
        action.fd.target_fd = 21;

        const char* argv[] = {path.c_str(), "--action", "clone-fd", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 1, &action,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(71, join(process));
        EXPECT_TRUE(has_fd(fd));
        close(fd);
        zx_handle_close(socket);
    }

    {
        zx::socket socket;
        int fd;
        status = fdio_pipe_half(&fd, socket.reset_and_get_address());
        ASSERT_GE(status, ZX_OK);

        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_TRANSFER_FD;
        action.fd.local_fd = fd;
        action.fd.target_fd = 21;

        const char* argv[] = {path.c_str(), "--action", "transfer-fd", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 1, &action,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(72, join(process));
        EXPECT_FALSE(has_fd(fd));
    }

    {
        zx::socket socket;
        int fd;
        status = fdio_pipe_half(&fd, socket.reset_and_get_address());
        ASSERT_GE(status, ZX_OK);

        fdio_spawn_action_t actions[2];
        actions[0].action = FDIO_SPAWN_ACTION_CLONE_FD;
        actions[0].fd.local_fd = fd;
        actions[0].fd.target_fd = 21;
        actions[1].action = FDIO_SPAWN_ACTION_TRANSFER_FD;
        actions[1].fd.local_fd = fd;
        actions[1].fd.target_fd = 22;

        const char* argv[] = {path.c_str(), "--action", "clone-and-transfer-fd", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 2, actions,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(73, join(process));
        EXPECT_FALSE(has_fd(fd));
    }

    END_TEST;
}

static bool spawn_actions_ns_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);

    {
        zx::channel h1, h2;
        ASSERT_EQ(ZX_OK, zx::channel::create(0, &h1, &h2));

        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_ADD_NS_ENTRY;
        action.ns.prefix = "/foo/bar/baz";
        action.ns.handle = h1.release();

        const char* argv[] = {path.c_str(), "--action", "ns-entry", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 1, &action,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(74, join(process));
    }

    END_TEST;
}

static bool spawn_actions_h_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);

    {
        zx::channel h1, h2;
        ASSERT_EQ(ZX_OK, zx::channel::create(0, &h1, &h2));

        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_ADD_HANDLE;
        action.h.id = PA_USER0;
        action.h.handle = h1.release();

        const char* argv[] = {path.c_str(), "--action", "add-handle", nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 1, &action,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(75, join(process));
    }

    END_TEST;
}

static bool spawn_actions_name_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);

    {
        fdio_spawn_action_t actions[2];
        actions[0].action = FDIO_SPAWN_ACTION_SET_NAME;
        actions[0].name.data = "proc-name-0";
        actions[1].action = FDIO_SPAWN_ACTION_SET_NAME;
        actions[1].name.data = "proc-name-1";

        const char* argv[] = {path.c_str(), nullptr};
        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 2, actions,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(43, join(process));
        char name[ZX_MAX_NAME_LEN];
        ASSERT_EQ(ZX_OK, process.get_property(ZX_PROP_NAME, name, sizeof(name)));
        EXPECT_EQ(0, strcmp(name, "proc-name-1"));
    }

    END_TEST;
}

static bool spawn_errors_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);
    char err_msg[FDIO_SPAWN_ERR_MSG_MAX_LENGTH];
    const char* argv[] = {path.c_str(), nullptr};

    ASSERT_EQ(ZX_ERR_INVALID_ARGS,
              fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL, path.c_str(),
                         nullptr, process.reset_and_get_address()));

    ASSERT_EQ(ZX_ERR_INVALID_ARGS,
              fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL, path.c_str(),
                             argv, nullptr, 1, nullptr, process.reset_and_get_address(), nullptr));

    {
        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_ADD_NS_ENTRY;
        action.ns.prefix = "/foo/bar/baz";
        action.ns.handle = ZX_HANDLE_INVALID;

        ASSERT_EQ(ZX_ERR_INVALID_ARGS,
                fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL, path.c_str(),
                               argv, nullptr, 1, &action, process.reset_and_get_address(), nullptr));
    }

    {
        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_ADD_HANDLE;
        action.h.id = PA_USER0;
        action.h.handle = ZX_HANDLE_INVALID;

        ASSERT_EQ(ZX_ERR_INVALID_ARGS,
                fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL, path.c_str(),
                               argv, nullptr, 1, &action, process.reset_and_get_address(), nullptr));
    }

    {
        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_SET_NAME;
        action.name.data = nullptr;

        ASSERT_EQ(ZX_ERR_INVALID_ARGS,
                fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL, path.c_str(),
                               argv, nullptr, 1, &action, process.reset_and_get_address(), nullptr));
    }

    {
        const char* empty_argv[] = {nullptr};
        ASSERT_EQ(ZX_ERR_INVALID_ARGS,
                  fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL, path.c_str(),
                             empty_argv, process.reset_and_get_address()));
    }

    ASSERT_EQ(ZX_ERR_NOT_FOUND,
              fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL, "/bogus/path",
                             argv, nullptr, 0, nullptr, process.reset_and_get_address(), err_msg));
    EXPECT_TRUE(strstr(err_msg, "/bogus/path") != nullptr);

    {
        zx::job job;
        ASSERT_EQ(ZX_OK, zx::job::default_job()->duplicate(0, &job));
        ASSERT_EQ(ZX_ERR_ACCESS_DENIED,
                  fdio_spawn(job.get(), FDIO_SPAWN_CLONE_ALL, path.c_str(),
                             argv, process.reset_and_get_address()));
    }

    {
        ASSERT_EQ(30, dup2(0, 30));
        ASSERT_EQ(0, close(0));
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(43, join(process));
        ASSERT_EQ(0, dup2(30, 0));
        ASSERT_EQ(0, close(30));
    }

    {
        ASSERT_EQ(30, dup2(0, 30));
        ASSERT_EQ(0, close(0));
        zxio_storage_t* storage = nullptr;
        fdio_t* io = fdio_zxio_create(&storage);
        ASSERT_EQ(0, fdio_bind_to_fd(io, 0, 0));
        status = fdio_spawn(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                            path.c_str(), argv, process.reset_and_get_address());
        ASSERT_EQ(ZX_ERR_NOT_SUPPORTED, status);
        ASSERT_EQ(0, close(0));
        ASSERT_EQ(0, dup2(30, 0));
        ASSERT_EQ(0, close(30));
    }

    {
        zxio_storage_t* storage = nullptr;
        fdio_t* io = fdio_zxio_create(&storage);
        int fd = fdio_bind_to_fd(io, -1, 0);
        ASSERT_GE(fd, 3);

        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_CLONE_FD;
        action.fd.local_fd = fd;
        action.fd.target_fd = 21;

        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 1, &action, process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_ERR_NOT_SUPPORTED, status);
        ASSERT_EQ(0, close(fd));
    }

    {
        zxio_storage_t* storage = nullptr;
        fdio_t* io = fdio_zxio_create(&storage);
        int fd = fdio_bind_to_fd(io, -1, 0);
        ASSERT_GE(fd, 3);

        fdio_spawn_action_t action;
        action.action = FDIO_SPAWN_ACTION_TRANSFER_FD;
        action.fd.local_fd = fd;
        action.fd.target_fd = 21;

        status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                path.c_str(), argv, nullptr, 1, &action, process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_ERR_NOT_SUPPORTED, status);
        ASSERT_EQ(-1, close(fd));
    }

    END_TEST;
}

static bool spawn_vmo_test(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::process process;
    const std::string path = new_path(kSpawnChild);

    {
        int fd = open(path.c_str(), O_RDONLY);
        ASSERT_GE(fd, 0);
        zx_handle_t vmo;
        ASSERT_EQ(ZX_OK, fdio_get_vmo_clone(fd, &vmo));
        close(fd);

        zx_handle_t exec_vmo;
        ASSERT_EQ(ZX_OK, zx_vmo_replace_as_executable(vmo, ZX_HANDLE_INVALID, &exec_vmo));

        const char* argv[] = {path.c_str(), nullptr};
        status = fdio_spawn_vmo(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
                                exec_vmo, argv, nullptr, 0, nullptr,
                                process.reset_and_get_address(), nullptr);
        ASSERT_EQ(ZX_OK, status);
        EXPECT_EQ(43, join(process));
    }

    END_TEST;
}

BEGIN_TEST_CASE(spawn_tests)
RUN_TEST(spawn_control_test)
RUN_TEST(spawn_launcher_test)
RUN_TEST(spawn_invalid_args_test)
RUN_TEST(spawn_flags_test)
RUN_TEST(spawn_environ_test)
RUN_TEST(spawn_actions_fd_test)
RUN_TEST(spawn_actions_ns_test)
RUN_TEST(spawn_actions_h_test)
RUN_TEST(spawn_actions_name_test)
RUN_TEST(spawn_errors_test)
RUN_TEST(spawn_vmo_test)
END_TEST_CASE(spawn_tests)