/*-------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2021 The Khronos Group Inc.
 * Copyright (c) 2021 Valve Corporation.
 *
 * 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_VALVE_mutable_descriptor_type.
 *//*--------------------------------------------------------------------*/
#include "vktBindingValveMutableTests.hpp"
#include "vktTestCase.hpp"

#include "vkDefs.hpp"
#include "vkRefUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vkBufferWithMemory.hpp"
#include "vkTypeUtil.hpp"
#include "vkObjUtil.hpp"
#include "vkBarrierUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkRayTracingUtil.hpp"

#include "deUniquePtr.hpp"
#include "deSTLUtil.hpp"
#include "deStringUtil.hpp"

#include <vector>
#include <algorithm>
#include <iterator>
#include <set>
#include <sstream>
#include <limits>

namespace vkt
{
namespace BindingModel
{

namespace
{

using namespace vk;

deUint32 getDescriptorNumericValue (deUint32 iteration, deUint32 bindingIdx, deUint32 descriptorIdx = 0u)
{
	// When assigning numeric values for the descriptor contents, each descriptor will get 0x5aIIBBDD. II is an octed containing the
	// iteration index. BB is an octet containing the binding index and DD is the descriptor index inside that binding.
	constexpr deUint32 kNumericValueBase = 0x5a000000u;

	return (kNumericValueBase | ((iteration & 0xFFu) << 16) | ((bindingIdx & 0xFFu) << 8) | (descriptorIdx & 0xFFu));
}

deUint16 getAccelerationStructureOffsetX (deUint32 descriptorNumericValue)
{
	// Keep the lowest 16 bits (binding and descriptor idx) as the offset.
	return static_cast<deUint16>(descriptorNumericValue);
}

// Value that will be stored in the output buffer to signal success reading values.
deUint32 getExpectedOutputBufferValue ()
{
	return 2u;
}

// This value will be stored in an image to be sampled when checking descriptors containing samplers alone.
deUint32 getExternalSampledImageValue ()
{
	return 0x41322314u;
}

// Value that will be ORed with the descriptor value before writing.
deUint32 getStoredValueMask ()
{
	return 0xFF000000u;
}

VkFormat getDescriptorImageFormat ()
{
	return VK_FORMAT_R32_UINT;
}

VkExtent3D getDefaultExtent ()
{
	return makeExtent3D(1u, 1u, 1u);
}

// Convert value to hexadecimal.
std::string toHex (deUint32 val)
{
	std::ostringstream s;
	s << "0x" << std::hex << val << "u";
	return s.str();
}

// Returns the list of descriptor types that cannot be part of a mutable descriptor.
std::vector<VkDescriptorType> getForbiddenMutableTypes ()
{
	return std::vector<VkDescriptorType>
		{
			VK_DESCRIPTOR_TYPE_MUTABLE_VALVE,
			VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC,
			VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC,
			VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT,
		};
}

// Returns the list of descriptor types that are mandatory for the extension.
std::vector<VkDescriptorType> getMandatoryMutableTypes ()
{
	return std::vector<VkDescriptorType>
		{
			VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
			VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
			VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
			VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
			VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
			VK_DESCRIPTOR_TYPE_STORAGE_BUFFER
		};
}

// This helps quickly transform a vector of descriptor types into a bitmask, which makes it easier to check some conditions.
enum DescriptorTypeFlagBits
{
	DTFB_SAMPLER                    = (1 << 0),
	DTFB_COMBINED_IMAGE_SAMPLER     = (1 << 1),
	DTFB_SAMPLED_IMAGE              = (1 << 2),
	DTFB_STORAGE_IMAGE              = (1 << 3),
	DTFB_UNIFORM_TEXEL_BUFFER       = (1 << 4),
	DTFB_STORAGE_TEXEL_BUFFER       = (1 << 5),
	DTFB_UNIFORM_BUFFER             = (1 << 6),
	DTFB_STORAGE_BUFFER             = (1 << 7),
	DTFB_UNIFORM_BUFFER_DYNAMIC     = (1 << 8),
	DTFB_STORAGE_BUFFER_DYNAMIC     = (1 << 9),
	DTFB_INPUT_ATTACHMENT           = (1 << 10),
	DTFB_INLINE_UNIFORM_BLOCK_EXT   = (1 << 11),
	DTFB_ACCELERATION_STRUCTURE_KHR = (1 << 12),
	DTFB_ACCELERATION_STRUCTURE_NV  = (1 << 13),
	DTFB_MUTABLE_VALVE              = (1 << 14),
};

using DescriptorTypeFlags = deUint32;

// Convert type to its corresponding flag bit.
DescriptorTypeFlagBits toDescriptorTypeFlagBit (VkDescriptorType descriptorType)
{
	switch (descriptorType)
	{
	case VK_DESCRIPTOR_TYPE_SAMPLER:                        return DTFB_SAMPLER;
	case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:         return DTFB_COMBINED_IMAGE_SAMPLER;
	case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:                  return DTFB_SAMPLED_IMAGE;
	case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:                  return DTFB_STORAGE_IMAGE;
	case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:           return DTFB_UNIFORM_TEXEL_BUFFER;
	case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:           return DTFB_STORAGE_TEXEL_BUFFER;
	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:                 return DTFB_UNIFORM_BUFFER;
	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:                 return DTFB_STORAGE_BUFFER;
	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:         return DTFB_UNIFORM_BUFFER_DYNAMIC;
	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:         return DTFB_STORAGE_BUFFER_DYNAMIC;
	case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:               return DTFB_INPUT_ATTACHMENT;
	case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:       return DTFB_INLINE_UNIFORM_BLOCK_EXT;
	case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:     return DTFB_ACCELERATION_STRUCTURE_KHR;
	case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV:      return DTFB_ACCELERATION_STRUCTURE_NV;
	case VK_DESCRIPTOR_TYPE_MUTABLE_VALVE:                  return DTFB_MUTABLE_VALVE;
	default: break;
	}

	// Unreachable.
	DE_ASSERT(false);
	return DTFB_SAMPLER;
}

// Convert vector of descriptor types to a bitfield.
DescriptorTypeFlags toDescriptorTypeFlags (const std::vector<VkDescriptorType>& types)
{
	DescriptorTypeFlags result = 0u;
	for (const auto& t : types)
		result |= toDescriptorTypeFlagBit(t);
	return result;
}

// Convert bitfield to vector of descriptor types.
std::vector<VkDescriptorType> toDescriptorTypeVector (DescriptorTypeFlags bitfield)
{
	std::vector<VkDescriptorType> result;

	if (bitfield & DTFB_SAMPLER)                     result.push_back(VK_DESCRIPTOR_TYPE_SAMPLER);
	if (bitfield & DTFB_COMBINED_IMAGE_SAMPLER)      result.push_back(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
	if (bitfield & DTFB_SAMPLED_IMAGE)               result.push_back(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
	if (bitfield & DTFB_STORAGE_IMAGE)               result.push_back(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
	if (bitfield & DTFB_UNIFORM_TEXEL_BUFFER)        result.push_back(VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER);
	if (bitfield & DTFB_STORAGE_TEXEL_BUFFER)        result.push_back(VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER);
	if (bitfield & DTFB_UNIFORM_BUFFER)              result.push_back(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
	if (bitfield & DTFB_STORAGE_BUFFER)              result.push_back(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
	if (bitfield & DTFB_UNIFORM_BUFFER_DYNAMIC)      result.push_back(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC);
	if (bitfield & DTFB_STORAGE_BUFFER_DYNAMIC)      result.push_back(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC);
	if (bitfield & DTFB_INPUT_ATTACHMENT)            result.push_back(VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
	if (bitfield & DTFB_INLINE_UNIFORM_BLOCK_EXT)    result.push_back(VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT);
	if (bitfield & DTFB_ACCELERATION_STRUCTURE_KHR)  result.push_back(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR);
	if (bitfield & DTFB_ACCELERATION_STRUCTURE_NV)   result.push_back(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV);
	if (bitfield & DTFB_MUTABLE_VALVE)               result.push_back(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE);

	return result;
}

// How to create the source set when copying descriptors from another set.
// * MUTABLE means to transform bindings into mutable bindings.
// * NONMUTABLE means to transform bindings into non-mutable bindings.
enum class SourceSetStrategy
{
	MUTABLE = 0,
	NONMUTABLE,
	NO_SOURCE,
};

enum class PoolMutableStrategy
{
	KEEP_TYPES = 0,
	EXPAND_TYPES,
	NO_TYPES,
};

// Type of information that's present in VkWriteDescriptorSet.
enum class WriteType
{
	IMAGE_INFO = 0,
	BUFFER_INFO,
	BUFFER_VIEW,
	ACCELERATION_STRUCTURE_INFO,
};

struct WriteInfo
{
	WriteType writeType;
	union
	{
		VkDescriptorImageInfo                           imageInfo;
		VkDescriptorBufferInfo                          bufferInfo;
		VkBufferView                                    bufferView;
		VkWriteDescriptorSetAccelerationStructureKHR    asInfo;
	};

	explicit WriteInfo (const VkDescriptorImageInfo& info_)
		: writeType(WriteType::IMAGE_INFO)
		, imageInfo(info_)
	{}

	explicit WriteInfo (const VkDescriptorBufferInfo& info_)
		: writeType(WriteType::BUFFER_INFO)
		, bufferInfo(info_)
	{}

	explicit WriteInfo (VkBufferView view_)
		: writeType(WriteType::BUFFER_VIEW)
		, bufferView(view_)
	{}

	explicit WriteInfo (const VkWriteDescriptorSetAccelerationStructureKHR& asInfo_)
		: writeType(WriteType::ACCELERATION_STRUCTURE_INFO)
		, asInfo(asInfo_)
	{}
};

// Resource backing up a single binding.
enum class ResourceType
{
	SAMPLER = 0,
	IMAGE,
	COMBINED_IMAGE_SAMPLER,
	BUFFER,
	BUFFER_VIEW,
	ACCELERATION_STRUCTURE,
};

// Type of resource backing up a particular descriptor type.
ResourceType toResourceType (VkDescriptorType descriptorType)
{
	ResourceType resourceType = ResourceType::SAMPLER;
	switch (descriptorType)
	{
	case VK_DESCRIPTOR_TYPE_SAMPLER:
		resourceType = ResourceType::SAMPLER;
		break;

	case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
		resourceType = ResourceType::COMBINED_IMAGE_SAMPLER;
		break;

	case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
	case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
	case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
		resourceType = ResourceType::IMAGE;
		break;

	case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
	case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
		resourceType = ResourceType::BUFFER_VIEW;
		break;

	case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
	case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
		resourceType = ResourceType::BUFFER;
		break;

	case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
		resourceType = ResourceType::ACCELERATION_STRUCTURE;
		break;

	default:
		DE_ASSERT(false);
		break;
	}

	return resourceType;
}

bool isShaderWritable (VkDescriptorType descriptorType)
{
	return (descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER || descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ||
	        descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER);
}

Move<VkSampler> makeDefaultSampler (const DeviceInterface& vkd, VkDevice device)
{
	const VkSamplerCreateInfo samplerCreateInfo = {
		VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,  //  VkStructureType			sType;
		nullptr,                                //  const void*				pNext;
		0u,                                     //  VkSamplerCreateFlags	flags;
		VK_FILTER_NEAREST,                      //  VkFilter				magFilter;
		VK_FILTER_NEAREST,                      //  VkFilter				minFilter;
		VK_SAMPLER_MIPMAP_MODE_NEAREST,         //  VkSamplerMipmapMode		mipmapMode;
		VK_SAMPLER_ADDRESS_MODE_REPEAT,         //  VkSamplerAddressMode	addressModeU;
		VK_SAMPLER_ADDRESS_MODE_REPEAT,         //  VkSamplerAddressMode	addressModeV;
		VK_SAMPLER_ADDRESS_MODE_REPEAT,         //  VkSamplerAddressMode	addressModeW;
		0.f,                                    //  float					mipLodBias;
		VK_FALSE,                               //  VkBool32				anisotropyEnable;
		1.f,                                    //  float					maxAnisotropy;
		VK_FALSE,                               //  VkBool32				compareEnable;
		VK_COMPARE_OP_ALWAYS,                   //  VkCompareOp				compareOp;
		0.f,                                    //  float					minLod;
		0.f,                                    //  float					maxLod;
		VK_BORDER_COLOR_INT_TRANSPARENT_BLACK,  //  VkBorderColor			borderColor;
		VK_FALSE,                               //  VkBool32				unnormalizedCoordinates;
	};

	return createSampler(vkd, device, &samplerCreateInfo);
}

de::MovePtr<ImageWithMemory> makeDefaultImage (const DeviceInterface& vkd, VkDevice device, Allocator& alloc)
{
	const auto              extent     = makeExtent3D(1u, 1u, 1u);
	const VkImageUsageFlags usageFlags = (
		VK_IMAGE_USAGE_SAMPLED_BIT
		| VK_IMAGE_USAGE_STORAGE_BIT
		| VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
		| VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
		| VK_IMAGE_USAGE_TRANSFER_SRC_BIT
		| VK_IMAGE_USAGE_TRANSFER_DST_BIT);

	const VkImageCreateInfo imageCreateInfo = {
		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,    //  VkStructureType			sType;
		nullptr,                                //  const void*				pNext;
		0u,                                     //  VkImageCreateFlags		flags;
		VK_IMAGE_TYPE_2D,                       //  VkImageType				imageType;
		getDescriptorImageFormat(),             //  VkFormat				format;
		extent,                                 //  VkExtent3D				extent;
		1u,                                     //  deUint32				mipLevels;
		1u,                                     //  deUint32				arrayLayers;
		VK_SAMPLE_COUNT_1_BIT,                  //  VkSampleCountFlagBits	samples;
		VK_IMAGE_TILING_OPTIMAL,                //  VkImageTiling			tiling;
		usageFlags,                             //  VkImageUsageFlags		usage;
		VK_SHARING_MODE_EXCLUSIVE,              //  VkSharingMode			sharingMode;
		0u,                                     //  deUint32				queueFamilyIndexCount;
		nullptr,                                //  const deUint32*			pQueueFamilyIndices;
		VK_IMAGE_LAYOUT_UNDEFINED,              //  VkImageLayout			initialLayout;
	};
	return de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, alloc, imageCreateInfo, MemoryRequirement::Any));
}

Move<VkImageView> makeDefaultImageView (const DeviceInterface& vkd, VkDevice device, VkImage image)
{
	const auto subresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
	return makeImageView(vkd, device, image, VK_IMAGE_VIEW_TYPE_2D, getDescriptorImageFormat(), subresourceRange);
}

de::MovePtr<BufferWithMemory> makeDefaultBuffer (const DeviceInterface& vkd, VkDevice device, Allocator& alloc, deUint32 numElements = 1u)
{
	const VkBufferUsageFlags bufferUsage = (
		VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
		| VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
		| VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT
		| VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
		| VK_BUFFER_USAGE_TRANSFER_SRC_BIT
		| VK_BUFFER_USAGE_TRANSFER_DST_BIT);

	const auto bufferSize = static_cast<VkDeviceSize>(sizeof(deUint32) * static_cast<size_t>(numElements));

	const auto bufferCreateInfo = makeBufferCreateInfo(bufferSize, bufferUsage);

	return de::MovePtr<BufferWithMemory>(new BufferWithMemory(vkd, device, alloc, bufferCreateInfo, MemoryRequirement::HostVisible));
}

Move<VkBufferView> makeDefaultBufferView (const DeviceInterface& vkd, VkDevice device, VkBuffer buffer)
{
	const auto bufferOffset = static_cast<VkDeviceSize>(0);
	const auto bufferSize   = static_cast<VkDeviceSize>(sizeof(deUint32));

	return makeBufferView(vkd, device, buffer, getDescriptorImageFormat(), bufferOffset, bufferSize);
}

struct AccelerationStructureData
{
	using TLASPtr = de::MovePtr<TopLevelAccelerationStructure>;
	using BLASPtr = de::MovePtr<BottomLevelAccelerationStructure>;

	TLASPtr tlas;
	BLASPtr blas;

	void swap (AccelerationStructureData& other)
	{
		auto myTlasPtr = tlas.release();
		auto myBlasPtr = blas.release();

		auto otherTlasPtr = other.tlas.release();
		auto otherBlasPtr = other.blas.release();

		tlas = TLASPtr(otherTlasPtr);
		blas = BLASPtr(otherBlasPtr);

		other.tlas = TLASPtr(myTlasPtr);
		other.blas = BLASPtr(myBlasPtr);
	}

	AccelerationStructureData () : tlas() , blas() {}

	AccelerationStructureData (AccelerationStructureData&& other)
		: AccelerationStructureData()
	{
		swap(other);
	}

	AccelerationStructureData& operator= (AccelerationStructureData&& other)
	{
		swap(other);
		return *this;
	}
};

AccelerationStructureData makeDefaultAccelerationStructure (const DeviceInterface& vkd, VkDevice device, VkCommandBuffer cmdBuffer, Allocator& alloc, bool triangles, deUint16 offsetX)
{
	AccelerationStructureData data;

	// Triangle around (offsetX, 0) with depth 5.0.
	const float middleX = static_cast<float>(offsetX);
	const float leftX   = middleX - 0.5f;
	const float rightX  = middleX + 0.5f;
	const float topY    = 0.5f;
	const float bottomY = -0.5f;
	const float depth   = 5.0f;

	std::vector<tcu::Vec3> vertices;

	if (triangles)
	{
		vertices.reserve(3u);
		vertices.emplace_back(middleX, topY, depth);
		vertices.emplace_back(rightX, bottomY, depth);
		vertices.emplace_back(leftX, bottomY, depth);
	}
	else
	{
		vertices.reserve(2u);
		vertices.emplace_back(leftX, bottomY, depth);
		vertices.emplace_back(rightX, topY, depth);
	}

	data.tlas = makeTopLevelAccelerationStructure();
	data.blas = makeBottomLevelAccelerationStructure();

	VkGeometryInstanceFlagsKHR instanceFlags = 0u;
	if (triangles)
		instanceFlags |= VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR;

	data.blas->addGeometry(vertices, triangles, VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR);
	data.blas->createAndBuild(vkd, device, cmdBuffer, alloc);

	de::SharedPtr<BottomLevelAccelerationStructure> blasSharedPtr (data.blas.release());
	data.tlas->setInstanceCount(1u);
	data.tlas->addInstance(blasSharedPtr, identityMatrix3x4, 0u, 0xFFu, 0u, instanceFlags);
	data.tlas->createAndBuild(vkd, device, cmdBuffer, alloc);

	return data;
}

const auto kShaderAccess = (VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);

struct Resource
{
	VkDescriptorType              descriptorType;
	ResourceType                  resourceType;
	Move<VkSampler>               sampler;
	de::MovePtr<ImageWithMemory>  imageWithMemory;
	Move<VkImageView>             imageView;
	de::MovePtr<BufferWithMemory> bufferWithMemory;
	Move<VkBufferView>            bufferView;
	AccelerationStructureData     asData;
	deUint32                      initialValue;

	Resource (VkDescriptorType descriptorType_, const DeviceInterface& vkd, VkDevice device, Allocator& alloc, deUint32 qIndex, VkQueue queue, bool useAABBs, deUint32 initialValue_, deUint32 numElements = 1u)
		: descriptorType	(descriptorType_)
		, resourceType      (toResourceType(descriptorType))
		, sampler           ()
		, imageWithMemory   ()
		, imageView         ()
		, bufferWithMemory  ()
		, bufferView        ()
		, asData            ()
		, initialValue      (initialValue_)
	{
		if (numElements != 1u)
			DE_ASSERT(resourceType == ResourceType::BUFFER);

		switch (resourceType)
		{
		case ResourceType::SAMPLER:
			sampler = makeDefaultSampler(vkd, device);
			break;

		case ResourceType::IMAGE:
			imageWithMemory = makeDefaultImage(vkd, device, alloc);
			imageView       = makeDefaultImageView(vkd, device, imageWithMemory->get());
			break;

		case ResourceType::COMBINED_IMAGE_SAMPLER:
			sampler         = makeDefaultSampler(vkd, device);
			imageWithMemory = makeDefaultImage(vkd, device, alloc);
			imageView       = makeDefaultImageView(vkd, device, imageWithMemory->get());
			break;

		case ResourceType::BUFFER:
			bufferWithMemory = makeDefaultBuffer(vkd, device, alloc, numElements);
			break;

		case ResourceType::BUFFER_VIEW:
			bufferWithMemory = makeDefaultBuffer(vkd, device, alloc);
			bufferView       = makeDefaultBufferView(vkd, device, bufferWithMemory->get());
			break;

		case ResourceType::ACCELERATION_STRUCTURE:
			{
				const auto cmdPool      = makeCommandPool(vkd, device, qIndex);
				const auto cmdBufferPtr = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
				const auto cmdBuffer    = cmdBufferPtr.get();
				const bool triangles    = !useAABBs;

				beginCommandBuffer(vkd, cmdBuffer);
				asData = makeDefaultAccelerationStructure(vkd, device, cmdBuffer, alloc, triangles, getAccelerationStructureOffsetX(initialValue));
				endCommandBuffer(vkd, cmdBuffer);
				submitCommandsAndWait(vkd, device, queue, cmdBuffer);
			}
			break;

		default:
			DE_ASSERT(false);
			break;
		}

		if (imageWithMemory || bufferWithMemory)
		{
			const auto cmdPool      = makeCommandPool(vkd, device, qIndex);
			const auto cmdBufferPtr = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
			const auto cmdBuffer    = cmdBufferPtr.get();

			if (imageWithMemory)
			{
				// Prepare staging buffer.
				const auto               bufferSize        = static_cast<VkDeviceSize>(sizeof(initialValue));
				const VkBufferUsageFlags bufferUsage       = (VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
				const auto               stagingBufferInfo = makeBufferCreateInfo(bufferSize, bufferUsage);

				BufferWithMemory stagingBuffer(vkd, device, alloc, stagingBufferInfo, MemoryRequirement::HostVisible);
				auto& bufferAlloc = stagingBuffer.getAllocation();
				void* bufferData  = bufferAlloc.getHostPtr();

				deMemcpy(bufferData, &initialValue, sizeof(initialValue));
				flushAlloc(vkd, device, bufferAlloc);

				beginCommandBuffer(vkd, cmdBuffer);

				// Transition and copy image.
				const auto copyRegion         = makeBufferImageCopy(makeExtent3D(1u, 1u, 1u),
																	makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u));

				// Switch image to TRANSFER_DST_OPTIMAL before copying data to it.
				const auto subresourceRange   = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);

				const auto preTransferBarrier = makeImageMemoryBarrier(
					0u, VK_ACCESS_TRANSFER_WRITE_BIT,
					VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
					imageWithMemory->get(), subresourceRange);

				vkd.cmdPipelineBarrier(
					cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
					0u, nullptr, 0u, nullptr, 1u, &preTransferBarrier);

				// Copy data to image.
				vkd.cmdCopyBufferToImage(cmdBuffer, stagingBuffer.get(), imageWithMemory->get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1u, &copyRegion);

				// Switch image to the GENERAL layout before reading or writing to it from shaders.
				const auto postTransferBarrier = makeImageMemoryBarrier(
					VK_ACCESS_TRANSFER_WRITE_BIT, kShaderAccess,
					VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_GENERAL,
					imageWithMemory->get(), subresourceRange);

				vkd.cmdPipelineBarrier(
					cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u,
					0u, nullptr, 0u, nullptr, 1u, &postTransferBarrier);

				endCommandBuffer(vkd, cmdBuffer);
				submitCommandsAndWait(vkd, device, queue, cmdBuffer);
			}

			if (bufferWithMemory)
			{
				auto& bufferAlloc = bufferWithMemory->getAllocation();
				void* bufferData  = bufferAlloc.getHostPtr();

				const std::vector<deUint32> bufferValues(numElements, initialValue);
				deMemcpy(bufferData, bufferValues.data(), de::dataSize(bufferValues));
				flushAlloc(vkd, device, bufferAlloc);

				beginCommandBuffer(vkd, cmdBuffer);

				// Make sure host writes happen before shader reads/writes. Note: this barrier is not needed in theory.
				const auto hostToShaderBarrier = makeMemoryBarrier(VK_ACCESS_HOST_WRITE_BIT, kShaderAccess);

				vkd.cmdPipelineBarrier(
					cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u,
					1u, &hostToShaderBarrier, 0u, nullptr, 0u, nullptr);

				endCommandBuffer(vkd, cmdBuffer);
				submitCommandsAndWait(vkd, device, queue, cmdBuffer);
			}
		}
	}

	// Remove problematic copy constructor.
	Resource (const Resource&) = delete;

	// Make it movable.
	Resource (Resource&& other) noexcept
		: descriptorType	(other.descriptorType)
		, resourceType      (other.resourceType)
		, sampler           (other.sampler)
		, imageWithMemory   (other.imageWithMemory.release())
		, imageView         (other.imageView)
		, bufferWithMemory  (other.bufferWithMemory.release())
		, bufferView        (other.bufferView)
		, asData			(std::move(other.asData))
		, initialValue      (other.initialValue)
	{}

	~Resource ()
	{}

	WriteInfo makeWriteInfo () const
	{
		using WriteInfoPtr = de::MovePtr<WriteInfo>;

		WriteInfoPtr writeInfo;

		switch (resourceType)
		{
		case ResourceType::SAMPLER:
			{
				const VkDescriptorImageInfo imageInfo = { sampler.get(), DE_NULL, VK_IMAGE_LAYOUT_UNDEFINED };
				writeInfo = WriteInfoPtr (new WriteInfo(imageInfo));
			}
			break;

		case ResourceType::IMAGE:
			{
				const VkDescriptorImageInfo imageInfo = { DE_NULL, imageView.get(), VK_IMAGE_LAYOUT_GENERAL };
				writeInfo = WriteInfoPtr (new WriteInfo(imageInfo));
			}
			break;

		case ResourceType::COMBINED_IMAGE_SAMPLER:
			{
				const VkDescriptorImageInfo imageInfo = { sampler.get(), imageView.get(), VK_IMAGE_LAYOUT_GENERAL };
				writeInfo = WriteInfoPtr (new WriteInfo(imageInfo));
			}
			break;

		case ResourceType::BUFFER:
			{
				const VkDescriptorBufferInfo bufferInfo = { bufferWithMemory->get(), 0ull, static_cast<VkDeviceSize>(sizeof(deUint32)) };
				writeInfo = WriteInfoPtr (new WriteInfo(bufferInfo));
			}
			break;

		case ResourceType::BUFFER_VIEW:
			writeInfo = WriteInfoPtr (new WriteInfo(bufferView.get()));
			break;

		case ResourceType::ACCELERATION_STRUCTURE:
			{
				VkWriteDescriptorSetAccelerationStructureKHR asWrite = initVulkanStructure();
				asWrite.accelerationStructureCount = 1u;
				asWrite.pAccelerationStructures    = asData.tlas.get()->getPtr();
				writeInfo = WriteInfoPtr (new WriteInfo(asWrite));
			}
			break;

		default:
			DE_ASSERT(false);
			break;
		}

		return *writeInfo;
	}

	tcu::Maybe<deUint32> getStoredValue (const DeviceInterface& vkd, VkDevice device, Allocator& alloc, deUint32 qIndex, VkQueue queue, deUint32 position = 0u) const
	{
		if (position != 0u)
			DE_ASSERT(static_cast<bool>(bufferWithMemory));

		if (imageWithMemory || bufferWithMemory)
		{
			// Command pool and buffer.
			const auto cmdPool      = makeCommandPool(vkd, device, qIndex);
			const auto cmdBufferPtr = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
			const auto cmdBuffer    = cmdBufferPtr.get();

			if (imageWithMemory)
			{
				// Prepare staging buffer.
				deUint32                 result;
				const auto               bufferSize        = static_cast<VkDeviceSize>(sizeof(result));
				const VkBufferUsageFlags bufferUsage       = (VK_BUFFER_USAGE_TRANSFER_DST_BIT);
				const auto               stagingBufferInfo = makeBufferCreateInfo(bufferSize, bufferUsage);

				BufferWithMemory stagingBuffer(vkd, device, alloc, stagingBufferInfo, MemoryRequirement::HostVisible);
				auto& bufferAlloc = stagingBuffer.getAllocation();
				void* bufferData  = bufferAlloc.getHostPtr();

				// Copy image value to staging buffer.
				beginCommandBuffer(vkd, cmdBuffer);

				// Make sure shader accesses happen before transfers and prepare image for transfer.
				const auto colorResourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);

				const auto preTransferBarrier = makeImageMemoryBarrier(
					kShaderAccess, VK_ACCESS_TRANSFER_READ_BIT,
					VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
					imageWithMemory->get(), colorResourceRange);

				vkd.cmdPipelineBarrier(
					cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u,
					0u, nullptr, 0u, nullptr, 1u, &preTransferBarrier);

				// Copy image contents to staging buffer.
				const auto copyRegion = makeBufferImageCopy(makeExtent3D(1u, 1u, 1u),
															makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u));
				vkd.cmdCopyImageToBuffer(cmdBuffer, imageWithMemory->get(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, stagingBuffer.get(), 1u, &copyRegion);

				// Make sure writes are visible from the host.
				const auto postTransferBarrier = makeMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_HOST_READ_BIT);
				vkd.cmdPipelineBarrier(cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u, 1u, &postTransferBarrier, 0u, nullptr, 0u, nullptr);

				endCommandBuffer(vkd, cmdBuffer);
				submitCommandsAndWait(vkd, device, queue, cmdBuffer);

				// Get value from staging buffer.
				invalidateAlloc(vkd, device, bufferAlloc);
				deMemcpy(&result, bufferData, sizeof(result));
				return tcu::just(result);
			}

			if (bufferWithMemory)
			{
				auto&       bufferAlloc = bufferWithMemory->getAllocation();
				auto        bufferData  = reinterpret_cast<const char*>(bufferAlloc.getHostPtr());
				deUint32    result;

				// Make sure shader writes are visible from the host.
				beginCommandBuffer(vkd, cmdBuffer);

				const auto shaderToHostBarrier = makeMemoryBarrier(kShaderAccess, VK_ACCESS_HOST_READ_BIT);
				vkd.cmdPipelineBarrier(
					cmdBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0u,
					1u, &shaderToHostBarrier, 0u, nullptr, 0u, nullptr);

				endCommandBuffer(vkd, cmdBuffer);
				submitCommandsAndWait(vkd, device, queue, cmdBuffer);

				invalidateAlloc(vkd, device, bufferAlloc);
				deMemcpy(&result, bufferData + sizeof(deUint32) * static_cast<size_t>(position), sizeof(result));
				return tcu::just(result);
			}
		}

		return tcu::Nothing;
	}
};

struct BindingInterface
{
	virtual ~BindingInterface () {}

	// Minimum number of iterations to test all mutable types.
	virtual deUint32 maxTypes () const = 0;

	// Types that will be used by the binding at a given iteration.
	virtual std::vector<VkDescriptorType> typesAtIteration (deUint32 iteration) const = 0;

	// Binding's main type.
	virtual VkDescriptorType mainType () const = 0;

	// Binding's list of mutable types, if present.
	virtual std::vector<VkDescriptorType> mutableTypes () const = 0;

	// Descriptor count in the binding.
	virtual size_t size () const = 0;

	// Is the binding an array binding?
	virtual bool isArray () const = 0;

	// Is the binding an unbounded array?
	virtual bool isUnbounded () const = 0;

	// Will the binding use different descriptor types in a given iteration?
	virtual bool needsAliasing (deUint32 iteration) const
	{
		const auto                 typesVec = typesAtIteration(iteration);
		std::set<VkDescriptorType> descTypes(begin(typesVec), end(typesVec));
		return (descTypes.size() > 1u);
	}

	// Will the binding need aliasing on any iteration up to a given number?
	virtual bool needsAliasingUpTo (deUint32 numIterations) const
	{
		std::vector<bool> needsAliasingFlags;
		needsAliasingFlags.reserve(numIterations);

		for (deUint32 iter = 0u; iter < numIterations; ++iter)
			needsAliasingFlags.push_back(needsAliasing(iter));

		return std::any_of(begin(needsAliasingFlags), end(needsAliasingFlags), [] (bool f) { return f; });
	}

private:
	virtual bool hasDescriptorType (deUint32 iteration, VkDescriptorType descriptorType) const
	{
		const auto typesVec = typesAtIteration(iteration);
		return (std::find(begin(typesVec), end(typesVec), descriptorType) != end(typesVec));
	}

public:
	// Convert one particular binding to a mutable or non-mutable equivalent binding, returning the equivalent binding.
	virtual de::MovePtr<BindingInterface> toMutable (deUint32 iteration) const = 0;
	virtual de::MovePtr<BindingInterface> toNonMutable (deUint32 iteration) const = 0;

	// Create resources needed to back up this binding.
	virtual std::vector<Resource> createResources (
		const DeviceInterface& vkd, VkDevice device, Allocator& alloc, deUint32 qIndex, VkQueue queue,
		deUint32 iteration, bool useAABBs, deUint32 baseValue) const = 0;

	// Get GLSL binding declarations. Note: no array size means no array, if size is < 0 it means unbounded array.
	virtual std::string glslDeclarations (deUint32 iteration, deUint32 setNum, deUint32 bindingNum, deUint32 inputAttachmentIdx, tcu::Maybe<deInt32> arraySize) const = 0;

	// Get GLSL statements to check this binding.
	virtual std::string glslCheckStatements (deUint32 iteration, deUint32 setNum, deUint32 bindingNum, deUint32 baseValue, tcu::Maybe<deUint32> arrayIndex, bool usePushConstants) const = 0;
};

// Represents a single binding that will be used in a test.
class SingleBinding : public BindingInterface
{
private:
	VkDescriptorType              type;             // The descriptor type.
	std::vector<VkDescriptorType> mutableTypesVec;  // The types that will be used for each iteration of a test if mutable.

public:
	SingleBinding (VkDescriptorType type_, std::vector<VkDescriptorType> mutableTypes_)
		: type              (type_)
		, mutableTypesVec   (std::move(mutableTypes_))
	{
		static const auto kForbiddenMutableTypes = getForbiddenMutableTypes();
		const auto        kBeginForbidden        = begin(kForbiddenMutableTypes);
		const auto        kEndForbidden          = end(kForbiddenMutableTypes);

		// For release builds.
		DE_UNREF(kBeginForbidden);
		DE_UNREF(kEndForbidden);

		if (type != VK_DESCRIPTOR_TYPE_MUTABLE_VALVE)
		{
			DE_ASSERT(mutableTypesVec.empty());
		}
		else
		{
			DE_ASSERT(!mutableTypesVec.empty());
			DE_ASSERT(std::none_of(begin(mutableTypesVec), end(mutableTypesVec),
			                       [&kBeginForbidden, &kEndForbidden] (VkDescriptorType t) -> bool {
				                       return std::find(kBeginForbidden, kEndForbidden, t) != kEndForbidden;
			                       }));
		}
	}

	deUint32 maxTypes () const override
	{
		if (type != VK_DESCRIPTOR_TYPE_MUTABLE_VALVE)
			return 1u;
		const auto vecSize = mutableTypesVec.size();
		DE_ASSERT(vecSize <= std::numeric_limits<deUint32>::max());
		return static_cast<deUint32>(vecSize);
	}

	VkDescriptorType typeAtIteration (deUint32 iteration) const
	{
		return typesAtIteration(iteration)[0];
	}

	std::vector<VkDescriptorType> usedTypes () const
	{
		if (type != VK_DESCRIPTOR_TYPE_MUTABLE_VALVE)
			return std::vector<VkDescriptorType>(1u, type);
		return mutableTypesVec;
	}

	std::vector<VkDescriptorType> typesAtIteration (deUint32 iteration) const override
	{
		const auto typesVec = usedTypes();
		return std::vector<VkDescriptorType>(1u, typesVec[static_cast<size_t>(iteration) % typesVec.size()]);
	}

	VkDescriptorType mainType () const override
	{
		return type;
	}

	std::vector<VkDescriptorType> mutableTypes () const override
	{
		return mutableTypesVec;
	}

	size_t size () const override
	{
		return size_t{1u};
	}

	bool isArray () const override
	{
		return false;
	}

	bool isUnbounded () const override
	{
		return false;
	}

	de::MovePtr<BindingInterface> toMutable (deUint32 iteration) const override
	{
		DE_UNREF(iteration);

		static const auto kMandatoryMutableTypeFlags = toDescriptorTypeFlags(getMandatoryMutableTypes());
		if (type == VK_DESCRIPTOR_TYPE_MUTABLE_VALVE)
		{
			const auto descFlags = (toDescriptorTypeFlags(mutableTypesVec) | kMandatoryMutableTypeFlags);
			return de::MovePtr<BindingInterface>(new SingleBinding(type, toDescriptorTypeVector(descFlags)));
		}

		// Make sure it's not a forbidden mutable type.
		static const auto kForbiddenMutableTypes = getForbiddenMutableTypes();
		DE_ASSERT(std::find(begin(kForbiddenMutableTypes), end(kForbiddenMutableTypes), type) == end(kForbiddenMutableTypes));

		// Convert the binding to mutable using a wider set of descriptor types if possible, including the binding type.
		const auto descFlags = (kMandatoryMutableTypeFlags | toDescriptorTypeFlagBit(type));

		return de::MovePtr<BindingInterface>(new SingleBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, toDescriptorTypeVector(descFlags)));
	}

	de::MovePtr<BindingInterface> toNonMutable (deUint32 iteration) const override
	{
		return de::MovePtr<BindingInterface>(new SingleBinding(typeAtIteration(iteration), std::vector<VkDescriptorType>()));
	}

	std::vector<Resource> createResources (
		const DeviceInterface& vkd, VkDevice device, Allocator& alloc, deUint32 qIndex, VkQueue queue,
		deUint32 iteration, bool useAABBs, deUint32 baseValue) const override
	{
		const auto descriptorType = typeAtIteration(iteration);

		std::vector<Resource> resources;
		resources.emplace_back(descriptorType, vkd, device, alloc, qIndex, queue, useAABBs, baseValue);
		return resources;
	}

	std::string glslDeclarations (deUint32 iteration, deUint32 setNum, deUint32 bindingNum, deUint32 inputAttachmentIdx, tcu::Maybe<deInt32> arraySize) const override
	{
		const auto         descriptorType = typeAtIteration(iteration);
		const std::string  arraySuffix    = ((static_cast<bool>(arraySize)) ? ((arraySize.get() < 0) ? "[]" : ("[" + de::toString(arraySize.get()) + "]")) : "");
		const std::string  layoutAttribs  = "set=" + de::toString(setNum) + ", binding=" + de::toString(bindingNum);
		const std::string  bindingSuffix  = "_" + de::toString(setNum) + "_" + de::toString(bindingNum);
		const std::string  nameSuffix     = bindingSuffix + arraySuffix;
		std::ostringstream declarations;

		declarations << "layout (";

		switch (descriptorType)
		{
		case VK_DESCRIPTOR_TYPE_SAMPLER:
			declarations << layoutAttribs << ") uniform sampler sampler" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
			declarations << layoutAttribs << ") uniform usampler2D combinedSampler" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
			declarations << layoutAttribs << ") uniform utexture2D sampledImage" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
			declarations << layoutAttribs << ") uniform uboBlock" << bindingSuffix << " { uint val; } ubo" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
			declarations << layoutAttribs << ") buffer sboBlock" << bindingSuffix << " { uint val; } ssbo" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
			declarations << layoutAttribs << ") uniform utextureBuffer uniformTexel" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
			declarations << layoutAttribs << ", r32ui) uniform uimageBuffer storageTexel" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
			declarations << layoutAttribs << ", r32ui) uniform uimage2D storageImage" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
			declarations << layoutAttribs << ", input_attachment_index=" << inputAttachmentIdx << ") uniform usubpassInput inputAttachment" << nameSuffix;
			break;

		case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
			declarations << layoutAttribs << ") uniform accelerationStructureEXT accelerationStructure" << nameSuffix;
			break;

		default:
			DE_ASSERT(false);
			break;
		}

		declarations << ";\n";

		return declarations.str();
	}

	std::string glslCheckStatements (deUint32 iteration, deUint32 setNum, deUint32 bindingNum, deUint32 baseValue_, tcu::Maybe<deUint32> arrayIndex, bool usePushConstants) const override
	{
		const auto        descriptorType = typeAtIteration(iteration);
		const std::string bindingSuffix  = "_" + de::toString(setNum) + "_" + de::toString(bindingNum);

		std::string indexSuffix;
		if (arrayIndex)
		{
			indexSuffix = de::toString(arrayIndex.get());
			if (usePushConstants)
				indexSuffix += " + pc.zero";
			indexSuffix = "[" + indexSuffix + "]";
		}

		const std::string nameSuffix         = bindingSuffix + indexSuffix;
		const std::string baseValue          = toHex(baseValue_);
		const std::string externalImageValue = toHex(getExternalSampledImageValue());
		const std::string mask               = toHex(getStoredValueMask());

		std::ostringstream checks;

		// Note: all of these depend on an external anyError uint variable.
		switch (descriptorType)
		{
		case VK_DESCRIPTOR_TYPE_SAMPLER:
			// Note this depends on an "externalSampledImage" binding.
			checks << "    {\n";
			checks << "      uint readValue = texture(usampler2D(externalSampledImage, sampler" << nameSuffix << "), vec2(0, 0)).r;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << externalImageValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
			checks << "    {\n";
			checks << "      uint readValue = texture(combinedSampler" << nameSuffix << ", vec2(0, 0)).r;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << baseValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
			// Note this depends on an "externalSampler" binding.
			checks << "    {\n";
			checks << "      uint readValue = texture(usampler2D(sampledImage" << nameSuffix << ", externalSampler), vec2(0, 0)).r;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << baseValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
			checks << "    {\n";
			checks << "      uint readValue = ubo" << nameSuffix << ".val;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << baseValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
			checks << "    {\n";
			checks << "      uint readValue = ssbo" << nameSuffix << ".val;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << baseValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			// Check writes.
			checks << "      ssbo" << nameSuffix << ".val = (readValue | " << mask << ");\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
			checks << "    {\n";
			checks << "      uint readValue = texelFetch(uniformTexel" << nameSuffix << ", 0).x;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << baseValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
			checks << "    {\n";
			checks << "      uint readValue = imageLoad(storageTexel" << nameSuffix << ", 0).x;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << baseValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			checks << "      readValue |= " << mask << ";\n";
			// Check writes.
			checks << "      imageStore(storageTexel" << nameSuffix << ", 0, uvec4(readValue, 0, 0, 0));\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
			checks << "    {\n";
			checks << "      uint readValue = imageLoad(storageImage" << nameSuffix << ", ivec2(0, 0)).x;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << baseValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			checks << "      readValue |= " << mask << ";\n";
			// Check writes.
			checks << "      imageStore(storageImage" << nameSuffix << ", ivec2(0, 0), uvec4(readValue, 0, 0, 0));\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
			checks << "    {\n";
			checks << "      uint readValue = subpassLoad(inputAttachment" << nameSuffix << ").x;\n";
			checks << "      debugPrintfEXT(\"iteration-" << iteration << nameSuffix << ": 0x%xu\\n\", readValue);\n";
			checks << "      anyError |= ((readValue == " << baseValue << ") ? 0u : 1u);\n";
			//checks << "      anyError = readValue;\n";
			checks << "    }\n";
			break;

		case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
			checks << "    {\n";
			checks << "      const uint cullMask = 0xFF;\n";
			checks << "      const vec3 origin = vec3(" << getAccelerationStructureOffsetX(baseValue_) << ".0, 0.0, 0.0);\n";
			checks << "      const vec3 direction = vec3(0.0, 0.0, 1.0);\n";
			checks << "      const float tmin = 1.0;\n";
			checks << "      const float tmax = 10.0;\n";
			checks << "      uint candidateFound = 0u;\n";
			checks << "      rayQueryEXT rq;\n";
			checks << "      rayQueryInitializeEXT(rq, accelerationStructure" << nameSuffix << ", gl_RayFlagsNoneEXT, cullMask, origin, tmin, direction, tmax);\n";
			checks << "      while (rayQueryProceedEXT(rq)) {\n";
			checks << "        const uint candidateType = rayQueryGetIntersectionTypeEXT(rq, false);\n";
			checks << "        if (candidateType == gl_RayQueryCandidateIntersectionTriangleEXT || candidateType == gl_RayQueryCandidateIntersectionAABBEXT) {\n";
			checks << "          candidateFound = 1u;\n";
			checks << "        }\n";
			checks << "      }\n";
			checks << "      anyError |= ((candidateFound == 1u) ? 0u : 1u);\n";
			checks << "    }\n";
			break;

		default:
			DE_ASSERT(false);
			break;
		}

		return checks.str();
	}
};

// Represents an array of bindings. Individual bindings are stored as SingleBindings because each one of them may take a different
// type in each iteration (i.e. they can all have different descriptor type vectors).
class ArrayBinding : public BindingInterface
{
private:
	bool                       unbounded;
	std::vector<SingleBinding> bindings;

public:
	ArrayBinding (bool unbounded_, std::vector<SingleBinding> bindings_)
		: unbounded (unbounded_)
		, bindings  (std::move(bindings_))
	{
		// We need to check all single bindings have the same effective type, even if mutable descriptors have different orders.
		DE_ASSERT(!bindings.empty());

		std::set<VkDescriptorType>    basicTypes;
		std::set<DescriptorTypeFlags> bindingTypes;

		for (const auto& b : bindings)
		{
			basicTypes.insert(b.mainType());
			bindingTypes.insert(toDescriptorTypeFlags(b.usedTypes()));
		}

		DE_ASSERT(basicTypes.size() == 1u);
		DE_ASSERT(bindingTypes.size() == 1u);

		// For release builds.
		DE_UNREF(basicTypes);
		DE_UNREF(bindingTypes);
	}

