/*-------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2018 Google Inc.
 *
 * 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 descriptor updates.
 *//*--------------------------------------------------------------------*/

#include "vktBindingDescriptorUpdateTests.hpp"
#ifndef CTS_USES_VULKANSC
#include "vktBindingDescriptorUpdateASTests.hpp"
#endif // CTS_USES_VULKANSC

#include "vktTestCase.hpp"
#include "vktTestCaseUtil.hpp"

#include "vkRefUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkObjUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkBarrierUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vkBufferWithMemory.hpp"

#include "tcuTexture.hpp"
#include "tcuTestLog.hpp"

#include "deRandom.hpp"

#include <string>
#include <vector>
#include <utility>
#include <memory>
#include <math.h>

namespace vkt
{
namespace BindingModel
{
namespace
{

// Test matches VkPositiveLayerTest.EmptyDescriptorUpdateTest
tcu::TestStatus EmptyDescriptorUpdateCase (Context& context)
{
	const vk::DeviceInterface&				vki					= context.getDeviceInterface();
	const vk::VkDevice						device				= context.getDevice();
	vk::Allocator&							allocator			= context.getDefaultAllocator();

	// Create layout with two uniform buffer descriptors w/ empty binding between them
	vk::DescriptorSetLayoutBuilder			builder;

	builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_ALL);
	builder.addBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, (vk::VkShaderStageFlags)0, DE_NULL);
	builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_ALL);

	vk::Unique<vk::VkDescriptorSetLayout>	layout				(builder.build(vki, device, (vk::VkDescriptorSetLayoutCreateFlags)0));

	// Create descriptor pool
	vk::Unique<vk::VkDescriptorPool>		descriptorPool		(vk::DescriptorPoolBuilder().addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2).build(vki, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1));

	// Create descriptor set
	const vk::VkDescriptorSetAllocateInfo	setAllocateInfo		=
	{
		vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,	// VkStructureType				sType
		DE_NULL,											// const void*					pNext
		*descriptorPool,									// VkDescriptorPool				descriptorPool
		1,													// deUint32						descriptorSetCount
		&layout.get()										// const VkDescriptorSetLayout*	pSetLayouts
	};

	vk::Unique<vk::VkDescriptorSet>			descriptorSet		(allocateDescriptorSet(vki, device, &setAllocateInfo));

	// Create a buffer to be used for update
	const vk::VkBufferCreateInfo			bufferCreateInfo	=
	{
		vk::VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,	// VkStructureType		sType
		DE_NULL,									// const void*			pNext
		(vk::VkBufferCreateFlags)DE_NULL,			// VkBufferCreateFlags	flags
		256,										// VkDeviceSize			size
		vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,		// VkBufferUsageFlags	usage
		vk::VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode		sharingMode
		0,											// deUint32				queueFamilyIndexCount
		DE_NULL										// const deUint32*		pQueueFamilyIndices
	};

	vk::Unique<vk::VkBuffer>				buffer				(createBuffer(vki, device, &bufferCreateInfo));
	const vk::VkMemoryRequirements			requirements		= vk::getBufferMemoryRequirements(vki, device, *buffer);
	de::MovePtr<vk::Allocation>				allocation			= allocator.allocate(requirements, vk::MemoryRequirement::Any);

	VK_CHECK(vki.bindBufferMemory(device, *buffer, allocation->getMemory(), allocation->getOffset()));

	// Only update the descriptor at binding 2
	const vk::VkDescriptorBufferInfo		descriptorInfo		=
	{
		*buffer,		// VkBuffer		buffer
		0,				// VkDeviceSize	offset
		VK_WHOLE_SIZE	// VkDeviceSize	range
	};

	const vk::VkWriteDescriptorSet			descriptorWrite		=
	{
		vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,	// VkStructureTypes					Type
		DE_NULL,									// const void*						pNext
		*descriptorSet,								// VkDescriptorSet					dstSet
		2,											// deUint32							dstBinding
		0,											// deUint32							dstArrayElement
		1,											// deUint32							descriptorCount
		vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,		// VkDescriptorType					descriptorType
		DE_NULL,									// const VkDescriptorImageInfo*		pImageInfo
		&descriptorInfo,							// const VkDescriptorBufferInfo*	pBufferInfo
		DE_NULL										// const VkBufferView*				pTexelBufferView
	};

	vki.updateDescriptorSets(device, 1, &descriptorWrite, 0, DE_NULL);

	// Test should always pass
	return tcu::TestStatus::pass("Pass");
}


tcu::TestCaseGroup* createEmptyDescriptorUpdateTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "empty_descriptor", "Update last descriptor in a set that includes an empty binding"));

	addFunctionCase(group.get(), "uniform_buffer", "", EmptyDescriptorUpdateCase);

	return group.release();
}

enum class PointerCase
{
	ZERO = 0,
	ONE,
	DESTROYED,
};

struct SamplerlessParams
{
	vk::VkDescriptorType	type;
	PointerCase				pointer;
	deUint32				descriptorSet;
};

class SamplerlessDescriptorWriteTestCase : public vkt::TestCase
{
public:
								SamplerlessDescriptorWriteTestCase	(tcu::TestContext& testCtx, const std::string& name, const std::string& description, const SamplerlessParams& params);
	virtual						~SamplerlessDescriptorWriteTestCase	(void) {}

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

	vk::VkFormatFeatureFlagBits	getMainImageFeature					(void) const;

	static const vk::VkFormat	kImageFormat						= vk::VK_FORMAT_R8G8B8A8_UNORM;
private:
	SamplerlessParams			m_params;
};

class SamplerlessDescriptorWriteTestInstance : public vkt::TestInstance
{
public:
								SamplerlessDescriptorWriteTestInstance	(Context& context, const SamplerlessParams& params);
	virtual						~SamplerlessDescriptorWriteTestInstance	(void) {}

	vk::VkSampler				getSamplerHandle						(void) const;
	virtual tcu::TestStatus		iterate									(void);

	vk::VkExtent3D				getMainImageExtent						(void) const;
	vk::VkImageUsageFlags		getMainImageUsage						(void) const;
	vk::VkImageLayout			getMainImageShaderLayout				(void) const;

	static const vk::VkFormat	kImageFormat							= SamplerlessDescriptorWriteTestCase::kImageFormat;
	static const vk::VkExtent3D	kFramebufferExtent;
	static const vk::VkExtent3D	kMinimumExtent;
	static const tcu::Vec4		kDescriptorColor;
private:
	SamplerlessParams			m_params;
};

const vk::VkExtent3D	SamplerlessDescriptorWriteTestInstance::kFramebufferExtent	= vk::makeExtent3D(64u, 64u, 1u);
const vk::VkExtent3D	SamplerlessDescriptorWriteTestInstance::kMinimumExtent		= vk::makeExtent3D(1u, 1u, 1u);
const tcu::Vec4			SamplerlessDescriptorWriteTestInstance::kDescriptorColor	{0.0f, 1.0f, 0.0f, 1.0f};

SamplerlessDescriptorWriteTestCase::SamplerlessDescriptorWriteTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description, const SamplerlessParams& params)
	: vkt::TestCase{testCtx, name, description}
	, m_params(params)
{
}

