// Copyright (C) 2018 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <gtest/gtest.h>

#include "VulkanStream.h"

#include <string.h>
#include <vulkan.h>

#include "render-utils/IOStream.h"
#include "android/base/ArraySize.h"
#include "android/base/BumpPool.h"
#include "common/goldfish_vk_deepcopy.h"
#include "common/goldfish_vk_extension_structs.h"
#include "common/goldfish_vk_marshaling.h"
#include "common/goldfish_vk_reserved_marshaling.h"
#include "common/goldfish_vk_testing.h"

namespace gfxstream {
namespace vk {
namespace {

using android::base::arraySize;

class TestStream : public IOStream {
   public:
    static constexpr size_t kBufSize = 1024;
    TestStream() : IOStream(kBufSize) {}

   protected:
    void* getDmaForReading(uint64_t guest_paddr) override { return nullptr; }
    void unlockDma(uint64_t guest_paddr) override {}

    // VulkanStream should never use these functions.
    void* allocBuffer(size_t minSize) override {
        fprintf(stderr, "%s: FATAL: not intended for use!\n", __func__);
        abort();
    }

    int commitBuffer(size_t size) override {
        fprintf(stderr, "%s: FATAL: not intended for use!\n", __func__);
        abort();
    }

    const unsigned char* readRaw(void* buf, size_t* inout_len) override {
        fprintf(stderr, "%s: FATAL: not intended for use!\n", __func__);
        abort();
    }

    void onSave(android::base::Stream*) override {
        fprintf(stderr, "%s: FATAL: not intended for use!\n", __func__);
        abort();
    }

    virtual unsigned char* onLoad(android::base::Stream*) override {
        fprintf(stderr, "%s: FATAL: not intended for use!\n", __func__);
        abort();
    }

    int writeFully(const void* buffer, size_t size) override {
        if (mBuffer.size() < mWriteCursor + size) {
            mBuffer.resize(mWriteCursor + size);
        }

        memcpy(mBuffer.data() + mWriteCursor, buffer, size);

        mWriteCursor += size;

        if (mReadCursor == mWriteCursor) {
            clear();
        }
        return 0;
    }

    const unsigned char* readFully(void* buf, size_t len) override {
        EXPECT_LE(mReadCursor + len, mBuffer.size());
        memcpy(buf, mBuffer.data() + mReadCursor, len);

        mReadCursor += len;

        if (mReadCursor == mWriteCursor) {
            clear();
        }
        return (unsigned char*)buf;
    }

   private:
    void clear() {
        mBuffer.clear();
        mReadCursor = 0;
        mWriteCursor = 0;
    }

    size_t mReadCursor = 0;
    size_t mWriteCursor = 0;
    std::vector<char> mBuffer;
};

// Just see whether the test class is OK
TEST(VulkanStream, Basic) {
    TestStream testStream;
    VulkanStream stream(&testStream);

    const uint32_t testInt = 6;
    stream.putBe32(testInt);
    EXPECT_EQ(testInt, stream.getBe32());

    const std::string testString = "Hello World";
    stream.putString(testString);
    EXPECT_EQ(testString, stream.getString());
}

// Try a "basic" Vulkan struct (VkInstanceCreateInfo)
TEST(VulkanStream, testMarshalVulkanStruct) {
    TestStream testStream;
    VulkanStream stream(&testStream);

    VkApplicationInfo appInfo = {
        VK_STRUCTURE_TYPE_APPLICATION_INFO,
        0,                         // pNext
        "VulkanStreamTest",        // application name
        6,                         // application version
        "VulkanStreamTestEngine",  // engine name
        4,                         // engine version,
        VK_API_VERSION_1_0,
    };

    const char* const layerNames[] = {
        "layer0",
        "layer1: test layer",
    };

    const char* const extensionNames[] = {
        "VK_KHR_8bit_storage",
        "VK_KHR_android_surface",
        "VK_MVK_macos_surface",
    };

    VkInstanceCreateInfo forMarshaling = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
                                          0,         // pNext
                                          0,         // flags,
                                          &appInfo,  // pApplicationInfo,
                                          arraySize(layerNames),
                                          layerNames,
                                          arraySize(extensionNames),
                                          extensionNames};

    marshal_VkInstanceCreateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);

    VkInstanceCreateInfo forUnmarshaling;
    memset(&forUnmarshaling, 0x0, sizeof(VkInstanceCreateInfo));

