// Copyright 2017 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 <zircon/process.h>
#include <zircon/status.h>
#include <zircon/syscalls.h>
#include <zircon/syscalls/exception.h>
#include <zircon/syscalls/object.h>
#include <mini-process/mini-process.h>
#include <unittest/unittest.h>

#include <inttypes.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>

#define LOCAL_TRACE 0
#define LTRACEF(str, x...)                                  \
    do {                                                    \
        if (LOCAL_TRACE) {                                  \
            printf("%s:%d: " str, __func__, __LINE__, ##x); \
        }                                                   \
    } while (0)

namespace {

// A function that returns a handle to get the info of.
// Typically get_test_process, get_test_job, zx_process_self, zx_job_default.
typedef zx_handle_t (*handle_source_fn)();

bool handle_valid_on_valid_handle_succeeds() {
    BEGIN_TEST;
    EXPECT_EQ(zx_object_get_info(zx_process_self(), ZX_INFO_HANDLE_VALID,
                                 nullptr, 0, nullptr, nullptr),
              ZX_OK);
    END_TEST;
}

bool handle_valid_on_closed_handle_fails() {
    BEGIN_TEST;
    // Create an event and show that it's valid.
    zx_handle_t event;
    ASSERT_EQ(zx_event_create(0u, &event), ZX_OK);
    EXPECT_EQ(zx_object_get_info(event, ZX_INFO_HANDLE_VALID,
                                 nullptr, 0, nullptr, nullptr),
              ZX_OK);

    // Close the handle and show that it becomes invalid.
    zx_handle_close(event);
    EXPECT_NE(zx_object_get_info(event, ZX_INFO_HANDLE_VALID,
                                 nullptr, 0, nullptr, nullptr),
              ZX_OK);
    END_TEST;
}

// Tests that ZX_INFO_TASK_STATS seems to work.
bool task_stats_smoke() {
    BEGIN_TEST;
    zx_info_task_stats_t info;
    ASSERT_EQ(zx_object_get_info(zx_process_self(), ZX_INFO_TASK_STATS,
                                 &info, sizeof(info), nullptr, nullptr),
              ZX_OK);
    ASSERT_GT(info.mem_private_bytes, 0u);
    ASSERT_GT(info.mem_shared_bytes, 0u);
    ASSERT_GE(info.mem_mapped_bytes,
              info.mem_private_bytes + info.mem_shared_bytes);

    ASSERT_GT(info.mem_scaled_shared_bytes, 0u);
    ASSERT_GT(info.mem_shared_bytes, info.mem_scaled_shared_bytes);
    END_TEST;
}

// Structs to keep track of VMARs/mappings in the test child process.
typedef struct test_mapping {
    uintptr_t base;
    size_t size;
    uint32_t flags; // ZX_INFO_MAPS_MMU_FLAG_PERM_{READ,WRITE,EXECUTE}
} test_mapping_t;

// A VMO that the test process maps or has a handle to.
typedef struct test_vmo {
    zx_koid_t koid;
    size_t size;
    uint32_t flags; // ZX_INFO_VMO_VIA_{HANDLE,MAPPING}
} test_vmo_t;

typedef struct test_mapping_info {
    uintptr_t vmar_base;
    size_t vmar_size;
    size_t num_mappings;
    test_mapping_t* mappings; // num_mappings entries
    size_t num_vmos;
    test_vmo_t* vmos; // num_vmos entries
} test_mapping_info_t;

// Gets the koid of the object pointed to by |handle|.
zx_status_t get_koid(zx_handle_t handle, zx_koid_t* koid) {
    zx_info_handle_basic_t info;
    zx_status_t s = zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC,
                                       &info, sizeof(info), nullptr, nullptr);
    if (s == ZX_OK) {
        *koid = info.koid;
    }
    return s;
}

// Returns a process singleton. ZX_INFO_PROCESS_MAPS can't run on the current
// process, so tests should use this instead.
// This handle is leaked, and we expect our process teardown to clean it up
// naturally.
zx_handle_t get_test_process_etc(const test_mapping_info_t** info) {
    static zx_handle_t test_process = ZX_HANDLE_INVALID;
    static test_mapping_info_t* test_info = nullptr;

    if (info != nullptr) {
        *info = nullptr;
    }
    if (test_process == ZX_HANDLE_INVALID) {
        // Create a VMO whose handle we'll give to the test process.
        // It will not be mapped into the test process's VMAR.
        const size_t unmapped_vmo_size = PAGE_SIZE;
        zx_handle_t unmapped_vmo;
        zx_status_t s = zx_vmo_create(
            unmapped_vmo_size, /* options */ 0u, &unmapped_vmo);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "zx_vmo_create"); // Poison the test.
            return ZX_HANDLE_INVALID;
        }
        zx_koid_t unmapped_vmo_koid;
        s = get_koid(unmapped_vmo, &unmapped_vmo_koid);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "get_koid");
            return ZX_HANDLE_INVALID;
        }
        // Try to set the name, but ignore any errors.
        static const char unmapped_vmo_name[] = "test:unmapped";
        zx_object_set_property(unmapped_vmo, ZX_PROP_NAME,
                               unmapped_vmo_name, sizeof(unmapped_vmo_name));

        // Failures from here on will start to leak handles, but they'll
        // be cleaned up when this binary exits.

        zx_handle_t process;
        zx_handle_t vmar;
        static const char pname[] = "object-info-minipr";
        s = zx_process_create(zx_job_default(), pname, sizeof(pname),
                              /* options */ 0u, &process, &vmar);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "zx_process_create");
            return ZX_HANDLE_INVALID;
        }

        zx_handle_t thread;
        static const char tname[] = "object-info-minith";
        s = zx_thread_create(process, tname, sizeof(tname),
                             /* options */ 0u, &thread);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "zx_thread_create");
            return ZX_HANDLE_INVALID;
        }

        zx_handle_t minip_channel;
        // Start the process before we mess with the VMAR,
        // so we don't step on the mapping done by start_mini_process_etc.
        s = start_mini_process_etc(process, thread, vmar, unmapped_vmo,
                                   &minip_channel);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "start_mini_process_etc");
            return ZX_HANDLE_INVALID;
        }
        unmapped_vmo = ZX_HANDLE_INVALID; // Transferred to the test process.
        zx_handle_close(minip_channel);

        // Create a child VMAR and a mapping under it, so we have
        // something interesting to look at when getting the process's
        // memory maps. After this, the process maps should at least contain:
        //
        //   Root Aspace
        //   - Root VMAR
        //     - Code+stack mapping created by start_mini_process_etc
        //     - Sub VMAR created below
        //       - kNumMappings mappings created below

        static const size_t kNumMappings = 8;
        // Leaked on failure. Never freed on success.
        test_mapping_info_t* ti = (test_mapping_info_t*)malloc(sizeof(*ti));
        ti->num_mappings = kNumMappings;
        ti->mappings =
            (test_mapping_t*)malloc(kNumMappings * sizeof(test_mapping_t));

        // Big enough to fit all of the mappings with some slop.
        ti->vmar_size = PAGE_SIZE * kNumMappings * 16;
        zx_handle_t sub_vmar;
        s = zx_vmar_allocate(vmar, /* offset */ 0,
                             ti->vmar_size,
                             ZX_VM_FLAG_CAN_MAP_READ |
                                 ZX_VM_FLAG_CAN_MAP_WRITE |
                                 ZX_VM_FLAG_CAN_MAP_EXECUTE,
                             &sub_vmar, &ti->vmar_base);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "zx_vmar_allocate");
            return ZX_HANDLE_INVALID;
        }

        zx_handle_t vmo;
        const size_t vmo_size = PAGE_SIZE * kNumMappings;
        s = zx_vmo_create(vmo_size, /* options */ 0u, &vmo);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "zx_vmo_create");
            return ZX_HANDLE_INVALID;
        }
        zx_koid_t vmo_koid;
        s = get_koid(vmo, &vmo_koid);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "get_koid");
            return ZX_HANDLE_INVALID;
        }
        // Try to set the name, but ignore any errors.
        static const char vmo_name[] = "test:mapped";
        zx_object_set_property(vmo, ZX_PROP_NAME, vmo_name, sizeof(vmo_name));

        // Record the VMOs now that we have both of them.
        ti->num_vmos = 2;
        ti->vmos = (test_vmo_t*)malloc(2 * sizeof(test_vmo_t));
        ti->vmos[0].koid = unmapped_vmo_koid;
        ti->vmos[0].size = unmapped_vmo_size;
        ti->vmos[0].flags = ZX_INFO_VMO_VIA_HANDLE;
        ti->vmos[1].koid = vmo_koid;
        ti->vmos[1].size = vmo_size;
        ti->vmos[1].flags = ZX_INFO_VMO_VIA_MAPPING;

        // Map each page of the VMO to some arbitray location in the VMAR.
        for (size_t i = 0; i < kNumMappings; i++) {
            test_mapping_t* m = &ti->mappings[i];
            m->size = PAGE_SIZE;

            // Pick flags for this mapping; cycle through different
            // combinations for the test. Must always have READ set
            // to be mapped.
            m->flags = ZX_VM_FLAG_PERM_READ;
            if (i & 1) {
                m->flags |= ZX_VM_FLAG_PERM_WRITE;
            }
            if (i & 2) {
                m->flags |= ZX_VM_FLAG_PERM_EXECUTE;
            }

            s = zx_vmar_map(sub_vmar, /* vmar_offset (ignored) */ 0,
                            vmo, /* vmo_offset */ i * PAGE_SIZE,
                            /* len */ PAGE_SIZE,
                            m->flags,
                            &m->base);
            if (s != ZX_OK) {
                char msg[32];
                snprintf(msg, sizeof(msg), "zx_vmar_map: [%zd]", i);
                EXPECT_EQ(s, ZX_OK, msg);
                return ZX_HANDLE_INVALID;
            }
        }
        zx_handle_close(vmo); // Kept alive by the VMAR.
        zx_handle_close(sub_vmar); // Kept alive by the process.

        test_process = process;
        test_info = ti;
    }
    if (info != nullptr) {
        *info = test_info;
    }
    return test_process;
}

