vulkan/pipeline/vktPipelineMultisampledRenderToSingleSampledTests.cpp

/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2021 The Khronos Group Inc.
 * Copyright (c) 2023 LunarG, Inc.
 * Copyright (c) 2023 Nintendo
 *
 * 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.
 *
 *//*!
 * \file
 * \brief Tests for VK_EXT_multisampled_render_to_single_sampled
 *//*--------------------------------------------------------------------*/

#include "vktPipelineMultisampledRenderToSingleSampledTests.hpp"
#include "vktPipelineMakeUtil.hpp"
#include "vktTestCase.hpp"
#include "vktTestCaseUtil.hpp"
#include "vktTestGroupUtil.hpp"

#include "vkCmdUtil.hpp"
#include "vkObjUtil.hpp"
#include "vkPlatform.hpp"
#include "vkMemUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkPrograms.hpp"
#include "vkImageUtil.hpp"
#include "vkPipelineConstructionUtil.hpp"

#include "deUniquePtr.hpp"
#include "deSharedPtr.hpp"
#include "deRandom.hpp"
#include "deMath.h"

#include "tcuVector.hpp"
#include "tcuTestLog.hpp"
#include "tcuImageCompare.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuRGBA.hpp"

#include <string>
#include <vector>

// For testing, logs
#define DEBUG_LOGS 0

#if DEBUG_LOGS
#define DBG(...) fprintf(stderr, __VA_ARGS__)
#else
#define DBG(...) ((void)0)
#endif

namespace vkt
{
namespace pipeline
{
namespace
{
using namespace vk;
using de::MovePtr;
using de::SharedPtr;
using de::UniquePtr;
using tcu::IVec2;
using tcu::IVec4;
using tcu::UVec2;
using tcu::UVec4;
using tcu::Vec2;
using tcu::Vec4;

VkImageAspectFlags getDepthStencilAspectFlags(const VkFormat format)
{
    const tcu::TextureFormat tcuFormat = mapVkFormat(format);

    if (tcuFormat.order == tcu::TextureFormat::DS)
        return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
    else if (tcuFormat.order == tcu::TextureFormat::D)
        return VK_IMAGE_ASPECT_DEPTH_BIT;
    else if (tcuFormat.order == tcu::TextureFormat::S)
        return VK_IMAGE_ASPECT_STENCIL_BIT;

    DE_ASSERT(false);
    return 0u;
}

inline bool isDepthFormat(const VkFormat format)
{
    return (getDepthStencilAspectFlags(format) & VK_IMAGE_ASPECT_DEPTH_BIT) != 0;
}

inline bool isStencilFormat(const VkFormat format)
{
    return (getDepthStencilAspectFlags(format) & VK_IMAGE_ASPECT_STENCIL_BIT) != 0;
}

using PipelineSp = SharedPtr<Unique<VkPipeline>>;

// How many regions to render to in multi-pass tests
constexpr uint32_t RegionCount = 4;

struct DrawPushConstants
{
    Vec4 color1Data[2];
    Vec4 color2Data[2];
    IVec4 color3Data[2];
    Vec2 depthData;
};

struct VerifyPushConstants
{
    Vec4 color1Data[2]   = {Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 0)};
    Vec4 color2Data[2]   = {Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 0)};
    IVec4 color3Data[2]  = {IVec4(0, 0, 0, 0), IVec4(0, 0, 0, 0)};
    float depthData      = 0;
    uint32_t stencilData = 0;
};

struct VerificationResults
{
    uint32_t color1Verification;
    uint32_t color2Verification;
    uint32_t color3Verification;
    uint32_t depthVerification;
    uint32_t stencilVerification;
};

struct VerifySingleFloatPushConstants
{
    UVec4 area;
    Vec4 color;
    uint32_t attachmentNdx;
};

struct VerifySingleIntPushConstants
{
    UVec4 area;
    IVec4 color;
    uint32_t attachmentNdx;
};

struct VerifySingleDepthPushConstants
{
    UVec4 area;
    float depthData;
};

struct VerifySingleStencilPushConstants
{
    UVec4 area;
    uint32_t stencilData;
};

//! The parameters that define a test case
struct TestParams
{
    VkSampleCountFlagBits numFloatColor1Samples;  //!< VkAttachmentDescription::samples and VkImageCreateInfo::samples
    VkSampleCountFlagBits numFloatColor2Samples;  //!< VkAttachmentDescription::samples and VkImageCreateInfo::samples
    VkSampleCountFlagBits numIntColorSamples;     //!< VkAttachmentDescription::samples and VkImageCreateInfo::samples
    VkSampleCountFlagBits numDepthStencilSamples; //!< VkAttachmentDescription::samples and VkImageCreateInfo::samples

    VkFormat floatColor1Format;  //!< Color attachment format
    VkFormat floatColor2Format;  //!< Color attachment format
    VkFormat intColorFormat;     //!< Color attachment format
    VkFormat depthStencilFormat; //!< D/S attachment format. Will test both aspects if it's a mixed format

    VkClearValue clearValues[4];

    VerifyPushConstants verifyConstants[RegionCount];

    bool
        isMultisampledRenderToSingleSampled; //!< Whether the test should use VK_EXT_multisampled_render_to_single_sampled or normal multisampling
    bool
        clearBeforeRenderPass; //!< Whether loadOp=CLEAR should be used, or clear is done before render pass and loadOp=LOAD is used
    bool renderToWholeFramebuffer; //!< Whether the test should render to the whole framebuffer.
    bool
        testBlendsColors; //!< Whether the test blends colors or overwrites them.  Tests don't adapt to this automatically, it's informative for shader generation.
    bool dynamicRendering;     //!< Whether the test should use dynamic rendering.
    bool useGarbageAttachment; //!< Whether the test uses garbage attachments.
    bool
        renderToAttachment; //!< Whether the test renders to input attachment in previous subpass or if it's initialize outside of render pass

    struct PerPass
    {
        VkSampleCountFlagBits numSamples; //!< Pipeline samples

        int32_t floatColor1Location;
        int32_t floatColor2Location;
        int32_t intColorLocation;
        bool hasDepthStencil;

        bool resolveFloatColor1;
        bool resolveFloatColor2;
        bool resolveIntColor;
        bool resolveDepthStencil;

        VkResolveModeFlagBits depthStencilResolveMode;

        DrawPushConstants drawConstantsWithDepthWrite[RegionCount];
        DrawPushConstants drawConstantsWithDepthTest[RegionCount];
    };

    std::vector<PerPass> perPass;

    // Used to carry forward the rng seed from test generation to test run.
    uint32_t rngSeed;

    PipelineConstructionType pipelineConstructionType;

    TestParams()
        : numFloatColor1Samples{}
        , numFloatColor2Samples{}
        , numIntColorSamples{}
        , numDepthStencilSamples{}
        , floatColor1Format{}
        , floatColor2Format{}
        , intColorFormat{}
        , depthStencilFormat{}
        , clearValues{}
    {
    }

    bool usesColor1InPass(const size_t passNdx) const
    {
        return perPass[passNdx].floatColor1Location >= 0;
    }
    bool usesColor2InPass(const size_t passNdx) const
    {
        return perPass[passNdx].floatColor2Location >= 0;
    }
    bool usesColor3InPass(const size_t passNdx) const
    {
        return perPass[passNdx].intColorLocation >= 0;
    }
    bool usesDepthStencilInPass(const size_t passNdx) const
    {
        return perPass[passNdx].hasDepthStencil;
    }
};

struct Image
{
    Move<VkImage> image;
    MovePtr<Allocation> alloc;
    Move<VkImageView> view;

    void allocate(const DeviceInterface &vk, const VkDevice device, const MovePtr<Allocator> &allocator,
                  const VkFormat format, const UVec2 &size, const VkSampleCountFlagBits samples,
                  const VkImageUsageFlags usage, const VkImageAspectFlags aspect, const uint32_t layerCount,
                  const bool usedForMSRTSS);
    Move<VkImageView> makeView(const DeviceInterface &vk, const VkDevice device, const VkFormat format,
                               const VkImageAspectFlags aspect, const uint32_t layerCount);
};

//! Common data used by the test
struct WorkingData
{
    UVec2 framebufferSize; //!< Size of the framebuffer
    UVec4 renderArea;      //!< Render area

    Move<VkBuffer> vertexBuffer;                 //!< Contains a fullscreen triangle
    MovePtr<Allocation> vertexBufferAlloc;       //!< Storage for vertexBuffer
    Move<VkBuffer> verificationBuffer;           //!< Buffer used for validation
    MovePtr<Allocation> verificationBufferAlloc; //!< Storage for verificationBuffer
    Move<VkBuffer> singleVerificationBuffer;     //!< Buffer used for validation of attachments outside the render area
    MovePtr<Allocation> singleVerificationBufferAlloc; //!< Storage for singleVerificationBuffer

    //!< Color and depth/stencil attachments
    Image floatColor1;
    Image floatColor2;
    Image intColor;
    Image depthStencil;
    Move<VkImageView> depthOnlyImageView;
    Move<VkImageView> stencilOnlyImageView;

    // Use when not rendering directly to input attachment
    Image dataColor1;
    Move<VkBuffer> dataBuffer;
    MovePtr<Allocation> dataBufferAlloc;

    //!< Resolve attachments
    Image floatResolve1;
    Image floatResolve2;
    Image intResolve;
    Image depthStencilResolve;
    Move<VkImageView> depthOnlyResolveImageView;
    Move<VkImageView> stencilOnlyResolveImageView;

    //!< Verification results for logging (an array of 5 to avoid hitting maxPerStageDescriptorStorageImages limit of 4.
    Image verify;

    WorkingData(void)
    {
    }

    Move<VkImage> &getResolvedFloatColorImage1(const TestParams &params)
    {
        return params.numFloatColor1Samples != VK_SAMPLE_COUNT_1_BIT ? floatResolve1.image : floatColor1.image;
    }
    Move<VkImage> &getResolvedFloatColorImage2(const TestParams &params)
    {
        return params.numFloatColor2Samples != VK_SAMPLE_COUNT_1_BIT ? floatResolve2.image : floatColor2.image;
    }
    Move<VkImage> &getResolvedIntColorImage(const TestParams &params)
    {
        return params.numIntColorSamples != VK_SAMPLE_COUNT_1_BIT ? intResolve.image : intColor.image;
    }
    Move<VkImage> &getResolvedDepthStencilImage(const TestParams &params)
    {
        return params.numDepthStencilSamples != VK_SAMPLE_COUNT_1_BIT ? depthStencilResolve.image : depthStencil.image;
    }

    Move<VkImageView> &getResolvedFloatColorImage1View(const TestParams &params)
    {
        return params.numFloatColor1Samples != VK_SAMPLE_COUNT_1_BIT ? floatResolve1.view : floatColor1.view;
    }
    Move<VkImageView> &getResolvedFloatColorImage2View(const TestParams &params)
    {
        return params.numFloatColor2Samples != VK_SAMPLE_COUNT_1_BIT ? floatResolve2.view : floatColor2.view;
    }
    Move<VkImageView> &getResolvedIntColorImageView(const TestParams &params)
    {
        return params.numIntColorSamples != VK_SAMPLE_COUNT_1_BIT ? intResolve.view : intColor.view;
    }
    Move<VkImageView> &getResolvedDepthOnlyImageView(const TestParams &params)
    {
        // If no depth aspect, return the stencil view just to have something bound in the desc set
        if (!isDepthFormat(params.depthStencilFormat))
            return getResolvedStencilOnlyImageView(params);
        return params.numDepthStencilSamples != VK_SAMPLE_COUNT_1_BIT ? depthOnlyResolveImageView : depthOnlyImageView;
    }
    Move<VkImageView> &getResolvedStencilOnlyImageView(const TestParams &params)
    {
        // If no stencil aspect, return the depth view just to have something bound in the desc set
        if (!isStencilFormat(params.depthStencilFormat))
            return getResolvedDepthOnlyImageView(params);
        return params.numDepthStencilSamples != VK_SAMPLE_COUNT_1_BIT ? stencilOnlyResolveImageView :
                                                                        stencilOnlyImageView;
    }
};

// Accumulate objects throughout the test to avoid them getting deleted before the command buffer is submitted and waited on.
// Speeds up the test by avoiding making multiple submissions and waits.
class TestObjects
{
public:
    TestObjects(Context &contextIn);

    void beginCommandBuffer();
    void submitCommandsAndWait();

    const Unique<VkCommandPool> cmdPool;
    const Unique<VkCommandBuffer> cmdBuffer;
    std::vector<PipelineSp> computePipelines;
    std::vector<MovePtr<GraphicsPipelineWrapper>> graphicsPipelines;
    std::vector<Move<VkDescriptorPool>> descriptorPools;
    std::vector<Move<VkDescriptorSet>> descriptorSets;
    std::vector<RenderPassWrapper> renderPassFramebuffers;
    RenderPassWrapper dataRenderPassFramebuffer;

private:
    Context &context;
};

const VkImageUsageFlags commonImageUsageFlags =
    VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
const VkImageUsageFlags colorImageUsageFlags =
    commonImageUsageFlags | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
const VkImageUsageFlags depthStencilImageUsageFlags =
    commonImageUsageFlags | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;

Move<VkImage> makeImage(const DeviceInterface &vk, const VkDevice device, const VkFormat format, const UVec2 &size,
                        const uint32_t layerCount, const VkSampleCountFlagBits samples, const VkImageUsageFlags usage,
                        const bool usedForMSRTSS)
{
    const VkImageCreateFlags createFlags = samples == VK_SAMPLE_COUNT_1_BIT && usedForMSRTSS ?
                                               VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT :
                                               0;

    const VkImageCreateInfo imageParams = {
        VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
        DE_NULL,                             // const void* pNext;
        createFlags,                         // VkImageCreateFlags flags;
        VK_IMAGE_TYPE_2D,                    // VkImageType imageType;
        format,                              // VkFormat format;
        makeExtent3D(size.x(), size.y(), 1), // VkExtent3D extent;
        1u,                                  // uint32_t mipLevels;
        layerCount,                          // uint32_t arrayLayers;
        samples,                             // VkSampleCountFlagBits samples;
        VK_IMAGE_TILING_OPTIMAL,             // VkImageTiling tiling;
        usage,                               // VkImageUsageFlags usage;
        VK_SHARING_MODE_EXCLUSIVE,           // VkSharingMode sharingMode;
        0u,                                  // uint32_t queueFamilyIndexCount;
        DE_NULL,                             // const uint32_t* pQueueFamilyIndices;
        VK_IMAGE_LAYOUT_UNDEFINED,           // VkImageLayout initialLayout;
    };
    return createImage(vk, device, &imageParams);
}

void Image::allocate(const DeviceInterface &vk, const VkDevice device, const MovePtr<Allocator> &allocator,
                     const VkFormat format, const UVec2 &size, const VkSampleCountFlagBits samples,
                     const VkImageUsageFlags usage, const VkImageAspectFlags aspect, const uint32_t layerCount,
                     const bool usedForMSRTSS)
{
    image = makeImage(vk, device, format, size, layerCount, samples, usage, usedForMSRTSS);
    alloc = bindImage(vk, device, *allocator, *image, MemoryRequirement::Any);
    view  = makeView(vk, device, format, aspect, layerCount);
}

Move<VkImageView> Image::makeView(const DeviceInterface &vk, const VkDevice device, const VkFormat format,
                                  const VkImageAspectFlags aspect, const uint32_t layerCount)
{
    return makeImageView(vk, device, *image, layerCount > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D,
                         format, makeImageSubresourceRange(aspect, 0u, 1u, 0u, layerCount));
}

//! Create a test-specific MSAA pipeline
MovePtr<GraphicsPipelineWrapper> makeGraphicsPipeline(
    const InstanceInterface &vki, const DeviceInterface &vk, const VkPhysicalDevice physicalDevice,
    const VkDevice device, const std::vector<std::string> &deviceExtensions,
    const PipelineConstructionType pipelineConstructionType, const PipelineLayoutWrapper &pipelineLayout,
    const VkRenderPass renderPass, VkPipelineRenderingCreateInfoKHR *pipelineRenderingCreateInfo,
    const ShaderWrapper vertexModule, const ShaderWrapper fragmentModule, const bool enableBlend,
    const bool enableDepthStencilWrite, const bool enableDepthTest, const uint32_t intWriteMask,
    const uint32_t subpassNdx, const int32_t integerAttachmentLocation, const UVec4 &viewportIn, const UVec4 &scissorIn,
    const VkSampleCountFlagBits numSamples, const bool garbageAttachment, const bool singleAttachment = false)
{
    std::vector<VkVertexInputBindingDescription> vertexInputBindingDescriptions;
    std::vector<VkVertexInputAttributeDescription> vertexInputAttributeDescriptions;

    // Vertex attributes: position
    vertexInputBindingDescriptions.push_back(
        makeVertexInputBindingDescription(0u, sizeof(Vec4), VK_VERTEX_INPUT_RATE_VERTEX));
    vertexInputAttributeDescriptions.push_back(
        makeVertexInputAttributeDescription(0u, 0u, VK_FORMAT_R32G32B32A32_SFLOAT, 0u));

    const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo = {
        VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,    // VkStructureType sType;
        DE_NULL,                                                      // const void* pNext;
        (VkPipelineVertexInputStateCreateFlags)0,                     // VkPipelineVertexInputStateCreateFlags flags;
        static_cast<uint32_t>(vertexInputBindingDescriptions.size()), // uint32_t vertexBindingDescriptionCount;
        dataOrNullPtr(
            vertexInputBindingDescriptions), // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
        static_cast<uint32_t>(vertexInputAttributeDescriptions.size()), // uint32_t vertexAttributeDescriptionCount;
        dataOrNullPtr(
            vertexInputAttributeDescriptions), // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
    };

    const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo = {
        VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
        DE_NULL,                                                     // const void* pNext;
        (VkPipelineInputAssemblyStateCreateFlags)0,                  // VkPipelineInputAssemblyStateCreateFlags flags;
        VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,                         // VkPrimitiveTopology topology;
        VK_FALSE,                                                    // VkBool32 primitiveRestartEnable;
    };

    const std::vector<VkViewport> viewports{{
        static_cast<float>(viewportIn.x()), static_cast<float>(viewportIn.y()), // x, y
        static_cast<float>(viewportIn.z()), static_cast<float>(viewportIn.w()), // width, height
        0.0f, 1.0f                                                              // minDepth, maxDepth
    }};

    const std::vector<VkRect2D> scissors = {{
        makeOffset2D(scissorIn.x(), scissorIn.y()),
        makeExtent2D(scissorIn.z(), scissorIn.w()),
    }};

    const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo = {
        VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
        DE_NULL,                                                    // const void* pNext;
        (VkPipelineRasterizationStateCreateFlags)0,                 // VkPipelineRasterizationStateCreateFlags flags;
        VK_FALSE,                                                   // VkBool32 depthClampEnable;
        VK_FALSE,                                                   // VkBool32 rasterizerDiscardEnable;
        VK_POLYGON_MODE_FILL,                                       // VkPolygonMode polygonMode;
        VK_CULL_MODE_NONE,                                          // VkCullModeFlags cullMode;
        VK_FRONT_FACE_COUNTER_CLOCKWISE,                            // VkFrontFace frontFace;
        VK_FALSE,                                                   // VkBool32 depthBiasEnable;
        0.0f,                                                       // float depthBiasConstantFactor;
        0.0f,                                                       // float depthBiasClamp;
        0.0f,                                                       // float depthBiasSlopeFactor;
        1.0f,                                                       // float lineWidth;
    };

    VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo = {
        VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
        DE_NULL,                                                  // const void* pNext;
        (VkPipelineMultisampleStateCreateFlags)0,                 // VkPipelineMultisampleStateCreateFlags flags;
        numSamples,                                               // VkSampleCountFlagBits rasterizationSamples;
        VK_TRUE,                                                  // VkBool32 sampleShadingEnable;
        1.0f,                                                     // float minSampleShading;
        DE_NULL,                                                  // const VkSampleMask* pSampleMask;
        VK_FALSE,                                                 // VkBool32 alphaToCoverageEnable;
        VK_FALSE                                                  // VkBool32 alphaToOneEnable;
    };

    // Simply increment the buffer
    const VkStencilOpState stencilOpState =
        makeStencilOpState(VK_STENCIL_OP_KEEP,                // stencil fail
                           VK_STENCIL_OP_INCREMENT_AND_CLAMP, // depth & stencil pass
                           VK_STENCIL_OP_KEEP,                // depth only fail
                           VK_COMPARE_OP_ALWAYS,              // compare op
                           ~0u,                               // compare mask
                           ~0u,                               // write mask
                           0u);                               // reference

    // Enable depth write and test if needed
    VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo = {
        VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,     // VkStructureType sType;
        DE_NULL,                                                        // const void* pNext;
        (VkPipelineDepthStencilStateCreateFlags)0,                      // VkPipelineDepthStencilStateCreateFlags flags;
        VK_TRUE,                                                        // VkBool32 depthTestEnable;
        enableDepthStencilWrite,                                        // VkBool32 depthWriteEnable;
        enableDepthTest ? VK_COMPARE_OP_GREATER : VK_COMPARE_OP_ALWAYS, // VkCompareOp depthCompareOp;
        VK_FALSE,                                                       // VkBool32 depthBoundsTestEnable;
        VK_TRUE,                                                        // VkBool32 stencilTestEnable;
        stencilOpState,                                                 // VkStencilOpState front;
        stencilOpState,                                                 // VkStencilOpState back;
        0.0f,                                                           // float minDepthBounds;
        1.0f,                                                           // float maxDepthBounds;
    };

    // Always blend by addition.  This is used to verify the combination of multiple draw calls.
    const VkColorComponentFlags colorComponentsAll =
        VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
    VkPipelineColorBlendAttachmentState defaultBlendAttachmentState = {
        enableBlend ? VK_TRUE : VK_FALSE, // VkBool32 blendEnable;
        VK_BLEND_FACTOR_ONE,              // VkBlendFactor srcColorBlendFactor;
        VK_BLEND_FACTOR_ONE,              // VkBlendFactor dstColorBlendFactor;
        VK_BLEND_OP_ADD,                  // VkBlendOp colorBlendOp;
        VK_BLEND_FACTOR_ONE,              // VkBlendFactor srcAlphaBlendFactor;
        VK_BLEND_FACTOR_ONE,              // VkBlendFactor dstAlphaBlendFactor;
        VK_BLEND_OP_ADD,                  // VkBlendOp alphaBlendOp;
        colorComponentsAll,               // VkColorComponentFlags colorWriteMask;
    };

    VkPipelineColorBlendAttachmentState blendAttachmentStates[4] = {
        defaultBlendAttachmentState,
        defaultBlendAttachmentState,
        defaultBlendAttachmentState,
        defaultBlendAttachmentState,
    };

    if (enableBlend && integerAttachmentLocation >= 0)
    {
        // Disable blend for the integer attachment unconditionally
        blendAttachmentStates[integerAttachmentLocation].blendEnable = VK_FALSE;
        // But emulate it by outputting to one channel only.
        blendAttachmentStates[integerAttachmentLocation].colorWriteMask =
            ((intWriteMask & 1) != 0 ? VK_COLOR_COMPONENT_R_BIT : 0) |
            ((intWriteMask & 2) != 0 ? VK_COLOR_COMPONENT_G_BIT : 0) |
            ((intWriteMask & 4) != 0 ? VK_COLOR_COMPONENT_B_BIT : 0) |
            ((intWriteMask & 8) != 0 ? VK_COLOR_COMPONENT_A_BIT : 0);
        DE_ASSERT(blendAttachmentStates[integerAttachmentLocation].colorWriteMask != 0);
    }

    const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo = {
        VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
        DE_NULL,                                                  // const void* pNext;
        (VkPipelineColorBlendStateCreateFlags)0,                  // VkPipelineColorBlendStateCreateFlags flags;
        VK_FALSE,                                                 // VkBool32 logicOpEnable;
        VK_LOGIC_OP_COPY,                                         // VkLogicOp logicOp;
        singleAttachment ? 1u : 4u,                               // uint32_t attachmentCount;
        blendAttachmentStates,    // const VkPipelineColorBlendAttachmentState* pAttachments;
        {0.0f, 0.0f, 0.0f, 0.0f}, // float blendConstants[4];
    };

    VkPipelineRenderingCreateInfo pipelineRenderingCreateInfoWithGarbage;
    std::vector<VkFormat> garbageFormats;

    if (garbageAttachment)
    {
        DE_ASSERT(pipelineRenderingCreateInfo);

        for (int i = 0; i < 10; i++)
            garbageFormats.push_back(VK_FORMAT_UNDEFINED);

        pipelineRenderingCreateInfoWithGarbage = *pipelineRenderingCreateInfo;
        // Just set a bunch of VK_FORMAT_UNDEFINED for garbage_color_attachment tests to make the validation happy.
        pipelineRenderingCreateInfoWithGarbage.colorAttachmentCount    = static_cast<uint32_t>(garbageFormats.size());
        pipelineRenderingCreateInfoWithGarbage.pColorAttachmentFormats = garbageFormats.data();
    }

    MovePtr<GraphicsPipelineWrapper> graphicsPipeline = MovePtr<GraphicsPipelineWrapper>(
        new GraphicsPipelineWrapper(vki, vk, physicalDevice, device, deviceExtensions, pipelineConstructionType, 0u));
    graphicsPipeline.get()
        ->setMonolithicPipelineLayout(pipelineLayout)
        .setupVertexInputState(&vertexInputStateInfo, &pipelineInputAssemblyStateInfo)
        .setupPreRasterizationShaderState(
            viewports, scissors, pipelineLayout, renderPass, subpassNdx, vertexModule, &pipelineRasterizationStateInfo,
            ShaderWrapper(), ShaderWrapper(), ShaderWrapper(), DE_NULL, nullptr,
            garbageAttachment ? &pipelineRenderingCreateInfoWithGarbage : pipelineRenderingCreateInfo)
        .setupFragmentShaderState(pipelineLayout, renderPass, subpassNdx, fragmentModule,
                                  &pipelineDepthStencilStateInfo, &pipelineMultisampleStateInfo)
        .setRenderingColorAttachmentsInfo(pipelineRenderingCreateInfo)
        .setupFragmentOutputState(renderPass, subpassNdx, &pipelineColorBlendStateInfo, &pipelineMultisampleStateInfo)
        .buildPipeline();

    return graphicsPipeline;
}

void logTestImages(Context &context, const TestParams &params, WorkingData &wd, const bool drawsToColor1,
                   const bool drawsToColor2, const bool drawsToColor3, const bool drawsToDepthStencil)
{
    const DeviceInterface &vk    = context.getDeviceInterface();
    const VkDevice device        = context.getDevice();
    MovePtr<Allocator> allocator = MovePtr<Allocator>(new SimpleAllocator(
        vk, device, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice())));
    tcu::TestLog &log            = context.getTestContext().getLog();

    const VkDeviceSize bufferSize[4] = {
        wd.framebufferSize.x() * wd.framebufferSize.y() * tcu::getPixelSize(mapVkFormat(params.floatColor1Format)),
        wd.framebufferSize.x() * wd.framebufferSize.y() * tcu::getPixelSize(mapVkFormat(params.floatColor2Format)),
        wd.framebufferSize.x() * wd.framebufferSize.y() * tcu::getPixelSize(mapVkFormat(params.intColorFormat)),
        wd.framebufferSize.x() * wd.framebufferSize.y() * tcu::getPixelSize(mapVkFormat(params.depthStencilFormat)),
    };
    const Move<VkBuffer> buffer[5] = {
        makeBuffer(vk, device, bufferSize[0], VK_BUFFER_USAGE_TRANSFER_DST_BIT),
        makeBuffer(vk, device, bufferSize[1], VK_BUFFER_USAGE_TRANSFER_DST_BIT),
        makeBuffer(vk, device, bufferSize[2], VK_BUFFER_USAGE_TRANSFER_DST_BIT),
        makeBuffer(vk, device, bufferSize[3], VK_BUFFER_USAGE_TRANSFER_DST_BIT),
        makeBuffer(vk, device, bufferSize[3], VK_BUFFER_USAGE_TRANSFER_DST_BIT),
    };
    const MovePtr<Allocation> bufferAlloc[5] = {
        bindBuffer(vk, device, *allocator, *buffer[0], MemoryRequirement::HostVisible),
        bindBuffer(vk, device, *allocator, *buffer[1], MemoryRequirement::HostVisible),
        bindBuffer(vk, device, *allocator, *buffer[2], MemoryRequirement::HostVisible),
        bindBuffer(vk, device, *allocator, *buffer[3], MemoryRequirement::HostVisible),
        bindBuffer(vk, device, *allocator, *buffer[4], MemoryRequirement::HostVisible),
    };

    for (uint32_t bufferNdx = 0; bufferNdx < 5; ++bufferNdx)
        invalidateAlloc(vk, device, *bufferAlloc[bufferNdx]);

    const Unique<VkCommandPool> cmdPool(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
                                                          context.getUniversalQueueFamilyIndex()));
    const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));

    beginCommandBuffer(vk, *cmdBuffer);

    const IVec2 size(wd.framebufferSize.x(), wd.framebufferSize.y());
    {
        if (drawsToColor1)
            copyImageToBuffer(vk, *cmdBuffer, *wd.getResolvedFloatColorImage1(params), *buffer[0], size,
                              VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 1);
        if (drawsToColor2)
            copyImageToBuffer(vk, *cmdBuffer, *wd.getResolvedFloatColorImage2(params), *buffer[1], size,
                              VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 1);
        if (drawsToColor3)
            copyImageToBuffer(vk, *cmdBuffer, *wd.getResolvedIntColorImage(params), *buffer[2], size,
                              VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, 1);

        VkImageLayout depthStencilLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
        if (drawsToDepthStencil && isDepthFormat(params.depthStencilFormat))
        {
            copyImageToBuffer(vk, *cmdBuffer, *wd.getResolvedDepthStencilImage(params), *buffer[3], size,
                              VK_ACCESS_SHADER_WRITE_BIT, depthStencilLayout, 1,
                              getDepthStencilAspectFlags(params.depthStencilFormat), VK_IMAGE_ASPECT_DEPTH_BIT);
            depthStencilLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
        }
        if (drawsToDepthStencil && isStencilFormat(params.depthStencilFormat))
        {
            copyImageToBuffer(vk, *cmdBuffer, *wd.getResolvedDepthStencilImage(params), *buffer[4], size,
                              VK_ACCESS_SHADER_WRITE_BIT, depthStencilLayout, 1,
                              getDepthStencilAspectFlags(params.depthStencilFormat), VK_IMAGE_ASPECT_STENCIL_BIT);
        }
    }

    endCommandBuffer(vk, *cmdBuffer);
    submitCommandsAndWait(vk, device, context.getUniversalQueue(), *cmdBuffer);

    // For the D32 depth formats, we specify the texture format directly as tcu::getEffectiveDepthStencilAccess assumes stencil data is interleaved.
    // For the D24 format however, we have to use tcu::getEffectiveDepthStencilAccess to correctly account for the 8-bit padding.
    const tcu::TextureFormat copiedDepthFormat = tcu::TextureFormat(
        tcu::TextureFormat::D,
        params.depthStencilFormat == VK_FORMAT_D16_UNORM ? tcu::TextureFormat::UNORM_INT16 : tcu::TextureFormat::FLOAT);
    const tcu::TextureFormat copiedStencilFormat =
        tcu::TextureFormat(tcu::TextureFormat::S, tcu::TextureFormat::UNSIGNED_INT8);

    const tcu::ConstPixelBufferAccess testImageData[5] = {
        {mapVkFormat(params.floatColor1Format), size.x(), size.y(), 1, bufferAlloc[0]->getHostPtr()},
        {mapVkFormat(params.floatColor2Format), size.x(), size.y(), 1, bufferAlloc[1]->getHostPtr()},
        {mapVkFormat(params.intColorFormat), size.x(), size.y(), 1, bufferAlloc[2]->getHostPtr()},
        {copiedDepthFormat, size.x(), size.y(), 1, bufferAlloc[3]->getHostPtr()},
        {copiedStencilFormat, size.x(), size.y(), 1, bufferAlloc[4]->getHostPtr()},
    };

    const tcu::ConstPixelBufferAccess testImageDataD24 = tcu::getEffectiveDepthStencilAccess(
        tcu::ConstPixelBufferAccess(mapVkFormat(params.depthStencilFormat), size.x(), size.y(), 1,
                                    bufferAlloc[3]->getHostPtr()),
        tcu::Sampler::MODE_DEPTH);

    log << tcu::TestLog::ImageSet("attachments", "attachments");
    if (drawsToColor1)
        log << tcu::TestLog::Image("Color attachment 1", "Color attachment 1", testImageData[0]);
    if (drawsToColor2)
        log << tcu::TestLog::Image("Color attachment 2", "Color attachment 2", testImageData[1]);
    if (drawsToColor3)
        log << tcu::TestLog::Image("Color attachment 3", "Color attachment 3", testImageData[2]);
    if (isDepthFormat(params.depthStencilFormat))
        log << tcu::TestLog::Image("Depth attachment", "Depth attachment",
                                   params.depthStencilFormat == VK_FORMAT_D24_UNORM_S8_UINT ? testImageDataD24 :
                                                                                              testImageData[3]);
    if (isStencilFormat(params.depthStencilFormat))
        log << tcu::TestLog::Image("Stencil attachment", "Stencil attachment", testImageData[4]);
    log << tcu::TestLog::EndImageSet;
}