    // Before unmarshaling, these structs should be different.
    // Test that the generated comparator can detect inequality.
    int inequalities = 0;
    checkEqual_VkInstanceCreateInfo(&forMarshaling, &forUnmarshaling,
                                    [&inequalities](const char* errMsg) {
                                        (void)errMsg;
                                        ++inequalities;
                                    });

    EXPECT_GT(inequalities, 0);

    unmarshal_VkInstanceCreateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);

    // Check that the strings are equal as well.

    EXPECT_STREQ(forMarshaling.pApplicationInfo->pApplicationName,
                 forUnmarshaling.pApplicationInfo->pApplicationName);

    EXPECT_STREQ(forMarshaling.pApplicationInfo->pEngineName,
                 forUnmarshaling.pApplicationInfo->pEngineName);

    for (size_t i = 0; i < arraySize(layerNames); ++i) {
        EXPECT_STREQ(forMarshaling.ppEnabledLayerNames[i], forUnmarshaling.ppEnabledLayerNames[i]);
    }

    for (size_t i = 0; i < arraySize(extensionNames); ++i) {
        EXPECT_STREQ(forMarshaling.ppEnabledExtensionNames[i],
                     forUnmarshaling.ppEnabledExtensionNames[i]);
    }

    EXPECT_EQ(forMarshaling.sType, forUnmarshaling.sType);
    EXPECT_EQ(forMarshaling.pNext, forUnmarshaling.pNext);
    EXPECT_EQ(forMarshaling.flags, forUnmarshaling.flags);
    EXPECT_EQ(forMarshaling.pApplicationInfo->sType, forUnmarshaling.pApplicationInfo->sType);
    EXPECT_EQ(forMarshaling.pApplicationInfo->apiVersion,
              forUnmarshaling.pApplicationInfo->apiVersion);

    checkEqual_VkInstanceCreateInfo(&forMarshaling, &forUnmarshaling,
                                    [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });
}

