/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2021 The Khronos Group 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  VkDeviceObjectReservationCreateInfo tests
*//*--------------------------------------------------------------------*/

#include "vktDeviceObjectReservationTests.hpp"

#include <vector>
#include <string>

#include "tcuTestCase.hpp"

#include "vkDefs.hpp"
#include "vkDeviceUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkSafetyCriticalUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vkBufferWithMemory.hpp"
#include "vkObjUtil.hpp"

#include "vktTestCaseUtil.hpp"
#include "vktCustomInstancesDevices.hpp"

using namespace vk;

namespace vkt
{
namespace sc
{
namespace
{

enum TestMaxValues
{
	TMV_UNDEFINED = 0,
	TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT,
	TMV_MAX_IMAGEVIEW_MIPLEVELS,
	TMV_MAX_IMAGEVIEW_ARRAYLAYERS,
	TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS,
	TMV_MAX_OCCLUSION_QUERIES_PER_POOL,
	TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL,
	TMV_MAX_TIMESTAMP_QUERIES_PER_POOL
};

const deUint32	VERIFYMAXVALUES_OBJECT_COUNT	= 5U;
const deUint32	VERIFYMAXVALUES_ARRAYLAYERS		= 8U;
const deUint32	VERIFYMAXVALUES_MIPLEVELS		= 5U;

enum TestRequestCounts
{
	TRC_UNDEFINED = 0,
	TRC_SEMAPHORE,
	TRC_COMMAND_BUFFER,
	TRC_FENCE,
	TRC_DEVICE_MEMORY,
	TRC_BUFFER,
	TRC_IMAGE,
	TRC_EVENT,
	TRC_QUERY_POOL,
	TRC_BUFFER_VIEW,
	TRC_IMAGE_VIEW,
	TRC_LAYERED_IMAGE_VIEW,
	TRC_PIPELINE_LAYOUT,
	TRC_RENDER_PASS,
	TRC_GRAPHICS_PIPELINE,
	TRC_COMPUTE_PIPELINE,
	TRC_DESCRIPTORSET_LAYOUT,
	TRC_SAMPLER,
	TRC_DESCRIPTOR_POOL,
	TRC_DESCRIPTORSET,
	TRC_FRAMEBUFFER,
	TRC_COMMANDPOOL,
	TRC_SAMPLERYCBCRCONVERSION,
	TRC_SURFACE,
	TRC_SWAPCHAIN,
	TRC_DISPLAY_MODE,
};

enum TestPoolSizes
{
	PST_UNDEFINED = 0,
	PST_NONE,
	PST_ZERO,
	PST_TOO_SMALL_SIZE,
	PST_ONE_FITS,
	PST_MULTIPLE_FIT,
};

struct TestParams
{
	TestParams (const TestMaxValues& testMaxValues_ = TMV_UNDEFINED, const TestRequestCounts& testRequestCounts_ = TRC_UNDEFINED, const TestPoolSizes& testPoolSizeType_ = PST_UNDEFINED)
		: testMaxValues		{ testMaxValues_ }
		, testRequestCounts	{ testRequestCounts_ }
		, testPoolSizeType	{ testPoolSizeType_ }
	{
	}
	TestMaxValues			testMaxValues;
	TestRequestCounts		testRequestCounts;
	TestPoolSizes			testPoolSizeType;
};

typedef de::SharedPtr<Unique<VkSemaphore>>					SemaphoreSp;
typedef de::SharedPtr<Unique<VkCommandBuffer>>				CommandBufferSp;
typedef de::SharedPtr<Unique<VkFence>>						FenceSp;
typedef de::SharedPtr<Unique<VkDeviceMemory> >				DeviceMemorySp;
typedef de::SharedPtr<Unique<VkBuffer>>						BufferSp;
typedef de::SharedPtr<Unique<VkImage>>						ImageSp;
typedef de::SharedPtr<Unique<VkEvent>>						EventSp;
typedef de::SharedPtr<Unique<VkQueryPool>>					QueryPoolSp;
typedef de::SharedPtr<Unique<VkBufferView>>					BufferViewSp;
typedef de::SharedPtr<Unique<VkImageView>>					ImageViewSp;
typedef de::SharedPtr<Unique<VkPipelineLayout>>				PipelineLayoutSp;
typedef de::SharedPtr<Unique<VkRenderPass>>					RenderPassSp;
typedef de::SharedPtr<Unique<VkPipeline>>					PipelineSp;
typedef de::SharedPtr<Unique<VkDescriptorSetLayout>>		DescriptorSetLayoutSp;
typedef de::SharedPtr<Unique<VkSampler>>					SamplerSp;
typedef de::SharedPtr<Unique<VkDescriptorPool>>				DescriptorPoolSp;
typedef de::SharedPtr<Unique<VkDescriptorSet>>				DescriptorSetSp;
typedef de::SharedPtr<Unique<VkFramebuffer>>				FramebufferSp;
typedef de::SharedPtr<Unique<VkCommandPool>>				CommandPoolSp;
typedef de::SharedPtr<Unique<VkSamplerYcbcrConversion>>		SamplerYcbcrConversionSp;
//typedef de::SharedPtr<Unique<VkSurfaceKHR>>					SurfaceSp;
//typedef de::SharedPtr<Unique<VkSwapchainKHR>>					SwapchainSp;
//typedef de::SharedPtr<Unique<VkDisplayModeKHR>>				DisplayModeSp;
typedef de::SharedPtr<Unique<VkSubpassDescription>>			SubpassDescriptionSp;
typedef de::SharedPtr<Unique<VkAttachmentDescription>>		AttachmentDescriptionSp;


void createSemaphores		(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 std::vector<SemaphoreSp>::iterator		begin,
							 std::vector<SemaphoreSp>::iterator		end)
{
	for(std::vector<SemaphoreSp>::iterator it=begin; it!=end; ++it)
		*it = SemaphoreSp(new Unique<VkSemaphore>(createSemaphore(vkd, device)));
}

void createCommandBuffers	(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 const VkCommandPool					commandPool,
							 std::vector<CommandBufferSp>::iterator	begin,
							 std::vector<CommandBufferSp>::iterator	end)
{
	for (std::vector<CommandBufferSp>::iterator it = begin; it != end; ++it)
	{
		const vk::VkCommandBufferAllocateInfo commandBufferAI =
		{
			vk::VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,				// sType
			DE_NULL,														// pNext
			commandPool,													// commandPool
			vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY,							// level
			1u																// commandBufferCount
		};
		*it = CommandBufferSp(new Unique<VkCommandBuffer>(allocateCommandBuffer(vkd, device, &commandBufferAI)));
	}
}

void createFences			(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 std::vector<FenceSp>::iterator			begin,
							 std::vector<FenceSp>::iterator			end)
{
	for (std::vector<FenceSp>::iterator it = begin; it != end; ++it)
	{
		const VkFenceCreateInfo fenceCI =
		{
			VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,							// VkStructureType		sType
			DE_NULL,														// const void*			pNext
			0u																// VkFenceCreateFlags	flags
		};
		*it = FenceSp(new Unique<VkFence>(createFence(vkd, device, &fenceCI)));
	}
}

void allocateDeviceMemory	(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 VkDeviceSize							size,
							 std::vector<DeviceMemorySp>::iterator	begin,
							 std::vector<DeviceMemorySp>::iterator	end)
{
	for (std::vector<DeviceMemorySp>::iterator it = begin; it != end; ++it)
	{
		VkMemoryAllocateInfo alloc =
		{
			VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,							// sType
			DE_NULL,														// pNext
			size,															// allocationSize
			0U																// memoryTypeIndex;
		};
		*it = DeviceMemorySp(new Unique<VkDeviceMemory>(allocateMemory(vkd, device, &alloc)));
	}
}

void createBuffers			(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 VkDeviceSize							size,
							 std::vector<BufferSp>::iterator		begin,
							 std::vector<BufferSp>::iterator		end)
{
	deUint32 queueFamilyIndex = 0u;
	for (std::vector<BufferSp>::iterator it = begin; it != end; ++it)
	{
		const VkBufferCreateInfo	bufferCI =
		{
			VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,							// sType
			DE_NULL,														// pNext
			0u,																// flags
			size,															// size
			VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,								// usage
			VK_SHARING_MODE_EXCLUSIVE,										// sharingMode
			1u,																// queueFamilyIndexCount
			&queueFamilyIndex,												// pQueueFamilyIndices
		};
		*it = BufferSp(new Unique<VkBuffer>(createBuffer(vkd, device, &bufferCI)));
	}
}

void createImages			(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 deUint32								size,
							 std::vector<ImageSp>::iterator			begin,
							 std::vector<ImageSp>::iterator			end)
{
	deUint32 queueFamilyIndex = 0u;
	for (std::vector<ImageSp>::iterator it = begin; it != end; ++it)
	{
		const VkImageCreateInfo			imageCI =
		{
			VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,							// VkStructureType			sType
			DE_NULL,														// const void*				pNext
			(VkImageCreateFlags)0u,											// VkImageCreateFlags		flags
			VK_IMAGE_TYPE_2D,												// VkImageType				imageType
			VK_FORMAT_R8_UNORM,												// VkFormat					format
			{
				size,														// deUint32	width
				size,														// deUint32	height
				1u															// deUint32	depth
			},																// VkExtent3D				extent
			1u,																// deUint32					mipLevels
			1u,																// deUint32					arrayLayers
			VK_SAMPLE_COUNT_1_BIT,											// VkSampleCountFlagBits	samples
			VK_IMAGE_TILING_OPTIMAL,										// VkImageTiling			tiling
			VK_IMAGE_USAGE_SAMPLED_BIT,										// VkImageUsageFlags		usage
			VK_SHARING_MODE_EXCLUSIVE,										// VkSharingMode			sharingMode
			1u,																// deUint32					queueFamilyIndexCount
			&queueFamilyIndex,												// const deUint32*			pQueueFamilyIndices
			VK_IMAGE_LAYOUT_UNDEFINED										// VkImageLayout			initialLayout
		};
		*it = ImageSp(new Unique<VkImage>(createImage(vkd, device, &imageCI)));
	}
}

void createEvents			(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 std::vector<EventSp>::iterator			begin,
							 std::vector<EventSp>::iterator			end)
{
	for(std::vector<EventSp>::iterator it=begin; it!=end; ++it)
		*it = EventSp(new Unique<VkEvent>(createEvent(vkd, device)));
}

void createQueryPools		(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 std::vector<QueryPoolSp>::iterator		begin,
							 std::vector<QueryPoolSp>::iterator		end)
{
	for (std::vector<QueryPoolSp>::iterator it = begin; it != end; ++it)
	{
		const VkQueryPoolCreateInfo	queryPoolCI =
		{
			VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,						//  VkStructureType					sType
			DE_NULL,														//  const void*						pNext
			(VkQueryPoolCreateFlags)0,										//  VkQueryPoolCreateFlags			flags
			VK_QUERY_TYPE_OCCLUSION,										//  VkQueryType						queryType
			1u,																//  deUint32						queryCount
			0u,																//  VkQueryPipelineStatisticFlags	pipelineStatistics
		};
		*it = QueryPoolSp(new Unique<VkQueryPool>(createQueryPool(vkd, device, &queryPoolCI)));
	}
}

void createBufferViews		(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 const VkBuffer							buffer,
							 const VkDeviceSize						size,
							 std::vector<BufferViewSp>::iterator	begin,
							 std::vector<BufferViewSp>::iterator	end)
{
	for (std::vector<BufferViewSp>::iterator it = begin; it != end; ++it)
	{
		const VkBufferViewCreateInfo bufferViewCI =
		{
			VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,						// VkStructureType			sType
			DE_NULL,														// const void*				pNext
			0u,																// VkBufferViewCreateFlags	flags
			buffer,															// VkBuffer					buffer
			VK_FORMAT_R8_UNORM,												// VkFormat					format
			0ull,															// VkDeviceSize				offset
			size															// VkDeviceSize				range
		};
		*it = BufferViewSp(new Unique<VkBufferView>(createBufferView(vkd, device, &bufferViewCI)));
	}
}

void createImageViews		(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 const VkImage							image,
							 std::vector<ImageViewSp>::iterator		begin,
							 std::vector<ImageViewSp>::iterator		end)
{
	for (std::vector<ImageViewSp>::iterator it = begin; it != end; ++it)
	{
		VkComponentMapping componentMapping { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY };
		VkImageViewCreateInfo imageViewCI =
		{
			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,						// VkStructureType          sType
			DE_NULL,														// const void*              pNext
			0u,																// VkImageViewCreateFlags   flags
			image,															// VkImage                  image
			VK_IMAGE_VIEW_TYPE_2D,											// VkImageViewType          viewType
			VK_FORMAT_R8_UNORM,												// VkFormat                 format
			componentMapping,												// VkComponentMapping       components
			{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u },					// VkImageSubresourceRange  subresourceRange
		};
		*it = ImageViewSp(new Unique<VkImageView>(createImageView(vkd, device, &imageViewCI)));
	}
}

void createPipelineLayouts	(const DeviceInterface&						vkd,
							 const VkDevice								device,
							 std::vector<PipelineLayoutSp>::iterator	begin,
							 std::vector<PipelineLayoutSp>::iterator	end)
{
	for (std::vector<PipelineLayoutSp>::iterator it = begin; it != end; ++it)
	{
		const VkPipelineLayoutCreateInfo pipelineLayoutCI =
		{
			VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,					// VkStructureType					sType
			DE_NULL,														// const void*						pNext
			0u,																// VkPipelineLayoutCreateFlags		flags
			0u,																// deUint32							setLayoutCount
			DE_NULL,														// const VkDescriptorSetLayout*		pSetLayouts
			0u,																// deUint32							pushConstantRangeCount
			DE_NULL															// const VkPushConstantRange*		pPushConstantRanges
		};
		*it = PipelineLayoutSp(new Unique<VkPipelineLayout>(createPipelineLayout(vkd, device, &pipelineLayoutCI)));
	}
}

void createRenderPasses		(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 VkAttachmentDescription*				colorAttachment,
							 std::vector<RenderPassSp>::iterator	begin,
							 std::vector<RenderPassSp>::iterator	end)
{
	for (std::vector<RenderPassSp>::iterator it = begin; it != end; ++it)
	{
		const VkAttachmentReference		colorAttachmentRef =
		{
			0u,																// deUint32			attachment
			VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL						// VkImageLayout	layout
		};

		const VkSubpassDescription		subpassDescription =
		{
			0u,																// VkSubpassDescriptionFlags	flags
			VK_PIPELINE_BIND_POINT_GRAPHICS,								// VkPipelineBindPoint			pipelineBindPoint
			0u,																// deUint32						inputAttachmentCount
			DE_NULL,														// const VkAttachmentReference*	pInputAttachments
			1u,																// deUint32						colorAttachmentCount
			&colorAttachmentRef,											// const VkAttachmentReference*	pColorAttachments
			DE_NULL,														// const VkAttachmentReference*	pResolveAttachments
			DE_NULL,														// const VkAttachmentReference*	pDepthStencilAttachment
			0u,																// deUint32						preserveAttachmentCount
			DE_NULL															// const deUint32*				pPreserveAttachments
		};

		const VkRenderPassCreateInfo	renderPassCI =
		{
			VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,	// VkStructureType					sType
			DE_NULL,									// const void*						pNext
			0u,											// VkRenderPassCreateFlags			flags
			1u,											// deUint32							attachmentCount
			colorAttachment,							// const VkAttachmentDescription*	pAttachments
			1u,											// deUint32							subpassCount
			&subpassDescription,						// const VkSubpassDescription*		pSubpasses
			0u,											// deUint32							dependencyCount
			DE_NULL										// const VkSubpassDependency*		pDependencies
		};
		*it = RenderPassSp(new Unique<VkRenderPass>(createRenderPass(vkd, device, &renderPassCI)));
	}
}

void createGraphicsPipelines (const DeviceInterface&				vkd,
							  const VkDevice						device,
							  VkShaderModule						vertexShaderModule,
							  VkShaderModule						fragmentShaderModule,
							  VkRenderPass							renderPass,
							  VkPipelineLayout						pipelineLayout,
							  VkDeviceSize							poolEntrySize,
							  de::SharedPtr<vk::ResourceInterface>	resourceInterface,
							  std::vector<PipelineSp>::iterator		begin,
							  std::vector<PipelineSp>::iterator		end)
{
	std::vector<VkPipelineShaderStageCreateInfo> shaderStageCreateInfos;
	shaderStageCreateInfos.push_back
	(
		{
			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,			// VkStructureType                     sType;
			DE_NULL,														// const void*                         pNext;
			(VkPipelineShaderStageCreateFlags)0,							// VkPipelineShaderStageCreateFlags    flags;
			VK_SHADER_STAGE_VERTEX_BIT,										// VkShaderStageFlagBits               stage;
			vertexShaderModule,												// VkShaderModule                      shader;
			"main",															// const char*                         pName;
			DE_NULL,														// const VkSpecializationInfo*         pSpecializationInfo;
		}
	);

	shaderStageCreateInfos.push_back
	(
		{
			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,			// VkStructureType                     sType;
			DE_NULL,														// const void*                         pNext;
			(VkPipelineShaderStageCreateFlags)0,							// VkPipelineShaderStageCreateFlags    flags;
			VK_SHADER_STAGE_FRAGMENT_BIT,									// VkShaderStageFlagBits               stage;
			fragmentShaderModule,											// VkShaderModule                      shader;
			"main",															// const char*                         pName;
			DE_NULL,														// const VkSpecializationInfo*         pSpecializationInfo;
		}
	);

	for (std::vector<PipelineSp>::iterator it = begin; it != end; ++it)
	{
		const VkPipelineVertexInputStateCreateInfo		vertexInputStateCreateInfo		=
		{
			VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,		// VkStructureType                             sType;
			DE_NULL,														// const void*                                 pNext;
			(VkPipelineVertexInputStateCreateFlags)0,						// VkPipelineVertexInputStateCreateFlags       flags;
			0u,																// deUint32                                    vertexBindingDescriptionCount;
			DE_NULL,														// const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
			0u,																// deUint32                                    vertexAttributeDescriptionCount;
			DE_NULL															// const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
		};

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

		const VkPipelineViewportStateCreateInfo			viewPortStateCreateInfo			=
		{
			VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,			// VkStructureType                       sType;
			DE_NULL,														// const void*                           pNext;
			(VkPipelineViewportStateCreateFlags)0,							// VkPipelineViewportStateCreateFlags    flags;
			1,																// deUint32                              viewportCount;
			DE_NULL,														// const VkViewport*                     pViewports;
			1,																// deUint32                              scissorCount;
			DE_NULL															// const VkRect2D*                       pScissors;
		};

		const VkPipelineRasterizationStateCreateInfo	rasterizationStateCreateInfo	=
		{
			VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,		// VkStructureType                            sType;
			DE_NULL,														// const void*                                pNext;
			(VkPipelineRasterizationStateCreateFlags)0,						// VkPipelineRasterizationStateCreateFlags    flags;
			VK_FALSE,														// VkBool32                                   depthClampEnable;
			VK_FALSE,														// VkBool32                                   rasterizerDiscardEnable;
			VK_POLYGON_MODE_FILL,											// VkPolygonMode                              polygonMode;
			VK_CULL_MODE_BACK_BIT,											// 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;
			DE_NULL,														// const void*                              pNext;
			(VkPipelineMultisampleStateCreateFlags)0,						// VkPipelineMultisampleStateCreateFlags    flags;
			VK_SAMPLE_COUNT_1_BIT,											// VkSampleCountFlagBits                    rasterizationSamples;
			VK_FALSE,														// VkBool32                                 sampleShadingEnable;
			0.0f,															// float                                    minSampleShading;
			DE_NULL,														// const VkSampleMask*                      pSampleMask;
			VK_FALSE,														// VkBool32                                 alphaToCoverageEnable;
			VK_FALSE														// VkBool32                                 alphaToOneEnable;
		};

		const VkPipelineColorBlendAttachmentState		colorBlendAttachmentState		=
		{
			VK_FALSE,														// VkBool32                 blendEnable;
			VK_BLEND_FACTOR_ZERO,											// VkBlendFactor            srcColorBlendFactor;
			VK_BLEND_FACTOR_ZERO,											// VkBlendFactor            dstColorBlendFactor;
			VK_BLEND_OP_ADD,												// VkBlendOp                colorBlendOp;
			VK_BLEND_FACTOR_ZERO,											// VkBlendFactor            srcAlphaBlendFactor;
			VK_BLEND_FACTOR_ZERO,											// VkBlendFactor            dstAlphaBlendFactor;
			VK_BLEND_OP_ADD,												// VkBlendOp                alphaBlendOp;
			(VkColorComponentFlags)0xFu										// VkColorComponentFlags    colorWriteMask;
		};

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

		const VkDynamicState							dynamicStates[]					=
		{
			VK_DYNAMIC_STATE_VIEWPORT,
			VK_DYNAMIC_STATE_SCISSOR
		};

		const VkPipelineDynamicStateCreateInfo			dynamicStateCreateInfo			=
		{
			VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,			// VkStructureType                      sType;
			DE_NULL,														// const void*                          pNext;
			(VkPipelineDynamicStateCreateFlags)0u,							// VkPipelineDynamicStateCreateFlags    flags;
			DE_LENGTH_OF_ARRAY(dynamicStates),								// deUint32                             dynamicStateCount;
			dynamicStates													// const VkDynamicState*                pDynamicStates;
		};

		VkGraphicsPipelineCreateInfo					graphicsPipelineCI				=
		{
			VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,				// VkStructureType                                  sType;
			DE_NULL,														// const void*                                      pNext;
			(VkPipelineCreateFlags)0,										// VkPipelineCreateFlags                            flags;
			deUint32(shaderStageCreateInfos.size()),						// deUint32                                         stageCount;
			shaderStageCreateInfos.data(),									// const VkPipelineShaderStageCreateInfo*           pStages;
			&vertexInputStateCreateInfo,									// const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
			&inputAssemblyStateCreateInfo,									// const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
			DE_NULL,														// const VkPipelineTessellationStateCreateInfo*     pTessellationState;
			&viewPortStateCreateInfo,										// const VkPipelineViewportStateCreateInfo*         pViewportState;
			&rasterizationStateCreateInfo,									// const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
			&multisampleStateCreateInfo,									// const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
			DE_NULL,														// const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
			&colorBlendStateCreateInfo,										// const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
			&dynamicStateCreateInfo,										// const VkPipelineDynamicStateCreateInfo*          pDynamicState;
			pipelineLayout,													// VkPipelineLayout                                 layout;
			renderPass,														// VkRenderPass                                     renderPass;
			0u,																// deUint32                                         subpass;
			DE_NULL,														// VkPipeline                                       basePipelineHandle;
			0																// int                                              basePipelineIndex;
		};

		// we have to ensure that proper poolEntrySize is used
		VkPipelineOfflineCreateInfo						pipelineOfflineCreateInfo;
		if (poolEntrySize != 0u)
		{
			pipelineOfflineCreateInfo				= resetPipelineOfflineCreateInfo();
			std::size_t					hashValue	= calculateGraphicsPipelineHash(graphicsPipelineCI, resourceInterface->getObjectHashes());
			memcpy(pipelineOfflineCreateInfo.pipelineIdentifier, &hashValue, sizeof(std::size_t));
			pipelineOfflineCreateInfo.poolEntrySize = poolEntrySize;
			graphicsPipelineCI.pNext				= &pipelineOfflineCreateInfo;
		}

		*it = PipelineSp(new Unique<VkPipeline>(createGraphicsPipeline(vkd, device, (VkPipelineCache)0u, &graphicsPipelineCI)));
	}
}

void createComputePipelines (const DeviceInterface&					vkd,
							 const VkDevice							device,
							 VkShaderModule							shaderModule,
							 VkPipelineLayout						pipelineLayout,
							 VkDeviceSize							poolEntrySize,
							 de::SharedPtr<vk::ResourceInterface>	resourceInterface,
							 std::vector<PipelineSp>::iterator		begin,
							 std::vector<PipelineSp>::iterator		end)
{
	for (std::vector<PipelineSp>::iterator it = begin; it != end; ++it)
	{
		VkPipelineShaderStageCreateInfo				shaderStageCreateInfo	=
		{
			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,			// VkStructureType                     sType;
			DE_NULL,														// const void*                         pNext;
			(VkPipelineShaderStageCreateFlags)0,							// VkPipelineShaderStageCreateFlags    flags;
			VK_SHADER_STAGE_COMPUTE_BIT,									// VkShaderStageFlagBits               stage;
			shaderModule,													// VkShaderModule                      shader;
			"main",															// const char*                         pName;
			DE_NULL,														// const VkSpecializationInfo*         pSpecializationInfo;
		};

		VkComputePipelineCreateInfo						computePipelineCI	=
		{
			VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,					// VkStructureType					sType
			DE_NULL,														// const void*						pNext
			0u,																// VkPipelineCreateFlags			flags
			shaderStageCreateInfo,											// VkPipelineShaderStageCreateInfo	stage
			pipelineLayout,													// VkPipelineLayout					layout
			(vk::VkPipeline)0,												// VkPipeline						basePipelineHandle
			0u,																// deInt32							basePipelineIndex
		};

		// we have to ensure that proper poolEntrySize is used
		VkPipelineOfflineCreateInfo						pipelineOfflineCreateInfo;
		if (poolEntrySize != 0u)
		{
			pipelineOfflineCreateInfo				= resetPipelineOfflineCreateInfo();
			std::size_t					hashValue	= calculateComputePipelineHash(computePipelineCI, resourceInterface->getObjectHashes());
			memcpy(pipelineOfflineCreateInfo.pipelineIdentifier, &hashValue, sizeof(std::size_t));
			pipelineOfflineCreateInfo.poolEntrySize = poolEntrySize;
			computePipelineCI.pNext					= &pipelineOfflineCreateInfo;
		}

		*it = PipelineSp(new Unique<VkPipeline>(createComputePipeline(vkd, device, (VkPipelineCache)0u, &computePipelineCI)));
	}
}

void createDescriptorSetLayouts	(const DeviceInterface&							vkd,
								 const VkDevice									device,
								 std::vector<DescriptorSetLayoutSp>::iterator	begin,
								 std::vector<DescriptorSetLayoutSp>::iterator	end)
{
	for (std::vector<DescriptorSetLayoutSp>::iterator it = begin; it != end; ++it)
	{
		const VkDescriptorSetLayoutBinding descriptorSetLayoutBinding =
		{
			0,																// binding
			VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,								// descriptorType
			1u,																// descriptorCount
			VK_SHADER_STAGE_ALL,											// stageFlags
			NULL															// pImmutableSamplers
		};

		const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCI =
		{
			VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,			// sType
			NULL,															// pNext
			(VkDescriptorSetLayoutCreateFlags)0u,							// flags
			1u,																// bindingCount
			&descriptorSetLayoutBinding										// pBindings
		};
		*it = DescriptorSetLayoutSp(new Unique<VkDescriptorSetLayout>(createDescriptorSetLayout(vkd, device, &descriptorSetLayoutCI)));
	}
}

void createSamplers			(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 std::vector<SamplerSp>::iterator		begin,
							 std::vector<SamplerSp>::iterator		end)
{
	for (std::vector<SamplerSp>::iterator it = begin; it != end; ++it)
	{
		const VkSamplerCreateInfo samplerCI =
		{
			VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,							//VkStructureType		sType
			DE_NULL,														//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_CLAMP_TO_EDGE,							//VkSamplerAddressMode	addressModeU
			VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,							//VkSamplerAddressMode	addressModeV
			VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,							//VkSamplerAddressMode	addressModeW
			0.0f,															//float					mipLodBias
			VK_FALSE,														//VkBool32				anisotropyEnable
			1.0f,															//float					maxAnisotropy
			VK_FALSE,														//VkBool32				compareEnable
			VK_COMPARE_OP_EQUAL,											//VkCompareOp			compareOp
			0.0f,															//float					minLod
			0.0f,															//float					maxLod
			VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,						//VkBorderColor			borderColor
			VK_TRUE,														//VkBool32				unnormalizedCoordinates
		};
		*it = SamplerSp(new Unique<VkSampler>(createSampler(vkd, device, &samplerCI)));
	}
}

void createDescriptorPools	(const DeviceInterface&						vkd,
							 const VkDevice								device,
							 deUint32									maxSets,
							 std::vector<DescriptorPoolSp>::iterator	begin,
							 std::vector<DescriptorPoolSp>::iterator	end)
{
	for (std::vector<DescriptorPoolSp>::iterator it = begin; it != end; ++it)
	{
		const VkDescriptorPoolSize			poolSizes =
		{
			VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
			1u
		};
		const VkDescriptorPoolCreateInfo	descriptorPoolCI =
		{
			VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,					// sType
			DE_NULL,														// pNext
			(VkDescriptorPoolCreateFlags)0u,								// flags
			maxSets,														// maxSets
			1u,																// poolSizeCount
			&poolSizes,														// pPoolSizes
		};
		*it = DescriptorPoolSp(new Unique<VkDescriptorPool>(createDescriptorPool(vkd, device, &descriptorPoolCI)));
	}
}

void createDescriptorSets	(const DeviceInterface&						vkd,
							 const VkDevice								device,
							 const VkDescriptorPool						descriptorPool,
							 const VkDescriptorSetLayout				setLayout,
							 std::vector<DescriptorSetSp>::iterator		begin,
							 std::vector<DescriptorSetSp>::iterator		end)
{
	for (std::vector<DescriptorSetSp>::iterator it = begin; it != end; ++it)
	{
		const VkDescriptorSetAllocateInfo descriptorSetAI =
		{
			VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,					// VkStructureType                 sType
			DE_NULL,														// const void*                     pNext
			descriptorPool,													// VkDescriptorPool                descriptorPool
			1u,																// deUint32                        descriptorSetCount
			&setLayout														// const VkDescriptorSetLayout*    pSetLayouts
		};
		*it = DescriptorSetSp(new Unique<VkDescriptorSet>(allocateDescriptorSet(vkd, device, &descriptorSetAI)));
	}
}

void createFramebuffers		(const DeviceInterface&						vkd,
							 const VkDevice								device,
							 const VkRenderPass							renderPass,
							 const VkImageView							imageView,
							 std::vector<FramebufferSp>::iterator		begin,
							 std::vector<FramebufferSp>::iterator		end)
{
	for (std::vector<FramebufferSp>::iterator it = begin; it != end; ++it)
	{
		const VkFramebufferCreateInfo framebufferCi =
		{
			VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,						// VkStructureType			sType
			DE_NULL,														// const void*				pNext
			0u,																// VkFramebufferCreateFlags	flags
			renderPass,														// VkRenderPass				renderPass
			1u,																// uint32_t					attachmentCount
			&imageView,														// const VkImageView*		pAttachments
			8u,																// uint32_t					width
			8u,																// uint32_t					height
			1u																// uint32_t					layers
		};

		*it = FramebufferSp(new Unique<VkFramebuffer>(createFramebuffer(vkd, device, &framebufferCi)));
	}
}

void createCommandPools		(const DeviceInterface&					vkd,
							 const VkDevice							device,
							 std::vector<CommandPoolSp>::iterator	begin,
							 std::vector<CommandPoolSp>::iterator	end)
{
	for (std::vector<CommandPoolSp>::iterator it = begin; it != end; ++it)
	{
		const VkCommandPoolCreateInfo			commandPoolCI =
		{
			VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,						// sType
			DE_NULL,														// pNext
			0u,																// flags
			0u,																// queueFamilyIndex
		};
		*it = CommandPoolSp(new Unique<VkCommandPool>(createCommandPool(vkd, device, &commandPoolCI)));
	}
}

void createSamplerYcbcrConversions (const DeviceInterface&							vkd,
									const VkDevice									device,
									std::vector<SamplerYcbcrConversionSp>::iterator	begin,
									std::vector<SamplerYcbcrConversionSp>::iterator	end)
{
	for (std::vector<SamplerYcbcrConversionSp>::iterator it = begin; it != end; ++it)
	{
		const VkSamplerYcbcrConversionCreateInfo	ycbcrConversionCI =
		{
			VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,			// sType
			DE_NULL,														// pNext
			VK_FORMAT_G8B8G8R8_422_UNORM,									// format
			VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,					// ycbcrModel
			VK_SAMPLER_YCBCR_RANGE_ITU_FULL,								// ycbcrRange
			{
				VK_COMPONENT_SWIZZLE_IDENTITY,								// r
				VK_COMPONENT_SWIZZLE_IDENTITY,								// g
				VK_COMPONENT_SWIZZLE_IDENTITY,								// b
				VK_COMPONENT_SWIZZLE_IDENTITY,								// a
			},																// components
			VK_CHROMA_LOCATION_MIDPOINT,									// xChromaOffset
			VK_CHROMA_LOCATION_MIDPOINT,									// yChromaOffset
			VK_FILTER_NEAREST,												// chromaFilter
			VK_FALSE,														// forceExplicitReconstruction
			};
		*it = SamplerYcbcrConversionSp(new Unique<VkSamplerYcbcrConversion>(createSamplerYcbcrConversion(vkd, device, &ycbcrConversionCI)));
	}
}

// Base class for all VkDeviceObjectReservationCreateInfo tests.
// Creates a device with 0 for all "max" values / and "RequestCounts"
class DeviceObjectReservationInstance : public vkt::TestInstance
{
public:
										DeviceObjectReservationInstance		(Context&								context,
																			 const TestParams&						testParams_);
	tcu::TestStatus						iterate								(void) override;