zx_handle_t get_test_process() {
    return get_test_process_etc(nullptr);
}

// Tests that ZX_INFO_PROCESS_MAPS seems to work.
bool process_maps_smoke() {
    BEGIN_TEST;
    const test_mapping_info_t* test_info;
    const zx_handle_t process = get_test_process_etc(&test_info);
    ASSERT_NONNULL(test_info, "get_test_process_etc");

    // Buffer big enough to read all of the test process's map entries.
    const size_t bufsize = test_info->num_mappings * 4 * sizeof(zx_info_maps_t);
    zx_info_maps_t* maps = (zx_info_maps_t*)malloc(bufsize);

    // Read the map entries.
    size_t actual;
    size_t avail;
    ASSERT_EQ(zx_object_get_info(process, ZX_INFO_PROCESS_MAPS,
                                 maps, bufsize,
                                 &actual, &avail),
              ZX_OK);
    EXPECT_EQ(actual, avail, "Should have read all entries");

    // The first two entries should always be the ASpace and root VMAR.
    ASSERT_GE(actual, 2u, "Root aspace/vmar missing?");
    EXPECT_EQ(maps[0].type, (uint32_t)ZX_INFO_MAPS_TYPE_ASPACE);
    EXPECT_EQ(maps[0].depth, 0u, "ASpace depth");
    EXPECT_GT(maps[0].size, 1u * 1024 * 1024 * 1024 * 1024, "ASpace size");
    EXPECT_EQ(maps[1].type, (uint32_t)ZX_INFO_MAPS_TYPE_VMAR);
    EXPECT_EQ(maps[1].depth, 1u, "Root VMAR depth");
    EXPECT_GT(maps[1].size, 1u * 1024 * 1024 * 1024 * 1024, "Root VMAR size");

    // Look for the VMAR and all of the mappings we created.
    bool saw_vmar = false; // Whether we've seen our VMAR.
    bool under_vmar = false; // If we're looking at children of our VMAR.
    size_t vmar_depth = 0;
    uint32_t saw_mapping = 0u; // bitmask of mapping indices we've seen.
    ASSERT_LT(test_info->num_mappings, 32u);

    LTRACEF("\n");
    for (size_t i = 2; i < actual; i++) {
        zx_info_maps_t* entry = maps + i;
        char msg[128];
        snprintf(msg, sizeof(msg),
                 "[%2zd] %*stype:%u base:0x%" PRIx64 " size:%" PRIu64,
                 i, (int)(entry->depth - 2) * 2, "",
                 entry->type, entry->base, entry->size);
        LTRACEF("%s\n", msg);
        // All entries should be children of the root VMAR.
        EXPECT_GT(entry->depth, 1u, msg);
        EXPECT_TRUE(entry->type >= ZX_INFO_MAPS_TYPE_ASPACE &&
                        entry->type < ZX_INFO_MAPS_TYPE_LAST,
                    msg);

        if (entry->type == ZX_INFO_MAPS_TYPE_VMAR &&
            entry->base == test_info->vmar_base &&
            entry->size == test_info->vmar_size) {
            saw_vmar = true;
            under_vmar = true;
            vmar_depth = entry->depth;
        } else if (under_vmar) {
            if (entry->depth <= vmar_depth) {
                under_vmar = false;
                vmar_depth = 0;
            } else {
                // |entry| should be a child mapping of our VMAR.
                EXPECT_EQ((uint32_t)ZX_INFO_MAPS_TYPE_MAPPING, entry->type,
                          msg);
                // The mapping should fit inside the VMAR.
                EXPECT_LE(test_info->vmar_base, entry->base, msg);
                EXPECT_LE(entry->base + entry->size,
                          test_info->vmar_base + test_info->vmar_size,
                          msg);
                // Look for it in the expected mappings.
                bool found = false;
                for (size_t j = 0; j < test_info->num_mappings; j++) {
                    const test_mapping_t* t = &test_info->mappings[j];
                    if (t->base == entry->base && t->size == entry->size) {
                        // Make sure we don't see duplicates.
                        EXPECT_EQ(0u, saw_mapping & (1 << j), msg);
                        saw_mapping |= 1 << j;
                        EXPECT_EQ(t->flags, entry->u.mapping.mmu_flags, msg);
                        found = true;
                        break;
                    }
                }
                EXPECT_TRUE(found, msg);
            }
        }
    }

    // Make sure we saw our VMAR and all of our mappings.
    EXPECT_TRUE(saw_vmar);
    EXPECT_EQ((uint32_t)(1 << test_info->num_mappings) - 1, saw_mapping);

    // Do one more read with a short buffer to test actual < avail.
    const size_t bufsize2 = actual * 3 / 4 * sizeof(zx_info_maps_t);
    zx_info_maps_t* maps2 = (zx_info_maps_t*)malloc(bufsize2);
    size_t actual2;
    size_t avail2;
    ASSERT_EQ(zx_object_get_info(process, ZX_INFO_PROCESS_MAPS,
                                 maps2, bufsize2,
                                 &actual2, &avail2),
              ZX_OK);
    EXPECT_LT(actual2, avail2);
    // mini-process is very simple, and won't have modified its own memory
    // maps since the previous dump. Its "committed_pages" values could be
    // different, though.
    EXPECT_EQ(avail, avail2);
    LTRACEF("\n");
    EXPECT_GT(actual2, 3u); // Make sure we're looking at something.
    for (size_t i = 0; i < actual2; i++) {
        zx_info_maps_t* e1 = maps + i;
        zx_info_maps_t* e2 = maps2 + i;
        char msg[128];
        snprintf(msg, sizeof(msg),
                 "[%2zd] %*stype:%u/%u base:0x%" PRIx64 "/0x%" PRIx64
                 " size:%" PRIu64 "/%" PRIu64,
                 i, (int)e1->depth * 2, "",
                 e1->type, e2->type, e1->base, e2->base, e1->size, e2->size);
        LTRACEF("%s\n", msg);
        EXPECT_EQ(e1->base, e2->base, msg);
        EXPECT_EQ(e1->size, e2->size, msg);
        EXPECT_EQ(e1->depth, e2->depth, msg);
        EXPECT_EQ(e1->type, e2->type, msg);
        if (e1->type == e2->type && e2->type == ZX_INFO_MAPS_TYPE_MAPPING) {
            EXPECT_EQ(e1->u.mapping.mmu_flags, e2->u.mapping.mmu_flags, msg);
        }
    }

    free(maps);
    free(maps2);
    END_TEST;
}