void logVerifyImages(Context &context, const TestParams &params, WorkingData &wd, const bool drawsToColor1,
                     const bool drawsToColor2, const bool drawsToColor3, const bool drawsToDepthStencil)
{
    const DeviceInterface &vk    = context.getDeviceInterface();
    const VkDevice device        = context.getDevice();
    MovePtr<Allocator> allocator = MovePtr<Allocator>(new SimpleAllocator(
        vk, device, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice())));
    tcu::TestLog &log            = context.getTestContext().getLog();

    const VkDeviceSize bufferSize =
        wd.framebufferSize.x() * wd.framebufferSize.y() * 5 * tcu::getPixelSize(mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
    const Move<VkBuffer> buffer           = makeBuffer(vk, device, bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
    const MovePtr<Allocation> bufferAlloc = bindBuffer(vk, device, *allocator, *buffer, MemoryRequirement::HostVisible);

    invalidateAlloc(vk, device, *bufferAlloc);

    const Unique<VkCommandPool> cmdPool(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
                                                          context.getUniversalQueueFamilyIndex()));
    const Unique<VkCommandBuffer> cmdBuffer(makeCommandBuffer(vk, device, *cmdPool));

    beginCommandBuffer(vk, *cmdBuffer);

    copyImageToBuffer(vk, *cmdBuffer, *wd.verify.image, *buffer, IVec2(wd.framebufferSize.x(), wd.framebufferSize.y()),
                      VK_ACCESS_SHADER_WRITE_BIT, VK_IMAGE_LAYOUT_GENERAL, 5);

    endCommandBuffer(vk, *cmdBuffer);
    submitCommandsAndWait(vk, device, context.getUniversalQueue(), *cmdBuffer);

    const tcu::ConstPixelBufferAccess verifyImageData(mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM), wd.framebufferSize.x(),
                                                      wd.framebufferSize.y(), 5, bufferAlloc->getHostPtr());

    log << tcu::TestLog::ImageSet("attachment error mask", "attachment error mask");
    if (drawsToColor1)
        log << tcu::TestLog::Image(
            "ErrorMask color attachment 1", "Error mask color attachment 1",
            tcu::getSubregion(verifyImageData, 0, 0, 0, wd.framebufferSize.x(), wd.framebufferSize.y(), 1));
    if (drawsToColor2)
        log << tcu::TestLog::Image(
            "ErrorMask color attachment 2", "Error mask color attachment 2",
            tcu::getSubregion(verifyImageData, 0, 0, 1, wd.framebufferSize.x(), wd.framebufferSize.y(), 1));
    if (drawsToColor3)
        log << tcu::TestLog::Image(
            "ErrorMask color attachment 3", "Error mask color attachment 3",
            tcu::getSubregion(verifyImageData, 0, 0, 2, wd.framebufferSize.x(), wd.framebufferSize.y(), 1));
    if (drawsToDepthStencil && isDepthFormat(params.depthStencilFormat))
        log << tcu::TestLog::Image(
            "ErrorMask depth attachment", "Error mask depth attachment",
            tcu::getSubregion(verifyImageData, 0, 0, 3, wd.framebufferSize.x(), wd.framebufferSize.y(), 1));
    if (drawsToDepthStencil && isStencilFormat(params.depthStencilFormat))
        log << tcu::TestLog::Image(
            "ErrorMask stencil attachment", "Error mask stencil attachment",
            tcu::getSubregion(verifyImageData, 0, 0, 4, wd.framebufferSize.x(), wd.framebufferSize.y(), 1));
    log << tcu::TestLog::EndImageSet;
}

bool checkAndReportError(Context &context, const uint32_t verifiedPixelCount, const uint32_t expectedPixelCount,
                         const std::string &attachment)
{
    tcu::TestLog &log = context.getTestContext().getLog();

    bool passed = verifiedPixelCount == expectedPixelCount;

    if (passed)
        log << tcu::TestLog::Message << "Verification passed for " << attachment << tcu::TestLog::EndMessage;
    else
        log << tcu::TestLog::Message << "Verification failed for " << attachment << " for "
            << (expectedPixelCount - verifiedPixelCount) << " pixel(s)" << tcu::TestLog::EndMessage;

    return passed;
}

void checkSampleRequirements(Context &context, const VkSampleCountFlagBits numSamples, const bool checkColor,
                             const bool checkDepth, const bool checkStencil)
{
    const VkPhysicalDeviceLimits &limits = context.getDeviceProperties().limits;

    if (checkColor && (limits.framebufferColorSampleCounts & numSamples) == 0u)
        TCU_THROW(NotSupportedError, "framebufferColorSampleCounts: sample count not supported");

    if (checkDepth && (limits.framebufferDepthSampleCounts & numSamples) == 0u)
        TCU_THROW(NotSupportedError, "framebufferDepthSampleCounts: sample count not supported");

    if (checkStencil && (limits.framebufferStencilSampleCounts & numSamples) == 0u)
        TCU_THROW(NotSupportedError, "framebufferStencilSampleCounts: sample count not supported");
}

void checkImageRequirements(Context &context, const VkFormat format, const VkFormatFeatureFlags requiredFeatureFlags,
                            const VkImageUsageFlags requiredUsageFlags, const VkSampleCountFlagBits requiredSampleCount,
                            VkImageFormatProperties &imageProperties)
{
    const InstanceInterface &vki          = context.getInstanceInterface();
    const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();

    const VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(vki, physicalDevice, format);

    if ((formatProperties.optimalTilingFeatures & requiredFeatureFlags) != requiredFeatureFlags)
        TCU_THROW(NotSupportedError, (de::toString(format) + ": format features not supported").c_str());

    const VkImageCreateFlags createFlags = requiredSampleCount == VK_SAMPLE_COUNT_1_BIT ?
                                               VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT :
                                               0;

    const VkResult result =
        vki.getPhysicalDeviceImageFormatProperties(physicalDevice, format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL,
                                                   requiredUsageFlags, createFlags, &imageProperties);

    if (result == VK_ERROR_FORMAT_NOT_SUPPORTED)
        TCU_THROW(NotSupportedError, (de::toString(format) + ": format not supported").c_str());

    if ((imageProperties.sampleCounts & requiredSampleCount) != requiredSampleCount)
        TCU_THROW(NotSupportedError, (de::toString(format) + ": sample count not supported").c_str());
}

TestObjects::TestObjects(Context &contextIn)
    : cmdPool(createCommandPool(contextIn.getDeviceInterface(), contextIn.getDevice(),
                                VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
                                contextIn.getUniversalQueueFamilyIndex()))
    , cmdBuffer(makeCommandBuffer(contextIn.getDeviceInterface(), contextIn.getDevice(), *cmdPool))
    , context(contextIn)
{
}

void TestObjects::beginCommandBuffer()
{
    const DeviceInterface &vk = context.getDeviceInterface();

    vk::beginCommandBuffer(vk, *cmdBuffer);
}

void TestObjects::submitCommandsAndWait()
{
    const DeviceInterface &vk = context.getDeviceInterface();
    const VkDevice device     = context.getDevice();

    VK_CHECK(vk.endCommandBuffer(*cmdBuffer));
    vk::submitCommandsAndWait(vk, device, context.getUniversalQueue(), *cmdBuffer);
}

void initializeAttachments(const TestParams &params, WorkingData &wd, std::vector<VkImage> &images,
                           std::vector<VkImageView> &attachments, const size_t passNdx, int32_t attachmentNdxes[8])
{
    const bool includeAll = passNdx >= params.perPass.size();
    int32_t currentNdx    = 0;

    // Output attachments
    if (includeAll || params.usesColor1InPass(passNdx))
    {
        images.push_back(wd.floatColor1.image.get());
        attachments.push_back(wd.floatColor1.view.get());
        attachmentNdxes[0] = currentNdx++;
    }
    if (includeAll || params.usesColor2InPass(passNdx))
    {
        images.push_back(wd.floatColor2.image.get());
        attachments.push_back(wd.floatColor2.view.get());
        attachmentNdxes[1] = currentNdx++;
    }
    if (includeAll || params.usesColor3InPass(passNdx))
    {
        images.push_back(wd.intColor.image.get());
        attachments.push_back(wd.intColor.view.get());
        attachmentNdxes[2] = currentNdx++;
    }
    if (includeAll || params.usesDepthStencilInPass(passNdx))
    {
        images.push_back(wd.depthStencil.image.get());
        attachments.push_back(wd.depthStencil.view.get());
        attachmentNdxes[3] = currentNdx++;
    }

    // Resolve attachments
    if (params.numFloatColor1Samples != VK_SAMPLE_COUNT_1_BIT && (includeAll || params.usesColor1InPass(passNdx)))
    {
        images.push_back(wd.floatResolve1.image.get());
        attachments.push_back(wd.floatResolve1.view.get());
        attachmentNdxes[4] = currentNdx++;
    }
    if (params.numFloatColor2Samples != VK_SAMPLE_COUNT_1_BIT && (includeAll || params.usesColor2InPass(passNdx)))
    {
        images.push_back(wd.floatResolve2.image.get());
        attachments.push_back(wd.floatResolve2.view.get());
        attachmentNdxes[5] = currentNdx++;
    }
    if (params.numIntColorSamples != VK_SAMPLE_COUNT_1_BIT && (includeAll || params.usesColor3InPass(passNdx)))
    {
        images.push_back(wd.intResolve.image.get());
        attachments.push_back(wd.intResolve.view.get());
        attachmentNdxes[6] = currentNdx++;
    }
    if (params.numDepthStencilSamples != VK_SAMPLE_COUNT_1_BIT &&
        (includeAll || params.usesDepthStencilInPass(passNdx)))
    {
        images.push_back(wd.depthStencilResolve.image.get());
        attachments.push_back(wd.depthStencilResolve.view.get());
        attachmentNdxes[7] = currentNdx++;
    }
}

void initializeAttachmentDescriptions(const TestParams &params, std::vector<VkAttachmentDescription2> &descs,
                                      const bool preCleared, const int32_t attachmentNdxes[8],
                                      uint32_t &attachmentUseMask)
{
    // The attachments are either cleared already or should be cleared now.  If an attachment was used in a previous render pass,
    // it will override these values to always LOAD and use the SHADER_READ_ONLY layout.  It's SHADER_READ_ONLY because final layout
    // is always that for simplicity.
    const VkAttachmentLoadOp loadOp   = preCleared ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_CLEAR;
    const VkImageLayout initialLayout = preCleared ? VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;

    // Output attachments
    if (attachmentNdxes[0] >= 0)
    {
        descs.push_back(VkAttachmentDescription2{
            VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType                  sType;
            DE_NULL,                                    // const void*                      pNext;
            (VkAttachmentDescriptionFlags)0,            // VkAttachmentDescriptionFlags flags;
            params.floatColor1Format,                   // VkFormat format;
            params.numFloatColor1Samples,               // VkSampleCountFlagBits samples;
            (attachmentUseMask & (1 << 0)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD : loadOp, // VkAttachmentLoadOp loadOp;
            VK_ATTACHMENT_STORE_OP_STORE,                                              // VkAttachmentStoreOp storeOp;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,  // VkAttachmentLoadOp stencilLoadOp;
            VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
            (attachmentUseMask & (1 << 0)) != 0 ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL :
                                                  initialLayout, // VkImageLayout initialLayout;
            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL             // VkImageLayout finalLayout;
        });
        attachmentUseMask |= 1 << 0;
    }

    if (attachmentNdxes[1] >= 0)
    {
        descs.push_back(VkAttachmentDescription2{
            VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType                  sType;
            DE_NULL,                                    // const void*                      pNext;
            (VkAttachmentDescriptionFlags)0,            // VkAttachmentDescriptionFlags flags;
            params.floatColor2Format,                   // VkFormat format;
            params.numFloatColor2Samples,               // VkSampleCountFlagBits samples;
            (attachmentUseMask & (1 << 1)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD : loadOp, // VkAttachmentLoadOp loadOp;
            VK_ATTACHMENT_STORE_OP_STORE,                                              // VkAttachmentStoreOp storeOp;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,  // VkAttachmentLoadOp stencilLoadOp;
            VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
            (attachmentUseMask & (1 << 1)) != 0 ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL :
                                                  initialLayout, // VkImageLayout initialLayout;
            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL             // VkImageLayout finalLayout;
        });
        attachmentUseMask |= 1 << 1;
    }

    if (attachmentNdxes[2] >= 0)
    {
        descs.push_back(VkAttachmentDescription2{
            VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType                  sType;
            DE_NULL,                                    // const void*                      pNext;
            (VkAttachmentDescriptionFlags)0,            // VkAttachmentDescriptionFlags flags;
            params.intColorFormat,                      // VkFormat format;
            params.numIntColorSamples,                  // VkSampleCountFlagBits samples;
            (attachmentUseMask & (1 << 2)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD : loadOp, // VkAttachmentLoadOp loadOp;
            VK_ATTACHMENT_STORE_OP_STORE,                                              // VkAttachmentStoreOp storeOp;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,  // VkAttachmentLoadOp stencilLoadOp;
            VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
            (attachmentUseMask & (1 << 2)) != 0 ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL :
                                                  initialLayout, // VkImageLayout initialLayout;
            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL             // VkImageLayout finalLayout;
        });
        attachmentUseMask |= 1 << 2;
    }

    if (attachmentNdxes[3] >= 0)
    {
        descs.push_back(VkAttachmentDescription2{
            VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType                  sType;
            DE_NULL,                                    // const void*                      pNext;
            (VkAttachmentDescriptionFlags)0,            // VkAttachmentDescriptionFlags flags;
            params.depthStencilFormat,                  // VkFormat format;
            params.numDepthStencilSamples,              // VkSampleCountFlagBits samples;
            (attachmentUseMask & (1 << 3)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD : loadOp, // VkAttachmentLoadOp loadOp;
            VK_ATTACHMENT_STORE_OP_STORE,                                              // VkAttachmentStoreOp storeOp;
            (attachmentUseMask & (1 << 3)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD :
                                                  loadOp, // VkAttachmentLoadOp stencilLoadOp;
            VK_ATTACHMENT_STORE_OP_STORE,                 // VkAttachmentStoreOp stencilStoreOp;
            (attachmentUseMask & (1 << 3)) != 0 ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL :
                                                  initialLayout, // VkImageLayout initialLayout;
            VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL      // VkImageLayout finalLayout;
        });
        attachmentUseMask |= 1 << 3;
    }

    // Resolve attachments
    if (attachmentNdxes[4] >= 0)
        descs.push_back(VkAttachmentDescription2{
            VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType                  sType;
            DE_NULL,                                    // const void*                      pNext;
            (VkAttachmentDescriptionFlags)0,            // VkAttachmentDescriptionFlags flags;
            params.floatColor1Format,                   // VkFormat format;
            VK_SAMPLE_COUNT_1_BIT,                      // VkSampleCountFlagBits samples;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,            // VkAttachmentLoadOp loadOp;
            VK_ATTACHMENT_STORE_OP_STORE,               // VkAttachmentStoreOp storeOp;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,            // VkAttachmentLoadOp stencilLoadOp;
            VK_ATTACHMENT_STORE_OP_DONT_CARE,           // VkAttachmentStoreOp stencilStoreOp;
            VK_IMAGE_LAYOUT_UNDEFINED,                  // VkImageLayout initialLayout;
            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL    // VkImageLayout finalLayout;
        });

    if (attachmentNdxes[5] >= 0)
        descs.push_back(VkAttachmentDescription2{
            VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType                  sType;
            DE_NULL,                                    // const void*                      pNext;
            (VkAttachmentDescriptionFlags)0,            // VkAttachmentDescriptionFlags flags;
            params.floatColor2Format,                   // VkFormat format;
            VK_SAMPLE_COUNT_1_BIT,                      // VkSampleCountFlagBits samples;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,            // VkAttachmentLoadOp loadOp;
            VK_ATTACHMENT_STORE_OP_STORE,               // VkAttachmentStoreOp storeOp;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,            // VkAttachmentLoadOp stencilLoadOp;
            VK_ATTACHMENT_STORE_OP_DONT_CARE,           // VkAttachmentStoreOp stencilStoreOp;
            VK_IMAGE_LAYOUT_UNDEFINED,                  // VkImageLayout initialLayout;
            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL    // VkImageLayout finalLayout;
        });

    if (attachmentNdxes[6] >= 0)
        descs.push_back(VkAttachmentDescription2{
            VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType                  sType;
            DE_NULL,                                    // const void*                      pNext;
            (VkAttachmentDescriptionFlags)0,            // VkAttachmentDescriptionFlags flags;
            params.intColorFormat,                      // VkFormat format;
            VK_SAMPLE_COUNT_1_BIT,                      // VkSampleCountFlagBits samples;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,            // VkAttachmentLoadOp loadOp;
            VK_ATTACHMENT_STORE_OP_STORE,               // VkAttachmentStoreOp storeOp;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,            // VkAttachmentLoadOp stencilLoadOp;
            VK_ATTACHMENT_STORE_OP_DONT_CARE,           // VkAttachmentStoreOp stencilStoreOp;
            VK_IMAGE_LAYOUT_UNDEFINED,                  // VkImageLayout initialLayout;
            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL    // VkImageLayout finalLayout;
        });

    if (attachmentNdxes[7] >= 0)
        descs.push_back(VkAttachmentDescription2{
            VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,     // VkStructureType                  sType;
            DE_NULL,                                        // const void*                      pNext;
            (VkAttachmentDescriptionFlags)0,                // VkAttachmentDescriptionFlags flags;
            params.depthStencilFormat,                      // VkFormat format;
            VK_SAMPLE_COUNT_1_BIT,                          // VkSampleCountFlagBits samples;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,                // VkAttachmentLoadOp loadOp;
            VK_ATTACHMENT_STORE_OP_STORE,                   // VkAttachmentStoreOp storeOp;
            VK_ATTACHMENT_LOAD_OP_DONT_CARE,                // VkAttachmentLoadOp stencilLoadOp;
            VK_ATTACHMENT_STORE_OP_STORE,                   // VkAttachmentStoreOp stencilStoreOp;
            VK_IMAGE_LAYOUT_UNDEFINED,                      // VkImageLayout initialLayout;
            VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL // VkImageLayout finalLayout;
        });
}

void initializeRenderingAttachmentInfos(const TestParams &params, WorkingData &wd,
                                        std::vector<VkRenderingAttachmentInfo> &colorAttachmentInfos,
                                        VkRenderingAttachmentInfo &depthStencilAttachmentInfo,
                                        std::vector<VkFormat> &colorAttachmentFormats, const int32_t attachmentNdxes[8],
                                        uint32_t &attachmentUseMask, uint32_t passNdx)
{
    // The attachments are either cleared already or should be cleared now. If an attachment was used in a previous render pass,
    // it will override these values to always LOAD and use the SHADER_READ_ONLY layout. It's SHADER_READ_ONLY because final layout
    // is always that for simplicity.
    const VkAttachmentLoadOp loadOp =
        params.clearBeforeRenderPass ? VK_ATTACHMENT_LOAD_OP_LOAD : VK_ATTACHMENT_LOAD_OP_CLEAR;
    const TestParams::PerPass &perPass = params.perPass[passNdx];

    const VkRenderingAttachmentInfo emptyRenderingAttachmentInfo = {
        VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, // VkStructureType            sType
        DE_NULL,                                     // const void*                pNext
        DE_NULL,                                     // VkImageView                imageView
        VK_IMAGE_LAYOUT_UNDEFINED,                   // VkImageLayout            imageLayout
        VK_RESOLVE_MODE_NONE,                        // VkResolveModeFlagBits    resolveMode
        DE_NULL,                                     // VkImageView                resolveImageView
        VK_IMAGE_LAYOUT_UNDEFINED,                   // VkImageLayout            resolveImageLayout
        VK_ATTACHMENT_LOAD_OP_DONT_CARE,             // VkAttachmentLoadOp        loadOp
        VK_ATTACHMENT_STORE_OP_DONT_CARE,            // VkAttachmentStoreOp        storeOp
        params.clearValues[0]                        // VkClearValue                clearValue
    };

    for (auto &colorAttachmentInfo : colorAttachmentInfos)
    {
        colorAttachmentInfo = emptyRenderingAttachmentInfo;
    }

    // Output attachments
    if (attachmentNdxes[0] >= 0)
    {
        VkRenderingAttachmentInfo renderingAttachmentInfo = {
            VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, // VkStructureType            sType
            DE_NULL,                                     // const void*                pNext
            wd.floatColor1.view.get(),                   // VkImageView                imageView
            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,    // VkImageLayout            imageLayout
            VK_RESOLVE_MODE_NONE,                        // VkResolveModeFlagBits    resolveMode
            DE_NULL,                                     // VkImageView                resolveImageView
            VK_IMAGE_LAYOUT_UNDEFINED,                   // VkImageLayout            resolveImageLayout
            (attachmentUseMask & (1 << 0)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD :
                                                  loadOp, // VkAttachmentLoadOp        loadOp
            VK_ATTACHMENT_STORE_OP_STORE,                 // VkAttachmentStoreOp        storeOp
            params.clearValues[0]                         // VkClearValue                clearValue
        };

        // Enable resolve image if it's used.
        if (attachmentNdxes[4] >= 0)
        {
            renderingAttachmentInfo.resolveMode        = VK_RESOLVE_MODE_AVERAGE_BIT;
            renderingAttachmentInfo.resolveImageView   = wd.floatResolve1.view.get();
            renderingAttachmentInfo.resolveImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        }
        else if (params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT)
        {
            renderingAttachmentInfo.resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT;
        }

        colorAttachmentInfos[perPass.floatColor1Location]   = renderingAttachmentInfo;
        colorAttachmentFormats[perPass.floatColor1Location] = params.floatColor1Format;
        attachmentUseMask |= 1 << 0;
    }

    if (attachmentNdxes[1] >= 0)
    {
        VkRenderingAttachmentInfo renderingAttachmentInfo = {
            VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, // VkStructureType            sType
            DE_NULL,                                     // const void*                pNext
            wd.floatColor2.view.get(),                   // VkImageView                imageView
            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,    // VkImageLayout            imageLayout
            VK_RESOLVE_MODE_NONE,                        // VkResolveModeFlagBits    resolveMode
            DE_NULL,                                     // VkImageView                resolveImageView
            VK_IMAGE_LAYOUT_UNDEFINED,                   // VkImageLayout            resolveImageLayout
            (attachmentUseMask & (1 << 1)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD :
                                                  loadOp, // VkAttachmentLoadOp        loadOp
            VK_ATTACHMENT_STORE_OP_STORE,                 // VkAttachmentStoreOp        storeOp
            params.clearValues[1]                         // VkClearValue                clearValue
        };

        if (attachmentNdxes[5] >= 0)
        {
            renderingAttachmentInfo.resolveMode        = VK_RESOLVE_MODE_AVERAGE_BIT;
            renderingAttachmentInfo.resolveImageView   = wd.floatResolve2.view.get();
            renderingAttachmentInfo.resolveImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        }
        else if (params.numFloatColor2Samples == VK_SAMPLE_COUNT_1_BIT)
        {
            renderingAttachmentInfo.resolveMode = VK_RESOLVE_MODE_AVERAGE_BIT;
        }

        colorAttachmentInfos[perPass.floatColor2Location]   = renderingAttachmentInfo;
        colorAttachmentFormats[perPass.floatColor2Location] = params.floatColor2Format;
        attachmentUseMask |= 1 << 1;
    }

    if (attachmentNdxes[2] >= 0)
    {
        VkRenderingAttachmentInfo renderingAttachmentInfo = {
            VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, // VkStructureType            sType
            DE_NULL,                                     // const void*                pNext
            wd.intColor.view.get(),                      // VkImageView                imageView
            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,    // VkImageLayout            imageLayout
            VK_RESOLVE_MODE_NONE,                        // VkResolveModeFlagBits    resolveMode
            DE_NULL,                                     // VkImageView                resolveImageView
            VK_IMAGE_LAYOUT_UNDEFINED,                   // VkImageLayout            resolveImageLayout
            (attachmentUseMask & (1 << 2)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD :
                                                  loadOp, // VkAttachmentLoadOp        loadOp
            VK_ATTACHMENT_STORE_OP_STORE,                 // VkAttachmentStoreOp        storeOp
            params.clearValues[2]                         // VkClearValue                clearValue
        };

        if (attachmentNdxes[6] >= 0)
        {
            renderingAttachmentInfo.resolveMode        = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
            renderingAttachmentInfo.resolveImageView   = wd.intResolve.view.get();
            renderingAttachmentInfo.resolveImageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        }
        else if (params.numIntColorSamples == VK_SAMPLE_COUNT_1_BIT)
        {
            renderingAttachmentInfo.resolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
        }

        colorAttachmentInfos[perPass.intColorLocation]   = renderingAttachmentInfo;
        colorAttachmentFormats[perPass.intColorLocation] = params.intColorFormat;
        attachmentUseMask |= 1 << 2;
    }

    if (attachmentNdxes[3] >= 0)
    {

        VkRenderingAttachmentInfo renderingAttachmentInfo = {
            VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,      // VkStructureType            sType
            DE_NULL,                                          // const void*                pNext
            wd.depthStencil.view.get(),                       // VkImageView                imageView
            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, // VkImageLayout            imageLayout
            VK_RESOLVE_MODE_NONE,                             // VkResolveModeFlagBits    resolveMode
            DE_NULL,                                          // VkImageView                resolveImageView
            VK_IMAGE_LAYOUT_UNDEFINED,                        // VkImageLayout            resolveImageLayout
            (attachmentUseMask & (1 << 3)) != 0 ? VK_ATTACHMENT_LOAD_OP_LOAD :
                                                  loadOp, // VkAttachmentLoadOp        loadOp
            VK_ATTACHMENT_STORE_OP_STORE,                 // VkAttachmentStoreOp        storeOp
            params.clearValues[3]                         // VkClearValue                clearValue
        };

        if (attachmentNdxes[7] >= 0)
        {
            renderingAttachmentInfo.resolveMode        = params.perPass[passNdx].depthStencilResolveMode;
            renderingAttachmentInfo.resolveImageView   = wd.depthStencilResolve.view.get();
            renderingAttachmentInfo.resolveImageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
        }
        else if (params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT)
        {
            renderingAttachmentInfo.resolveMode = params.perPass[passNdx].depthStencilResolveMode;
        }

        depthStencilAttachmentInfo = renderingAttachmentInfo;
        attachmentUseMask |= 1 << 3;
    }
}

void initResolveImageLayouts(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    const DeviceInterface &vk                       = context.getDeviceInterface();
    const VkImageMemoryBarrier imageBarrierTemplate = {
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType            sType
        DE_NULL,                                // const void*                pNext
        0,                                      // VkAccessFlags            srcAccessMask
        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags            dstAccessMask
        VK_IMAGE_LAYOUT_UNDEFINED,                        // VkImageLayout            oldLayout
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,         // VkImageLayout            newLayout
        VK_QUEUE_FAMILY_IGNORED,                          // uint32_t                    srcQueueFamilyIndex
        VK_QUEUE_FAMILY_IGNORED,                          // uint32_t                    dstQueueFamilyIndex
        0,                                                // VkImage                    image
        makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u,
                                  1u), // VkImageSubresourceRange    subresourceRange
    };

    std::vector<VkImageMemoryBarrier> barriers;

    if (wd.floatResolve1.image)
    {
        barriers.push_back(imageBarrierTemplate);
        barriers.back().image = *wd.floatResolve1.image;
    }

    if (wd.floatResolve2.image)
    {
        barriers.push_back(imageBarrierTemplate);
        barriers.back().image = *wd.floatResolve2.image;
    }

    if (wd.intResolve.image)
    {
        barriers.push_back(imageBarrierTemplate);
        barriers.back().image = *wd.intResolve.image;
    }

    if (wd.depthStencilResolve.image)
    {
        barriers.push_back(imageBarrierTemplate);
        barriers.back().image                       = *wd.depthStencilResolve.image;
        barriers.back().newLayout                   = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
        barriers.back().subresourceRange.aspectMask = getDepthStencilAspectFlags(params.depthStencilFormat);
    }

    if (!barriers.empty())
    {
        vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                              VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
                              0u, 0u, DE_NULL, 0u, DE_NULL, static_cast<uint32_t>(barriers.size()), barriers.data());
    }
}

void preRenderingImageLayoutTransition(Context &context, const TestParams &params, WorkingData &wd,
                                       TestObjects &testObjects)
{
    const DeviceInterface &vk = context.getDeviceInterface();
    const bool preCleared     = params.clearBeforeRenderPass;

    const VkImageMemoryBarrier imageBarrierTemplate = {
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType            sType;
        DE_NULL,                                // const void*                pNext;
        preCleared ? (VkAccessFlags)VK_ACCESS_TRANSFER_WRITE_BIT :
                     (VkAccessFlags)0, // VkAccessFlags              srcAccessMask;
        VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, // VkAccessFlags              dstAccessMask;
        preCleared ? VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL :
                     VK_IMAGE_LAYOUT_UNDEFINED,   // VkImageLayout              oldLayout;
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout              newLayout;
        VK_QUEUE_FAMILY_IGNORED,                  // uint32_t                   srcQueueFamilyIndex;
        VK_QUEUE_FAMILY_IGNORED,                  // uint32_t                   dstQueueFamilyIndex;
        0,                                        // VkImage                    image;
        makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u,
                                  1u), // VkImageSubresourceRange    subresourceRange;
    };

    VkImageMemoryBarrier barriers[4] = {imageBarrierTemplate, imageBarrierTemplate, imageBarrierTemplate,
                                        imageBarrierTemplate};
    barriers[0].image                = *wd.floatColor1.image;
    barriers[1].image                = *wd.floatColor2.image;
    barriers[2].image                = *wd.intColor.image;
    barriers[3].image                = *wd.depthStencil.image;
    barriers[3].dstAccessMask =
        VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
    barriers[3].newLayout                   = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
    barriers[3].subresourceRange.aspectMask = getDepthStencilAspectFlags(params.depthStencilFormat);

    vk.cmdPipelineBarrier(*testObjects.cmdBuffer,
                          preCleared ? VK_PIPELINE_STAGE_TRANSFER_BIT : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                          VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
                              VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
                          0u, 0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(barriers), barriers);
}

void postRenderingResolveImageLayoutTransition(Context &context, const TestParams &params, WorkingData &wd,
                                               TestObjects &testObjects)
{
    const DeviceInterface &vk                       = context.getDeviceInterface();
    const VkImageMemoryBarrier imageBarrierTemplate = {
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType            sType
        DE_NULL,                                // const void*                pNext
        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags            srcAccessMask
        VK_ACCESS_SHADER_READ_BIT,                        // VkAccessFlags            dstAccessMask
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,         // VkImageLayout            oldLayout
        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,         // VkImageLayout            newLayout
        VK_QUEUE_FAMILY_IGNORED,                          // uint32_t                    srcQueueFamilyIndex
        VK_QUEUE_FAMILY_IGNORED,                          // uint32_t                    dstQueueFamilyIndex
        0,                                                // VkImage                    image
        makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u,
                                  1u), // VkImageSubresourceRange    subresourceRange
    };

    std::vector<VkImageMemoryBarrier> barriers;

    if (wd.floatResolve1.image)
    {
        barriers.push_back(imageBarrierTemplate);
        barriers.back().image = *wd.floatResolve1.image;
    }

    if (wd.floatResolve2.image)
    {
        barriers.push_back(imageBarrierTemplate);
        barriers.back().image = *wd.floatResolve2.image;
    }

    if (wd.intResolve.image)
    {
        barriers.push_back(imageBarrierTemplate);
        barriers.back().image = *wd.intResolve.image;
    }

    if (wd.depthStencilResolve.image)
    {
        barriers.push_back(imageBarrierTemplate);
        barriers.back().image                       = *wd.depthStencilResolve.image;
        barriers.back().oldLayout                   = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
        barriers.back().newLayout                   = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
        barriers.back().subresourceRange.aspectMask = getDepthStencilAspectFlags(params.depthStencilFormat);
    }

    if (!barriers.empty())
    {
        vk.cmdPipelineBarrier(*testObjects.cmdBuffer,
                              VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
                              VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL,
                              static_cast<uint32_t>(barriers.size()), barriers.data());
    }
}

void preinitializeAttachmentReferences(std::vector<VkAttachmentReference2> &references, const uint32_t count)
{
    references.resize(count, VkAttachmentReference2{
                                 VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // VkStructureType       sType;
                                 DE_NULL,                                  // const void*           pNext;
                                 VK_ATTACHMENT_UNUSED,                     // uint32_t              attachment;
                                 VK_IMAGE_LAYOUT_UNDEFINED,                // VkImageLayout         layout;
                                 0,                                        // VkImageAspectFlags    aspectMask;
                             });
}

void initializeAttachmentReference(VkAttachmentReference2 &reference, uint32_t attachment,
                                   const VkFormat depthStencilFormat, const bool isInputAttachment)
{
    const bool isColor = depthStencilFormat == VK_FORMAT_UNDEFINED;

    reference.attachment = attachment;
    reference.layout     = isInputAttachment ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL :
                           isColor           ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL :
                                               VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
    reference.aspectMask =
        isColor ? VkImageAspectFlags(VK_IMAGE_ASPECT_COLOR_BIT) : getDepthStencilAspectFlags(depthStencilFormat);
}

bool isInAttachmentReferences(const std::vector<VkAttachmentReference2> &references, const int32_t attachment)
{
    for (const VkAttachmentReference2 &reference : references)
        if (reference.attachment == static_cast<uint32_t>(attachment))
            return true;

    return false;
}

void addSubpassDescription(
    const TestParams &params, const uint32_t passNdx, std::vector<VkAttachmentReference2> &attachmentReferences,
    std::vector<VkAttachmentReference2> &resolveAttachmentReferences,
    VkSubpassDescriptionDepthStencilResolve &depthStencilResolve, std::vector<uint32_t> *preserveAttachments,
    VkMultisampledRenderToSingleSampledInfoEXT &msrtss, std::vector<VkSubpassDescription2> &subpasses,
    const std::vector<VkAttachmentReference2> &inputAttachmentReferences, const int32_t attachmentNdxes[8])
{
    const TestParams::PerPass &perPass   = params.perPass[passNdx];
    bool anySingleSampledAttachmentsUsed = false;

    // Maximum 4 attachment references for color and 1 for depth
    preinitializeAttachmentReferences(attachmentReferences, 5);
    preinitializeAttachmentReferences(resolveAttachmentReferences, 5);

    if (!params.renderToAttachment && passNdx == 0)
    {
        attachmentReferences[0].layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    }

    if (perPass.floatColor1Location >= 0)
    {
        initializeAttachmentReference(attachmentReferences[perPass.floatColor1Location], attachmentNdxes[0],
                                      VK_FORMAT_UNDEFINED, false);
        anySingleSampledAttachmentsUsed =
            anySingleSampledAttachmentsUsed || params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT;
    }
    else if (preserveAttachments && !isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[0]))
    {
        if (attachmentNdxes[0] != -1)
            preserveAttachments->push_back(attachmentNdxes[0]);
    }
    if (perPass.floatColor2Location >= 0)
    {
        initializeAttachmentReference(attachmentReferences[perPass.floatColor2Location], attachmentNdxes[1],
                                      VK_FORMAT_UNDEFINED, false);
        anySingleSampledAttachmentsUsed =
            anySingleSampledAttachmentsUsed || params.numFloatColor2Samples == VK_SAMPLE_COUNT_1_BIT;
    }
    else if (preserveAttachments && !isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[1]))
    {
        if (attachmentNdxes[1] != -1)
            preserveAttachments->push_back(attachmentNdxes[1]);
    }
    if (perPass.intColorLocation >= 0)
    {
        initializeAttachmentReference(attachmentReferences[perPass.intColorLocation], attachmentNdxes[2],
                                      VK_FORMAT_UNDEFINED, false);
        anySingleSampledAttachmentsUsed =
            anySingleSampledAttachmentsUsed || params.numIntColorSamples == VK_SAMPLE_COUNT_1_BIT;
    }
    else if (preserveAttachments && !isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[2]))
    {
        if (attachmentNdxes[2] != -1)
            preserveAttachments->push_back(attachmentNdxes[2]);
    }
    if (perPass.hasDepthStencil)
    {
        initializeAttachmentReference(attachmentReferences.back(), attachmentNdxes[3], params.depthStencilFormat,
                                      false);
        anySingleSampledAttachmentsUsed =
            anySingleSampledAttachmentsUsed || params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT;
    }
    else if (preserveAttachments && !isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[3]))
    {
        if (attachmentNdxes[3] != -1)
            preserveAttachments->push_back(attachmentNdxes[3]);
    }

    // Resolve attachments
    if (perPass.resolveFloatColor1)
    {
        initializeAttachmentReference(resolveAttachmentReferences[perPass.floatColor1Location], attachmentNdxes[4],
                                      VK_FORMAT_UNDEFINED, false);
    }
    else if (preserveAttachments && !isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[4]))
    {
        if (attachmentNdxes[4] != -1)
            preserveAttachments->push_back(attachmentNdxes[4]);
    }
    if (perPass.resolveFloatColor2)
    {
        initializeAttachmentReference(resolveAttachmentReferences[perPass.floatColor2Location], attachmentNdxes[5],
                                      VK_FORMAT_UNDEFINED, false);
    }
    else if (preserveAttachments && !isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[5]))
    {
        if (attachmentNdxes[5] != -1)
            preserveAttachments->push_back(attachmentNdxes[5]);
    }
    if (perPass.resolveIntColor)
    {
        initializeAttachmentReference(resolveAttachmentReferences[perPass.intColorLocation], attachmentNdxes[6],
                                      VK_FORMAT_UNDEFINED, false);
    }
    else if (preserveAttachments && !isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[6]))
    {
        if (attachmentNdxes[6] != -1)
            preserveAttachments->push_back(attachmentNdxes[6]);
    }

    // Account for single-sampled attachments in input attachments as well.
    if (!inputAttachmentReferences.empty())
    {
        if (attachmentNdxes[0] >= 0 && isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[0]))
            anySingleSampledAttachmentsUsed =
                anySingleSampledAttachmentsUsed || params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT;
        if (attachmentNdxes[1] >= 0 && isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[1]))
            anySingleSampledAttachmentsUsed =
                anySingleSampledAttachmentsUsed || params.numFloatColor2Samples == VK_SAMPLE_COUNT_1_BIT;
        if (attachmentNdxes[2] >= 0 && isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[2]))
            anySingleSampledAttachmentsUsed =
                anySingleSampledAttachmentsUsed || params.numIntColorSamples == VK_SAMPLE_COUNT_1_BIT;
        if (attachmentNdxes[3] >= 0 && isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[3]))
            anySingleSampledAttachmentsUsed =
                anySingleSampledAttachmentsUsed || params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT;
    }

    const bool needsMsrtss = anySingleSampledAttachmentsUsed && perPass.numSamples != VK_SAMPLE_COUNT_1_BIT;
    const bool needsDepthStencilResolve =
        perPass.resolveDepthStencil ||
        (needsMsrtss && params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT && perPass.hasDepthStencil);

    if (needsDepthStencilResolve)
    {
        if (perPass.resolveDepthStencil)
        {
            initializeAttachmentReference(resolveAttachmentReferences.back(), attachmentNdxes[7],
                                          params.depthStencilFormat, false);
        }
        depthStencilResolve = VkSubpassDescriptionDepthStencilResolve{
            VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, // VkStructureType                  sType;
            DE_NULL,                                                     // const void*                      pNext;
            perPass.depthStencilResolveMode, // VkResolveModeFlagBits            depthResolveMode;
            perPass.depthStencilResolveMode, // VkResolveModeFlagBits            stencilResolveMode;
            perPass.resolveDepthStencil ? &resolveAttachmentReferences.back() :
                                          nullptr, // const VkAttachmentReference2*    pDepthStencilResolveAttachment;
        };
    }
    else if (preserveAttachments && !isInAttachmentReferences(inputAttachmentReferences, attachmentNdxes[7]))
    {
        if (attachmentNdxes[7] != -1)
            preserveAttachments->push_back(attachmentNdxes[7]);
    }

    VkSubpassDescription2 subpassDescription = {
        VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,                   // VkStructureType                 sType;
        needsDepthStencilResolve ? &depthStencilResolve : DE_NULL, // const void*                     pNext;
        (VkSubpassDescriptionFlags)0,                              // VkSubpassDescriptionFlags       flags;
        VK_PIPELINE_BIND_POINT_GRAPHICS,                           // VkPipelineBindPoint             pipelineBindPoint;
        0u,                                                        // uint32_t                        viewMask;
        static_cast<uint32_t>(
            inputAttachmentReferences.size()),      // uint32_t                        inputAttachmentCount;
        dataOrNullPtr(inputAttachmentReferences),   // const VkAttachmentReference2*   pInputAttachments;
        4u,                                         // uint32_t                        colorAttachmentCount;
        dataOrNullPtr(attachmentReferences),        // const VkAttachmentReference2*   pColorAttachments;
        dataOrNullPtr(resolveAttachmentReferences), // const VkAttachmentReference2*   pResolveAttachments;
        perPass.hasDepthStencil ? &attachmentReferences.back() :
                                  DE_NULL, // const VkAttachmentReference2*   pDepthStencilAttachment;
        preserveAttachments ? static_cast<uint32_t>(preserveAttachments->size()) :
                              0, // uint32_t                        preserveAttachmentCount;
        preserveAttachments ? dataOrNullPtr(*preserveAttachments) :
                              nullptr, // const uint32_t*                 pPreserveAttachments;
    };

    // Append MSRTSS to subpass desc
    msrtss = VkMultisampledRenderToSingleSampledInfoEXT{
        VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, // VkStructureType            sType
        subpassDescription.pNext,                                         // const void*                pNext
        VK_TRUE,            // VkBool32                    multisampledRenderToSingleSampledEnable
        perPass.numSamples, // VkSampleCountFlagBits    rasterizationSamples
    };
    if (needsMsrtss)
        subpassDescription.pNext = &msrtss;

    subpasses.push_back(subpassDescription);
}