// Try a Vulkan struct that has non-ptr structs in it
TEST(VulkanStream, testMarshalVulkanStructWithNonPtrStruct) {
    TestStream testStream;
    VulkanStream stream(&testStream);

    VkPhysicalDeviceProperties forMarshaling = {
        VK_API_VERSION_1_0,
        0,
        0x8086,
        0x7800,
        VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
        "Intel740",
        "123456789abcdef",
        {
            0x00,             // maxImageDimension1D;
            0x01,             // maxImageDimension2D;
            0x02,             // maxImageDimension3D;
            0x03,             // maxImageDimensionCube;
            0x04,             // maxImageArrayLayers;
            0x05,             // maxTexelBufferElements;
            0x06,             // maxUniformBufferRange;
            0x07,             // maxStorageBufferRange;
            0x08,             // maxPushConstantsSize;
            0x09,             // maxMemoryAllocationCount;
            0x0a,             // maxSamplerAllocationCount;
            0x0b,             // bufferImageGranularity;
            0x0c,             // sparseAddressSpaceSize;
            0x0d,             // maxBoundDescriptorSets;
            0x0e,             // maxPerStageDescriptorSamplers;
            0x0f,             // maxPerStageDescriptorUniformBuffers;
            0x10,             // maxPerStageDescriptorStorageBuffers;
            0x11,             // maxPerStageDescriptorSampledImages;
            0x12,             // maxPerStageDescriptorStorageImages;
            0x13,             // maxPerStageDescriptorInputAttachments;
            0x14,             // maxPerStageResources;
            0x15,             // maxDescriptorSetSamplers;
            0x16,             // maxDescriptorSetUniformBuffers;
            0x17,             // maxDescriptorSetUniformBuffersDynamic;
            0x18,             // maxDescriptorSetStorageBuffers;
            0x19,             // maxDescriptorSetStorageBuffersDynamic;
            0x1a,             // maxDescriptorSetSampledImages;
            0x1b,             // maxDescriptorSetStorageImages;
            0x1c,             // maxDescriptorSetInputAttachments;
            0x1d,             // maxVertexInputAttributes;
            0x1e,             // maxVertexInputBindings;
            0x1f,             // maxVertexInputAttributeOffset;
            0x20,             // maxVertexInputBindingStride;
            0x21,             // maxVertexOutputComponents;
            0x22,             // maxTessellationGenerationLevel;
            0x23,             // maxTessellationPatchSize;
            0x24,             // maxTessellationControlPerVertexInputComponents;
            0x25,             // maxTessellationControlPerVertexOutputComponents;
            0x26,             // maxTessellationControlPerPatchOutputComponents;
            0x27,             // maxTessellationControlTotalOutputComponents;
            0x28,             // maxTessellationEvaluationInputComponents;
            0x29,             // maxTessellationEvaluationOutputComponents;
            0x2a,             // maxGeometryShaderInvocations;
            0x2b,             // maxGeometryInputComponents;
            0x2c,             // maxGeometryOutputComponents;
            0x2d,             // maxGeometryOutputVertices;
            0x2e,             // maxGeometryTotalOutputComponents;
            0x2f,             // maxFragmentInputComponents;
            0x30,             // maxFragmentOutputAttachments;
            0x31,             // maxFragmentDualSrcAttachments;
            0x32,             // maxFragmentCombinedOutputResources;
            0x33,             // maxComputeSharedMemorySize;
            {0x1, 0x2, 0x3},  // maxComputeWorkGroupCount[3];
            0x35,             // maxComputeWorkGroupInvocations;
            {0x4, 0x5, 0x6},  // maxComputeWorkGroupSize[3];
            0x37,             // subPixelPrecisionBits;
            0x38,             // subTexelPrecisionBits;
            0x39,             // mipmapPrecisionBits;
            0x3a,             // maxDrawIndexedIndexValue;
            0x3b,             // maxDrawIndirectCount;
            1.0f,             // maxSamplerLodBias;
            1.0f,             // maxSamplerAnisotropy;
            0x3e,             // maxViewports;
            {0x7, 0x8},       // maxViewportDimensions[2];
            {0.4f, 0.5f},     // viewportBoundsRange[2];
            0x41,             // viewportSubPixelBits;
            0x42,             // minMemoryMapAlignment;
            0x43,             // minTexelBufferOffsetAlignment;
            0x44,             // minUniformBufferOffsetAlignment;
            0x45,             // minStorageBufferOffsetAlignment;
            0x46,             // minTexelOffset;
            0x47,             // maxTexelOffset;
            0x48,             // minTexelGatherOffset;
            0x49,             // maxTexelGatherOffset;
            10.0f,            // minInterpolationOffset;
            11.0f,            // maxInterpolationOffset;
            0x4c,             // subPixelInterpolationOffsetBits;
            0x4d,             // maxFramebufferWidth;
            0x4e,             // maxFramebufferHeight;
            0x4f,             // maxFramebufferLayers;
            0x50,             // framebufferColorSampleCounts;
            0x51,             // framebufferDepthSampleCounts;
            0x52,             // framebufferStencilSampleCounts;
            0x53,             // framebufferNoAttachmentsSampleCounts;
            0x54,             // maxColorAttachments;
            0x55,             // sampledImageColorSampleCounts;
            0x56,             // sampledImageIntegerSampleCounts;
            0x57,             // sampledImageDepthSampleCounts;
            0x58,             // sampledImageStencilSampleCounts;
            0x59,             // storageImageSampleCounts;
            0x5a,             // maxSampleMaskWords;
            0x5b,             // timestampComputeAndGraphics;
            100.0f,           // timestampPeriod;
            0x5d,             // maxClipDistances;
            0x5e,             // maxCullDistances;
            0x5f,             // maxCombinedClipAndCullDistances;
            0x60,             // discreteQueuePriorities;
            {0.0f, 1.0f},     // pointSizeRange[2];
            {1.0f, 2.0f},     // lineWidthRange[2];
            3.0f,             // pointSizeGranularity;
            4.0f,             // lineWidthGranularity;
            0x65,             // strictLines;
            0x66,             // standardSampleLocations;
            0x67,             // optimalBufferCopyOffsetAlignment;
            0x68,             // optimalBufferCopyRowPitchAlignment;
            0x69,             // nonCoherentAtomSize;
        },
        {
            0xff,  // residencyStandard2DBlockShape;
            0x00,  // residencyStandard2DMultisampleBlockShape;
            0x11,  // residencyStandard3DBlockShape;
            0x22,  // residencyAlignedMipSize;
            0x33,  // residencyNonResidentStrict;
        },
    };

    marshal_VkPhysicalDeviceProperties(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);

    VkPhysicalDeviceProperties forUnmarshaling;
    memset(&forUnmarshaling, 0x0, sizeof(VkPhysicalDeviceLimits));

    // Test the autogenerated testing code
    int inequalities = 0;
    checkEqual_VkPhysicalDeviceProperties(&forMarshaling, &forUnmarshaling,
                                          [&inequalities](const char* errMsg) {
                                              (void)errMsg;
                                              ++inequalities;
                                          });

    EXPECT_GT(inequalities, 0);

    unmarshal_VkPhysicalDeviceProperties(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);

    // Test the autogenerated testing code
    EXPECT_EQ(VK_API_VERSION_1_0, forUnmarshaling.apiVersion);
    EXPECT_EQ(VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, forUnmarshaling.deviceType);
    EXPECT_EQ(2.0f, forUnmarshaling.limits.lineWidthRange[1]);
    EXPECT_EQ(11.0f, forUnmarshaling.limits.maxInterpolationOffset);

    checkEqual_VkPhysicalDeviceProperties(&forMarshaling, &forUnmarshaling,
                                          [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });
}