template <uint32_t Topic, typename EntryType>
bool self_fails() {
    BEGIN_TEST;
    EntryType entries[2];
    size_t actual;
    size_t avail;
    // It's illegal to look at your own entries, because the output buffer
    // lives inside the address space that's being examined.
    EXPECT_EQ(zx_object_get_info(zx_process_self(), Topic,
                                 entries, sizeof(entries), &actual, &avail),
              ZX_ERR_ACCESS_DENIED);
    END_TEST;
}

template <uint32_t Topic, typename EntryType>
bool invalid_handle_fails() {
    BEGIN_TEST;
    EntryType entries[2];
    size_t actual;
    size_t avail;
    // Passing ZX_HANDLE_INVALID should fail.
    EXPECT_EQ(zx_object_get_info(ZX_HANDLE_INVALID, Topic,
                                 entries, sizeof(entries), &actual, &avail),
              ZX_ERR_BAD_HANDLE);
    END_TEST;
}

template <uint32_t Topic, typename EntryType, handle_source_fn GetWrongHandle>
bool wrong_handle_type_fails() {
    BEGIN_TEST;
    EntryType entries[2];
    size_t actual;
    size_t avail;
    // Passing a handle to an unsupported object type should fail.
    EXPECT_NE(zx_object_get_info(GetWrongHandle(), Topic,
                                 entries, sizeof(entries), &actual, &avail),
              ZX_OK);
    END_TEST;
}

