// 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 <fbl/algorithm.h>
#include <fcntl.h>
#include <fuchsia/sysmem/c/fidl.h>
#include <lib/fdio/unsafe.h>
#include <lib/fdio/fd.h>
#include <lib/fdio/fdio.h>
#include <lib/fdio/directory.h>
#include <lib/fidl-async-2/fidl_struct.h>
#include <lib/zx/channel.h>
#include <lib/zx/event.h>

#include <limits>

// We assume one sysmem since boot, for now.
const char* kSysmemDevicePath = "/dev/class/sysmem/000";

extern const fidl_type_t fuchsia_sysmem_BufferCollectionConstraintsTable;
using BufferCollectionConstraints = FidlStruct<fuchsia_sysmem_BufferCollectionConstraints,
                                               &fuchsia_sysmem_BufferCollectionConstraintsTable>;
extern const fidl_type_t fuchsia_sysmem_BufferCollectionInfo_2Table;
using BufferCollectionInfo =
    FidlStruct<fuchsia_sysmem_BufferCollectionInfo_2, &fuchsia_sysmem_BufferCollectionInfo_2Table>;

namespace {

zx_status_t connect_to_sysmem_driver(zx::channel* allocator2_client_param) {
    zx_status_t status;

    zx::channel driver_client;
    zx::channel driver_server;
    status = zx::channel::create(0, &driver_client, &driver_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fdio_service_connect(kSysmemDevicePath, driver_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel allocator2_client;
    zx::channel allocator2_server;
    status = zx::channel::create(0, &allocator2_client, &allocator2_server);
    ASSERT_EQ(status, ZX_OK, "");

    status =
        fuchsia_sysmem_DriverConnectorConnect(driver_client.get(), allocator2_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    *allocator2_client_param = std::move(allocator2_client);
    return ZX_OK;
}

zx_status_t connect_to_sysmem_service(zx::channel* allocator2_client_param) {
    zx_status_t status;

    zx::channel allocator2_client;
    zx::channel allocator2_server;
    status = zx::channel::create(0, &allocator2_client, &allocator2_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fdio_service_connect("/svc/fuchsia.sysmem.Allocator", allocator2_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    *allocator2_client_param = std::move(allocator2_client);
    return ZX_OK;
}

zx_koid_t get_koid(zx_handle_t handle) {
    zx_info_handle_basic_t info;
    zx_status_t status =
        zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &info, sizeof(info), nullptr, nullptr);
    ASSERT_EQ(status, ZX_OK, "");
    return info.koid;
}

zx_status_t verify_connectivity(zx::channel& allocator2_client) {
    zx_status_t status;

    zx::channel collection_client;
    zx::channel collection_server;
    status = zx::channel::create(0, &collection_client, &collection_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fuchsia_sysmem_AllocatorAllocateNonSharedCollection(allocator2_client.get(),
                                                                  collection_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    status = fuchsia_sysmem_BufferCollectionSync(collection_client.get());
    ASSERT_EQ(status, ZX_OK, "");

    return ZX_OK;
}

} // namespace

extern "C" bool test_sysmem_driver_connection(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator2_client;
    status = connect_to_sysmem_driver(&allocator2_client);
    ASSERT_EQ(status, ZX_OK, "");

    status = verify_connectivity(allocator2_client);
    ASSERT_EQ(status, ZX_OK, "");

    END_TEST;
}

extern "C" bool test_sysmem_service_connection(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator2_client;
    status = connect_to_sysmem_service(&allocator2_client);
    ASSERT_EQ(status, ZX_OK, "");

    status = verify_connectivity(allocator2_client);
    ASSERT_EQ(status, ZX_OK, "");

    END_TEST;
}

extern "C" bool test_sysmem_token_one_participant_no_image_constraints(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator2_client;
    status = connect_to_sysmem_driver(&allocator2_client);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client;
    zx::channel token_server;
    status = zx::channel::create(0, &token_client, &token_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fuchsia_sysmem_AllocatorAllocateSharedCollection(allocator2_client.get(),
                                                               token_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client;
    zx::channel collection_server;
    status = zx::channel::create(0, &collection_client, &collection_server);
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator2_client.get(), token_client.release(), collection_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    BufferCollectionConstraints constraints(BufferCollectionConstraints::Default);
    constraints->usage.cpu = fuchsia_sysmem_cpuUsageReadOften | fuchsia_sysmem_cpuUsageWriteOften;
    constraints->min_buffer_count_for_camping = 3;
    constraints->has_buffer_memory_constraints = true;
    constraints->buffer_memory_constraints = fuchsia_sysmem_BufferMemoryConstraints{
        .min_size_bytes = 64 * 1024,
        .max_size_bytes = 128 * 1024,
        .physically_contiguous_required = false,
        .secure_required = false,
        .ram_domain_supported = false,
        .cpu_domain_supported = true,
        .inaccessible_domain_supported = false,
        .heap_permitted_count = 0,
        .heap_permitted = {},
    };
    ZX_DEBUG_ASSERT(constraints->image_format_constraints_count == 0);
    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client.get(), true,
                                                           constraints.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx_status_t allocation_status;
    BufferCollectionInfo buffer_collection_info(BufferCollectionInfo::Default);
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client.get(), &allocation_status, buffer_collection_info.get());
    // This is the first round-trip to/from sysmem.  A failure here can be due
    // to any step above failing async.
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");

    ASSERT_EQ(buffer_collection_info->buffer_count, 3, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.size_bytes, 64 * 1024, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.is_physically_contiguous, false, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.is_secure, false, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.coherency_domain,
              fuchsia_sysmem_CoherencyDomain_Cpu, "");
    ASSERT_EQ(buffer_collection_info->settings.has_image_format_constraints, false, "");

    for (uint32_t i = 0; i < 64; ++i) {
        if (i < 3) {
            ASSERT_NE(buffer_collection_info->buffers[i].vmo, ZX_HANDLE_INVALID, "");
            uint64_t size_bytes = 0;
            status = zx_vmo_get_size(buffer_collection_info->buffers[i].vmo, &size_bytes);
            ASSERT_EQ(status, ZX_OK, "");
            ASSERT_EQ(size_bytes, 64 * 1024, "");
        } else {
            ASSERT_EQ(buffer_collection_info->buffers[i].vmo, ZX_HANDLE_INVALID, "");
        }
    }

    END_TEST;
}

extern "C" bool test_sysmem_token_one_participant_with_image_constraints(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator2_client;
    status = connect_to_sysmem_driver(&allocator2_client);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client;
    zx::channel token_server;
    status = zx::channel::create(0, &token_client, &token_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fuchsia_sysmem_AllocatorAllocateSharedCollection(allocator2_client.get(),
                                                               token_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client;
    zx::channel collection_server;
    status = zx::channel::create(0, &collection_client, &collection_server);
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator2_client.get(), token_client.release(), collection_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    BufferCollectionConstraints constraints(BufferCollectionConstraints::Default);
    constraints->usage.cpu = fuchsia_sysmem_cpuUsageReadOften | fuchsia_sysmem_cpuUsageWriteOften;
    constraints->min_buffer_count_for_camping = 3;
    constraints->has_buffer_memory_constraints = true;
    constraints->buffer_memory_constraints = fuchsia_sysmem_BufferMemoryConstraints{
        // This min_size_bytes is intentionally too small to hold the min_coded_width and
        // min_coded_height in NV12
        // format.
        .min_size_bytes = 64 * 1024,
        .max_size_bytes = 128 * 1024,
        .physically_contiguous_required = false,
        .secure_required = false,
        .ram_domain_supported = false,
        .cpu_domain_supported = true,
        .inaccessible_domain_supported = false,
        .heap_permitted_count = 0,
        .heap_permitted = {},
    };
    constraints->image_format_constraints_count = 1;
    fuchsia_sysmem_ImageFormatConstraints& image_constraints =
        constraints->image_format_constraints[0];
    image_constraints.pixel_format.type = fuchsia_sysmem_PixelFormatType_NV12;
    image_constraints.color_spaces_count = 1;
    image_constraints.color_space[0] = fuchsia_sysmem_ColorSpace{
        .type = fuchsia_sysmem_ColorSpaceType_REC709,
    };
    // The min dimensions intentionally imply a min size that's larger than
    // buffer_memory_constraints.min_size_bytes.
    image_constraints.min_coded_width = 256;
    image_constraints.max_coded_width = std::numeric_limits<uint32_t>::max();
    image_constraints.min_coded_height = 256;
    image_constraints.max_coded_height = std::numeric_limits<uint32_t>::max();
    image_constraints.min_bytes_per_row = 256;
    image_constraints.max_bytes_per_row = std::numeric_limits<uint32_t>::max();
    image_constraints.max_coded_width_times_coded_height = std::numeric_limits<uint32_t>::max();
    image_constraints.layers = 1;
    image_constraints.coded_width_divisor = 2;
    image_constraints.coded_height_divisor = 2;
    image_constraints.bytes_per_row_divisor = 2;
    image_constraints.start_offset_divisor = 2;
    image_constraints.display_width_divisor = 1;
    image_constraints.display_height_divisor = 1;

    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client.get(), true,
                                                           constraints.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx_status_t allocation_status;
    BufferCollectionInfo buffer_collection_info(BufferCollectionInfo::Default);
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client.get(), &allocation_status, buffer_collection_info.get());
    // This is the first round-trip to/from sysmem.  A failure here can be due
    // to any step above failing async.
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");

    ASSERT_EQ(buffer_collection_info->buffer_count, 3, "");
    // The size should be sufficient for the whole NV12 frame, not just min_size_bytes.
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.size_bytes, 64 * 1024 * 3 / 2, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.is_physically_contiguous, false, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.is_secure, false, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.coherency_domain,
              fuchsia_sysmem_CoherencyDomain_Cpu, "");
    // We specified image_format_constraints so the result must also have
    // image_format_constraints.
    ASSERT_EQ(buffer_collection_info->settings.has_image_format_constraints, true, "");

    for (uint32_t i = 0; i < 64; ++i) {
        if (i < 3) {
            ASSERT_NE(buffer_collection_info->buffers[i].vmo, ZX_HANDLE_INVALID, "");
            uint64_t size_bytes = 0;
            status = zx_vmo_get_size(buffer_collection_info->buffers[i].vmo, &size_bytes);
            ASSERT_EQ(status, ZX_OK, "");
            // The portion of the VMO the client can use is large enough to hold the min image size,
            // despite the min buffer size being smaller.
            ASSERT_GE(buffer_collection_info->settings.buffer_settings.size_bytes,
                      64 * 1024 * 3 / 2, "");
            // The vmo has room for the nominal size of the portion of the VMO the client can use.
            ASSERT_LE(buffer_collection_info->buffers[i].vmo_usable_start +
                          buffer_collection_info->settings.buffer_settings.size_bytes,
                      size_bytes, "");
        } else {
            ASSERT_EQ(buffer_collection_info->buffers[i].vmo, ZX_HANDLE_INVALID, "");
        }
    }

    END_TEST;
}

extern "C" bool test_sysmem_min_buffer_count(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator_client;
    status = connect_to_sysmem_driver(&allocator_client);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client;
    zx::channel token_server;
    status = zx::channel::create(0, &token_client, &token_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fuchsia_sysmem_AllocatorAllocateSharedCollection(allocator_client.get(),
                                                              token_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client;
    zx::channel collection_server;
    status = zx::channel::create(0, &collection_client, &collection_server);
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator_client.get(), token_client.release(), collection_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    BufferCollectionConstraints constraints(BufferCollectionConstraints::Default);
    constraints->usage.cpu = fuchsia_sysmem_cpuUsageReadOften | fuchsia_sysmem_cpuUsageWriteOften;
    constraints->min_buffer_count_for_camping = 3;
    constraints->min_buffer_count = 5;
    constraints->has_buffer_memory_constraints = true;
    constraints->buffer_memory_constraints = fuchsia_sysmem_BufferMemoryConstraints{
        .min_size_bytes = 64 * 1024,
        .max_size_bytes = 128 * 1024,
        .physically_contiguous_required = false,
        .secure_required = false,
        .ram_domain_supported = false,
        .cpu_domain_supported = true,
        .inaccessible_domain_supported = false,
        .heap_permitted_count = 0,
        .heap_permitted = {},
    };
    ZX_DEBUG_ASSERT(constraints->image_format_constraints_count == 0);
    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client.get(), true,
                                                           constraints.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx_status_t allocation_status;
    BufferCollectionInfo buffer_collection_info(BufferCollectionInfo::Default);
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client.get(), &allocation_status, buffer_collection_info.get());
    // This is the first round-trip to/from sysmem.  A failure here can be due
    // to any step above failing async.
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");

    ASSERT_EQ(buffer_collection_info->buffer_count, 5, "");

    END_TEST;
}

extern "C" bool test_sysmem_no_token(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator2_client;
    status = connect_to_sysmem_driver(&allocator2_client);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client;
    zx::channel collection_server;
    status = zx::channel::create(0, &collection_client, &collection_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fuchsia_sysmem_AllocatorAllocateNonSharedCollection(allocator2_client.get(),
                                                                  collection_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    BufferCollectionConstraints constraints(BufferCollectionConstraints::Default);
    constraints->usage.cpu = fuchsia_sysmem_cpuUsageReadOften | fuchsia_sysmem_cpuUsageWriteOften;
    // Ask for display usage to encourage using the ram coherency domain.
    constraints->usage.display = fuchsia_sysmem_displayUsageLayer;
    constraints->min_buffer_count_for_camping = 3;
    constraints->has_buffer_memory_constraints = true;
    constraints->buffer_memory_constraints = fuchsia_sysmem_BufferMemoryConstraints{
        .min_size_bytes = 64 * 1024,
        .max_size_bytes = 128 * 1024,
        .physically_contiguous_required = false,
        .secure_required = false,
        .ram_domain_supported = true,
        .cpu_domain_supported = true,
        .inaccessible_domain_supported = false,
        .heap_permitted_count = 0,
        .heap_permitted = {},
    };
    ZX_DEBUG_ASSERT(constraints->image_format_constraints_count == 0);
    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client.get(), true,
                                                           constraints.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx_status_t allocation_status;
    BufferCollectionInfo buffer_collection_info(BufferCollectionInfo::Default);
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client.get(), &allocation_status, buffer_collection_info.get());
    // This is the first round-trip to/from sysmem.  A failure here can be due
    // to any step above failing async.
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");

    ASSERT_EQ(buffer_collection_info->buffer_count, 3, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.size_bytes, 64 * 1024, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.is_physically_contiguous, false, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.is_secure, false, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.coherency_domain,
              fuchsia_sysmem_CoherencyDomain_Ram, "");
    ASSERT_EQ(buffer_collection_info->settings.has_image_format_constraints, false, "");

    for (uint32_t i = 0; i < 64; ++i) {
        if (i < 3) {
            ASSERT_NE(buffer_collection_info->buffers[i].vmo, ZX_HANDLE_INVALID, "");
            uint64_t size_bytes = 0;
            status = zx_vmo_get_size(buffer_collection_info->buffers[i].vmo, &size_bytes);
            ASSERT_EQ(status, ZX_OK, "");
            ASSERT_EQ(size_bytes, 64 * 1024, "");
        } else {
            ASSERT_EQ(buffer_collection_info->buffers[i].vmo, ZX_HANDLE_INVALID, "");
        }
    }

    END_TEST;
}

extern "C" bool test_sysmem_multiple_participants(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator2_client_1;
    status = connect_to_sysmem_driver(&allocator2_client_1);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client_1;
    zx::channel token_server_1;
    status = zx::channel::create(0, &token_client_1, &token_server_1);
    ASSERT_EQ(status, ZX_OK, "");

    // Client 1 creates a token and new LogicalBufferCollection using
    // AllocateSharedCollection().
    status = fuchsia_sysmem_AllocatorAllocateSharedCollection(allocator2_client_1.get(),
                                                               token_server_1.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client_2;
    zx::channel token_server_2;
    status = zx::channel::create(0, &token_client_2, &token_server_2);
    ASSERT_EQ(status, ZX_OK, "");

    // Client 1 duplicates its token and gives the duplicate to client 2 (this
    // test is single proc, so both clients are coming from this client
    // process - normally the two clients would be in separate processes with
    // token_client_2 transferred to another participant).
    status = fuchsia_sysmem_BufferCollectionTokenDuplicate(
        token_client_1.get(), std::numeric_limits<uint32_t>::max(), token_server_2.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client_3;
    zx::channel token_server_3;
    status = zx::channel::create(0, &token_client_3, &token_server_3);
    ASSERT_EQ(status, ZX_OK, "");

    // Client 3 is used to test a participant that doesn't set any constraints
    // and only wants a notification that the allocation is done.
    status = fuchsia_sysmem_BufferCollectionTokenDuplicate(
        token_client_1.get(), std::numeric_limits<uint32_t>::max(), token_server_3.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client_1;
    zx::channel collection_server_1;
    status = zx::channel::create(0, &collection_client_1, &collection_server_1);
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client_1.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator2_client_1.get(), token_client_1.release(), collection_server_1.release());
    ASSERT_EQ(status, ZX_OK, "");

    BufferCollectionConstraints constraints_1(BufferCollectionConstraints::Default);
    constraints_1->usage.cpu = fuchsia_sysmem_cpuUsageReadOften | fuchsia_sysmem_cpuUsageWriteOften;
    constraints_1->min_buffer_count_for_camping = 3;
    constraints_1->has_buffer_memory_constraints = true;
    constraints_1->buffer_memory_constraints = fuchsia_sysmem_BufferMemoryConstraints{
        // This min_size_bytes is intentionally too small to hold the min_coded_width and
        // min_coded_height in NV12
        // format.
        .min_size_bytes = 64 * 1024,
        // Allow a max that's just large enough to accomodate the size implied
        // by the min frame size and PixelFormat.
        .max_size_bytes = (512 * 512) * 3 / 2,
        .physically_contiguous_required = false,
        .secure_required = false,
        .ram_domain_supported = false,
        .cpu_domain_supported = true,
        .inaccessible_domain_supported = false,
        .heap_permitted_count = 0,
        .heap_permitted = {},
    };
    constraints_1->image_format_constraints_count = 1;
    fuchsia_sysmem_ImageFormatConstraints& image_constraints_1 =
        constraints_1->image_format_constraints[0];
    image_constraints_1.pixel_format.type = fuchsia_sysmem_PixelFormatType_NV12;
    image_constraints_1.color_spaces_count = 1;
    image_constraints_1.color_space[0] = fuchsia_sysmem_ColorSpace{
        .type = fuchsia_sysmem_ColorSpaceType_REC709,
    };
    // The min dimensions intentionally imply a min size that's larger than
    // buffer_memory_constraints.min_size_bytes.
    image_constraints_1.min_coded_width = 256;
    image_constraints_1.max_coded_width = std::numeric_limits<uint32_t>::max();
    image_constraints_1.min_coded_height = 256;
    image_constraints_1.max_coded_height = std::numeric_limits<uint32_t>::max();
    image_constraints_1.min_bytes_per_row = 256;
    image_constraints_1.max_bytes_per_row = std::numeric_limits<uint32_t>::max();
    image_constraints_1.max_coded_width_times_coded_height = std::numeric_limits<uint32_t>::max();
    image_constraints_1.layers = 1;
    image_constraints_1.coded_width_divisor = 2;
    image_constraints_1.coded_height_divisor = 2;
    image_constraints_1.bytes_per_row_divisor = 2;
    image_constraints_1.start_offset_divisor = 2;
    image_constraints_1.display_width_divisor = 1;
    image_constraints_1.display_height_divisor = 1;

    // Start with constraints_2 a copy of constraints_1.  There are no handles
    // in the constraints struct so a struct copy instead of clone is fine here.
    BufferCollectionConstraints constraints_2(*constraints_1.get());
    // Modify constraints_2 to require double the width and height.
    constraints_2->image_format_constraints[0].min_coded_width = 512;
    constraints_2->image_format_constraints[0].min_coded_height = 512;

    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client_1.get(), true,
                                                           constraints_1.release());
    ASSERT_EQ(status, ZX_OK, "");

    // Client 2 connects to sysmem separately.
    zx::channel allocator2_client_2;
    status = connect_to_sysmem_driver(&allocator2_client_2);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client_2;
    zx::channel collection_server_2;
    status = zx::channel::create(0, &collection_client_2, &collection_server_2);
    ASSERT_EQ(status, ZX_OK, "");

    // Just because we can, perform this sync as late as possible, just before
    // the BindSharedCollection() via allocator2_client_2.  Without this Sync(),
    // the BindSharedCollection() might arrive at the server before the
    // Duplicate() that delivered the server end of token_client_2 to sysmem,
    // which would cause sysmem to not recognize the token.
    status = fuchsia_sysmem_BufferCollectionSync(collection_client_1.get());
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client_2.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator2_client_2.get(), token_client_2.release(), collection_server_2.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client_3;
    zx::channel collection_server_3;
    status = zx::channel::create(0, &collection_client_3, &collection_server_3);
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client_3.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator2_client_2.get(), token_client_3.release(), collection_server_3.release());
    ASSERT_EQ(status, ZX_OK, "");

    fuchsia_sysmem_BufferCollectionConstraints empty_constraints = {};

    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client_3.get(), false,
                                                           &empty_constraints);
    ASSERT_EQ(status, ZX_OK, "");

    // Not all constraints have been input, so the buffers haven't been
    // allocated yet.
    zx_status_t check_status;
    status = fuchsia_sysmem_BufferCollectionCheckBuffersAllocated(collection_client_1.get(), &check_status);
    ASSERT_EQ(status, ZX_OK, "");
    EXPECT_EQ(check_status, ZX_ERR_UNAVAILABLE, "");
    status = fuchsia_sysmem_BufferCollectionCheckBuffersAllocated(collection_client_2.get(), &check_status);
    ASSERT_EQ(status, ZX_OK, "");
    EXPECT_EQ(check_status, ZX_ERR_UNAVAILABLE, "");

    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client_2.get(), true,
                                                           constraints_2.release());
    ASSERT_EQ(status, ZX_OK, "");

    //
    // Only after both participants (both clients) have SetConstraints() will
    // the allocation be successful.
    //

    zx_status_t allocation_status;
    BufferCollectionInfo buffer_collection_info_1(BufferCollectionInfo::Default);
    // This helps with a later exact equality check.
    memset(buffer_collection_info_1.get(), 0, sizeof(*buffer_collection_info_1.get()));
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client_1.get(), &allocation_status, buffer_collection_info_1.get());
    // This is the first round-trip to/from sysmem.  A failure here can be due
    // to any step above failing async.
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");

    status = fuchsia_sysmem_BufferCollectionCheckBuffersAllocated(collection_client_1.get(), &check_status);
    ASSERT_EQ(status, ZX_OK, "");
    EXPECT_EQ(check_status, ZX_OK, "");
    status = fuchsia_sysmem_BufferCollectionCheckBuffersAllocated(collection_client_2.get(), &check_status);
    ASSERT_EQ(status, ZX_OK, "");
    EXPECT_EQ(check_status, ZX_OK, "");

    BufferCollectionInfo buffer_collection_info_2(BufferCollectionInfo::Default);
    // This helps with a later exact equality check.
    memset(buffer_collection_info_2.get(), 0, sizeof(*buffer_collection_info_2.get()));
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client_2.get(), &allocation_status, buffer_collection_info_2.get());
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");

    BufferCollectionInfo buffer_collection_info_3(BufferCollectionInfo::Default);
    memset(buffer_collection_info_3.get(), 0, sizeof(*buffer_collection_info_3.get()));
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client_3.get(), &allocation_status, buffer_collection_info_3.get());
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");

    //
    // buffer_collection_info_1 and buffer_collection_info_2 should be exactly
    // equal except their non-zero handle values, which should be different.  We
    // verify the handle values then check that the structs are exactly the same
    // with handle values zeroed out.
    //

    // copy_1 and copy_2 intentionally don't manage their handle values.

    // struct copy
    fuchsia_sysmem_BufferCollectionInfo_2 copy_1 = *buffer_collection_info_1.get();
    // struct copy
    fuchsia_sysmem_BufferCollectionInfo_2 copy_2 = *buffer_collection_info_2.get();
    for (uint32_t i = 0; i < fbl::count_of(buffer_collection_info_1->buffers); ++i) {
        ASSERT_EQ(buffer_collection_info_1->buffers[i].vmo != ZX_HANDLE_INVALID,
                  buffer_collection_info_2->buffers[i].vmo != ZX_HANDLE_INVALID, "");
        if (buffer_collection_info_1->buffers[i].vmo != ZX_HANDLE_INVALID) {
            // The handle values must be different.
            ASSERT_NE(buffer_collection_info_1->buffers[i].vmo,
                      buffer_collection_info_2->buffers[i].vmo, "");
            // For now, the koid(s) are expected to be equal.  This is not a
            // fundamental check, in that sysmem could legitimately change in
            // future to vend separate child VMOs (of the same portion of a
            // non-copy-on-write parent VMO) to the two participants and that
            // would still be potentially valid overall.
            zx_koid_t koid_1 = get_koid(buffer_collection_info_1->buffers[i].vmo);
            zx_koid_t koid_2 = get_koid(buffer_collection_info_2->buffers[i].vmo);
            ASSERT_EQ(koid_1, koid_2, "");

            // Prepare the copies for memcmp().
            copy_1.buffers[i].vmo = ZX_HANDLE_INVALID;
            copy_2.buffers[i].vmo = ZX_HANDLE_INVALID;
        }

        // Buffer collection 3 never got a SetConstraints(), so we get no VMOs.
        ASSERT_EQ(ZX_HANDLE_INVALID, buffer_collection_info_3->buffers[i].vmo, "");
    }
    int32_t memcmp_result = memcmp(&copy_1, &copy_2, sizeof(copy_1));
    // Check that buffer_collection_info_1 and buffer_collection_info_2 are
    // consistent.
    ASSERT_EQ(memcmp_result, 0, "");

    memcmp_result = memcmp(&copy_1, buffer_collection_info_3.get(), sizeof(copy_1));
    // Check that buffer_collection_info_1 and buffer_collection_info_3 are
    // consistent, except for the vmos.
    ASSERT_EQ(memcmp_result, 0, "");

    //
    // Verify that buffer_collection_info_1 paid attention to constraints_2, and
    // that buffer_collection_info_2 makes sense.
    //

    // Because each specified min_buffer_count_for_camping 3, and each
    // participant camping count adds together since they camp independently.
    ASSERT_EQ(buffer_collection_info_1->buffer_count, 6, "");
    // The size should be sufficient for the whole NV12 frame, not just
    // min_size_bytes.  In other words, the portion of the VMO the client can
    // use is large enough to hold the min image size, despite the min buffer
    // size being smaller.
    ASSERT_GE(buffer_collection_info_1->settings.buffer_settings.size_bytes, (512 * 512) * 3 / 2,
              "");
    ASSERT_EQ(buffer_collection_info_1->settings.buffer_settings.is_physically_contiguous, false,
              "");
    ASSERT_EQ(buffer_collection_info_1->settings.buffer_settings.is_secure, false, "");
    // We specified image_format_constraints so the result must also have
    // image_format_constraints.
    ASSERT_EQ(buffer_collection_info_1->settings.has_image_format_constraints, true, "");

    for (uint32_t i = 0; i < 64; ++i) {
        if (i < 6) {
            ASSERT_NE(buffer_collection_info_1->buffers[i].vmo, ZX_HANDLE_INVALID, "");
            ASSERT_NE(buffer_collection_info_2->buffers[i].vmo, ZX_HANDLE_INVALID, "");

            uint64_t size_bytes_1 = 0;
            status = zx_vmo_get_size(buffer_collection_info_1->buffers[i].vmo, &size_bytes_1);
            ASSERT_EQ(status, ZX_OK, "");

            uint64_t size_bytes_2 = 0;
            status = zx_vmo_get_size(buffer_collection_info_2->buffers[i].vmo, &size_bytes_2);
            ASSERT_EQ(status, ZX_OK, "");

            // The vmo has room for the nominal size of the portion of the VMO
            // the client can use.  These checks should pass even if sysmem were
            // to vend different child VMOs to the two participants.
            ASSERT_LE(buffer_collection_info_1->buffers[i].vmo_usable_start +
                          buffer_collection_info_1->settings.buffer_settings.size_bytes,
                      size_bytes_1, "");
            ASSERT_LE(buffer_collection_info_2->buffers[i].vmo_usable_start +
                          buffer_collection_info_2->settings.buffer_settings.size_bytes,
                      size_bytes_2, "");
        } else {
            ASSERT_EQ(buffer_collection_info_1->buffers[i].vmo, ZX_HANDLE_INVALID, "");
            ASSERT_EQ(buffer_collection_info_2->buffers[i].vmo, ZX_HANDLE_INVALID, "");
        }
    }

    // Close to ensure grabbing null constraints from a closed collection
    // doesn't crash
    zx_status_t close_status = fuchsia_sysmem_BufferCollectionClose(collection_client_3.get());
    EXPECT_EQ(close_status, ZX_OK, "");

    END_TEST;
}

extern "C" bool test_sysmem_constraints_retained_beyond_clean_close() {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator2_client_1;
    status = connect_to_sysmem_driver(&allocator2_client_1);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client_1;
    zx::channel token_server_1;
    status = zx::channel::create(0, &token_client_1, &token_server_1);
    ASSERT_EQ(status, ZX_OK, "");

    // Client 1 creates a token and new LogicalBufferCollection using
    // AllocateSharedCollection().
    status = fuchsia_sysmem_AllocatorAllocateSharedCollection(allocator2_client_1.get(),
                                                               token_server_1.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client_2;
    zx::channel token_server_2;
    status = zx::channel::create(0, &token_client_2, &token_server_2);
    ASSERT_EQ(status, ZX_OK, "");

    // Client 1 duplicates its token and gives the duplicate to client 2 (this
    // test is single proc, so both clients are coming from this client
    // process - normally the two clients would be in separate processes with
    // token_client_2 transferred to another participant).
    status = fuchsia_sysmem_BufferCollectionTokenDuplicate(
        token_client_1.get(), std::numeric_limits<uint32_t>::max(), token_server_2.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client_1;
    zx::channel collection_server_1;
    status = zx::channel::create(0, &collection_client_1, &collection_server_1);
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client_1.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator2_client_1.get(), token_client_1.release(), collection_server_1.release());
    ASSERT_EQ(status, ZX_OK, "");

    BufferCollectionConstraints constraints_1(BufferCollectionConstraints::Default);
    constraints_1->usage.cpu = fuchsia_sysmem_cpuUsageReadOften | fuchsia_sysmem_cpuUsageWriteOften;
    constraints_1->min_buffer_count_for_camping = 2;
    constraints_1->has_buffer_memory_constraints = true;
    constraints_1->buffer_memory_constraints = fuchsia_sysmem_BufferMemoryConstraints{
        .min_size_bytes = 64 * 1024,
        .max_size_bytes = 64 * 1024,
        .physically_contiguous_required = false,
        .secure_required = false,
        .ram_domain_supported = false,
        .cpu_domain_supported = true,
        .inaccessible_domain_supported = false,
        .heap_permitted_count = 0,
        .heap_permitted = {},
    };

    // constraints_2 is just a copy of constraints_1 - since both participants
    // specify min_buffer_count_for_camping 2, the total number of allocated
    // buffers will be 4.  There are no handles in the constraints struct so a
    // struct copy instead of clone is fine here.
    BufferCollectionConstraints constraints_2(*constraints_1.get());
    ASSERT_EQ(constraints_2->min_buffer_count_for_camping, 2, "");

    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client_1.get(), true,
                                                           constraints_1.release());
    ASSERT_EQ(status, ZX_OK, "");

    // Client 2 connects to sysmem separately.
    zx::channel allocator2_client_2;
    status = connect_to_sysmem_driver(&allocator2_client_2);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client_2;
    zx::channel collection_server_2;
    status = zx::channel::create(0, &collection_client_2, &collection_server_2);
    ASSERT_EQ(status, ZX_OK, "");

    // Just because we can, perform this sync as late as possible, just before
    // the BindSharedCollection() via allocator2_client_2.  Without this Sync(),
    // the BindSharedCollection() might arrive at the server before the
    // Duplicate() that delivered the server end of token_client_2 to sysmem,
    // which would cause sysmem to not recognize the token.
    status = fuchsia_sysmem_BufferCollectionSync(collection_client_1.get());
    ASSERT_EQ(status, ZX_OK, "");

    // client 1 will now do a clean Close(), but client 1's constraints will be
    // retained by the LogicalBufferCollection.
    status = fuchsia_sysmem_BufferCollectionClose(collection_client_1.get());
    ASSERT_EQ(status, ZX_OK, "");
    // close client 1's channel.
    collection_client_1.reset();

    // Wait briefly so that LogicalBufferCollection will have seen the channel
    // closure of client 1 before client 2 sets constraints.  If we wanted to
    // eliminate this sleep we could add a call to query how many
    // BufferCollection views still exist per LogicalBufferCollection, but that
    // call wouldn't be meant to be used by normal clients, so it seems best to
    // avoid adding such a call.
    status = zx_nanosleep(zx_deadline_after(ZX_MSEC(250)));
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client_2.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator2_client_2.get(), token_client_2.release(), collection_server_2.release());
    ASSERT_EQ(status, ZX_OK, "");

    // Not all constraints have been input (client 2 hasn't SetConstraints()
    // yet), so the buffers haven't been allocated yet.
    zx_status_t check_status;
    status = fuchsia_sysmem_BufferCollectionCheckBuffersAllocated(collection_client_2.get(), &check_status);
    ASSERT_EQ(status, ZX_OK, "");
    EXPECT_EQ(check_status, ZX_ERR_UNAVAILABLE, "");

    status = fuchsia_sysmem_BufferCollectionSetConstraints(collection_client_2.get(), true,
                                                           constraints_2.release());
    ASSERT_EQ(status, ZX_OK, "");

    //
    // Now that client 2 has SetConstraints(), the allocation will proceed, with
    // client 1's constraints included despite client 1 having done a clean
    // Close().
    //

    zx_status_t allocation_status;
    BufferCollectionInfo buffer_collection_info_2(BufferCollectionInfo::Default);
    // This helps with a later exact equality check.
    memset(buffer_collection_info_2.get(), 0, sizeof(*buffer_collection_info_2.get()));
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client_2.get(), &allocation_status, buffer_collection_info_2.get());
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");

    // The fact that this is 4 instead of 2 proves that client 1's constraints
    // were taken into account.
    ASSERT_EQ(buffer_collection_info_2->buffer_count, 4, "");

    END_TEST;
}

extern "C" bool test_sysmem_heap_constraints(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator_client;
    status = connect_to_sysmem_driver(&allocator_client);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client;
    zx::channel token_server;
    status = zx::channel::create(0, &token_client, &token_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fuchsia_sysmem_AllocatorAllocateSharedCollection(
        allocator_client.get(), token_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client;
    zx::channel collection_server;
    status = zx::channel::create(0, &collection_client, &collection_server);
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator_client.get(), token_client.release(),
        collection_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    BufferCollectionConstraints constraints(
        BufferCollectionConstraints::Default);
    constraints->usage.vulkan = fuchsia_sysmem_vulkanUsageTransferDst;
    constraints->min_buffer_count_for_camping = 1;
    constraints->has_buffer_memory_constraints = true;
    constraints->buffer_memory_constraints =
        fuchsia_sysmem_BufferMemoryConstraints{
            .min_size_bytes = 4 * 1024,
            .max_size_bytes = 4 * 1024,
            .physically_contiguous_required = true,
            .secure_required = false,
            .ram_domain_supported = false,
            .cpu_domain_supported = false,
            .inaccessible_domain_supported = true,
            .heap_permitted_count = 1,
            .heap_permitted = {fuchsia_sysmem_HeapType_SYSTEM_RAM}};

    status = fuchsia_sysmem_BufferCollectionSetConstraints(
        collection_client.get(), true, constraints.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx_status_t allocation_status;
    BufferCollectionInfo buffer_collection_info(BufferCollectionInfo::Default);
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client.get(), &allocation_status,
        buffer_collection_info.get());
    // This is the first round-trip to/from sysmem.  A failure here can be due
    // to any step above failing async.
    ASSERT_EQ(status, ZX_OK, "");
    ASSERT_EQ(allocation_status, ZX_OK, "");
    ASSERT_EQ(buffer_collection_info->buffer_count, 1, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.coherency_domain,
              fuchsia_sysmem_CoherencyDomain_Inaccessible, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings.heap,
              fuchsia_sysmem_HeapType_SYSTEM_RAM, "");
    ASSERT_EQ(buffer_collection_info->settings.buffer_settings
                  .is_physically_contiguous,
               true, "");

    END_TEST;
}

extern "C" bool test_sysmem_cpu_usage_and_inaccessible_domain_fails(void) {
    BEGIN_TEST;

    zx_status_t status;
    zx::channel allocator_client;
    status = connect_to_sysmem_driver(&allocator_client);
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel token_client;
    zx::channel token_server;
    status = zx::channel::create(0, &token_client, &token_server);
    ASSERT_EQ(status, ZX_OK, "");

    status = fuchsia_sysmem_AllocatorAllocateSharedCollection(
        allocator_client.get(), token_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx::channel collection_client;
    zx::channel collection_server;
    status = zx::channel::create(0, &collection_client, &collection_server);
    ASSERT_EQ(status, ZX_OK, "");

    ASSERT_NE(token_client.get(), ZX_HANDLE_INVALID, "");
    status = fuchsia_sysmem_AllocatorBindSharedCollection(
        allocator_client.get(), token_client.release(),
        collection_server.release());
    ASSERT_EQ(status, ZX_OK, "");

    BufferCollectionConstraints constraints(
        BufferCollectionConstraints::Default);
    constraints->usage.cpu = fuchsia_sysmem_cpuUsageReadOften | fuchsia_sysmem_cpuUsageWriteOften;
    constraints->min_buffer_count_for_camping = 1;
    constraints->has_buffer_memory_constraints = true;
    constraints->buffer_memory_constraints =
        fuchsia_sysmem_BufferMemoryConstraints{
            .min_size_bytes = 4 * 1024,
            .max_size_bytes = 4 * 1024,
            .physically_contiguous_required = true,
            .secure_required = false,
            .ram_domain_supported = false,
            .cpu_domain_supported = false,
            .inaccessible_domain_supported = true,
            .heap_permitted_count = 1,
            .heap_permitted = {fuchsia_sysmem_HeapType_SYSTEM_RAM}};

    status = fuchsia_sysmem_BufferCollectionSetConstraints(
        collection_client.get(), true, constraints.release());
    ASSERT_EQ(status, ZX_OK, "");

    zx_status_t allocation_status;
    BufferCollectionInfo buffer_collection_info(BufferCollectionInfo::Default);
    status = fuchsia_sysmem_BufferCollectionWaitForBuffersAllocated(
        collection_client.get(), &allocation_status,
        buffer_collection_info.get());
    // usage.cpu != 0 && inaccessible_domain_supported is expected to result in failure to
    // allocate.
    ASSERT_NE(status, ZX_OK, "");

    END_TEST;
}

// TODO(dustingreen): Add tests to cover more failure cases.

// clang-format off
BEGIN_TEST_CASE(sysmem_tests)
    RUN_TEST(test_sysmem_driver_connection)
    RUN_TEST(test_sysmem_service_connection)
    RUN_TEST(test_sysmem_token_one_participant_no_image_constraints)
    RUN_TEST(test_sysmem_token_one_participant_with_image_constraints)
    RUN_TEST(test_sysmem_min_buffer_count)
    RUN_TEST(test_sysmem_no_token)
    RUN_TEST(test_sysmem_multiple_participants)
    RUN_TEST(test_sysmem_constraints_retained_beyond_clean_close)
    RUN_TEST(test_sysmem_heap_constraints)
    RUN_TEST(test_sysmem_cpu_usage_and_inaccessible_domain_fails)
END_TEST_CASE(sysmem_tests)
// clang-format on