void addSubpassDependency(const uint32_t subpassNdx, std::vector<VkSubpassDependency2> &subpassDependencies)
{
    subpassDependencies.push_back(VkSubpassDependency2{
        VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, // VkStructureType         sType;
        DE_NULL,                                // const void*             pNext;
        subpassNdx - 1,                         // uint32_t                srcSubpass;
        subpassNdx,                             // uint32_t                dstSubpass;

        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
            VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, // VkPipelineStageFlags    srcStageMask;

        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
            VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, // VkPipelineStageFlags    dstStageMask;

        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags           srcAccessMask;

        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, // VkAccessFlags           dstAccessMask;

        VK_DEPENDENCY_BY_REGION_BIT, // VkDependencyFlags       dependencyFlags;
        0,                           // int32_t                 viewOffset;
    });
}

void createRenderPassAndFramebuffer(Context &context, WorkingData &wd, TestObjects &testObjects,
                                    const PipelineConstructionType pipelineConstructionType,
                                    const std::vector<VkImage> &images, const std::vector<VkImageView> &attachments,
                                    const std::vector<VkAttachmentDescription2> &attachmentDescriptions,
                                    const std::vector<VkSubpassDescription2> &subpasses,
                                    const std::vector<VkSubpassDependency2> &subpassDependencies)
{
    const DeviceInterface &vk = context.getDeviceInterface();
    const VkDevice device     = context.getDevice();

    const VkRenderPassCreateInfo2 renderPassInfo = {
        VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,          // VkStructureType sType;
        DE_NULL,                                              // const void* pNext;
        (VkRenderPassCreateFlags)0,                           // VkRenderPassCreateFlags flags;
        static_cast<uint32_t>(attachmentDescriptions.size()), // uint32_t attachmentCount;
        dataOrNullPtr(attachmentDescriptions),                // const VkAttachmentDescription2* pAttachments;
        static_cast<uint32_t>(subpasses.size()),              // uint32_t subpassCount;
        dataOrNullPtr(subpasses),                             // const VkSubpassDescription2* pSubpasses;
        static_cast<uint32_t>(subpassDependencies.size()),    // uint32_t dependencyCount;
        dataOrNullPtr(subpassDependencies),                   // const VkSubpassDependency2* pDependencies;
        0u,      // uint32_t                         correlatedViewMaskCount;
        DE_NULL, // const uint32_t*                  pCorrelatedViewMasks;
    };

    testObjects.renderPassFramebuffers.emplace_back(
        RenderPassWrapper(pipelineConstructionType, vk, device, &renderPassInfo));
    testObjects.renderPassFramebuffers.back().createFramebuffer(vk, device, static_cast<uint32_t>(attachments.size()),
                                                                dataOrNullPtr(images), dataOrNullPtr(attachments),
                                                                wd.framebufferSize.x(), wd.framebufferSize.y());
}

void createWorkingData(Context &context, const TestParams &params, WorkingData &wd)
{
    const DeviceInterface &vk    = context.getDeviceInterface();
    const VkDevice device        = context.getDevice();
    MovePtr<Allocator> allocator = MovePtr<Allocator>(new SimpleAllocator(
        vk, device, getPhysicalDeviceMemoryProperties(context.getInstanceInterface(), context.getPhysicalDevice())));

    // Create images
    {
        // TODO: change image types to be nonuniform, for example: mip 1 of 2D image, mip 2/level 3 of 2D array image, etc.
        wd.floatColor1.allocate(vk, device, allocator, params.floatColor1Format, wd.framebufferSize,
                                params.numFloatColor1Samples, colorImageUsageFlags, VK_IMAGE_ASPECT_COLOR_BIT, 1, true);
        wd.floatColor2.allocate(vk, device, allocator, params.floatColor2Format, wd.framebufferSize,
                                params.numFloatColor2Samples, colorImageUsageFlags, VK_IMAGE_ASPECT_COLOR_BIT, 1, true);
        wd.intColor.allocate(vk, device, allocator, params.intColorFormat, wd.framebufferSize,
                             params.numIntColorSamples, colorImageUsageFlags, VK_IMAGE_ASPECT_COLOR_BIT, 1, true);
        wd.depthStencil.allocate(vk, device, allocator, params.depthStencilFormat, wd.framebufferSize,
                                 params.numDepthStencilSamples, depthStencilImageUsageFlags,
                                 getDepthStencilAspectFlags(params.depthStencilFormat), 1, true);

        if (!params.renderToAttachment)
        {
            wd.dataColor1.allocate(vk, device, allocator, params.floatColor1Format, wd.framebufferSize,
                                   params.numFloatColor1Samples, colorImageUsageFlags, VK_IMAGE_ASPECT_COLOR_BIT, 1,
                                   true);
            VkDeviceSize bufferSize = static_cast<VkDeviceSize>(wd.framebufferSize.x() * wd.framebufferSize.y() * 4u);
            wd.dataBuffer =
                makeBuffer(vk, device, bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT);
            wd.dataBufferAlloc = bindBuffer(vk, device, *allocator, *wd.dataBuffer, MemoryRequirement::HostVisible);
        }

        if (isDepthFormat(params.depthStencilFormat))
            wd.depthOnlyImageView =
                wd.depthStencil.makeView(vk, device, params.depthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT, 1);

        if (isStencilFormat(params.depthStencilFormat))
            wd.stencilOnlyImageView =
                wd.depthStencil.makeView(vk, device, params.depthStencilFormat, VK_IMAGE_ASPECT_STENCIL_BIT, 1);

        if (params.numFloatColor1Samples != VK_SAMPLE_COUNT_1_BIT)
        {
            wd.floatResolve1.allocate(vk, device, allocator, params.floatColor1Format, wd.framebufferSize,
                                      VK_SAMPLE_COUNT_1_BIT, colorImageUsageFlags, VK_IMAGE_ASPECT_COLOR_BIT, 1, false);
        }

        if (params.numFloatColor2Samples != VK_SAMPLE_COUNT_1_BIT)
        {
            wd.floatResolve2.allocate(vk, device, allocator, params.floatColor2Format, wd.framebufferSize,
                                      VK_SAMPLE_COUNT_1_BIT, colorImageUsageFlags, VK_IMAGE_ASPECT_COLOR_BIT, 1, false);
        }

        if (params.numIntColorSamples != VK_SAMPLE_COUNT_1_BIT)
        {
            wd.intResolve.allocate(vk, device, allocator, params.intColorFormat, wd.framebufferSize,
                                   VK_SAMPLE_COUNT_1_BIT, colorImageUsageFlags, VK_IMAGE_ASPECT_COLOR_BIT, 1, false);
        }

        if (params.numDepthStencilSamples != VK_SAMPLE_COUNT_1_BIT)
        {
            wd.depthStencilResolve.allocate(vk, device, allocator, params.depthStencilFormat, wd.framebufferSize,
                                            VK_SAMPLE_COUNT_1_BIT, depthStencilImageUsageFlags,
                                            getDepthStencilAspectFlags(params.depthStencilFormat), 1, false);

            if (isDepthFormat(params.depthStencilFormat))
                wd.depthOnlyResolveImageView = wd.depthStencilResolve.makeView(vk, device, params.depthStencilFormat,
                                                                               VK_IMAGE_ASPECT_DEPTH_BIT, 1);

            if (isStencilFormat(params.depthStencilFormat))
                wd.stencilOnlyResolveImageView = wd.depthStencilResolve.makeView(vk, device, params.depthStencilFormat,
                                                                                 VK_IMAGE_ASPECT_STENCIL_BIT, 1);
        }

        wd.verify.allocate(vk, device, allocator, VK_FORMAT_R8G8B8A8_UNORM, wd.framebufferSize, VK_SAMPLE_COUNT_1_BIT,
                           VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
                               VK_IMAGE_USAGE_TRANSFER_DST_BIT,
                           VK_IMAGE_ASPECT_COLOR_BIT, 5, false);
    }

    // Create vertex and verification buffers
    {
        // A fullscreen triangle
        const std::vector<Vec4> vertices = {
            Vec4(-1.0f, -1.0f, 0.0f, 1.0f),
            Vec4(3.0f, -1.0f, 0.0f, 1.0f),
            Vec4(-1.0f, 3.0f, 0.0f, 1.0f),
        };

        const VkDeviceSize vertexBufferSize = static_cast<VkDeviceSize>(sizeof(vertices[0]) * vertices.size());
        wd.vertexBuffer      = makeBuffer(vk, device, vertexBufferSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
        wd.vertexBufferAlloc = bindBuffer(vk, device, *allocator, *wd.vertexBuffer, MemoryRequirement::HostVisible);

        deMemcpy(wd.vertexBufferAlloc->getHostPtr(), dataOrNullPtr(vertices),
                 static_cast<std::size_t>(vertexBufferSize));
        flushMappedMemoryRange(vk, device, wd.vertexBufferAlloc->getMemory(), wd.vertexBufferAlloc->getOffset(),
                               VK_WHOLE_SIZE);

        // Initialize the verification data with 0.
        const VerificationResults results = {};

        wd.verificationBuffer = makeBuffer(vk, device, sizeof(results), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
        wd.verificationBufferAlloc =
            bindBuffer(vk, device, *allocator, *wd.verificationBuffer, MemoryRequirement::HostVisible);

        deMemcpy(wd.verificationBufferAlloc->getHostPtr(), &results, sizeof(results));
        flushMappedMemoryRange(vk, device, wd.verificationBufferAlloc->getMemory(),
                               wd.verificationBufferAlloc->getOffset(), VK_WHOLE_SIZE);

        wd.singleVerificationBuffer = makeBuffer(vk, device, sizeof(results), VK_BUFFER_USAGE_STORAGE_BUFFER_BIT);
        wd.singleVerificationBufferAlloc =
            bindBuffer(vk, device, *allocator, *wd.singleVerificationBuffer, MemoryRequirement::HostVisible);

        deMemcpy(wd.singleVerificationBufferAlloc->getHostPtr(), &results, sizeof(results));
        flushMappedMemoryRange(vk, device, wd.singleVerificationBufferAlloc->getMemory(),
                               wd.singleVerificationBufferAlloc->getOffset(), VK_WHOLE_SIZE);
    }
}

void checkRequirements(Context &context, TestParams params)
{
    const VkPhysicalDevice physicalDevice          = context.getPhysicalDevice();
    const vk::InstanceInterface &instanceInterface = context.getInstanceInterface();

    checkPipelineConstructionRequirements(instanceInterface, physicalDevice, params.pipelineConstructionType);

    context.requireDeviceFunctionality("VK_KHR_depth_stencil_resolve");
    context.requireDeviceFunctionality("VK_KHR_create_renderpass2");

    if (params.dynamicRendering)
        context.requireDeviceFunctionality("VK_KHR_dynamic_rendering");

    if (params.isMultisampledRenderToSingleSampled)
    {
        context.requireDeviceFunctionality("VK_EXT_multisampled_render_to_single_sampled");

        // Check extension feature
        {
            VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT msrtssFeatures = {
                VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT,
                DE_NULL,
                VK_FALSE,
            };
            VkPhysicalDeviceFeatures2 physicalDeviceFeatures = {
                VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
                &msrtssFeatures,
                {},
            };

            instanceInterface.getPhysicalDeviceFeatures2(physicalDevice, &physicalDeviceFeatures);

            if (msrtssFeatures.multisampledRenderToSingleSampled != VK_TRUE)
            {
                TCU_THROW(NotSupportedError, "multisampledRenderToSingleSampled not supported");
            }
        }
    }

    // Check whether formats are supported with the requested usage and sample counts.
    {
        VkImageFormatProperties imageProperties;
        checkImageRequirements(context, params.floatColor1Format,
                               VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT |
                                   VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
                               colorImageUsageFlags, params.numFloatColor1Samples, imageProperties);
        if (params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT)
            for (const TestParams::PerPass &perPass : params.perPass)
                if (perPass.floatColor1Location >= 0 &&
                    (imageProperties.sampleCounts & perPass.numSamples) != perPass.numSamples)
                    TCU_THROW(NotSupportedError,
                              (de::toString(params.floatColor1Format) + ": sample count not supported").c_str());
    }
    {
        VkImageFormatProperties imageProperties;
        checkImageRequirements(context, params.floatColor2Format,
                               VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT |
                                   VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
                               colorImageUsageFlags, params.numFloatColor2Samples, imageProperties);
        if (params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT)
            for (const TestParams::PerPass &perPass : params.perPass)
                if (perPass.floatColor2Location >= 0 &&
                    (imageProperties.sampleCounts & perPass.numSamples) != perPass.numSamples)
                    TCU_THROW(NotSupportedError,
                              (de::toString(params.floatColor2Format) + ": sample count not supported").c_str());
    }
    {
        VkImageFormatProperties imageProperties;
        checkImageRequirements(context, params.intColorFormat,
                               VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
                               colorImageUsageFlags, params.numIntColorSamples, imageProperties);
        if (params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT)
            for (const TestParams::PerPass &perPass : params.perPass)
                if (perPass.intColorLocation >= 0 &&
                    (imageProperties.sampleCounts & perPass.numSamples) != perPass.numSamples)
                    TCU_THROW(NotSupportedError,
                              (de::toString(params.intColorFormat) + ": sample count not supported").c_str());
    }
    {
        VkImageFormatProperties imageProperties;
        checkImageRequirements(context, params.depthStencilFormat,
                               VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,
                               depthStencilImageUsageFlags, params.numDepthStencilSamples, imageProperties);
        if (params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT)
            for (const TestParams::PerPass &perPass : params.perPass)
                if (perPass.hasDepthStencil &&
                    (imageProperties.sampleCounts & perPass.numSamples) != perPass.numSamples)
                    TCU_THROW(NotSupportedError,
                              (de::toString(params.depthStencilFormat) + ": sample count not supported").c_str());
    }

    // Perform query to get supported depth/stencil resolve modes.
    VkPhysicalDeviceDepthStencilResolveProperties dsResolveProperties = {};
    dsResolveProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;

    VkPhysicalDeviceProperties2 deviceProperties = {};
    deviceProperties.sType                       = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
    deviceProperties.pNext                       = &dsResolveProperties;

    instanceInterface.getPhysicalDeviceProperties2(physicalDevice, &deviceProperties);

    for (const TestParams::PerPass &perPass : params.perPass)
    {
        // Check whether sample counts used for rendering are acceptable
        const bool checkColor =
            perPass.floatColor1Location >= 0 || perPass.floatColor2Location >= 0 || perPass.intColorLocation >= 0;
        const bool checkDepth   = perPass.hasDepthStencil && isDepthFormat(params.depthStencilFormat);
        const bool checkStencil = perPass.hasDepthStencil && isStencilFormat(params.depthStencilFormat);
        checkSampleRequirements(context, perPass.numSamples, checkColor, checkDepth, checkStencil);

        // Check whether depth/stencil resolve mode is supported
        if (perPass.depthStencilResolveMode != VK_RESOLVE_MODE_NONE &&
            ((dsResolveProperties.supportedDepthResolveModes & perPass.depthStencilResolveMode) == 0 ||
             (dsResolveProperties.supportedStencilResolveModes & perPass.depthStencilResolveMode) == 0))
        {
            TCU_THROW(NotSupportedError, "Depth/stencil resolve mode not supported");
        }
    }

    context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING);
}

void checkHasMsrtss(Context &context, VkFormat)
{
    context.requireDeviceFunctionality("VK_EXT_multisampled_render_to_single_sampled");
}

void generateRandomClearValues(de::Random &rng, const TestParams &params, VkClearValue clearValues[4], bool smallValues)
{
    const bool usesSignedIntFormat = params.intColorFormat == VK_FORMAT_R16G16B16A16_SINT;

    const float minFloatValue      = 0.05f;
    const float maxFloatValue      = smallValues ? 0.1f : 0.95f;
    const uint32_t minIntValue     = smallValues ? 20 : 5000;
    const uint32_t maxIntValue     = smallValues ? 100 : 10000;
    const float minDepthValue      = 0.05f;
    const float maxDepthValue      = smallValues ? 0.1f : 0.5f;
    const uint32_t minStencilValue = 0x10;
    const uint32_t maxStencilValue = 0x20;

    clearValues[0].color.float32[0]     = rng.getFloat(minFloatValue, maxFloatValue);
    clearValues[0].color.float32[1]     = rng.getFloat(minFloatValue, maxFloatValue);
    clearValues[0].color.float32[2]     = rng.getFloat(minFloatValue, maxFloatValue);
    clearValues[0].color.float32[3]     = rng.getFloat(minFloatValue, maxFloatValue);
    clearValues[1].color.float32[0]     = rng.getFloat(minFloatValue, maxFloatValue);
    clearValues[1].color.float32[1]     = rng.getFloat(minFloatValue, maxFloatValue);
    clearValues[1].color.float32[2]     = rng.getFloat(minFloatValue, maxFloatValue);
    clearValues[1].color.float32[3]     = rng.getFloat(minFloatValue, maxFloatValue);
    clearValues[2].color.int32[0]       = (usesSignedIntFormat ? -1 : 1) * rng.getInt(minIntValue, maxIntValue);
    clearValues[2].color.int32[1]       = (usesSignedIntFormat ? -1 : 1) * rng.getInt(minIntValue, maxIntValue);
    clearValues[2].color.int32[2]       = (usesSignedIntFormat ? -1 : 1) * rng.getInt(minIntValue, maxIntValue);
    clearValues[2].color.int32[3]       = (usesSignedIntFormat ? -1 : 1) * rng.getInt(minIntValue, maxIntValue);
    clearValues[3].depthStencil.depth   = rng.getFloat(minDepthValue, maxDepthValue);
    clearValues[3].depthStencil.stencil = rng.getInt(minStencilValue, maxStencilValue);
}

void clearImagesBeforeDraw(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    const DeviceInterface &vk = context.getDeviceInterface();

    const VkImageMemoryBarrier imageBarrierTemplate = {
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType            sType;
        DE_NULL,                                // const void*                pNext;
        0,                                      // VkAccessFlags              srcAccessMask;
        VK_ACCESS_TRANSFER_WRITE_BIT,           // VkAccessFlags              dstAccessMask;
        VK_IMAGE_LAYOUT_UNDEFINED,              // VkImageLayout              oldLayout;
        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,   // VkImageLayout              newLayout;
        VK_QUEUE_FAMILY_IGNORED,                // uint32_t                   srcQueueFamilyIndex;
        VK_QUEUE_FAMILY_IGNORED,                // uint32_t                   dstQueueFamilyIndex;
        0,                                      // VkImage                    image;
        makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u,
                                  1u), // VkImageSubresourceRange    subresourceRange;
    };

    VkImage firstImage = params.renderToAttachment ? *wd.floatColor1.image : *wd.dataColor1.image;

    VkImageMemoryBarrier preClearBarriers[4]        = {imageBarrierTemplate, imageBarrierTemplate, imageBarrierTemplate,
                                                       imageBarrierTemplate};
    preClearBarriers[0].image                       = firstImage;
    preClearBarriers[1].image                       = *wd.floatColor2.image;
    preClearBarriers[2].image                       = *wd.intColor.image;
    preClearBarriers[3].image                       = *wd.depthStencil.image;
    preClearBarriers[3].subresourceRange.aspectMask = getDepthStencilAspectFlags(params.depthStencilFormat);

    vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
                          0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(preClearBarriers), preClearBarriers);

    vk.cmdClearColorImage(*testObjects.cmdBuffer, firstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                          &params.clearValues[0].color, 1, &preClearBarriers[0].subresourceRange);
    vk.cmdClearColorImage(*testObjects.cmdBuffer, *wd.floatColor2.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                          &params.clearValues[1].color, 1, &preClearBarriers[1].subresourceRange);
    vk.cmdClearColorImage(*testObjects.cmdBuffer, *wd.intColor.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                          &params.clearValues[2].color, 1, &preClearBarriers[2].subresourceRange);
    vk.cmdClearDepthStencilImage(*testObjects.cmdBuffer, *wd.depthStencil.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                                 &params.clearValues[3].depthStencil, 1, &preClearBarriers[3].subresourceRange);

    const VkMemoryBarrier postClearBarrier = {
        VK_STRUCTURE_TYPE_MEMORY_BARRIER, // VkStructureType    sType;
        DE_NULL,                          // const void*        pNext;
        VK_ACCESS_TRANSFER_WRITE_BIT,     // VkAccessFlags      srcAccessMask;
        VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags      dstAccessMask;
    };

    vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
                          VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
                              VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
                          0u, 1u, &postClearBarrier, 0u, DE_NULL, 0u, DE_NULL);
}

void getDrawRegions(WorkingData &wd, UVec4 regions[RegionCount])
{
    static_assert(RegionCount == 4, "Update this function to generate the correct number of regions");

    UVec2 oneThirdRenderAreaSize(wd.renderArea.z() / 3, wd.renderArea.w() / 3);
    UVec2 twoThirdsRenderAreaSize(wd.renderArea.z() - oneThirdRenderAreaSize.x(),
                                  wd.renderArea.w() - oneThirdRenderAreaSize.y());
    UVec2 renderAreaSplit(wd.renderArea.x() + oneThirdRenderAreaSize.x(),
                          wd.renderArea.y() + oneThirdRenderAreaSize.y());

    regions[0] = UVec4(wd.renderArea.x(), wd.renderArea.y(), oneThirdRenderAreaSize.x(), oneThirdRenderAreaSize.y());
    regions[1] = UVec4(renderAreaSplit.x(), wd.renderArea.y(), twoThirdsRenderAreaSize.x(), oneThirdRenderAreaSize.y());
    regions[2] = UVec4(wd.renderArea.x(), renderAreaSplit.y(), oneThirdRenderAreaSize.x(), twoThirdsRenderAreaSize.y());
    regions[3] =
        UVec4(renderAreaSplit.x(), renderAreaSplit.y(), twoThirdsRenderAreaSize.x(), twoThirdsRenderAreaSize.y());
}

void startRenderPass(Context &context, WorkingData &wd, TestObjects &testObjects, const uint32_t clearValueCount,
                     const VkClearValue *clearValues)
{
    const DeviceInterface &vk = context.getDeviceInterface();

    const VkRect2D renderArea = {{static_cast<int32_t>(wd.renderArea.x()), static_cast<int32_t>(wd.renderArea.y())},
                                 {wd.renderArea.z(), wd.renderArea.w()}};

    testObjects.renderPassFramebuffers.back().begin(vk, *testObjects.cmdBuffer, renderArea, clearValueCount,
                                                    clearValues);
}

void startRendering(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects,
                    uint32_t colorAttachmentCount, std::vector<VkRenderingAttachmentInfo> &colorAttachmentInfos,
                    VkRenderingAttachmentInfo &depthStencilAttachmentInfo, uint32_t renderPassNdx)
{
    const DeviceInterface &vk          = context.getDeviceInterface();
    const TestParams::PerPass &perPass = params.perPass[renderPassNdx];

    bool anySingleSampledAttachmentsUsed = false;
    if (perPass.floatColor1Location >= 0)
    {
        anySingleSampledAttachmentsUsed =
            anySingleSampledAttachmentsUsed || params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT;
    }
    if (perPass.floatColor2Location >= 0)
    {
        anySingleSampledAttachmentsUsed =
            anySingleSampledAttachmentsUsed || params.numFloatColor2Samples == VK_SAMPLE_COUNT_1_BIT;
    }
    if (perPass.intColorLocation >= 0)
    {
        anySingleSampledAttachmentsUsed =
            anySingleSampledAttachmentsUsed || params.numIntColorSamples == VK_SAMPLE_COUNT_1_BIT;
    }
    if (perPass.hasDepthStencil)
    {
        anySingleSampledAttachmentsUsed =
            anySingleSampledAttachmentsUsed || params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT;
    }

    // Append MSRTSS to subpass desc
    VkMultisampledRenderToSingleSampledInfoEXT msrtss = {
        VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, // VkStructureType            sType
        DE_NULL,                                                          // const void*                pNext
        VK_TRUE,           // VkBool32                    multisampledRenderToSingleSampledEnable
        perPass.numSamples // VkSampleCountFlagBits    rasterizationSamples
    };

    const VkRect2D renderArea = {{static_cast<int32_t>(wd.renderArea.x()), static_cast<int32_t>(wd.renderArea.y())},
                                 {wd.renderArea.z(), wd.renderArea.w()}};

    const bool useDepthStencil = params.usesDepthStencilInPass(renderPassNdx);

    VkRenderingInfo renderingInfo = {
        VK_STRUCTURE_TYPE_RENDERING_INFO, // VkStructureType                        sType
        DE_NULL,                          // const void*                            pNext
        (VkRenderingFlags)0,              // VkRenderingFlags                        flags
        renderArea,                       // VkRect2D                                renderArea
        1u,                               // uint32_t                                layerCount
        0u,                               // uint32_t                                viewMask
        colorAttachmentCount,             // uint32_t                                colorAttachmentCount
        colorAttachmentInfos.data(),      // const VkRenderingAttachmentInfo*        pColorAttachments
        useDepthStencil && isDepthFormat(params.depthStencilFormat) ?
            &depthStencilAttachmentInfo :
            DE_NULL, // const VkRenderingAttachmentInfo*        pDepthAttachment
        useDepthStencil && isStencilFormat(params.depthStencilFormat) ?
            &depthStencilAttachmentInfo :
            DE_NULL // const VkRenderingAttachmentInfo*        pStencilAttachment
    };

    if (anySingleSampledAttachmentsUsed && perPass.numSamples != VK_SAMPLE_COUNT_1_BIT)
        renderingInfo.pNext = &msrtss;

    vk.cmdBeginRendering(*testObjects.cmdBuffer, &renderingInfo);
}