template <uint32_t Topic, typename EntryType,
          handle_source_fn GetHandle, zx_rights_t MissingRights>
bool missing_rights_fails() {
    BEGIN_TEST;
    // Call should succeed with the default rights.
    zx_handle_t obj = GetHandle();
    EntryType entries[2];
    size_t actual;
    size_t avail;
    EXPECT_EQ(zx_object_get_info(obj, Topic,
                                 entries, sizeof(entries), &actual, &avail),
              ZX_OK);

    // Get the test object handle rights.
    zx_info_handle_basic_t hi;
    ASSERT_EQ(zx_object_get_info(obj, ZX_INFO_HANDLE_BASIC,
                                 &hi, sizeof(hi), nullptr, nullptr),
              ZX_OK);
    char msg[32];
    snprintf(msg, sizeof(msg), "rights 0x%" PRIx32, hi.rights);
    EXPECT_EQ(hi.rights & MissingRights, MissingRights, msg);

    // Create a handle without the important rights.
    zx_handle_t handle;
    ASSERT_EQ(zx_handle_duplicate(obj, hi.rights & ~MissingRights, &handle),
              ZX_OK);

    // Call should fail without these rights.
    EXPECT_EQ(zx_object_get_info(handle, Topic,
                                 entries, sizeof(entries), &actual, &avail),
              ZX_ERR_ACCESS_DENIED);

    zx_handle_close(handle);
    END_TEST;
}

template <uint32_t Topic, typename EntryType, handle_source_fn GetHandle>
bool single_zero_buffer_fails() {
    BEGIN_TEST;
    EntryType entry;
    size_t actual;
    size_t avail;
    // Passing a zero-sized buffer to a topic that expects a single
    // in/out entry should fail.
    EXPECT_EQ(zx_object_get_info(GetHandle(), Topic,
                                 &entry, // buffer
                                 0, // len
                                 &actual, &avail),
              ZX_ERR_BUFFER_TOO_SMALL);
    EXPECT_EQ(0u, actual);
    EXPECT_GT(avail, 0u);
    END_TEST;
}

template <uint32_t Topic, handle_source_fn GetHandle>
bool multi_zero_buffer_succeeds() {
    BEGIN_TEST;
    size_t actual;
    size_t avail;
    // Passing a zero-sized null buffer to a topic that can handle multiple
    // in/out entries should succeed.
    EXPECT_EQ(zx_object_get_info(GetHandle(), Topic,
                                 nullptr, // buffer
                                 0, // len
                                 &actual, &avail),
              ZX_OK);
    EXPECT_EQ(0u, actual);
    EXPECT_GT(avail, 0u);
    END_TEST;
}

template <uint32_t Topic, typename EntryType, handle_source_fn GetHandle>
bool short_buffer_succeeds() {
    BEGIN_TEST;
    EntryType entries[1];
    size_t actual;
    size_t avail;
    // Passing a buffer shorter than avail should succeed.
    EXPECT_EQ(zx_object_get_info(GetHandle(), Topic,
                                 entries,
                                 sizeof(entries),
                                 &actual, &avail),
              ZX_OK);
    EXPECT_EQ(1u, actual);
    EXPECT_GT(avail, actual);
    END_TEST;
}

template <uint32_t Topic, typename EntryType, handle_source_fn GetHandle>
bool null_avail_actual_succeeds() {
    BEGIN_TEST;
    EntryType entries[2];
    EXPECT_EQ(zx_object_get_info(GetHandle(), Topic,
                                 entries, sizeof(entries),
                                 nullptr, // actual
                                 nullptr), // avail
              ZX_OK);
    END_TEST;
}

template <uint32_t Topic, typename EntryType, handle_source_fn GetHandle>
bool bad_buffer_fails() {
    BEGIN_TEST;
    size_t actual;
    size_t avail;
    EXPECT_EQ(zx_object_get_info(GetHandle(), Topic,
                                 // Bad buffer pointer value.
                                 (EntryType*)1,
                                 sizeof(EntryType),
                                 &actual, &avail),
              ZX_ERR_INVALID_ARGS);
    END_TEST;
}