	deUint32 maxTypes () const override
	{
		// Each binding may have the same effective type but a different number of iterations due to repeated types.
		std::vector<size_t> bindingSizes;
		bindingSizes.reserve(bindings.size());

		std::transform(begin(bindings), end(bindings), std::back_inserter(bindingSizes),
		               [] (const SingleBinding& b) { return b.usedTypes().size(); });

		const auto maxElement = std::max_element(begin(bindingSizes), end(bindingSizes));
		DE_ASSERT(maxElement != end(bindingSizes));
		DE_ASSERT(*maxElement <= std::numeric_limits<deUint32>::max());
		return static_cast<deUint32>(*maxElement);
	}

	std::vector<VkDescriptorType> typesAtIteration (deUint32 iteration) const override
	{
		std::vector<VkDescriptorType> result;
		result.reserve(bindings.size());

		for (const auto& b : bindings)
			result.push_back(b.typeAtIteration(iteration));

		return result;
	}

	VkDescriptorType mainType () const override
	{
		return bindings[0].mainType();
	}

	std::vector<VkDescriptorType> mutableTypes () const override
	{
		return bindings[0].mutableTypes();
	}

	size_t size () const override
	{
		return bindings.size();
	}

	bool isArray () const override
	{
		return true;
	}

	bool isUnbounded () const override
	{
		return unbounded;
	}