	virtual Move<VkDevice>				createTestDevice					(VkDeviceCreateInfo&					deviceCreateInfo,
																			 VkDeviceObjectReservationCreateInfo&	objectInfo,
																			 VkPhysicalDeviceVulkanSC10Features&	sc10Features);
	virtual void						performTest							(const DeviceInterface&					vkd,
																			 VkDevice								device);
	virtual bool						verifyTestResults					(const DeviceInterface&					vkd,
																			 VkDevice								device);

protected:
	TestParams							testParams;
	vkt::CustomInstance					instance;
	VkPhysicalDevice					physicalDevice;
};

DeviceObjectReservationInstance::DeviceObjectReservationInstance (Context&			context,
																  const TestParams&	testParams_)
	: vkt::TestInstance				( context )
	, testParams					( testParams_ )
	, instance						( vkt::createCustomInstanceFromContext(context) )
	, physicalDevice				( chooseDevice(instance.getDriver(), instance, context.getTestContext().getCommandLine()) )
{
}

tcu::TestStatus DeviceObjectReservationInstance::iterate (void)
{
	const float						queuePriority		= 1.0f;

	const VkDeviceQueueCreateInfo	deviceQueueCI		=
	{
		VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,							// sType
		DE_NULL,															// pNext
		(VkDeviceQueueCreateFlags)0u,										// flags
		0,																	//queueFamilyIndex;
		1,																	//queueCount;
		&queuePriority,														//pQueuePriorities;
	};

	VkDeviceCreateInfo				deviceCreateInfo	=
	{
		VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,								// sType;
		DE_NULL,															// pNext;
		(VkDeviceCreateFlags)0u,											// flags
		1,																	// queueRecordCount;
		&deviceQueueCI,														// pRequestedQueues;
		0,																	// layerCount;
		DE_NULL,															// ppEnabledLayerNames;
		0,																	// extensionCount;
		DE_NULL,															// ppEnabledExtensionNames;
		DE_NULL,															// pEnabledFeatures;
	};

	void* pNext = DE_NULL;

	VkDeviceObjectReservationCreateInfo	objectInfo		= resetDeviceObjectReservationCreateInfo();
	objectInfo.pipelineCacheRequestCount				= 1u;
	objectInfo.pNext									= pNext;
	pNext												= &objectInfo;

	VkPhysicalDeviceVulkanSC10Features	sc10Features	= createDefaultSC10Features();
	sc10Features.pNext									= pNext;
	pNext												= &sc10Features;

	deviceCreateInfo.pNext								= pNext;

	Move<VkDevice>					device				= createTestDevice(deviceCreateInfo, objectInfo, sc10Features);
	de::MovePtr<DeviceDriverSC, DeinitDeviceDeleter>
									deviceDriver		= de::MovePtr<DeviceDriverSC, DeinitDeviceDeleter>(new DeviceDriverSC(m_context.getPlatformInterface(), instance, *device, m_context.getTestContext().getCommandLine(), m_context.getResourceInterface(), m_context.getDeviceVulkanSC10Properties()),
															DeinitDeviceDeleter(m_context.getResourceInterface().get(), *device));

	performTest(*deviceDriver, *device);

	const VkQueue					queue				= getDeviceQueue(*deviceDriver, *device,  0, 0);
	VK_CHECK(deviceDriver->queueWaitIdle(queue));

	if (!verifyTestResults(*deviceDriver, *device))
		return tcu::TestStatus::fail("Failed");
	return tcu::TestStatus::pass("Pass");
}

Move<VkDevice> DeviceObjectReservationInstance::createTestDevice (VkDeviceCreateInfo&					deviceCreateInfo,
																  VkDeviceObjectReservationCreateInfo&	objectInfo,
																  VkPhysicalDeviceVulkanSC10Features&	sc10Features)
{
	DE_UNREF(sc10Features);

	// perform any non pipeline operations - create 2 semaphores
	objectInfo.semaphoreRequestCount = 2u;

	return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
}

void DeviceObjectReservationInstance::performTest (const DeviceInterface&				vkd,
												   VkDevice								device)
{
	std::vector<SemaphoreSp> semaphores(2u);
	createSemaphores(vkd, device, begin(semaphores), end(semaphores));
}

bool DeviceObjectReservationInstance::verifyTestResults (const DeviceInterface&			vkd,
														 VkDevice						device)
{
	DE_UNREF(vkd);
	DE_UNREF(device);
	return true;
}

// Creates device with multiple VkDeviceObjectReservationCreateInfo and ensures that the limits of an individual VkDeviceObjectReservationCreateInfo can be exceeded.
class MultipleReservation : public DeviceObjectReservationInstance
{
public:
	MultipleReservation (Context&			context,
						 const TestParams&	testParams_)
		: DeviceObjectReservationInstance(context, testParams_)
	{
	}
	Move<VkDevice> createTestDevice (VkDeviceCreateInfo&					deviceCreateInfo,
									 VkDeviceObjectReservationCreateInfo&	objectInfo,
									 VkPhysicalDeviceVulkanSC10Features&	sc10Features) override
	{
		DE_UNREF(sc10Features);

		VkDeviceObjectReservationCreateInfo  thirdObjectInfo	= resetDeviceObjectReservationCreateInfo();
		thirdObjectInfo.deviceMemoryRequestCount				= 2;

		VkDeviceObjectReservationCreateInfo  secondObjectInfo	= resetDeviceObjectReservationCreateInfo();
		secondObjectInfo.deviceMemoryRequestCount				= 2;
		secondObjectInfo.pNext									= &thirdObjectInfo;

		objectInfo.deviceMemoryRequestCount						= 2;
		objectInfo.pNext										= &secondObjectInfo;

		return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
	}