// Try a Vulkan struct that has ptr fields with count (dynamic arrays)
TEST(VulkanStream, testMarshalVulkanStructWithPtrFields) {
    TestStream testStream;
    VulkanStream stream(&testStream);

    const uint32_t bindCount = 14;

    std::vector<VkSparseImageMemoryBind> sparseBinds;

    for (uint32_t i = 0; i < bindCount; i++) {
        VkSparseImageMemoryBind sparseBind = {
            // VkImageSubresource subresource
            {
                VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT,
                i,
                i * 2,
            },
            // VkOffset3D offset
            {1, 2 + (int32_t)i, 3},
            // VkExtent3D extent
            {10, 20 * i, 30},
            // VkDeviceMemory memory
            (VkDeviceMemory)(uintptr_t)(0xff - i),
            // VkDeviceSize memoryOffset
            0x12345678 + i,
            // VkSparseMemoryBindFlags flags
            VK_SPARSE_MEMORY_BIND_METADATA_BIT,
        };

        sparseBinds.push_back(sparseBind);
    }

    VkSparseImageMemoryBindInfo forMarshaling = {
        (VkImage)(uintptr_t)54,
        bindCount,
        sparseBinds.data(),
    };

    marshal_VkSparseImageMemoryBindInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);

    VkSparseImageMemoryBindInfo forUnmarshaling = {
        0,
        0,
        nullptr,
    };

    unmarshal_VkSparseImageMemoryBindInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);

    EXPECT_EQ(bindCount, forUnmarshaling.bindCount);
    EXPECT_EQ(forMarshaling.image, forUnmarshaling.image);

    // Test some values in there so we know the autogenerated
    // compare code works.
    for (uint32_t i = 0; i < bindCount; i++) {
        EXPECT_EQ(forMarshaling.pBinds[i].memoryOffset, forUnmarshaling.pBinds[i].memoryOffset);
        EXPECT_EQ(forMarshaling.pBinds[i].memoryOffset, forUnmarshaling.pBinds[i].memoryOffset);
        EXPECT_EQ(forMarshaling.pBinds[i].subresource.arrayLayer,
                  forUnmarshaling.pBinds[i].subresource.arrayLayer);
    }

    checkEqual_VkSparseImageMemoryBindInfo(
        &forMarshaling, &forUnmarshaling, [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });
}

// Try a Vulkan struct that has ptr fields that are not structs
TEST(VulkanStream, testMarshalVulkanStructWithSimplePtrFields) {
    TestStream testStream;
    VulkanStream stream(&testStream);

    const uint32_t queueCount = 4;

    std::vector<float> queuePriorities;

    for (uint32_t i = 0; i < queueCount; i++) {
        queuePriorities.push_back(i * 4.0f);
    }

    VkDeviceQueueCreateInfo forMarshaling = {
        VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, 0, 0, 1, queueCount, queuePriorities.data(),
    };

    VkDeviceQueueCreateInfo forUnmarshaling = {
        VK_STRUCTURE_TYPE_APPLICATION_INFO, 0, 0, 0, 0, nullptr,
    };

    marshal_VkDeviceQueueCreateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);
    unmarshal_VkDeviceQueueCreateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);

    // As always, test the autogenerated tester.
    for (uint32_t i = 0; i < queueCount; i++) {
        EXPECT_EQ(forMarshaling.pQueuePriorities[i], forUnmarshaling.pQueuePriorities[i]);
    }

    checkEqual_VkDeviceQueueCreateInfo(&forMarshaling, &forUnmarshaling,
                                       [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });
}