void SamplerlessDescriptorWriteTestCase::initPrograms (vk::SourceCollections& programCollection) const
{
	const std::string vertexShader =
		"#version 450\n"
		"layout(location=0) in vec4 position;\n"
		"void main() { gl_Position = position; }\n";

	programCollection.glslSources.add("vert") << glu::VertexSource(vertexShader);

	std::string descriptorDecl;
	std::string readOp;
	std::string extensions;

	switch (m_params.type)
	{
	case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
		extensions		= "#extension GL_EXT_samplerless_texture_functions : require\n";
		descriptorDecl	= "layout(set=" + std::to_string(m_params.descriptorSet) + ", binding=0) uniform texture2D img;";
		readOp			= "texelFetch(img, ivec2(0, 0), 0)";
		break;
	case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
		descriptorDecl	= "layout(rgba8, set=" + std::to_string(m_params.descriptorSet) + ", binding=0) uniform image2D img;";
		readOp			= "imageLoad(img, ivec2(0, 0))";
		break;
	case vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
		descriptorDecl	= "layout(input_attachment_index=0, set=" + std::to_string(m_params.descriptorSet) + ", binding=0) uniform subpassInput img;";
		readOp			= "subpassLoad(img)";
		break;
	default:
		DE_ASSERT(false);
		break;
	}

	std::ostringstream fragmentShader;

	fragmentShader
		<< "#version 450\n"
		<< extensions
		<< descriptorDecl << "\n"
		<< "layout(location = 0) out vec4 color_out;\n"
		<< "void main()\n"
		<< "{\n"
		<< "    color_out = " << readOp << ";\n"
		<< "}\n"
		;

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

vk::VkFormatFeatureFlagBits SamplerlessDescriptorWriteTestCase::getMainImageFeature (void) const
{
	vk::VkFormatFeatureFlagBits feature = static_cast<vk::VkFormatFeatureFlagBits>(0);

	switch (m_params.type)
	{
	case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:		feature = vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;		break;
	case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:		feature = vk::VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;		break;
	case vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:	feature = vk::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;	break;
	default:
		DE_ASSERT(false);
		break;
	}

	return feature;
}

void SamplerlessDescriptorWriteTestCase::checkSupport (Context& context) const
{
	const auto&	vki				= context.getInstanceInterface();
	const auto	physicalDevice	= context.getPhysicalDevice();
	const auto	mainFeature		= getMainImageFeature();

	const vk::VkFormatFeatureFlags features =
	(
		vk::VK_FORMAT_FEATURE_TRANSFER_DST_BIT		|	// For color clearing.
		vk::VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT	|	// For the separate frame buffer image (uses the same format).
		mainFeature
	);

	const auto props = vk::getPhysicalDeviceFormatProperties(vki, physicalDevice, kImageFormat);
	if ((props.optimalTilingFeatures & features) != features)
		TCU_THROW(NotSupportedError, "Image format does not support the required features");
}

vkt::TestInstance* SamplerlessDescriptorWriteTestCase::createInstance (Context& context) const
{
	return new SamplerlessDescriptorWriteTestInstance{context, m_params};
}

SamplerlessDescriptorWriteTestInstance::SamplerlessDescriptorWriteTestInstance (Context& context, const SamplerlessParams& params)
	: vkt::TestInstance{context}
	, m_params(params)
{
}

struct DestroyedSampler
{
	vk::VkSampler sampler;

	DestroyedSampler (Context& context)
		: sampler{DE_NULL}
	{
		const vk::VkSamplerCreateInfo createInfo =
		{
			vk::VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,		// VkStructureType		sType;
			nullptr,										// const void*			pNext;
			0u,												// VkSamplerCreateFlags	flags;
			vk::VK_FILTER_NEAREST,							// VkFilter				magFilter;
			vk::VK_FILTER_NEAREST,							// VkFilter				minFilter;
			vk::VK_SAMPLER_MIPMAP_MODE_NEAREST,				// VkSamplerMipmapMode	mipmapMode;
			vk::VK_SAMPLER_ADDRESS_MODE_REPEAT,				// VkSamplerAddressMode	addressModeU;
			vk::VK_SAMPLER_ADDRESS_MODE_REPEAT,				// VkSamplerAddressMode	addressModeV;
			vk::VK_SAMPLER_ADDRESS_MODE_REPEAT,				// VkSamplerAddressMode	addressModeW;
			0.0f,											// float				mipLodBias;
			VK_FALSE,										// VkBool32				anisotropyEnable;
			1.0f,											// float				maxAnisotropy;
			VK_FALSE,										// VkBool32				compareEnable;
			vk::VK_COMPARE_OP_NEVER,						// VkCompareOp			compareOp;
			0.0f,											// float				minLod;
			0.0f,											// float				maxLod;
			vk::VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,	// VkBorderColor		borderColor;
			VK_FALSE,										// VkBool32				unnormalizedCoordinates;
		};
		const auto newSampler = vk::createSampler(context.getDeviceInterface(), context.getDevice(), &createInfo);
		sampler = newSampler.get();
		// newSampler will be destroyed here and sampler will hold the former handle.
	}
};

vk::VkSampler SamplerlessDescriptorWriteTestInstance::getSamplerHandle (void) const
{
	if (m_params.pointer == PointerCase::ZERO)	return vk::VkSampler{DE_NULL};
	if (m_params.pointer == PointerCase::ONE)	return vk::VkSampler{1};
	static const DestroyedSampler destroyedSampler{m_context};
	return destroyedSampler.sampler;
}

vk::VkExtent3D SamplerlessDescriptorWriteTestInstance::getMainImageExtent (void) const
{
	const vk::VkExtent3D* extent = nullptr;

	switch (m_params.type)
	{
	case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:		// fallthrough
	case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:		extent = &kMinimumExtent;		break;
	case vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:	extent = &kFramebufferExtent;	break;
	default:
		DE_ASSERT(false);
		break;
	}

	return *extent;
}

vk::VkImageUsageFlags SamplerlessDescriptorWriteTestInstance::getMainImageUsage (void) const
{
	vk::VkImageUsageFlags usage = vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT;	// Used when clearing the image.

	switch (m_params.type)
	{
	case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:		usage |= vk::VK_IMAGE_USAGE_SAMPLED_BIT;			break;
	case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:		usage |= vk::VK_IMAGE_USAGE_STORAGE_BIT;			break;
	case vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:	usage |= vk::VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;	break;
	default:
		DE_ASSERT(false);
		break;
	}

	return usage;
}

vk::VkImageLayout SamplerlessDescriptorWriteTestInstance::getMainImageShaderLayout (void) const
{
	vk::VkImageLayout layout = vk::VK_IMAGE_LAYOUT_UNDEFINED;

	switch (m_params.type)
	{
	case vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:		// fallthrough
	case vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:	layout = vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;	break;
	case vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:		layout = vk::VK_IMAGE_LAYOUT_GENERAL;					break;
	default:
		DE_ASSERT(false);
		break;
	}

	return layout;
}


tcu::TestStatus SamplerlessDescriptorWriteTestInstance::iterate (void)
{
	const auto&	vkd			= m_context.getDeviceInterface();
	const auto	device		= m_context.getDevice();
	auto&		allocator	= m_context.getDefaultAllocator();
	const auto	queue		= m_context.getUniversalQueue();
	const auto	queueIndex	= m_context.getUniversalQueueFamilyIndex();
	const auto	tcuFormat	= vk::mapVkFormat(kImageFormat);

	const vk::VkImageCreateInfo mainImgCreateInfo =
	{
		vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,	// VkStructureType			sType;
		nullptr,									// const void*				pNext;
		0u,											// VkImageCreateFlags		flags;
		vk::VK_IMAGE_TYPE_2D,						// VkImageType				imageType;
		kImageFormat,								// VkFormat					format;
		getMainImageExtent(),						// VkExtent3D				extent;
		1u,											// deUint32					mipLevels;
		1u,											// deUint32					arrayLayers;
		vk::VK_SAMPLE_COUNT_1_BIT,					// VkSampleCountFlagBits	samples;
		vk::VK_IMAGE_TILING_OPTIMAL,				// VkImageTiling			tiling;
		getMainImageUsage(),						// VkImageUsageFlags		usage;
		vk::VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode			sharingMode;
		1u,											// deUint32					queueFamilyIndexCount;
		&queueIndex,								// const deUint32*			pQueueFamilyIndices;
		vk::VK_IMAGE_LAYOUT_UNDEFINED,				// VkImageLayout			initialLayout;
	};

	const vk::VkImageCreateInfo fbImgCreateInfo =
	{
		vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,	// VkStructureType			sType;
		nullptr,									// const void*				pNext;
		0u,											// VkImageCreateFlags		flags;
		vk::VK_IMAGE_TYPE_2D,						// VkImageType				imageType;
		kImageFormat,								// VkFormat					format;
		kFramebufferExtent,							// VkExtent3D				extent;
		1u,											// deUint32					mipLevels;
		1u,											// deUint32					arrayLayers;
		vk::VK_SAMPLE_COUNT_1_BIT,					// VkSampleCountFlagBits	samples;
		vk::VK_IMAGE_TILING_OPTIMAL,				// VkImageTiling			tiling;
		(vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |	// VkImageUsageFlags		usage;
		 vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT),			// Used when verifying the image.
		vk::VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode			sharingMode;
		1u,											// deUint32					queueFamilyIndexCount;
		&queueIndex,								// const deUint32*			pQueueFamilyIndices;
		vk::VK_IMAGE_LAYOUT_UNDEFINED,				// VkImageLayout			initialLayout;
	};

	// Create main and framebuffer images.
	const vk::ImageWithMemory mainImage	{vkd, device, allocator, mainImgCreateInfo,	vk::MemoryRequirement::Any};
	const vk::ImageWithMemory fbImage	{vkd, device, allocator, fbImgCreateInfo,	vk::MemoryRequirement::Any};

	// Corresponding image views.
	const auto colorSubresourceRange	= vk::makeImageSubresourceRange(vk::VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
	const auto mainView					= vk::makeImageView(vkd, device, mainImage.get(),	vk::VK_IMAGE_VIEW_TYPE_2D, kImageFormat, colorSubresourceRange);
	const auto fbView					= vk::makeImageView(vkd, device, fbImage.get(),		vk::VK_IMAGE_VIEW_TYPE_2D, kImageFormat, colorSubresourceRange);

	// Buffer to copy rendering result to.
	const vk::VkDeviceSize		resultsBufferSize	= static_cast<vk::VkDeviceSize>(static_cast<deUint32>(tcu::getPixelSize(tcuFormat)) * kFramebufferExtent.width * kFramebufferExtent.height * kFramebufferExtent.depth);
	const auto					resultsBufferInfo	= vk::makeBufferCreateInfo(resultsBufferSize, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT);
	const vk::BufferWithMemory	resultsBuffer		{vkd, device, allocator, resultsBufferInfo, vk::MemoryRequirement::HostVisible};

	const std::vector<tcu::Vec4> fullScreenQuad =
	{
		{ -1.f, -1.f,	0.f, 1.f },
		{  1.f, -1.f,	0.f, 1.f },
		{ -1.f,  1.f,	0.f, 1.f },
		{ -1.f,  1.f,	0.f, 1.f },
		{  1.f, -1.f,	0.f, 1.f },
		{  1.f,  1.f,	0.f, 1.f },
	};

	// Vertex buffer.
	const vk::VkDeviceSize		vertexBufferSize	= static_cast<vk::VkDeviceSize>(fullScreenQuad.size() * sizeof(decltype(fullScreenQuad)::value_type));
	const auto					vertexBufferInfo	= vk::makeBufferCreateInfo(vertexBufferSize, vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
	const vk::BufferWithMemory	vertexBuffer		{vkd, device, allocator, vertexBufferInfo, vk::MemoryRequirement::HostVisible};

	// Copy data to vertex buffer.
	const auto&	vertexAlloc		= vertexBuffer.getAllocation();
	const auto	vertexDataPtr	= reinterpret_cast<char*>(vertexAlloc.getHostPtr()) + vertexAlloc.getOffset();
	deMemcpy(vertexDataPtr, fullScreenQuad.data(), static_cast<size_t>(vertexBufferSize));
	vk::flushAlloc(vkd, device, vertexAlloc);

	// Descriptor set layouts.
	vk::DescriptorSetLayoutBuilder layoutBuilder;
	std::vector<vk::Move<vk::VkDescriptorSetLayout>> descriptorSetLayouts;
	// Create layouts for required amount of empty descriptor sets before the one that is actually used.
	for (deUint32 descIdx = 0u; descIdx < m_params.descriptorSet; descIdx++)
	{
		descriptorSetLayouts.push_back(layoutBuilder.build(vkd, device));
	}
	// Create a layout for the descriptor set that is actually used.
	layoutBuilder.addSingleBinding(m_params.type, vk::VK_SHADER_STAGE_FRAGMENT_BIT);
	descriptorSetLayouts.push_back(layoutBuilder.build(vkd, device));

	// Descriptor pool.
	vk::DescriptorPoolBuilder poolBuilder;
	poolBuilder.addType(m_params.type);
	const auto descriptorPool = poolBuilder.build(vkd, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, m_params.descriptorSet + 1);

	// Descriptor sets.
	std::vector<vk::Move<vk::VkDescriptorSet>> descriptorSets;
	for (deUint32 descIdx = 0u; descIdx < m_params.descriptorSet; descIdx++)
	{
		descriptorSets.push_back(vk::makeDescriptorSet(vkd, device, descriptorPool.get(), descriptorSetLayouts[descIdx].get()));
	}
	descriptorSets.push_back(vk::makeDescriptorSet(vkd, device, descriptorPool.get(), descriptorSetLayouts[m_params.descriptorSet].get()));

	// Update descriptor set with the descriptor.
	// IMPORTANT: the chosen sampler handle is used here.
	vk::DescriptorSetUpdateBuilder updateBuilder;
	const auto descriptorImageInfo = vk::makeDescriptorImageInfo(getSamplerHandle(), mainView.get(), getMainImageShaderLayout());
	updateBuilder.writeSingle(descriptorSets[m_params.descriptorSet].get(), vk::DescriptorSetUpdateBuilder::Location::binding(0u), m_params.type, &descriptorImageInfo);
	updateBuilder.update(vkd, device);

	// Shader modules.
	const auto vertexModule	= vk::createShaderModule(vkd, device, m_context.getBinaryCollection().get("vert"), 0u);
	const auto fragModule	= vk::createShaderModule(vkd, device, m_context.getBinaryCollection().get("frag"), 0u);

	// Render pass.
	const vk::VkAttachmentDescription fbAttachment =
	{
		0u,												// VkAttachmentDescriptionFlags	flags;
		kImageFormat,									// VkFormat						format;
		vk::VK_SAMPLE_COUNT_1_BIT,						// VkSampleCountFlagBits		samples;
		vk::VK_ATTACHMENT_LOAD_OP_CLEAR,				// VkAttachmentLoadOp			loadOp;
		vk::VK_ATTACHMENT_STORE_OP_STORE,				// VkAttachmentStoreOp			storeOp;
		vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,			// VkAttachmentLoadOp			stencilLoadOp;
		vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,			// VkAttachmentStoreOp			stencilStoreOp;
		vk::VK_IMAGE_LAYOUT_UNDEFINED,					// VkImageLayout				initialLayout;
		vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	// VkImageLayout				finalLayout;
	};

	std::vector<vk::VkAttachmentDescription> attachmentDescs;
	attachmentDescs.push_back(fbAttachment);

	if (m_params.type == vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
	{
		// Add it as a frame buffer attachment.
		const vk::VkAttachmentDescription inputAttachment =
		{
			0u,												// VkAttachmentDescriptionFlags	flags;
			kImageFormat,									// VkFormat						format;
			vk::VK_SAMPLE_COUNT_1_BIT,						// VkSampleCountFlagBits		samples;
			vk::VK_ATTACHMENT_LOAD_OP_LOAD,					// VkAttachmentLoadOp			loadOp;
			vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,			// VkAttachmentStoreOp			storeOp;
			vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,			// VkAttachmentLoadOp			stencilLoadOp;
			vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,			// VkAttachmentStoreOp			stencilStoreOp;
			getMainImageShaderLayout(),						// VkImageLayout				initialLayout;
			getMainImageShaderLayout(),						// VkImageLayout				finalLayout;
		};

		attachmentDescs.push_back(inputAttachment);
	}

	std::vector<vk::VkAttachmentReference> inputAttachments;
	if (m_params.type == vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
	{
		const vk::VkAttachmentReference inputRef =
		{
			1u,												// deUint32			attachment;
			getMainImageShaderLayout(),						// VkImageLayout	layout;
		};

		inputAttachments.push_back(inputRef);
	}

	const vk::VkAttachmentReference colorRef =
	{
			0u,												// deUint32			attachment;
			vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	// VkImageLayout	layout;
	};
	const std::vector<vk::VkAttachmentReference> colorAttachments(1u, colorRef);

	const vk::VkSubpassDescription subpass =
	{
		0u,																// VkSubpassDescriptionFlags		flags;
		vk::VK_PIPELINE_BIND_POINT_GRAPHICS,							// VkPipelineBindPoint				pipelineBindPoint;
		static_cast<deUint32>(inputAttachments.size()),					// deUint32							inputAttachmentCount;
		(inputAttachments.empty() ? nullptr : inputAttachments.data()),	// const VkAttachmentReference*		pInputAttachments;
		static_cast<deUint32>(colorAttachments.size()),					// deUint32							colorAttachmentCount;
		colorAttachments.data(),										// const VkAttachmentReference*		pColorAttachments;
		0u,																// const VkAttachmentReference*		pResolveAttachments;
		nullptr,														// const VkAttachmentReference*		pDepthStencilAttachment;
		0u,																// deUint32							preserveAttachmentCount;
		nullptr,														// const deUint32*					pPreserveAttachments;
	};
	const std::vector<vk::VkSubpassDescription> subpasses(1u, subpass);

	const vk::VkRenderPassCreateInfo renderPassInfo =
	{
		vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,	// VkStructureType					sType;
		nullptr,										// const void*						pNext;
		0u,												// VkRenderPassCreateFlags			flags;
		static_cast<deUint32>(attachmentDescs.size()),	// deUint32							attachmentCount;
		attachmentDescs.data(),							// const VkAttachmentDescription*	pAttachments;
		static_cast<deUint32>(subpasses.size()),		// deUint32							subpassCount;
		subpasses.data(),								// const VkSubpassDescription*		pSubpasses;
		0u,												// deUint32							dependencyCount;
		nullptr,										// const VkSubpassDependency*		pDependencies;
	};
	const auto renderPass = vk::createRenderPass(vkd, device, &renderPassInfo);

	// Framebuffer.
	std::vector<vk::VkImageView> attachments;
	attachments.push_back(fbView.get());
	if (m_params.type == vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT)
		attachments.push_back(mainView.get());
	const auto framebuffer = vk::makeFramebuffer(vkd, device, renderPass.get(), static_cast<deUint32>(attachments.size()), attachments.data(), kFramebufferExtent.width, kFramebufferExtent.height, kFramebufferExtent.depth);

	// Pipeline layout.
	const auto pipelineLayout = vk::makePipelineLayout(vkd, device, descriptorSetLayouts);

	// Graphics pipeline.
	const std::vector<vk::VkViewport>	viewports(1u, vk::makeViewport(kFramebufferExtent));
	const std::vector<vk::VkRect2D>		scissors(1u, vk::makeRect2D(kFramebufferExtent));

	const auto pipeline = vk::makeGraphicsPipeline(
		vkd, device, pipelineLayout.get(),
		vertexModule.get(), DE_NULL, DE_NULL, DE_NULL, fragModule.get(),
		renderPass.get(), viewports, scissors);

	// Command pool and command buffer.
	const auto cmdPool		= vk::createCommandPool(vkd, device, vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueIndex);
	const auto cmdBufferPtr	= vk::allocateCommandBuffer(vkd, device, cmdPool.get(), vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY);
	const auto cmdBuffer	= cmdBufferPtr.get();

	// Draw quad.
	const vk::VkRect2D		renderArea			= vk::makeRect2D(kFramebufferExtent);
	const tcu::Vec4			clearFbColor		(0.0f, 0.0f, 0.0f, 1.0f);
	const vk::VkDeviceSize	vertexBufferOffset	= 0ull;

	const auto vtxBufferBarrier	= vk::makeBufferMemoryBarrier(vk::VK_ACCESS_HOST_WRITE_BIT, vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, vertexBuffer.get(), 0ull, vertexBufferSize);
	const auto preClearBarrier	= vk::makeImageMemoryBarrier(0u, vk::VK_ACCESS_TRANSFER_WRITE_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, mainImage.get(), colorSubresourceRange);
	const auto postClearBarrier	= vk::makeImageMemoryBarrier(vk::VK_ACCESS_TRANSFER_WRITE_BIT, vk::VK_ACCESS_SHADER_READ_BIT | vk::VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
						vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, getMainImageShaderLayout(), mainImage.get(), colorSubresourceRange);
	const auto clearDescColor	= vk::makeClearValueColor(kDescriptorColor);

	vk::beginCommandBuffer(vkd, cmdBuffer);

	vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0u, 0u, nullptr, 1u, &vtxBufferBarrier, 0u, nullptr);
	vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, nullptr, 0u, nullptr, 1u, &preClearBarrier);
	vkd.cmdClearColorImage(cmdBuffer, mainImage.get(), vk::VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clearDescColor.color, 1u, &colorSubresourceRange);
	vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_TRANSFER_BIT, vk::VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0u, 0u, nullptr, 0u, nullptr, 1u, &postClearBarrier);

	vk::beginRenderPass(vkd, cmdBuffer, renderPass.get(), framebuffer.get(), renderArea, clearFbColor);
	vkd.cmdBindPipeline(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.get());
	vkd.cmdBindDescriptorSets(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout.get(), m_params.descriptorSet, 1u, &descriptorSets[m_params.descriptorSet].get(), 0u, nullptr);
	vkd.cmdBindVertexBuffers(cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);
	vkd.cmdDraw(cmdBuffer, static_cast<deUint32>(fullScreenQuad.size()), 1u, 0u, 0u);
	vk::endRenderPass(vkd, cmdBuffer);

	const tcu::IVec2 copySize{static_cast<int>(kFramebufferExtent.width), static_cast<int>(kFramebufferExtent.height)};
	vk::copyImageToBuffer(vkd, cmdBuffer, fbImage.get(), resultsBuffer.get(), copySize);

	vk::endCommandBuffer(vkd, cmdBuffer);
	vk::submitCommandsAndWait(vkd, device, queue, cmdBuffer);
	m_context.resetCommandPoolForVKSC(device, *cmdPool);

	// Check results.
	const auto& resultsBufferAlloc = resultsBuffer.getAllocation();
	vk::invalidateAlloc(vkd, device, resultsBufferAlloc);

	const auto							resultsBufferPtr	= reinterpret_cast<const char*>(resultsBufferAlloc.getHostPtr()) + resultsBufferAlloc.getOffset();
	const tcu::ConstPixelBufferAccess	resultPixels		{tcuFormat, copySize[0], copySize[1], 1, resultsBufferPtr};

	bool pass = true;
	for (int x = 0; pass && x < resultPixels.getWidth(); ++x)
	for (int y = 0; pass && y < resultPixels.getHeight(); ++y)
	for (int z = 0; pass && z < resultPixels.getDepth(); ++z)
	{
		const auto pixel = resultPixels.getPixel(x, y, z);
		pass = (pixel == kDescriptorColor);
	}

	tcu::TestStatus status = tcu::TestStatus::pass("Pass");
	if (!pass)
	{
		auto& log = m_context.getTestContext().getLog();
		log << tcu::TestLog::Image("color", "Rendered image", resultPixels);
		status = tcu::TestStatus::fail("Pixel mismatch; please check the rendered image");
	}

	return status;
}

tcu::TestCaseGroup* createSamplerlessWriteTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "samplerless", "Verify sampler unused with some descriptor image types"));

	const std::vector<std::pair<vk::VkDescriptorType, std::string>> descriptorTypes =
	{
		std::make_pair(vk::VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,	"sampled_img"),
		std::make_pair(vk::VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,	"storage_img"),
		std::make_pair(vk::VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,	"input_attachment"),
	};

	const std::vector<std::pair<PointerCase, std::string>> pointerCases =
	{
		std::make_pair(PointerCase::ZERO,		"sampler_zero"),
		std::make_pair(PointerCase::ONE,		"sampler_one"),
		std::make_pair(PointerCase::DESTROYED,	"sampler_destroyed"),
	};

	for (const auto& typeCase		: descriptorTypes)
	for (const auto& pointerCase	: pointerCases)
	for (deUint32 descriptorSet = 0u; descriptorSet < 2u; descriptorSet++)
	{
		std::string			caseName	= typeCase.second + "_" + pointerCase.second;
		SamplerlessParams	params		{typeCase.first, pointerCase.first, descriptorSet};
		if (descriptorSet > 0u)
		{
			caseName += "_set_" + std::to_string(descriptorSet);
		}

		group->addChild(new SamplerlessDescriptorWriteTestCase(testCtx, caseName, "", params));
	}

	return group.release();
}