	void performTest (const DeviceInterface&				vkd,
					  VkDevice								device) override
	{
		std::vector<VkDeviceMemory>	memoryObjects(6, (VkDeviceMemory)0);
		for (size_t ndx = 0; ndx < 6; ndx++)
		{
			VkMemoryAllocateInfo alloc =
			{
				VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,						// sType
				DE_NULL,													// pNext
				128U,														// allocationSize
				0U															// memoryTypeIndex;
			};

			VK_CHECK(vkd.allocateMemory(device, &alloc, (const VkAllocationCallbacks*)DE_NULL, &memoryObjects[ndx]));

			TCU_CHECK(!!memoryObjects[ndx]);
		}
	}
};

void checkSupportVerifyMaxValues (vkt::Context& context, TestParams testParams)
{
	if (testParams.testMaxValues == TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL && context.getDeviceFeatures().pipelineStatisticsQuery == VK_FALSE)
		TCU_THROW(NotSupportedError, "pipelineStatisticsQuery is not supported");
}

// For each of the various resource "max" values, create resources that exercise the maximum values requested

class VerifyMaxValues : public DeviceObjectReservationInstance
{
public:
	VerifyMaxValues					(Context&								context,
									 const TestParams&						testParams_)
		: DeviceObjectReservationInstance(context, testParams_)
	{
	}
	Move<VkDevice> createTestDevice (VkDeviceCreateInfo&					deviceCreateInfo,
									 VkDeviceObjectReservationCreateInfo&	objectInfo,
									 VkPhysicalDeviceVulkanSC10Features&	sc10Features) override
	{
		DE_UNREF(sc10Features);
		switch (testParams.testMaxValues)
		{
			case TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT:
				objectInfo.descriptorSetLayoutBindingLimit			= VERIFYMAXVALUES_OBJECT_COUNT+1u;
				objectInfo.descriptorSetLayoutBindingRequestCount	= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.descriptorSetLayoutRequestCount			= 1u;
				break;
			case TMV_MAX_IMAGEVIEW_MIPLEVELS:
				objectInfo.maxImageViewMipLevels					= VERIFYMAXVALUES_MIPLEVELS;
				objectInfo.maxImageViewArrayLayers					= 1u;
				objectInfo.imageRequestCount						= 1u;
				objectInfo.deviceMemoryRequestCount					= 1u;
				break;
			case TMV_MAX_IMAGEVIEW_ARRAYLAYERS:
				objectInfo.maxImageViewMipLevels					= 1u;
				objectInfo.maxImageViewArrayLayers					= VERIFYMAXVALUES_ARRAYLAYERS;
				objectInfo.imageRequestCount						= 1u;
				objectInfo.deviceMemoryRequestCount					= 1u;
				break;
			case TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS:
				objectInfo.maxLayeredImageViewMipLevels				= VERIFYMAXVALUES_MIPLEVELS;
				objectInfo.maxImageViewArrayLayers					= VERIFYMAXVALUES_ARRAYLAYERS;
				objectInfo.imageRequestCount						= 1u;
				objectInfo.deviceMemoryRequestCount					= 1u;
				break;
			case TMV_MAX_OCCLUSION_QUERIES_PER_POOL:
				objectInfo.maxOcclusionQueriesPerPool				= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.queryPoolRequestCount					= 1u;
				break;
			case TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL:
				objectInfo.maxPipelineStatisticsQueriesPerPool		= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.queryPoolRequestCount					= 1u;
				break;
			case TMV_MAX_TIMESTAMP_QUERIES_PER_POOL:
				objectInfo.maxTimestampQueriesPerPool				= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.queryPoolRequestCount					= 1u;
				break;
			default:
				TCU_THROW(InternalError, "Unsupported max value");
		}

		return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
	}