// Vulkan struct with a void* field that refers to actual data
// that needs to get transmitted over
TEST(VulkanStream, testMarshalVulkanStructWithVoidPtrToData) {
    TestStream testStream;
    VulkanStream stream(&testStream);

    // Not going to validate the map entries---
    // that's the validation layer's job,
    // and this is just to make sure values match.
    const uint32_t numEntries = 5;
    const size_t dataSize = 54;

    std::vector<VkSpecializationMapEntry> entries(numEntries);

    for (uint32_t i = 0; i < numEntries; i++) {
        entries[i].constantID = 8 * i + 0;
        entries[i].offset = 8 * i + 1;
        entries[i].size = 8 * i + 2;
    }

    std::vector<uint8_t> data(dataSize);

    for (size_t i = 0; i < dataSize; i++) {
        data[i] = (uint8_t)i;
    }

    VkSpecializationInfo forMarshaling = {
        numEntries,
        entries.data(),
        dataSize,
        data.data(),
    };

    VkSpecializationInfo forUnmarshaling;
    memset(&forUnmarshaling, 0x0, sizeof(VkSpecializationInfo));

    int inequalities = 0;
    checkEqual_VkSpecializationInfo(&forMarshaling, &forUnmarshaling,
                                    [&inequalities](const char* errMsg) { ++inequalities; });

    EXPECT_GT(inequalities, 0);

    marshal_VkSpecializationInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);
    unmarshal_VkSpecializationInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);

    checkEqual_VkSpecializationInfo(&forMarshaling, &forUnmarshaling,
                                    [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });
}

// Tests that marshal + unmarshal is equivalent to deepcopy.
TEST(VulkanStream, testDeepcopyEquivalence) {
    BumpPool pool;
    TestStream testStream;
    VulkanStream stream(&testStream);

    VkApplicationInfo appInfo = {
        VK_STRUCTURE_TYPE_APPLICATION_INFO,
        0,                         // pNext
        "VulkanStreamTest",        // application name
        6,                         // application version
        "VulkanStreamTestEngine",  // engine name
        4,                         // engine version,
        VK_API_VERSION_1_0,
    };

    const char* const layerNames[] = {
        "layer0",
        "layer1: test layer",
    };

    const char* const extensionNames[] = {
        "VK_KHR_8bit_storage",
        "VK_KHR_android_surface",
        "VK_MVK_macos_surface",
    };

    VkInstanceCreateInfo forMarshaling = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
                                          0,         // pNext
                                          0,         // flags,
                                          &appInfo,  // pApplicationInfo,
                                          arraySize(layerNames),
                                          layerNames,
                                          arraySize(extensionNames),
                                          extensionNames};

    marshal_VkInstanceCreateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);

    VkInstanceCreateInfo forUnmarshaling;
    VkInstanceCreateInfo forDeepcopy;

    unmarshal_VkInstanceCreateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);
    deepcopy_VkInstanceCreateInfo(&pool, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling, &forDeepcopy);

    checkEqual_VkInstanceCreateInfo(&forMarshaling, &forUnmarshaling,
                                    [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });

    checkEqual_VkInstanceCreateInfo(&forMarshaling, &forDeepcopy,
                                    [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });
}

// Tests that a struct with an extension struct attached
// is properly marshaled/unmarshaled.
TEST(VulkanStream, testStructExtension) {
    BumpPool pool;
    TestStream testStream;
    VulkanStream stream(&testStream);

    VkImage image = (VkImage)1;
    VkBuffer buffer = (VkBuffer)2;

    VkMemoryDedicatedAllocateInfo dedicatedAllocInfo = {
        VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
        0,
        image,
        buffer,
    };

    VkMemoryAllocateInfo forMarshaling = {
        VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
        &dedicatedAllocInfo,
        4096,
        5,
    };

    marshal_VkMemoryAllocateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);

    VkMemoryAllocateInfo forUnmarshaling;
    unmarshal_VkMemoryAllocateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);

    VkMemoryDedicatedAllocateInfo* copiedDedicated =
        (VkMemoryDedicatedAllocateInfo*)forUnmarshaling.pNext;

    EXPECT_EQ(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, copiedDedicated->sType);
    EXPECT_EQ(image, copiedDedicated->image);
    EXPECT_EQ(buffer, copiedDedicated->buffer);

    checkEqual_VkMemoryAllocateInfo(&forMarshaling, &forUnmarshaling,
                                    [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });

    VkMemoryAllocateInfo forDeepcopy;
    deepcopy_VkMemoryAllocateInfo(&pool, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling, &forDeepcopy);

    copiedDedicated = (VkMemoryDedicatedAllocateInfo*)forDeepcopy.pNext;

    EXPECT_EQ(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, copiedDedicated->sType);
    EXPECT_EQ(image, copiedDedicated->image);
    EXPECT_EQ(buffer, copiedDedicated->buffer);

    checkEqual_VkMemoryAllocateInfo(&forMarshaling, &forDeepcopy,
                                    [](const char* errMsg) { EXPECT_TRUE(false) << errMsg; });
}