class RandomDescriptorUpdateTestCase : public vkt::TestCase
{
public:
	RandomDescriptorUpdateTestCase				(tcu::TestContext& testCtx, const std::string& name, const std::string& description);
	virtual	~RandomDescriptorUpdateTestCase		(void) {}

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

private:
};

class RandomDescriptorUpdateTestInstance : public vkt::TestInstance
{
public:
	RandomDescriptorUpdateTestInstance			(Context& context);
	virtual	~RandomDescriptorUpdateTestInstance	(void) {}

	virtual tcu::TestStatus		iterate			(void);

	static const vk::VkExtent3D	kFramebufferExtent;
	static const vk::VkFormat	kImageFormat;
	static const deUint32		kNumBuffers;
	static const deUint32		kNumOffsets;
	static const deUint32		kNumIterations;

private:
	deRandom					m_random;
};

const vk::VkExtent3D	RandomDescriptorUpdateTestInstance::kFramebufferExtent	= vk::makeExtent3D(64u, 64u, 1u);
const vk::VkFormat		RandomDescriptorUpdateTestInstance::kImageFormat		= vk::VK_FORMAT_R16G16B16A16_SFLOAT;
const deUint32			RandomDescriptorUpdateTestInstance::kNumBuffers			= 3u;
const deUint32			RandomDescriptorUpdateTestInstance::kNumOffsets			= 5u;
const deUint32			RandomDescriptorUpdateTestInstance::kNumIterations		= 1000u;