void postDrawBarrier(Context &context, TestObjects &testObjects)
{
    const DeviceInterface &vk = context.getDeviceInterface();

    const VkMemoryBarrier barrier = {
        VK_STRUCTURE_TYPE_MEMORY_BARRIER, // VkStructureType    sType;
        DE_NULL,                          // const void*        pNext;
        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
            VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags      srcAccessMask;
        VK_ACCESS_SHADER_READ_BIT,                        // VkAccessFlags      dstAccessMask;
    };

    vk.cmdPipelineBarrier(*testObjects.cmdBuffer,
                          VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
                              VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
                          VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 1u, &barrier, 0u, DE_NULL, 0u, DE_NULL);
}

void setupVerifyDescriptorSetAndPipeline(Context &context, const TestParams &params, WorkingData &wd,
                                         TestObjects &testObjects, const VkPushConstantRange *pushConstantRange,
                                         Move<VkPipelineLayout> &verifyPipelineLayout)
{
    const DeviceInterface &vk = context.getDeviceInterface();
    const VkDevice device     = context.getDevice();

    const Unique<VkDescriptorSetLayout> descriptorSetLayout(
        DescriptorSetLayoutBuilder()
            .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
            .build(vk, device));

    testObjects.descriptorPools.emplace_back(
        DescriptorPoolBuilder()
            .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
            .addType(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 5u)
            .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1u)
            .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));

    testObjects.descriptorSets.emplace_back(
        makeDescriptorSet(vk, device, *testObjects.descriptorPools.back(), *descriptorSetLayout));

    const VkDescriptorBufferInfo resultBufferInfo =
        makeDescriptorBufferInfo(*wd.verificationBuffer, 0ull, sizeof(VerificationResults));
    const VkDescriptorImageInfo color1ImageInfo = makeDescriptorImageInfo(
        DE_NULL, *wd.getResolvedFloatColorImage1View(params), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
    const VkDescriptorImageInfo color2ImageInfo = makeDescriptorImageInfo(
        DE_NULL, *wd.getResolvedFloatColorImage2View(params), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
    const VkDescriptorImageInfo color3ImageInfo = makeDescriptorImageInfo(
        DE_NULL, *wd.getResolvedIntColorImageView(params), VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
    const VkDescriptorImageInfo depthImageInfo = makeDescriptorImageInfo(
        DE_NULL, *wd.getResolvedDepthOnlyImageView(params), VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL);
    const VkDescriptorImageInfo stencilImageInfo = makeDescriptorImageInfo(
        DE_NULL, *wd.getResolvedStencilOnlyImageView(params), VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL);
    const VkDescriptorImageInfo verifyImageInfo =
        makeDescriptorImageInfo(DE_NULL, *wd.verify.view, VK_IMAGE_LAYOUT_GENERAL);

    DescriptorSetUpdateBuilder builder;

    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(0u),
                        VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultBufferInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(1u),
                        VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &color1ImageInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(2u),
                        VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &color2ImageInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(3u),
                        VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &color3ImageInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(4u),
                        VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &depthImageInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(5u),
                        VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &stencilImageInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(6u),
                        VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &verifyImageInfo);

    builder.update(vk, device);

    const Unique<VkShaderModule> verifyModule(
        createShaderModule(vk, device, context.getBinaryCollection().get("comp"), 0u));

    verifyPipelineLayout = makePipelineLayout(vk, device, 1, &*descriptorSetLayout, 1, pushConstantRange);

    testObjects.computePipelines.push_back(
        PipelineSp(new Unique<VkPipeline>(makeComputePipeline(vk, device, *verifyPipelineLayout, *verifyModule))));

    vk.cmdBindPipeline(*testObjects.cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, **testObjects.computePipelines.back());
    vk.cmdBindDescriptorSets(*testObjects.cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *verifyPipelineLayout, 0u, 1u,
                             &testObjects.descriptorSets.back().get(), 0u, DE_NULL);
}

void postVerifyBarrier(Context &context, TestObjects &testObjects, const Move<VkBuffer> &verificationBuffer)
{
    const DeviceInterface &vk = context.getDeviceInterface();

    const VkBufferMemoryBarrier barrier = {
        VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType    sType;
        DE_NULL,                                 // const void*        pNext;
        VK_ACCESS_SHADER_WRITE_BIT,              // VkAccessFlags      srcAccessMask;
        VK_ACCESS_HOST_READ_BIT,                 // VkAccessFlags      dstAccessMask;
        VK_QUEUE_FAMILY_IGNORED,                 // uint32_t           srcQueueFamilyIndex;
        VK_QUEUE_FAMILY_IGNORED,                 // uint32_t           dstQueueFamilyIndex;
        *verificationBuffer,                     // VkBuffer           buffer;
        0ull,                                    // VkDeviceSize       offset;
        VK_WHOLE_SIZE,                           // VkDeviceSize       size;
    };

    vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
                          0u, DE_NULL, 1u, &barrier, 0u, DE_NULL);
}

void dispatchVerifyConstantColor(Context &context, TestObjects &testObjects, const Move<VkImageView> &imageView,
                                 const VkImageLayout layout, const Move<VkImageView> &verifyImageView,
                                 const Move<VkBuffer> &verificationBuffer, const uint32_t pushConstantSize,
                                 const void *pushConstants, const std::string &shaderName)
{
    const DeviceInterface &vk = context.getDeviceInterface();
    const VkDevice device     = context.getDevice();

    // Set up descriptor set
    const Unique<VkDescriptorSetLayout> descriptorSetLayout(
        DescriptorSetLayoutBuilder()
            .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_COMPUTE_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_COMPUTE_BIT)
            .build(vk, device));

    testObjects.descriptorPools.emplace_back(
        DescriptorPoolBuilder()
            .addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
            .addType(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1u)
            .addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1u)
            .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));

    testObjects.descriptorSets.emplace_back(
        makeDescriptorSet(vk, device, *testObjects.descriptorPools.back(), *descriptorSetLayout));

    const VkDescriptorBufferInfo resultBufferInfo =
        makeDescriptorBufferInfo(*verificationBuffer, 0ull, sizeof(VerificationResults));
    const VkDescriptorImageInfo imageInfo = makeDescriptorImageInfo(DE_NULL, *imageView, layout);
    const VkDescriptorImageInfo verifyImageInfo =
        makeDescriptorImageInfo(DE_NULL, *verifyImageView, VK_IMAGE_LAYOUT_GENERAL);

    DescriptorSetUpdateBuilder builder;

    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(0u),
                        VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &resultBufferInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(1u),
                        VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, &imageInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(2u),
                        VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, &verifyImageInfo);

    builder.update(vk, device);

    // Setup pipeline
    const VkPushConstantRange &verifyPushConstantRange = {
        VK_SHADER_STAGE_COMPUTE_BIT, // VkShaderStageFlags    stageFlags;
        0,                           // uint32_t              offset;
        pushConstantSize,            // uint32_t              size;
    };

    const Unique<VkShaderModule> verifyModule(
        createShaderModule(vk, device, context.getBinaryCollection().get(shaderName), 0u));
    const Unique<VkPipelineLayout> verifyPipelineLayout(
        makePipelineLayout(vk, device, 1, &*descriptorSetLayout, 1, &verifyPushConstantRange));

    testObjects.computePipelines.push_back(
        PipelineSp(new Unique<VkPipeline>(makeComputePipeline(vk, device, *verifyPipelineLayout, *verifyModule))));

    vk.cmdBindPipeline(*testObjects.cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, **testObjects.computePipelines.back());
    vk.cmdBindDescriptorSets(*testObjects.cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *verifyPipelineLayout, 0u, 1u,
                             &testObjects.descriptorSets.back().get(), 0u, DE_NULL);

    const VkMemoryBarrier preVerifyBarrier = {
        VK_STRUCTURE_TYPE_MEMORY_BARRIER,                       // VkStructureType    sType;
        DE_NULL,                                                // const void*        pNext;
        VK_ACCESS_SHADER_WRITE_BIT,                             // VkAccessFlags      srcAccessMask;
        VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT, // VkAccessFlags      dstAccessMask;
    };

    vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                          VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 1u, &preVerifyBarrier, 0u,
                          DE_NULL, 0u, DE_NULL);

    // Area is always the first uvec4
    const UVec4 *area = static_cast<const UVec4 *>(pushConstants);

    vk.cmdPushConstants(*testObjects.cmdBuffer, *verifyPipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, pushConstantSize,
                        pushConstants);
    vk.cmdDispatch(*testObjects.cmdBuffer, (area->z() + 7) / 8, (area->w() + 7) / 8, 1);

    postVerifyBarrier(context, testObjects, verificationBuffer);
}

void testStart(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    de::Random rng(params.rngSeed);

    wd.framebufferSize = UVec2(rng.getInt(60, 80), rng.getInt(48, 64));
    wd.renderArea      = UVec4(0, 0, wd.framebufferSize.x(), wd.framebufferSize.y());
    if (!params.renderToWholeFramebuffer)
    {
        wd.renderArea.x() += rng.getInt(5, 15);
        wd.renderArea.y() += rng.getInt(5, 15);
        wd.renderArea.z() -= wd.renderArea.x() + rng.getInt(2, 12);
        wd.renderArea.w() -= wd.renderArea.y() + rng.getInt(2, 12);
    }

    createWorkingData(context, params, wd);

    testObjects.beginCommandBuffer();

    const DeviceInterface &vk = context.getDeviceInterface();

    // Clear verify image
    {
        VkImageMemoryBarrier clearBarrier = {
            VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType            sType;
            DE_NULL,                                // const void*                pNext;
            0,                                      // VkAccessFlags              srcAccessMask;
            VK_ACCESS_TRANSFER_WRITE_BIT,           // VkAccessFlags              dstAccessMask;
            VK_IMAGE_LAYOUT_UNDEFINED,              // VkImageLayout              oldLayout;
            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,   // VkImageLayout              newLayout;
            VK_QUEUE_FAMILY_IGNORED,                // uint32_t                   srcQueueFamilyIndex;
            VK_QUEUE_FAMILY_IGNORED,                // uint32_t                   dstQueueFamilyIndex;
            *wd.verify.image,                       // VkImage                    image;
            makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u,
                                      5u), // VkImageSubresourceRange    subresourceRange;
        };

        vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
                              0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &clearBarrier);

        VkClearColorValue clearToBlack;
        clearToBlack.float32[0] = 0;
        clearToBlack.float32[1] = 0;
        clearToBlack.float32[2] = 0;
        clearToBlack.float32[3] = 1.0;
        vk.cmdClearColorImage(*testObjects.cmdBuffer, *wd.verify.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                              &clearToBlack, 1, &clearBarrier.subresourceRange);
    }

    // Transition it to GENERAL
    {
        VkImageMemoryBarrier verifyBarrier = {
            VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType            sType;
            DE_NULL,                                // const void*                pNext;
            VK_ACCESS_TRANSFER_WRITE_BIT,           // VkAccessFlags              srcAccessMask;
            VK_ACCESS_SHADER_WRITE_BIT,             // VkAccessFlags              dstAccessMask;
            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,   // VkImageLayout              oldLayout;
            VK_IMAGE_LAYOUT_GENERAL,                // VkImageLayout              newLayout;
            VK_QUEUE_FAMILY_IGNORED,                // uint32_t                   srcQueueFamilyIndex;
            VK_QUEUE_FAMILY_IGNORED,                // uint32_t                   dstQueueFamilyIndex;
            *wd.verify.image,                       // VkImage                    image;
            makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u,
                                      5u), // VkImageSubresourceRange    subresourceRange;
        };

        vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
                              VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &verifyBarrier);
    }
}

void testEnd(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    // If not rendering to the whole framebuffer and the images were cleared before the render pass, verify that the area outside the render pass is untouched.
    const bool verifyOutsideRenderArea = params.clearBeforeRenderPass && !params.renderToWholeFramebuffer;
    if (verifyOutsideRenderArea)
    {
        const DeviceInterface &vk = context.getDeviceInterface();
        const VkDevice device     = context.getDevice();

        const UVec4 verifyAreas[] = {
            UVec4(0, 0, wd.framebufferSize.x(), wd.renderArea.y()),
            UVec4(0, wd.renderArea.y(), wd.renderArea.x(), wd.renderArea.w()),
            UVec4(wd.renderArea.x() + wd.renderArea.z(), wd.renderArea.y(),
                  wd.framebufferSize.x() - wd.renderArea.x() - wd.renderArea.z(), wd.renderArea.w()),
            UVec4(0, wd.renderArea.y() + wd.renderArea.w(), wd.framebufferSize.x(),
                  wd.framebufferSize.y() - wd.renderArea.y() - wd.renderArea.w()),
        };

        for (uint32_t areaNdx = 0; areaNdx < DE_LENGTH_OF_ARRAY(verifyAreas); ++areaNdx)
        {
            if (params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT)
            {
                const VerifySingleFloatPushConstants verifyColor1 = {
                    verifyAreas[areaNdx],
                    Vec4(params.clearValues[0].color.float32[0], params.clearValues[0].color.float32[1],
                         params.clearValues[0].color.float32[2], params.clearValues[0].color.float32[3]),
                    0,
                };
                dispatchVerifyConstantColor(context, testObjects, wd.getResolvedFloatColorImage1View(params),
                                            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, wd.verify.view,
                                            wd.singleVerificationBuffer, static_cast<uint32_t>(sizeof(verifyColor1)),
                                            &verifyColor1, "comp_singleFloat");
            }

            if (params.numFloatColor2Samples == VK_SAMPLE_COUNT_1_BIT)
            {
                const VerifySingleFloatPushConstants verifyColor2 = {
                    verifyAreas[areaNdx],
                    Vec4(params.clearValues[1].color.float32[0], params.clearValues[1].color.float32[1],
                         params.clearValues[1].color.float32[2], params.clearValues[1].color.float32[3]),
                    1,
                };
                dispatchVerifyConstantColor(context, testObjects, wd.getResolvedFloatColorImage2View(params),
                                            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, wd.verify.view,
                                            wd.singleVerificationBuffer, static_cast<uint32_t>(sizeof(verifyColor2)),
                                            &verifyColor2, "comp_singleFloat");
            }

            if (params.numIntColorSamples == VK_SAMPLE_COUNT_1_BIT)
            {
                const VerifySingleIntPushConstants verifyColor3 = {
                    verifyAreas[areaNdx],
                    IVec4(params.clearValues[2].color.int32[0], params.clearValues[2].color.int32[1],
                          params.clearValues[2].color.int32[2], params.clearValues[2].color.int32[3]),
                    2,
                };
                dispatchVerifyConstantColor(context, testObjects, wd.getResolvedIntColorImageView(params),
                                            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, wd.verify.view,
                                            wd.singleVerificationBuffer, static_cast<uint32_t>(sizeof(verifyColor3)),
                                            &verifyColor3, "comp_singleInt");
            }

            if (params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT && isDepthFormat(params.depthStencilFormat))
            {
                const VerifySingleDepthPushConstants verifyDepth = {
                    verifyAreas[areaNdx],
                    params.clearValues[3].depthStencil.depth,
                };
                dispatchVerifyConstantColor(context, testObjects, wd.getResolvedDepthOnlyImageView(params),
                                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, wd.verify.view,
                                            wd.singleVerificationBuffer, static_cast<uint32_t>(sizeof(verifyDepth)),
                                            &verifyDepth, "comp_singleDepth");
            }

            if (params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT && isStencilFormat(params.depthStencilFormat))
            {
                const VerifySingleStencilPushConstants verifyStencil = {
                    verifyAreas[areaNdx],
                    params.clearValues[3].depthStencil.stencil,
                };
                dispatchVerifyConstantColor(context, testObjects, wd.getResolvedStencilOnlyImageView(params),
                                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, wd.verify.view,
                                            wd.singleVerificationBuffer, static_cast<uint32_t>(sizeof(verifyStencil)),
                                            &verifyStencil, "comp_singleStencil");
            }
        }

        invalidateAlloc(vk, device, *wd.singleVerificationBufferAlloc);
    }

    testObjects.submitCommandsAndWait();
}

tcu::TestStatus verify(Context &context, const TestParams &params, WorkingData &wd)
{
    bool drawsToColor1       = false;
    bool drawsToColor2       = false;
    bool drawsToColor3       = false;
    bool drawsToDepthStencil = false;
    for (const TestParams::PerPass &perPass : params.perPass)
    {
        if (perPass.floatColor1Location >= 0)
            drawsToColor1 = true;
        if (perPass.floatColor2Location >= 0)
            drawsToColor2 = true;
        if (perPass.intColorLocation >= 0)
            drawsToColor3 = true;
        if (perPass.hasDepthStencil)
            drawsToDepthStencil = true;
    }

    logTestImages(context, params, wd, drawsToColor1, drawsToColor2, drawsToColor3, drawsToDepthStencil);

    // Verify draw call results
    {
        const VerificationResults *const results =
            static_cast<const VerificationResults *>(wd.verificationBufferAlloc->getHostPtr());
        const uint32_t totalPixels = wd.renderArea.z() * wd.renderArea.w();
        bool allOk                 = true;
        const char *errorDelim     = "";
        std::string errorMsg       = "Incorrect multisampled rendering for ";

        if (drawsToColor1)
            if (!checkAndReportError(context, results->color1Verification, totalPixels, "color attachment 1"))
            {
                errorMsg += errorDelim;
                errorMsg += "color attachment 1";
                errorDelim = ", ";
                allOk      = false;
            }

        if (drawsToColor2)
            if (!checkAndReportError(context, results->color2Verification, totalPixels, "color attachment 2"))
            {
                errorMsg += errorDelim;
                errorMsg += "color attachment 2";
                errorDelim = ", ";
                allOk      = false;
            }

        if (drawsToColor3)
            if (!checkAndReportError(context, results->color3Verification, totalPixels, "color attachment 3"))
            {
                errorMsg += errorDelim;
                errorMsg += "color attachment 3";
                errorDelim = ", ";
                allOk      = false;
            }

        if (drawsToDepthStencil && isDepthFormat(params.depthStencilFormat))
            if (!checkAndReportError(context, results->depthVerification, totalPixels, "depth attachment"))
            {
                errorMsg += errorDelim;
                errorMsg += "depth attachment";
                errorDelim = ", ";
                allOk      = false;
            }

        if (drawsToDepthStencil && isStencilFormat(params.depthStencilFormat))
            if (!checkAndReportError(context, results->stencilVerification, totalPixels, "stencil attachment"))
            {
                errorMsg += errorDelim;
                errorMsg += "stencil attachment";
                errorDelim = ", ";
                allOk      = false;
            }

        if (!allOk)
        {
            logVerifyImages(context, params, wd, drawsToColor1, drawsToColor2, drawsToColor3, drawsToDepthStencil);
            return tcu::TestStatus::fail(errorMsg);
        }
    }

    const bool verifyOutsideRenderArea = params.clearBeforeRenderPass && !params.renderToWholeFramebuffer;
    if (verifyOutsideRenderArea)
    {
        const VerificationResults *const results =
            static_cast<const VerificationResults *>(wd.singleVerificationBufferAlloc->getHostPtr());
        const uint32_t totalPixels =
            wd.framebufferSize.x() * wd.framebufferSize.y() - wd.renderArea.z() * wd.renderArea.w();
        bool allOk = true;

        if (params.numFloatColor1Samples == VK_SAMPLE_COUNT_1_BIT)
            allOk = checkAndReportError(context, results->color1Verification, totalPixels,
                                        "color attachment 1 (outside render area)") &&
                    allOk;
        if (params.numFloatColor2Samples == VK_SAMPLE_COUNT_1_BIT)
            allOk = checkAndReportError(context, results->color2Verification, totalPixels,
                                        "color attachment 2 (outside render area)") &&
                    allOk;
        if (params.numIntColorSamples == VK_SAMPLE_COUNT_1_BIT)
            allOk = checkAndReportError(context, results->color3Verification, totalPixels,
                                        "color attachment 3 (outside render area)") &&
                    allOk;
        if (params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT && isDepthFormat(params.depthStencilFormat))
            allOk = checkAndReportError(context, results->depthVerification, totalPixels,
                                        "depth attachment (outside render area)") &&
                    allOk;
        if (params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT && isStencilFormat(params.depthStencilFormat))
            allOk = checkAndReportError(context, results->stencilVerification, totalPixels,
                                        "stencil attachment (outside render area)") &&
                    allOk;

        if (!allOk)
        {
            logVerifyImages(context, params, wd, drawsToColor1, drawsToColor2, drawsToColor3, drawsToDepthStencil);
            return tcu::TestStatus::fail("Detected corruption outside render area");
        }
    }

    return tcu::TestStatus::pass("Pass");
}

void initConstantColorVerifyPrograms(SourceCollections &programCollection, const TestParams params)
{
    const bool usesSignedIntFormat = params.intColorFormat == VK_FORMAT_R16G16B16A16_SINT;

    // Compute shader - Verify outside render area is intact (float colors)
    {
        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "#extension GL_EXT_samplerless_texture_functions : require\n"
            << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "    vec4 color;\n"
            << "    uint attachmentNdx;\n"
            << "} params;\n"
            << "\n"
            << "layout(local_size_x = 8, local_size_y = 8) in;\n"
            << "layout(set = 0, binding = 0, std430) writeonly buffer Output {\n"
            << "    uint colorVerification[3];\n"
            << "    uint depthVerification;\n"
            << "    uint stencilVerification;\n"
            << "} sb_out;\n"
            << "layout(set = 0, binding = 1) uniform texture2D colorImage;\n"
            << "layout(set = 0, binding = 2, rgba8) uniform writeonly image2DArray verify;\n"
            << "\n"
            << "bool v4matches(vec4 a, vec4 b, float error)\n"
            << "{\n"
            << "    return all(lessThan(abs(a - b), vec4(error)));\n"
            << "}\n"
            << "\n"
            << "void main (void)\n"
            << "{\n"
            << "    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, params.area.zw)))\n"
            << "        return;\n"
            << "\n"
            << "    uvec2 coords = params.area.xy + gl_GlobalInvocationID.xy;\n"
            << "\n"
            << "    vec4 result = vec4(1, 0, 0, 1);\n"
            << "    vec4 color = texelFetch(colorImage, ivec2(coords), 0);\n"
            << "    if (v4matches(color, params.color, 0.01))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.colorVerification[params.attachmentNdx], 1);\n"
            << "        result = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, params.attachmentNdx), result);\n"
            << "}\n";

        programCollection.glslSources.add("comp_singleFloat") << glu::ComputeSource(src.str());
    }

    // Compute shader - Verify outside render area is intact (int colors)
    {
        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "#extension GL_EXT_samplerless_texture_functions : require\n"
            << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "    ivec4 color;\n"
            << "    uint attachmentNdx;\n"
            << "} params;\n"
            << "\n"
            << "layout(local_size_x = 8, local_size_y = 8) in;\n"
            << "layout(set = 0, binding = 0, std430) writeonly buffer Output {\n"
            << "    uint colorVerification[3];\n"
            << "    uint depthVerification;\n"
            << "    uint stencilVerification;\n"
            << "} sb_out;\n"
            << "layout(set = 0, binding = 1) uniform " << (usesSignedIntFormat ? "i" : "u") << "texture2D colorImage;\n"
            << "layout(set = 0, binding = 2, rgba8) uniform writeonly image2DArray verify;\n"
            << "\n"
            << "bool i4matches(ivec4 a, ivec4 b, int error)\n"
            << "{\n"
            << "    return all(lessThanEqual(abs(a - b), ivec4(error)));\n"
            << "}\n"
            << "\n"
            << "void main (void)\n"
            << "{\n"
            << "    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, params.area.zw)))\n"
            << "        return;\n"
            << "\n"
            << "    uvec2 coords = params.area.xy + gl_GlobalInvocationID.xy;\n"
            << "\n"
            << "    vec4 result = vec4(1, 0, 0, 1);\n"
            << "    ivec4 color = ivec4(texelFetch(colorImage, ivec2(coords), 0));\n"
            << "    if (i4matches(color, params.color, 0))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.colorVerification[params.attachmentNdx], 1);\n"
            << "        result = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, params.attachmentNdx), result);\n"
            << "}\n";

        programCollection.glslSources.add("comp_singleInt") << glu::ComputeSource(src.str());
    }

    // Compute shader - Verify outside render area is intact (depth)
    {
        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "#extension GL_EXT_samplerless_texture_functions : require\n"
            << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "    float depthData;\n"
            << "} params;\n"
            << "\n"
            << "layout(local_size_x = 8, local_size_y = 8) in;\n"
            << "layout(set = 0, binding = 0, std430) writeonly buffer Output {\n"
            << "    uint colorVerification[3];\n"
            << "    uint depthVerification;\n"
            << "    uint stencilVerification;\n"
            << "} sb_out;\n"
            << "layout(set = 0, binding = 1) uniform texture2D depthImage;\n"
            << "layout(set = 0, binding = 2, rgba8) uniform writeonly image2DArray verify;\n"
            << "\n"
            << "bool fmatches(float a, float b, float error)\n"
            << "{\n"
            << "    return abs(a - b) < error;\n"
            << "}\n"
            << "\n"
            << "void main (void)\n"
            << "{\n"
            << "    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, params.area.zw)))\n"
            << "        return;\n"
            << "\n"
            << "    uvec2 coords = params.area.xy + gl_GlobalInvocationID.xy;\n"
            << "\n"
            << "    vec4 result = vec4(1, 0, 0, 1);\n"
            << "    float depth  = texelFetch(depthImage, ivec2(coords), 0).r;\n"
            << "    if (fmatches(depth, params.depthData, 0.01))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.depthVerification, 1);\n"
            << "        result = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, 3), result);\n"
            << "}\n";

        programCollection.glslSources.add("comp_singleDepth") << glu::ComputeSource(src.str());
    }

    // Compute shader - Verify outside render area is intact (stencil)
    {
        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "#extension GL_EXT_samplerless_texture_functions : require\n"
            << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "    uint stencilData;\n"
            << "} params;\n"
            << "\n"
            << "layout(local_size_x = 8, local_size_y = 8) in;\n"
            << "layout(set = 0, binding = 0, std430) writeonly buffer Output {\n"
            << "    uint colorVerification[3];\n"
            << "    uint depthVerification;\n"
            << "    uint stencilVerification;\n"
            << "} sb_out;\n"
            << "layout(set = 0, binding = 1) uniform utexture2D stencilImage;\n"
            << "layout(set = 0, binding = 2, rgba8) uniform writeonly image2DArray verify;\n"
            << "\n"
            << "bool umatches(uint a, uint b, uint error)\n"
            << "{\n"
            << "    return abs(a - b) <= error;\n"
            << "}\n"
            << "\n"
            << "void main (void)\n"
            << "{\n"
            << "    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, params.area.zw)))\n"
            << "        return;\n"
            << "\n"
            << "    uvec2 coords = params.area.xy + gl_GlobalInvocationID.xy;\n"
            << "\n"
            << "    vec4 result = vec4(1, 0, 0, 1);\n"
            << "    uint stencil = texelFetch(stencilImage, ivec2(coords), 0).r;\n"
            << "    if (umatches(stencil, params.stencilData, 0))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.stencilVerification, 1);\n"
            << "        result = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, 4), result);\n"
            << "}\n";

        programCollection.glslSources.add("comp_singleStencil") << glu::ComputeSource(src.str());
    }
}

void initBasicPrograms(SourceCollections &programCollection, const TestParams params)
{
    // Vertex shader - position
    {
        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "\n"
            << "layout(location = 0) in  vec4 in_position;\n"
            << "\n"
            << "out gl_PerVertex {\n"
            << "    vec4 gl_Position;\n"
            << "};\n"
            << "\n"
            << "void main(void)\n"
            << "{\n"
            << "    gl_Position = in_position;\n"
            << "}\n";

        programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
    }

    const bool usesSignedIntFormat = params.intColorFormat == VK_FORMAT_R16G16B16A16_SINT;
    const char *intTypePrefix      = usesSignedIntFormat ? "i" : "u";

    // The framebuffer contains four attachments with the same number of samples.
    // The fragment shader outputs a different color per sample (in a gradient) to verify that the multisampled image actually has that many samples:
    //
    // - For samples [4s, 4s+3), the shader outputs:
    //
    //     Vec4(0, v, v, v),
    //     Vec4(v, 0, v, v),
    //     Vec4(v, v, 0, v),
    //     Vec4(v, v, v, 0),
    //
    //   for float attachments where v = 1-s*0.2. For sample s, it outputs:
    //
    //     UVec4(v, v + 1, v + 2, v + 3),
    //
    //   for the int attachment where v = (s+1)*(s+1)*10.
    //
    // Additionally, the fragment shader outputs depth based on the sample index as well.  For sample s, it outputs 1 - (s^1)/16.
    // Note that ^1 ensures VK_RESOLVE_MODE_SAMPLE_ZERO_BIT and VK_RESOLVE_MODE_MAX_BIT produce different values.
    {
        const TestParams::PerPass &perPass = params.perPass[0];

        // The shader outputs up to 16 samples
        const uint32_t numSamples = static_cast<uint32_t>(perPass.numSamples);

        DE_ASSERT(numSamples <= 16);

        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "\n"
            << "layout(location = " << perPass.floatColor1Location << ") out vec4 o_color1;\n"
            << "layout(location = " << perPass.floatColor2Location << ") out vec4 o_color2;\n"
            << "layout(location = " << perPass.intColorLocation << ") out " << intTypePrefix << "vec4 o_color3;\n"
            << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "} params;\n"
            << "\n"
            << "void main(void)\n"
            << "{\n"
            << "    vec2 uv = (gl_FragCoord.xy - vec2(params.area.xy)) / vec2(params.area.zw);\n";
        for (uint32_t sampleID = 0; sampleID < numSamples; ++sampleID)
        {
            const char *uvComponent = sampleID % 2 == 0 ? "uv.x" : "uv.y";

            const float floatValue  = 1 - static_cast<float>(sampleID / 4) * 0.2f;
            const uint32_t intValue = (sampleID + 1) * (sampleID + 1) * 10;
            const float depthValue  = 1 - static_cast<float>(sampleID ^ 1) / 16.0f;

            const Vec4 floatChannels(sampleID % 4 == 0 ? 0 : floatValue, sampleID % 4 == 1 ? 0 : floatValue,
                                     sampleID % 4 == 2 ? 0 : floatValue, sampleID % 4 == 3 ? 0 : floatValue);
            const UVec4 intChannels(intValue, intValue + 1, intValue + 2, intValue + 3);

            src << "    " << (sampleID == 0 ? "" : "else ") << "if (gl_SampleID == " << sampleID << ")\n"
                << "    {\n"
                << "        o_color1 = vec4(" << floatChannels.x() << ", " << floatChannels.y() << ", "
                << floatChannels.z() << ", " << floatChannels.w() << ") * " << uvComponent << ";\n"
                << "        o_color2 = vec4(" << floatChannels.x() << ", " << floatChannels.y() << ", "
                << floatChannels.z() << ", " << floatChannels.w() << ") * " << uvComponent << ";\n"
                << "        o_color3 = " << intTypePrefix << "vec4(vec4(" << intChannels.x() << ", " << intChannels.y()
                << ", " << intChannels.z() << ", " << intChannels.w() << ") * " << uvComponent << ");\n"
                << "        gl_FragDepth = " << depthValue << ";\n"
                << "    }\n";
        }
        src << "}\n";

        programCollection.glslSources.add("frag") << glu::FragmentSource(src.str());
    }

    // Compute shader - verify the results of rendering
    //
    // Take the formulas used for the fragment shader.  Note the following:
    //
    //    n-1
    //    sum(1 - s*0.2)
    //     0                 n - (n*(n-1))/2 * 0.2
    //  ----------------- = ----------------------- = 1 - (n-1)*0.1
    //          n                    n
    //
    // When rendering is done to every sample and the attachment is resolved, we expect:
    //
    // - For float attachments, average of:
    //   * Horizontal gradient:
    //
    //       Vec4(0, 1, 1, 1)            if 2 samples
    //       Vec4(0.5v, v, 0.5v, v)        o.w. where v = 1 - (n - 1)*0.1 where n = floor(sampleCount / 4).
    //
    //   * Vertical gradient:
    //
    //       Vec4(1, 0, 1, 1)            if 2 samples
    //       Vec4(v, 0.5v, v, 0.5v)        o.w. where v = 1 - (n - 1)*0.1 where n = floor(sampleCount / 4).
    //
    // - For the int attachments, any of UVec4(v, v + 1, v + 2, v + 3) where v = (s+1)*(s+1)*10
    // - For the depth attachment, either 1 or 1-1/16 based on whether MAX or SAMPLE_ZERO resolve modes are selected respectively.
    // - For the stencil attachment, expect the clear value + 1.
    {
        const TestParams::PerPass &perPass = params.perPass[0];

        // The shader outputs up to 16 samples
        const uint32_t numSamples = static_cast<uint32_t>(perPass.numSamples);

        const float floatValue = 1 - static_cast<float>((numSamples / 4) - 1) * 0.1f;

        const Vec4 floatExpectHorizontal =
            numSamples == 2 ? Vec4(0, 1, 1, 1) : Vec4(0.5f * floatValue, floatValue, 0.5f * floatValue, floatValue);
        const Vec4 floatExpectVertical =
            numSamples == 2 ? Vec4(1, 0, 1, 1) : Vec4(floatValue, 0.5f * floatValue, floatValue, 0.5f * floatValue);

        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "#extension GL_EXT_samplerless_texture_functions : require\n"
            << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "    uint stencilExpect;\n"
            << "} params;\n"
            << "\n"
            << "layout(local_size_x = 8, local_size_y = 8) in;\n"
            << "layout(set = 0, binding = 0, std430) writeonly buffer Output {\n"
            << "    uint colorVerification[3];\n"
            << "    uint depthVerification;\n"
            << "    uint stencilVerification;\n"
            << "} sb_out;\n"
            << "layout(set = 0, binding = 1) uniform texture2D color1Image;\n"
            << "layout(set = 0, binding = 2) uniform texture2D color2Image;\n"
            << "layout(set = 0, binding = 3) uniform " << (usesSignedIntFormat ? "i" : "u")
            << "texture2D color3Image;\n";
        if (isDepthFormat(params.depthStencilFormat))
            src << "layout(set = 0, binding = 4) uniform texture2D depthImage;\n";
        if (isStencilFormat(params.depthStencilFormat))
            src << "layout(set = 0, binding = 5) uniform utexture2D stencilImage;\n";
        src << "layout(set = 0, binding = 6, rgba8) uniform writeonly image2DArray verify;\n"
            << "\n"
            << "bool fmatches(float a, float b, float error)\n"
            << "{\n"
            << "    return abs(a - b) < error;\n"
            << "}\n"
            << "bool umatches(uint a, uint b, uint error)\n"
            << "{\n"
            << "    return abs(a - b) <= error;\n"
            << "}\n"
            << "bool v4matches(vec4 a, vec4 b, vec4 error)\n"
            << "{\n"
            << "    return all(lessThan(abs(a - b), error));\n"
            << "}\n"
            << "bool i4matchesEither(ivec4 a, ivec4 b, ivec4 c, int errorB, int errorC)\n"
            << "{\n"
            << "    return all(lessThanEqual(abs(a - b), ivec4(errorB))) || all(lessThanEqual(abs(a - c), "
               "ivec4(errorC)));\n"
            << "}\n"
            << "\n"
            << "void main (void)\n"
            << "{\n"
            << "    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, params.area.zw)))\n"
            << "        return;\n"
            << "\n"
            << "    uvec2 coords = params.area.xy + gl_GlobalInvocationID.xy;\n"
            << "    vec2 uv = (vec2(gl_GlobalInvocationID.xy) + vec2(0.5)) / vec2(params.area.zw);\n"
            << "\n"
            << "    vec4 result1 = vec4(1, 0, 0, 1);\n"
            << "    vec4 color1 = texelFetch(color1Image, ivec2(coords), 0);\n"
            << "    vec4 expected1H = vec4(" << floatExpectHorizontal.x() << ", " << floatExpectHorizontal.y() << ", "
            << floatExpectHorizontal.z() << ", " << floatExpectHorizontal.w() << ");\n"
            << "    vec4 expected1V = vec4(" << floatExpectVertical.x() << ", " << floatExpectVertical.y() << ", "
            << floatExpectVertical.z() << ", " << floatExpectVertical.w() << ");\n"
            << "    vec4 expected1 = (expected1H * uv.x + expected1V * uv.y) / 2.0;\n"
            // Allow room for precision errors.  Rendering happens at sample locations while verification uv is in the middle of pixel.
            << "    if (v4matches(color1, expected1, max(expected1H / float(params.area.z), expected1V / "
               "float(params.area.w)) + 2.0/255.0))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.colorVerification[0], 1);\n"
            << "        result1 = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, 0), result1);\n"
            << "\n"
            << "    vec4 result2 = vec4(1, 0, 0, 1);\n"
            << "    vec4 color2 = texelFetch(color2Image, ivec2(coords), 0);\n"
            // Allow room for precision errors.  Rendering happens at sample locations while verification uv is in the middle of pixel.
            << "    if (v4matches(color2, expected1, max(expected1H / float(params.area.z), expected1V / "
               "float(params.area.w)) + 2.0/1024.0))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.colorVerification[1], 1);\n"
            << "        result2 = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, 1), result2);\n"
            << "\n"
            << "    vec4 result3 = vec4(1, 0, 0, 1);\n"
            << "    ivec4 color3 = ivec4(texelFetch(color3Image, ivec2(coords), 0));\n"
            << "    if (";
        for (uint32_t sampleID = 0; sampleID < numSamples; ++sampleID)
        {
            const uint32_t intValue = (sampleID + 1) * (sampleID + 1) * 10;
            const UVec4 intExpect(intValue, intValue + 1, intValue + 2, intValue + 3);

            src << (sampleID == 0 ? "" : "        || ") << "i4matchesEither(color3, ivec4(vec4(" << intExpect.x()
                << ", " << intExpect.y() << ", " << intExpect.z() << ", " << intExpect.w() << ") * uv.x), "
                << "ivec4(vec4(" << intExpect.x() << ", " << intExpect.y() << ", " << intExpect.z() << ", "
                << intExpect.w()
                << ") * uv.y), "
                // Allow room for precision errors.  Rendering happens at sample locations while verification uv is in the middle of pixel.
                << intValue << " / int(params.area.z) + 1, " << intValue << " / int(params.area.w) + 1)"
                << (sampleID == numSamples - 1 ? ")" : "") << "\n";
        }
        src << "    {\n"
            << "        atomicAdd(sb_out.colorVerification[2], 1);\n"
            << "        result3 = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, 2), result3);\n"
            << "\n";
        if (isDepthFormat(params.depthStencilFormat))
        {
            const float expect =
                perPass.depthStencilResolveMode == VK_RESOLVE_MODE_SAMPLE_ZERO_BIT ? 1 - 1 / 16.0f : 1.0f;

            src << "    vec4 resultDepth = vec4(1, 0, 0, 1);\n"
                << "    float depth  = texelFetch(depthImage, ivec2(coords), 0).r;\n"
                << "    if (fmatches(depth, " << expect << ", 0.01))\n"
                << "    {\n"
                << "        atomicAdd(sb_out.depthVerification, 1);\n"
                << "        resultDepth = vec4(0, 1, 0, 1);\n"
                << "    }\n"
                << "    imageStore(verify, ivec3(coords, 3), resultDepth);\n";
        }
        if (isStencilFormat(params.depthStencilFormat))
        {
            src << "    vec4 resultStencil = vec4(1, 0, 0, 1);\n"
                << "    uint stencil = texelFetch(stencilImage, ivec2(coords), 0).r;\n"
                << "    if (umatches(stencil, params.stencilExpect, 0))\n"
                << "    {\n"
                << "        atomicAdd(sb_out.stencilVerification, 1);\n"
                << "        resultStencil = vec4(0, 1, 0, 1);\n"
                << "    }\n"
                << "    imageStore(verify, ivec3(coords, 4), resultStencil);\n";
        }
        src << "}\n";

        programCollection.glslSources.add("comp") << glu::ComputeSource(src.str());
    }

    // Always generate constant-color checks as they are used by vkCmdClearAttachments tests
    initConstantColorVerifyPrograms(programCollection, params);
}