	de::MovePtr<BindingInterface> toMutable (deUint32 iteration) const override
	{
		// Replicate the first binding once converted, as all are equivalent.
		const auto                       firstBindingPtr = bindings[0].toMutable(iteration);
		const auto                       firstBinding    = *dynamic_cast<SingleBinding*>(firstBindingPtr.get());
		const std::vector<SingleBinding> newBindings     (bindings.size(), firstBinding);

		return de::MovePtr<BindingInterface>(new ArrayBinding(unbounded, newBindings));
	}

	de::MovePtr<BindingInterface> toNonMutable (deUint32 iteration) const override
	{
		// Make sure this binding can be converted to nonmutable for a given iteration.
		DE_ASSERT(!needsAliasing(iteration));

		// We could use each SingleBinding's toNonMutable(), but this is the same.
		const auto                       descType       = bindings[0].typeAtIteration(iteration);
		const SingleBinding              firstBinding   (descType, std::vector<VkDescriptorType>());
		const std::vector<SingleBinding> newBindings    (bindings.size(), firstBinding);

		return de::MovePtr<BindingInterface>(new ArrayBinding(unbounded, newBindings));
	}

	std::vector<Resource> createResources (
		const DeviceInterface& vkd, VkDevice device, Allocator& alloc, deUint32 qIndex, VkQueue queue,
		deUint32 iteration, bool useAABBs, deUint32 baseValue) const override
	{
		std::vector<Resource> resources;
		const auto            numBindings = static_cast<deUint32>(bindings.size());

		for (deUint32 i = 0u; i < numBindings; ++i)
		{
			auto resourceVec = bindings[i].createResources(vkd, device, alloc, qIndex, queue, iteration, useAABBs, baseValue + i);
			resources.emplace_back(std::move(resourceVec[0]));
		}

		return resources;
	}

	// We will ignore the array size parameter.
	std::string glslDeclarations (deUint32 iteration, deUint32 setNum, deUint32 bindingNum, deUint32 inputAttachmentIdx, tcu::Maybe<deInt32> arraySize) const override
	{
		const auto descriptorCount = bindings.size();
		const auto arraySizeVal    = (isUnbounded() ? tcu::just(deInt32{-1}) : tcu::just(static_cast<deInt32>(descriptorCount)));

		DE_UNREF(arraySize);
		DE_ASSERT(descriptorCount < static_cast<size_t>(std::numeric_limits<deInt32>::max()));

		// Maybe a single declaration is enough.
		if (!needsAliasing(iteration))
			return bindings[0].glslDeclarations(iteration, setNum, bindingNum, inputAttachmentIdx, arraySizeVal);

		// Aliasing needed. Avoid reusing types.
		const auto                 descriptorTypes = typesAtIteration(iteration);
		std::set<VkDescriptorType> usedTypes;
		std::ostringstream         declarations;

		for (size_t descriptorIdx = 0u; descriptorIdx < descriptorCount; ++descriptorIdx)
		{
			const auto& descriptorType = descriptorTypes[descriptorIdx];
			if (usedTypes.count(descriptorType) > 0)
				continue;

			usedTypes.insert(descriptorType);
			declarations << bindings[descriptorIdx].glslDeclarations(iteration, setNum, bindingNum, inputAttachmentIdx, arraySizeVal);
		}

		return declarations.str();
	}

	std::string glslCheckStatements (deUint32 iteration, deUint32 setNum, deUint32 bindingNum, deUint32 baseValue_, tcu::Maybe<deUint32> arrayIndex, bool usePushConstants) const override
	{
		DE_ASSERT(!arrayIndex);
		DE_UNREF(arrayIndex); // For release builds.

		std::ostringstream checks;
		const auto         numDescriptors = static_cast<deUint32>(bindings.size());

		for (deUint32 descriptorIdx  = 0u; descriptorIdx < numDescriptors; ++descriptorIdx)
		{
			const auto& binding = bindings[descriptorIdx];
			checks << binding.glslCheckStatements(iteration, setNum, bindingNum, baseValue_ + descriptorIdx, tcu::just(descriptorIdx), usePushConstants);
		}

		return checks.str();
	}
};

class DescriptorSet;

using DescriptorSetPtr = de::SharedPtr<DescriptorSet>;

class DescriptorSet
{
public:
	using BindingInterfacePtr   = de::MovePtr<BindingInterface>;
	using BindingPtrVector      = std::vector<BindingInterfacePtr>;

private:
	BindingPtrVector bindings;

public:
	explicit DescriptorSet (BindingPtrVector& bindings_)
		: bindings(std::move(bindings_))
	{
		DE_ASSERT(!bindings.empty());
	}

	size_t numBindings () const
	{
		return bindings.size();
	}

	const BindingInterface* getBinding (size_t bindingIdx) const
	{
		return bindings.at(bindingIdx).get();
	}

	// Maximum number of descriptor types used by any binding in the set.
	deUint32 maxTypes () const
	{
		std::vector<deUint32> maxSizes;
		maxSizes.reserve(bindings.size());

		std::transform(begin(bindings), end(bindings), std::back_inserter(maxSizes),
		               [] (const BindingInterfacePtr& b) { return b->maxTypes(); });

		const auto maxElement = std::max_element(begin(maxSizes), end(maxSizes));
		DE_ASSERT(maxElement != end(maxSizes));
		return *maxElement;
	}

	// Create another descriptor set that can be the source for copies when setting descriptor values.
	DescriptorSetPtr genSourceSet (SourceSetStrategy strategy, deUint32 iteration) const
	{
		BindingPtrVector newBindings;
		for (const auto& b : bindings)
		{
			if (strategy == SourceSetStrategy::MUTABLE)
				newBindings.push_back(b->toMutable(iteration));
			else
				newBindings.push_back(b->toNonMutable(iteration));
		}

		return DescriptorSetPtr(new DescriptorSet(newBindings));
	}

	// Makes a descriptor pool that can be used when allocating descriptors for this set.
	Move<VkDescriptorPool> makeDescriptorPool (const DeviceInterface& vkd, VkDevice device, PoolMutableStrategy strategy, VkDescriptorPoolCreateFlags flags) const
	{
		std::vector<VkDescriptorPoolSize>             poolSizes;
		std::vector<std::vector<VkDescriptorType>>    mutableTypesVec;
		std::vector<VkMutableDescriptorTypeListVALVE> mutableTypeLists;

		// Make vector element addresses stable.
		const auto bindingCount = numBindings();
		poolSizes.reserve(bindingCount);
		mutableTypesVec.reserve(bindingCount);
		mutableTypeLists.reserve(bindingCount);

		for (const auto& b : bindings)
		{
			const auto                 mainType = b->mainType();
			const VkDescriptorPoolSize poolSize = {
				mainType,
				static_cast<deUint32>(b->size()),
			};
			poolSizes.push_back(poolSize);

			if (strategy == PoolMutableStrategy::KEEP_TYPES || strategy == PoolMutableStrategy::EXPAND_TYPES)
			{
				if (mainType == VK_DESCRIPTOR_TYPE_MUTABLE_VALVE)
				{
					if (strategy == PoolMutableStrategy::KEEP_TYPES)
					{
						mutableTypesVec.emplace_back(b->mutableTypes());
					}
					else
					{
						// Expand the type list with the mandatory types.
						static const auto mandatoryTypesFlags = toDescriptorTypeFlags(getMandatoryMutableTypes());
						const auto        bindingTypes        = toDescriptorTypeVector(mandatoryTypesFlags | toDescriptorTypeFlags(b->mutableTypes()));

						mutableTypesVec.emplace_back(bindingTypes);
					}

					const auto& lastVec = mutableTypesVec.back();
					const VkMutableDescriptorTypeListVALVE typeList = { static_cast<deUint32>(lastVec.size()), de::dataOrNull(lastVec) };
					mutableTypeLists.push_back(typeList);
				}
				else
				{
					const VkMutableDescriptorTypeListVALVE typeList = { 0u, nullptr };
					mutableTypeLists.push_back(typeList);
				}
			}
			else if (strategy == PoolMutableStrategy::NO_TYPES)
				; // Do nothing, we will not use any type list.
			else
				DE_ASSERT(false);
		}

		VkDescriptorPoolCreateInfo poolCreateInfo = initVulkanStructure();

		poolCreateInfo.maxSets       = 1u;
		poolCreateInfo.flags         = flags;
		poolCreateInfo.poolSizeCount = static_cast<deUint32>(poolSizes.size());
		poolCreateInfo.pPoolSizes    = de::dataOrNull(poolSizes);

		VkMutableDescriptorTypeCreateInfoVALVE mutableInfo = initVulkanStructure();

		if (strategy == PoolMutableStrategy::KEEP_TYPES || strategy == PoolMutableStrategy::EXPAND_TYPES)
		{
			mutableInfo.mutableDescriptorTypeListCount = static_cast<deUint32>(mutableTypeLists.size());
			mutableInfo.pMutableDescriptorTypeLists    = de::dataOrNull(mutableTypeLists);
			poolCreateInfo.pNext                       = &mutableInfo;
		}

		return createDescriptorPool(vkd, device, &poolCreateInfo);
	}

private:
	// Building the descriptor set layout create info structure is cumbersome, so we'll reuse the same procedure to check support
	// and create the layout. This structure contains the result. "supported" is created as an enum to avoid the Move<> to bool
	// conversion cast in the contructors.
	struct DescriptorSetLayoutResult
	{
		enum class LayoutSupported { NO = 0, YES };

		LayoutSupported             supported;
		Move<VkDescriptorSetLayout> layout;

		explicit DescriptorSetLayoutResult (Move<VkDescriptorSetLayout>&& layout_)
			: supported (LayoutSupported::YES)
			, layout    (layout_)
		{}

		explicit DescriptorSetLayoutResult (LayoutSupported supported_)
			: supported (supported_)
			, layout    ()
		{}
	};

	DescriptorSetLayoutResult makeOrCheckDescriptorSetLayout (bool checkOnly, const DeviceInterface& vkd, VkDevice device, VkShaderStageFlags stageFlags, VkDescriptorSetLayoutCreateFlags createFlags) const
	{
		const auto                                    numIterations = maxTypes();
		std::vector<VkDescriptorSetLayoutBinding>     bindingsVec;
		std::vector<std::vector<VkDescriptorType>>    mutableTypesVec;
		std::vector<VkMutableDescriptorTypeListVALVE> mutableTypeLists;

		// Make vector element addresses stable.
		const auto bindingCount = numBindings();
		bindingsVec.reserve(bindingCount);
		mutableTypesVec.reserve(bindingCount);
		mutableTypeLists.reserve(bindingCount);

		for (size_t bindingIdx = 0u; bindingIdx < bindings.size(); ++bindingIdx)
		{
			const auto& binding = bindings[bindingIdx];
			const auto mainType = binding->mainType();

			const VkDescriptorSetLayoutBinding layoutBinding = {
				static_cast<deUint32>(bindingIdx),        //    deUint32			binding;
				mainType,                                 //    VkDescriptorType	descriptorType;
				static_cast<deUint32>(binding->size()),   //    deUint32			descriptorCount;
				stageFlags,                               //    VkShaderStageFlags	stageFlags;
				nullptr,                                  //    const VkSampler*	pImmutableSamplers;
			};
			bindingsVec.push_back(layoutBinding);

			// This list may be empty for non-mutable types, which is fine.
			mutableTypesVec.push_back(binding->mutableTypes());
			const auto& lastVec = mutableTypesVec.back();

			const VkMutableDescriptorTypeListVALVE typeList = {
				static_cast<deUint32>(lastVec.size()),  //  deUint32				descriptorTypeCount;
				de::dataOrNull(lastVec),                //  const VkDescriptorType*	pDescriptorTypes;
			};
			mutableTypeLists.push_back(typeList);
		}

		// Make sure to include the variable descriptor count and/or update after bind binding flags.
		const bool        updateAfterBind = ((createFlags & VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT) != 0u);
		bool              lastIsUnbounded = false;
		bool              aliasingNeded   = false;
		std::vector<bool> bindingNeedsAliasing(bindings.size(), false);

		for (size_t bindingIdx = 0; bindingIdx < bindings.size(); ++bindingIdx)
		{
			if (bindingIdx < bindings.size() - 1)
				DE_ASSERT(!bindings[bindingIdx]->isUnbounded());
			else
				lastIsUnbounded = bindings[bindingIdx]->isUnbounded();

			if (bindings[bindingIdx]->needsAliasingUpTo(numIterations))
			{
				bindingNeedsAliasing[bindingIdx] = true;
				aliasingNeded = true;
			}
		}

		using FlagsCreateInfoPtr = de::MovePtr<VkDescriptorSetLayoutBindingFlagsCreateInfo>;
		using BindingFlagsVecPtr = de::MovePtr<std::vector<VkDescriptorBindingFlags>>;

		FlagsCreateInfoPtr flagsCreateInfo;
		BindingFlagsVecPtr bindingFlagsVec;

		if (updateAfterBind || lastIsUnbounded || aliasingNeded)
		{
			flagsCreateInfo = FlagsCreateInfoPtr(new VkDescriptorSetLayoutBindingFlagsCreateInfo);
			*flagsCreateInfo = initVulkanStructure();

			bindingFlagsVec = BindingFlagsVecPtr(new std::vector<VkDescriptorBindingFlags>(bindingsVec.size(), (updateAfterBind ? VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT : 0)));
			if (lastIsUnbounded)
				bindingFlagsVec->back() |= VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT;

			for (size_t bindingIdx = 0; bindingIdx < bindings.size(); ++bindingIdx)
			{
				if (bindingNeedsAliasing[bindingIdx])
					bindingFlagsVec->at(bindingIdx) |= VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT;
			}

			flagsCreateInfo->bindingCount  = static_cast<deUint32>(bindingFlagsVec->size());
			flagsCreateInfo->pBindingFlags = de::dataOrNull(*bindingFlagsVec);
		}

		const VkMutableDescriptorTypeCreateInfoVALVE createInfoValve = {
			VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE,
			flagsCreateInfo.get(),
			static_cast<deUint32>(mutableTypeLists.size()),
			de::dataOrNull(mutableTypeLists),
		};

		const VkDescriptorSetLayoutCreateInfo layoutCreateInfo = {
			VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,    //  VkStructureType						sType;
			&createInfoValve,                                       //  const void*							pNext;
			createFlags,                                            //  VkDescriptorSetLayoutCreateFlags	flags;
			static_cast<deUint32>(bindingsVec.size()),              //  deUint32							bindingCount;
			de::dataOrNull(bindingsVec),                            //  const VkDescriptorSetLayoutBinding*	pBindings;
		};

		if (checkOnly)
		{
			VkDescriptorSetLayoutSupport support = initVulkanStructure();
			vkd.getDescriptorSetLayoutSupport(device, &layoutCreateInfo, &support);
			DescriptorSetLayoutResult result((support.supported == VK_TRUE) ? DescriptorSetLayoutResult::LayoutSupported::YES
			                                                                : DescriptorSetLayoutResult::LayoutSupported::NO);
			return result;
		}
		else
		{
			DescriptorSetLayoutResult result(createDescriptorSetLayout(vkd, device, &layoutCreateInfo));
			return result;
		}
	}

public:
	Move<VkDescriptorSetLayout> makeDescriptorSetLayout (const DeviceInterface& vkd, VkDevice device, VkShaderStageFlags stageFlags, VkDescriptorSetLayoutCreateFlags createFlags) const
	{
		return makeOrCheckDescriptorSetLayout(false /*checkOnly*/, vkd, device, stageFlags, createFlags).layout;
	}