RandomDescriptorUpdateTestCase::RandomDescriptorUpdateTestCase (tcu::TestContext& testCtx, const std::string& name, const std::string& description)
: vkt::TestCase(testCtx, name, description)
{
}

void RandomDescriptorUpdateTestCase::initPrograms (vk::SourceCollections& programCollection) const
{
	const std::string vertexShader =
			"#version 450\n"
			"layout(location=0) in vec4 position;\n"
			"void main() { gl_Position = position; }\n";

	programCollection.glslSources.add("vert") << glu::VertexSource(vertexShader);

	std::ostringstream fragmentShader;

	fragmentShader
			<< "#version 450\n"
			<< "layout(location = 0) out vec4 color_out;\n"
			<< "layout(set = 0, binding = 0) uniform buf\n"
			<< "{\n"
			<< "    vec4 data0;\n"
			<< "    vec4 data1;\n"
			<< "};\n"
			<< "void main()\n"
			<< "{\n"
			<< "    color_out = data0 + data1;\n"
			<< "}\n"
			;

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

vkt::TestInstance* RandomDescriptorUpdateTestCase::createInstance (Context& context) const
{
	return new RandomDescriptorUpdateTestInstance(context);
}

RandomDescriptorUpdateTestInstance::RandomDescriptorUpdateTestInstance(Context &context)
: vkt::TestInstance(context)
{
	deRandom_init(&m_random, 0);
}

tcu::TestStatus RandomDescriptorUpdateTestInstance::iterate()
{
	const auto&								vkd						= m_context.getDeviceInterface();
	const auto								device					= m_context.getDevice();
	auto&									allocator				= m_context.getDefaultAllocator();
	const auto								queue					= m_context.getUniversalQueue();
	const auto								queueIndex				= m_context.getUniversalQueueFamilyIndex();
	const auto								tcuFormat				= vk::mapVkFormat(kImageFormat);
	vk::DescriptorSetLayoutBuilder			builder;

	builder.addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_FRAGMENT_BIT);

	vk::Unique<vk::VkDescriptorSetLayout>	layout					(builder.build(vkd, device, (vk::VkDescriptorSetLayoutCreateFlags)0));

	// Create descriptor pool
	vk::Unique<vk::VkDescriptorPool>		descriptorPool			(vk::DescriptorPoolBuilder().addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1).build(vkd, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1));

	// Create descriptor set
	const vk::VkDescriptorSetAllocateInfo	setAllocateInfo			=
	{
		vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,	// VkStructureType				sType
		DE_NULL,											// const void*					pNext
		*descriptorPool,									// VkDescriptorPool				descriptorPool
		1u,													// deUint32						descriptorSetCount
		&layout.get()										// const VkDescriptorSetLayout*	pSetLayouts
	};

	vk::Unique<vk::VkDescriptorSet>			descriptorSet			(allocateDescriptorSet(vkd, device, &setAllocateInfo));

	// The maximum allowed buffer offset alignment is 256 bytes. Meaningful data is placed at these offsets.
	const deUint32	bufferSize = 256u * kNumOffsets;

	float									bufferContents[kNumBuffers][bufferSize / 4];
	float									counter				= 1.0f;
	float									sign				= 1.0f;
	deUint32								offset				= 0;
	deUint32								channelSelector		= 0;

	// The buffers are filled with a running counter in one of the channels.
	// Both signed and unsigned values are used for each counter. Two vec4s
	// are initialized at offsets of 256 bytes (the maximum allowed alignment).
	// Everythin else is left as zero.
	for (deUint32 b = 0; b < kNumBuffers; b++)
	{
		deMemset(bufferContents[b], 0, bufferSize);

		for (deUint32 o = 0; o < kNumOffsets; o++)
		{
			offset = o * 64;

			// Two vectors at every offset.
			for (deUint32 v = 0; v < 2; v++)
			{
				// Only RGB channels are being tested.
				for (deUint32 c = 0; c < 3; c++)
				{
					if (c == channelSelector)
					{
						bufferContents[b][offset++] = sign * counter;
					}
					else
					{
						bufferContents[b][offset++] = 0.0f;
					}
				}
				// Keep alpha at one.
				bufferContents[b][offset++] = 1.0f;

				channelSelector = channelSelector + 1;

				// All three channels have been filled in. Switch a sign or increase the counter.
				if (channelSelector == 3)
				{
					channelSelector = 0;
					if (sign == 1.0f)
					{
						sign = -1.0f;
					}
					else
					{
						sign = 1.0f;
						counter += 1.0f;
					}
				}
			}
		}
	}

	const auto								bufferInfo				= vk::makeBufferCreateInfo(bufferSize, vk::VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
	std::vector<std::shared_ptr<vk::BufferWithMemory>>	buffers;

	for (const auto& contents : bufferContents)
	{
		buffers.emplace_back(std::make_shared<vk::BufferWithMemory>(vkd, device, allocator, bufferInfo, vk::MemoryRequirement::HostVisible));
		const auto&	bufferAlloc	= buffers.back()->getAllocation();
		const auto	bufferPtr	= reinterpret_cast<char*>(bufferAlloc.getHostPtr()) + bufferAlloc.getOffset();
		deMemcpy(bufferPtr, contents, bufferSize);
		vk::flushAlloc(vkd, device, bufferAlloc);
	}

	// Create framebuffer image and view.
	const vk::VkImageCreateInfo				fbImgCreateInfo			=
	{
		vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,	// VkStructureType			sType
		DE_NULL,									// const void*				pNext
		0u,											// VkImageCreateFlags		flags
		vk::VK_IMAGE_TYPE_2D,						// VkImageType				imageType
		kImageFormat,								// VkFormat					format
		kFramebufferExtent,							// VkExtent3D				extent
		1u,											// deUint32					mipLevels
		1u,											// deUint32					arrayLayers
		vk::VK_SAMPLE_COUNT_1_BIT,					// VkSampleCountFlagBits	samples
		vk::VK_IMAGE_TILING_OPTIMAL,				// VkImageTiling			tiling
		(vk::VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |	// VkImageUsageFlags		usage
		 vk::VK_IMAGE_USAGE_TRANSFER_SRC_BIT),
		vk::VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode			sharingMode
		1u,											// deUint32					queueFamilyIndexCount
		&queueIndex,								// const deUint32*			pQueueFamilyIndices
		vk::VK_IMAGE_LAYOUT_UNDEFINED				// VkImageLayout			initialLayout
	};

	const vk::ImageWithMemory				fbImage					(vkd, device, allocator, fbImgCreateInfo,	vk::MemoryRequirement::Any);
	const auto								colorSubresourceRange	= vk::makeImageSubresourceRange(vk::VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
	const auto								fbView					= vk::makeImageView(vkd, device, fbImage.get(),		vk::VK_IMAGE_VIEW_TYPE_2D, kImageFormat, colorSubresourceRange);

	// Buffer to copy rendering result to.
	const vk::VkDeviceSize					resultsBufferSize		= static_cast<vk::VkDeviceSize>(static_cast<deUint32>(tcu::getPixelSize(tcuFormat)) * kFramebufferExtent.width * kFramebufferExtent.height * kFramebufferExtent.depth);
	const auto								resultsBufferInfo		= vk::makeBufferCreateInfo(resultsBufferSize, vk::VK_BUFFER_USAGE_TRANSFER_DST_BIT);
	const vk::BufferWithMemory				resultsBuffer			(vkd, device, allocator, resultsBufferInfo, vk::MemoryRequirement::HostVisible);

	const std::vector<tcu::Vec4>			fullScreenQuad			=
	{
		{ -1.f, -1.f,	0.f, 1.f },
		{  1.f, -1.f,	0.f, 1.f },
		{ -1.f,  1.f,	0.f, 1.f },
		{ -1.f,  1.f,	0.f, 1.f },
		{  1.f, -1.f,	0.f, 1.f },
		{  1.f,  1.f,	0.f, 1.f }
	};

	// Vertex buffer.
	const vk::VkDeviceSize					vertexBufferSize		= static_cast<vk::VkDeviceSize>(fullScreenQuad.size() * sizeof(decltype(fullScreenQuad)::value_type));
	const auto								vertexBufferInfo		= vk::makeBufferCreateInfo(vertexBufferSize, vk::VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
	const vk::BufferWithMemory				vertexBuffer			(vkd, device, allocator, vertexBufferInfo, vk::MemoryRequirement::HostVisible | vk::MemoryRequirement::Coherent);

	// Copy data to vertex buffer.
	const auto&								vertexAlloc				= vertexBuffer.getAllocation();
	const auto								vertexDataPtr			= reinterpret_cast<char*>(vertexAlloc.getHostPtr()) + vertexAlloc.getOffset();
	deMemcpy(vertexDataPtr, fullScreenQuad.data(), static_cast<size_t>(vertexBufferSize));
	vk::flushAlloc(vkd, device, vertexAlloc);

	// Shader modules.
	const auto								vertexModule			= vk::createShaderModule(vkd, device, m_context.getBinaryCollection().get("vert"), 0u);
	const auto								fragModule				= vk::createShaderModule(vkd, device, m_context.getBinaryCollection().get("frag"), 0u);

	// Render pass.
	const vk::VkAttachmentDescription		fbAttachment			=
	{
		0u,												// VkAttachmentDescriptionFlags		flags
		kImageFormat,									// VkFormat							format
		vk::VK_SAMPLE_COUNT_1_BIT,						// VkSampleCountFlagBits			samples
		vk::VK_ATTACHMENT_LOAD_OP_LOAD,					// VkAttachmentLoadOp				loadOp
		vk::VK_ATTACHMENT_STORE_OP_STORE,				// VkAttachmentStoreOp				storeOp
		vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,			// VkAttachmentLoadOp				stencilLoadOp
		vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,			// VkAttachmentStoreOp				stencilStoreOp
		vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	// VkImageLayout					initialLayout
		vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL	// VkImageLayout					finalLayout
	};

	std::vector<vk::VkAttachmentDescription>	attachmentDescs;
	attachmentDescs.push_back(fbAttachment);

	const vk::VkAttachmentReference			colorRef				=
	{
		0u,												// deUint32			attachment
		vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,	// VkImageLayout	layout
	};
	const std::vector<vk::VkAttachmentReference> colorAttachments(1u, colorRef);

	const vk::VkSubpassDescription				subpass				=
	{
		0u,												// VkSubpassDescriptionFlags		flags
		vk::VK_PIPELINE_BIND_POINT_GRAPHICS,			// VkPipelineBindPoint				pipelineBindPoint
		0u,												// deUint32							inputAttachmentCount
		DE_NULL,										// const VkAttachmentReference*		pInputAttachments
		static_cast<deUint32>(colorAttachments.size()),	// deUint32							colorAttachmentCount
		colorAttachments.data(),						// const VkAttachmentReference*		pColorAttachments
		0u,												// const VkAttachmentReference*		pResolveAttachments
		DE_NULL,										// const VkAttachmentReference*		pDepthStencilAttachment
		0u,												// deUint32							preserveAttachmentCount
		DE_NULL											// const deUint32*					pPreserveAttachments
	};
	const std::vector<vk::VkSubpassDescription>	subpasses			(1u, subpass);

	const vk::VkRenderPassCreateInfo renderPassInfo =
	{
		vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,	// VkStructureType					sType
		DE_NULL,										// const void*						pNext
		0u,												// VkRenderPassCreateFlags			flags
		static_cast<deUint32>(attachmentDescs.size()),	// deUint32							attachmentCount
		attachmentDescs.data(),							// const VkAttachmentDescription*	pAttachments
		static_cast<deUint32>(subpasses.size()),		// deUint32							subpassCount
		subpasses.data(),								// const VkSubpassDescription*		pSubpasses
		0u,												// deUint32							dependencyCount
		DE_NULL,										// const VkSubpassDependency*		pDependencies
	};
	const auto									renderPass			= vk::createRenderPass(vkd, device, &renderPassInfo);

	// Framebuffer.
	std::vector<vk::VkImageView>				attachments;
	attachments.push_back(fbView.get());
	const auto									framebuffer			= vk::makeFramebuffer(vkd, device, renderPass.get(), static_cast<deUint32>(attachments.size()), attachments.data(), kFramebufferExtent.width, kFramebufferExtent.height, kFramebufferExtent.depth);

	// Pipeline layout.
	const auto									pipelineLayout		= vk::makePipelineLayout(vkd, device, layout.get());

	// Graphics pipeline.
	const std::vector<vk::VkViewport>			viewports			(1u, vk::makeViewport(kFramebufferExtent));
	const std::vector<vk::VkRect2D>				scissors			(1u, vk::makeRect2D(kFramebufferExtent));

	// Use additive alpha blending to accumulate results from all iterations.
	const vk::VkPipelineColorBlendAttachmentState	colorBlendAttachmentState	=
	{
		VK_TRUE,						// VkBool32					blendEnable
		vk::VK_BLEND_FACTOR_ONE,		// VkBlendFactor			srcColorBlendFactor
		vk::VK_BLEND_FACTOR_ONE,		// VkBlendFactor			dstColorBlendFactor
		vk::VK_BLEND_OP_ADD,			// VkBlendOp				colorBlendOp
		vk::VK_BLEND_FACTOR_ONE,		// VkBlendFactor			srcAlphaBlendFactor
		vk::VK_BLEND_FACTOR_ZERO,		// VkBlendFactor			dstAlphaBlendFactor
		vk::VK_BLEND_OP_ADD,			// VkBlendOp				alphaBlendOp
		vk::VK_COLOR_COMPONENT_R_BIT	// VkColorComponentFlags	colorWriteMask
		| vk::VK_COLOR_COMPONENT_G_BIT
		| vk::VK_COLOR_COMPONENT_B_BIT
		| vk::VK_COLOR_COMPONENT_A_BIT
	};

	const vk::VkPipelineColorBlendStateCreateInfo	colorBlendState	=
	{
		vk::VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,	// VkStructureType								sType
		DE_NULL,														// const void*									pNext
		0u,																// VkPipelineColorBlendStateCreateFlags			flags
		VK_FALSE,														// VkBool32										logicOpEnable
		vk::VK_LOGIC_OP_CLEAR,											// VkLogicOp									logicOp
		1u,																// deUint32										attachmentCount
		&colorBlendAttachmentState,										// const VkPipelineColorBlendAttachmentState*	pAttachments
		{ 1.0f, 1.0f, 1.0f, 1.0f }										// float										blendConstants[4]
	};

	const auto									pipeline			= vk::makeGraphicsPipeline(vkd, device, pipelineLayout.get(),
																							   vertexModule.get(), DE_NULL, DE_NULL, DE_NULL, fragModule.get(),
																							   renderPass.get(), viewports, scissors, vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
																							   0u, 0u, DE_NULL, DE_NULL, DE_NULL, DE_NULL, &colorBlendState);

	// Command pool and command buffer.
	const auto									cmdPool				= vk::createCommandPool(vkd, device, vk::VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueIndex);
	const auto									cmdBufferPtr		= vk::allocateCommandBuffer(vkd, device, cmdPool.get(), vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY);
	const auto									cmdBuffer			= cmdBufferPtr.get();

	const vk::VkRect2D							renderArea			= vk::makeRect2D(kFramebufferExtent);
	const vk::VkDeviceSize						vertexBufferOffset	= 0ull;

	const auto									vtxBufferBarrier	= vk::makeBufferMemoryBarrier(vk::VK_ACCESS_HOST_WRITE_BIT, vk::VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, vertexBuffer.get(), 0ull, vertexBufferSize);
	const auto									fbBarrier			= vk::makeImageMemoryBarrier(0u, vk::VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, vk::VK_IMAGE_LAYOUT_UNDEFINED, vk::VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, fbImage.get(), colorSubresourceRange);

	vk::VkClearValue							clearValue;
	clearValue.color.float32[0] = 0.0f;
	clearValue.color.float32[1] = 0.0f;
	clearValue.color.float32[2] = 0.0f;
	clearValue.color.float32[3] = 1.0f;

	const vk::VkClearAttachment					clearAttachment		=
	{
		vk::VK_IMAGE_ASPECT_COLOR_BIT,	// VkImageAspectFlags	aspectMask
		0u,								// uint32_t				colorAttachment
		clearValue						// VkClearValue			clearValue
	};

	const vk::VkClearRect						clearRect			=
	{
		vk::makeRect2D(kFramebufferExtent),	// VkRect2D	rect
		0u,									// uint32_t	baseArrayLayer
		1u									// uint32_t	layerCount
	};

	vk::beginCommandBuffer(vkd, cmdBuffer);
	vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_HOST_BIT, vk::VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0u,
						   0u, DE_NULL, 1u, &vtxBufferBarrier, 0u, DE_NULL);
	vkd.cmdPipelineBarrier(cmdBuffer, vk::VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, vk::VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0u,
						   0u, DE_NULL, 0u, DE_NULL, 1u, &fbBarrier);
	vk::endCommandBuffer(vkd, cmdBuffer);
	vk::submitCommandsAndWait(vkd, device, queue, cmdBuffer);
	m_context.resetCommandPoolForVKSC(device, *cmdPool);

	struct DescriptorWrite
	{
		deUint32			bufferId;	// Which buffer to use for the descriptor update.
		vk::VkDeviceSize	offset;		// The offset for the descriptor update.
		vk::VkDeviceSize	range;		// The range for the descriptor update.
	};

	// Each iteration operates on a descriptor mutation which decides the source of the descriptor update.
	struct DescriptorMutation
	{
		deBool							update;		// Determines if a descriptor update is performed.
		deUint32						numDraws;	// The number of consecutive draw calls in a loop.
		std::vector<DescriptorWrite>	writes;		// Multiple redundant writes can be performed.
		// Other ideas to implement:
		// - Sometimes also update the buffer contents.
		// - Multiple descriptor sets.
	};

	std::vector<DescriptorMutation>				descriptorMutations;

	// Keep track of the expected result while generating the mutations.
	tcu::Vec4									uboValue0;
	tcu::Vec4									uboValue1;
	tcu::Vec4									expectedColor		(0.0f, 0.0f, 0.0f, 1.0f);
	DescriptorWrite								descWrite			= { 0u, 0u, 32u };

	for (deUint32 i = 0; i < kNumIterations; i++)
	{
		while (true)
		{
			tcu::Vec4						val0		= uboValue0;
			tcu::Vec4						val1		= uboValue1;

			deUint32						numWrites	= 1u;

			// Sometimes do redundant descriptor writes.
			if (deRandom_getUint32(&m_random) % 10 == 0)
				numWrites = deRandom_getUint32(&m_random) % 20 + 1;

			std::vector<DescriptorWrite>	writes;

			for (deUint32 w = 0; w < numWrites; w++)
			{
				// The first half: Most of the times change the offset but sometimes the buffer.
				// The second half: Most of the times change the buffer but sometimes change the offset.
				bool	firstHalf	= i < kNumIterations / 2;
				bool	rare		= (deRandom_getUint32(&m_random) % 100u >= (firstHalf ? 98u : 80u));

				// firstHalf     rare      change
				// --------------------------------
				//     1          0        Offset
				//     1          1        Buffer
				//     0          0        Buffer
				//     0          1        Offset
				//
				// This has a XOR pattern

				if (firstHalf ^ rare)
					descWrite.offset = (deRandom_getUint32(&m_random) % kNumOffsets) * 256u;
				else
					descWrite.bufferId = deRandom_getUint32(&m_random) % kNumBuffers;

				writes.push_back(descWrite);
			}

			DescriptorMutation				mutation	= {i == 0 ? true : deRandom_getBool(&m_random),
										deRandom_getUint32(&m_random) % 10u, writes};

			const auto&						lastWrite	= mutation.writes.back();
			if (mutation.update)
			{
				for (int c = 0; c < 3; c++)
				{
					val0[c] = bufferContents[lastWrite.bufferId][lastWrite.offset / 4 + c];
					val1[c] = bufferContents[lastWrite.bufferId][lastWrite.offset / 4 + 4 + c];

					// Sanity check we are reading expected values.
					DE_ASSERT(val0[c] >= -counter && val0[c] <= counter);
					DE_ASSERT(val1[c] >= -counter && val1[c] <= counter);
				}
			}

			tcu::Vec4						color		= expectedColor + (val0 + val1) * tcu::Vec4(static_cast<float>(mutation.numDraws));

			// 16-bit float can precisely present integers from -2048..2048. Continue randomizing the mutation
			// until we stay in this range.
			if (color[0] >= -2048.0f && color[0] <= 2048.0f && color[1] >= -2048.0f && color[1] <= 2048.0f
				&& color[2] >= -2048.0f && color[2] <= 2048.0f)
			{
				descriptorMutations.push_back(mutation);
				uboValue0		= val0;
				uboValue1		= val1;
				expectedColor	= color;
				break;
			}
			else
			{
				// Randomize both buffer and offset for a better chance to hit a
				// mutation that pushes the values back to the desired range.
				descWrite.offset = (deRandom_getUint32(&m_random) % kNumOffsets) * 256u;
				descWrite.bufferId = deRandom_getUint32(&m_random) % kNumBuffers;
			}
		}
	}

	bool first = true;

	for (auto mutation : descriptorMutations)
	{
		if (mutation.update)
		{
			for (const auto &write : mutation.writes)
			{
				const vk::VkDescriptorBufferInfo descriptorInfo =
				{
					buffers[write.bufferId]->get(),	// VkBuffer		buffer
					write.offset,					// VkDeviceSize	offset
					write.range						// VkDeviceSize	range
				};

				const vk::VkWriteDescriptorSet descriptorWrite =
				{
					vk::VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,	// VkStructureTypes					Type
					DE_NULL,									// const void*						pNext
					*descriptorSet,								// VkDescriptorSet					dstSet
					0,											// deUint32							dstBinding
					0,											// deUint32							dstArrayElement
					1u,											// deUint32							descriptorCount
					vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,		// VkDescriptorType					descriptorType
					DE_NULL,									// const VkDescriptorImageInfo*		pImageInfo
					&descriptorInfo,							// const VkDescriptorBufferInfo*	pBufferInfo
					DE_NULL										// const VkBufferView*				pTexelBufferView
				};

				vkd.updateDescriptorSets(device, 1, &descriptorWrite, 0, DE_NULL);
			}
		}

		vk::beginCommandBuffer(vkd, cmdBuffer);

		vk::beginRenderPass(vkd, cmdBuffer, renderPass.get(), framebuffer.get(), renderArea);
		vkd.cmdBindPipeline(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.get());
		// Clear the frame buffer during the first iteration.
		if (first)
		{
			vkd.cmdClearAttachments(cmdBuffer, 1u, &clearAttachment, 1u, &clearRect);
			first = false;
		}
		vkd.cmdBindDescriptorSets(cmdBuffer, vk::VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout.get(), 0u, 1u,
								  &descriptorSet.get(), 0u, nullptr);
		vkd.cmdBindVertexBuffers(cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);

		for (deUint32 i = 0u; i < mutation.numDraws; i++)
			vkd.cmdDraw(cmdBuffer, static_cast<deUint32>(fullScreenQuad.size()), 1u, 0u, 0u);

		vk::endRenderPass(vkd, cmdBuffer);
		vk::endCommandBuffer(vkd, cmdBuffer);
		vk::submitCommandsAndWait(vkd, device, queue, cmdBuffer);
		m_context.resetCommandPoolForVKSC(device, *cmdPool);
	}

	vk::beginCommandBuffer(vkd, cmdBuffer);
	const tcu::IVec2 copySize{static_cast<int>(kFramebufferExtent.width),
							  static_cast<int>(kFramebufferExtent.height)};
	vk::copyImageToBuffer(vkd, cmdBuffer, fbImage.get(), resultsBuffer.get(), copySize);
	vk::endCommandBuffer(vkd, cmdBuffer);
	vk::submitCommandsAndWait(vkd, device, queue, cmdBuffer);
	m_context.resetCommandPoolForVKSC(device, *cmdPool);

	// Check results.
	const auto& resultsBufferAlloc = resultsBuffer.getAllocation();
	vk::invalidateAlloc(vkd, device, resultsBufferAlloc);

	const auto							resultsBufferPtr	= reinterpret_cast<const char*>(resultsBufferAlloc.getHostPtr()) + resultsBufferAlloc.getOffset();
	const tcu::ConstPixelBufferAccess	resultPixels		{tcuFormat, copySize[0], copySize[1], 1, resultsBufferPtr};

	// The test only operates on integers, so a tolerance of 0.5 should work.
	const float							tolerance			= 0.5f;

	bool pass = true;
	for (int x = 0; pass && x < resultPixels.getWidth(); ++x)
		for (int y = 0; pass && y < resultPixels.getHeight(); ++y)
			for (int z = 0; pass && z < resultPixels.getDepth(); ++z)
			{
				const auto pixel = resultPixels.getPixel(x, y, z);
				for (int c = 0; c < 3; c++)
					if (fabs(pixel[c] - expectedColor[c]) > tolerance)
						pass = false;
			}

	tcu::TestStatus status = tcu::TestStatus::pass("Pass");
	if (!pass)
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Image("color", "Rendered image", resultPixels);
		status = tcu::TestStatus::fail("Pixel mismatch; please check the rendered image");
	}

	return status;
}

tcu::TestCaseGroup* createRandomDescriptorUpdateTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "random", "Update descriptors randomly between draws"));

	group->addChild(new RandomDescriptorUpdateTestCase(testCtx, "uniform_buffer", ""));
	return group.release();
}

} // anonymous

tcu::TestCaseGroup* createDescriptorUpdateTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "descriptor_update", "Update descriptor sets"));

	group->addChild(createEmptyDescriptorUpdateTests(testCtx));
	group->addChild(createSamplerlessWriteTests(testCtx));
	group->addChild(createRandomDescriptorUpdateTests(testCtx));
#ifndef CTS_USES_VULKANSC
	group->addChild(createDescriptorUpdateASTests(testCtx));
#endif // CTS_USES_VULKANSC

	return group.release();
}

} // BindingModel
} // vkt