TEST(VulkanStream, testConflictStructExtensions_marshaling) {
    BumpPool pool;
    TestStream testStream;
    VulkanStream stream(&testStream);

    VkStructureType conflictSType0 = static_cast<VkStructureType>(1000218000u);
    {
        VkImportColorBufferGOOGLE importColorBuffer = {
            .sType = conflictSType0,
            .pNext = nullptr,
            .colorBuffer = 0xabcd1234,
        };
        VkMemoryAllocateInfo forMarshaling = {
            .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
            .pNext = &importColorBuffer,
            .allocationSize = 0xcdab,
            .memoryTypeIndex = 0xabcd,
        };
        marshal_VkMemoryAllocateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);

        VkMemoryAllocateInfo forUnmarshaling;
        unmarshal_VkMemoryAllocateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);
        ASSERT_TRUE(forUnmarshaling.pNext);
        const VkImportColorBufferGOOGLE* ext =
            reinterpret_cast<const VkImportColorBufferGOOGLE*>(forUnmarshaling.pNext);

        EXPECT_EQ(ext->sType, VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE);
        EXPECT_EQ(ext->pNext, nullptr);
        EXPECT_EQ(ext->colorBuffer, importColorBuffer.colorBuffer);
    }
    {
        VkPhysicalDeviceFragmentDensityMapFeaturesEXT densityMapFeatures = {
            .sType = conflictSType0,
            .pNext = nullptr,
            .fragmentDensityMap = true,
            .fragmentDensityMapDynamic = false,
            .fragmentDensityMapNonSubsampledImages = true,
        };
        VkDeviceCreateInfo forMarshaling = {
            .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
            .pNext = &densityMapFeatures,
        };
        marshal_VkDeviceCreateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forMarshaling);

        VkDeviceCreateInfo forUnmarshaling;
        unmarshal_VkDeviceCreateInfo(&stream, VK_STRUCTURE_TYPE_MAX_ENUM, &forUnmarshaling);
        ASSERT_TRUE(forUnmarshaling.pNext);
        const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* ext =
            reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT*>(
                forUnmarshaling.pNext);

        EXPECT_EQ(ext->sType, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT);
        EXPECT_EQ(ext->pNext, nullptr);
        EXPECT_EQ(ext->fragmentDensityMap, densityMapFeatures.fragmentDensityMap);
        EXPECT_EQ(ext->fragmentDensityMapDynamic, densityMapFeatures.fragmentDensityMapDynamic);
        EXPECT_EQ(ext->fragmentDensityMapNonSubsampledImages,
                  densityMapFeatures.fragmentDensityMapNonSubsampledImages);
    }
}

TEST(VulkanStream, testConflictStructExtensions_size) {
    BumpPool pool;
    TestStream testStream;
    VulkanStream stream(&testStream);

    VkStructureType conflictSType0 = static_cast<VkStructureType>(1000218000u);
    {
        VkImportColorBufferGOOGLE importColorBuffer = {
            .sType = conflictSType0,
            .pNext = nullptr,
            .colorBuffer = 0xabcd1234,
        };
        VkMemoryAllocateInfo allocateInfo = {
            .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
            .pNext = &importColorBuffer,
            .allocationSize = 0xcdab,
            .memoryTypeIndex = 0xabcd,
        };

        size_t size = goldfish_vk_extension_struct_size(allocateInfo.sType, &importColorBuffer);
        EXPECT_EQ(size, sizeof(VkImportColorBufferGOOGLE));
    }
    {
        VkPhysicalDeviceFragmentDensityMapFeaturesEXT densityMapFeatures = {
            .sType = conflictSType0,
            .pNext = nullptr,
            .fragmentDensityMap = true,
            .fragmentDensityMapDynamic = false,
            .fragmentDensityMapNonSubsampledImages = true,
        };
        VkDeviceCreateInfo deviceCreateInfo = {
            .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
            .pNext = &densityMapFeatures,
        };

        size_t size =
            goldfish_vk_extension_struct_size(deviceCreateInfo.sType, &densityMapFeatures);
        EXPECT_EQ(size, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT));
    }
}

}  // namespace
}  // namespace vk
}  // namespace gfxstream