	bool checkDescriptorSetLayout (const DeviceInterface& vkd, VkDevice device, VkShaderStageFlags stageFlags, VkDescriptorSetLayoutCreateFlags createFlags) const
	{
		return (makeOrCheckDescriptorSetLayout(true /*checkOnly*/, vkd, device, stageFlags, createFlags).supported == DescriptorSetLayoutResult::LayoutSupported::YES);
	}

	size_t numDescriptors () const
	{
		size_t total = 0;
		for (const auto& b : bindings)
			total += b->size();
		return total;
	}

	std::vector<Resource> createResources (const DeviceInterface& vkd, VkDevice device, Allocator& alloc, deUint32 qIndex, VkQueue queue, deUint32 iteration, bool useAABBs) const
	{
		// Create resources for each binding.
		std::vector<Resource> result;
		result.reserve(numDescriptors());

		const auto bindingsCount = static_cast<deUint32>(bindings.size());

		for (deUint32 bindingIdx = 0u; bindingIdx < bindingsCount; ++bindingIdx)
		{
			const auto& binding             = bindings[bindingIdx];
			auto        bindingResources    = binding->createResources(vkd, device, alloc, qIndex, queue, iteration, useAABBs, getDescriptorNumericValue(iteration, bindingIdx));

			for (auto& resource : bindingResources)
				result.emplace_back(std::move(resource));
		}

		return result;
	}

	// Updates a descriptor set with the given resources. Note: the set must have been created with a layout that's compatible with this object.
	void updateDescriptorSet (const DeviceInterface& vkd, VkDevice device, VkDescriptorSet set, deUint32 iteration, const std::vector<Resource>& resources) const
	{
		// Make sure the number of resources is correct.
		const auto numResources = resources.size();
		DE_ASSERT(numDescriptors() == numResources);

		std::vector<VkWriteDescriptorSet> descriptorWrites;
		descriptorWrites.reserve(numResources);

		std::vector<VkDescriptorImageInfo>                          imageInfoVec;
		std::vector<VkDescriptorBufferInfo>                         bufferInfoVec;
		std::vector<VkBufferView>                                   bufferViewVec;
		std::vector<VkWriteDescriptorSetAccelerationStructureKHR>   asWriteVec;
		size_t                                                      resourceIdx = 0;

		// We'll be storing pointers to elements of these vectors as we're appending elements, so we need their addresses to be stable.
		imageInfoVec.reserve(numResources);
		bufferInfoVec.reserve(numResources);
		bufferViewVec.reserve(numResources);
		asWriteVec.reserve(numResources);

		for (size_t bindingIdx = 0; bindingIdx < bindings.size(); ++bindingIdx)
		{
			const auto& binding         = bindings[bindingIdx];
			const auto  descriptorTypes = binding->typesAtIteration(iteration);

			for (size_t descriptorIdx = 0; descriptorIdx < binding->size(); ++descriptorIdx)
			{
				// Make sure the resource type matches the expected value.
				const auto& resource       = resources[resourceIdx];
				const auto& descriptorType = descriptorTypes[descriptorIdx];

				DE_ASSERT(resource.descriptorType == descriptorType);

				// Obtain the descriptor write info for the resource.
				const auto writeInfo = resource.makeWriteInfo();

				switch (writeInfo.writeType)
				{
				case WriteType::IMAGE_INFO:                  imageInfoVec.push_back(writeInfo.imageInfo);   break;
				case WriteType::BUFFER_INFO:                 bufferInfoVec.push_back(writeInfo.bufferInfo); break;
				case WriteType::BUFFER_VIEW:                 bufferViewVec.push_back(writeInfo.bufferView); break;
				case WriteType::ACCELERATION_STRUCTURE_INFO: asWriteVec.push_back(writeInfo.asInfo);        break;
				default: DE_ASSERT(false); break;
				}

				// Add a new VkWriteDescriptorSet struct or extend the last one with more info. This helps us exercise different implementation code paths.
				bool extended = false;

				if (!descriptorWrites.empty() && descriptorIdx > 0)
				{
					auto& last = descriptorWrites.back();
					if (last.dstSet == set /* this should always be true */ &&
					    last.dstBinding == bindingIdx && (last.dstArrayElement + last.descriptorCount) == descriptorIdx &&
					    last.descriptorType == descriptorType &&
					    writeInfo.writeType != WriteType::ACCELERATION_STRUCTURE_INFO)
					{
						// The new write should be in the same vector (imageInfoVec, bufferInfoVec or bufferViewVec) so increasing the count works.
						++last.descriptorCount;
						extended = true;
					}
				}

				if (!extended)
				{
					const VkWriteDescriptorSet write = {
						VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
						((writeInfo.writeType == WriteType::ACCELERATION_STRUCTURE_INFO) ? &asWriteVec.back() : nullptr),
						set,
						static_cast<deUint32>(bindingIdx),
						static_cast<deUint32>(descriptorIdx),
						1u,
						descriptorType,
						(writeInfo.writeType == WriteType::IMAGE_INFO  ? &imageInfoVec.back()  : nullptr),
						(writeInfo.writeType == WriteType::BUFFER_INFO ? &bufferInfoVec.back() : nullptr),
						(writeInfo.writeType == WriteType::BUFFER_VIEW ? &bufferViewVec.back() : nullptr),
					};
					descriptorWrites.push_back(write);
				}

				++resourceIdx;
			}
		}

		// Finally, update descriptor set with all the writes.
		vkd.updateDescriptorSets(device, static_cast<deUint32>(descriptorWrites.size()), de::dataOrNull(descriptorWrites), 0u, nullptr);
	}

	// Copies between descriptor sets. They must be compatible and related to this set.
	void copyDescriptorSet (const DeviceInterface& vkd, VkDevice device, VkDescriptorSet srcSet, VkDescriptorSet dstSet) const
	{
		std::vector<VkCopyDescriptorSet> copies;

		for (size_t bindingIdx = 0; bindingIdx < numBindings(); ++bindingIdx)
		{
			const auto& binding         = getBinding(bindingIdx);
			const auto  bindingNumber   = static_cast<deUint32>(bindingIdx);
			const auto  descriptorCount = static_cast<deUint32>(binding->size());

			const VkCopyDescriptorSet copy =
			{
				VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
				nullptr,
				// set, binding, array element.
				srcSet, bindingNumber, 0u,
				dstSet, bindingNumber, 0u,
				descriptorCount,
			};

			copies.push_back(copy);
		}

		vkd.updateDescriptorSets(device, 0u, nullptr, static_cast<deUint32>(copies.size()), de::dataOrNull(copies));
	}

	// Does any binding in the set need aliasing in a given iteration?
	bool needsAliasing (deUint32 iteration) const
	{
		std::vector<bool> aliasingNeededFlags;
		aliasingNeededFlags.reserve(bindings.size());

		std::transform(begin(bindings), end(bindings), std::back_inserter(aliasingNeededFlags),
		               [iteration] (const BindingInterfacePtr& b) { return b->needsAliasing(iteration); });
		return std::any_of(begin(aliasingNeededFlags), end(aliasingNeededFlags), [] (bool f) { return f; });
	}

	// Does any binding in the set need aliasing in any iteration?
	bool needsAnyAliasing () const
	{
		const auto        numIterations       = maxTypes();
		std::vector<bool> aliasingNeededFlags (numIterations, false);

		for (deUint32 iteration = 0; iteration < numIterations; ++iteration)
		    aliasingNeededFlags[iteration] = needsAliasing(iteration);

		return std::any_of(begin(aliasingNeededFlags), end(aliasingNeededFlags), [] (bool f) { return f; });
	}

	// Is the last binding an unbounded array?
	bool lastBindingIsUnbounded () const
	{
		if (bindings.empty())
			return false;
		return bindings.back()->isUnbounded();
	}

	// Get the variable descriptor count for the last binding if any.
	tcu::Maybe<deUint32> getVariableDescriptorCount () const
	{
		if (lastBindingIsUnbounded())
			return tcu::just(static_cast<deUint32>(bindings.back()->size()));
		return tcu::Nothing;
	}

	// Check if the set contains a descriptor type of the given type at the given iteration.
	bool containsTypeAtIteration (VkDescriptorType descriptorType, deUint32 iteration) const
	{
		return std::any_of(begin(bindings), end(bindings),
		                   [descriptorType, iteration] (const BindingInterfacePtr& b) {
			                   const auto types = b->typesAtIteration(iteration);
			                   return de::contains(begin(types), end(types), descriptorType);
		                   });
	}

	// Is any binding an array?
	bool hasArrays () const
	{
		return std::any_of(begin(bindings), end(bindings), [] (const BindingInterfacePtr& b) { return b->isArray(); });
	}
};

enum class UpdateType
{
	WRITE = 0,
	COPY,
};

enum class SourceSetType
{
	NORMAL = 0,
	HOST_ONLY,
	NO_SOURCE,
};

enum class UpdateMoment
{
	NORMAL = 0,
	UPDATE_AFTER_BIND,
};

enum class TestingStage
{
	COMPUTE = 0,
	VERTEX,
	TESS_EVAL,
	TESS_CONTROL,
	GEOMETRY,
	FRAGMENT,
	RAY_GEN,
	INTERSECTION,
	ANY_HIT,
	CLOSEST_HIT,
	MISS,
	CALLABLE,
};

enum class ArrayAccessType
{
	CONSTANT = 0,
	PUSH_CONSTANT,
	NO_ARRAY,
};

// Are we testing a ray tracing pipeline stage?
bool isRayTracingStage (TestingStage stage)
{
	switch (stage)
	{
	case TestingStage::RAY_GEN:
	case TestingStage::INTERSECTION:
	case TestingStage::ANY_HIT:
	case TestingStage::CLOSEST_HIT:
	case TestingStage::MISS:
	case TestingStage::CALLABLE:
		return true;
	default:
		break;
	}

	return false;
}

struct TestParams
{
	DescriptorSetPtr    descriptorSet;
	UpdateType          updateType;
	SourceSetStrategy   sourceSetStrategy;
	SourceSetType       sourceSetType;
	PoolMutableStrategy poolMutableStrategy;
	UpdateMoment        updateMoment;
	ArrayAccessType     arrayAccessType;
	TestingStage        testingStage;

	VkShaderStageFlags getStageFlags () const
	{
		VkShaderStageFlags flags = 0u;

		switch (testingStage)
		{
		case TestingStage::COMPUTE:			flags |= VK_SHADER_STAGE_COMPUTE_BIT;					break;
		case TestingStage::VERTEX:			flags |= VK_SHADER_STAGE_VERTEX_BIT;					break;
		case TestingStage::TESS_EVAL:		flags |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;	break;
		case TestingStage::TESS_CONTROL:	flags |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;		break;
		case TestingStage::GEOMETRY:		flags |= VK_SHADER_STAGE_GEOMETRY_BIT;					break;
		case TestingStage::FRAGMENT:		flags |= VK_SHADER_STAGE_FRAGMENT_BIT;					break;
		case TestingStage::RAY_GEN:			flags |= VK_SHADER_STAGE_RAYGEN_BIT_KHR;				break;
		case TestingStage::INTERSECTION:	flags |= VK_SHADER_STAGE_INTERSECTION_BIT_KHR;			break;
		case TestingStage::ANY_HIT:			flags |= VK_SHADER_STAGE_ANY_HIT_BIT_KHR;				break;
		case TestingStage::CLOSEST_HIT:		flags |= VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;			break;
		case TestingStage::MISS:			flags |= VK_SHADER_STAGE_MISS_BIT_KHR;					break;
		case TestingStage::CALLABLE:		flags |= VK_SHADER_STAGE_CALLABLE_BIT_KHR;				break;
		default:
			DE_ASSERT(false);
			break;
		}

		return flags;
	}

	VkPipelineStageFlags getPipelineWriteStage () const
	{
		VkPipelineStageFlags flags = 0u;

		switch (testingStage)
		{
		case TestingStage::COMPUTE:			flags |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;					break;
		case TestingStage::VERTEX:			flags |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;					break;
		case TestingStage::TESS_EVAL:		flags |= VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;	break;
		case TestingStage::TESS_CONTROL:	flags |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT;		break;
		case TestingStage::GEOMETRY:		flags |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;					break;
		case TestingStage::FRAGMENT:		flags |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;					break;
		case TestingStage::RAY_GEN:			// fallthrough
		case TestingStage::INTERSECTION:	// fallthrough
		case TestingStage::ANY_HIT:			// fallthrough
		case TestingStage::CLOSEST_HIT:		// fallthrough
		case TestingStage::MISS:			// fallthrough
		case TestingStage::CALLABLE:		flags |= VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;			break;
		default:
			DE_ASSERT(false);
			break;
		}

		return flags;
	}

private:
	VkDescriptorSetLayoutCreateFlags getLayoutCreateFlags (bool isSourceSet) const
	{
		// UPDATE_AFTER_BIND cannot be used with HOST_ONLY sets.
		//DE_ASSERT(!(updateMoment == UpdateMoment::UPDATE_AFTER_BIND && sourceSetType == SourceSetType::HOST_ONLY));

		VkDescriptorSetLayoutCreateFlags createFlags = 0u;

		if ((!isSourceSet || sourceSetType != SourceSetType::HOST_ONLY) && updateMoment == UpdateMoment::UPDATE_AFTER_BIND)
			createFlags |= VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT;

		if (isSourceSet && sourceSetType == SourceSetType::HOST_ONLY)
			createFlags |= VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE;

		return createFlags;
	}

public:
	VkDescriptorSetLayoutCreateFlags getSrcLayoutCreateFlags () const
	{
		return getLayoutCreateFlags(true);
	}

	VkDescriptorSetLayoutCreateFlags getDstLayoutCreateFlags () const
	{
		return getLayoutCreateFlags(false);
	}

private:
	VkDescriptorPoolCreateFlags getPoolCreateFlags (bool isSourceSet) const
	{
		// UPDATE_AFTER_BIND cannot be used with HOST_ONLY sets.
		//DE_ASSERT(!(updateMoment == UpdateMoment::UPDATE_AFTER_BIND && sourceSetType == SourceSetType::HOST_ONLY));

		VkDescriptorPoolCreateFlags poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;

		if ((!isSourceSet || sourceSetType != SourceSetType::HOST_ONLY) && updateMoment == UpdateMoment::UPDATE_AFTER_BIND)
			poolCreateFlags |= VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;

		if (isSourceSet && sourceSetType == SourceSetType::HOST_ONLY)
			poolCreateFlags |= VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE;

		return poolCreateFlags;
	}

public:
	VkDescriptorPoolCreateFlags getSrcPoolCreateFlags () const
	{
		return getPoolCreateFlags(true);
	}

	VkDescriptorPoolCreateFlags getDstPoolCreateFlags () const
	{
		return getPoolCreateFlags(false);
	}

	VkPipelineBindPoint getBindPoint () const
	{
		if (testingStage == TestingStage::COMPUTE)
			return VK_PIPELINE_BIND_POINT_COMPUTE;
		if (isRayTracingStage(testingStage))
			return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
		return VK_PIPELINE_BIND_POINT_GRAPHICS;
	}
};

class MutableTypesTest : public TestCase
{
public:
	MutableTypesTest (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const TestParams& params)
		: TestCase(testCtx, name, description)
		, m_params(params)
	{}

	~MutableTypesTest () override = default;

	void            initPrograms        (vk::SourceCollections& programCollection) const override;
	TestInstance*   createInstance      (Context& context) const override;
	void            checkSupport        (Context& context) const override;

private:
	TestParams      m_params;
};

class MutableTypesInstance : public TestInstance
{
public:
	MutableTypesInstance (Context& context, const TestParams& params)
		: TestInstance  (context)
		, m_params      (params)
	{}

	~MutableTypesInstance () override = default;