// Tests the behavior when passing a buffer that starts in mapped
// memory but crosses into unmapped memory.
template <uint32_t Topic, typename EntryType, handle_source_fn GetHandle>
bool partially_unmapped_buffer_fails() {
    BEGIN_TEST;
    // Create a two-page VMAR.
    zx_handle_t vmar;
    uintptr_t vmar_addr;
    ASSERT_EQ(zx_vmar_allocate(zx_vmar_root_self(),
                               0, 2 * PAGE_SIZE,
                               ZX_VM_FLAG_CAN_MAP_READ |
                                   ZX_VM_FLAG_CAN_MAP_WRITE |
                                   ZX_VM_FLAG_CAN_MAP_SPECIFIC,
                               &vmar, &vmar_addr),
              ZX_OK);

    // Create a one-page VMO.
    zx_handle_t vmo;
    ASSERT_EQ(zx_vmo_create(PAGE_SIZE, 0, &vmo), ZX_OK);

    // Map the first page of the VMAR.
    uintptr_t vmo_addr;
    ASSERT_EQ(zx_vmar_map(vmar, 0, vmo, 0, PAGE_SIZE,
                          ZX_VM_FLAG_SPECIFIC |
                              ZX_VM_FLAG_PERM_READ |
                              ZX_VM_FLAG_PERM_WRITE,
                          &vmo_addr),
              ZX_OK);
    ASSERT_EQ(vmar_addr, vmo_addr);

    // Point to a spot in the mapped page just before the unmapped region:
    // the first entry will hit mapped memory, the second entry will hit
    // unmapped memory.
    EntryType* entries = (EntryType*)(vmo_addr + PAGE_SIZE) - 1;

    size_t actual;
    size_t avail;
    EXPECT_EQ(zx_object_get_info(GetHandle(), Topic,
                                 entries, sizeof(EntryType) * 4,
                                 &actual, &avail),
              // Bad user buffer should return ZX_ERR_INVALID_ARGS.
              ZX_ERR_INVALID_ARGS);

    zx_vmar_destroy(vmar);
    zx_handle_close(vmar);
    zx_handle_close(vmo);
    END_TEST;
}

template <uint32_t Topic, typename EntryType, handle_source_fn GetHandle>
bool bad_actual_fails() {
    BEGIN_TEST;
    EntryType entries[2];
    size_t avail;
    EXPECT_EQ(zx_object_get_info(GetHandle(), Topic,
                                 entries, sizeof(entries),
                                 // Bad actual pointer value.
                                 (size_t*)1,
                                 &avail),
              ZX_ERR_INVALID_ARGS);
    END_TEST;
}

template <uint32_t Topic, typename EntryType, handle_source_fn GetHandle>
bool bad_avail_fails() {
    BEGIN_TEST;
    EntryType entries[2];
    size_t actual;
    EXPECT_EQ(zx_object_get_info(GetHandle(), Topic,
                                 entries, sizeof(entries), &actual,
                                 // Bad available pointer value.
                                 (size_t*)1),
              ZX_ERR_INVALID_ARGS);
    END_TEST;
}