	void performTest (const DeviceInterface&				vkd,
					  VkDevice								device) override
	{
		SimpleAllocator					allocator(vkd, device, getPhysicalDeviceMemoryProperties(instance.getDriver(), physicalDevice));
		de::MovePtr<ImageWithMemory>	image;
		Move<VkQueryPool>				queryPool;
		Move<VkDescriptorSetLayout>		descriptorSetLayout;
		deUint32						queueFamilyIndex = 0u;

		switch (testParams.testMaxValues)
		{
			case TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT:
			{
				const VkDescriptorSetLayoutBinding	binding =
				{
					VERIFYMAXVALUES_OBJECT_COUNT,							// binding
					VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,						// descriptorType
					1u,														// descriptorCount
					VK_SHADER_STAGE_ALL,									// stageFlags
					DE_NULL,												// pImmutableSamplers
				};

				const VkDescriptorSetLayoutCreateInfo	layoutCreateInfo =
				{
					VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
					DE_NULL,												// pNext
					0u,														// flags
					1u,														// bindingCount
					&binding,												// pBindings
				};
				descriptorSetLayout = createDescriptorSetLayout(vkd, device, &layoutCreateInfo);
				break;
			}
			case TMV_MAX_IMAGEVIEW_MIPLEVELS:
			{
				const VkImageCreateInfo			imageCreateInfo =
				{
					VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,					// VkStructureType			sType;
					DE_NULL,												// const void*				pNext;
					(VkImageCreateFlags)0u,									// VkImageCreateFlags		flags;
					VK_IMAGE_TYPE_2D,										// VkImageType				imageType;
					VK_FORMAT_R8_UNORM,										// VkFormat					format;
					{
						1 << VERIFYMAXVALUES_MIPLEVELS,						// deUint32	width;
						1 << VERIFYMAXVALUES_MIPLEVELS,						// deUint32	height;
						1u													// deUint32	depth;
					},														// VkExtent3D				extent;
					VERIFYMAXVALUES_MIPLEVELS,								// deUint32					mipLevels;
					1u,														// deUint32					arrayLayers;
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits	samples;
					VK_IMAGE_TILING_OPTIMAL,								// VkImageTiling			tiling;
					VK_IMAGE_USAGE_SAMPLED_BIT,								// VkImageUsageFlags		usage;
					VK_SHARING_MODE_EXCLUSIVE,								// VkSharingMode			sharingMode;
					1u,														// deUint32					queueFamilyIndexCount;
					&queueFamilyIndex,										// const deUint32*			pQueueFamilyIndices;
					VK_IMAGE_LAYOUT_UNDEFINED								// VkImageLayout			initialLayout;
				};
				image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
				break;
			}
			case TMV_MAX_IMAGEVIEW_ARRAYLAYERS:
			{
				const VkImageCreateInfo			imageCreateInfo =
				{
					VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,					// VkStructureType			sType;
					DE_NULL,												// const void*				pNext;
					(VkImageCreateFlags)0u,									// VkImageCreateFlags		flags;
					VK_IMAGE_TYPE_2D,										// VkImageType				imageType;
					VK_FORMAT_R8_UNORM,										// VkFormat					format;
					{
						16U,												// deUint32	width;
						16U,												// deUint32	height;
						1u													// deUint32	depth;
					},														// VkExtent3D				extent;
					1u,														// deUint32					mipLevels;
					VERIFYMAXVALUES_ARRAYLAYERS,							// deUint32					arrayLayers;
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits	samples;
					VK_IMAGE_TILING_OPTIMAL,								// VkImageTiling			tiling;
					VK_IMAGE_USAGE_SAMPLED_BIT,								// VkImageUsageFlags		usage;
					VK_SHARING_MODE_EXCLUSIVE,								// VkSharingMode			sharingMode;
					1u,														// deUint32					queueFamilyIndexCount;
					&queueFamilyIndex,										// const deUint32*			pQueueFamilyIndices;
					VK_IMAGE_LAYOUT_UNDEFINED								// VkImageLayout			initialLayout;
				};
				image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
				break;
			}
			case TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS:
			{
				const VkImageCreateInfo			imageCreateInfo =
				{
					VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,					// VkStructureType			sType;
					DE_NULL,												// const void*				pNext;
					(VkImageCreateFlags)0u,									// VkImageCreateFlags		flags;
					VK_IMAGE_TYPE_2D,										// VkImageType				imageType;
					VK_FORMAT_R8_UNORM,										// VkFormat					format;
					{
						1 << VERIFYMAXVALUES_MIPLEVELS,						// deUint32	width;
						1 << VERIFYMAXVALUES_MIPLEVELS,						// deUint32	height;
						1u													// deUint32	depth;
					},														// VkExtent3D				extent;
					VERIFYMAXVALUES_MIPLEVELS,								// deUint32					mipLevels;
					VERIFYMAXVALUES_ARRAYLAYERS,							// deUint32					arrayLayers;
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits	samples;
					VK_IMAGE_TILING_OPTIMAL,								// VkImageTiling			tiling;
					VK_IMAGE_USAGE_SAMPLED_BIT,								// VkImageUsageFlags		usage;
					VK_SHARING_MODE_EXCLUSIVE,								// VkSharingMode			sharingMode;
					1u,														// deUint32					queueFamilyIndexCount;
					&queueFamilyIndex,										// const deUint32*			pQueueFamilyIndices;
					VK_IMAGE_LAYOUT_UNDEFINED								// VkImageLayout			initialLayout;
				};
				image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(vkd, device, allocator, imageCreateInfo, MemoryRequirement::Any));
				break;
			}
			case TMV_MAX_OCCLUSION_QUERIES_PER_POOL:
			{
				const VkQueryPoolCreateInfo	queryPoolCreateInfo =
				{
					VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,				//  VkStructureType					sType;
					DE_NULL,												//  const void*						pNext;
					(VkQueryPoolCreateFlags)0,								//  VkQueryPoolCreateFlags			flags;
					VK_QUERY_TYPE_OCCLUSION,								//  VkQueryType						queryType;
					VERIFYMAXVALUES_OBJECT_COUNT,							//  deUint32						queryCount;
					0u,														//  VkQueryPipelineStatisticFlags	pipelineStatistics;
				};
				queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
				break;
			}
			case TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL:
			{
				const VkQueryPoolCreateInfo	queryPoolCreateInfo =
				{
					VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,				//  VkStructureType					sType;
					DE_NULL,												//  const void*						pNext;
					(VkQueryPoolCreateFlags)0,								//  VkQueryPoolCreateFlags			flags;
					VK_QUERY_TYPE_PIPELINE_STATISTICS,						//  VkQueryType						queryType;
					VERIFYMAXVALUES_OBJECT_COUNT,							//  deUint32						queryCount;
					0u,														//  VkQueryPipelineStatisticFlags	pipelineStatistics;
				};
				queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
				break;
			}
			case TMV_MAX_TIMESTAMP_QUERIES_PER_POOL:
			{
				const VkQueryPoolCreateInfo	queryPoolCreateInfo =
				{
					VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,				//  VkStructureType					sType;
					DE_NULL,												//  const void*						pNext;
					(VkQueryPoolCreateFlags)0,								//  VkQueryPoolCreateFlags			flags;
					VK_QUERY_TYPE_TIMESTAMP,								//  VkQueryType						queryType;
					VERIFYMAXVALUES_OBJECT_COUNT,							//  deUint32						queryCount;
					0u,														//  VkQueryPipelineStatisticFlags	pipelineStatistics;
				};
				queryPool = createQueryPool(vkd, device, &queryPoolCreateInfo);
				break;
			}
			default:
				TCU_THROW(InternalError, "Unsupported max value");
		}
	}
};

void checkSupportVerifyRequestCounts (vkt::Context& context, TestParams testParams)
{
	if (testParams.testRequestCounts == TRC_SAMPLERYCBCRCONVERSION && context.getDeviceVulkan11Features().samplerYcbcrConversion == VK_FALSE)
		TCU_THROW(NotSupportedError, "samplerYcbcrConversion is not supported");
}

// create programs for VerifyRequestCounts tests
struct ProgramsVerifyLimits
{
	void init(SourceCollections& dst, TestParams testParams) const
	{
		if (testParams.testRequestCounts == TRC_GRAPHICS_PIPELINE || testParams.testPoolSizeType != PST_UNDEFINED)
		{
			dst.glslSources.add("vertex") << glu::VertexSource(
				"#version 450\n"
				"\n"
				"void main (void)\n"
				"{\n"
				"   gl_Position = vec4(0);\n"
				"}\n");
			dst.glslSources.add("fragment") << glu::FragmentSource(
				"#version 450\n"
				"\n"
				"layout(location=0) out vec4 x;\n"
				"void main (void)\n"
				"{\n"
				"   x = vec4(1);\n"
				"}\n");
		}
		else if (testParams.testRequestCounts == TRC_COMPUTE_PIPELINE)
		{
			dst.glslSources.add("compute") << glu::ComputeSource(
				"#version 450\n"
				"layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
				"void main (void)\n"
				"{\n"
				"	uvec4 x = uvec4(0);\n"
				"}\n");
		}
	}
};

// For each of the various resource "max" values, create resources that exercise the maximum values requested
class VerifyRequestCounts : public DeviceObjectReservationInstance
{
public:
	VerifyRequestCounts				(Context&								context,
									 const TestParams&						testParams_)
		: DeviceObjectReservationInstance(context, testParams_)
	{
	}