	tcu::TestStatus iterate () override;

private:
	TestParams      m_params;
};

// Check if a descriptor set contains a given descriptor type in any iteration up to maxTypes().
bool containsAnyDescriptorType (const DescriptorSet& descriptorSet, VkDescriptorType descriptorType)
{
	const auto numIterations = descriptorSet.maxTypes();

	for (deUint32 iter = 0u; iter < numIterations; ++iter)
	{
		if (descriptorSet.containsTypeAtIteration(descriptorType, iter))
			return true;
	}

	return false;
}

// Check if testing this descriptor set needs an external image (for sampler descriptors).
bool needsExternalImage (const DescriptorSet& descriptorSet)
{
	return containsAnyDescriptorType(descriptorSet, VK_DESCRIPTOR_TYPE_SAMPLER);
}

// Check if testing this descriptor set needs an external sampler (for sampled images).
bool needsExternalSampler (const DescriptorSet& descriptorSet)
{
	return containsAnyDescriptorType(descriptorSet, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
}

// Check if this descriptor set contains a input attachments.
bool usesInputAttachments (const DescriptorSet& descriptorSet)
{
	return containsAnyDescriptorType(descriptorSet, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
}

// Check if this descriptor set contains acceleration structures.
bool usesAccelerationStructures (const DescriptorSet& descriptorSet)
{
	return containsAnyDescriptorType(descriptorSet, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR);
}

std::string shaderName (deUint32 iteration)
{
	return ("iteration-" + de::toString(iteration));
}

void MutableTypesTest::initPrograms (vk::SourceCollections& programCollection) const
{
	const bool						usePushConstants      = (m_params.arrayAccessType == ArrayAccessType::PUSH_CONSTANT);
	const bool						useExternalImage      = needsExternalImage(*m_params.descriptorSet);
	const bool						useExternalSampler    = needsExternalSampler(*m_params.descriptorSet);
	const bool						rayQueries            = usesAccelerationStructures(*m_params.descriptorSet);
	const bool						rayTracing            = isRayTracingStage(m_params.testingStage);
	const auto						numIterations         = m_params.descriptorSet->maxTypes();
	const auto						numBindings           = m_params.descriptorSet->numBindings();
	const vk::ShaderBuildOptions	rtBuildOptions        (programCollection.usedVulkanVersion, vk::SPIRV_VERSION_1_4, 0u, true);

	// Extra set and bindings for external resources.
	std::ostringstream extraSet;
	deUint32           extraBindings = 0u;

	extraSet << "layout (set=1, binding=" << extraBindings++ << ") buffer OutputBufferBlock { uint value[" << numIterations << "]; } outputBuffer;\n";
	if (useExternalImage)
		extraSet << "layout (set=1, binding=" << extraBindings++ << ") uniform utexture2D externalSampledImage;\n";
	if (useExternalSampler)
		extraSet << "layout (set=1, binding=" << extraBindings++ << ") uniform sampler externalSampler;\n";
	// The extra binding below will be declared in the "passthrough" ray generation shader.
#if 0
	if (rayTracing)
		extraSet << "layout (set=1, binding=" << extraBindings++ << ") uniform accelerationStructureEXT externalAS;\n";
#endif

	// Common vertex preamble.
	std::ostringstream vertexPreamble;
	vertexPreamble
			<< "vec2 vertexPositions[3] = vec2[](\n"
			<< "  vec2(0.0, -0.5),\n"
			<< "  vec2(0.5, 0.5),\n"
			<< "  vec2(-0.5, 0.5)\n"
			<< ");\n"
			;

	// Vertex shader body common statements.
	std::ostringstream vertexBodyCommon;
	vertexBodyCommon << "  gl_Position = vec4(vertexPositions[gl_VertexIndex], 0.0, 1.0);\n";

	// Common tessellation control preamble.
	std::ostringstream tescPreamble;
	tescPreamble
		<< "layout (vertices=3) out;\n"
		<< "in gl_PerVertex\n"
		<< "{\n"
		<< "  vec4 gl_Position;\n"
		<< "} gl_in[gl_MaxPatchVertices];\n"
		<< "out gl_PerVertex\n"
		<< "{\n"
		<< "  vec4 gl_Position;\n"
		<< "} gl_out[];\n"
		;

	// Common tessellation control body.
	std::ostringstream tescBodyCommon;
	tescBodyCommon
		<< "  gl_TessLevelInner[0] = 1.0;\n"
		<< "  gl_TessLevelInner[1] = 1.0;\n"
		<< "  gl_TessLevelOuter[0] = 1.0;\n"
		<< "  gl_TessLevelOuter[1] = 1.0;\n"
		<< "  gl_TessLevelOuter[2] = 1.0;\n"
		<< "  gl_TessLevelOuter[3] = 1.0;\n"
		<< "  gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
		;

	// Common tessellation evaluation preamble.
	std::ostringstream tesePreamble;
	tesePreamble
		<< "layout (triangles, fractional_odd_spacing, cw) in;\n"
		<< "in gl_PerVertex\n"
		<< "{\n"
		<< "  vec4 gl_Position;\n"
		<< "} gl_in[gl_MaxPatchVertices];\n"
		<< "out gl_PerVertex\n"
		<< "{\n"
		<< "  vec4 gl_Position;\n"
		<< "};\n"
		;

	// Common tessellation evaluation body.
	std::ostringstream teseBodyCommon;
	teseBodyCommon
		<< "  gl_Position = (gl_TessCoord.x * gl_in[0].gl_Position) +\n"
		<< "                (gl_TessCoord.y * gl_in[1].gl_Position) +\n"
		<< "                (gl_TessCoord.z * gl_in[2].gl_Position);\n"
		;

	// Shader preamble.
	std::ostringstream preamble;

	preamble
		<< "#version 460\n"
		<< "#extension GL_EXT_nonuniform_qualifier : enable\n"
		<< "#extension GL_EXT_debug_printf : enable\n"
		<< (rayTracing ? "#extension GL_EXT_ray_tracing : enable\n" : "")
		<< (rayQueries ? "#extension GL_EXT_ray_query : enable\n" : "")
		<< "\n"
		;

	if (m_params.testingStage == TestingStage::VERTEX)
	{
		preamble << vertexPreamble.str();
	}
	else if (m_params.testingStage == TestingStage::COMPUTE)
	{
		preamble
			<< "layout (local_size_x=1, local_size_y=1, local_size_z=1) in;\n"
			<< "\n"
			;
	}
	else if (m_params.testingStage == TestingStage::GEOMETRY)
	{
		preamble
			<< "layout (triangles) in;\n"
			<< "layout (triangle_strip, max_vertices=3) out;\n"
			<< "in gl_PerVertex\n"
			<< "{\n"
			<< "  vec4 gl_Position;\n"
			<< "} gl_in[3];\n"
			<< "out gl_PerVertex\n"
			<< "{\n"
			<< "  vec4 gl_Position;\n"
			<< "};\n"
			;
	}
	else if (m_params.testingStage == TestingStage::TESS_CONTROL)
	{
		preamble << tescPreamble.str();
	}
	else if (m_params.testingStage == TestingStage::TESS_EVAL)
	{
		preamble << tesePreamble.str();
	}
	else if (m_params.testingStage == TestingStage::CALLABLE)
	{
		preamble << "layout (location=0) callableDataInEXT float unusedCallableData;\n";
	}
	else if (m_params.testingStage == TestingStage::CLOSEST_HIT ||
			 m_params.testingStage == TestingStage::ANY_HIT ||
			 m_params.testingStage == TestingStage::MISS)
	{
		preamble << "layout (location=0) rayPayloadInEXT float unusedRayPayload;\n";
	}
	else if (m_params.testingStage == TestingStage::INTERSECTION)
	{
		preamble << "hitAttributeEXT vec3 hitAttribute;\n";
	}

	preamble << extraSet.str();
	if (usePushConstants)
		preamble << "layout (push_constant, std430) uniform PushConstantBlock { uint zero; } pc;\n";
	preamble << "\n";

	// We need to create a shader per iteration.
	for (deUint32 iter = 0u; iter < numIterations; ++iter)
	{
		// Shader preamble.
		std::ostringstream shader;
		shader << preamble.str();

		deUint32 inputAttachmentCount = 0u;

		// Descriptor declarations for this iteration.
		for (size_t bindingIdx = 0; bindingIdx < numBindings; ++bindingIdx)
		{
			DE_ASSERT(bindingIdx <= std::numeric_limits<deUint32>::max());

			const auto binding            = m_params.descriptorSet->getBinding(bindingIdx);
			const auto bindingTypes       = binding->typesAtIteration(iter);
			const auto hasInputAttachment = de::contains(begin(bindingTypes), end(bindingTypes), VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT);
			const auto isArray            = binding->isArray();
			const auto isUnbounded        = binding->isUnbounded();
			const auto bindingSize        = binding->size();

			// If the binding is an input attachment, make sure it's not an array.
			DE_ASSERT(!hasInputAttachment || !isArray);

			// Make sure the descriptor count fits a deInt32 if needed.
			DE_ASSERT(!isArray || isUnbounded || bindingSize <= static_cast<size_t>(std::numeric_limits<deInt32>::max()));

			const auto arraySize = (isArray ? (isUnbounded ? tcu::just(deInt32{-1}) : tcu::just(static_cast<deInt32>(bindingSize)))
			                                : tcu::Nothing);

			shader << binding->glslDeclarations(iter, 0u, static_cast<deUint32>(bindingIdx), inputAttachmentCount, arraySize);

			if (hasInputAttachment)
				++inputAttachmentCount;
		}

		// Main body.
		shader
			<< "\n"
			<< "void main() {\n"
			// This checks if we are the first invocation to arrive here, so the checks are executed only once.
			<< "  const uint flag = atomicCompSwap(outputBuffer.value[" << iter << "], 0u, 1u);\n"
			<< "  if (flag == 0u) {\n"
			<< "    uint anyError = 0u;\n"
			;

		for (size_t bindingIdx = 0; bindingIdx < numBindings; ++bindingIdx)
		{
			const auto binding = m_params.descriptorSet->getBinding(bindingIdx);
			const auto idx32 = static_cast<deUint32>(bindingIdx);
			shader << binding->glslCheckStatements(iter, 0u, idx32, getDescriptorNumericValue(iter, idx32), tcu::Nothing, usePushConstants);
		}

		shader
			<< "    if (anyError == 0u) {\n"
			<< "      atomicAdd(outputBuffer.value[" << iter << "], 1u);\n"
			<< "    }\n"
			<< "  }\n" // Closes if (flag == 0u).
			;

		if (m_params.testingStage == TestingStage::VERTEX)
		{
			shader << vertexBodyCommon.str();
		}
		else if (m_params.testingStage == TestingStage::GEOMETRY)
		{
			shader
				<< "  gl_Position = gl_in[0].gl_Position; EmitVertex();\n"
				<< "  gl_Position = gl_in[1].gl_Position; EmitVertex();\n"
				<< "  gl_Position = gl_in[2].gl_Position; EmitVertex();\n"
				;
		}
		else if (m_params.testingStage == TestingStage::TESS_CONTROL)
		{
			shader << tescBodyCommon.str();
		}
		else if (m_params.testingStage == TestingStage::TESS_EVAL)
		{
			shader << teseBodyCommon.str();
		}

		shader
			<< "}\n" // End of main().
			;

		{
			const auto	shaderNameStr	= shaderName(iter);
			const auto	shaderStr		= shader.str();
			auto&		glslSource		= programCollection.glslSources.add(shaderNameStr);

			if (m_params.testingStage == TestingStage::COMPUTE)
				glslSource << glu::ComputeSource(shaderStr);
			else if (m_params.testingStage == TestingStage::VERTEX)
				glslSource << glu::VertexSource(shaderStr);
			else if (m_params.testingStage == TestingStage::FRAGMENT)
				glslSource << glu::FragmentSource(shaderStr);
			else if (m_params.testingStage == TestingStage::GEOMETRY)
				glslSource << glu::GeometrySource(shaderStr);
			else if (m_params.testingStage == TestingStage::TESS_CONTROL)
				glslSource << glu::TessellationControlSource(shaderStr);
			else if (m_params.testingStage == TestingStage::TESS_EVAL)
				glslSource << glu::TessellationEvaluationSource(shaderStr);
			else if (m_params.testingStage == TestingStage::RAY_GEN)
				glslSource << glu::RaygenSource(updateRayTracingGLSL(shaderStr));
			else if (m_params.testingStage == TestingStage::INTERSECTION)
				glslSource << glu::IntersectionSource(updateRayTracingGLSL(shaderStr));
			else if (m_params.testingStage == TestingStage::ANY_HIT)
				glslSource << glu::AnyHitSource(updateRayTracingGLSL(shaderStr));
			else if (m_params.testingStage == TestingStage::CLOSEST_HIT)
				glslSource << glu::ClosestHitSource(updateRayTracingGLSL(shaderStr));
			else if (m_params.testingStage == TestingStage::MISS)
				glslSource << glu::MissSource(updateRayTracingGLSL(shaderStr));
			else if (m_params.testingStage == TestingStage::CALLABLE)
				glslSource << glu::CallableSource(updateRayTracingGLSL(shaderStr));
			else
				DE_ASSERT(false);

			if (rayTracing || rayQueries)
				glslSource << rtBuildOptions;
		}
	}

	if (m_params.testingStage == TestingStage::FRAGMENT
		|| m_params.testingStage == TestingStage::GEOMETRY
		|| m_params.testingStage == TestingStage::TESS_CONTROL
		|| m_params.testingStage == TestingStage::TESS_EVAL)
	{
		// Add passthrough vertex shader that works for points.
		std::ostringstream vertPassthrough;
		vertPassthrough
			<< "#version 460\n"
			<< "out gl_PerVertex\n"
			<< "{\n"
			<< "  vec4 gl_Position;\n"
			<< "};\n"
			<< vertexPreamble.str()
			<< "void main() {\n"
			<< vertexBodyCommon.str()
			<< "}\n"
			;
		programCollection.glslSources.add("vert") << glu::VertexSource(vertPassthrough.str());
	}

	if (m_params.testingStage == TestingStage::TESS_CONTROL)
	{
		// Add passthrough tessellation evaluation shader.
		std::ostringstream tesePassthrough;
		tesePassthrough
			<< "#version 460\n"
			<< tesePreamble.str()
			<< "void main (void)\n"
			<< "{\n"
			<< teseBodyCommon.str()
			<< "}\n"
			;

		programCollection.glslSources.add("tese") << glu::TessellationEvaluationSource(tesePassthrough.str());
	}

	if (m_params.testingStage == TestingStage::TESS_EVAL)
	{
		// Add passthrough tessellation control shader.
		std::ostringstream tescPassthrough;
		tescPassthrough
			<< "#version 460\n"
			<< tescPreamble.str()
			<< "void main (void)\n"
			<< "{\n"
			<< tescBodyCommon.str()
			<< "}\n"
			;

		programCollection.glslSources.add("tesc") << glu::TessellationControlSource(tescPassthrough.str());
	}

	if (rayTracing && m_params.testingStage != TestingStage::RAY_GEN)
	{
		// Add a "passthrough" ray generation shader.
		std::ostringstream rgen;
		rgen
			<< "#version 460 core\n"
			<< "#extension GL_EXT_ray_tracing : require\n"
			<< "layout (set=1, binding=" << extraBindings << ") uniform accelerationStructureEXT externalAS;\n"
			<< ((m_params.testingStage == TestingStage::CALLABLE)
				? "layout (location=0) callableDataEXT float unusedCallableData;\n"
				: "layout (location=0) rayPayloadEXT float unusedRayPayload;\n")
			<< "\n"
			<< "void main()\n"
			<< "{\n"
			;

		if (m_params.testingStage == TestingStage::INTERSECTION
			|| m_params.testingStage == TestingStage::ANY_HIT
			|| m_params.testingStage == TestingStage::CLOSEST_HIT
			|| m_params.testingStage == TestingStage::MISS)
		{
			// We need to trace rays in this case to get hits or misses.
			const auto zDir = ((m_params.testingStage == TestingStage::MISS) ? "-1.0" : "1.0");

			rgen
				<< "  const uint cullMask = 0xFF;\n"
				<< "  const float tMin = 1.0;\n"
				<< "  const float tMax = 10.0;\n"
				<< "  const vec3 origin = vec3(0.0, 0.0, 0.0);\n"
				<< "  const vec3 direction = vec3(0.0, 0.0, " << zDir << ");\n"
				<< "  traceRayEXT(externalAS, gl_RayFlagsNoneEXT, cullMask, 0, 0, 0, origin, tMin, direction, tMax, 0);\n"
				;

		}
		else if (m_params.testingStage == TestingStage::CALLABLE)
		{
			rgen << "  executeCallableEXT(0, 0);\n";
		}

		// End of main().
		rgen << "}\n";

		programCollection.glslSources.add("rgen") << glu::RaygenSource(updateRayTracingGLSL(rgen.str())) << rtBuildOptions;

		// Intersection shaders will ignore the intersection, so we need a passthrough miss shader.
		if (m_params.testingStage == TestingStage::INTERSECTION)
		{
			std::ostringstream miss;
			miss
				<< "#version 460 core\n"
				<< "#extension GL_EXT_ray_tracing : require\n"
				<< "layout (location=0) rayPayloadEXT float unusedRayPayload;\n"
				<< "\n"
				<< "void main()\n"
				<< "{\n"
				<< "}\n"
				;

			programCollection.glslSources.add("miss") << glu::MissSource(updateRayTracingGLSL(miss.str())) << rtBuildOptions;
		}
	}
}

TestInstance* MutableTypesTest::createInstance (Context& context) const
{
	return new MutableTypesInstance(context, m_params);
}

void requirePartiallyBound (Context& context)
{
	context.requireDeviceFunctionality("VK_EXT_descriptor_indexing");
	const auto& indexingFeatures = context.getDescriptorIndexingFeatures();
	if (!indexingFeatures.descriptorBindingPartiallyBound)
		TCU_THROW(NotSupportedError, "Partially bound bindings not supported");
}

void requireVariableDescriptorCount (Context& context)
{
	context.requireDeviceFunctionality("VK_EXT_descriptor_indexing");
	const auto& indexingFeatures = context.getDescriptorIndexingFeatures();
	if (!indexingFeatures.descriptorBindingVariableDescriptorCount)
		TCU_THROW(NotSupportedError, "Variable descriptor count not supported");
}

// Calculates the set of used descriptor types for a given set and iteration count, for bindings matching a predicate.
std::set<VkDescriptorType> getUsedDescriptorTypes (const DescriptorSet& descriptorSet, deUint32 numIterations, bool (*predicate)(const BindingInterface* binding))
{
	std::set<VkDescriptorType> usedDescriptorTypes;

	for (size_t bindingIdx = 0; bindingIdx < descriptorSet.numBindings(); ++bindingIdx)
	{
		const auto bindingPtr = descriptorSet.getBinding(bindingIdx);
		if (predicate(bindingPtr))
		{
			for (deUint32 iter = 0u; iter < numIterations; ++iter)
			{
				const auto descTypes = bindingPtr->typesAtIteration(iter);
				usedDescriptorTypes.insert(begin(descTypes), end(descTypes));
			}
		}
	}

	return usedDescriptorTypes;
}

std::set<VkDescriptorType> getAllUsedDescriptorTypes (const DescriptorSet& descriptorSet, deUint32 numIterations)
{
	return getUsedDescriptorTypes(descriptorSet, numIterations, [] (const BindingInterface*) { return true; });
}

std::set<VkDescriptorType> getUsedArrayDescriptorTypes (const DescriptorSet& descriptorSet, deUint32 numIterations)
{
	return getUsedDescriptorTypes(descriptorSet, numIterations, [] (const BindingInterface* b) { return b->isArray(); });
}

// Are we testing a vertex pipeline stage?
bool isVertexStage (TestingStage stage)
{
	switch (stage)
	{
	case TestingStage::VERTEX:
	case TestingStage::TESS_CONTROL:
	case TestingStage::TESS_EVAL:
	case TestingStage::GEOMETRY:
		return true;
	default:
		break;
	}

	return false;
}

void MutableTypesTest::checkSupport (Context& context) const
{
	context.requireDeviceFunctionality("VK_VALVE_mutable_descriptor_type");

	// Check ray tracing if needed.
	const bool rayTracing = isRayTracingStage(m_params.testingStage);

	if (rayTracing)
	{
		context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
		context.requireDeviceFunctionality("VK_KHR_ray_tracing_pipeline");
	}

	// Check if ray queries are needed. Ray queries are used to verify acceleration structure descriptors.
	const bool rayQueriesNeeded = usesAccelerationStructures(*m_params.descriptorSet);
	if (rayQueriesNeeded)
	{
		context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
		context.requireDeviceFunctionality("VK_KHR_ray_query");
	}

	// We'll use iterations to check each mutable type, as needed.
	const auto numIterations = m_params.descriptorSet->maxTypes();

	if (m_params.descriptorSet->lastBindingIsUnbounded())
		requireVariableDescriptorCount(context);

	for (deUint32 iter = 0u; iter < numIterations; ++iter)
	{
		if (m_params.descriptorSet->needsAliasing(iter))
		{
			requirePartiallyBound(context);
			break;
		}
	}

	if (m_params.updateMoment == UpdateMoment::UPDATE_AFTER_BIND)
	{
		// Check update after bind for each used descriptor type.
		const auto& usedDescriptorTypes = getAllUsedDescriptorTypes(*m_params.descriptorSet, numIterations);
		const auto& indexingFeatures    = context.getDescriptorIndexingFeatures();

		for (const auto& descType : usedDescriptorTypes)
		{
			switch (descType)
			{
			case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
			case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
				if (!indexingFeatures.descriptorBindingUniformBufferUpdateAfterBind)
					TCU_THROW(NotSupportedError, "Update-after-bind not supported for uniform buffers");
				break;

			case VK_DESCRIPTOR_TYPE_SAMPLER:
			case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
			case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
				if (!indexingFeatures.descriptorBindingSampledImageUpdateAfterBind)
					TCU_THROW(NotSupportedError, "Update-after-bind not supported for samplers and sampled images");
				break;

			case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
				if (!indexingFeatures.descriptorBindingStorageImageUpdateAfterBind)
					TCU_THROW(NotSupportedError, "Update-after-bind not supported for storage images");
				break;

			case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
			case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
				if (!indexingFeatures.descriptorBindingStorageBufferUpdateAfterBind)
					TCU_THROW(NotSupportedError, "Update-after-bind not supported for storage buffers");
				break;

			case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
				if (!indexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind)
					TCU_THROW(NotSupportedError, "Update-after-bind not supported for uniform texel buffers");
				break;

			case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
				if (!indexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind)
					TCU_THROW(NotSupportedError, "Update-after-bind not supported for storage texel buffers");
				break;

			case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
				TCU_THROW(InternalError, "Tests do not support update-after-bind with input attachments");

			case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
				{
					// Just in case we ever mix some of these in.
					context.requireDeviceFunctionality("VK_EXT_inline_uniform_block");
					const auto& iubFeatures = context.getInlineUniformBlockFeatures();
					if (!iubFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind)
						TCU_THROW(NotSupportedError, "Update-after-bind not supported for inline uniform blocks");
				}
				break;

			case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
				{
					// Just in case we ever mix some of these in.
					context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
					const auto& asFeatures = context.getAccelerationStructureFeatures();
					if (!asFeatures.descriptorBindingAccelerationStructureUpdateAfterBind)
						TCU_THROW(NotSupportedError, "Update-after-bind not supported for acceleration structures");
				}
				break;

			case VK_DESCRIPTOR_TYPE_MUTABLE_VALVE:
				TCU_THROW(InternalError, "Found VK_DESCRIPTOR_TYPE_MUTABLE_VALVE in list of used descriptor types");

			default:
				TCU_THROW(InternalError, "Unexpected descriptor type found in list of used descriptor types: " + de::toString(descType));
			}
		}
	}

	if (m_params.arrayAccessType == ArrayAccessType::PUSH_CONSTANT)
	{
		// These require dynamically uniform indices.
		const auto& usedDescriptorTypes         = getUsedArrayDescriptorTypes(*m_params.descriptorSet, numIterations);
		const auto& features                    = context.getDeviceFeatures();
		const auto descriptorIndexingSupported  = context.isDeviceFunctionalitySupported("VK_EXT_descriptor_indexing");
		const auto& indexingFeatures            = context.getDescriptorIndexingFeatures();

		for (const auto& descType : usedDescriptorTypes)
		{
			switch (descType)
			{
			case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
			case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
				if (!features.shaderUniformBufferArrayDynamicIndexing)
					TCU_THROW(NotSupportedError, "Dynamic indexing not supported for uniform buffers");
				break;

			case VK_DESCRIPTOR_TYPE_SAMPLER:
			case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
			case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
				if (!features.shaderSampledImageArrayDynamicIndexing)
					TCU_THROW(NotSupportedError, "Dynamic indexing not supported for samplers and sampled images");
				break;

			case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
				if (!features.shaderStorageImageArrayDynamicIndexing)
					TCU_THROW(NotSupportedError, "Dynamic indexing not supported for storage images");
				break;

			case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
			case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
				if (!features.shaderStorageBufferArrayDynamicIndexing)
					TCU_THROW(NotSupportedError, "Dynamic indexing not supported for storage buffers");
				break;

			case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
				if (!descriptorIndexingSupported || !indexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing)
					TCU_THROW(NotSupportedError, "Dynamic indexing not supported for uniform texel buffers");
				break;

			case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
				if (!descriptorIndexingSupported || !indexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing)
					TCU_THROW(NotSupportedError, "Dynamic indexing not supported for storage texel buffers");
				break;

			case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
				if (!descriptorIndexingSupported || !indexingFeatures.shaderInputAttachmentArrayDynamicIndexing)
					TCU_THROW(NotSupportedError, "Dynamic indexing not supported for input attachments");
				break;

			case VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR:
				context.requireDeviceFunctionality("VK_KHR_acceleration_structure");
				break;

			case VK_DESCRIPTOR_TYPE_MUTABLE_VALVE:
				TCU_THROW(InternalError, "Found VK_DESCRIPTOR_TYPE_MUTABLE_VALVE in list of used array descriptor types");

			default:
				TCU_THROW(InternalError, "Unexpected descriptor type found in list of used descriptor types: " + de::toString(descType));
			}
		}
	}

	// Check layout support.
	{
		const auto& vkd               = context.getDeviceInterface();
		const auto  device            = context.getDevice();
		const auto  stageFlags        = m_params.getStageFlags();

		{
			const auto  layoutCreateFlags = m_params.getDstLayoutCreateFlags();
			const auto  supported         = m_params.descriptorSet->checkDescriptorSetLayout(vkd, device, stageFlags, layoutCreateFlags);

			if (!supported)
				TCU_THROW(NotSupportedError, "Required descriptor set layout not supported");
		}

		if (m_params.updateType == UpdateType::COPY)
		{
			const auto  layoutCreateFlags = m_params.getSrcLayoutCreateFlags();
			const auto  supported         = m_params.descriptorSet->checkDescriptorSetLayout(vkd, device, stageFlags, layoutCreateFlags);

			if (!supported)
				TCU_THROW(NotSupportedError, "Required descriptor set layout for source set not supported");

			// Check specific layouts for the different source sets are supported.
			for (deUint32 iter = 0u; iter < numIterations; ++iter)
			{
				const auto srcSet             = m_params.descriptorSet->genSourceSet(m_params.sourceSetStrategy, iter);
				const auto srcLayoutSupported = srcSet->checkDescriptorSetLayout(vkd, device, stageFlags, layoutCreateFlags);

				if (!srcLayoutSupported)
					TCU_THROW(NotSupportedError, "Descriptor set layout for source set at iteration " + de::toString(iter) + " not supported");
			}
		}
	}

	// Check supported stores and stages.
	const bool vertexStage   = isVertexStage(m_params.testingStage);
	const bool fragmentStage = (m_params.testingStage == TestingStage::FRAGMENT);
	const bool geometryStage = (m_params.testingStage == TestingStage::GEOMETRY);
	const bool tessellation  = (m_params.testingStage == TestingStage::TESS_CONTROL || m_params.testingStage == TestingStage::TESS_EVAL);

	const auto& features = context.getDeviceFeatures();

	if (vertexStage && !features.vertexPipelineStoresAndAtomics)
		TCU_THROW(NotSupportedError, "Vertex pipeline stores and atomics not supported");

	if (fragmentStage && !features.fragmentStoresAndAtomics)
		TCU_THROW(NotSupportedError, "Fragment shader stores and atomics not supported");

	if (geometryStage && !features.geometryShader)
		TCU_THROW(NotSupportedError, "Geometry shader not supported");

	if (tessellation && !features.tessellationShader)
		TCU_THROW(NotSupportedError, "Tessellation shaders not supported");
}

// What to do at each iteration step. Used to apply UPDATE_AFTER_BIND or not.
enum class Step
{
	UPDATE = 0,
	BIND,
};

// Create render pass.
Move<VkRenderPass> buildRenderPass (const DeviceInterface& vkd, VkDevice device, const std::vector<Resource>& resources)
{
	const auto imageFormat = getDescriptorImageFormat();

	std::vector<VkAttachmentDescription>    attachmentDescriptions;
	std::vector<VkAttachmentReference>      attachmentReferences;
	std::vector<deUint32>                   attachmentIndices;

	for (const auto& resource : resources)
	{
		if (resource.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
		{
			const auto nextIndex = static_cast<deUint32>(attachmentDescriptions.size());

			const VkAttachmentDescription description = {
				0u,                                 //  VkAttachmentDescriptionFlags	flags;
				imageFormat,                        //  VkFormat						format;
				VK_SAMPLE_COUNT_1_BIT,              //  VkSampleCountFlagBits			samples;
				VK_ATTACHMENT_LOAD_OP_LOAD,         //  VkAttachmentLoadOp				loadOp;
				VK_ATTACHMENT_STORE_OP_DONT_CARE,   //  VkAttachmentStoreOp				storeOp;
				VK_ATTACHMENT_LOAD_OP_DONT_CARE,    //  VkAttachmentLoadOp				stencilLoadOp;
				VK_ATTACHMENT_STORE_OP_DONT_CARE,   //  VkAttachmentStoreOp				stencilStoreOp;
				VK_IMAGE_LAYOUT_GENERAL,            //  VkImageLayout					initialLayout;
				VK_IMAGE_LAYOUT_GENERAL,            //  VkImageLayout					finalLayout;
			};

			const VkAttachmentReference reference = { nextIndex, VK_IMAGE_LAYOUT_GENERAL };

			attachmentIndices.push_back(nextIndex);
			attachmentDescriptions.push_back(description);
			attachmentReferences.push_back(reference);
		}
	}

	const auto attachmentCount = static_cast<deUint32>(attachmentDescriptions.size());
	DE_ASSERT(attachmentCount == static_cast<deUint32>(attachmentIndices.size()));
	DE_ASSERT(attachmentCount == static_cast<deUint32>(attachmentReferences.size()));

	const VkSubpassDescription subpassDescription =
	{
		0u,                                     //  VkSubpassDescriptionFlags		flags;
		VK_PIPELINE_BIND_POINT_GRAPHICS,        //  VkPipelineBindPoint				pipelineBindPoint;
		attachmentCount,                        //  deUint32						inputAttachmentCount;
		de::dataOrNull(attachmentReferences),   //  const VkAttachmentReference*	pInputAttachments;
		0u,                                     //  deUint32						colorAttachmentCount;
		nullptr,                                //  const VkAttachmentReference*	pColorAttachments;
		0u,                                     //  const VkAttachmentReference*	pResolveAttachments;
		nullptr,                                //  const VkAttachmentReference*	pDepthStencilAttachment;
		0u,                                     //  deUint32						preserveAttachmentCount;
		nullptr,                                //  const deUint32*					pPreserveAttachments;
	};

	const VkRenderPassCreateInfo renderPassCreateInfo =
	{
		VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,              //  VkStructureType					sType;
		nullptr,                                                //  const void*						pNext;
		0u,                                                     //  VkRenderPassCreateFlags			flags;
		static_cast<deUint32>(attachmentDescriptions.size()),   //  deUint32						attachmentCount;
		de::dataOrNull(attachmentDescriptions),                 //  const VkAttachmentDescription*	pAttachments;
		1u,                                                     //  deUint32						subpassCount;
		&subpassDescription,                                    //  const VkSubpassDescription*		pSubpasses;
		0u,                                                     //  deUint32						dependencyCount;
		nullptr,                                                //  const VkSubpassDependency*		pDependencies;
	};

	return createRenderPass(vkd, device, &renderPassCreateInfo);
}

// Create a graphics pipeline.
Move<VkPipeline> buildGraphicsPipeline (const DeviceInterface& vkd, VkDevice device, VkPipelineLayout pipelineLayout,
										VkShaderModule vertModule,
										VkShaderModule tescModule,
										VkShaderModule teseModule,
										VkShaderModule geomModule,
										VkShaderModule fragModule,
										VkRenderPass renderPass)
{
	const auto                    extent    = getDefaultExtent();
	const std::vector<VkViewport> viewports (1u, makeViewport(extent));
	const std::vector<VkRect2D>   scissors  (1u, makeRect2D(extent));
	const auto                    hasTess   = (tescModule != DE_NULL || teseModule != DE_NULL);
	const auto                    topology  = (hasTess ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);


	const VkPipelineVertexInputStateCreateInfo vertexInputStateCreateInfo = initVulkanStructure();

	const VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo = {
		VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,    //  VkStructureType							sType;
		nullptr,                                                        //  const void*								pNext;
		0u,                                                             //  VkPipelineInputAssemblyStateCreateFlags	flags;
		topology,                                                       //  VkPrimitiveTopology						topology;
		VK_FALSE,                                                       //  VkBool32								primitiveRestartEnable;
	};

	const VkPipelineTessellationStateCreateInfo tessellationStateCreateInfo = {
		VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,  //	VkStructureType							sType;
		nullptr,                                                    //	const void*								pNext;
		0u,                                                         //	VkPipelineTessellationStateCreateFlags	flags;
		(hasTess ? 3u : 0u),                                        //	deUint32								patchControlPoints;
	};

	const VkPipelineViewportStateCreateInfo viewportStateCreateInfo = {
		VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,  //  VkStructureType						sType;
		nullptr,                                                //  const void*							pNext;
		0u,                                                     //  VkPipelineViewportStateCreateFlags	flags;
		static_cast<deUint32>(viewports.size()),                //  deUint32							viewportCount;
		de::dataOrNull(viewports),                              //  const VkViewport*					pViewports;
		static_cast<deUint32>(scissors.size()),                 //  deUint32							scissorCount;
		de::dataOrNull(scissors),                               //  const VkRect2D*						pScissors;
	};

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

	const VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo = {
		VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,   //  VkStructureType							sType;
		nullptr,                                                    //  const void*								pNext;
		0u,                                                         //  VkPipelineMultisampleStateCreateFlags	flags;
		VK_SAMPLE_COUNT_1_BIT,                                      //  VkSampleCountFlagBits					rasterizationSamples;
		VK_FALSE,                                                   //  VkBool32								sampleShadingEnable;
		1.0f,                                                       //  float									minSampleShading;
		nullptr,                                                    //  const VkSampleMask*						pSampleMask;
		VK_FALSE,                                                   //  VkBool32								alphaToCoverageEnable;
		VK_FALSE,                                                   //  VkBool32								alphaToOneEnable;
	};

	const VkPipelineDepthStencilStateCreateInfo depthStencilStateCreateInfo = initVulkanStructure();

	const VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo = initVulkanStructure();

	return makeGraphicsPipeline(vkd, device, pipelineLayout,
	                            vertModule, tescModule, teseModule, geomModule, fragModule,
	                            renderPass, 0u, &vertexInputStateCreateInfo, &inputAssemblyStateCreateInfo,
	                            (hasTess ? &tessellationStateCreateInfo : nullptr), &viewportStateCreateInfo,
								&rasterizationStateCreateInfo, &multisampleStateCreateInfo,
	                            &depthStencilStateCreateInfo, &colorBlendStateCreateInfo, nullptr);
}

Move<VkFramebuffer> buildFramebuffer (const DeviceInterface& vkd, VkDevice device, VkRenderPass renderPass, const std::vector<Resource>& resources)
{
	const auto extent = getDefaultExtent();

	std::vector<VkImageView> inputAttachments;
	for (const auto& resource : resources)
	{
		if (resource.descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
			inputAttachments.push_back(resource.imageView.get());
	}

	const VkFramebufferCreateInfo framebufferCreateInfo =
	{
		VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,		//	VkStructureType				sType;
		nullptr,										//	const void*					pNext;
		0u,												//	VkFramebufferCreateFlags	flags;
		renderPass,										//	VkRenderPass				renderPass;
		static_cast<deUint32>(inputAttachments.size()),	//	deUint32					attachmentCount;
		de:: dataOrNull(inputAttachments),				//	const VkImageView*			pAttachments;
		extent.width,									//	deUint32					width;
		extent.height,									//	deUint32					height;
		extent.depth,									//	deUint32					layers;
	};

	return createFramebuffer(vkd, device, &framebufferCreateInfo);
}

tcu::TestStatus MutableTypesInstance::iterate ()
{
	const auto device  = m_context.getDevice();
	const auto physDev = m_context.getPhysicalDevice();
	const auto qIndex  = m_context.getUniversalQueueFamilyIndex();
	const auto queue   = m_context.getUniversalQueue();

	const auto& vki      = m_context.getInstanceInterface();
	const auto& vkd      = m_context.getDeviceInterface();
	auto      & alloc    = m_context.getDefaultAllocator();
	const auto& paramSet = m_params.descriptorSet;

	const auto numIterations      = paramSet->maxTypes();
	const bool useExternalImage   = needsExternalImage(*m_params.descriptorSet);
	const bool useExternalSampler = needsExternalSampler(*m_params.descriptorSet);
	const auto stageFlags         = m_params.getStageFlags();
	const bool srcSetNeeded       = (m_params.updateType == UpdateType::COPY);
	const bool updateAfterBind    = (m_params.updateMoment == UpdateMoment::UPDATE_AFTER_BIND);
	const auto bindPoint          = m_params.getBindPoint();
	const bool rayTracing         = isRayTracingStage(m_params.testingStage);
	const bool useAABBs           = (m_params.testingStage == TestingStage::INTERSECTION);

	// Resources for each iteration.
	std::vector<std::vector<Resource>> allResources;
	allResources.reserve(numIterations);

	// Command pool.
	const auto cmdPool = makeCommandPool(vkd, device, qIndex);

	// Descriptor pool and set for the active (dst) descriptor set.
	const auto dstPoolFlags   = m_params.getDstPoolCreateFlags();
	const auto dstLayoutFlags = m_params.getDstLayoutCreateFlags();

	const auto dstPool   = paramSet->makeDescriptorPool(vkd, device, m_params.poolMutableStrategy, dstPoolFlags);
	const auto dstLayout = paramSet->makeDescriptorSetLayout(vkd, device, stageFlags, dstLayoutFlags);
	const auto varCount  = paramSet->getVariableDescriptorCount();

	using VariableCountInfoPtr = de::MovePtr<VkDescriptorSetVariableDescriptorCountAllocateInfo>;

	VariableCountInfoPtr dstVariableCountInfo;
	if (varCount)
	{
		dstVariableCountInfo = VariableCountInfoPtr(new VkDescriptorSetVariableDescriptorCountAllocateInfo);
		*dstVariableCountInfo = initVulkanStructure();

		dstVariableCountInfo->descriptorSetCount = 1u;
		dstVariableCountInfo->pDescriptorCounts  = &(varCount.get());
	}
	const auto dstSet = makeDescriptorSet(vkd, device, dstPool.get(), dstLayout.get(), dstVariableCountInfo.get());

	// Source pool and set (optional).
	const auto                  srcPoolFlags   = m_params.getSrcPoolCreateFlags();
	const auto                  srcLayoutFlags = m_params.getSrcLayoutCreateFlags();
	DescriptorSetPtr            iterationSrcSet;
	Move<VkDescriptorPool>      srcPool;
	Move<VkDescriptorSetLayout> srcLayout;
	Move<VkDescriptorSet>       srcSet;

	// Extra set for external resources and output buffer.
	std::vector<Resource> extraResources;
	extraResources.emplace_back(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vkd, device, alloc, qIndex, queue, useAABBs, 0u, numIterations);
	if (useExternalImage)
		extraResources.emplace_back(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, vkd, device, alloc, qIndex, queue, useAABBs, getExternalSampledImageValue());
	if (useExternalSampler)
		extraResources.emplace_back(VK_DESCRIPTOR_TYPE_SAMPLER, vkd, device, alloc, qIndex, queue, useAABBs, 0u);
	if (rayTracing)
		extraResources.emplace_back(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, vkd, device, alloc, qIndex, queue, useAABBs, 0u);

	Move<VkDescriptorPool> extraPool;
	{
		DescriptorPoolBuilder poolBuilder;
		poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
		if (useExternalImage)
			poolBuilder.addType(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE);
		if (useExternalSampler)
			poolBuilder.addType(VK_DESCRIPTOR_TYPE_SAMPLER);
		if (rayTracing)
			poolBuilder.addType(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR);
		extraPool = poolBuilder.build(vkd, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);
	}

	Move<VkDescriptorSetLayout> extraLayout;
	{
		DescriptorSetLayoutBuilder layoutBuilder;
		layoutBuilder.addBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u, stageFlags, nullptr);
		if (useExternalImage)
			layoutBuilder.addBinding(VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1u, stageFlags, nullptr);
		if (useExternalSampler)
			layoutBuilder.addBinding(VK_DESCRIPTOR_TYPE_SAMPLER, 1u, stageFlags, nullptr);
		if (rayTracing)
		{
			// The extra acceleration structure is used from the ray generation shader only.
			layoutBuilder.addBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1u, VK_SHADER_STAGE_RAYGEN_BIT_KHR, nullptr);
		}
		extraLayout = layoutBuilder.build(vkd, device);
	}

	const auto extraSet = makeDescriptorSet(vkd, device, extraPool.get(), extraLayout.get());

	// Update extra set.
	using DescriptorBufferInfoPtr = de::MovePtr<VkDescriptorBufferInfo>;
	using DescriptorImageInfoPtr  = de::MovePtr<VkDescriptorImageInfo>;
	using DescriptorASInfoPtr     = de::MovePtr<VkWriteDescriptorSetAccelerationStructureKHR>;

	deUint32                bindingCount = 0u;
	DescriptorBufferInfoPtr bufferInfoPtr;
	DescriptorImageInfoPtr  imageInfoPtr;
	DescriptorImageInfoPtr  samplerInfoPtr;
	DescriptorASInfoPtr     asWriteInfoPtr;

    const auto outputBufferSize = static_cast<VkDeviceSize>(sizeof(deUint32) * static_cast<size_t>(numIterations));
	bufferInfoPtr = DescriptorBufferInfoPtr(new VkDescriptorBufferInfo(makeDescriptorBufferInfo(extraResources[bindingCount++].bufferWithMemory->get(), 0ull, outputBufferSize)));
	if (useExternalImage)
		imageInfoPtr = DescriptorImageInfoPtr(new VkDescriptorImageInfo(makeDescriptorImageInfo(DE_NULL, extraResources[bindingCount++].imageView.get(), VK_IMAGE_LAYOUT_GENERAL)));
	if (useExternalSampler)
		samplerInfoPtr = DescriptorImageInfoPtr(new VkDescriptorImageInfo(makeDescriptorImageInfo(extraResources[bindingCount++].sampler.get(), DE_NULL, VK_IMAGE_LAYOUT_GENERAL)));
	if (rayTracing)
	{
		asWriteInfoPtr = DescriptorASInfoPtr(new VkWriteDescriptorSetAccelerationStructureKHR);
		*asWriteInfoPtr = initVulkanStructure();
		asWriteInfoPtr->accelerationStructureCount  = 1u;
		asWriteInfoPtr->pAccelerationStructures     = extraResources[bindingCount++].asData.tlas.get()->getPtr();
	}

	{
		bindingCount = 0u;
		DescriptorSetUpdateBuilder updateBuilder;
		updateBuilder.writeSingle(extraSet.get(), DescriptorSetUpdateBuilder::Location::binding(bindingCount++), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, bufferInfoPtr.get());
		if (useExternalImage)
			updateBuilder.writeSingle(extraSet.get(), DescriptorSetUpdateBuilder::Location::binding(bindingCount++), VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, imageInfoPtr.get());
		if (useExternalSampler)
			updateBuilder.writeSingle(extraSet.get(), DescriptorSetUpdateBuilder::Location::binding(bindingCount++), VK_DESCRIPTOR_TYPE_SAMPLER, samplerInfoPtr.get());
		if (rayTracing)
			updateBuilder.writeSingle(extraSet.get(), DescriptorSetUpdateBuilder::Location::binding(bindingCount++), VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, asWriteInfoPtr.get());
		updateBuilder.update(vkd, device);
	}

	// Push constants.
	const deUint32            zero    = 0u;
	const VkPushConstantRange pcRange = {stageFlags, 0u /*offset*/, static_cast<deUint32>(sizeof(zero)) /*size*/ };

	// Needed for some test variants.
	Move<VkShaderModule> vertPassthrough;
	Move<VkShaderModule> tesePassthrough;
	Move<VkShaderModule> tescPassthrough;
	Move<VkShaderModule> rgenPassthrough;
	Move<VkShaderModule> missPassthrough;

	if (m_params.testingStage == TestingStage::FRAGMENT
		|| m_params.testingStage == TestingStage::GEOMETRY
		|| m_params.testingStage == TestingStage::TESS_CONTROL
		|| m_params.testingStage == TestingStage::TESS_EVAL)
	{
		vertPassthrough = createShaderModule(vkd, device, m_context.getBinaryCollection().get("vert"), 0u);
	}

	if (m_params.testingStage == TestingStage::TESS_CONTROL)
	{
		tesePassthrough = createShaderModule(vkd, device, m_context.getBinaryCollection().get("tese"), 0u);
	}

	if (m_params.testingStage == TestingStage::TESS_EVAL)
	{
		tescPassthrough = createShaderModule(vkd, device, m_context.getBinaryCollection().get("tesc"), 0u);
	}

	if (m_params.testingStage == TestingStage::CLOSEST_HIT
		|| m_params.testingStage == TestingStage::ANY_HIT
		|| m_params.testingStage == TestingStage::INTERSECTION
		|| m_params.testingStage == TestingStage::MISS
		|| m_params.testingStage == TestingStage::CALLABLE)
	{
		rgenPassthrough = createShaderModule(vkd, device, m_context.getBinaryCollection().get("rgen"), 0u);
	}

	if (m_params.testingStage == TestingStage::INTERSECTION)
	{
		missPassthrough = createShaderModule(vkd, device, m_context.getBinaryCollection().get("miss"), 0u);
	}

	for (deUint32 iteration = 0u; iteration < numIterations; ++iteration)
	{
		// Generate source set for the current iteration.
		if (srcSetNeeded)
		{
			// Free previous descriptor set before rebuilding the pool.
			srcSet          = Move<VkDescriptorSet>();
			iterationSrcSet = paramSet->genSourceSet(m_params.sourceSetStrategy, iteration);
			srcPool         = iterationSrcSet->makeDescriptorPool(vkd, device, m_params.poolMutableStrategy, srcPoolFlags);
			srcLayout       = iterationSrcSet->makeDescriptorSetLayout(vkd, device, stageFlags, srcLayoutFlags);

			const auto srcVarCount = iterationSrcSet->getVariableDescriptorCount();
			VariableCountInfoPtr srcVariableCountInfo;

			if (srcVarCount)
			{
				srcVariableCountInfo = VariableCountInfoPtr(new VkDescriptorSetVariableDescriptorCountAllocateInfo);
				*srcVariableCountInfo = initVulkanStructure();

				srcVariableCountInfo->descriptorSetCount = 1u;
				srcVariableCountInfo->pDescriptorCounts = &(srcVarCount.get());
			}

			srcSet = makeDescriptorSet(vkd, device, srcPool.get(), srcLayout.get(), srcVariableCountInfo.get());
		}

		// Set layouts and sets used in the pipeline.
		const std::vector<VkDescriptorSetLayout> setLayouts = {dstLayout.get(), extraLayout.get()};
		const std::vector<VkDescriptorSet>       usedSets   = {dstSet.get(), extraSet.get()};

		// Create resources.
		allResources.emplace_back(paramSet->createResources(vkd, device, alloc, qIndex, queue, iteration, useAABBs));
		const auto& resources = allResources.back();

		// Make pipeline for the current iteration.
		const auto pipelineLayout = makePipelineLayout(vkd, device, static_cast<deUint32>(setLayouts.size()), de::dataOrNull(setLayouts), 1u, &pcRange);
		const auto moduleName     = shaderName(iteration);
		const auto shaderModule   = createShaderModule(vkd, device, m_context.getBinaryCollection().get(moduleName), 0u);

		Move<VkPipeline>     pipeline;
		Move<VkRenderPass>   renderPass;
		Move<VkFramebuffer>  framebuffer;

		deUint32 shaderGroupHandleSize		= 0u;
		deUint32 shaderGroupBaseAlignment	= 1u;

		de::MovePtr<BufferWithMemory>	raygenSBT;
		de::MovePtr<BufferWithMemory>	missSBT;
		de::MovePtr<BufferWithMemory>	hitSBT;
		de::MovePtr<BufferWithMemory>	callableSBT;

		VkStridedDeviceAddressRegionKHR	raygenSBTRegion		= makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0);
		VkStridedDeviceAddressRegionKHR	missSBTRegion		= makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0);
		VkStridedDeviceAddressRegionKHR	hitSBTRegion		= makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0);
		VkStridedDeviceAddressRegionKHR	callableSBTRegion	= makeStridedDeviceAddressRegionKHR(DE_NULL, 0, 0);

		if (bindPoint == VK_PIPELINE_BIND_POINT_COMPUTE)
			pipeline = makeComputePipeline(vkd, device, pipelineLayout.get(), 0u, shaderModule.get(), 0u, nullptr);
		else if (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
		{
			VkShaderModule vertModule = DE_NULL;
			VkShaderModule teseModule = DE_NULL;
			VkShaderModule tescModule = DE_NULL;
			VkShaderModule geomModule = DE_NULL;
			VkShaderModule fragModule = DE_NULL;

			if (m_params.testingStage == TestingStage::VERTEX)
				vertModule = shaderModule.get();
			else if (m_params.testingStage == TestingStage::FRAGMENT)
			{
				vertModule = vertPassthrough.get();
				fragModule = shaderModule.get();
			}
			else if (m_params.testingStage == TestingStage::GEOMETRY)
			{
				vertModule = vertPassthrough.get();
				geomModule = shaderModule.get();
			}
			else if (m_params.testingStage == TestingStage::TESS_CONTROL)
			{
				vertModule = vertPassthrough.get();
				teseModule = tesePassthrough.get();
				tescModule = shaderModule.get();
			}
			else if (m_params.testingStage == TestingStage::TESS_EVAL)
			{
				vertModule = vertPassthrough.get();
				tescModule = tescPassthrough.get();
				teseModule = shaderModule.get();
			}
			else
				DE_ASSERT(false);

			renderPass  = buildRenderPass(vkd, device, resources);
			pipeline    = buildGraphicsPipeline(vkd, device, pipelineLayout.get(), vertModule, tescModule, teseModule, geomModule, fragModule, renderPass.get());
			framebuffer = buildFramebuffer(vkd, device, renderPass.get(), resources);
		}
		else if (bindPoint == VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR)
		{
			const auto rayTracingPipeline       = de::newMovePtr<RayTracingPipeline>();
			const auto rayTracingPropertiesKHR	= makeRayTracingProperties(vki, physDev);
			shaderGroupHandleSize				= rayTracingPropertiesKHR->getShaderGroupHandleSize();
			shaderGroupBaseAlignment			= rayTracingPropertiesKHR->getShaderGroupBaseAlignment();

			VkShaderModule rgenModule = DE_NULL;
			VkShaderModule isecModule = DE_NULL;
			VkShaderModule ahitModule = DE_NULL;
			VkShaderModule chitModule = DE_NULL;
			VkShaderModule missModule = DE_NULL;
			VkShaderModule callModule = DE_NULL;

			const deUint32  rgenGroup   = 0u;
			deUint32        hitGroup    = 0u;
			deUint32        missGroup   = 0u;
			deUint32        callGroup   = 0u;

			if (m_params.testingStage == TestingStage::RAY_GEN)
			{
				rgenModule = shaderModule.get();
				rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenModule, rgenGroup);
			}
			else if (m_params.testingStage == TestingStage::INTERSECTION)
			{
				hitGroup   = 1u;
				missGroup  = 2u;
				rgenModule = rgenPassthrough.get();
				missModule = missPassthrough.get();
				isecModule = shaderModule.get();
				rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenModule, rgenGroup);
				rayTracingPipeline->addShader(VK_SHADER_STAGE_INTERSECTION_BIT_KHR, isecModule, hitGroup);
				rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR, missModule, missGroup);
			}
			else if (m_params.testingStage == TestingStage::ANY_HIT)
			{
				hitGroup   = 1u;
				rgenModule = rgenPassthrough.get();
				ahitModule = shaderModule.get();
				rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenModule, rgenGroup);
				rayTracingPipeline->addShader(VK_SHADER_STAGE_ANY_HIT_BIT_KHR, ahitModule, hitGroup);
			}
			else if (m_params.testingStage == TestingStage::CLOSEST_HIT)
			{
				hitGroup   = 1u;
				rgenModule = rgenPassthrough.get();
				chitModule = shaderModule.get();
				rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenModule, rgenGroup);
				rayTracingPipeline->addShader(VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, chitModule, hitGroup);
			}
			else if (m_params.testingStage == TestingStage::MISS)
			{
				missGroup  = 1u;
				rgenModule = rgenPassthrough.get();
				missModule = shaderModule.get();
				rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenModule, rgenGroup);
				rayTracingPipeline->addShader(VK_SHADER_STAGE_MISS_BIT_KHR, missModule, missGroup);
			}
			else if (m_params.testingStage == TestingStage::CALLABLE)
			{
				callGroup  = 1u;
				rgenModule = rgenPassthrough.get();
				callModule = shaderModule.get();
				rayTracingPipeline->addShader(VK_SHADER_STAGE_RAYGEN_BIT_KHR, rgenModule, rgenGroup);
				rayTracingPipeline->addShader(VK_SHADER_STAGE_CALLABLE_BIT_KHR, callModule, callGroup);
			}
			else
				DE_ASSERT(false);

			pipeline = rayTracingPipeline->createPipeline(vkd, device, pipelineLayout.get());

			raygenSBT = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline.get(), alloc, shaderGroupHandleSize, shaderGroupBaseAlignment, rgenGroup, 1u);
			raygenSBTRegion = makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, raygenSBT->get(), 0ull), shaderGroupHandleSize, shaderGroupHandleSize);

			if (missGroup > 0u)
			{
				missSBT = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline.get(), alloc, shaderGroupHandleSize, shaderGroupBaseAlignment, missGroup, 1u);
				missSBTRegion = makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, missSBT->get(), 0ull), shaderGroupHandleSize, shaderGroupHandleSize);
			}

			if (hitGroup > 0u)
			{
				hitSBT = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline.get(), alloc, shaderGroupHandleSize, shaderGroupBaseAlignment, hitGroup, 1u);
				hitSBTRegion = makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, hitSBT->get(), 0ull), shaderGroupHandleSize, shaderGroupHandleSize);
			}

			if (callGroup > 0u)
			{
				callableSBT = rayTracingPipeline->createShaderBindingTable(vkd, device, pipeline.get(), alloc, shaderGroupHandleSize, shaderGroupBaseAlignment, callGroup, 1u);
				callableSBTRegion = makeStridedDeviceAddressRegionKHR(getBufferDeviceAddress(vkd, device, callableSBT->get(), 0ull), shaderGroupHandleSize, shaderGroupHandleSize);
			}
		}
		else
			DE_ASSERT(false);

		// Command buffer for the current iteration.
		const auto cmdBufferPtr = allocateCommandBuffer(vkd, device, cmdPool.get(), VK_COMMAND_BUFFER_LEVEL_PRIMARY);
		const auto cmdBuffer    = cmdBufferPtr.get();

		beginCommandBuffer(vkd, cmdBuffer);

		const Step steps[] = {
			(updateAfterBind ? Step::BIND : Step::UPDATE),
			(updateAfterBind ? Step::UPDATE : Step::BIND)
		};

		for (const auto& step : steps)
		{
			if (step == Step::BIND)
			{
				vkd.cmdBindPipeline(cmdBuffer, bindPoint, pipeline.get());
				vkd.cmdBindDescriptorSets(cmdBuffer, bindPoint, pipelineLayout.get(), 0u, static_cast<deUint32>(usedSets.size()), de::dataOrNull(usedSets), 0u, nullptr);
			}
			else // Step::UPDATE
			{
				if (srcSetNeeded)
				{
					// Note: these operations need to be called on paramSet and not iterationSrcSet. The latter is a compatible set
					// that's correct and contains compatible bindings but, when a binding has been changed from non-mutable to
					// mutable or to an extended mutable type, the list of descriptor types for the mutable bindings in
					// iterationSrcSet are not in iteration order like they are in the original set and must not be taken into
					// account to update or copy sets.
					paramSet->updateDescriptorSet(vkd, device, srcSet.get(), iteration, resources);
					paramSet->copyDescriptorSet(vkd, device, srcSet.get(), dstSet.get());
				}
				else
				{
					paramSet->updateDescriptorSet(vkd, device, dstSet.get(), iteration, resources);
				}
			}
		}

		// Run shader.
		vkd.cmdPushConstants(cmdBuffer, pipelineLayout.get(), stageFlags, 0u, static_cast<deUint32>(sizeof(zero)), &zero);

		if (bindPoint == VK_PIPELINE_BIND_POINT_COMPUTE)
			vkd.cmdDispatch(cmdBuffer, 1u, 1u, 1u);
		else if (bindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS)
		{
			const auto extent     = getDefaultExtent();
			const auto renderArea = makeRect2D(extent);

			beginRenderPass(vkd, cmdBuffer, renderPass.get(), framebuffer.get(), renderArea);
			vkd.cmdDraw(cmdBuffer, 3u, 1u, 0u, 0u);
			endRenderPass(vkd, cmdBuffer);
		}
		else if (bindPoint == VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR)
		{
			vkd.cmdTraceRaysKHR(cmdBuffer, &raygenSBTRegion, &missSBTRegion, &hitSBTRegion, &callableSBTRegion, 1u, 1u, 1u);
		}
		else
			DE_ASSERT(false);

		endCommandBuffer(vkd, cmdBuffer);
		submitCommandsAndWait(vkd, device, queue, cmdBuffer);

		// Verify output buffer.
		{
			const auto outputBufferVal = extraResources[0].getStoredValue(vkd, device, alloc, qIndex, queue, iteration);
			DE_ASSERT(static_cast<bool>(outputBufferVal));

			const auto expectedValue = getExpectedOutputBufferValue();
			if (outputBufferVal.get() != expectedValue)
			{
				std::ostringstream msg;
				msg << "Iteration " << iteration << ": unexpected value found in output buffer (expected " << expectedValue << " and found " << outputBufferVal.get() << ")";
				TCU_FAIL(msg.str());
			}
		}

		// Verify descriptor writes.
		{
			size_t     resourcesOffset = 0;
			const auto writeMask       = getStoredValueMask();
			const auto numBindings     = paramSet->numBindings();

			for (deUint32 bindingIdx = 0u; bindingIdx < numBindings; ++bindingIdx)
			{
				const auto binding = paramSet->getBinding(bindingIdx);
				const auto bindingTypes = binding->typesAtIteration(iteration);

				for (size_t descriptorIdx = 0; descriptorIdx < bindingTypes.size(); ++descriptorIdx)
				{
					const auto& descriptorType = bindingTypes[descriptorIdx];
					if (!isShaderWritable(descriptorType))
						continue;

					const auto& resource        = resources[resourcesOffset + descriptorIdx];
					const auto  initialValue    = resource.initialValue;
					const auto  storedValuePtr  = resource.getStoredValue(vkd, device, alloc, qIndex, queue);

					DE_ASSERT(static_cast<bool>(storedValuePtr));
					const auto storedValue   = storedValuePtr.get();
					const auto expectedValue = (initialValue | writeMask);
					if (expectedValue != storedValue)
					{
						std::ostringstream msg;
						msg << "Iteration " << iteration << ": descriptor at binding " << bindingIdx << " index " << descriptorIdx
						    << " with type " << de::toString(descriptorType) << " contains unexpected value " << std::hex
							<< storedValue << " (expected " << expectedValue << ")";
						TCU_FAIL(msg.str());
					}
				}

				resourcesOffset += bindingTypes.size();
			}
		}
	}

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