// Tests that ZX_INFO_PROCESS_VMOS seems to work.
bool process_vmos_smoke() {
    BEGIN_TEST;
    const test_mapping_info_t* test_info;
    const zx_handle_t process = get_test_process_etc(&test_info);
    ASSERT_NONNULL(test_info, "get_test_process_etc");

    // Buffer big enough to read all of the test process's VMO entries.
    // There'll be one per mapping, one for the unmapped VMO, plus some
    // extras (at least the vDSO and the mini-process stack).
    const size_t bufsize =
        (test_info->num_mappings + 1 + 8) * sizeof(zx_info_vmo_t);
    zx_info_vmo_t* vmos = (zx_info_vmo_t*)malloc(bufsize);

    // Read the VMO entries.
    size_t actual;
    size_t avail;
    ASSERT_EQ(zx_object_get_info(process, ZX_INFO_PROCESS_VMOS,
                                 vmos, bufsize,
                                 &actual, &avail),
              ZX_OK);
    EXPECT_EQ(actual, avail, "Should have read all entries");

    // Look for the expected VMOs.
    uint32_t saw_vmo = 0u; // Bitmask of VMO indices we've seen
    ASSERT_LT(test_info->num_vmos, 32u);

    LTRACEF("\n");
    for (size_t i = 0; i < actual; i++) {
        zx_info_vmo_t* entry = vmos + i;
        char msg[128];
        snprintf(msg, sizeof(msg),
                 "[%2zd] koid:%" PRIu64 " name:'%s' size:%" PRIu64
                 " flags:0x%" PRIx32,
                 i, entry->koid, entry->name, entry->size_bytes, entry->flags);
        LTRACEF("%s\n", msg);

        // Look for it in the expected VMOs. We won't find all VMOs here,
        // since we don't track the vDSO or mini-process stack.
        for (size_t j = 0; j < test_info->num_vmos; j++) {
            const test_vmo_t* t = &test_info->vmos[j];
            if (t->koid == entry->koid && t->size == entry->size_bytes) {
                // These checks aren't appropriate for all VMOs.
                // The VMOs we track are:
                // - Only mapped or via handle, not both
                // - Not clones
                // - Not shared
                EXPECT_EQ(entry->parent_koid, 0u, msg);
                EXPECT_EQ(entry->num_children, 0u, msg);
                EXPECT_EQ(entry->share_count, 1u, msg);
                EXPECT_EQ(t->flags & entry->flags, t->flags, msg);
                if (entry->flags & ZX_INFO_VMO_VIA_HANDLE) {
                    EXPECT_EQ(entry->num_mappings, 0u, msg);
                } else {
                    EXPECT_NE(entry->flags & ZX_INFO_VMO_VIA_MAPPING, 0u, msg);
                    EXPECT_EQ(
                        entry->num_mappings, test_info->num_mappings, msg);
                }
                EXPECT_EQ(entry->flags & ZX_INFO_VMO_IS_COW_CLONE, 0u, msg);

                saw_vmo |= 1 << j; // Duplicates are fine and expected
                break;
            }
        }

        // All of our VMOs should be paged, not physical.
        EXPECT_EQ(ZX_INFO_VMO_TYPE(entry->flags), ZX_INFO_VMO_TYPE_PAGED, msg);

        // Each entry should be via either map or handle, but not both.
        // NOTE: This could change in the future, but currently reflects
        // the way things work.
        const uint32_t kViaMask =
            ZX_INFO_VMO_VIA_HANDLE | ZX_INFO_VMO_VIA_MAPPING;
        EXPECT_NE(entry->flags & kViaMask, kViaMask, msg);

        // TODO(dbort): Test more fields/flags of zx_info_vmo_t by adding some
        // clones, shared VMOs, mapped+handle VMOs, physical VMOs if possible.
        // All but committed_bytes should be predictable.
    }

    // Make sure we saw all of the expected VMOs.
    EXPECT_EQ((uint32_t)(1 << test_info->num_vmos) - 1, saw_vmo);

    // Do one more read with a short buffer to test actual < avail.
    const size_t bufsize2 = actual * 3 / 4 * sizeof(zx_info_vmo_t);
    zx_info_vmo_t* vmos2 = (zx_info_vmo_t*)malloc(bufsize2);
    size_t actual2;
    size_t avail2;
    ASSERT_EQ(zx_object_get_info(process, ZX_INFO_PROCESS_VMOS,
                                 vmos2, bufsize2,
                                 &actual2, &avail2),
              ZX_OK);
    EXPECT_LT(actual2, avail2);
    // mini-process is very simple, and won't have modified its own set of VMOs
    // since the previous dump.
    EXPECT_EQ(avail, avail2);
    LTRACEF("\n");
    EXPECT_GT(actual2, 3u); // Make sure we're looking at something.
    for (size_t i = 0; i < actual2; i++) {
        zx_info_vmo_t* e1 = vmos + i;
        zx_info_vmo_t* e2 = vmos2 + i;
        char msg[128];
        snprintf(msg, sizeof(msg),
                 "[%2zd] koid:%" PRIu64 "/%" PRIu64 " name:'%s'/'%s' "
                 "size:%" PRIu64 "/%" PRIu64 " flags:0x%" PRIx32 "/0x%" PRIx32,
                 i, e1->koid, e2->koid, e1->name, e2->name,
                 e1->size_bytes, e2->size_bytes, e1->flags, e2->flags);
        LTRACEF("%s\n", msg);
        EXPECT_EQ(e1->koid, e2->koid, msg);
        EXPECT_EQ(e1->size_bytes, e2->size_bytes, msg);
        EXPECT_EQ(e1->flags, e2->flags, msg);
        if (e1->flags == e2->flags && e2->flags & ZX_INFO_VMO_VIA_HANDLE) {
            EXPECT_EQ(e1->handle_rights, e2->handle_rights, msg);
        }
    }

    free(vmos);
    free(vmos2);
    END_TEST;
}

// ZX_INFO_JOB_PROCESS/ZX_INFO_JOB_CHILDREN tests

// Returns a job with the structure:
// - returned job
//   - child process 1
//   - child process 2
//   - child process 3 (kTestJobChildProcs)
//   - child job 1
//     - grandchild process 1.1
//     - grandchild job 1.1
//   - child job 2 (kTestJobChildJobs)
//     - grandchild process 2.1
//     - grandchild job 2.1
const size_t kTestJobChildProcs = 3;
const size_t kTestJobChildJobs = 2;
zx_handle_t get_test_job() {
    static zx_handle_t test_job = ZX_HANDLE_INVALID;

    if (test_job == ZX_HANDLE_INVALID) {
        char msg[64];
        zx_handle_t root;
        zx_status_t s = zx_job_create(zx_job_default(), 0, &root);
        if (s != ZX_OK) {
            EXPECT_EQ(s, ZX_OK, "zx_job_create"); // Poison the test.
            return ZX_HANDLE_INVALID;
        }
        for (size_t i = 0; i < kTestJobChildProcs; i++) {
            zx_handle_t proc;
            zx_handle_t vmar;
            s = zx_process_create(root, "child", 6, 0, &proc, &vmar);
            if (s != ZX_OK) {
                snprintf(msg, sizeof(msg), "zx_process_create(child %zu)", i);
                goto fail;
            }
        }
        for (size_t i = 0; i < kTestJobChildJobs; i++) {
            zx_handle_t job;
            s = zx_job_create(root, 0, &job);
            if (s != ZX_OK) {
                snprintf(msg, sizeof(msg), "zx_job_create(child %zu)", i);
                goto fail;
            }
            zx_handle_t proc;
            zx_handle_t vmar;
            s = zx_process_create(job, "grandchild", 6, 0, &proc, &vmar);
            if (s != ZX_OK) {
                snprintf(msg, sizeof(msg), "zx_process_create(grandchild)");
                goto fail;
            }
            zx_handle_t subjob;
            s = zx_job_create(job, 0, &subjob);
            if (s != ZX_OK) {
                snprintf(msg, sizeof(msg), "zx_job_create(grandchild)");
                goto fail;
            }
        }

        if (false) {
        fail:
            EXPECT_EQ(s, ZX_OK, msg); // Poison the test
            zx_task_kill(root); // Clean up all tasks; leaks handles
            return ZX_HANDLE_INVALID;
        }
        test_job = root;
    }

    return test_job;
}