	Move<VkDevice> createTestDevice (VkDeviceCreateInfo&					deviceCreateInfo,
									 VkDeviceObjectReservationCreateInfo&	objectInfo,
									 VkPhysicalDeviceVulkanSC10Features&	sc10Features) override
	{
		DE_UNREF(sc10Features);

		std::vector<VkPipelinePoolSize>	poolSizes;
		VkDeviceSize					pipelineDefaultSize			= VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());

		switch (testParams.testRequestCounts)
		{
			case TRC_SEMAPHORE:
				objectInfo.semaphoreRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_COMMAND_BUFFER:
				objectInfo.commandPoolRequestCount					= 1u;
				objectInfo.commandBufferRequestCount				= 2 * VERIFYMAXVALUES_OBJECT_COUNT + (VERIFYMAXVALUES_OBJECT_COUNT - VERIFYMAXVALUES_OBJECT_COUNT / 2) ;
				break;
			case TRC_FENCE:
				objectInfo.fenceRequestCount						= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_DEVICE_MEMORY:
				objectInfo.deviceMemoryRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_BUFFER:
				objectInfo.bufferRequestCount						= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_IMAGE:
				objectInfo.imageRequestCount						= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.maxImageViewMipLevels					= 1u;
				objectInfo.maxImageViewArrayLayers					= 1u;
				break;
			case TRC_EVENT:
				objectInfo.eventRequestCount						= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_QUERY_POOL:
				objectInfo.queryPoolRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_BUFFER_VIEW:
				objectInfo.deviceMemoryRequestCount					= 1u;
				objectInfo.bufferRequestCount						= 1u;
				objectInfo.bufferViewRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_IMAGE_VIEW:
				objectInfo.deviceMemoryRequestCount					= 1u;
				objectInfo.imageViewRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.imageRequestCount						= 1u;
				objectInfo.maxImageViewMipLevels					= 1u;
				objectInfo.maxImageViewArrayLayers					= 1u;
				break;
			case TRC_LAYERED_IMAGE_VIEW:
				objectInfo.deviceMemoryRequestCount					= 1u;
				objectInfo.imageViewRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.layeredImageViewRequestCount				= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.imageRequestCount						= 1u;
				objectInfo.maxImageViewMipLevels					= 1u;
				objectInfo.maxImageViewArrayLayers					= VERIFYMAXVALUES_ARRAYLAYERS;
				break;
			case TRC_PIPELINE_LAYOUT:
				objectInfo.pipelineLayoutRequestCount				= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_RENDER_PASS:
				objectInfo.renderPassRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.subpassDescriptionRequestCount			= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.attachmentDescriptionRequestCount		= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_GRAPHICS_PIPELINE:
				objectInfo.pipelineLayoutRequestCount				= 1u;
				objectInfo.renderPassRequestCount					= 1u;
				objectInfo.subpassDescriptionRequestCount			= 1u;
				objectInfo.attachmentDescriptionRequestCount		= 1u;
				objectInfo.graphicsPipelineRequestCount				= VERIFYMAXVALUES_OBJECT_COUNT;
				poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, pipelineDefaultSize, VERIFYMAXVALUES_OBJECT_COUNT });
				break;
			case TRC_COMPUTE_PIPELINE:
				objectInfo.pipelineLayoutRequestCount				= 1u;
				objectInfo.computePipelineRequestCount				= VERIFYMAXVALUES_OBJECT_COUNT;
				poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, pipelineDefaultSize, VERIFYMAXVALUES_OBJECT_COUNT });
				break;
			case TRC_DESCRIPTORSET_LAYOUT:
				objectInfo.descriptorSetLayoutRequestCount			= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.descriptorSetLayoutBindingRequestCount	= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.descriptorSetLayoutBindingLimit			= 2u;
				break;
			case TRC_SAMPLER:
				objectInfo.samplerRequestCount						= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_DESCRIPTOR_POOL:
				objectInfo.descriptorPoolRequestCount				= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_DESCRIPTORSET:
				objectInfo.descriptorSetLayoutRequestCount			= 1u;
				objectInfo.descriptorSetLayoutBindingRequestCount	= 1u;
				objectInfo.descriptorSetLayoutBindingLimit			= 2u;
				objectInfo.descriptorPoolRequestCount				= 1u;
				objectInfo.descriptorSetRequestCount				= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_FRAMEBUFFER:
				objectInfo.deviceMemoryRequestCount					= 1u;
				objectInfo.imageViewRequestCount					= 1u;
				objectInfo.imageRequestCount						= 1u;
				objectInfo.maxImageViewMipLevels					= 1u;
				objectInfo.maxImageViewArrayLayers					= 1u;
				objectInfo.renderPassRequestCount					= 1u;
				objectInfo.subpassDescriptionRequestCount			= 1u;
				objectInfo.attachmentDescriptionRequestCount		= 1u;
				objectInfo.framebufferRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_COMMANDPOOL:
				objectInfo.commandPoolRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
				objectInfo.commandBufferRequestCount				= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
			case TRC_SAMPLERYCBCRCONVERSION:
				objectInfo.samplerYcbcrConversionRequestCount		= VERIFYMAXVALUES_OBJECT_COUNT;
				break;