void dispatchVerifyBasic(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    const DeviceInterface &vk = context.getDeviceInterface();
    const VkDevice device     = context.getDevice();

    postDrawBarrier(context, testObjects);

    const VkPushConstantRange &verifyPushConstantRange = {
        VK_SHADER_STAGE_COMPUTE_BIT,                             // VkShaderStageFlags    stageFlags;
        0,                                                       // uint32_t              offset;
        static_cast<uint32_t>(sizeof(UVec4) + sizeof(uint32_t)), // uint32_t              size;
    };

    Move<VkPipelineLayout> verifyPipelineLayout;
    setupVerifyDescriptorSetAndPipeline(context, params, wd, testObjects, &verifyPushConstantRange,
                                        verifyPipelineLayout);

    const uint32_t stencilExpect = params.clearValues[3].depthStencil.stencil + 1;

    vk.cmdPushConstants(*testObjects.cmdBuffer, *verifyPipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof(UVec4),
                        &wd.renderArea);
    vk.cmdPushConstants(*testObjects.cmdBuffer, *verifyPipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, sizeof(UVec4),
                        sizeof(uint32_t), &stencilExpect);
    vk.cmdDispatch(*testObjects.cmdBuffer, (wd.renderArea.z() + 7) / 8, (wd.renderArea.w() + 7) / 8, 1);

    postVerifyBarrier(context, testObjects, wd.verificationBuffer);

    invalidateAlloc(vk, device, *wd.verificationBufferAlloc);
}

void drawBasic(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    const InstanceInterface &vki          = context.getInstanceInterface();
    const DeviceInterface &vk             = context.getDeviceInterface();
    const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
    const VkDevice device                 = context.getDevice();
    VkPipelineRenderingCreateInfo pipelineRenderingCreateInfo;
    std::vector<VkFormat> colorAttachmentFormats = {VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED,
                                                    VK_FORMAT_UNDEFINED};
    std::vector<VkRenderingAttachmentInfo> colorAttachmentInfos(4u);
    VkRenderingAttachmentInfo depthStencilAttachmentInfo;

    DE_ASSERT(params.perPass.size() == 1);

    if (params.clearBeforeRenderPass)
    {
        clearImagesBeforeDraw(context, params, wd, testObjects);
    }

    if (params.dynamicRendering)
    {
        preRenderingImageLayoutTransition(context, params, wd, testObjects);
        initResolveImageLayouts(context, params, wd, testObjects);
    }

    // Create a render pass and a framebuffer
    {
        std::vector<VkSubpassDescription2> subpasses;
        std::vector<VkImage> images;
        std::vector<VkImageView> attachments;
        std::vector<VkAttachmentDescription2> attachmentDescriptions;
        std::vector<VkAttachmentReference2> attachmentReferences;
        std::vector<VkAttachmentReference2> resolveAttachmentReferences;
        VkMultisampledRenderToSingleSampledInfoEXT msrtss;
        VkSubpassDescriptionDepthStencilResolve depthStencilResolve;
        int32_t attachmentNdxes[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
        uint32_t attachmentUseMask = 0;

        initializeAttachments(params, wd, images, attachments, 0, attachmentNdxes);

        if (params.dynamicRendering)
        {
            initializeRenderingAttachmentInfos(params, wd, colorAttachmentInfos, depthStencilAttachmentInfo,
                                               colorAttachmentFormats, attachmentNdxes, attachmentUseMask, 0u);

            pipelineRenderingCreateInfo = {
                VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,     // VkStructureType    sType
                DE_NULL,                                              // const void*        pNext
                0u,                                                   // uint32_t            viewMask
                static_cast<uint32_t>(colorAttachmentFormats.size()), // uint32_t            colorAttachmentCount
                colorAttachmentFormats.data(),                        // const VkFormat*    pColorAttachmentFormats
                VK_FORMAT_UNDEFINED,                                  // VkFormat            depthAttachmentFormat
                VK_FORMAT_UNDEFINED                                   // VkFormat            stencilAttachmentFormat
            };

            if (params.usesDepthStencilInPass(0))
            {
                if (isDepthFormat(params.depthStencilFormat))
                    pipelineRenderingCreateInfo.depthAttachmentFormat = params.depthStencilFormat;
                if (isStencilFormat(params.depthStencilFormat))
                    pipelineRenderingCreateInfo.stencilAttachmentFormat = params.depthStencilFormat;
            }
        }
        else
        {
            initializeAttachmentDescriptions(params, attachmentDescriptions, params.clearBeforeRenderPass,
                                             attachmentNdxes, attachmentUseMask);

            addSubpassDescription(params, 0, attachmentReferences, resolveAttachmentReferences, depthStencilResolve,
                                  nullptr, msrtss, subpasses, {}, attachmentNdxes);

            createRenderPassAndFramebuffer(context, wd, testObjects, params.pipelineConstructionType, images,
                                           attachments, attachmentDescriptions, subpasses, {});
        }
    }

    {
        const VkPushConstantRange &pushConstantRange = {
            VK_SHADER_STAGE_FRAGMENT_BIT,         // VkShaderStageFlags    stageFlags;
            0,                                    // uint32_t              offset;
            static_cast<uint32_t>(sizeof(UVec4)), // uint32_t              size;
        };

        const ShaderWrapper vertexModule(ShaderWrapper(vk, device, context.getBinaryCollection().get("vert"), 0u));
        const ShaderWrapper fragmentModule(ShaderWrapper(vk, device, context.getBinaryCollection().get("frag"), 0u));
        const PipelineLayoutWrapper pipelineLayout(params.pipelineConstructionType, vk, device, 0, DE_NULL, 1,
                                                   &pushConstantRange);

        testObjects.graphicsPipelines.push_back(pipeline::makeGraphicsPipeline(
            vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
            pipelineLayout, params.dynamicRendering ? DE_NULL : *testObjects.renderPassFramebuffers.back(),
            params.dynamicRendering ? &pipelineRenderingCreateInfo : DE_NULL, vertexModule, fragmentModule, false, true,
            false, 0, 0, params.perPass[0].intColorLocation, wd.renderArea, wd.renderArea, params.perPass[0].numSamples,
            params.useGarbageAttachment));

        if (params.dynamicRendering)
        {
            startRendering(context, params, wd, testObjects, static_cast<uint32_t>(colorAttachmentFormats.size()),
                           colorAttachmentInfos, depthStencilAttachmentInfo, 0u);
        }
        else
        {
            startRenderPass(context, wd, testObjects, DE_LENGTH_OF_ARRAY(params.clearValues), params.clearValues);
        }

        const VkDeviceSize vertexBufferOffset = 0;
        vk.cmdBindVertexBuffers(*testObjects.cmdBuffer, 0u, 1u, &wd.vertexBuffer.get(), &vertexBufferOffset);

        vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(UVec4),
                            &wd.renderArea);
        (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
        vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);

        if (params.dynamicRendering)
        {
            vk.cmdEndRendering(*testObjects.cmdBuffer);
        }
        else
        {
            testObjects.renderPassFramebuffers.back().end(vk, *testObjects.cmdBuffer);
        }
    }

    if (params.dynamicRendering)
    {
        postRenderingResolveImageLayoutTransition(context, params, wd, testObjects);
    }

    // Verify results
    dispatchVerifyBasic(context, params, wd, testObjects);
}

//! Verify multisampled rendering is done with the exact number of samples.
tcu::TestStatus testBasic(Context &context, const TestParams params)
{
    WorkingData wd;
    TestObjects testObjects(context);
    testStart(context, params, wd, testObjects);

    drawBasic(context, params, wd, testObjects);

    testEnd(context, params, wd, testObjects);
    return verify(context, params, wd);
}

void generateBasicTest(de::Random &rng, TestParams &params, const VkSampleCountFlagBits sampleCount,
                       const VkResolveModeFlagBits resolveMode, const bool renderToWholeFramebuffer)
{
    params.perPass.resize(1);

    TestParams::PerPass &perPass = params.perPass[0];

    // Set the sample count for attachments.
    if (params.isMultisampledRenderToSingleSampled)
    {
        params.numFloatColor1Samples  = VK_SAMPLE_COUNT_1_BIT;
        params.numFloatColor2Samples  = VK_SAMPLE_COUNT_1_BIT;
        params.numIntColorSamples     = VK_SAMPLE_COUNT_1_BIT;
        params.numDepthStencilSamples = VK_SAMPLE_COUNT_1_BIT;

        perPass.resolveFloatColor1  = false;
        perPass.resolveFloatColor2  = false;
        perPass.resolveIntColor     = false;
        perPass.resolveDepthStencil = false;
    }
    else
    {
        params.numFloatColor1Samples  = sampleCount;
        params.numFloatColor2Samples  = sampleCount;
        params.numIntColorSamples     = sampleCount;
        params.numDepthStencilSamples = sampleCount;

        perPass.resolveFloatColor1  = true;
        perPass.resolveFloatColor2  = true;
        perPass.resolveIntColor     = true;
        perPass.resolveDepthStencil = true;
    }
    perPass.depthStencilResolveMode = resolveMode;

    perPass.numSamples = sampleCount;

    // Set locations for the color attachments.
    perPass.floatColor1Location = 0;
    perPass.floatColor2Location = 1;
    perPass.intColorLocation    = 2;

    // Depth/stencil is always used
    perPass.hasDepthStencil = true;

    // Always clear before render pass so outside render area can be verified.
    params.clearBeforeRenderPass    = true;
    params.renderToWholeFramebuffer = renderToWholeFramebuffer;
    params.testBlendsColors         = false;

    // Set random clear values.
    generateRandomClearValues(rng, params, params.clearValues, false);

    params.rngSeed = rng.getUint32();
}

void dispatchVerifyClearAttachments(Context &context, const TestParams &params, WorkingData &wd,
                                    TestObjects &testObjects, const UVec4 regions[RegionCount],
                                    const VkClearValue clearValues[RegionCount - 1][4])
{
    const DeviceInterface &vk = context.getDeviceInterface();
    const VkDevice device     = context.getDevice();

    postDrawBarrier(context, testObjects);

    const VkPushConstantRange &verifyPushConstantRange = {
        VK_SHADER_STAGE_COMPUTE_BIT,                             // VkShaderStageFlags    stageFlags;
        0,                                                       // uint32_t              offset;
        static_cast<uint32_t>(sizeof(UVec4) + sizeof(uint32_t)), // uint32_t              size;
    };

    Move<VkPipelineLayout> verifyPipelineLayout;
    setupVerifyDescriptorSetAndPipeline(context, params, wd, testObjects, &verifyPushConstantRange,
                                        verifyPipelineLayout);

    const uint32_t stencilExpect[2] = {
        // For region 0, there's a single draw that increments the cleared stencil
        params.clearValues[3].depthStencil.stencil + 1,
        // For region 1, there's a vkCmdClearAttachments followed by a draw that increments that stencil value
        clearValues[0][3].depthStencil.stencil + 1,
    };

    // Verify regions 0 and 1 have gradient colors.
    for (uint32_t regionNdx = 0; regionNdx < 2; ++regionNdx)
    {
        vk.cmdPushConstants(*testObjects.cmdBuffer, *verifyPipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0,
                            sizeof(UVec4), &regions[regionNdx]);
        vk.cmdPushConstants(*testObjects.cmdBuffer, *verifyPipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, sizeof(UVec4),
                            sizeof(uint32_t), &stencilExpect[regionNdx]);
        vk.cmdDispatch(*testObjects.cmdBuffer, (regions[regionNdx].z() + 7) / 8, (regions[regionNdx].w() + 7) / 8, 1);

        postVerifyBarrier(context, testObjects, wd.verificationBuffer);
    }

    // Verify the rest of the regions have clear values.  Note that clearValues[0] is unused as it's overriden with a draw call to region 1.
    for (uint32_t regionNdx = 2; regionNdx < RegionCount; ++regionNdx)
    {
        const VkClearValue *regionClearValues = clearValues[regionNdx - 1];
        const UVec4 &region                   = regions[regionNdx];

        {
            const VerifySingleFloatPushConstants verifyColor1 = {
                region,
                Vec4(regionClearValues[0].color.float32[0], regionClearValues[0].color.float32[1],
                     regionClearValues[0].color.float32[2], regionClearValues[0].color.float32[3]),
                0,
            };
            dispatchVerifyConstantColor(context, testObjects, wd.getResolvedFloatColorImage1View(params),
                                        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, wd.verify.view, wd.verificationBuffer,
                                        static_cast<uint32_t>(sizeof(verifyColor1)), &verifyColor1, "comp_singleFloat");
        }

        {
            const VerifySingleFloatPushConstants verifyColor2 = {
                region,
                Vec4(regionClearValues[1].color.float32[0], regionClearValues[1].color.float32[1],
                     regionClearValues[1].color.float32[2], regionClearValues[1].color.float32[3]),
                1,
            };
            dispatchVerifyConstantColor(context, testObjects, wd.getResolvedFloatColorImage2View(params),
                                        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, wd.verify.view, wd.verificationBuffer,
                                        static_cast<uint32_t>(sizeof(verifyColor2)), &verifyColor2, "comp_singleFloat");
        }

        {
            const VerifySingleIntPushConstants verifyColor3 = {
                region,
                IVec4(regionClearValues[2].color.int32[0], regionClearValues[2].color.int32[1],
                      regionClearValues[2].color.int32[2], regionClearValues[2].color.int32[3]),
                2,
            };
            dispatchVerifyConstantColor(context, testObjects, wd.getResolvedIntColorImageView(params),
                                        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, wd.verify.view, wd.verificationBuffer,
                                        static_cast<uint32_t>(sizeof(verifyColor3)), &verifyColor3, "comp_singleInt");
        }

        if (isDepthFormat(params.depthStencilFormat))
        {
            const VerifySingleDepthPushConstants verifyDepth = {
                region,
                regionClearValues[3].depthStencil.depth,
            };
            dispatchVerifyConstantColor(context, testObjects, wd.getResolvedDepthOnlyImageView(params),
                                        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, wd.verify.view,
                                        wd.verificationBuffer, static_cast<uint32_t>(sizeof(verifyDepth)), &verifyDepth,
                                        "comp_singleDepth");
        }

        if (isStencilFormat(params.depthStencilFormat))
        {
            const VerifySingleStencilPushConstants verifyStencil = {
                region,
                regionClearValues[3].depthStencil.stencil,
            };
            dispatchVerifyConstantColor(context, testObjects, wd.getResolvedStencilOnlyImageView(params),
                                        VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, wd.verify.view,
                                        wd.verificationBuffer, static_cast<uint32_t>(sizeof(verifyStencil)),
                                        &verifyStencil, "comp_singleStencil");
        }
    }

    invalidateAlloc(vk, device, *wd.verificationBufferAlloc);
}

void drawClearAttachments(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    const InstanceInterface &vki          = context.getInstanceInterface();
    const DeviceInterface &vk             = context.getDeviceInterface();
    const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
    const VkDevice device                 = context.getDevice();
    VkPipelineRenderingCreateInfo pipelineRenderingCreateInfo;
    std::vector<VkFormat> colorAttachmentFormats = {VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED,
                                                    VK_FORMAT_UNDEFINED};
    std::vector<VkRenderingAttachmentInfo> colorAttachmentInfos(4u);
    VkRenderingAttachmentInfo depthStencilAttachmentInfo;

    DE_ASSERT(params.perPass.size() == 1);

    if (params.clearBeforeRenderPass)
    {
        clearImagesBeforeDraw(context, params, wd, testObjects);
    }

    if (params.dynamicRendering)
    {
        preRenderingImageLayoutTransition(context, params, wd, testObjects);
        initResolveImageLayouts(context, params, wd, testObjects);
    }

    // Create a render pass and a framebuffer
    {
        std::vector<VkSubpassDescription2> subpasses;
        std::vector<VkImage> images;
        std::vector<VkImageView> attachments;
        std::vector<VkAttachmentDescription2> attachmentDescriptions;
        std::vector<VkAttachmentReference2> attachmentReferences;
        std::vector<VkAttachmentReference2> resolveAttachmentReferences;
        VkMultisampledRenderToSingleSampledInfoEXT msrtss;
        VkSubpassDescriptionDepthStencilResolve depthStencilResolve;
        int32_t attachmentNdxes[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
        uint32_t attachmentUseMask = 0;

        initializeAttachments(params, wd, images, attachments, 0, attachmentNdxes);

        if (params.dynamicRendering)
        {
            initializeRenderingAttachmentInfos(params, wd, colorAttachmentInfos, depthStencilAttachmentInfo,
                                               colorAttachmentFormats, attachmentNdxes, attachmentUseMask, 0u);

            pipelineRenderingCreateInfo = {
                VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,     // VkStructureType    sType
                DE_NULL,                                              // const void*        pNext
                0u,                                                   // uint32_t            viewMask
                static_cast<uint32_t>(colorAttachmentFormats.size()), // uint32_t            colorAttachmentCount
                colorAttachmentFormats.data(),                        // const VkFormat*    pColorAttachmentFormats
                VK_FORMAT_UNDEFINED,                                  // VkFormat            depthAttachmentFormat
                VK_FORMAT_UNDEFINED                                   // VkFormat            stencilAttachmentFormat
            };

            if (params.usesDepthStencilInPass(0))
            {
                if (isDepthFormat(params.depthStencilFormat))
                    pipelineRenderingCreateInfo.depthAttachmentFormat = params.depthStencilFormat;
                if (isStencilFormat(params.depthStencilFormat))
                    pipelineRenderingCreateInfo.stencilAttachmentFormat = params.depthStencilFormat;
            }
        }
        else
        {
            initializeAttachmentDescriptions(params, attachmentDescriptions, params.clearBeforeRenderPass,
                                             attachmentNdxes, attachmentUseMask);

            addSubpassDescription(params, 0, attachmentReferences, resolveAttachmentReferences, depthStencilResolve,
                                  nullptr, msrtss, subpasses, {}, attachmentNdxes);

            createRenderPassAndFramebuffer(context, wd, testObjects, params.pipelineConstructionType, images,
                                           attachments, attachmentDescriptions, subpasses, {});
        }
    }

    UVec4 regions[RegionCount];
    getDrawRegions(wd, regions);

    VkClearValue clearValues[RegionCount - 1][4];
    de::Random rng(params.rngSeed);
    for (uint32_t regionNdx = 0; regionNdx < RegionCount - 1; ++regionNdx)
        generateRandomClearValues(rng, params, clearValues[regionNdx], false);

    {
        const VkPushConstantRange &pushConstantRange = {
            VK_SHADER_STAGE_FRAGMENT_BIT,         // VkShaderStageFlags    stageFlags;
            0,                                    // uint32_t              offset;
            static_cast<uint32_t>(sizeof(UVec4)), // uint32_t              size;
        };

        const ShaderWrapper vertexModule(ShaderWrapper(vk, device, context.getBinaryCollection().get("vert"), 0u));
        const ShaderWrapper fragmentModule(ShaderWrapper(vk, device, context.getBinaryCollection().get("frag"), 0u));
        const PipelineLayoutWrapper pipelineLayout(params.pipelineConstructionType, vk, device, 0, DE_NULL, 1,
                                                   &pushConstantRange);

        if (params.dynamicRendering)
        {
            startRendering(context, params, wd, testObjects, static_cast<uint32_t>(colorAttachmentFormats.size()),
                           colorAttachmentInfos, depthStencilAttachmentInfo, 0u);
        }
        else
        {
            startRenderPass(context, wd, testObjects, DE_LENGTH_OF_ARRAY(params.clearValues), params.clearValues);
        }

        // Draw to region[0]
        testObjects.graphicsPipelines.push_back(pipeline::makeGraphicsPipeline(
            vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
            pipelineLayout, params.dynamicRendering ? DE_NULL : *testObjects.renderPassFramebuffers.back(),
            params.dynamicRendering ? &pipelineRenderingCreateInfo : DE_NULL, vertexModule, fragmentModule, false, true,
            false, 0, 0, params.perPass[0].intColorLocation, regions[0], regions[0], params.perPass[0].numSamples,
            params.useGarbageAttachment));

        const VkDeviceSize vertexBufferOffset = 0;
        vk.cmdBindVertexBuffers(*testObjects.cmdBuffer, 0u, 1u, &wd.vertexBuffer.get(), &vertexBufferOffset);

        vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(UVec4),
                            &regions[0]);
        (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
        vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);

        // Clear all regions except region 0
        {
            for (uint32_t regionNdx = 0; regionNdx < RegionCount - 1; ++regionNdx)
            {
                const VkClearAttachment attachments[4] = {
                    {
                        VK_IMAGE_ASPECT_COLOR_BIT,
                        static_cast<uint32_t>(params.perPass[0].floatColor1Location),
                        clearValues[regionNdx][0],
                    },
                    {
                        VK_IMAGE_ASPECT_COLOR_BIT,
                        static_cast<uint32_t>(params.perPass[0].floatColor2Location),
                        clearValues[regionNdx][1],
                    },
                    {
                        VK_IMAGE_ASPECT_COLOR_BIT,
                        static_cast<uint32_t>(params.perPass[0].intColorLocation),
                        clearValues[regionNdx][2],
                    },
                    {
                        getDepthStencilAspectFlags(params.depthStencilFormat),
                        0,
                        clearValues[regionNdx][3],
                    },
                };
                const UVec4 &region            = regions[regionNdx + 1];
                const VkClearRect clearRegions = {
                    {{static_cast<int32_t>(region.x()), static_cast<int32_t>(region.y())}, {region.z(), region.w()}},
                    0,
                    1};

                vk.cmdClearAttachments(*testObjects.cmdBuffer, 4, attachments, 1, &clearRegions);
            }
        }

        // Draw to region[1], overriding the clear value
        testObjects.graphicsPipelines.push_back(makeGraphicsPipeline(
            vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
            pipelineLayout, params.dynamicRendering ? DE_NULL : *testObjects.renderPassFramebuffers.back(),
            params.dynamicRendering ? &pipelineRenderingCreateInfo : DE_NULL, vertexModule, fragmentModule, false, true,
            false, 0, 0, params.perPass[0].intColorLocation, regions[1], regions[1], params.perPass[0].numSamples,
            params.useGarbageAttachment));

        vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(UVec4),
                            &regions[1]);
        (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
        vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);

        if (params.dynamicRendering)
        {
            vk.cmdEndRendering(*testObjects.cmdBuffer);
        }
        else
        {
            testObjects.renderPassFramebuffers.back().end(vk, *testObjects.cmdBuffer);
        }
    }

    if (params.dynamicRendering)
    {
        postRenderingResolveImageLayoutTransition(context, params, wd, testObjects);
    }

    // Verify results
    dispatchVerifyClearAttachments(context, params, wd, testObjects, regions, clearValues);
}

//! Verify vkCmdClearAttachments works.
tcu::TestStatus testClearAttachments(Context &context, const TestParams params)
{
    WorkingData wd;
    TestObjects testObjects(context);
    testStart(context, params, wd, testObjects);

    drawClearAttachments(context, params, wd, testObjects);

    testEnd(context, params, wd, testObjects);
    return verify(context, params, wd);
}

void drawOnePass(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects,
                 const ShaderWrapper &vertexModule, const PipelineLayoutWrapper &pipelineLayout, const uint32_t passNdx,
                 const uint32_t subpassNdx, UVec4 regions[RegionCount],
                 VkPipelineRenderingCreateInfo *pipelineRenderingCreateInfo)
{
    const InstanceInterface &vki          = context.getInstanceInterface();
    const DeviceInterface &vk             = context.getDeviceInterface();
    const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
    const VkDevice device                 = context.getDevice();

    const VkDeviceSize vertexBufferOffset = 0;
    vk.cmdBindVertexBuffers(*testObjects.cmdBuffer, 0u, 1u, &wd.vertexBuffer.get(), &vertexBufferOffset);

    const TestParams::PerPass &perPass = params.perPass[passNdx];

    // Each subpass performs 4 sets of one or two draw calls.  Two if there is depth/stencil and one if not.
    // When depth/stencil is present, the first draw call writes to depth, while the second draw call does a depth test.
    // The four sets are draw calls with scissors dividing the render area in four:
    //
    // +--------+---------------+
    // |        |               |
    // |   1    |       2       |
    // |        |               |
    // +--------+---------------+
    // |        |               |
    // |        |               |
    // |   3    |       4       |
    // |        |               |
    // |        |               |
    // +--------+---------------+
    //

    std::ostringstream fragName;
    fragName << "frag_" << passNdx;
    const ShaderWrapper fragmentModule(
        ShaderWrapper(vk, device, context.getBinaryCollection().get(fragName.str().c_str()), 0u));

    for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
    {
        testObjects.graphicsPipelines.push_back(pipeline::makeGraphicsPipeline(
            vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
            pipelineLayout, params.dynamicRendering ? DE_NULL : *testObjects.renderPassFramebuffers.back(),
            params.dynamicRendering ? pipelineRenderingCreateInfo : DE_NULL, vertexModule, fragmentModule, true, true,
            false, 1 << passNdx, subpassNdx, perPass.intColorLocation, regions[regionNdx], regions[regionNdx],
            perPass.numSamples, params.useGarbageAttachment));

        vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(UVec4),
                            &regions[regionNdx]);
        vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(UVec4),
                            sizeof(perPass.drawConstantsWithDepthWrite[regionNdx]),
                            &perPass.drawConstantsWithDepthWrite[regionNdx]);
        (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
        vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);

        if (perPass.hasDepthStencil)
        {
            testObjects.graphicsPipelines.push_back(pipeline::makeGraphicsPipeline(
                vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
                pipelineLayout, params.dynamicRendering ? DE_NULL : *testObjects.renderPassFramebuffers.back(),
                params.dynamicRendering ? pipelineRenderingCreateInfo : DE_NULL, vertexModule, fragmentModule, true,
                false, true, 1 << passNdx, subpassNdx, perPass.intColorLocation, regions[regionNdx], regions[regionNdx],
                perPass.numSamples, params.useGarbageAttachment));

            vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(UVec4),
                                &regions[regionNdx]);
            vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(UVec4),
                                sizeof(perPass.drawConstantsWithDepthTest[regionNdx]),
                                &perPass.drawConstantsWithDepthTest[regionNdx]);
            (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
            vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);
        }
    }
}

void dispatchVerifyMultiPassRendering(Context &context, const TestParams &params, WorkingData &wd,
                                      TestObjects &testObjects, UVec4 regions[RegionCount])
{
    const DeviceInterface &vk = context.getDeviceInterface();
    const VkDevice device     = context.getDevice();

    postDrawBarrier(context, testObjects);

    const VkPushConstantRange &verifyPushConstantRange = {
        VK_SHADER_STAGE_COMPUTE_BIT,                                        // VkShaderStageFlags    stageFlags;
        0,                                                                  // uint32_t              offset;
        static_cast<uint32_t>(sizeof(UVec4) + sizeof(VerifyPushConstants)), // uint32_t              size;
    };

    Move<VkPipelineLayout> verifyPipelineLayout;
    setupVerifyDescriptorSetAndPipeline(context, params, wd, testObjects, &verifyPushConstantRange,
                                        verifyPipelineLayout);

    for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
    {
        if (regionNdx != 0)
        {
            const VkMemoryBarrier preVerifyBarrier = {
                VK_STRUCTURE_TYPE_MEMORY_BARRIER,                       // VkStructureType    sType;
                DE_NULL,                                                // const void*        pNext;
                VK_ACCESS_SHADER_WRITE_BIT,                             // VkAccessFlags      srcAccessMask;
                VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT, // VkAccessFlags      dstAccessMask;
            };

            vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                                  VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 1u, &preVerifyBarrier, 0u,
                                  DE_NULL, 0u, DE_NULL);
        }

        vk.cmdPushConstants(*testObjects.cmdBuffer, *verifyPipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, 0,
                            sizeof(UVec4), &regions[regionNdx]);
        vk.cmdPushConstants(*testObjects.cmdBuffer, *verifyPipelineLayout, VK_SHADER_STAGE_COMPUTE_BIT, sizeof(UVec4),
                            sizeof(params.verifyConstants[regionNdx]), &params.verifyConstants[regionNdx]);
        vk.cmdDispatch(*testObjects.cmdBuffer, (regions[regionNdx].z() + 7) / 8, (regions[regionNdx].w() + 7) / 8, 1);
    }

    postVerifyBarrier(context, testObjects, wd.verificationBuffer);

    invalidateAlloc(vk, device, *wd.verificationBufferAlloc);
}