// The jobch_helper_* (job child helper) functions allow testing both
// ZX_INFO_JOB_PROCESS and ZX_INFO_JOB_CHILDREN.
bool jobch_helper_smoke(uint32_t topic, size_t expected_count) {
    BEGIN_TEST;
    zx_koid_t koids[32];
    size_t actual;
    size_t avail;
    EXPECT_EQ(zx_object_get_info(get_test_job(), topic,
                                 koids, sizeof(koids), &actual, &avail),
              ZX_OK);
    EXPECT_EQ(expected_count, actual);
    EXPECT_EQ(expected_count, avail);

    // All returned koids should produce a valid handle when passed to
    // zx_object_get_child.
    for (size_t i = 0; i < actual; i++) {
        char msg[32];
        snprintf(msg, sizeof(msg), "koid %zu", koids[i]);
        zx_handle_t h = ZX_HANDLE_INVALID;
        EXPECT_EQ(zx_object_get_child(get_test_job(), koids[i],
                                      ZX_RIGHT_SAME_RIGHTS, &h),
                  ZX_OK, msg);
        zx_handle_close(h);
    }
    END_TEST;
}

bool job_processes_smoke() {
    return jobch_helper_smoke(ZX_INFO_JOB_PROCESSES, kTestJobChildProcs);
}

bool job_children_smoke() {
    return jobch_helper_smoke(ZX_INFO_JOB_CHILDREN, kTestJobChildJobs);
}

} // namespace

// Tests that should pass for any topic. Use the wrappers below instead of
// calling this directly.
#define _RUN_COMMON_TESTS(topic, entry_type, get_handle)                   \
    RUN_TEST((invalid_handle_fails<topic, entry_type>));                   \
    RUN_TEST((null_avail_actual_succeeds<topic, entry_type, get_handle>)); \
    RUN_TEST((bad_buffer_fails<topic, entry_type, get_handle>));           \
    RUN_TEST((bad_actual_fails<topic, entry_type, get_handle>));           \
    RUN_TEST((bad_avail_fails<topic, entry_type, get_handle>))

// Tests that should pass for any topic that expects a single entry in its
// in/out buffer.
#define RUN_SINGLE_ENTRY_TESTS(topic, entry_type, get_handle) \
    _RUN_COMMON_TESTS(topic, entry_type, get_handle);         \
    RUN_TEST((single_zero_buffer_fails<topic, entry_type, get_handle>))

// Tests that should pass for any topic that can handle multiple entries in its
// in/out buffer.
#define RUN_MULTI_ENTRY_TESTS(topic, entry_type, get_handle)          \
    _RUN_COMMON_TESTS(topic, entry_type, get_handle);                 \
    RUN_TEST((multi_zero_buffer_succeeds<topic, get_handle>));        \
    RUN_TEST((short_buffer_succeeds<topic, entry_type, get_handle>)); \
    RUN_TEST((partially_unmapped_buffer_fails<topic, entry_type, get_handle>))

BEGIN_TEST_CASE(object_info_tests)

// ZX_INFO_HANDLE_VALID is an oddball that doesn't care about its buffer,
// so we can't use the normal topic test suites.
RUN_TEST(handle_valid_on_valid_handle_succeeds);
RUN_TEST(handle_valid_on_closed_handle_fails);
RUN_TEST((invalid_handle_fails<ZX_INFO_HANDLE_VALID, void*>));

RUN_TEST(task_stats_smoke);
RUN_SINGLE_ENTRY_TESTS(ZX_INFO_TASK_STATS, zx_info_task_stats_t, zx_process_self);
RUN_TEST((wrong_handle_type_fails<ZX_INFO_TASK_STATS, zx_info_task_stats_t, get_test_job>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_TASK_STATS, zx_info_task_stats_t, zx_thread_self>));

RUN_TEST(process_maps_smoke);
RUN_MULTI_ENTRY_TESTS(ZX_INFO_PROCESS_MAPS, zx_info_maps_t, get_test_process);
RUN_TEST((self_fails<ZX_INFO_PROCESS_MAPS, zx_info_maps_t>))
RUN_TEST((wrong_handle_type_fails<ZX_INFO_PROCESS_MAPS, zx_info_maps_t, get_test_job>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_PROCESS_MAPS, zx_info_maps_t, zx_thread_self>));
RUN_TEST((missing_rights_fails<ZX_INFO_PROCESS_MAPS, zx_info_maps_t, get_test_process,
                               ZX_RIGHT_READ>));

RUN_TEST(process_vmos_smoke);
RUN_MULTI_ENTRY_TESTS(ZX_INFO_PROCESS_VMOS, zx_info_vmo_t, get_test_process);
RUN_TEST((self_fails<ZX_INFO_PROCESS_VMOS, zx_info_vmo_t>))
RUN_TEST((wrong_handle_type_fails<ZX_INFO_PROCESS_VMOS, zx_info_vmo_t, get_test_job>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_PROCESS_VMOS, zx_info_vmo_t, zx_thread_self>));
RUN_TEST((missing_rights_fails<ZX_INFO_PROCESS_VMOS, zx_info_vmo_t, get_test_process,
                               ZX_RIGHT_READ>));