//			case TRC_SURFACE:
//				objectInfo.surfaceRequestCount						= VERIFYMAXVALUES_OBJECT_COUNT;
//				break;
//			case TRC_SWAPCHAIN:
//				objectInfo.swapchainRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
//				break;
//			case TRC_DISPLAY_MODE:
//				objectInfo.displayModeRequestCount					= VERIFYMAXVALUES_OBJECT_COUNT;
//				break;
			default:
				TCU_THROW(InternalError, "Unsupported request count");
		}

		objectInfo.pipelinePoolSizeCount = deUint32(poolSizes.size());
		objectInfo.pPipelinePoolSizes = poolSizes.empty() ? DE_NULL : poolSizes.data();

		return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
	}


	void performTest (const DeviceInterface&				vkd,
					  VkDevice								device) override
	{
		SimpleAllocator	allocator			(vkd, device, getPhysicalDeviceMemoryProperties(instance.getDriver(), physicalDevice));
		VkDeviceSize	pipelineDefaultSize	= VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
		deUint32		queueFamilyIndex	= 0u;

		switch (testParams.testRequestCounts)
		{
			case TRC_SEMAPHORE:
			{
				std::vector<SemaphoreSp> semaphores(VERIFYMAXVALUES_OBJECT_COUNT);
				createSemaphores(vkd, device, begin(semaphores), end(semaphores));
				std::fill(begin(semaphores) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(semaphores), SemaphoreSp());
				createSemaphores(vkd, device, begin(semaphores) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(semaphores));
				std::fill(begin(semaphores), end(semaphores), SemaphoreSp());
				createSemaphores(vkd, device, begin(semaphores), end(semaphores));
				break;
			}
			case TRC_COMMAND_BUFFER:
			{
				std::vector<CommandPoolSp> commandPools(1u);
				createCommandPools(vkd, device, begin(commandPools), end(commandPools));

				std::vector<CommandBufferSp> commandBuffers(VERIFYMAXVALUES_OBJECT_COUNT);
				createCommandBuffers(vkd, device, commandPools[0]->get(), begin(commandBuffers), end(commandBuffers));
				std::fill(begin(commandBuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(commandBuffers), CommandBufferSp());
				createCommandBuffers(vkd, device, commandPools[0]->get(), begin(commandBuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(commandBuffers));
				std::fill(begin(commandBuffers), end(commandBuffers), CommandBufferSp());
				createCommandBuffers(vkd, device, commandPools[0]->get(), begin(commandBuffers), end(commandBuffers));
				break;
			}
			case TRC_FENCE:
			{
				std::vector<FenceSp> fences(VERIFYMAXVALUES_OBJECT_COUNT);
				createFences(vkd, device, begin(fences), end(fences));
				std::fill(begin(fences) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(fences), FenceSp());
				createFences(vkd, device, begin(fences) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(fences));
				std::fill(begin(fences), end(fences), FenceSp());
				createFences(vkd, device, begin(fences), end(fences));
				break;
			}
			case TRC_DEVICE_MEMORY:
			{
				std::vector<DeviceMemorySp> mems(VERIFYMAXVALUES_OBJECT_COUNT);
				allocateDeviceMemory(vkd, device, 16U, begin(mems), end(mems));
				break;
			}
			case TRC_BUFFER:
			{
				std::vector<BufferSp> buffers(VERIFYMAXVALUES_OBJECT_COUNT);
				createBuffers(vkd, device, 32ull, begin(buffers), end(buffers));
				std::fill(begin(buffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(buffers), BufferSp());
				createBuffers(vkd, device, 32ull, begin(buffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(buffers));
				std::fill(begin(buffers), end(buffers), BufferSp());
				createBuffers(vkd, device, 32ull, begin(buffers), end(buffers));
				break;
			}
			case TRC_IMAGE:
			{
				std::vector<ImageSp> images(VERIFYMAXVALUES_OBJECT_COUNT);
				createImages(vkd, device, 16u, begin(images), end(images));
				std::fill(begin(images) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(images), ImageSp());
				createImages(vkd, device, 16u, begin(images) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(images));
				std::fill(begin(images), end(images), ImageSp());
				createImages(vkd, device, 16u, begin(images), end(images));
				break;
			}
			case TRC_EVENT:
			{
				std::vector<EventSp> events(VERIFYMAXVALUES_OBJECT_COUNT);
				createEvents(vkd, device, begin(events), end(events));
				std::fill(begin(events) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(events), EventSp());
				createEvents(vkd, device, begin(events) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(events));
				std::fill(begin(events), end(events), EventSp());
				createEvents(vkd, device, begin(events), end(events));
				break;
			}
			case TRC_QUERY_POOL:
			{
				std::vector<QueryPoolSp> queryPools(VERIFYMAXVALUES_OBJECT_COUNT);
				createQueryPools(vkd, device, begin(queryPools), end(queryPools));
				break;
			}
			case TRC_BUFFER_VIEW:
			{
				const VkBufferCreateInfo bufferCI = makeBufferCreateInfo(128ull, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
				BufferWithMemory buffer(vkd, device, allocator, bufferCI, MemoryRequirement::HostVisible);

				std::vector<BufferViewSp> bufferViews(VERIFYMAXVALUES_OBJECT_COUNT);
				createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews), end(bufferViews));
				std::fill(begin(bufferViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(bufferViews), BufferViewSp());
				createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(bufferViews));
				std::fill(begin(bufferViews), end(bufferViews), BufferViewSp());
				createBufferViews(vkd, device, buffer.get(), 128ull, begin(bufferViews), end(bufferViews));
				break;
			}
			case TRC_IMAGE_VIEW:
			{
				const VkImageCreateInfo			imageCI =
				{
					VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,					// VkStructureType			sType;
					DE_NULL,												// const void*				pNext;
					(VkImageCreateFlags)0u,									// VkImageCreateFlags		flags;
					VK_IMAGE_TYPE_2D,										// VkImageType				imageType;
					VK_FORMAT_R8_UNORM,										// VkFormat					format;
					{
						8u,													// deUint32	width;
						8u,													// deUint32	height;
						1u													// deUint32	depth;
					},														// VkExtent3D				extent;
					1u,														// deUint32					mipLevels;
					1u,														// deUint32					arrayLayers;
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits	samples;
					VK_IMAGE_TILING_OPTIMAL,								// VkImageTiling			tiling;
					VK_IMAGE_USAGE_SAMPLED_BIT,								// VkImageUsageFlags		usage;
					VK_SHARING_MODE_EXCLUSIVE,								// VkSharingMode			sharingMode;
					1u,														// deUint32					queueFamilyIndexCount;
					&queueFamilyIndex,										// const deUint32*			pQueueFamilyIndices;
					VK_IMAGE_LAYOUT_UNDEFINED								// VkImageLayout			initialLayout;
				};
				ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);

				std::vector<ImageViewSp> imageViews(VERIFYMAXVALUES_OBJECT_COUNT);
				createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
				std::fill(begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews), ImageViewSp());
				createImageViews(vkd, device, image.get(), begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews));
				std::fill(begin(imageViews), end(imageViews), ImageViewSp());
				createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
				break;
			}
			case TRC_LAYERED_IMAGE_VIEW:
			{
				const VkImageCreateInfo			imageCI =
				{
					VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,					// VkStructureType			sType;
					DE_NULL,												// const void*				pNext;
					(VkImageCreateFlags)0u,									// VkImageCreateFlags		flags;
					VK_IMAGE_TYPE_2D,										// VkImageType				imageType;
					VK_FORMAT_R8_UNORM,										// VkFormat					format;
					{
						8u,													// deUint32	width;
						8u,													// deUint32	height;
						1u													// deUint32	depth;
					},														// VkExtent3D				extent;
					1u,														// deUint32					mipLevels;
					VERIFYMAXVALUES_ARRAYLAYERS,							// deUint32					arrayLayers;
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits	samples;
					VK_IMAGE_TILING_OPTIMAL,								// VkImageTiling			tiling;
					VK_IMAGE_USAGE_SAMPLED_BIT,								// VkImageUsageFlags		usage;
					VK_SHARING_MODE_EXCLUSIVE,								// VkSharingMode			sharingMode;
					1u,														// deUint32					queueFamilyIndexCount;
					&queueFamilyIndex,										// const deUint32*			pQueueFamilyIndices;
					VK_IMAGE_LAYOUT_UNDEFINED								// VkImageLayout			initialLayout;
				};
				ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);

				std::vector<ImageViewSp> imageViews(VERIFYMAXVALUES_OBJECT_COUNT);
				createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
				std::fill(begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews), ImageViewSp());
				createImageViews(vkd, device, image.get(), begin(imageViews) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(imageViews));
				std::fill(begin(imageViews), end(imageViews), ImageViewSp());
				createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));
				break;
			}
			case TRC_PIPELINE_LAYOUT:
			{
				std::vector<PipelineLayoutSp> pipelineLayouts(VERIFYMAXVALUES_OBJECT_COUNT);
				createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
				std::fill(begin(pipelineLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelineLayouts), PipelineLayoutSp());
				createPipelineLayouts(vkd, device, begin(pipelineLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelineLayouts));
				std::fill(begin(pipelineLayouts), end(pipelineLayouts), PipelineLayoutSp());
				createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
				break;
			}
			case TRC_RENDER_PASS:
			{
				VkAttachmentDescription	attachmentDescription =
				{
					0u,														// VkAttachmentDescriptionFlags	flags;
					VK_FORMAT_R8G8B8A8_UNORM,								// VkFormat						format;
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits		samples;
					VK_ATTACHMENT_LOAD_OP_DONT_CARE,						// 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_UNDEFINED,								// VkImageLayout				initialLayout;
					VK_IMAGE_LAYOUT_GENERAL,								// VkImageLayout				finalLayout;
				};

				std::vector<RenderPassSp> renderPasses(VERIFYMAXVALUES_OBJECT_COUNT);
				createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
				std::fill(begin(renderPasses) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(renderPasses), RenderPassSp());
				createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(renderPasses));
				std::fill(begin(renderPasses), end(renderPasses), RenderPassSp());
				createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
				break;
			}
			case TRC_GRAPHICS_PIPELINE:
			{
				VkAttachmentDescription	attachmentDescription =
				{
					0u,														// VkAttachmentDescriptionFlags	flags;
					VK_FORMAT_R8G8B8A8_UNORM,								// VkFormat						format;
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits		samples;
					VK_ATTACHMENT_LOAD_OP_DONT_CARE,						// 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_UNDEFINED,								// VkImageLayout				initialLayout;
					VK_IMAGE_LAYOUT_GENERAL,								// VkImageLayout				finalLayout;
				};
				std::vector<RenderPassSp> renderPasses(1u);
				createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));
				std::vector<PipelineLayoutSp>	pipelineLayouts(1u);
				createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
				Move<VkShaderModule>			vertexShaderModule		= createShaderModule(vkd, device, m_context.getBinaryCollection().get("vertex"), 0u);
				Move<VkShaderModule>			fragmentShaderModule	= createShaderModule(vkd, device, m_context.getBinaryCollection().get("fragment"), 0u);

				std::vector<PipelineSp> pipelines(VERIFYMAXVALUES_OBJECT_COUNT);
				createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(), renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines), end(pipelines));

				if (m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory)
				{
					std::fill(begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines), PipelineSp());
					createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(), renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines));
					std::fill(begin(pipelines), end(pipelines), PipelineSp());
					createGraphicsPipelines(vkd, device, vertexShaderModule.get(), fragmentShaderModule.get(), renderPasses[0]->get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines), end(pipelines));
				}

				break;
			}
			case TRC_COMPUTE_PIPELINE:
			{
				std::vector<PipelineLayoutSp>	pipelineLayouts	(1u);
				createPipelineLayouts(vkd, device, begin(pipelineLayouts), end(pipelineLayouts));
				Move<VkShaderModule>			shaderModule	= createShaderModule(vkd, device, m_context.getBinaryCollection().get("compute"), 0u);

				std::vector<PipelineSp> pipelines(VERIFYMAXVALUES_OBJECT_COUNT);
				createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines), end(pipelines));

				if (m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory)
				{
					std::fill(begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines), PipelineSp());
					createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(pipelines));
					std::fill(begin(pipelines), end(pipelines), PipelineSp());
					createComputePipelines(vkd, device, shaderModule.get(), pipelineLayouts[0]->get(), pipelineDefaultSize, m_context.getResourceInterface(), begin(pipelines), end(pipelines));
				}
				break;
			}
			case TRC_DESCRIPTORSET_LAYOUT:
			{
				std::vector<DescriptorSetLayoutSp> descriptorSetLayouts(VERIFYMAXVALUES_OBJECT_COUNT);
				createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
				std::fill(begin(descriptorSetLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSetLayouts), DescriptorSetLayoutSp());
				createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSetLayouts));
				std::fill(begin(descriptorSetLayouts), end(descriptorSetLayouts), DescriptorSetLayoutSp());
				createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
				break;
			}
			case TRC_SAMPLER:
			{
				std::vector<SamplerSp> samplers(VERIFYMAXVALUES_OBJECT_COUNT);
				createSamplers(vkd, device, begin(samplers), end(samplers));
				std::fill(begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers), SamplerSp());
				createSamplers(vkd, device, begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers));
				std::fill(begin(samplers), end(samplers), SamplerSp());
				createSamplers(vkd, device, begin(samplers), end(samplers));
				break;
			}
			case TRC_DESCRIPTOR_POOL:
			{
				std::vector<DescriptorPoolSp> descriptorPools(VERIFYMAXVALUES_OBJECT_COUNT);
				createDescriptorPools(vkd, device, 1u, begin(descriptorPools), end(descriptorPools));
				break;
			}
			case TRC_DESCRIPTORSET:
			{
				std::vector<DescriptorSetLayoutSp> descriptorSetLayouts(1u);
				createDescriptorSetLayouts(vkd, device, begin(descriptorSetLayouts), end(descriptorSetLayouts));
				std::vector<DescriptorPoolSp> descriptorPools(1u);
				createDescriptorPools(vkd, device, VERIFYMAXVALUES_OBJECT_COUNT, begin(descriptorPools), end(descriptorPools));

				std::vector<DescriptorSetSp> descriptorSets(VERIFYMAXVALUES_OBJECT_COUNT);
				createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(), begin(descriptorSets), end(descriptorSets));
				if (m_context.getDeviceVulkanSC10Properties().recycleDescriptorSetMemory)
				{
					std::fill(begin(descriptorSets) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSets), DescriptorSetSp());
					createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(), begin(descriptorSets) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(descriptorSets));
					std::fill(begin(descriptorSets), end(descriptorSets), DescriptorSetSp());
					createDescriptorSets(vkd, device, descriptorPools[0]->get(), descriptorSetLayouts[0]->get(), begin(descriptorSets), end(descriptorSets));
				}
				break;
			}
			case TRC_FRAMEBUFFER:
			{
				VkImageCreateInfo	imageCI	=
				{
					VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,					// VkStructureType			sType
					DE_NULL,												// const void*				pNext
					(VkImageCreateFlags)0u,									// VkImageCreateFlags		flags
					VK_IMAGE_TYPE_2D,										// VkImageType				imageType
					VK_FORMAT_R8G8B8A8_UNORM,								// VkFormat					format
					{
						8u,													// deUint32	width
						8u,													// deUint32	height
						1u													// deUint32	depth
					},														// VkExtent3D				extent
					1u,														// deUint32					mipLevels
					1u,														// deUint32					arrayLayers
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits	samples
					VK_IMAGE_TILING_OPTIMAL,								// VkImageTiling			tiling
					VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,					// VkImageUsageFlags		usage;
					VK_SHARING_MODE_EXCLUSIVE,								// VkSharingMode			sharingMode;
					1u,														// deUint32					queueFamilyIndexCount;
					&queueFamilyIndex,										// const deUint32*			pQueueFamilyIndices;
					VK_IMAGE_LAYOUT_UNDEFINED,								// VkImageLayout			initialLayout;
				};
				ImageWithMemory image(vkd, device, allocator, imageCI, MemoryRequirement::Any);

				VkAttachmentDescription	attachmentDescription =
				{
					0u,														// VkAttachmentDescriptionFlags	flags;
					VK_FORMAT_R8G8B8A8_UNORM,								// VkFormat						format;
					VK_SAMPLE_COUNT_1_BIT,									// VkSampleCountFlagBits		samples;
					VK_ATTACHMENT_LOAD_OP_DONT_CARE,						// 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_UNDEFINED,								// VkImageLayout				initialLayout;
					VK_IMAGE_LAYOUT_GENERAL,								// VkImageLayout				finalLayout;
				};

				std::vector<RenderPassSp> renderPasses(1u);
				createRenderPasses(vkd, device, &attachmentDescription, begin(renderPasses), end(renderPasses));

				std::vector<ImageViewSp> imageViews(1u);
				createImageViews(vkd, device, image.get(), begin(imageViews), end(imageViews));

				std::vector<FramebufferSp> framebuffers(VERIFYMAXVALUES_OBJECT_COUNT);
				createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(), begin(framebuffers), end(framebuffers));
				std::fill(begin(framebuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(framebuffers), FramebufferSp());
				createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(), begin(framebuffers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(framebuffers));
				std::fill(begin(framebuffers), end(framebuffers), FramebufferSp());
				createFramebuffers(vkd, device, renderPasses[0]->get(), imageViews[0]->get(), begin(framebuffers), end(framebuffers));
				break;
			}
			case TRC_COMMANDPOOL:
			{
				std::vector<CommandPoolSp> commandPools(VERIFYMAXVALUES_OBJECT_COUNT);
				createCommandPools(vkd, device, begin(commandPools), end(commandPools));
				break;
			}
			case TRC_SAMPLERYCBCRCONVERSION:
			{
				std::vector<SamplerYcbcrConversionSp> samplers(VERIFYMAXVALUES_OBJECT_COUNT);
				createSamplerYcbcrConversions(vkd, device, begin(samplers), end(samplers));
				std::fill(begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers), SamplerYcbcrConversionSp());
				createSamplerYcbcrConversions(vkd, device, begin(samplers) + VERIFYMAXVALUES_OBJECT_COUNT / 2, end(samplers));
				std::fill(begin(samplers), end(samplers), SamplerYcbcrConversionSp());
				createSamplerYcbcrConversions(vkd, device, begin(samplers), end(samplers));
				break;
			}