void drawSingleRenderPass(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    const DeviceInterface &vk   = context.getDeviceInterface();
    const VkDevice device       = context.getDevice();
    const uint32_t numSubpasses = static_cast<uint32_t>(params.perPass.size());

    if (params.clearBeforeRenderPass)
    {
        clearImagesBeforeDraw(context, params, wd, testObjects);
    }

    // Create a render pass and a framebuffer
    {
        std::vector<VkSubpassDescription2> subpasses;
        std::vector<VkImage> images;
        std::vector<VkImageView> attachments;
        std::vector<VkAttachmentDescription2> attachmentDescriptions;
        std::vector<std::vector<VkAttachmentReference2>> attachmentReferences(numSubpasses);
        std::vector<std::vector<VkAttachmentReference2>> resolveAttachmentReferences(numSubpasses);
        std::vector<std::vector<uint32_t>> preserveAttachments(numSubpasses);
        std::vector<VkSubpassDependency2> subpassDependencies;
        std::vector<VkMultisampledRenderToSingleSampledInfoEXT> msrtss(numSubpasses);
        std::vector<VkSubpassDescriptionDepthStencilResolve> depthStencilResolve(numSubpasses);
        int32_t attachmentNdxes[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
        uint32_t attachmentUseMask = 0;

        initializeAttachments(params, wd, images, attachments, params.perPass.size(), attachmentNdxes);
        initializeAttachmentDescriptions(params, attachmentDescriptions, params.clearBeforeRenderPass, attachmentNdxes,
                                         attachmentUseMask);

        for (uint32_t passNdx = 0; passNdx < numSubpasses; ++passNdx)
        {
            addSubpassDescription(params, passNdx, attachmentReferences[passNdx], resolveAttachmentReferences[passNdx],
                                  depthStencilResolve[passNdx], &preserveAttachments[passNdx], msrtss[passNdx],
                                  subpasses, {}, attachmentNdxes);

            if (passNdx > 0)
                addSubpassDependency(passNdx, subpassDependencies);
        }

        createRenderPassAndFramebuffer(context, wd, testObjects, params.pipelineConstructionType, images, attachments,
                                       attachmentDescriptions, subpasses, subpassDependencies);
    }

    const VkPushConstantRange &pushConstantRange = {
        VK_SHADER_STAGE_FRAGMENT_BIT,                                     // VkShaderStageFlags    stageFlags;
        0,                                                                // uint32_t              offset;
        static_cast<uint32_t>(sizeof(UVec4) + sizeof(DrawPushConstants)), // uint32_t              size;
    };

    const ShaderWrapper vertexModule(ShaderWrapper(vk, device, context.getBinaryCollection().get("vert"), 0u));
    const PipelineLayoutWrapper pipelineLayout(params.pipelineConstructionType, vk, device, 0, DE_NULL, 1,
                                               &pushConstantRange);

    UVec4 regions[RegionCount];
    getDrawRegions(wd, regions);

    startRenderPass(context, wd, testObjects, DE_LENGTH_OF_ARRAY(params.clearValues), params.clearValues);

    for (uint32_t passNdx = 0; passNdx < numSubpasses; ++passNdx)
    {
        if (passNdx != 0)
            testObjects.renderPassFramebuffers.back().nextSubpass(vk, *testObjects.cmdBuffer,
                                                                  VK_SUBPASS_CONTENTS_INLINE);

        drawOnePass(context, params, wd, testObjects, vertexModule, pipelineLayout, passNdx, passNdx, regions, DE_NULL);
    }

    testObjects.renderPassFramebuffers.back().end(vk, *testObjects.cmdBuffer);

    // Verify results
    dispatchVerifyMultiPassRendering(context, params, wd, testObjects, regions);
}

//! Verify multisampled rendering in subpasses
tcu::TestStatus testSingleRenderPass(Context &context, const TestParams params)
{
    WorkingData wd;
    TestObjects testObjects(context);
    testStart(context, params, wd, testObjects);

    drawSingleRenderPass(context, params, wd, testObjects);

    testEnd(context, params, wd, testObjects);
    return verify(context, params, wd);
}

void drawMultiRenderPass(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    const DeviceInterface &vk      = context.getDeviceInterface();
    const VkDevice device          = context.getDevice();
    const uint32_t numRenderPasses = static_cast<uint32_t>(params.perPass.size());

    if (params.clearBeforeRenderPass)
    {
        clearImagesBeforeDraw(context, params, wd, testObjects);
    }

    if (params.dynamicRendering)
    {
        preRenderingImageLayoutTransition(context, params, wd, testObjects);
        initResolveImageLayouts(context, params, wd, testObjects);
    }

    const VkPushConstantRange &pushConstantRange = {
        VK_SHADER_STAGE_FRAGMENT_BIT,                                     // VkShaderStageFlags    stageFlags;
        0,                                                                // uint32_t              offset;
        static_cast<uint32_t>(sizeof(UVec4) + sizeof(DrawPushConstants)), // uint32_t              size;
    };

    const ShaderWrapper vertexModule(ShaderWrapper(vk, device, context.getBinaryCollection().get("vert"), 0u));
    const PipelineLayoutWrapper pipelineLayout(params.pipelineConstructionType, vk, device, 0, DE_NULL, 1,
                                               &pushConstantRange);

    UVec4 regions[RegionCount];
    getDrawRegions(wd, regions);

    uint32_t attachmentUseMask = 0;

    for (uint32_t renderPassNdx = 0; renderPassNdx < numRenderPasses; ++renderPassNdx)
    {
        // Create a render pass and a framebuffer
        std::vector<VkSubpassDescription2> subpasses;
        std::vector<VkImage> images;
        std::vector<VkImageView> attachments;
        std::vector<VkAttachmentDescription2> attachmentDescriptions;
        std::vector<VkAttachmentReference2> attachmentReferences;
        std::vector<VkAttachmentReference2> resolveAttachmentReferences;
        VkMultisampledRenderToSingleSampledInfoEXT msrtss;
        VkSubpassDescriptionDepthStencilResolve depthStencilResolve;
        int32_t attachmentNdxes[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
        VkPipelineRenderingCreateInfo pipelineRenderingCreateInfo;
        std::vector<VkFormat> colorAttachmentFormats = {VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED, VK_FORMAT_UNDEFINED,
                                                        VK_FORMAT_UNDEFINED};
        std::vector<VkRenderingAttachmentInfo> colorAttachmentInfos(4u);
        VkRenderingAttachmentInfo depthStencilAttachmentInfo;

        std::vector<VkClearValue> clearValues;

        initializeAttachments(params, wd, images, attachments, renderPassNdx, attachmentNdxes);
        if (params.dynamicRendering)
        {
            initializeRenderingAttachmentInfos(params, wd, colorAttachmentInfos, depthStencilAttachmentInfo,
                                               colorAttachmentFormats, attachmentNdxes, attachmentUseMask,
                                               renderPassNdx);

            pipelineRenderingCreateInfo = {
                VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,     // VkStructureType    sType
                DE_NULL,                                              // const void*        pNext
                0u,                                                   // uint32_t            viewMask
                static_cast<uint32_t>(colorAttachmentFormats.size()), // uint32_t            colorAttachmentCount
                colorAttachmentFormats.data(),                        // const VkFormat*    pColorAttachmentFormats
                VK_FORMAT_UNDEFINED,                                  // VkFormat            depthAttachmentFormat
                VK_FORMAT_UNDEFINED                                   // VkFormat            stencilAttachmentFormat
            };

            if (params.usesDepthStencilInPass(renderPassNdx))
            {
                if (isDepthFormat(params.depthStencilFormat))
                    pipelineRenderingCreateInfo.depthAttachmentFormat = params.depthStencilFormat;
                if (isStencilFormat(params.depthStencilFormat))
                    pipelineRenderingCreateInfo.stencilAttachmentFormat = params.depthStencilFormat;
            }
        }
        else
        {
            initializeAttachmentDescriptions(params, attachmentDescriptions, params.clearBeforeRenderPass,
                                             attachmentNdxes, attachmentUseMask);

            addSubpassDescription(params, renderPassNdx, attachmentReferences, resolveAttachmentReferences,
                                  depthStencilResolve, nullptr, msrtss, subpasses, {}, attachmentNdxes);

            createRenderPassAndFramebuffer(context, wd, testObjects, params.pipelineConstructionType, images,
                                           attachments, attachmentDescriptions, subpasses, {});

            // Init clear values
            if (attachmentNdxes[0] >= 0)
                clearValues.push_back(params.clearValues[0]);
            if (attachmentNdxes[1] >= 0)
                clearValues.push_back(params.clearValues[1]);
            if (attachmentNdxes[2] >= 0)
                clearValues.push_back(params.clearValues[2]);
            if (attachmentNdxes[3] >= 0)
                clearValues.push_back(params.clearValues[3]);
        }

        if (renderPassNdx > 0)
        {
            const VkMemoryBarrier interRenderPassBarrier = {
                VK_STRUCTURE_TYPE_MEMORY_BARRIER, // VkStructureType    sType;
                DE_NULL,                          // const void*        pNext;
                VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags      srcAccessMask;
                VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT |
                    VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags      dstAccessMask;
            };

            vk.cmdPipelineBarrier(
                *testObjects.cmdBuffer,
                VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
                    VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
                VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT |
                    VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT,
                0u, 1u, &interRenderPassBarrier, 0u, DE_NULL, 0u, DE_NULL);
        }

        if (params.dynamicRendering)
        {
            startRendering(context, params, wd, testObjects, static_cast<uint32_t>(colorAttachmentFormats.size()),
                           colorAttachmentInfos, depthStencilAttachmentInfo, renderPassNdx);
        }
        else
        {
            startRenderPass(context, wd, testObjects, static_cast<uint32_t>(clearValues.size()),
                            dataOrNullPtr(clearValues));
        }

        drawOnePass(context, params, wd, testObjects, vertexModule, pipelineLayout, renderPassNdx, 0, regions,
                    &pipelineRenderingCreateInfo);

        if (params.dynamicRendering)
        {
            vk.cmdEndRendering(*testObjects.cmdBuffer);
        }
        else
        {
            testObjects.renderPassFramebuffers.back().end(vk, *testObjects.cmdBuffer);
        }
    }

    if (params.dynamicRendering)
    {
        postRenderingResolveImageLayoutTransition(context, params, wd, testObjects);
    }

    // Verify results
    dispatchVerifyMultiPassRendering(context, params, wd, testObjects, regions);
}

//! Verify multisampled rendering in multiple render passes
tcu::TestStatus testMultiRenderPass(Context &context, const TestParams params)
{
    WorkingData wd;
    TestObjects testObjects(context);
    testStart(context, params, wd, testObjects);

    drawMultiRenderPass(context, params, wd, testObjects);

    testEnd(context, params, wd, testObjects);
    return verify(context, params, wd);
}

void generateMultiPassTest(de::Random &rng, TestParams &params)
{
    const VkSampleCountFlagBits sampleRange[] = {
        // 4x multisampling is always supported.  A higher chance is given to that to avoid too many tests being skipped.
        VK_SAMPLE_COUNT_2_BIT, VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_4_BIT,
        VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_8_BIT, VK_SAMPLE_COUNT_16_BIT,
    };

    const VkResolveModeFlagBits depthStencilResolveModeRange[] = {
        // SAMPLE_ZERO is always supported, while MAX may not be.  A higher chance is given to SAMPLE_ZERO to avoid too many tests being skipped.
        VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
        VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
        VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
        VK_RESOLVE_MODE_MAX_BIT,
    };

    // Generate a random number of passes (either subpass or render pass)
    const uint32_t passCount = rng.getInt(1, 4);

    params.perPass.resize(passCount);

    std::vector<uint32_t> passAttachments;

    uint32_t usedAttachmentMask = 0;
    if (params.isMultisampledRenderToSingleSampled)
    {
        // Decide which attachments will be used in which pass.  This is a bit mask.
        for (uint32_t passNdx = 0; passNdx < passCount; ++passNdx)
        {
            passAttachments.push_back(rng.getInt(1, 15));
            usedAttachmentMask |= passAttachments.back();
        }
    }
    else
    {
        passAttachments.push_back(15); // Make sure all attachments have the same sample count
        for (uint32_t passNdx = 1; passNdx < passCount; ++passNdx)
            passAttachments.push_back(rng.getInt(1, 15));
    }

    // Decide which attachments will be single-sampled.  This is a bit mask.
    // Include any attachment that is not used in any subpass just to make all attachments valid.
    const uint32_t singleSampledAttachmentsMask =
        params.isMultisampledRenderToSingleSampled ? rng.getInt(1, 15) | (~usedAttachmentMask & 0xF) : 0;

    DBG("Generating test for %u passes\n", passCount);

    // Set the sample count for attachments.  Multisampled attachments that are used in the same pass will get the same number of samples.
    if ((singleSampledAttachmentsMask & 1) != 0)
        params.numFloatColor1Samples = VK_SAMPLE_COUNT_1_BIT;
    if ((singleSampledAttachmentsMask & 2) != 0)
        params.numFloatColor2Samples = VK_SAMPLE_COUNT_1_BIT;
    if ((singleSampledAttachmentsMask & 4) != 0)
        params.numIntColorSamples = VK_SAMPLE_COUNT_1_BIT;
    if ((singleSampledAttachmentsMask & 8) != 0)
        params.numDepthStencilSamples = VK_SAMPLE_COUNT_1_BIT;

    for (uint32_t passNdx = 0; passNdx < passCount; ++passNdx)
    {
        TestParams::PerPass &perPass = params.perPass[passNdx];

        const uint32_t multisampledAttachments        = passAttachments[passNdx] & ~singleSampledAttachmentsMask;
        const VkSampleCountFlagBits randomSampleCount = sampleRange[rng.getInt(0, DE_LENGTH_OF_ARRAY(sampleRange) - 1)];
        DBG("  + random samples: %d, multisampled attachments: %#x\n", randomSampleCount, multisampledAttachments);

        if (multisampledAttachments == 0)
        {
            // If all attachments are single-sampled, choose a random number of samples for the render pass.
            perPass.numSamples = randomSampleCount;
        }
        else
        {
            // Otherwise see if any of the attachments has already been decided what number of samples it has.
            VkSampleCountFlagBits sampleCount =
                (multisampledAttachments & 1) != 0 && params.numFloatColor1Samples != 0 ?
                    params.numFloatColor1Samples :
                (multisampledAttachments & 2) != 0 && params.numFloatColor2Samples != 0 ?
                    params.numFloatColor2Samples :
                (multisampledAttachments & 4) != 0 && params.numIntColorSamples != 0 ?
                    params.numIntColorSamples :
                (multisampledAttachments & 8) != 0 && params.numDepthStencilSamples != 0 ?
                    params.numDepthStencilSamples
                    // If none of the attachments already have a defined sample, generate a random sample count to use for all of them.
                    :
                    randomSampleCount;
            DBG("   + sample count from attachments or random: %d (already: %d %d %d %d)\n", sampleCount,
                params.numFloatColor1Samples, params.numFloatColor2Samples, params.numIntColorSamples,
                params.numDepthStencilSamples);

            perPass.numSamples = sampleCount;

            // Make all multisampled attachments used in the pass have the same number of samples.  Additionally, make all the multisampled attachments
            // used in conjunction with the these ones in future passes also have the same number of samples.
            for (uint32_t followingPassNdx = passNdx; followingPassNdx < passCount; ++followingPassNdx)
            {
                const uint32_t followingMultisampledAttachments =
                    passAttachments[followingPassNdx] & ~singleSampledAttachmentsMask;

                if ((followingMultisampledAttachments & 1) != 0)
                    params.numFloatColor1Samples = sampleCount;
                if ((followingMultisampledAttachments & 2) != 0)
                    params.numFloatColor2Samples = sampleCount;
                if ((followingMultisampledAttachments & 4) != 0)
                    params.numIntColorSamples = sampleCount;
                if ((followingMultisampledAttachments & 8) != 0)
                    params.numDepthStencilSamples = sampleCount;
            }
        }

        // Generate random locations for the color attachments.
        int32_t locations[] = {0, 1, 2, 3};
        for (int i = 0; i < 3; ++i)
        {
            int j = rng.getInt(i, 3);
            std::swap(locations[i], locations[j]);
        }
        size_t nextLocation         = 0;
        perPass.floatColor1Location = (passAttachments[passNdx] & 1) != 0 ? locations[nextLocation++] : -1;
        perPass.floatColor2Location = (passAttachments[passNdx] & 2) != 0 ? locations[nextLocation++] : -1;
        perPass.intColorLocation    = (passAttachments[passNdx] & 4) != 0 ? locations[nextLocation++] : -1;

        // Specify if depth/stencil is used
        perPass.hasDepthStencil = (passAttachments[passNdx] & 8) != 0;

        perPass.resolveFloatColor1      = false;
        perPass.resolveFloatColor2      = false;
        perPass.resolveIntColor         = false;
        perPass.resolveDepthStencil     = false;
        perPass.depthStencilResolveMode = VK_RESOLVE_MODE_NONE;

        DBG(" - %u samples, locations: %d %d %d has D/S? %d\n", perPass.numSamples, perPass.floatColor1Location,
            perPass.floatColor2Location, perPass.intColorLocation, perPass.hasDepthStencil);
    }

    DBG(" Sample counts: %u %u %u %u\n", params.numFloatColor1Samples, params.numFloatColor2Samples,
        params.numIntColorSamples, params.numDepthStencilSamples);

    // Assert that generated passes are valid
    for (uint32_t passNdx = 0; passNdx < passCount; ++passNdx)
    {
        const VkSampleCountFlagBits sampleCounts[4] = {params.numFloatColor1Samples, params.numFloatColor2Samples,
                                                       params.numIntColorSamples, params.numDepthStencilSamples};
        VkSampleCountFlagBits subpassSampleCount    = VK_SAMPLE_COUNT_1_BIT;

        for (uint32_t attachmentNdx = 0; attachmentNdx < 4; ++attachmentNdx)
        {
            if ((passAttachments[passNdx] & (1 << attachmentNdx)) == 0)
                continue;

            const VkSampleCountFlagBits attachmentSampleCount = sampleCounts[attachmentNdx] == VK_SAMPLE_COUNT_1_BIT ?
                                                                    params.perPass[passNdx].numSamples :
                                                                    sampleCounts[attachmentNdx];

            if (subpassSampleCount == VK_SAMPLE_COUNT_1_BIT)
                subpassSampleCount = attachmentSampleCount;

            DE_ASSERT(subpassSampleCount == attachmentSampleCount);
        }
    }

    // Determine when multisampled attachments should resolve.
    uint32_t resolvedAttachmentsMask = singleSampledAttachmentsMask;
    for (uint32_t passNdx = passCount; passNdx > 0; --passNdx)
    {
        TestParams::PerPass &perPass         = params.perPass[passNdx - 1];
        const uint32_t unresolvedAttachments = passAttachments[passNdx - 1] & ~resolvedAttachmentsMask;

        // Make every multisampled attachment resolve in the last pass it's used.
        if ((unresolvedAttachments & 1) != 0)
            perPass.resolveFloatColor1 = true;
        if ((unresolvedAttachments & 2) != 0)
            perPass.resolveFloatColor2 = true;
        if ((unresolvedAttachments & 4) != 0)
            perPass.resolveIntColor = true;
        if ((unresolvedAttachments & 8) != 0)
            perPass.resolveDepthStencil = true;

        if (perPass.resolveDepthStencil || params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT)
            perPass.depthStencilResolveMode =
                depthStencilResolveModeRange[rng.getInt(0, DE_LENGTH_OF_ARRAY(depthStencilResolveModeRange) - 1)];

        resolvedAttachmentsMask |= unresolvedAttachments;

        DBG(" - Resolved 0x%x in pass %u\n", unresolvedAttachments, passNdx - 1);
    }

    // Decide whether clear should be done as part of the render pass.  Tests loadOp=CLEAR vs loadOp=LOAD.
    params.clearBeforeRenderPass = rng.getBool();
    // Decide whether should render to the whole framebuffer or a subarea.
    params.renderToWholeFramebuffer = rng.getBool();
    // These tests blend color so they can verify the results all at once at the end.
    params.testBlendsColors = true;

    // Set random clear values.  Use small values as draw calls do additive blending.
    generateRandomClearValues(rng, params, params.clearValues, true);

    // Decide DrawPushConstants
    for (uint32_t passNdx = 0; passNdx < passCount; ++passNdx)
    {
        TestParams::PerPass &perPass = params.perPass[passNdx];

        for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
        {
            perPass.drawConstantsWithDepthWrite[regionNdx] = DrawPushConstants{
                {Vec4(rng.getFloat(0.05f, 0.1f), 0, rng.getFloat(0.05f, 0.1f), 0),
                 Vec4(0, rng.getFloat(0.05f, 0.1f), 0, rng.getFloat(0.05f, 0.1f))},
                {Vec4(rng.getFloat(0.05f, 0.1f), rng.getFloat(0.05f, 0.1f), 0, 0),
                 Vec4(0, 0, rng.getFloat(0.05f, 0.1f), rng.getFloat(0.05f, 0.1f))},
                {IVec4(0, 0, 0, 0), IVec4(0, 0, 0, 0)},
                // Use quantized values to avoid values that are too close and may cause precision issues
                Vec2(0.1f * static_cast<float>(rng.getInt(2, 9)), 0.1f * static_cast<float>(rng.getInt(2, 9))),
            };

            perPass.drawConstantsWithDepthTest[regionNdx] = DrawPushConstants{
                {Vec4(rng.getFloat(0.05f, 0.1f), 0, rng.getFloat(0.05f, 0.1f), 0),
                 Vec4(0, rng.getFloat(0.05f, 0.1f), 0, rng.getFloat(0.05f, 0.1f))},
                {Vec4(rng.getFloat(0.05f, 0.1f), rng.getFloat(0.05f, 0.1f), 0, 0),
                 Vec4(0, 0, rng.getFloat(0.05f, 0.1f), rng.getFloat(0.05f, 0.1f))},
                {IVec4(0, 0, 0, 0), IVec4(0, 0, 0, 0)},
                Vec2(0.1f * static_cast<float>(rng.getInt(2, 9)) + 0.05f,
                     0.1f * static_cast<float>(rng.getInt(2, 8)) + 0.05f),
            };

            // Integer resolve may choose any sample, so we modify only one channel per pass (hence the maximum of 4 passes).  This way, the verification
            // shader can accept two values per channel.
            perPass.drawConstantsWithDepthWrite[regionNdx].color3Data[0][passNdx] = rng.getInt(1000, 5000);
            perPass.drawConstantsWithDepthWrite[regionNdx].color3Data[1][passNdx] = rng.getInt(1000, 5000);
            perPass.drawConstantsWithDepthTest[regionNdx].color3Data[0][passNdx]  = rng.getInt(1000, 5000);
            perPass.drawConstantsWithDepthTest[regionNdx].color3Data[1][passNdx]  = rng.getInt(1000, 5000);
        }
    }

    // Calculate VerifyPushConstants.  Walk through the passes and emulate what the draw calls would produce.
    // Note: Color clear value is not applied and is added by the verification shader.  This is because the verification shader interpolates colors with black,
    // so the baseline (clear value) is added afterwards.
    Vec2 depthResult[RegionCount];
    UVec2 stencilResult[RegionCount];
    for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
    {
        depthResult[regionNdx] =
            Vec2(params.clearValues[3].depthStencil.depth, params.clearValues[3].depthStencil.depth);
        stencilResult[regionNdx] =
            UVec2(params.clearValues[3].depthStencil.stencil, params.clearValues[3].depthStencil.stencil);
    }

    for (uint32_t passNdx = 0; passNdx < passCount; ++passNdx)
    {
        TestParams::PerPass &perPass = params.perPass[passNdx];

        for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
        {
            // Apply the draw call output to enabled attachments.  Note that the tests always do additive blending, and when depth test succeeds, stencil is incremented.

            // First draw call overwrites depth and always succeeds.
            // Second draw call overwrites only the samples that pass the depth test (which is GREATER).
            const bool evenSamplesPassDepthTest =
                perPass.hasDepthStencil && (!isDepthFormat(params.depthStencilFormat) ||
                                            perPass.drawConstantsWithDepthTest[regionNdx].depthData[0] >
                                                perPass.drawConstantsWithDepthWrite[regionNdx].depthData[0]);
            const bool oddSamplesPassDepthTest =
                perPass.hasDepthStencil && (!isDepthFormat(params.depthStencilFormat) ||
                                            perPass.drawConstantsWithDepthTest[regionNdx].depthData[1] >
                                                perPass.drawConstantsWithDepthWrite[regionNdx].depthData[1]);

            if (perPass.floatColor1Location >= 0)
            {
                params.verifyConstants[regionNdx].color1Data[0] +=
                    perPass.drawConstantsWithDepthWrite[regionNdx].color1Data[0];
                params.verifyConstants[regionNdx].color1Data[1] +=
                    perPass.drawConstantsWithDepthWrite[regionNdx].color1Data[1];
                if (evenSamplesPassDepthTest)
                    params.verifyConstants[regionNdx].color1Data[0] +=
                        perPass.drawConstantsWithDepthTest[regionNdx].color1Data[0];
                if (oddSamplesPassDepthTest)
                    params.verifyConstants[regionNdx].color1Data[1] +=
                        perPass.drawConstantsWithDepthTest[regionNdx].color1Data[1];
            }
            if (perPass.floatColor2Location >= 0)
            {
                params.verifyConstants[regionNdx].color2Data[0] +=
                    perPass.drawConstantsWithDepthWrite[regionNdx].color2Data[0];
                params.verifyConstants[regionNdx].color2Data[1] +=
                    perPass.drawConstantsWithDepthWrite[regionNdx].color2Data[1];
                if (evenSamplesPassDepthTest)
                    params.verifyConstants[regionNdx].color2Data[0] +=
                        perPass.drawConstantsWithDepthTest[regionNdx].color2Data[0];
                if (oddSamplesPassDepthTest)
                    params.verifyConstants[regionNdx].color2Data[1] +=
                        perPass.drawConstantsWithDepthTest[regionNdx].color2Data[1];
            }
            if (perPass.intColorLocation >= 0)
            {
                // Note that integer formats don't blend, so always take the last value that's written.  Each pass writes to only one channel, and color mask is used
                // to emulate the effect of blending.
                if (evenSamplesPassDepthTest)
                    params.verifyConstants[regionNdx].color3Data[0] +=
                        perPass.drawConstantsWithDepthTest[regionNdx].color3Data[0];
                else
                    params.verifyConstants[regionNdx].color3Data[0] +=
                        perPass.drawConstantsWithDepthWrite[regionNdx].color3Data[0];

                if (oddSamplesPassDepthTest)
                    params.verifyConstants[regionNdx].color3Data[1] +=
                        perPass.drawConstantsWithDepthTest[regionNdx].color3Data[1];
                else
                    params.verifyConstants[regionNdx].color3Data[1] +=
                        perPass.drawConstantsWithDepthWrite[regionNdx].color3Data[1];
            }
            if (perPass.hasDepthStencil)
            {
                depthResult[regionNdx] = perPass.drawConstantsWithDepthWrite[regionNdx].depthData;
                stencilResult[regionNdx] += UVec2(1);

                if (evenSamplesPassDepthTest)
                    ++stencilResult[regionNdx][0];
                if (oddSamplesPassDepthTest)
                    ++stencilResult[regionNdx][1];
            }

            // There is no need to resolve color attachments between passes.  For float formats, the additive nature of blend and resolve means we can continue adding to
            // the two color vectors and get the same result in the end, no matter when and how often resolve happens.  For the integer formats this is not true (because resolve
            // does not average), so the test makes sure every channel is written to in only one pass, which again means there's no need to perform a resolve in between passes.
            // Depth/stencil needs to resolve though, either if multisampled and requested or if it's single sampled.
            if (perPass.resolveDepthStencil || params.numDepthStencilSamples == VK_SAMPLE_COUNT_1_BIT)
            {
                DE_ASSERT(perPass.depthStencilResolveMode == VK_RESOLVE_MODE_SAMPLE_ZERO_BIT ||
                          perPass.depthStencilResolveMode == VK_RESOLVE_MODE_MAX_BIT);
                if (perPass.depthStencilResolveMode == VK_RESOLVE_MODE_SAMPLE_ZERO_BIT)
                {
                    params.verifyConstants[regionNdx].depthData   = depthResult[regionNdx][0];
                    params.verifyConstants[regionNdx].stencilData = stencilResult[regionNdx][0];
                }
                else
                {
                    params.verifyConstants[regionNdx].depthData =
                        std::max(depthResult[regionNdx][0], depthResult[regionNdx][1]);
                    params.verifyConstants[regionNdx].stencilData =
                        std::max(stencilResult[regionNdx][0], stencilResult[regionNdx][1]);
                }

                // If depth/stencil is single-sampled, prepare the data for the next pass.  If multisampled, it will no longer be used after the resolve.
                depthResult[regionNdx][0] = depthResult[regionNdx][1] = params.verifyConstants[regionNdx].depthData;
                stencilResult[regionNdx][0]                           = stencilResult[regionNdx][1] =
                    params.verifyConstants[regionNdx].stencilData;
            }
        }
    }

    params.rngSeed = rng.getUint32();

    // Note: formats are decided outside this function
}

void initMultipassPrograms(SourceCollections &programCollection, const TestParams params)
{
    // Vertex shader - position
    {
        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "\n"
            << "layout(location = 0) in  vec4 in_position;\n"
            << "\n"
            << "out gl_PerVertex {\n"
            << "    vec4 gl_Position;\n"
            << "};\n"
            << "\n"
            << "void main(void)\n"
            << "{\n"
            << "    gl_Position = in_position;\n"
            << "}\n";

        programCollection.glslSources.add("vert") << glu::VertexSource(src.str());
    }

    const bool usesSignedIntFormat = params.intColorFormat == VK_FORMAT_R16G16B16A16_SINT;
    const char *intTypePrefix      = usesSignedIntFormat ? "i" : "u";

    // Fragment shader - output color based on sample index and push constants
    size_t count = params.perPass.size();
    if (!params.renderToAttachment)
        ++count;
    for (size_t passNdx = 0; passNdx < count; ++passNdx)
    {
        const TestParams::PerPass &perPass = params.perPass[passNdx % params.perPass.size()];

        // The framebuffer contains four attachments with a mixture of samples.  A subpass can only contain a mixture of 1x and Nx samples with the pipelines configured at Nx multisampled rendering.
        // The fragment shader is adjusted based on which of these attachments are used in the subpass.  The output of the fragment shader is determined by push constants
        // as such (2 colors specified per output in uniform data):
        //
        // - For even samples, output color is interpolation of color 0 and transparent black from left to right
        // - For odd samples, output color is interpolation of color 1 and transparent black from top to bottom
        //
        // Additionally, the fragment shader outputs depth based on the sample index as well.
        //
        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "\n";

        if (perPass.floatColor1Location >= 0)
            src << "layout(location = " << perPass.floatColor1Location << ") out vec4 o_color1;\n";
        else if (passNdx == params.perPass.size())
            src << "layout(location = 0) out vec4 o_color1;\n";
        if (perPass.floatColor2Location >= 0)
            src << "layout(location = " << perPass.floatColor2Location << ") out vec4 o_color2;\n";
        if (perPass.intColorLocation >= 0)
            src << "layout(location = " << perPass.intColorLocation << ") out " << intTypePrefix << "vec4 o_color3;\n";

        src << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "    vec4 color1Data[2];\n"
            << "    vec4 color2Data[2];\n"
            << "    ivec4 color3Data[2];\n"
            << "    vec2 depthData;\n"
            << "} params;\n"
            << "\n"
            << "void main(void)\n"
            << "{\n"
            << "    vec2 uv = (gl_FragCoord.xy - vec2(params.area.xy)) / vec2(params.area.zw);\n"
            << "    if (gl_SampleID % 2 == 0)\n"
            << "    {\n";

        if (perPass.floatColor1Location >= 0 || passNdx == params.perPass.size())
            src << "        o_color1 = params.color1Data[0] * uv.x;\n";
        if (perPass.floatColor2Location >= 0)
            src << "        o_color2 = params.color2Data[0] * uv.x;\n";
        if (perPass.intColorLocation >= 0)
            src << "        o_color3 = " << intTypePrefix << "vec4(vec4(params.color3Data[0]) * uv.x);\n";
        if (perPass.hasDepthStencil)
            src << "        gl_FragDepth = params.depthData.x;\n";

        src << "    }\n"
            << "    else\n"
            << "    {\n";

        if (perPass.floatColor1Location >= 0 || passNdx == params.perPass.size())
            src << "        o_color1 = params.color1Data[1] * uv.y;\n";
        if (perPass.floatColor2Location >= 0)
            src << "        o_color2 = params.color2Data[1] * uv.y;\n";
        if (perPass.intColorLocation >= 0)
            src << "        o_color3 = " << intTypePrefix << "vec4(vec4(params.color3Data[1]) * uv.y);\n";
        if (perPass.hasDepthStencil)
            src << "        gl_FragDepth = params.depthData.y;\n";

        src << "    }\n"
            << "}\n";

        std::ostringstream name;
        name << "frag_" << passNdx;

        programCollection.glslSources.add(name.str()) << glu::FragmentSource(src.str());
    }

    // Compute shader - verify the results of rendering
    {
        // The images are cleared and rendered to, possibly multiple times with blend, by blending between one color and black horizontally and another color and black vertically for every other sample.
        // Once resolved, the resulting image is verified by interpolating one color and black horizontally, another color and black vertically, averaging them and adding in the clear color.  For integer
        // formats, instead of averaging the two interpolated colors, either of the colors is accepted as integer resolves selects any sample.  A comparison threshold is used to avoid precision issues.
        // Each pixel that passes the test atomically increments an integer in the output buffer.  The test passes if the final number in the output buffer is the same as the number of pixels in the area being verified.

        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "#extension GL_EXT_samplerless_texture_functions : require\n"
            << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "    vec4 color1Data[2];\n"
            << "    vec4 color2Data[2];\n"
            << "    ivec4 color3Data[2];\n"
            << "    float depthData;\n"
            << "    uint stencilData;\n"
            << "} params;\n"
            << "\n"
            << "layout(local_size_x = 8, local_size_y = 8) in;\n"
            << "layout(set = 0, binding = 0, std430) writeonly buffer Output {\n"
            << "    uint colorVerification[3];\n"
            << "    uint depthVerification;\n"
            << "    uint stencilVerification;\n"
            << "} sb_out;\n"
            << "layout(set = 0, binding = 1) uniform texture2D color1Image;\n"
            << "layout(set = 0, binding = 2) uniform texture2D color2Image;\n"
            << "layout(set = 0, binding = 3) uniform " << (usesSignedIntFormat ? "i" : "u")
            << "texture2D color3Image;\n";
        if (isDepthFormat(params.depthStencilFormat))
            src << "layout(set = 0, binding = 4) uniform texture2D depthImage;\n";
        if (isStencilFormat(params.depthStencilFormat))
            src << "layout(set = 0, binding = 5) uniform utexture2D stencilImage;\n";
        src << "layout(set = 0, binding = 6, rgba8) uniform writeonly image2DArray verify;\n"
            << "\n"
            << "bool fmatches(float a, float b, float error)\n"
            << "{\n"
            << "    return abs(a - b) < error;\n"
            << "}\n"
            << "bool umatches(uint a, uint b, uint error)\n"
            << "{\n"
            << "    return abs(a - b) <= error;\n"
            << "}\n"
            << "bool v4matches(vec4 a, vec4 b, vec4 error)\n"
            << "{\n"
            << "    return all(lessThan(abs(a - b), error));\n"
            << "}\n"
            << "bool i4matchesEither(ivec4 a, ivec4 b, ivec4 c, ivec4 errorB, ivec4 errorC)\n"
            << "{\n"
            << "    const bvec4 bMatches = lessThanEqual(abs(a - b), errorB);\n"
            << "    const bvec4 cMatches = lessThanEqual(abs(a - c), errorC);\n"
            << "    return all(bvec4(bMatches.x || cMatches.x, bMatches.y || cMatches.y, bMatches.z || cMatches.z, "
               "bMatches.w || cMatches.w));\n"
            << "}\n"
            << "\n"
            << "void main (void)\n"
            << "{\n"
            << "    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, params.area.zw)))\n"
            << "        return;\n"
            << "\n"
            << "    uvec2 coords = params.area.xy + gl_GlobalInvocationID.xy;\n"
            << "    vec2 uv = (vec2(gl_GlobalInvocationID.xy) + vec2(0.5)) / vec2(params.area.zw);\n"
            << "\n"
            << "    vec4 result1 = vec4(1, 0, 0, 1);\n"
            << "    vec4 color1 = texelFetch(color1Image, ivec2(coords), 0);\n"
            << "    vec4 expected1 = (params.color1Data[0] * uv.x + params.color1Data[1] * uv.y) / 2.0";
        if (params.testBlendsColors)
            src << " + vec4(" << params.clearValues[0].color.float32[0] << ", "
                << params.clearValues[0].color.float32[1] << ", " << params.clearValues[0].color.float32[2] << ", "
                << params.clearValues[0].color.float32[3] << ")";
        src << ";\n"
            // Allow room for precision errors.  Rendering happens at sample locations while verification uv is in the middle of pixel.
            << "    if (v4matches(color1, expected1, max(params.color1Data[0] / float(params.area.z), "
               "params.color1Data[1] / float(params.area.w)) + 2.0/255.0))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.colorVerification[0], 1);\n"
            << "        result1 = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, 0), result1);\n"
            << "\n"
            << "    vec4 result2 = vec4(1, 0, 0, 1);\n"
            << "    vec4 color2 = texelFetch(color2Image, ivec2(coords), 0);\n"
            << "    vec4 expected2 = (params.color2Data[0] * uv.x + params.color2Data[1] * uv.y) / 2.0";
        if (params.testBlendsColors)
            src << " + vec4(" << params.clearValues[1].color.float32[0] << ", "
                << params.clearValues[1].color.float32[1] << ", " << params.clearValues[1].color.float32[2] << ", "
                << params.clearValues[1].color.float32[3] << ")";
        src << ";\n"
            // Allow room for precision errors.  Rendering happens at sample locations while verification uv is in the middle of pixel.
            << "    if (v4matches(color2, expected2, max(params.color2Data[0] / float(params.area.z), "
               "params.color2Data[1] / float(params.area.w)) + 2.0/1024.0))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.colorVerification[1], 1);\n"
            << "        result2 = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, 1), result2);\n"
            << "\n"
            << "    vec4 result3 = vec4(1, 0, 0, 1);\n"
            << "    ivec4 color3 = ivec4(texelFetch(color3Image, ivec2(coords), 0));\n";
        // Note that integer formats don't blend, so clear values are discarded, except for channels that are never written to.  Each pass
        // outputs only to one channel.
        if (params.testBlendsColors)
            src << "    ivec4 clearValue3 = ivec4("
                << (params.perPass[0].intColorLocation < 0 ? params.clearValues[2].color.int32[0] : 0) << ", "
                << (params.perPass.size() < 2 || params.perPass[1].intColorLocation < 0 ?
                        params.clearValues[2].color.int32[1] :
                        0)
                << ", "
                << (params.perPass.size() < 3 || params.perPass[2].intColorLocation < 0 ?
                        params.clearValues[2].color.int32[2] :
                        0)
                << ", "
                << (params.perPass.size() < 4 || params.perPass[3].intColorLocation < 0 ?
                        params.clearValues[2].color.int32[3] :
                        0)
                << ")"
                << ";\n";
        else
            src << "    ivec4 clearValue3 = ivec4(0);\n";
        src << "    ivec4 expected3_0 = ivec4(params.color3Data[0] * uv.x) + clearValue3;\n"
            << "    ivec4 expected3_1 = ivec4(params.color3Data[1] * uv.y) + clearValue3;\n"
            // Allow room for precision errors.  Rendering happens at sample locations while verification uv is in the middle of pixel.
            << "    if (i4matchesEither(color3, expected3_0, expected3_1, params.color3Data[0] / int(params.area.z), "
               "params.color3Data[1] / int(params.area.w)))\n"
            << "    {\n"
            << "        atomicAdd(sb_out.colorVerification[2], 1);\n"
            << "        result3 = vec4(0, 1, 0, 1);\n"
            << "    }\n"
            << "    imageStore(verify, ivec3(coords, 2), result3);\n"
            << "\n";
        if (isDepthFormat(params.depthStencilFormat))
            src << "    vec4 resultDepth = vec4(1, 0, 0, 1);\n"
                << "    float depth  = texelFetch(depthImage, ivec2(coords), 0).r;\n"
                << "    if (fmatches(depth, params.depthData, 0.01))\n"
                << "    {\n"
                << "        atomicAdd(sb_out.depthVerification, 1);\n"
                << "        resultDepth = vec4(0, 1, 0, 1);\n"
                << "    }\n"
                << "    imageStore(verify, ivec3(coords, 3), resultDepth);\n";
        if (isStencilFormat(params.depthStencilFormat))
            src << "    vec4 resultStencil = vec4(1, 0, 0, 1);\n"
                << "    uint stencil = texelFetch(stencilImage, ivec2(coords), 0).r;\n"
                << "    if (umatches(stencil, params.stencilData, 0))\n"
                << "    {\n"
                << "        atomicAdd(sb_out.stencilVerification, 1);\n"
                << "        resultStencil = vec4(0, 1, 0, 1);\n"
                << "    }\n"
                << "    imageStore(verify, ivec3(coords, 4), resultStencil);\n";
        src << "}\n";

        programCollection.glslSources.add("comp") << glu::ComputeSource(src.str());
    }

    const bool verifyOutsideRenderArea = params.clearBeforeRenderPass && !params.renderToWholeFramebuffer;
    if (verifyOutsideRenderArea)
        initConstantColorVerifyPrograms(programCollection, params);
}

void copyToInputAttachment(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects,
                           const PipelineLayoutWrapper &pipelineLayout, const ShaderWrapper &vertexModule,
                           const UVec4 *regions)
{
    const InstanceInterface &vki          = context.getInstanceInterface();
    const DeviceInterface &vk             = context.getDeviceInterface();
    const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
    const VkDevice device                 = context.getDevice();

    const ShaderWrapper fragmentModule2(ShaderWrapper(vk, device, context.getBinaryCollection().get("frag_2"), 0u));

    const VkRect2D renderArea = {{static_cast<int32_t>(wd.renderArea.x()), static_cast<int32_t>(wd.renderArea.y())},
                                 {wd.renderArea.z(), wd.renderArea.w()}};

    vk::VkAttachmentDescription2 attachmentDescription{
        VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, // VkStructureType sType;
        DE_NULL,                                    // const void* pNext;
        (VkAttachmentDescriptionFlags)0u,           // VkAttachmentDescriptionFlags flags;
        params.floatColor1Format,                   // VkFormat format;
        params.numFloatColor1Samples,               // VkSampleCountFlagBits samples;
        VK_ATTACHMENT_LOAD_OP_CLEAR,                // VkAttachmentLoadOp loadOp;
        VK_ATTACHMENT_STORE_OP_STORE,               // VkAttachmentStoreOp storeOp;
        VK_ATTACHMENT_LOAD_OP_DONT_CARE,            // VkAttachmentLoadOp stencilLoadOp;
        VK_ATTACHMENT_STORE_OP_DONT_CARE,           // VkAttachmentStoreOp stencilStoreOp;
        VK_IMAGE_LAYOUT_UNDEFINED,                  // VkImageLayout initialLayout;
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,   // VkImageLayout finalLayout;
    };

    vk::VkAttachmentReference2 attachmentReference{
        VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // VkStructureType sType;
        DE_NULL,                                  // const void* pNext;
        0u,                                       // uint32_t attachment;
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout layout;
        VK_IMAGE_ASPECT_COLOR_BIT,                // VkImageAspectFlags aspectMask;
    };

    VkMultisampledRenderToSingleSampledInfoEXT msrtss = {
        VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, // VkStructureType            sType
        DE_NULL,                                                          // const void*                pNext
        VK_TRUE,                      // VkBool32                    multisampledRenderToSingleSampledEnable
        params.perPass[0].numSamples, // VkSampleCountFlagBits    rasterizationSamples
    };

    vk::VkSubpassDescription2 subpass = {
        VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, // VkStructureType                 sType;
        &msrtss,                                 // const void*                     pNext;
        (VkSubpassDescriptionFlags)0,            // VkSubpassDescriptionFlags       flags;
        VK_PIPELINE_BIND_POINT_GRAPHICS,         // VkPipelineBindPoint             pipelineBindPoint;
        0u,                                      // uint32_t                        viewMask;
        0u,                                      // uint32_t                        inputAttachmentCount;
        DE_NULL,                                 // const VkAttachmentReference2*   pInputAttachments;
        1u,                                      // uint32_t                        colorAttachmentCount;
        &attachmentReference,                    // const VkAttachmentReference2*   pColorAttachments;
        0u,                                      // const VkAttachmentReference2*   pResolveAttachments;
        DE_NULL,                                 // const VkAttachmentReference2*   pDepthStencilAttachment;
        0u,                                      // uint32_t                        preserveAttachmentCount;
        DE_NULL,                                 // const uint32_t*                 pPreserveAttachments;
    };

    const VkRenderPassCreateInfo2 renderPassInfo = {
        VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, // VkStructureType sType;
        DE_NULL,                                     // const void* pNext;
        (VkRenderPassCreateFlags)0,                  // VkRenderPassCreateFlags flags;
        1u,                                          // uint32_t attachmentCount;
        &attachmentDescription,                      // const VkAttachmentDescription2* pAttachments;
        1u,                                          // uint32_t subpassCount;
        &subpass,                                    // const VkSubpassDescription2* pSubpasses;
        0u,                                          // uint32_t dependencyCount;
        DE_NULL,                                     // const VkSubpassDependency2* pDependencies;
        0u,                                          // uint32_t                         correlatedViewMaskCount;
        DE_NULL,                                     // const uint32_t*                  pCorrelatedViewMasks;
    };

    testObjects.dataRenderPassFramebuffer =
        RenderPassWrapper(params.pipelineConstructionType, vk, device, &renderPassInfo);
    testObjects.dataRenderPassFramebuffer.createFramebuffer(vk, device, *wd.dataColor1.image, *wd.dataColor1.view,
                                                            wd.framebufferSize.x(), wd.framebufferSize.y());

    testObjects.dataRenderPassFramebuffer.begin(vk, *testObjects.cmdBuffer, renderArea, 1u, params.clearValues);

    // start render pass and end after
    const VkDeviceSize vertexBufferOffset = 0;
    vk.cmdBindVertexBuffers(*testObjects.cmdBuffer, 0u, 1u, &wd.vertexBuffer.get(), &vertexBufferOffset);

    // First draw call outputs to color attachment 1 and depth/stencil.  It doesn't blend with clear for simplicity of the verification code.
    for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
    {
        testObjects.graphicsPipelines.push_back(pipeline::makeGraphicsPipeline(
            vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
            pipelineLayout, *testObjects.dataRenderPassFramebuffer, DE_NULL, vertexModule, fragmentModule2, false, true,
            false, 0, 0, 0, regions[regionNdx], regions[regionNdx], params.perPass[0].numSamples,
            params.useGarbageAttachment, true));

        vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(UVec4),
                            &regions[regionNdx]);
        vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(UVec4),
                            sizeof(params.perPass[0].drawConstantsWithDepthWrite[regionNdx]),
                            &params.perPass[0].drawConstantsWithDepthWrite[regionNdx]);
        (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
        vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);
    }

    testObjects.dataRenderPassFramebuffer.end(vk, *testObjects.cmdBuffer);

    vk::VkBufferImageCopy copy = {
        0u,                                      // VkDeviceSize                         bufferOffset;
        0u,                                      // uint32_t                                     bufferRowLength;
        0u,                                      // uint32_t                                     bufferImageHeight;
        {VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u}, // VkImageSubresourceLayers     imageSubresource;
        {0u, 0u, 0u},                            // VkOffset3D                           imageOffset;
        {wd.framebufferSize.x(), wd.framebufferSize.y(), 1u} // VkExtent3D                           imageExtent;
    };

    vk::VkImageMemoryBarrier dataBarrier = {
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // VkStructureType sType;
        DE_NULL,                                    // const void* pNext;
        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,       // VkAccessFlags srcAccessMask;
        VK_ACCESS_TRANSFER_READ_BIT,                // VkAccessFlags dstAccessMask;
        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,   // VkImageLayout oldLayout;
        VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,       // VkImageLayout newLayout;
        0u,                                         // uint32_t srcQueueFamilyIndex;
        0u,                                         // uint32_t dstQueueFamilyIndex;
        *wd.dataColor1.image,                       // VkImage image;
        {VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u} // VkImageSubresourceRange subresourceRange;
    };
    vk::VkImageMemoryBarrier preBarrier = {
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // VkStructureType sType;
        DE_NULL,                                    // const void* pNext;
        VK_ACCESS_NONE,                             // VkAccessFlags srcAccessMask;
        VK_ACCESS_TRANSFER_WRITE_BIT,               // VkAccessFlags dstAccessMask;
        VK_IMAGE_LAYOUT_UNDEFINED,                  // VkImageLayout oldLayout;
        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,       // VkImageLayout newLayout;
        0u,                                         // uint32_t srcQueueFamilyIndex;
        0u,                                         // uint32_t dstQueueFamilyIndex;
        *wd.floatColor1.image,                      // VkImage image;
        {VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u} // VkImageSubresourceRange subresourceRange;
    };
    vk::VkImageMemoryBarrier postBarrier = {
        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,     // VkStructureType sType;
        DE_NULL,                                    // const void* pNext;
        VK_ACCESS_TRANSFER_WRITE_BIT,               // VkAccessFlags srcAccessMask;
        VK_ACCESS_SHADER_READ_BIT,                  // VkAccessFlags dstAccessMask;
        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,       // VkImageLayout oldLayout;
        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,       // VkImageLayout newLayout;
        0u,                                         // uint32_t srcQueueFamilyIndex;
        0u,                                         // uint32_t dstQueueFamilyIndex;
        *wd.floatColor1.image,                      // VkImage image;
        {VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u} // VkImageSubresourceRange subresourceRange;
    };
    VkDeviceSize bufferSize = static_cast<VkDeviceSize>(wd.framebufferSize.x() * wd.framebufferSize.y() * 4u);
    vk::VkBufferMemoryBarrier bufferBarrier = {
        VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
        DE_NULL,                                 // const void* pNext;
        VK_ACCESS_TRANSFER_WRITE_BIT,            // VkAccessFlags srcAccessMask;
        VK_ACCESS_TRANSFER_READ_BIT,             // VkAccessFlags dstAccessMask;
        0u,                                      // uint32_t srcQueueFamilyIndex;
        0u,                                      // uint32_t dstQueueFamilyIndex;
        *wd.dataBuffer,                          // VkBuffer buffer;
        0u,                                      // VkDeviceSize offset;
        bufferSize                               // VkDeviceSize size;
    };
    vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                          VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &dataBarrier);
    vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_NONE, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u,
                          DE_NULL, 0u, DE_NULL, 1u, &preBarrier);
    vk.cmdCopyImageToBuffer(*testObjects.cmdBuffer, *wd.dataColor1.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                            *wd.dataBuffer, 1u, &copy);
    vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
                          0u, DE_NULL, 1u, &bufferBarrier, 0u, DE_NULL);
    vk.cmdCopyBufferToImage(*testObjects.cmdBuffer, *wd.dataBuffer, *wd.floatColor1.image,
                            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &copy);
    vk.cmdPipelineBarrier(*testObjects.cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                          0u, 0u, DE_NULL, 0u, DE_NULL, 1u, &postBarrier);
}