RUN_TEST(job_processes_smoke);
RUN_MULTI_ENTRY_TESTS(ZX_INFO_JOB_PROCESSES, zx_koid_t, get_test_job);
RUN_TEST((wrong_handle_type_fails<ZX_INFO_JOB_PROCESSES, zx_koid_t, get_test_process>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_JOB_PROCESSES, zx_koid_t, zx_thread_self>));
RUN_TEST((missing_rights_fails<ZX_INFO_JOB_PROCESSES, zx_koid_t, get_test_job,
                               ZX_RIGHT_ENUMERATE>));

RUN_TEST(job_children_smoke);
RUN_MULTI_ENTRY_TESTS(ZX_INFO_JOB_CHILDREN, zx_koid_t, get_test_job);
RUN_TEST((wrong_handle_type_fails<ZX_INFO_JOB_CHILDREN, zx_koid_t, get_test_process>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_JOB_CHILDREN, zx_koid_t, zx_thread_self>));
RUN_TEST((missing_rights_fails<ZX_INFO_JOB_CHILDREN, zx_koid_t, get_test_job,
                               ZX_RIGHT_ENUMERATE>));

// Basic tests for all other topics.

RUN_SINGLE_ENTRY_TESTS(ZX_INFO_HANDLE_BASIC, zx_info_handle_basic_t, get_test_job);
RUN_SINGLE_ENTRY_TESTS(ZX_INFO_HANDLE_BASIC, zx_info_handle_basic_t, get_test_process);
RUN_SINGLE_ENTRY_TESTS(ZX_INFO_HANDLE_BASIC, zx_info_handle_basic_t, zx_thread_self);
RUN_SINGLE_ENTRY_TESTS(ZX_INFO_HANDLE_BASIC, zx_info_handle_basic_t, zx_vmar_root_self);

RUN_SINGLE_ENTRY_TESTS(ZX_INFO_PROCESS, zx_info_process_t, get_test_process);
RUN_TEST((wrong_handle_type_fails<ZX_INFO_PROCESS, zx_info_process_t, get_test_job>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_PROCESS, zx_info_process_t, zx_thread_self>));

RUN_SINGLE_ENTRY_TESTS(ZX_INFO_VMAR, zx_info_vmar_t, zx_vmar_root_self);
RUN_TEST((wrong_handle_type_fails<ZX_INFO_VMAR, zx_info_vmar_t, get_test_job>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_VMAR, zx_info_vmar_t, get_test_process>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_VMAR, zx_info_vmar_t, zx_thread_self>));

RUN_SINGLE_ENTRY_TESTS(ZX_INFO_THREAD, zx_info_thread_t, zx_thread_self);
RUN_TEST((wrong_handle_type_fails<ZX_INFO_THREAD, zx_info_thread_t, get_test_job>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_THREAD, zx_info_thread_t, get_test_process>));

RUN_SINGLE_ENTRY_TESTS(ZX_INFO_THREAD_STATS, zx_info_thread_stats_t, zx_thread_self);
RUN_TEST((wrong_handle_type_fails<ZX_INFO_THREAD_STATS, zx_info_thread_t, get_test_job>));
RUN_TEST((wrong_handle_type_fails<ZX_INFO_THREAD_STATS, zx_info_thread_t, get_test_process>));

// ZX_INFO_PROCESS_THREADS tests.
// TODO(dbort): Use RUN_MULTI_ENTRY_TESTS instead. |short_buffer_succeeds| and
// |partially_unmapped_buffer_fails| currently fail because those tests expect
// avail > 1, but the test process only has one thread and it's not trivial to
// add more.
RUN_TEST((invalid_handle_fails<ZX_INFO_PROCESS_THREADS, zx_koid_t>));
RUN_TEST((null_avail_actual_succeeds<ZX_INFO_PROCESS_THREADS, zx_koid_t, get_test_process>));
RUN_TEST((bad_buffer_fails<ZX_INFO_PROCESS_THREADS, zx_koid_t, get_test_process>));
RUN_TEST((bad_actual_fails<ZX_INFO_PROCESS_THREADS, zx_koid_t, get_test_process>));
RUN_TEST((bad_avail_fails<ZX_INFO_PROCESS_THREADS, zx_koid_t, get_test_process>))
RUN_TEST((multi_zero_buffer_succeeds<ZX_INFO_PROCESS_THREADS, get_test_process>));

// Skip most tests for ZX_INFO_THREAD_EXCEPTION_REPORT, which is tested
// elsewhere and requires the target thread to be in a certain state.
RUN_TEST((invalid_handle_fails<ZX_INFO_THREAD_EXCEPTION_REPORT, zx_exception_report_t>));

// TODO(dbort): Test resource topics
// RUN_MULTI_ENTRY_TESTS(ZX_INFO_RESOURCE_CHILDREN, zx_rrec_t, get_root_resource);
// RUN_MULTI_ENTRY_TESTS(ZX_INFO_RESOURCE_RECORDS, zx_rrec_t, get_root_resource);
// RUN_MULTI_ENTRY_TESTS(ZX_INFO_CPU_STATS, zx_info_cpu_stats_t, get_root_resource);
// RUN_SINGLE_ENTRY_TESTS(ZX_INFO_KMEM_STATS, zx_info_kmem_stats_t, get_root_resource);

END_TEST_CASE(object_info_tests)

#ifndef BUILD_COMBINED_TESTS
int main(int argc, char** argv) {
    return unittest_run_all_tests(argc, argv) ? 0 : -1;
}
#endif