//			case TRC_SURFACE:
//				break;
//			case TRC_SWAPCHAIN:
//				break;
//			case TRC_DISPLAY_MODE:
//				break;
			default:
				TCU_THROW(InternalError, "Unsupported max value");
		}
	}
};

// test pipeline pool sizes
class VerifyPipelinePoolSizes : public DeviceObjectReservationInstance
{
public:
	VerifyPipelinePoolSizes			(Context&								context,
									 const TestParams&						testParams_)
		: DeviceObjectReservationInstance(context, testParams_)
	{
	}

	Move<VkDevice> createTestDevice (VkDeviceCreateInfo&					deviceCreateInfo,
									 VkDeviceObjectReservationCreateInfo&	objectInfo,
									 VkPhysicalDeviceVulkanSC10Features&	sc10Features) override
	{
		DE_UNREF(sc10Features);

		std::vector<VkPipelinePoolSize> poolSizes;

		const VkDeviceSize psTooSmall		= 64u;
		const VkDeviceSize psForOnePipeline	= VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());

		switch (testParams.testPoolSizeType)
		{
		case PST_NONE:
			objectInfo.graphicsPipelineRequestCount = 1u;
			break;
		case PST_ZERO:
			objectInfo.graphicsPipelineRequestCount = 1u;
			poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, 0u, 1u });
			break;
		case PST_TOO_SMALL_SIZE:
			poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psTooSmall, 1u });
			objectInfo.graphicsPipelineRequestCount = 1u;
			break;
		case PST_ONE_FITS:
			poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psForOnePipeline, 1u });
			objectInfo.graphicsPipelineRequestCount = 1u;
			break;
		case PST_MULTIPLE_FIT:
			poolSizes.push_back({ VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE, DE_NULL, psForOnePipeline, 16u });
			objectInfo.graphicsPipelineRequestCount = 16u;
			break;
		default:
			TCU_THROW(InternalError, "Unsupported pool size type");
		}

		objectInfo.pipelinePoolSizeCount					= deUint32(poolSizes.size());
		objectInfo.pPipelinePoolSizes						= poolSizes.empty() ? DE_NULL : poolSizes.data();
		objectInfo.pipelineLayoutRequestCount				= 1u;
		objectInfo.renderPassRequestCount					= 1u;
		objectInfo.subpassDescriptionRequestCount			= 1u;
		objectInfo.attachmentDescriptionRequestCount		= 1u;

		return createCustomDevice(m_context.getTestContext().getCommandLine().isValidationEnabled(), m_context.getPlatformInterface(), instance, instance.getDriver(), physicalDevice, &deviceCreateInfo);
	}

	void performTest (const DeviceInterface&				vk,
					  VkDevice								device) override
	{
		const vk::PlatformInterface&					vkp								= m_context.getPlatformInterface();
		const InstanceInterface&						vki								= instance.getDriver();

		Move<VkShaderModule>							vertexShader					= createShaderModule(vk, device, m_context.getBinaryCollection().get("vertex"), 0);
		Move<VkShaderModule>							fragmentShader					= createShaderModule(vk, device, m_context.getBinaryCollection().get("fragment"), 0);

		std::vector<VkPipelineShaderStageCreateInfo>	shaderStageCreateInfos			=
		{
			{
				VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,						// VkStructureType                     sType;
				DE_NULL,																	// const void*                         pNext;
				(VkPipelineShaderStageCreateFlags)0,										// VkPipelineShaderStageCreateFlags    flags;
				VK_SHADER_STAGE_VERTEX_BIT,													// VkShaderStageFlagBits               stage;
				*vertexShader,																// VkShaderModule                      shader;
				"main",																		// const char*                         pName;
				DE_NULL,																	// const VkSpecializationInfo*         pSpecializationInfo;
			},
			{
				VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,						// VkStructureType                     sType;
				DE_NULL,																	// const void*                         pNext;
				(VkPipelineShaderStageCreateFlags)0,										// VkPipelineShaderStageCreateFlags    flags;
				VK_SHADER_STAGE_FRAGMENT_BIT,												// VkShaderStageFlagBits               stage;
				*fragmentShader,																// VkShaderModule                      shader;
				"main",																		// const char*                         pName;
				DE_NULL,																	// const VkSpecializationInfo*         pSpecializationInfo;
			}
		};

		VkPipelineVertexInputStateCreateInfo			vertexInputStateCreateInfo;
		VkPipelineInputAssemblyStateCreateInfo			inputAssemblyStateCreateInfo;
		VkPipelineViewportStateCreateInfo				viewPortStateCreateInfo;
		VkPipelineRasterizationStateCreateInfo			rasterizationStateCreateInfo;
		VkPipelineMultisampleStateCreateInfo			multisampleStateCreateInfo;
		VkPipelineColorBlendAttachmentState				colorBlendAttachmentState;
		VkPipelineColorBlendStateCreateInfo				colorBlendStateCreateInfo;
		VkPipelineDynamicStateCreateInfo				dynamicStateCreateInfo;
		std::vector<VkDynamicState>						dynamicStates					= { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };

		const VkPipelineLayoutCreateInfo				pipelineLayoutCreateInfo		=
		{
			VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,										// VkStructureType                     sType;
			DE_NULL,																			// const void*                         pNext;
			(VkPipelineLayoutCreateFlags)0u,													// VkPipelineLayoutCreateFlags         flags;
			0u,																					// deUint32                            setLayoutCount;
			DE_NULL,																			// const VkDescriptorSetLayout*        pSetLayouts;
			0u,																					// deUint32                            pushConstantRangeCount;
			DE_NULL																				// const VkPushConstantRange*          pPushConstantRanges;
		};
		Move<VkPipelineLayout>							pipelineLayout					= createPipelineLayout(vk, device, &pipelineLayoutCreateInfo);

		const VkFormat									format							= getRenderTargetFormat(vki, physicalDevice);

		VkAttachmentDescription							attachmentDescription;
		VkAttachmentReference							attachmentReference;
		VkSubpassDescription							subpassDescription;
		VkRenderPassCreateInfo							renderPassCreateInfo			= prepareSimpleRenderPassCI(format, attachmentDescription, attachmentReference, subpassDescription);
		Move<VkRenderPass>								renderPass						= createRenderPass(vk, device, &renderPassCreateInfo);

		VkGraphicsPipelineCreateInfo					graphicsPipelineCreateInfo		= prepareSimpleGraphicsPipelineCI(vertexInputStateCreateInfo, shaderStageCreateInfos,
				inputAssemblyStateCreateInfo, viewPortStateCreateInfo, rasterizationStateCreateInfo, multisampleStateCreateInfo, colorBlendAttachmentState, colorBlendStateCreateInfo,
				dynamicStateCreateInfo, dynamicStates, *pipelineLayout, *renderPass);

		// create custom VkPipelineIdentifierInfo
		VkPipelineOfflineCreateInfo						pipelineID						= resetPipelineOfflineCreateInfo();
		applyPipelineIdentifier(pipelineID, "ID_DR_PS_00");
		pipelineID.pNext																= graphicsPipelineCreateInfo.pNext;
		graphicsPipelineCreateInfo.pNext												= &pipelineID;

		if (m_context.getTestContext().getCommandLine().isSubProcess())
		{
			pipelineID.poolEntrySize = VkDeviceSize(m_context.getTestContext().getCommandLine().getPipelineDefaultSize());
		}

		std::size_t										pipelineCount					= 0u;
		switch (testParams.testPoolSizeType)
		{
		case PST_NONE:
		case PST_ZERO:
		case PST_TOO_SMALL_SIZE:
		case PST_ONE_FITS:
			pipelineCount = 1u;
			break;
		case PST_MULTIPLE_FIT:
			pipelineCount = 16u;
			break;
		default:
			TCU_THROW(InternalError, "Unsupported pool size type");
		};

		if (!m_context.getTestContext().getCommandLine().isSubProcess())
		{
			std::vector<Move<VkPipeline>> pipelines;
			for (deUint32 i = 0; i < pipelineCount; ++i)
				pipelines.emplace_back(createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo));
			return;
		}

		GetDeviceProcAddrFunc				getDeviceProcAddrFunc			= (GetDeviceProcAddrFunc)vkp.getInstanceProcAddr(instance, "vkGetDeviceProcAddr");
		CreateGraphicsPipelinesFunc			createGraphicsPipelinesFunc		= (CreateGraphicsPipelinesFunc)getDeviceProcAddrFunc(device, "vkCreateGraphicsPipelines");
		DestroyPipelineFunc					destroyPipelineFunc				= (DestroyPipelineFunc)getDeviceProcAddrFunc(device, "vkDestroyPipeline");
		VkPipelineCache						pipelineCache					= m_context.getResourceInterface()->getPipelineCache(device);
		std::vector<VkPipeline>				pipelines						(pipelineCount, VkPipeline(DE_NULL));
		deUint32							iterations						= m_context.getDeviceVulkanSC10Properties().recyclePipelineMemory ? 1u : 4u;

		// if recyclePipelineMemory is set then we are able to create the same pipelines again
		for (deUint32 iter = 0; iter < iterations; ++iter)
		{
			for (deUint32 i = 0; i < pipelineCount; ++i)
			{
				VkResult result = createGraphicsPipelinesFunc(device, pipelineCache, 1u, &graphicsPipelineCreateInfo, DE_NULL, &pipelines[i]);
				results.push_back(result);
				if (result != VK_SUCCESS)
				{
					for (deUint32 j = 0; j < pipelineCount; ++j)
						if (pipelines[j].getInternal() != DE_NULL)
							destroyPipelineFunc(device, pipelines[j], DE_NULL);
					return;
				}
			}

			for (deUint32 i = 0; i < pipelineCount; ++i)
			{
				destroyPipelineFunc(device, pipelines[i], DE_NULL);
				pipelines[i] = VkPipeline(DE_NULL);
			}
		}
	}

	bool verifyTestResults	(const DeviceInterface&					vkd,
							 VkDevice								device) override
	{
		DE_UNREF(vkd);
		DE_UNREF(device);

		if (!m_context.getTestContext().getCommandLine().isSubProcess())
			return true;

		switch (testParams.testPoolSizeType)
		{
		case PST_NONE:
		case PST_ZERO:
		case PST_TOO_SMALL_SIZE:
			return (results.back() == VK_ERROR_OUT_OF_POOL_MEMORY);
		case PST_ONE_FITS:
			return (results.back() == VK_SUCCESS);
		case PST_MULTIPLE_FIT:
			return (results.back() == VK_SUCCESS);
		default:
			TCU_THROW(InternalError, "Unsupported pool size type");
		};
		return true;
	}

	std::vector<VkResult> results;
};

} // anonymous