using GroupPtr = de::MovePtr<tcu::TestCaseGroup>;

void createMutableTestVariants (tcu::TestContext& testCtx, tcu::TestCaseGroup* parentGroup, const DescriptorSetPtr& descriptorSet, const std::vector<TestingStage>& stagesToTest)
{
	const struct
	{
		UpdateType  updateType;
		const char* name;
	} updateTypes[] = {
		{UpdateType::WRITE, "update_write"},
		{UpdateType::COPY,  "update_copy"},
	};

	const struct
	{
		SourceSetStrategy   sourceSetStrategy;
		const char*         name;
	} sourceStrategies[] = {
		{SourceSetStrategy::MUTABLE,    "mutable_source"},
		{SourceSetStrategy::NONMUTABLE, "nonmutable_source"},
		{SourceSetStrategy::NO_SOURCE,  "no_source"},
	};

	const struct
	{
		SourceSetType   sourceSetType;
		const char*     name;
	} sourceTypes[] = {
		{SourceSetType::NORMAL,    "normal_source"},
		{SourceSetType::HOST_ONLY, "host_only_source"},
		{SourceSetType::NO_SOURCE, "no_source"},
	};

	const struct
	{
		PoolMutableStrategy poolMutableStrategy;
		const char*         name;
	} poolStrategies[] = {
		{PoolMutableStrategy::KEEP_TYPES,   "pool_same_types"},
		{PoolMutableStrategy::NO_TYPES,     "pool_no_types"},
		{PoolMutableStrategy::EXPAND_TYPES, "pool_expand_types"},
	};

	const struct
	{
		UpdateMoment    updateMoment;
		const char*     name;
	} updateMoments[] = {
		{UpdateMoment::NORMAL,            "pre_update"},
		{UpdateMoment::UPDATE_AFTER_BIND, "update_after_bind"},
	};

	const struct
	{
		ArrayAccessType arrayAccessType;
		const char*     name;
	} arrayAccessTypes[] = {
		{ArrayAccessType::CONSTANT,      "index_constant"},
		{ArrayAccessType::PUSH_CONSTANT, "index_push_constant"},
		{ArrayAccessType::NO_ARRAY,      "no_array"},
	};

	const struct StageAndName
	{
		TestingStage    testingStage;
		const char*     name;
	} testStageList[] = {
		{TestingStage::COMPUTE,      "comp"},
		{TestingStage::VERTEX,       "vert"},
		{TestingStage::TESS_CONTROL, "tesc"},
		{TestingStage::TESS_EVAL,    "tese"},
		{TestingStage::GEOMETRY,     "geom"},
		{TestingStage::FRAGMENT,     "frag"},
		{TestingStage::RAY_GEN,      "rgen"},
		{TestingStage::INTERSECTION, "isec"},
		{TestingStage::ANY_HIT,      "ahit"},
		{TestingStage::CLOSEST_HIT,  "chit"},
		{TestingStage::MISS,         "miss"},
		{TestingStage::CALLABLE,     "call"},
	};

	const bool hasArrays           = descriptorSet->hasArrays();
	const bool hasInputAttachments = usesInputAttachments(*descriptorSet);

	for (const auto& ut : updateTypes)
	{
		GroupPtr updateGroup(new tcu::TestCaseGroup(testCtx, ut.name, ""));

		for (const auto& srcStrategy : sourceStrategies)
		{
			// Skip combinations that make no sense.
			if (ut.updateType == UpdateType::WRITE && srcStrategy.sourceSetStrategy != SourceSetStrategy::NO_SOURCE)
				continue;

			if (ut.updateType == UpdateType::COPY && srcStrategy.sourceSetStrategy == SourceSetStrategy::NO_SOURCE)
				continue;

			if (srcStrategy.sourceSetStrategy == SourceSetStrategy::NONMUTABLE && descriptorSet->needsAnyAliasing())
				continue;

			GroupPtr srcStrategyGroup(new tcu::TestCaseGroup(testCtx, srcStrategy.name, ""));

			for (const auto& srcType : sourceTypes)
			{
				// Skip combinations that make no sense.
				if (ut.updateType == UpdateType::WRITE && srcType.sourceSetType != SourceSetType::NO_SOURCE)
					continue;

				if (ut.updateType == UpdateType::COPY && srcType.sourceSetType == SourceSetType::NO_SOURCE)
					continue;

				GroupPtr srcTypeGroup(new tcu::TestCaseGroup(testCtx, srcType.name, ""));

				for (const auto& poolStrategy: poolStrategies)
				{
					GroupPtr poolStrategyGroup(new tcu::TestCaseGroup(testCtx, poolStrategy.name, ""));

					for (const auto& moment : updateMoments)
					{
						//if (moment.updateMoment == UpdateMoment::UPDATE_AFTER_BIND && srcType.sourceSetType == SourceSetType::HOST_ONLY)
						//	continue;

						if (moment.updateMoment == UpdateMoment::UPDATE_AFTER_BIND && hasInputAttachments)
							continue;

						GroupPtr momentGroup(new tcu::TestCaseGroup(testCtx, moment.name, ""));

						for (const auto& accessType : arrayAccessTypes)
						{
							// Skip combinations that make no sense.
							if (hasArrays && accessType.arrayAccessType == ArrayAccessType::NO_ARRAY)
								continue;

							if (!hasArrays && accessType.arrayAccessType != ArrayAccessType::NO_ARRAY)
								continue;

							GroupPtr accessTypeGroup(new tcu::TestCaseGroup(testCtx, accessType.name, ""));

							for (const auto& testStage : stagesToTest)
							{
								const auto beginItr = std::begin(testStageList);
								const auto endItr   = std::end(testStageList);
								const auto iter     = std::find_if(beginItr, endItr, [testStage] (const StageAndName& ts) { return ts.testingStage == testStage; });

								DE_ASSERT(iter != endItr);
								const auto& stage = *iter;

								if (hasInputAttachments && stage.testingStage != TestingStage::FRAGMENT)
									continue;

								TestParams params = {
									descriptorSet,
									ut.updateType,
									srcStrategy.sourceSetStrategy,
									srcType.sourceSetType,
									poolStrategy.poolMutableStrategy,
									moment.updateMoment,
									accessType.arrayAccessType,
									stage.testingStage,
								};

								accessTypeGroup->addChild(new MutableTypesTest(testCtx, stage.name, "", params));
							}

							momentGroup->addChild(accessTypeGroup.release());
						}

						poolStrategyGroup->addChild(momentGroup.release());
					}

					srcTypeGroup->addChild(poolStrategyGroup.release());
				}

				srcStrategyGroup->addChild(srcTypeGroup.release());
			}

			updateGroup->addChild(srcStrategyGroup.release());
		}

		parentGroup->addChild(updateGroup.release());
	}
}

}