void drawInputAttachments(Context &context, const TestParams &params, WorkingData &wd, TestObjects &testObjects)
{
    const InstanceInterface &vki          = context.getInstanceInterface();
    const DeviceInterface &vk             = context.getDeviceInterface();
    const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
    const VkDevice device                 = context.getDevice();
    const uint32_t numSubpasses           = static_cast<uint32_t>(params.perPass.size());

    if (params.clearBeforeRenderPass)
    {
        clearImagesBeforeDraw(context, params, wd, testObjects);
    }

    // Create a render pass and a framebuffer
    {
        std::vector<VkSubpassDescription2> subpasses;
        std::vector<VkImage> images;
        std::vector<VkImageView> attachments;
        std::vector<VkAttachmentDescription2> attachmentDescriptions;
        std::vector<std::vector<VkAttachmentReference2>> attachmentReferences(numSubpasses);
        std::vector<std::vector<VkAttachmentReference2>> resolveAttachmentReferences(numSubpasses);
        std::vector<std::vector<uint32_t>> preserveAttachments(numSubpasses);
        std::vector<VkAttachmentReference2> inputAttachmentReferences;
        std::vector<VkSubpassDependency2> subpassDependencies;
        std::vector<VkMultisampledRenderToSingleSampledInfoEXT> msrtss(numSubpasses);
        std::vector<VkSubpassDescriptionDepthStencilResolve> depthStencilResolve(numSubpasses);
        int32_t attachmentNdxes[8] = {-1, -1, -1, -1, -1, -1, -1, -1};
        uint32_t attachmentUseMask = 0;

        initializeAttachments(params, wd, images, attachments, params.perPass.size(), attachmentNdxes);
        initializeAttachmentDescriptions(params, attachmentDescriptions, params.clearBeforeRenderPass, attachmentNdxes,
                                         attachmentUseMask);

        DE_ASSERT(numSubpasses == 2);
        inputAttachmentReferences.resize(2,
                                         VkAttachmentReference2{
                                             VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, // VkStructureType       sType;
                                             DE_NULL,                                  // const void*           pNext;
                                             VK_ATTACHMENT_UNUSED,      // uint32_t              attachment;
                                             VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout         layout;
                                             0,                         // VkImageAspectFlags    aspectMask;
                                         });
        // Color attachment 1 and depth/stencil attachment are used as input attachments in subpass 1.
        initializeAttachmentReference(inputAttachmentReferences[0], attachmentNdxes[0], VK_FORMAT_UNDEFINED, true);
        initializeAttachmentReference(inputAttachmentReferences[1], attachmentNdxes[3], params.depthStencilFormat,
                                      true);

        for (uint32_t passNdx = 0; passNdx < numSubpasses; ++passNdx)
        {
            const std::vector<VkAttachmentReference2> noInputAttachments;

            addSubpassDescription(params, passNdx, attachmentReferences[passNdx], resolveAttachmentReferences[passNdx],
                                  depthStencilResolve[passNdx], &preserveAttachments[passNdx], msrtss[passNdx],
                                  subpasses, passNdx == 0 ? noInputAttachments : inputAttachmentReferences,
                                  attachmentNdxes);
        }

        subpassDependencies.push_back(VkSubpassDependency2{
            VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, // VkStructureType         sType;
            DE_NULL,                                // const void*             pNext;
            0,                                      // uint32_t                srcSubpass;
            1,                                      // uint32_t                dstSubpass;

            VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT |
                VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, // VkPipelineStageFlags    srcStageMask;

            VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, // VkPipelineStageFlags    dstStageMask;

            VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT |
                VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, // VkAccessFlags           srcAccessMask;

            VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, // VkAccessFlags           dstAccessMask;

            VK_DEPENDENCY_BY_REGION_BIT, // VkDependencyFlags       dependencyFlags;
            0,                           // int32_t                 viewOffset;
        });

        createRenderPassAndFramebuffer(context, wd, testObjects, params.pipelineConstructionType, images, attachments,
                                       attachmentDescriptions, subpasses, subpassDependencies);
    }

    const VkPushConstantRange &pushConstantRange = {
        VK_SHADER_STAGE_FRAGMENT_BIT,                                     // VkShaderStageFlags    stageFlags;
        0,                                                                // uint32_t              offset;
        static_cast<uint32_t>(sizeof(UVec4) + sizeof(DrawPushConstants)), // uint32_t              size;
    };

    const ShaderWrapper vertexModule(ShaderWrapper(vk, device, context.getBinaryCollection().get("vert"), 0u));
    const ShaderWrapper fragmentModule0(ShaderWrapper(vk, device, context.getBinaryCollection().get("frag_0"), 0u));
    const ShaderWrapper fragmentModule1(ShaderWrapper(vk, device, context.getBinaryCollection().get("frag_1"), 0u));
    const PipelineLayoutWrapper pipelineLayout(params.pipelineConstructionType, vk, device, 0, DE_NULL, 1,
                                               &pushConstantRange);

    // Descriptor set and layout for the draw call that uses input attachments
    const Unique<VkDescriptorSetLayout> descriptorSetLayout(
        DescriptorSetLayoutBuilder()
            .addSingleBinding(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_SHADER_STAGE_FRAGMENT_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_SHADER_STAGE_FRAGMENT_BIT)
            .addSingleBinding(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_SHADER_STAGE_FRAGMENT_BIT)
            .build(vk, device));

    testObjects.descriptorPools.emplace_back(
        DescriptorPoolBuilder()
            .addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1u)
            .addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1u)
            .addType(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1u)
            .build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));

    testObjects.descriptorSets.emplace_back(
        makeDescriptorSet(vk, device, *testObjects.descriptorPools.back(), *descriptorSetLayout));

    const VkDescriptorImageInfo color1Info =
        makeDescriptorImageInfo(DE_NULL, *wd.floatColor1.view, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
    const VkDescriptorImageInfo depthInfo = makeDescriptorImageInfo(
        DE_NULL, isDepthFormat(params.depthStencilFormat) ? *wd.depthOnlyImageView : *wd.stencilOnlyImageView,
        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
    const VkDescriptorImageInfo stencilInfo = makeDescriptorImageInfo(
        DE_NULL, isStencilFormat(params.depthStencilFormat) ? *wd.stencilOnlyImageView : *wd.depthOnlyImageView,
        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

    DescriptorSetUpdateBuilder builder;

    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(0u),
                        VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, &color1Info);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(1u),
                        VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, &depthInfo);
    builder.writeSingle(*testObjects.descriptorSets.back(), DescriptorSetUpdateBuilder::Location::binding(2u),
                        VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, &stencilInfo);

    builder.update(vk, device);

    const VkPushConstantRange &inputPushConstantRange = {
        VK_SHADER_STAGE_FRAGMENT_BIT,         // VkShaderStageFlags    stageFlags;
        0,                                    // uint32_t              offset;
        static_cast<uint32_t>(sizeof(UVec4)), // uint32_t              size;
    };

    const ShaderWrapper fragmentModuleIn(ShaderWrapper(vk, device, context.getBinaryCollection().get("frag_in"), 0u));
    const PipelineLayoutWrapper inputPipelineLayout(params.pipelineConstructionType, vk, device, 1,
                                                    &*descriptorSetLayout, 1, &inputPushConstantRange);

    UVec4 regions[RegionCount];
    getDrawRegions(wd, regions);

    if (!params.renderToAttachment)
    {
        copyToInputAttachment(context, params, wd, testObjects, pipelineLayout, vertexModule, regions);
    }

    startRenderPass(context, wd, testObjects, DE_LENGTH_OF_ARRAY(params.clearValues), params.clearValues);

    {
        DE_ASSERT(numSubpasses == 2);

        const VkDeviceSize vertexBufferOffset = 0;
        vk.cmdBindVertexBuffers(*testObjects.cmdBuffer, 0u, 1u, &wd.vertexBuffer.get(), &vertexBufferOffset);

        // First draw call outputs to color attachment 1 and depth/stencil.  It doesn't blend with clear for simplicity of the verification code.
        for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
        {
            testObjects.graphicsPipelines.push_back(pipeline::makeGraphicsPipeline(
                vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
                pipelineLayout, *testObjects.renderPassFramebuffers.back(), DE_NULL, vertexModule, fragmentModule0,
                false, true, false, 0, 0, params.perPass[0].intColorLocation, regions[regionNdx], regions[regionNdx],
                params.perPass[0].numSamples, params.useGarbageAttachment));

            vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(UVec4),
                                &regions[regionNdx]);
            vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(UVec4),
                                sizeof(params.perPass[0].drawConstantsWithDepthWrite[regionNdx]),
                                &params.perPass[0].drawConstantsWithDepthWrite[regionNdx]);
            (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
            vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);
        }

        // Next subpass initializes color attachments 2 and 3 from color attachment 1 and depth/stencil, then issues a draw call that modifies those attachments.
        testObjects.renderPassFramebuffers.back().nextSubpass(vk, *testObjects.cmdBuffer, VK_SUBPASS_CONTENTS_INLINE);

        for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
        {
            testObjects.graphicsPipelines.push_back(pipeline::makeGraphicsPipeline(
                vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
                inputPipelineLayout, *testObjects.renderPassFramebuffers.back(), DE_NULL, vertexModule,
                fragmentModuleIn, false, false, false, 0, 1, params.perPass[1].intColorLocation, regions[regionNdx],
                regions[regionNdx], params.perPass[1].numSamples, params.useGarbageAttachment));

            vk.cmdPushConstants(*testObjects.cmdBuffer, *inputPipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0,
                                sizeof(UVec4), &regions[regionNdx]);
            (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
            vk.cmdBindDescriptorSets(*testObjects.cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *inputPipelineLayout, 0u,
                                     1u, &testObjects.descriptorSets.back().get(), 0u, DE_NULL);
            vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);
        }

        for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
        {
            testObjects.graphicsPipelines.push_back(pipeline::makeGraphicsPipeline(
                vki, vk, physicalDevice, device, context.getDeviceExtensions(), params.pipelineConstructionType,
                pipelineLayout, *testObjects.renderPassFramebuffers.back(), DE_NULL, vertexModule, fragmentModule1,
                true, false, false, 0xC, 1, params.perPass[1].intColorLocation, regions[regionNdx], regions[regionNdx],
                params.perPass[1].numSamples, params.useGarbageAttachment));

            vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(UVec4),
                                &regions[regionNdx]);
            vk.cmdPushConstants(*testObjects.cmdBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(UVec4),
                                sizeof(params.perPass[1].drawConstantsWithDepthWrite[regionNdx]),
                                &params.perPass[1].drawConstantsWithDepthWrite[regionNdx]);
            (*testObjects.graphicsPipelines.back()).bind(*testObjects.cmdBuffer);
            vk.cmdDraw(*testObjects.cmdBuffer, 3, 1u, 0u, 0u);
        }
    }

    testObjects.renderPassFramebuffers.back().end(vk, *testObjects.cmdBuffer);

    // Verify results
    dispatchVerifyMultiPassRendering(context, params, wd, testObjects, regions);
}

//! Verify input attachments and multisampled rendering interact correctly.
tcu::TestStatus testInputAttachments(Context &context, const TestParams params)
{
    WorkingData wd;
    TestObjects testObjects(context);
    testStart(context, params, wd, testObjects);

    drawInputAttachments(context, params, wd, testObjects);

    testEnd(context, params, wd, testObjects);

    return verify(context, params, wd);
}