tcu::TestCaseGroup*	createDeviceObjectReservationTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "device_object_reservation", "Tests verifying VkDeviceObjectReservationCreateInfo"));

	// add basic tests
	{
		de::MovePtr<tcu::TestCaseGroup> basicGroup(new tcu::TestCaseGroup(group->getTestContext(), "basic", ""));

		basicGroup->addChild(new InstanceFactory1<DeviceObjectReservationInstance, TestParams>(testCtx, tcu::NODETYPE_SELF_VALIDATE, "create_device", "", TestParams()));
		basicGroup->addChild(new InstanceFactory1<MultipleReservation, TestParams>(testCtx, tcu::NODETYPE_SELF_VALIDATE, "multiple_device_object_reservation", "", TestParams()));

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

	// add tests verifying device limits
	{
		de::MovePtr<tcu::TestCaseGroup> limitGroup(new tcu::TestCaseGroup(group->getTestContext(), "limits", ""));
		struct TestMaxValuesData
		{
			TestMaxValues							testMaxValues;
			const char*								name;
		} testMaxValues[] =
		{
			{ TMV_DESCRIPTOR_SET_LAYOUT_BINDING_LIMIT,		"descriptor_set_layout_binding_limit" },
			{ TMV_MAX_IMAGEVIEW_MIPLEVELS,					"max_imageview_miplevels" },
			{ TMV_MAX_IMAGEVIEW_ARRAYLAYERS,				"max_imageview_arraylayers" },
			{ TMV_MAX_LAYEREDIMAGEVIEW_MIPLEVELS,			"max_layeredimageview_miplevels" },
			{ TMV_MAX_OCCLUSION_QUERIES_PER_POOL,			"max_occlusion_queries_per_pool" },
			{ TMV_MAX_PIPELINESTATISTICS_QUERIES_PER_POOL,	"max_pipelinestatistics_queries_per_pool" },
			{ TMV_MAX_TIMESTAMP_QUERIES_PER_POOL,			"max_timestamp_queries_per_pool" },
		};
		{
			de::MovePtr<tcu::TestCaseGroup> maxValGroup(new tcu::TestCaseGroup(group->getTestContext(), "max_values", ""));

			for (deInt32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testMaxValues); ndx++)
			{
				TestParams testParams
				{
					testMaxValues[ndx].testMaxValues,
					TRC_UNDEFINED
				};
				maxValGroup->addChild(new InstanceFactory1WithSupport<VerifyMaxValues, TestParams, FunctionSupport1<TestParams>>(testCtx, tcu::NODETYPE_SELF_VALIDATE, testMaxValues[ndx].name, "", testParams,
					typename FunctionSupport1<TestParams>::Args(checkSupportVerifyMaxValues, testParams)));
			}

			limitGroup->addChild(maxValGroup.release());
		}

		struct TestRequestCountData
		{
			TestRequestCounts						requestCount;
			const char*								name;
		} testRequestCounts[] =
		{
			{ TRC_SEMAPHORE,					"semaphore" },
			{ TRC_COMMAND_BUFFER,				"command_buffer" },
			{ TRC_FENCE,						"fence" },
			{ TRC_DEVICE_MEMORY,				"device_memory" },
			{ TRC_BUFFER,						"buffer" },
			{ TRC_IMAGE,						"image" },
			{ TRC_EVENT,						"event" },
			{ TRC_QUERY_POOL,					"query_pool" },
			{ TRC_BUFFER_VIEW,					"buffer_view" },
			{ TRC_IMAGE_VIEW,					"image_view" },
			{ TRC_LAYERED_IMAGE_VIEW,			"layered_image_view" },
			{ TRC_PIPELINE_LAYOUT,				"pipeline_layout" },
			{ TRC_RENDER_PASS,					"render_pass" },
			{ TRC_GRAPHICS_PIPELINE,			"graphics_pipeline" },
			{ TRC_COMPUTE_PIPELINE,				"compute_pipeline" },
			{ TRC_DESCRIPTORSET_LAYOUT,			"descriptorset_layout" },
			{ TRC_SAMPLER,						"sampler" },
			{ TRC_DESCRIPTOR_POOL,				"descriptor_pool" },
			{ TRC_DESCRIPTORSET,				"descriptorset" },
			{ TRC_FRAMEBUFFER,					"framebuffer" },
			{ TRC_COMMANDPOOL,					"commandpool" },
			{ TRC_SAMPLERYCBCRCONVERSION,		"samplerycbcrconversion" },
//			{ TRC_SURFACE,						"surface" },
//			{ TRC_SWAPCHAIN,					"swapchain" },
//			{ TRC_DISPLAY_MODE,					"display_mode" },
		};
		{
			de::MovePtr<tcu::TestCaseGroup> requestCountGroup(new tcu::TestCaseGroup(group->getTestContext(), "request_count", ""));

			for (deInt32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testRequestCounts); ndx++)
			{
				TestParams testParams
				{
					TMV_UNDEFINED,
					testRequestCounts[ndx].requestCount
				};
				requestCountGroup->addChild(new InstanceFactory1WithSupport<VerifyRequestCounts, TestParams, FunctionSupport1<TestParams>, ProgramsVerifyLimits>(testCtx, tcu::NODETYPE_SELF_VALIDATE, testRequestCounts[ndx].name, "",
					ProgramsVerifyLimits(), testParams, typename FunctionSupport1<TestParams>::Args(checkSupportVerifyRequestCounts, testParams)));
			}

			limitGroup->addChild(requestCountGroup.release());
		}

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

	// add tests verifying pipeline pool sizes
	{
		de::MovePtr<tcu::TestCaseGroup> ppsGroup(new tcu::TestCaseGroup(group->getTestContext(), "pipeline_pool_size", ""));


		struct PoolSizesData
		{
			TestPoolSizes					type;
			const char*						name;
		} poolSizes[] =
		{
			{ PST_NONE,					"none" },
			{ PST_ZERO,					"zero" },
			{ PST_TOO_SMALL_SIZE,		"too_small_size" },
			{ PST_ONE_FITS,				"one_fits" },
			{ PST_MULTIPLE_FIT,			"multiple_fit" },
		};

		for (deInt32 ndx = 0; ndx < DE_LENGTH_OF_ARRAY(poolSizes); ndx++)
		{
			TestParams testParams(TMV_UNDEFINED, TRC_UNDEFINED, poolSizes[ndx].type);

			ppsGroup->addChild(new InstanceFactory1<VerifyPipelinePoolSizes, TestParams, ProgramsVerifyLimits>(testCtx, tcu::NODETYPE_SELF_VALIDATE, poolSizes[ndx].name, "", ProgramsVerifyLimits(), testParams));
		}


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

	return group.release();
}

}	// sc

}	// vkt