std::string descriptorTypeStr (VkDescriptorType descriptorType)
{
	static const auto prefixLen = std::string("VK_DESCRIPTOR_TYPE_").size();
	return de::toLower(de::toString(descriptorType).substr(prefixLen));
}

tcu::TestCaseGroup* createDescriptorValveMutableTests (tcu::TestContext& testCtx)
{
	GroupPtr mainGroup(new tcu::TestCaseGroup(testCtx, "mutable_descriptor", "Tests for VK_VALVE_mutable_descriptor_type"));

	const VkDescriptorType basicDescriptorTypes[] = {
		VK_DESCRIPTOR_TYPE_SAMPLER,
		VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
		VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
		VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
		VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER,
		VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
		VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
		VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
		VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
		VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
	};

	static const auto mandatoryTypes = getMandatoryMutableTypes();

	using StageVec = std::vector<TestingStage>;

	const StageVec allStages =
	{
		TestingStage::COMPUTE,
		TestingStage::VERTEX,
		TestingStage::TESS_CONTROL,
		TestingStage::TESS_EVAL,
		TestingStage::GEOMETRY,
		TestingStage::FRAGMENT,
		TestingStage::RAY_GEN,
		TestingStage::INTERSECTION,
		TestingStage::ANY_HIT,
		TestingStage::CLOSEST_HIT,
		TestingStage::MISS,
		TestingStage::CALLABLE,
	};

	const StageVec reducedStages =
	{
		TestingStage::COMPUTE,
		TestingStage::VERTEX,
		TestingStage::FRAGMENT,
		TestingStage::RAY_GEN,
	};

	const StageVec computeOnly =
	{
		TestingStage::COMPUTE,
	};

	// Basic tests with a single mutable descriptor.
	{
		GroupPtr singleCases(new tcu::TestCaseGroup(testCtx, "single", "Basic mutable descriptor tests with a single mutable descriptor"));

		for (const auto& descriptorType : basicDescriptorTypes)
		{
			const auto                          groupName = descriptorTypeStr(descriptorType);
			const std::vector<VkDescriptorType> actualTypes(1u, descriptorType);

			DescriptorSetPtr setPtr;
			{
				DescriptorSet::BindingPtrVector setBindings;
				setBindings.emplace_back(new SingleBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, actualTypes));
				setPtr = DescriptorSetPtr(new DescriptorSet(setBindings));
			}

			GroupPtr subGroup(new tcu::TestCaseGroup(testCtx, groupName.c_str(), ""));
			createMutableTestVariants(testCtx, subGroup.get(), setPtr, allStages);

			singleCases->addChild(subGroup.release());
		}

		// Case with a single descriptor that iterates several types.
		{
			DescriptorSetPtr setPtr;
			{
				DescriptorSet::BindingPtrVector setBindings;
				setBindings.emplace_back(new SingleBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, mandatoryTypes));
				setPtr = DescriptorSetPtr(new DescriptorSet(setBindings));
			}

			GroupPtr subGroup(new tcu::TestCaseGroup(testCtx, "all_mandatory", ""));
			createMutableTestVariants(testCtx, subGroup.get(), setPtr, reducedStages);

			singleCases->addChild(subGroup.release());
		}

		// Cases that try to verify switching from any descriptor type to any other is possible.
		{
			GroupPtr subGroup(new tcu::TestCaseGroup(testCtx, "switches", "Test switching from one to another descriptor type works as expected"));

			for (const auto& initialDescriptorType : basicDescriptorTypes)
			{
				for (const auto& finalDescriptorType : basicDescriptorTypes)
				{
					if (initialDescriptorType == finalDescriptorType)
						continue;

					const std::vector<VkDescriptorType> mutableTypes { initialDescriptorType, finalDescriptorType };
					DescriptorSet::BindingPtrVector setBindings;
					setBindings.emplace_back(new SingleBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, mutableTypes));

					DescriptorSetPtr setPtr = DescriptorSetPtr(new DescriptorSet(setBindings));

					const auto groupName = descriptorTypeStr(initialDescriptorType) + "_" + descriptorTypeStr(finalDescriptorType);
					GroupPtr combinationGroup(new tcu::TestCaseGroup(testCtx, groupName.c_str(), ""));
					createMutableTestVariants(testCtx, combinationGroup.get(), setPtr, reducedStages);
					subGroup->addChild(combinationGroup.release());
				}
			}

			singleCases->addChild(subGroup.release());
		}

		mainGroup->addChild(singleCases.release());
	}

	// Cases with a single non-mutable descriptor. This provides some basic checks to verify copying to non-mutable bindings works.
	{
		GroupPtr singleNonMutableGroup (new tcu::TestCaseGroup(testCtx, "single_nonmutable", "Tests using a single non-mutable descriptor"));

		for (const auto& descriptorType : basicDescriptorTypes)
		{
			DescriptorSet::BindingPtrVector bindings;
			bindings.emplace_back(new SingleBinding(descriptorType, std::vector<VkDescriptorType>()));
			DescriptorSetPtr descriptorSet (new DescriptorSet(bindings));

			const auto groupName = descriptorTypeStr(descriptorType);
			GroupPtr descGroup (new tcu::TestCaseGroup(testCtx, groupName.c_str(), ""));

			createMutableTestVariants(testCtx, descGroup.get(), descriptorSet, reducedStages);
			singleNonMutableGroup->addChild(descGroup.release());
		}

		mainGroup->addChild(singleNonMutableGroup.release());
	}

	const struct {
		bool unbounded;
		const char* name;
	} unboundedCases[] = {
		{false, "constant_size"},
		{true,  "unbounded"},
	};

	const struct {
		bool aliasing;
		const char* name;
	} aliasingCases[] = {
		{false, "noaliasing"},
		{true,  "aliasing"},
	};

	const struct {
		bool oneArrayOnly;
		bool mixNonMutable;
		const char* groupName;
		const char* groupDesc;
	} arrayCountGroups[] = {
		{true,  false, "one_array",             "Tests using an array of mutable descriptors"},
		{false, false, "multiple_arrays",       "Tests using multiple arrays of mutable descriptors"},
		{false, true,  "multiple_arrays_mixed", "Tests using multiple arrays of mutable descriptors mixed with arrays of nonmutable ones"},
	};

	for (const auto& variant : arrayCountGroups)
	{
		GroupPtr arrayGroup(new tcu::TestCaseGroup(testCtx, variant.groupName, variant.groupDesc));

		for (const auto& unboundedCase : unboundedCases)
		{
			GroupPtr unboundedGroup(new tcu::TestCaseGroup(testCtx, unboundedCase.name, ""));

			for (const auto& aliasingCase : aliasingCases)
			{
				GroupPtr aliasingGroup(new tcu::TestCaseGroup(testCtx, aliasingCase.name, ""));

				DescriptorSet::BindingPtrVector setBindings;

				// Prepare descriptors for this test variant.
				for (size_t mandatoryTypesRotation = 0; mandatoryTypesRotation < mandatoryTypes.size(); ++mandatoryTypesRotation)
				{
					const bool isLastBinding = (variant.oneArrayOnly || mandatoryTypesRotation == mandatoryTypes.size() - 1u);
					const bool isUnbounded   = (unboundedCase.unbounded && isLastBinding);

					// Create a rotation of the mandatory types for each mutable array binding.
					auto mandatoryTypesVector = mandatoryTypes;
					{
						const auto beginPtr = &mandatoryTypesVector[0];
						const auto endPtr   = beginPtr + mandatoryTypesVector.size();
						std::rotate(beginPtr, &mandatoryTypesVector[mandatoryTypesRotation], endPtr);
					}

					std::vector<SingleBinding> arrayBindings;

					if (aliasingCase.aliasing)
					{
						// With aliasing, the descriptor types rotate in each descriptor.
						for (size_t typeIdx = 0; typeIdx < mandatoryTypesVector.size(); ++typeIdx)
						{
							auto       rotatedTypes = mandatoryTypesVector;
							const auto beginPtr     = &rotatedTypes[0];
							const auto endPtr       = beginPtr + rotatedTypes.size();

							std::rotate(beginPtr, &rotatedTypes[typeIdx], endPtr);

							arrayBindings.emplace_back(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, rotatedTypes);
						}
					}
					else
					{
						// Without aliasing, all descriptors use the same type at the same time.
						const SingleBinding noAliasingBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, mandatoryTypesVector);
						arrayBindings.resize(mandatoryTypesVector.size(), noAliasingBinding);
					}

					setBindings.emplace_back(new ArrayBinding(isUnbounded, arrayBindings));

					if (variant.mixNonMutable && !isUnbounded)
					{
						// Create a non-mutable array binding interleaved with the other ones.
						const SingleBinding nonMutableBinding(mandatoryTypes[mandatoryTypesRotation], std::vector<VkDescriptorType>());
						std::vector<SingleBinding> nonMutableBindings(mandatoryTypes.size(), nonMutableBinding);
						setBindings.emplace_back(new ArrayBinding(false, nonMutableBindings));
					}

					if (variant.oneArrayOnly)
						break;
				}

				DescriptorSetPtr descriptorSet(new DescriptorSet(setBindings));
				createMutableTestVariants(testCtx, aliasingGroup.get(), descriptorSet, computeOnly);

				unboundedGroup->addChild(aliasingGroup.release());
			}

			arrayGroup->addChild(unboundedGroup.release());
		}

		mainGroup->addChild(arrayGroup.release());
	}

	// Cases with a single mutable binding followed by an array of mutable bindings.
	// The array will use a single type beyond the mandatory ones.
	{
		GroupPtr singleAndArrayGroup(new tcu::TestCaseGroup(testCtx, "single_and_array", "Tests using a single mutable binding followed by a mutable array binding"));

		for (const auto& descriptorType : basicDescriptorTypes)
		{
			// Input attachments will not use arrays.
			if (descriptorType == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
				continue;

			if (de::contains(begin(mandatoryTypes), end(mandatoryTypes), descriptorType))
				continue;

			const auto groupName = descriptorTypeStr(descriptorType);
			GroupPtr descTypeGroup(new tcu::TestCaseGroup(testCtx, groupName.c_str(), ""));

			for (const auto& aliasingCase : aliasingCases)
			{
				GroupPtr aliasingGroup(new tcu::TestCaseGroup(testCtx, aliasingCase.name, ""));

				DescriptorSet::BindingPtrVector setBindings;
				std::vector<SingleBinding> arrayBindings;

				// Single mutable descriptor as the first binding.
				setBindings.emplace_back(new SingleBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, mandatoryTypes));

				// Descriptor array as the second binding.
				auto arrayBindingDescTypes = mandatoryTypes;
				arrayBindingDescTypes.push_back(descriptorType);

				if (aliasingCase.aliasing)
				{
					// With aliasing, the descriptor types rotate in each descriptor.
					for (size_t typeIdx = 0; typeIdx < arrayBindingDescTypes.size(); ++typeIdx)
					{
						auto       rotatedTypes = arrayBindingDescTypes;
						const auto beginPtr     = &rotatedTypes[0];
						const auto endPtr       = beginPtr + rotatedTypes.size();

						std::rotate(beginPtr, &rotatedTypes[typeIdx], endPtr);

						arrayBindings.emplace_back(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, rotatedTypes);
					}
				}
				else
				{
					// Without aliasing, all descriptors use the same type at the same time.
					const SingleBinding noAliasingBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, arrayBindingDescTypes);
					arrayBindings.resize(arrayBindingDescTypes.size(), noAliasingBinding);
				}

				// Second binding: array binding.
				setBindings.emplace_back(new ArrayBinding(false/*unbounded*/, arrayBindings));

				// Create set and test variants.
				DescriptorSetPtr descriptorSet(new DescriptorSet(setBindings));
				createMutableTestVariants(testCtx, aliasingGroup.get(), descriptorSet, computeOnly);

				descTypeGroup->addChild(aliasingGroup.release());
			}

			singleAndArrayGroup->addChild(descTypeGroup.release());
		}

		mainGroup->addChild(singleAndArrayGroup.release());
	}

	// Cases with several mutable non-array bindings.
	{
		GroupPtr multipleGroup    (new tcu::TestCaseGroup(testCtx, "multiple", "Tests using multiple mutable bindings"));
		GroupPtr mutableOnlyGroup (new tcu::TestCaseGroup(testCtx, "mutable_only", "Tests using only mutable descriptors"));
		GroupPtr mixedGroup       (new tcu::TestCaseGroup(testCtx, "mixed", "Tests mixing mutable descriptors an non-mutable descriptors"));

		// Each descriptor will have a different type in every iteration, like in the one_array aliasing case.
		for (int groupIdx = 0; groupIdx < 2; ++groupIdx)
		{
			const bool mixed = (groupIdx == 1);
			DescriptorSet::BindingPtrVector setBindings;

			for (size_t typeIdx = 0; typeIdx < mandatoryTypes.size(); ++typeIdx)
			{
				auto       rotatedTypes = mandatoryTypes;
				const auto beginPtr     = &rotatedTypes[0];
				const auto endPtr       = beginPtr + rotatedTypes.size();

				std::rotate(beginPtr, &rotatedTypes[typeIdx], endPtr);
				setBindings.emplace_back(new SingleBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, rotatedTypes));

				// Additional non-mutable binding interleaved with the mutable ones.
				if (mixed)
					setBindings.emplace_back(new SingleBinding(rotatedTypes[0], std::vector<VkDescriptorType>()));
			}
			DescriptorSetPtr descriptorSet(new DescriptorSet(setBindings));

			const auto dstGroup = (mixed ? mixedGroup.get() : mutableOnlyGroup.get());
			createMutableTestVariants(testCtx, dstGroup, descriptorSet, computeOnly);
		}

		multipleGroup->addChild(mutableOnlyGroup.release());
		multipleGroup->addChild(mixedGroup.release());
		mainGroup->addChild(multipleGroup.release());
	}

	return mainGroup.release();
}

} // BindingModel
} // vkt