void generateInputAttachmentsTest(de::Random &rng, TestParams &params, const VkSampleCountFlagBits sampleCount,
                                  const VkResolveModeFlagBits resolveMode, const bool renderToWholeFramebuffer,
                                  const bool renderToAttachment)
{
    params.perPass.resize(2);

    // Set the sample count for attachments.
    if (params.isMultisampledRenderToSingleSampled)
    {
        params.numFloatColor1Samples  = VK_SAMPLE_COUNT_1_BIT;
        params.numFloatColor2Samples  = VK_SAMPLE_COUNT_1_BIT;
        params.numIntColorSamples     = VK_SAMPLE_COUNT_1_BIT;
        params.numDepthStencilSamples = VK_SAMPLE_COUNT_1_BIT;

        params.perPass[0].resolveFloatColor1  = false;
        params.perPass[0].resolveDepthStencil = false;

        params.perPass[1].resolveFloatColor2 = false;
        params.perPass[1].resolveIntColor    = false;
    }
    else
    {
        params.numFloatColor1Samples  = sampleCount;
        params.numFloatColor2Samples  = sampleCount;
        params.numIntColorSamples     = sampleCount;
        params.numDepthStencilSamples = sampleCount;

        params.perPass[0].resolveFloatColor1  = true;
        params.perPass[0].resolveDepthStencil = true;

        params.perPass[1].resolveFloatColor2 = true;
        params.perPass[1].resolveIntColor    = true;
    }

    // Subpass 0 renders to color1 and depth/stencil only.  They are resolved at the end of the pass.
    params.perPass[0].resolveFloatColor2      = false;
    params.perPass[0].resolveIntColor         = false;
    params.perPass[0].depthStencilResolveMode = resolveMode;

    params.perPass[0].numSamples = sampleCount;

    params.perPass[0].floatColor1Location = renderToAttachment ? 0 : -1;
    params.perPass[0].floatColor2Location = -1;
    params.perPass[0].intColorLocation    = -1;
    params.perPass[0].hasDepthStencil     = true;

    // Subpass 1 uses color1 and depth/stencil as input attachments and outputs to color2 and color3.
    params.perPass[1].resolveFloatColor1  = false;
    params.perPass[1].resolveDepthStencil = false;

    params.perPass[1].numSamples = params.isMultisampledRenderToSingleSampled ? VK_SAMPLE_COUNT_1_BIT : sampleCount;

    params.perPass[1].floatColor1Location = -1;
    params.perPass[1].floatColor2Location = 3;
    params.perPass[1].intColorLocation    = 2;
    params.perPass[1].hasDepthStencil     = false;

    // Always clear before render pass so outside render area can be verified.
    params.clearBeforeRenderPass    = true;
    params.renderToWholeFramebuffer = renderToWholeFramebuffer;
    params.testBlendsColors         = false;

    // Set random clear values.
    generateRandomClearValues(rng, params, params.clearValues, true);

    // Decide DrawPushConstants
    for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
    {
        // Subpass 0 writes to color 1, depth and stencil.
        params.perPass[0].drawConstantsWithDepthWrite[regionNdx] = DrawPushConstants{
            {Vec4(rng.getFloat(0.2f, 0.4f), 0, rng.getFloat(0.2f, 0.4f), 0),
             Vec4(0, rng.getFloat(0.2f, 0.4f), 0, rng.getFloat(0.2f, 0.4f))},
            {Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 0)},
            {IVec4(0, 0, 0, 0), IVec4(0, 0, 0, 0)},
            // Use quantized values to avoid values that are too close and may cause precision issues
            Vec2(0.025f * static_cast<float>(rng.getInt(2, 38)), 0.025f * static_cast<float>(rng.getInt(2, 38))),
        };

        // Subpass 1 writes to color 2 and color 3.
        params.perPass[1].drawConstantsWithDepthWrite[regionNdx] = DrawPushConstants{
            {Vec4(0, 0, 0, 0), Vec4(0, 0, 0, 0)},
            {Vec4(rng.getFloat(0.2f, 0.4f), rng.getFloat(0.2f, 0.4f), 0, 0),
             Vec4(0, 0, rng.getFloat(0.2f, 0.4f), rng.getFloat(0.2f, 0.4f))},
            {IVec4(0, 0, 0, 0), IVec4(0, 0, 0, 0)},
            // Use quantized values to avoid values that are too close and may cause precision issues
            Vec2(0, 0),
        };

        // Integer resolve may choose any sample, so we modify only one channel.  This way, the verification
        // shader can accept two values per channel.
        params.perPass[0].drawConstantsWithDepthWrite[regionNdx].color3Data[0][0] = rng.getInt(1000, 5000);
        params.perPass[0].drawConstantsWithDepthWrite[regionNdx].color3Data[1][1] = rng.getInt(1000, 5000);
        params.perPass[1].drawConstantsWithDepthWrite[regionNdx].color3Data[0][2] = rng.getInt(1000, 5000);
        params.perPass[1].drawConstantsWithDepthWrite[regionNdx].color3Data[1][3] = rng.getInt(1000, 5000);
    }

    // Calculate VerifyPushConstants.  Walk through the passes and emulate what the draw calls would produce.
    for (uint32_t regionNdx = 0; regionNdx < RegionCount; ++regionNdx)
    {
        // First, subpass[0]'s data is written to every sample of color1 and depth/stencil.
        params.verifyConstants[regionNdx].color1Data[0] =
            params.perPass[0].drawConstantsWithDepthWrite[regionNdx].color1Data[0];
        params.verifyConstants[regionNdx].color1Data[1] =
            params.perPass[0].drawConstantsWithDepthWrite[regionNdx].color1Data[1];

        // Then depth/stencil is resolved
        DE_ASSERT(resolveMode == VK_RESOLVE_MODE_SAMPLE_ZERO_BIT || resolveMode == VK_RESOLVE_MODE_MAX_BIT);
        if (resolveMode == VK_RESOLVE_MODE_SAMPLE_ZERO_BIT)
        {
            params.verifyConstants[regionNdx].depthData =
                params.perPass[0].drawConstantsWithDepthWrite[regionNdx].depthData[0];
        }
        else
        {
            params.verifyConstants[regionNdx].depthData =
                std::max(params.perPass[0].drawConstantsWithDepthWrite[regionNdx].depthData[0],
                         params.perPass[0].drawConstantsWithDepthWrite[regionNdx].depthData[1]);
        }
        params.verifyConstants[regionNdx].stencilData = params.clearValues[3].depthStencil.stencil + 1;

        // Then subpass 1 initializes color2 and color3 based on the previous subpass' color1 and depth/stencil values.
        params.verifyConstants[regionNdx].color2Data[0] = params.verifyConstants[regionNdx].color1Data[0];
        params.verifyConstants[regionNdx].color2Data[1] = params.verifyConstants[regionNdx].color1Data[1];

        if (isDepthFormat(params.depthStencilFormat))
        {
            if (params.isMultisampledRenderToSingleSampled)
            {
                params.verifyConstants[regionNdx].color3Data[0][0] =
                    int32_t(10000 * params.verifyConstants[regionNdx].depthData);
                params.verifyConstants[regionNdx].color3Data[1][0] =
                    int32_t(10000 * params.verifyConstants[regionNdx].depthData);
            }
            else
            {
                params.verifyConstants[regionNdx].color3Data[0][0] =
                    int32_t(10000 * params.perPass[0].drawConstantsWithDepthWrite[regionNdx].depthData[0]);
                params.verifyConstants[regionNdx].color3Data[1][0] =
                    int32_t(10000 * params.perPass[0].drawConstantsWithDepthWrite[regionNdx].depthData[1]);
            }
        }

        if (isStencilFormat(params.depthStencilFormat))
        {
            params.verifyConstants[regionNdx].color3Data[0][1] = 100 * params.verifyConstants[regionNdx].stencilData;
            params.verifyConstants[regionNdx].color3Data[1][1] = 100 * params.verifyConstants[regionNdx].stencilData;
        }

        // Finally, a draw call in subpass 1 blends on top of those values.
        if (params.isMultisampledRenderToSingleSampled)
        {
            // If subpass 1 is single-sampled, there's only one sample to write to which is interpolated along X.  Additionally, there's no resolve.
            // The verification code expects the following:
            //
            //     color@uv = (color_even_samples*u + color_odd_samples*v) / 2
            //
            // In this case, we want color@uv to be color_even_samples*u.  We can have the verification shader arrive at this value
            // by providing color_even_samples twice what it should be and zero for color_odd_samples:
            //
            //     color@uv = (color_even_samples*2*u + 0*v) / 2 = color_even_samples*u
            params.verifyConstants[regionNdx].color2Data[0] +=
                params.perPass[1].drawConstantsWithDepthWrite[regionNdx].color2Data[0] * Vec4(2, 2, 2, 2);
        }
        else
        {
            params.verifyConstants[regionNdx].color2Data[0] +=
                params.perPass[1].drawConstantsWithDepthWrite[regionNdx].color2Data[0];
            params.verifyConstants[regionNdx].color2Data[1] +=
                params.perPass[1].drawConstantsWithDepthWrite[regionNdx].color2Data[1];
        }

        params.verifyConstants[regionNdx].color3Data[0] +=
            params.perPass[1].drawConstantsWithDepthWrite[regionNdx].color3Data[0];
        params.verifyConstants[regionNdx].color3Data[1] +=
            params.perPass[1].drawConstantsWithDepthWrite[regionNdx].color3Data[1];
    }

    params.rngSeed = rng.getUint32();
}

void initInputAttachmentsPrograms(SourceCollections &programCollection, const TestParams params)
{
    // This test reuses the same programs as the multipass tests for rendering and verification.
    initMultipassPrograms(programCollection, params);

    const bool usesSignedIntFormat = params.intColorFormat == VK_FORMAT_R16G16B16A16_SINT;
    const char *intTypePrefix      = usesSignedIntFormat ? "i" : "u";
    const char *subpassInputSuffix = params.perPass[1].numSamples == VK_SAMPLE_COUNT_1_BIT ? "" : "MS";
    const char *subpassLoadParam   = params.perPass[1].numSamples == VK_SAMPLE_COUNT_1_BIT ? "" : ", gl_SampleID";

    // Fragment shader - initialize color attachments 2 and 3 with data from color attachments 1 and depth/stencil
    {
        const TestParams::PerPass &perPass = params.perPass[1];

        // Data from color attachment 1 is replicated in color attachment 2.  Data from the depth/stencil attachment is replicated in the red and green
        // channels of color attachment 3.  Depth is multiplied by 10000 and interpolated along x and stencil by 100 and interpolated along y.  This makes
        // the result look like the other draw calls that produce a gradient and simplifies the verification code.
        std::ostringstream src;
        src << glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
            << "\n"
            << "layout(location = " << perPass.floatColor2Location << ") out vec4 o_color2;\n"
            << "layout(location = " << perPass.intColorLocation << ") out " << intTypePrefix << "vec4 o_color3;\n"
            << "layout(input_attachment_index = 0, set = 0, binding = 0) uniform subpassInput" << subpassInputSuffix
            << " i_color1;\n";
        if (isDepthFormat(params.depthStencilFormat))
            src << "layout(input_attachment_index = 1, set = 0, binding = 1) uniform subpassInput" << subpassInputSuffix
                << " i_depth;\n";
        if (isStencilFormat(params.depthStencilFormat))
            src << "layout(input_attachment_index = 1, set = 0, binding = 2) uniform usubpassInput"
                << subpassInputSuffix << " i_stencil;\n";
        src << "\n"
            << "layout(push_constant) uniform PushConstants {\n"
            << "    uvec4 area;\n"
            << "} params;\n"
            << "\n"
            << "void main(void)\n"
            << "{\n"
            << "    vec2 uv = (gl_FragCoord.xy - vec2(params.area.xy)) / vec2(params.area.zw);\n"
            << "    o_color2 = subpassLoad(i_color1" << subpassLoadParam << ");\n"
            << "    if (gl_SampleID % 2 != 0)\n"
            << "        uv.xy = uv.yx;\n"
            << "    uvec4 color3Value = uvec4(0);\n";
        if (isDepthFormat(params.depthStencilFormat))
            src << "    color3Value.x = uint(subpassLoad(i_depth" << subpassLoadParam << ").x * 10000 * uv.x);\n";
        if (isStencilFormat(params.depthStencilFormat))
            src << "    color3Value.y = uint(subpassLoad(i_stencil" << subpassLoadParam << ").x * 100 * uv.y);\n";
        src << "    o_color3 = " << intTypePrefix << "vec4(color3Value);\n"
            << "}\n";

        programCollection.glslSources.add("frag_in") << glu::FragmentSource(src.str());
    }
}

//! Verify that subpass resolve perf query works.
tcu::TestStatus testPerfQuery(Context &context, VkFormat format)
{
    const InstanceInterface &vki                  = context.getInstanceInterface();
    const VkPhysicalDevice physicalDevice         = context.getPhysicalDevice();
    VkFormatProperties2 formatProperties          = {};
    VkSubpassResolvePerformanceQueryEXT perfQuery = {};

    perfQuery.sType   = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT;
    perfQuery.optimal = 0xDEADBEEF;

    formatProperties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
    formatProperties.pNext = &perfQuery;

    vki.getPhysicalDeviceFormatProperties2(physicalDevice, format, &formatProperties);

    // There is actually nothing to verify other than that the above query was successful.
    // Regardless of optimal resolve or not, the operations must succeed.  We'll just make sure
    // the driver did produce a valid response.
    if (perfQuery.optimal != VK_FALSE && perfQuery.optimal != VK_TRUE)
    {
        std::string errorMsg = "VkSubpassResolvePerformanceQueryEXT::optimal is not populated after query";
        return tcu::TestStatus::fail(errorMsg);
    }

    return tcu::TestStatus::pass("Pass");
}

std::string getFormatShortString(const VkFormat format)
{
    std::string s(de::toLower(getFormatName(format)));
    return s.substr(10);
}

std::string getFormatCaseName(const VkFormat color1Format, const VkFormat color2Format, const VkFormat color3Format,
                              const VkFormat depthStencilFormat)
{
    std::ostringstream str;
    str << getFormatShortString(color1Format) << "_" << getFormatShortString(color2Format) << "_"
        << getFormatShortString(color3Format) << "_" << getFormatShortString(depthStencilFormat);
    return str.str();
}

std::string getSampleCountCaseName(const VkSampleCountFlagBits sampleCount)
{
    std::ostringstream str;
    str << sampleCount << "x";
    return str.str();
}

std::string getResolveModeCaseName(const VkResolveModeFlagBits resolveMode)
{
    std::ostringstream str;
    if (resolveMode == VK_RESOLVE_MODE_SAMPLE_ZERO_BIT)
        str << "ds_resolve_sample_zero";
    else if (resolveMode == VK_RESOLVE_MODE_MAX_BIT)
        str << "ds_resolve_max";
    else
        DE_ASSERT(false);
    return str.str();
}

void createMultisampledTestsInGroup(tcu::TestCaseGroup *rootGroup, const bool isMultisampledRenderToSingleSampled,
                                    PipelineConstructionType pipelineConstructionType, const bool dynamicRendering)
{
    // Color 1 is a float format
    const VkFormat color1FormatRange[] = {
        VK_FORMAT_R8G8B8A8_UNORM,
    };
    constexpr uint32_t color1FormatCount = DE_LENGTH_OF_ARRAY(color1FormatRange);

    // Color 2 is a float format
    const VkFormat color2FormatRange[] = {
        VK_FORMAT_R16G16B16A16_SFLOAT,
    };
    constexpr uint32_t color2FormatCount = DE_LENGTH_OF_ARRAY(color2FormatRange);

    // Color 3 is an integer format
    const VkFormat color3FormatRange[] = {
        VK_FORMAT_R32G32B32A32_UINT,
        VK_FORMAT_R16G16B16A16_SINT,
    };
    constexpr uint32_t color3FormatCount = DE_LENGTH_OF_ARRAY(color3FormatRange);

    // Test formats with only depth, only stencil or both
    const VkFormat depthStencilFormatRange[] = {
        VK_FORMAT_D16_UNORM,         //!< Must be supported
        VK_FORMAT_S8_UINT,           //!< May not be supported
        VK_FORMAT_D24_UNORM_S8_UINT, //!< Either this, or the next one must be supported
        VK_FORMAT_D32_SFLOAT_S8_UINT,
    };
    constexpr uint32_t depthStencilFormatCount = DE_LENGTH_OF_ARRAY(depthStencilFormatRange);

    const VkSampleCountFlagBits sampleRange[] = {
        VK_SAMPLE_COUNT_2_BIT,
        VK_SAMPLE_COUNT_4_BIT,
        VK_SAMPLE_COUNT_8_BIT,
        VK_SAMPLE_COUNT_16_BIT,
    };

    const VkResolveModeFlagBits depthStencilResolveModeRange[] = {
        VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
        VK_RESOLVE_MODE_MAX_BIT,
    };

    const bool boolRange[] = {false, true};

    // Test 1: Simple tests that verify Nx multisampling actually uses N samples.
    {
        MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(rootGroup->getTestContext(), "basic"));

        de::Random rng(0xDEADBEEF);

        for (const VkFormat color1Format : color1FormatRange)
            for (const VkFormat color2Format : color2FormatRange)
                for (const VkFormat color3Format : color3FormatRange)
                    for (const VkFormat depthStencilFormat : depthStencilFormatRange)
                    {
                        MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(
                            rootGroup->getTestContext(),
                            getFormatCaseName(color1Format, color2Format, color3Format, depthStencilFormat).c_str()));

                        for (const VkSampleCountFlagBits sampleCount : sampleRange)
                        {
                            MovePtr<tcu::TestCaseGroup> sampleGroup(new tcu::TestCaseGroup(
                                rootGroup->getTestContext(), getSampleCountCaseName(sampleCount).c_str()));

                            for (const VkResolveModeFlagBits resolveMode : depthStencilResolveModeRange)
                            {
                                MovePtr<tcu::TestCaseGroup> resolveGroup(new tcu::TestCaseGroup(
                                    rootGroup->getTestContext(), getResolveModeCaseName(resolveMode).c_str()));

                                for (const bool renderToWholeFramebuffer : boolRange)
                                {
                                    TestParams testParams;
                                    deMemset(&testParams, 0, sizeof(testParams));

                                    testParams.pipelineConstructionType = pipelineConstructionType;
                                    testParams.isMultisampledRenderToSingleSampled =
                                        isMultisampledRenderToSingleSampled;
                                    testParams.floatColor1Format    = color1Format;
                                    testParams.floatColor2Format    = color2Format;
                                    testParams.intColorFormat       = color3Format;
                                    testParams.depthStencilFormat   = depthStencilFormat;
                                    testParams.dynamicRendering     = dynamicRendering;
                                    testParams.useGarbageAttachment = false;
                                    testParams.renderToAttachment   = true;

                                    generateBasicTest(rng, testParams, sampleCount, resolveMode,
                                                      renderToWholeFramebuffer);

                                    addFunctionCaseWithPrograms(
                                        resolveGroup.get(),
                                        renderToWholeFramebuffer ? "whole_framebuffer" : "sub_framebuffer",
                                        checkRequirements, initBasicPrograms, testBasic, testParams);
                                }

                                sampleGroup->addChild(resolveGroup.release());
                            }
                            formatGroup->addChild(sampleGroup.release());
                        }
                        group->addChild(formatGroup.release());
                    }

        rootGroup->addChild(group.release());
    }

    // Test 2: Test that vkCmdClearAttachments works.
    {
        MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(rootGroup->getTestContext(), "clear_attachments"));

        de::Random rng(0x0FEDCBA9);

        for (const VkFormat color1Format : color1FormatRange)
            for (const VkFormat color2Format : color2FormatRange)
                for (const VkFormat color3Format : color3FormatRange)
                    for (const VkFormat depthStencilFormat : depthStencilFormatRange)
                    {
                        MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(
                            rootGroup->getTestContext(),
                            getFormatCaseName(color1Format, color2Format, color3Format, depthStencilFormat).c_str()));

                        for (const VkSampleCountFlagBits sampleCount : sampleRange)
                        {
                            MovePtr<tcu::TestCaseGroup> sampleGroup(new tcu::TestCaseGroup(
                                rootGroup->getTestContext(), getSampleCountCaseName(sampleCount).c_str()));

                            for (const VkResolveModeFlagBits resolveMode : depthStencilResolveModeRange)
                            {
                                MovePtr<tcu::TestCaseGroup> resolveGroup(new tcu::TestCaseGroup(
                                    rootGroup->getTestContext(), getResolveModeCaseName(resolveMode).c_str()));

                                for (const bool renderToWholeFramebuffer : boolRange)
                                {
                                    TestParams testParams;
                                    deMemset(&testParams, 0, sizeof(testParams));

                                    testParams.pipelineConstructionType = pipelineConstructionType;
                                    testParams.isMultisampledRenderToSingleSampled =
                                        isMultisampledRenderToSingleSampled;
                                    testParams.floatColor1Format    = color1Format;
                                    testParams.floatColor2Format    = color2Format;
                                    testParams.intColorFormat       = color3Format;
                                    testParams.depthStencilFormat   = depthStencilFormat;
                                    testParams.dynamicRendering     = dynamicRendering;
                                    testParams.useGarbageAttachment = false;
                                    testParams.renderToAttachment   = true;

                                    generateBasicTest(rng, testParams, sampleCount, resolveMode,
                                                      renderToWholeFramebuffer);

                                    addFunctionCaseWithPrograms(
                                        resolveGroup.get(),
                                        renderToWholeFramebuffer ? "whole_framebuffer" : "sub_framebuffer",
                                        checkRequirements, initBasicPrograms, testClearAttachments, testParams);
                                }
                                sampleGroup->addChild(resolveGroup.release());
                            }
                            formatGroup->addChild(sampleGroup.release());
                        }
                        group->addChild(formatGroup.release());
                    }

        rootGroup->addChild(group.release());
    }

    // Test 3: Tests with a single render pass, potentially with multiple subpasses.
    // Multiple subpasses can't be tested with dynamic rendering.
    if (!dynamicRendering)
    {
        // Single render pass with multiple subpasses
        MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(rootGroup->getTestContext(), "multi_subpass"));
        MovePtr<tcu::TestCaseGroup> formatGroup[color1FormatCount][color2FormatCount][color3FormatCount]
                                               [depthStencilFormatCount];

        for (uint32_t color1FormatNdx = 0; color1FormatNdx < color1FormatCount; ++color1FormatNdx)
            for (uint32_t color2FormatNdx = 0; color2FormatNdx < color2FormatCount; ++color2FormatNdx)
                for (uint32_t color3FormatNdx = 0; color3FormatNdx < color3FormatCount; ++color3FormatNdx)
                    for (uint32_t depthStencilFormatNdx = 0; depthStencilFormatNdx < depthStencilFormatCount;
                         ++depthStencilFormatNdx)
                    {
                        formatGroup[color1FormatNdx][color2FormatNdx][color3FormatNdx][depthStencilFormatNdx] =
                            MovePtr<tcu::TestCaseGroup>(new tcu::TestCaseGroup(
                                rootGroup->getTestContext(),
                                getFormatCaseName(
                                    color1FormatRange[color1FormatNdx], color2FormatRange[color2FormatNdx],
                                    color3FormatRange[color3FormatNdx], depthStencilFormatRange[depthStencilFormatNdx])
                                    .c_str()));
                    }

        de::Random rng(0x12345678);

        for (uint32_t iteration = 0; iteration < (isMultisampledRenderToSingleSampled ? 1000u : 250u); ++iteration)
        {
            TestParams testParams;
            deMemset(&testParams, 0, sizeof(testParams));

            const uint32_t color1FormatNdx       = iteration % color1FormatCount;
            const uint32_t color2FormatNdx       = iteration % color2FormatCount;
            const uint32_t color3FormatNdx       = iteration % color3FormatCount;
            const uint32_t depthStencilFormatNdx = iteration % depthStencilFormatCount;

            testParams.pipelineConstructionType            = pipelineConstructionType;
            testParams.isMultisampledRenderToSingleSampled = isMultisampledRenderToSingleSampled;
            testParams.floatColor1Format                   = color1FormatRange[color1FormatNdx];
            testParams.floatColor2Format                   = color2FormatRange[color2FormatNdx];
            testParams.intColorFormat                      = color3FormatRange[color3FormatNdx];
            testParams.depthStencilFormat                  = depthStencilFormatRange[depthStencilFormatNdx];
            testParams.dynamicRendering                    = false;
            testParams.useGarbageAttachment                = false;
            testParams.renderToAttachment                  = true;

            generateMultiPassTest(rng, testParams);

            std::ostringstream name;
            name << "random_" << iteration;

            addFunctionCaseWithPrograms(
                formatGroup[color1FormatNdx][color2FormatNdx][color3FormatNdx][depthStencilFormatNdx].get(),
                name.str().c_str(), checkRequirements, initMultipassPrograms, testSingleRenderPass, testParams);
        }

        for (uint32_t color1FormatNdx = 0; color1FormatNdx < color1FormatCount; ++color1FormatNdx)
            for (uint32_t color2FormatNdx = 0; color2FormatNdx < color2FormatCount; ++color2FormatNdx)
                for (uint32_t color3FormatNdx = 0; color3FormatNdx < color3FormatCount; ++color3FormatNdx)
                    for (uint32_t depthStencilFormatNdx = 0; depthStencilFormatNdx < depthStencilFormatCount;
                         ++depthStencilFormatNdx)
                    {
                        group->addChild(
                            formatGroup[color1FormatNdx][color2FormatNdx][color3FormatNdx][depthStencilFormatNdx]
                                .release());
                    }

        rootGroup->addChild(group.release());
    }

    // Test 4: Tests with a multiple render passes, a single subpass each.
    {
        MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(rootGroup->getTestContext(), "multi_renderpass"));
        MovePtr<tcu::TestCaseGroup> formatGroup[color1FormatCount][color2FormatCount][color3FormatCount]
                                               [depthStencilFormatCount];

        for (uint32_t color1FormatNdx = 0; color1FormatNdx < color1FormatCount; ++color1FormatNdx)
            for (uint32_t color2FormatNdx = 0; color2FormatNdx < color2FormatCount; ++color2FormatNdx)
                for (uint32_t color3FormatNdx = 0; color3FormatNdx < color3FormatCount; ++color3FormatNdx)
                    for (uint32_t depthStencilFormatNdx = 0; depthStencilFormatNdx < depthStencilFormatCount;
                         ++depthStencilFormatNdx)
                    {
                        formatGroup[color1FormatNdx][color2FormatNdx][color3FormatNdx][depthStencilFormatNdx] =
                            MovePtr<tcu::TestCaseGroup>(new tcu::TestCaseGroup(
                                rootGroup->getTestContext(),
                                getFormatCaseName(
                                    color1FormatRange[color1FormatNdx], color2FormatRange[color2FormatNdx],
                                    color3FormatRange[color3FormatNdx], depthStencilFormatRange[depthStencilFormatNdx])
                                    .c_str()));
                    }

        de::Random rng(0x87654321);

        for (uint32_t iteration = 0; iteration < (isMultisampledRenderToSingleSampled ? 1000u : 250u); ++iteration)
        {
            TestParams testParams;
            deMemset(&testParams, 0, sizeof(testParams));

            const uint32_t color1FormatNdx       = iteration % color1FormatCount;
            const uint32_t color2FormatNdx       = iteration % color2FormatCount;
            const uint32_t color3FormatNdx       = iteration % color3FormatCount;
            const uint32_t depthStencilFormatNdx = iteration % depthStencilFormatCount;

            testParams.pipelineConstructionType            = pipelineConstructionType;
            testParams.isMultisampledRenderToSingleSampled = isMultisampledRenderToSingleSampled;
            testParams.floatColor1Format                   = color1FormatRange[color1FormatNdx];
            testParams.floatColor2Format                   = color2FormatRange[color2FormatNdx];
            testParams.intColorFormat                      = color3FormatRange[color3FormatNdx];
            testParams.depthStencilFormat                  = depthStencilFormatRange[depthStencilFormatNdx];
            testParams.dynamicRendering                    = dynamicRendering;
            testParams.useGarbageAttachment                = false;
            testParams.renderToAttachment                  = true;

            generateMultiPassTest(rng, testParams);

            std::ostringstream name;
            name << "random_" << iteration;

            addFunctionCaseWithPrograms(
                formatGroup[color1FormatNdx][color2FormatNdx][color3FormatNdx][depthStencilFormatNdx].get(),
                name.str().c_str(), checkRequirements, initMultipassPrograms, testMultiRenderPass, testParams);
        }

        for (uint32_t color1FormatNdx = 0; color1FormatNdx < color1FormatCount; ++color1FormatNdx)
            for (uint32_t color2FormatNdx = 0; color2FormatNdx < color2FormatCount; ++color2FormatNdx)
                for (uint32_t color3FormatNdx = 0; color3FormatNdx < color3FormatCount; ++color3FormatNdx)
                    for (uint32_t depthStencilFormatNdx = 0; depthStencilFormatNdx < depthStencilFormatCount;
                         ++depthStencilFormatNdx)
                    {
                        group->addChild(
                            formatGroup[color1FormatNdx][color2FormatNdx][color3FormatNdx][depthStencilFormatNdx]
                                .release());
                    }

        rootGroup->addChild(group.release());
    }

    // Test 5: Tests multisampled rendering followed by use as input attachment.
    // These tests have two subpasses, so these can't be tested with dynamic rendering.
    if (!dynamicRendering && !vk::isConstructionTypeShaderObject(pipelineConstructionType))
    {
        // Tests that input attachment interaction with multisampled rendering works
        MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(rootGroup->getTestContext(), "input_attachments"));

        for (uint32_t i = 0; i < 2; ++i)
        {
            bool renderToAttachment = i == 0;
            if (!isMultisampledRenderToSingleSampled && !renderToAttachment)
                continue;
            std::string input_name = renderToAttachment ? "render_to" : "initialize";
            MovePtr<tcu::TestCaseGroup> inputGroup(
                new tcu::TestCaseGroup(rootGroup->getTestContext(), input_name.c_str()));

            de::Random rng(0x18273645);

            for (const VkFormat color1Format : color1FormatRange)
                for (const VkFormat color2Format : color2FormatRange)
                    for (const VkFormat color3Format : color3FormatRange)
                        for (const VkFormat depthStencilFormat : depthStencilFormatRange)
                        {
                            // Combination of framebuffer attachment formats
                            MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(
                                rootGroup->getTestContext(),
                                getFormatCaseName(color1Format, color2Format, color3Format, depthStencilFormat)
                                    .c_str()));

                            for (const VkSampleCountFlagBits sampleCount : sampleRange)
                            {
                                MovePtr<tcu::TestCaseGroup> sampleGroup(new tcu::TestCaseGroup(
                                    rootGroup->getTestContext(), getSampleCountCaseName(sampleCount).c_str()));

                                for (const VkResolveModeFlagBits resolveMode : depthStencilResolveModeRange)
                                {
                                    MovePtr<tcu::TestCaseGroup> resolveGroup(new tcu::TestCaseGroup(
                                        rootGroup->getTestContext(), getResolveModeCaseName(resolveMode).c_str()));

                                    for (const bool renderToWholeFramebuffer : boolRange)
                                    {
                                        TestParams testParams;
                                        deMemset(&testParams, 0, sizeof(testParams));

                                        testParams.pipelineConstructionType = pipelineConstructionType;
                                        testParams.isMultisampledRenderToSingleSampled =
                                            isMultisampledRenderToSingleSampled;
                                        testParams.floatColor1Format    = color1Format;
                                        testParams.floatColor2Format    = color2Format;
                                        testParams.intColorFormat       = color3Format;
                                        testParams.depthStencilFormat   = depthStencilFormat;
                                        testParams.dynamicRendering     = false;
                                        testParams.useGarbageAttachment = false;
                                        testParams.renderToAttachment   = renderToAttachment;

                                        generateInputAttachmentsTest(rng, testParams, sampleCount, resolveMode,
                                                                     renderToWholeFramebuffer, renderToAttachment);

                                        addFunctionCaseWithPrograms(resolveGroup.get(),
                                                                    renderToWholeFramebuffer ? "whole_framebuffer" :
                                                                                               "sub_framebuffer",
                                                                    checkRequirements, initInputAttachmentsPrograms,
                                                                    testInputAttachments, testParams);
                                    }
                                    sampleGroup->addChild(resolveGroup.release());
                                }
                                formatGroup->addChild(sampleGroup.release());
                            }
                            inputGroup->addChild(formatGroup.release());
                        }
            group->addChild(inputGroup.release());
        }

        rootGroup->addChild(group.release());
    }

    // Test 6: Tests subpass resolve efficiency query.
    // Efficiency query tests don't need to be tested with different pipeline construction types and with dynamic rendering.
    if (isMultisampledRenderToSingleSampled && pipelineConstructionType == PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC &&
        !dynamicRendering)
    {
        MovePtr<tcu::TestCaseGroup> group(
            new tcu::TestCaseGroup(rootGroup->getTestContext(), "subpass_resolve_efficiency_query"));

        for (const VkFormat format : color1FormatRange)
        {
            addFunctionCase(group.get(), getFormatShortString(format), checkHasMsrtss, testPerfQuery, format);
        }

        for (const VkFormat format : color2FormatRange)
        {
            addFunctionCase(group.get(), getFormatShortString(format), checkHasMsrtss, testPerfQuery, format);
        }

        for (const VkFormat format : color3FormatRange)
        {
            addFunctionCase(group.get(), getFormatShortString(format), checkHasMsrtss, testPerfQuery, format);
        }

        for (const VkFormat format : depthStencilFormatRange)
        {
            addFunctionCase(group.get(), getFormatShortString(format), checkHasMsrtss, testPerfQuery, format);
        }

        rootGroup->addChild(group.release());
    }

    // Test 7: Test that work with garbage color attachments
    if (dynamicRendering && pipelineConstructionType != vk::PIPELINE_CONSTRUCTION_TYPE_MONOLITHIC)
    {
        MovePtr<tcu::TestCaseGroup> group(
            new tcu::TestCaseGroup(rootGroup->getTestContext(), "garbage_color_attachment"));

        de::Random rng(0x12348765);

        for (const VkFormat color1Format : color1FormatRange)
            for (const VkFormat color2Format : color2FormatRange)
                for (const VkFormat color3Format : color3FormatRange)
                    for (const VkFormat depthStencilFormat : depthStencilFormatRange)
                    {
                        TestParams testParams;
                        deMemset(&testParams, 0, sizeof(testParams));

                        testParams.pipelineConstructionType            = pipelineConstructionType;
                        testParams.isMultisampledRenderToSingleSampled = isMultisampledRenderToSingleSampled;
                        testParams.floatColor1Format                   = color1Format;
                        testParams.floatColor2Format                   = color2Format;
                        testParams.intColorFormat                      = color3Format;
                        testParams.depthStencilFormat                  = depthStencilFormat;
                        testParams.dynamicRendering                    = dynamicRendering;
                        testParams.useGarbageAttachment                = true;
                        testParams.renderToAttachment                  = true;

                        generateBasicTest(rng, testParams, VK_SAMPLE_COUNT_2_BIT, VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,
                                          true);

                        // Combination of framebuffer attachment formats
                        addFunctionCaseWithPrograms(
                            group.get(),
                            getFormatCaseName(color1Format, color2Format, color3Format, depthStencilFormat).c_str(),
                            checkRequirements, initBasicPrograms, testBasic, testParams);
                    }

        rootGroup->addChild(group.release());
    }
}

void createMultisampledRenderToSingleSampledTestsInGroup(tcu::TestCaseGroup *rootGroup,
                                                         PipelineConstructionType pipelineConstructionType)
{
    createMultisampledTestsInGroup(rootGroup, true, pipelineConstructionType, false);

    MovePtr<tcu::TestCaseGroup> dynamicRenderingGroup(
        new tcu::TestCaseGroup(rootGroup->getTestContext(), "dynamic_rendering"));
    createMultisampledTestsInGroup(dynamicRenderingGroup.get(), true, pipelineConstructionType, true);
    rootGroup->addChild(dynamicRenderingGroup.release());
}

void createMultisampledMiscTestsInGroup(tcu::TestCaseGroup *rootGroup,
                                        PipelineConstructionType pipelineConstructionType)
{
    createMultisampledTestsInGroup(rootGroup, false, pipelineConstructionType, false);

    MovePtr<tcu::TestCaseGroup> dynamicRenderingGroup(
        new tcu::TestCaseGroup(rootGroup->getTestContext(), "dynamic_rendering"));
    createMultisampledTestsInGroup(dynamicRenderingGroup.get(), false, pipelineConstructionType, true);
    rootGroup->addChild(dynamicRenderingGroup.release());
}

} // namespace

tcu::TestCaseGroup *createMultisampledRenderToSingleSampledTests(tcu::TestContext &testCtx,
                                                                 vk::PipelineConstructionType pipelineConstructionType)
{
    // Test multisampled rendering to single-sampled framebuffer attachments
    return createTestGroup(testCtx, "multisampled_render_to_single_sampled",
                           createMultisampledRenderToSingleSampledTestsInGroup, pipelineConstructionType);
}

tcu::TestCaseGroup *createMultisampledMiscTests(tcu::TestContext &testCtx,
                                                vk::PipelineConstructionType pipelineConstructionType)
{
    return createTestGroup(testCtx, "misc", createMultisampledMiscTestsInGroup, pipelineConstructionType);
}

} // namespace pipeline
} // namespace vkt