/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2019 The Khronos Group Inc.
 * Copyright (c) 2019 Valve Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *		http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief VK_EXT_depth_range_unrestricted Tests
 *//*--------------------------------------------------------------------*/

#include "vktPipelineDepthRangeUnrestrictedTests.hpp"
#include "vktPipelineVertexUtil.hpp"
#include "vktPipelineClearUtil.hpp"
#include "vktPipelineImageUtil.hpp"
#include "vktPipelineReferenceRenderer.hpp"
#include "vktTestCase.hpp"
#include "vktTestCaseUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkImageUtil.hpp"
#include "vkBuilderUtil.hpp"
#include "vkRefUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkObjUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"

#include <sstream>
#include <vector>

namespace vkt
{
namespace pipeline
{

using namespace vk;

namespace
{

enum testDynamicStaticMode
{
	TEST_MODE_VIEWPORT_DEPTH_BOUNDS_STATIC	= 0,
	TEST_MODE_VIEWPORT_DYNAMIC				= 1,
	TEST_MODE_DEPTH_BOUNDS_DYNAMIC			= 2,
	TEST_MODE_VIEWPORT_DEPTH_BOUNDS_DYNAMIC	= 3,
};

struct DepthRangeUnrestrictedParam
{
	VkFormat		depthFormat;
	VkBool32		testClearValueOnly;
	VkClearValue	depthBufferClearValue;
	VkBool32		depthClampEnable;
	float			wc;							// Component W of the vertices
	deUint32		viewportDepthBoundsMode;
	float			viewportMinDepth;
	float			viewportMaxDepth;
	VkBool32		depthBoundsTestEnable;
	float			minDepthBounds;
	float			maxDepthBounds;
	VkCompareOp		depthCompareOp;
};

// helper functions
std::string getFormatCaseName (vk::VkFormat format)
{
	return de::toLower(de::toString(getFormatStr(format)).substr(10));
}

std::string getCompareOpStringName (VkCompareOp compare)
{
	return de::toLower(de::toString(getCompareOpStr(compare)).substr(3));
}

const std::string generateTestName (struct DepthRangeUnrestrictedParam param)
{
	std::ostringstream result;

	result << getFormatCaseName(param.depthFormat).c_str();
	result << "_" << getCompareOpStringName(param.depthCompareOp).c_str();
	result << "_clear_value_" << (int) param.depthBufferClearValue.depthStencil.depth;

	if (param.depthClampEnable == VK_FALSE)
		result << "_wc_" << (int) param.wc;

	if (param.viewportDepthBoundsMode & TEST_MODE_VIEWPORT_DYNAMIC)
		result << "_dynamic";
	result << "_viewport_min_" << (int)param.viewportMinDepth << "_max_" << (int)param.viewportMaxDepth;

	if (param.depthBoundsTestEnable)
	{
		if (param.viewportDepthBoundsMode & TEST_MODE_DEPTH_BOUNDS_DYNAMIC)
			result << "_dynamic";
		result << "_boundstest_min" << (int)param.minDepthBounds << "_max_" << (int)param.maxDepthBounds;
	}

	return result.str();
}

const std::string generateTestDescription (struct DepthRangeUnrestrictedParam param)
{
	std::string result("Test unrestricted depth ranges on viewport");
	if (param.depthBoundsTestEnable)
		result += " , depth bounds test";
	return result;
}

deBool isSupportedDepthStencilFormat (const InstanceInterface& instanceInterface, VkPhysicalDevice device, VkFormat format)
{
	VkFormatProperties formatProps;

	instanceInterface.getPhysicalDeviceFormatProperties(device, format, &formatProps);

	return (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0u;
}

deBool isFloatingPointDepthFormat (VkFormat format)
{
	switch (format)
	{
	case VK_FORMAT_D32_SFLOAT:
	case VK_FORMAT_D32_SFLOAT_S8_UINT:
		return DE_TRUE;
	case VK_FORMAT_D24_UNORM_S8_UINT:
	case VK_FORMAT_D16_UNORM_S8_UINT:
	case VK_FORMAT_D16_UNORM:
		return DE_FALSE;
	default:
		DE_FATAL("No depth format");
	}
	return DE_FALSE;
}

deBool depthFormatHasStencilComponent (VkFormat format)
{
	switch (format)
	{
	case VK_FORMAT_D32_SFLOAT_S8_UINT:
	case VK_FORMAT_D24_UNORM_S8_UINT:
	case VK_FORMAT_D16_UNORM_S8_UINT:
		return DE_TRUE;
	case VK_FORMAT_D32_SFLOAT:
	case VK_FORMAT_D16_UNORM:
		return DE_FALSE;
	default:
		DE_FATAL("No depth format");
	}
	return DE_FALSE;
}

deBool compareDepthResult (VkCompareOp compare, float depth, float clearValue)
{
	deBool result = DE_FALSE;

	DE_ASSERT(compare <= VK_COMPARE_OP_ALWAYS && compare >= VK_COMPARE_OP_NEVER);

	switch (compare)
	{
	case VK_COMPARE_OP_ALWAYS:
		result = DE_TRUE;
		break;
	case VK_COMPARE_OP_NEVER:
		result = DE_FALSE;
		break;
	case VK_COMPARE_OP_EQUAL:
		result = depth == clearValue;
		break;
	case VK_COMPARE_OP_NOT_EQUAL:
		result = depth != clearValue;
		break;
	case VK_COMPARE_OP_GREATER:
		result = depth > clearValue;
		break;
	case VK_COMPARE_OP_GREATER_OR_EQUAL:
		result = depth >= clearValue;
		break;
	case VK_COMPARE_OP_LESS:
		result = depth < clearValue;
		break;
	case VK_COMPARE_OP_LESS_OR_EQUAL:
		result = depth <= clearValue;
		break;
	default:
		result = false;
		break;
	}
	return result;
}

static inline std::vector<Vertex4RGBA> createPoints (float wc)
{
	using tcu::Vec2;
	using tcu::Vec4;

	std::vector<Vertex4RGBA> vertices;

	// Vertices are in the following positions of the image:
	//
	// ----------------------------------
	// |                                |
	// |                                |
	// |      5                  6      |
	// |                                |
	// |          1         2           |
	// |                                |
	// |                                |
	// |          3         0           |
	// |                                |
	// |      7                  4      |
	// |                                |
	// |                                |
	// ----------------------------------
	//
	// Vertex    Depth    Color
	//   0        0.0     white
	//   1        0.25    magenta
	//   2       -2.0     yellow
	//   3        2.0     red
	//   4       -5.0     black
	//   5        5.0     cyan
	//   6       10.0     blue
	//   7      -10.0     green
	// Depth values are constant, they don't depend on wc.
	const Vertex4RGBA vertex0 =
	{
		Vec4(0.25f * wc, 0.25f * wc, 0.0f, wc),
		Vec4(1.0f, 1.0f, 1.0f, 1.0)
	};
	const Vertex4RGBA vertex1 =
	{
		Vec4(-0.25f * wc, -0.25f * wc, 0.25f, wc),
		Vec4(1.0f, 0.0f, 1.0f, 1.0)
	};
	const Vertex4RGBA vertex2 =
	{
		Vec4(0.25f * wc, -0.25f * wc, -2.0f, wc),
		Vec4(1.0f, 1.0f, 0.0f, 1.0)
	};
	const Vertex4RGBA vertex3 =
	{
		Vec4(-0.25f * wc, 0.25f * wc, 2.0f, wc),
		Vec4(1.0f, 0.0f, 0.0f, 1.0)
	};
	const Vertex4RGBA vertex4 =
	{
		Vec4(0.5f * wc, 0.5f * wc, -5.0f, wc),
		Vec4(0.0f, 0.0f, 0.0f, 1.0)
	};
	const Vertex4RGBA vertex5 =
	{
		Vec4(-0.5f * wc, -0.5f * wc, 5.0f, wc),
		Vec4(0.0f, 1.0f, 1.0f, 1.0)
	};
	const Vertex4RGBA vertex6 =
	{
		Vec4(0.5f * wc, -0.5f * wc, 10.0f, wc),
		Vec4(0.0f, 0.0f, 1.0f, 1.0)
	};

	const Vertex4RGBA vertex7 =
	{
		Vec4(-0.5f * wc, 0.5f * wc, -10.0f, wc),
		Vec4(0.0f, 1.0f, 0.0f, 1.0)
	};

	vertices.push_back(vertex0);
	vertices.push_back(vertex1);
	vertices.push_back(vertex2);
	vertices.push_back(vertex3);
	vertices.push_back(vertex4);
	vertices.push_back(vertex5);
	vertices.push_back(vertex6);
	vertices.push_back(vertex7);

	return vertices;
}

template <class Test>
vkt::TestCase* newTestCase (tcu::TestContext&					testContext,
							const DepthRangeUnrestrictedParam	testParam)
{
	return new Test(testContext,
					generateTestName(testParam).c_str(),
					generateTestDescription(testParam).c_str(),
					testParam);
}

Move<VkBuffer> createBufferAndBindMemory (Context& context, VkDeviceSize size, VkBufferUsageFlags usage, de::MovePtr<Allocation>* pAlloc)
{
	const DeviceInterface&	vk				 = context.getDeviceInterface();
	const VkDevice			vkDevice		 = context.getDevice();
	const deUint32			queueFamilyIndex = context.getUniversalQueueFamilyIndex();

	const VkBufferCreateInfo vertexBufferParams =
	{
		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,		// VkStructureType		sType;
		DE_NULL,									// const void*			pNext;
		0u,											// VkBufferCreateFlags	flags;
		size,										// VkDeviceSize			size;
		usage,										// VkBufferUsageFlags	usage;
		VK_SHARING_MODE_EXCLUSIVE,					// VkSharingMode		sharingMode;
		1u,											// deUint32				queueFamilyCount;
		&queueFamilyIndex							// const deUint32*		pQueueFamilyIndices;
	};

	Move<VkBuffer> vertexBuffer = createBuffer(vk, vkDevice, &vertexBufferParams);

	*pAlloc = context.getDefaultAllocator().allocate(getBufferMemoryRequirements(vk, vkDevice, *vertexBuffer), MemoryRequirement::HostVisible);
	VK_CHECK(vk.bindBufferMemory(vkDevice, *vertexBuffer, (*pAlloc)->getMemory(), (*pAlloc)->getOffset()));

	return vertexBuffer;
}

Move<VkImage> createImage2DAndBindMemory (Context&							context,
										  VkFormat							format,
										  deUint32							width,
										  deUint32							height,
										  VkImageUsageFlags					usage,
										  VkSampleCountFlagBits				sampleCount,
										  de::details::MovePtr<Allocation>* pAlloc)
{
	const DeviceInterface&	vk				 = context.getDeviceInterface();
	const VkDevice			vkDevice		 = context.getDevice();
	const deUint32			queueFamilyIndex = context.getUniversalQueueFamilyIndex();

	const VkImageCreateInfo colorImageParams =
	{
		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,										// VkStructureType		sType;
		DE_NULL,																	// const void*			pNext;
		0u,																			// VkImageCreateFlags	flags;
		VK_IMAGE_TYPE_2D,															// VkImageType			imageType;
		format,																		// VkFormat				format;
		{ width, height, 1u },														// VkExtent3D			extent;
		1u,																			// deUint32				mipLevels;
		1u,																			// deUint32				arraySize;
		sampleCount,																// deUint32				samples;
		VK_IMAGE_TILING_OPTIMAL,													// VkImageTiling		tiling;
		usage,																		// VkImageUsageFlags	usage;
		VK_SHARING_MODE_EXCLUSIVE,													// VkSharingMode		sharingMode;
		1u,																			// deUint32				queueFamilyCount;
		&queueFamilyIndex,															// const deUint32*		pQueueFamilyIndices;
		VK_IMAGE_LAYOUT_UNDEFINED,													// VkImageLayout		initialLayout;
	};

	Move<VkImage> image = createImage(vk, vkDevice, &colorImageParams);

	*pAlloc = context.getDefaultAllocator().allocate(getImageMemoryRequirements(vk, vkDevice, *image), MemoryRequirement::Any);
	VK_CHECK(vk.bindImageMemory(vkDevice, *image, (*pAlloc)->getMemory(), (*pAlloc)->getOffset()));

	return image;
}
Move<VkRenderPass> makeRenderPass (const DeviceInterface&				vk,
								   const VkDevice						device,
								   const VkFormat						colorFormat,
								   const VkFormat						depthStencilFormat,
								   const VkAttachmentLoadOp				loadOperationColor,
								   const VkAttachmentLoadOp				loadOperationDepthStencil)
{
	const bool								hasColor							= colorFormat != VK_FORMAT_UNDEFINED;
	const bool								hasDepthStencil						= depthStencilFormat != VK_FORMAT_UNDEFINED;
	const VkImageLayout						initialLayoutColor					= loadOperationColor == VK_ATTACHMENT_LOAD_OP_LOAD ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
	const VkImageLayout						initialLayoutDepthStencil			= loadOperationDepthStencil == VK_ATTACHMENT_LOAD_OP_LOAD ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;

	const VkAttachmentDescription			colorAttachmentDescription			=
	{
		(VkAttachmentDescriptionFlags)0,				// VkAttachmentDescriptionFlags    flags
		colorFormat,									// VkFormat                        format
		VK_SAMPLE_COUNT_1_BIT,							// VkSampleCountFlagBits           samples
		loadOperationColor,								// VkAttachmentLoadOp              loadOp
		VK_ATTACHMENT_STORE_OP_STORE,					// VkAttachmentStoreOp             storeOp
		VK_ATTACHMENT_LOAD_OP_DONT_CARE,				// VkAttachmentLoadOp              stencilLoadOp
		VK_ATTACHMENT_STORE_OP_DONT_CARE,				// VkAttachmentStoreOp             stencilStoreOp
		initialLayoutColor,								// VkImageLayout                   initialLayout
		VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL		// VkImageLayout                   finalLayout
	};

	const VkAttachmentDescription			depthStencilAttachmentDescription	=
	{
		(VkAttachmentDescriptionFlags)0,					// VkAttachmentDescriptionFlags    flags
		depthStencilFormat,									// VkFormat                        format
		VK_SAMPLE_COUNT_1_BIT,								// VkSampleCountFlagBits           samples
		loadOperationDepthStencil,							// VkAttachmentLoadOp              loadOp
		VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp             storeOp
		loadOperationDepthStencil,							// VkAttachmentLoadOp              stencilLoadOp
		VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp             stencilStoreOp
		initialLayoutDepthStencil,							// VkImageLayout                   initialLayout
		VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL	// VkImageLayout                   finalLayout
	};

	std::vector<VkAttachmentDescription>	attachmentDescriptions;

	if (hasColor)
		attachmentDescriptions.push_back(colorAttachmentDescription);
	if (hasDepthStencil)
		attachmentDescriptions.push_back(depthStencilAttachmentDescription);

	const VkAttachmentReference				colorAttachmentRef					=
	{
		0u,											// deUint32         attachment
		VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL	// VkImageLayout    layout
	};

	const VkAttachmentReference				depthStencilAttachmentRef			=
	{
		hasColor ? 1u : 0u,									// deUint32         attachment
		VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL	// VkImageLayout    layout
	};

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

	const VkRenderPassCreateInfo			renderPassInfo						=
	{
		VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,									// VkStructureType                   sType
		DE_NULL,																	// const void*                       pNext
		(VkRenderPassCreateFlags)0,													// VkRenderPassCreateFlags           flags
		(deUint32)attachmentDescriptions.size(),									// deUint32                          attachmentCount
		attachmentDescriptions.size() > 0 ? &attachmentDescriptions[0] : DE_NULL,	// const VkAttachmentDescription*    pAttachments
		1u,																			// deUint32                          subpassCount
		&subpassDescription,														// const VkSubpassDescription*       pSubpasses
		0u,																			// deUint32                          dependencyCount
		DE_NULL																		// const VkSubpassDependency*        pDependencies
	};

	return createRenderPass(vk, device, &renderPassInfo, DE_NULL);
}

// Test Classes
class DepthRangeUnrestrictedTestInstance : public vkt::TestInstance
{
public:
								DepthRangeUnrestrictedTestInstance		(Context&				context,
																		 const DepthRangeUnrestrictedParam	param);
	virtual						~DepthRangeUnrestrictedTestInstance		(void);
	virtual tcu::TestStatus		iterate									(void);
protected:
			void				prepareRenderPass						(VkRenderPass renderPass, VkFramebuffer framebuffer, VkPipeline pipeline);
			void				prepareCommandBuffer					(void);
			Move<VkPipeline>	buildPipeline							(VkRenderPass renderpass);
			void				bindShaderStage							(VkShaderStageFlagBits					stage,
																		 const char*							sourceName,
																		 const char*							entryName);
			tcu::TestStatus		verifyTestResult						(void);
protected:
	const DepthRangeUnrestrictedParam	m_param;
	deBool								m_extensions;
	const tcu::UVec2					m_renderSize;
	const VkFormat						m_colorFormat;
	Move<VkPipelineLayout>				m_pipelineLayout;

	Move<VkImage>						m_depthImage;
	de::MovePtr<Allocation>				m_depthImageAlloc;
	de::MovePtr<Allocation>				m_colorImageAlloc;
	Move<VkImageView>					m_depthAttachmentView;
	VkImageMemoryBarrier				m_imageLayoutBarriers[2];

	Move<VkBuffer>						m_vertexBuffer;
	de::MovePtr<Allocation>				m_vertexBufferMemory;
	std::vector<Vertex4RGBA>			m_vertices;

	Move<VkRenderPass>					m_renderPass;
	Move<VkCommandPool>					m_cmdPool;
	Move<VkCommandBuffer>				m_cmdBuffer;
	Move<VkImage>						m_colorImage;
	Move<VkImageView>					m_colorAttachmentView;
	Move<VkFramebuffer>					m_framebuffer;
	Move<VkPipeline>					m_pipeline;

	Move<VkShaderModule>				m_shaderModules[2];
	deUint32							m_shaderStageCount;
	VkPipelineShaderStageCreateInfo		m_shaderStageInfo[2];
};

void DepthRangeUnrestrictedTestInstance::bindShaderStage (VkShaderStageFlagBits	stage,
														  const char*			sourceName,
														  const char*			entryName)
{
	const DeviceInterface&	vk			= m_context.getDeviceInterface();
	const VkDevice			vkDevice	= m_context.getDevice();

	// Create shader module
	deUint32*				code		= (deUint32*)m_context.getBinaryCollection().get(sourceName).getBinary();
	deUint32				codeSize	= (deUint32)m_context.getBinaryCollection().get(sourceName).getSize();

	const VkShaderModuleCreateInfo moduleCreateInfo =
	{
		VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,				// VkStructureType				sType;
		DE_NULL,													// const void*					pNext;
		0u,															// VkShaderModuleCreateFlags	flags;
		codeSize,													// deUintptr					codeSize;
		code,														// const deUint32*				pCode;
	};

	m_shaderModules[m_shaderStageCount] = createShaderModule(vk, vkDevice, &moduleCreateInfo);

	// Prepare shader stage info
	m_shaderStageInfo[m_shaderStageCount].sType					= VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
	m_shaderStageInfo[m_shaderStageCount].pNext					= DE_NULL;
	m_shaderStageInfo[m_shaderStageCount].flags					= 0u;
	m_shaderStageInfo[m_shaderStageCount].stage					= stage;
	m_shaderStageInfo[m_shaderStageCount].module				= *m_shaderModules[m_shaderStageCount];
	m_shaderStageInfo[m_shaderStageCount].pName					= entryName;
	m_shaderStageInfo[m_shaderStageCount].pSpecializationInfo	= DE_NULL;

	m_shaderStageCount++;
}

Move<VkPipeline> DepthRangeUnrestrictedTestInstance::buildPipeline (VkRenderPass renderPass)
{
	const DeviceInterface&		vk					= m_context.getDeviceInterface();
	const VkDevice				vkDevice			= m_context.getDevice();

	// Create pipeline
	const VkVertexInputBindingDescription vertexInputBindingDescription =
	{
		0u,									// deUint32				binding;
		sizeof(Vertex4RGBA),				// deUint32				strideInBytes;
		VK_VERTEX_INPUT_RATE_VERTEX,		// VkVertexInputRate	inputRate;
	};

	const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
	{
		{
			0u,									// deUint32 location;
			0u,									// deUint32 binding;
			VK_FORMAT_R32G32B32A32_SFLOAT,		// VkFormat format;
			0u									// deUint32 offsetInBytes;
		},
		{
			1u,									// deUint32 location;
			0u,									// deUint32 binding;
			VK_FORMAT_R32G32B32A32_SFLOAT,		// VkFormat format;
			DE_OFFSET_OF(Vertex4RGBA, color),	// deUint32 offsetInBytes;
		}
	};

	const VkPipelineVertexInputStateCreateInfo vertexInputStateParams =
	{
		VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,		// VkStructureType							sType;
		DE_NULL,														// const void*								pNext;
		0u,																// VkPipelineVertexInputStateCreateFlags	flags;
		1u,																// deUint32									vertexBindingDescriptionCount;
		&vertexInputBindingDescription,									// const VkVertexInputBindingDescription*	pVertexBindingDescriptions;
		2u,																// deUint32									vertexAttributeDescriptionCount;
		vertexInputAttributeDescriptions,								// const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
	};

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

	const VkRect2D		scissor		= makeRect2D(m_renderSize);
	VkViewport			viewport	= makeViewport(m_renderSize);

	if (!(m_param.viewportDepthBoundsMode & TEST_MODE_VIEWPORT_DYNAMIC))
	{
		viewport.minDepth				= m_param.viewportMinDepth;
		viewport.maxDepth				= m_param.viewportMaxDepth;
	}

	const VkPipelineViewportStateCreateInfo viewportStateParams =
	{
		VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,			// VkStructureType							sType;
		DE_NULL,														// const void*								pNext;
		0u,																// VkPipelineViewportStateCreateFlags		flags;
		1u,																// deUint32									viewportCount;
		&viewport,														// const VkViewport*						pViewports;
		1u,																// deUint32									scissorCount;
		&scissor														// const VkRect2D*							pScissors;
	};

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

	const VkPipelineColorBlendAttachmentState colorBlendAttachmentState =
	{
		VK_FALSE,														// VkBool32									blendEnable;
		VK_BLEND_FACTOR_ONE,											// VkBlendFactor							srcColorBlendFactor;
		VK_BLEND_FACTOR_ZERO,											// VkBlendFactor							dstColorBlendFactor;
		VK_BLEND_OP_ADD,												// VkBlendOp								colorBlendOp;
		VK_BLEND_FACTOR_ONE,											// VkBlendFactor							srcAlphaBlendFactor;
		VK_BLEND_FACTOR_ZERO,											// VkBlendFactor							dstAlphaBlendFactor;
		VK_BLEND_OP_ADD,												// VkBlendOp								alphaBlendOp;
		VK_COLOR_COMPONENT_R_BIT |
		VK_COLOR_COMPONENT_G_BIT |
		VK_COLOR_COMPONENT_B_BIT |
		VK_COLOR_COMPONENT_A_BIT										// VkColorComponentFlags					colorWriteMask;
	};

	const VkPipelineColorBlendStateCreateInfo colorBlendStateParams =
	{
		VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,	// VkStructureType								sType;
		DE_NULL,													// const void*									pNext;
		0u,															// VkPipelineColorBlendStateCreateFlags			flags;
		VK_FALSE,													// VkBool32										logicOpEnable;
		VK_LOGIC_OP_COPY,											// VkLogicOp									logicOp;
		1u,															// deUint32										attachmentCount;
		&colorBlendAttachmentState,									// const VkPipelineColorBlendAttachmentState*	pAttachments;
		{ 0.0f, 0.0f, 0.0f, 0.0f },									// float										blendConst[4];
	};

	const VkPipelineMultisampleStateCreateInfo  multisampleStateParams	=
	{
		VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,	// VkStructureType								sType;
		DE_NULL,													// const void*									pNext;
		0u,															// 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;
	};

	float minDepthBounds = m_param.minDepthBounds;
	float maxDepthBounds = m_param.maxDepthBounds;

	if (m_param.viewportDepthBoundsMode & TEST_MODE_DEPTH_BOUNDS_DYNAMIC)
	{
		minDepthBounds = 0.0f;
		maxDepthBounds = 1.0f;
	}

	VkPipelineDepthStencilStateCreateInfo depthStencilStateParams =
	{
		VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType								sType;
		DE_NULL,													// const void*									pNext;
		0u,															// VkPipelineDepthStencilStateCreateFlags		flags;
		VK_TRUE,													// VkBool32										depthTestEnable;
		VK_TRUE,													// VkBool32										depthWriteEnable;
		m_param.depthCompareOp,										// VkCompareOp									depthCompareOp;
		m_param.depthBoundsTestEnable,								// VkBool32										depthBoundsTestEnable;
		VK_FALSE,													// VkBool32										stencilTestEnable;
		// VkStencilOpState front;
		{
			VK_STENCIL_OP_KEEP,		// VkStencilOp	failOp;
			VK_STENCIL_OP_KEEP,		// VkStencilOp	passOp;
			VK_STENCIL_OP_KEEP,		// VkStencilOp	depthFailOp;
			VK_COMPARE_OP_NEVER,	// VkCompareOp	compareOp;
			0u,						// deUint32		compareMask;
			0u,						// deUint32		writeMask;
			0u,						// deUint32		reference;
		},
		// VkStencilOpState back;
		{
			VK_STENCIL_OP_KEEP,		// VkStencilOp	failOp;
			VK_STENCIL_OP_KEEP,		// VkStencilOp	passOp;
			VK_STENCIL_OP_KEEP,		// VkStencilOp	depthFailOp;
			VK_COMPARE_OP_NEVER,	// VkCompareOp	compareOp;
			0u,						// deUint32		compareMask;
			0u,						// deUint32		writeMask;
			0u,						// deUint32		reference;
		},
		minDepthBounds,												// float										minDepthBounds;
		maxDepthBounds,												// float										maxDepthBounds;
	};

	std::vector<VkDynamicState> dynamicStates;
	if (m_param.viewportDepthBoundsMode & TEST_MODE_VIEWPORT_DYNAMIC)
		dynamicStates.push_back(VK_DYNAMIC_STATE_VIEWPORT);
	if (m_param.viewportDepthBoundsMode & TEST_MODE_DEPTH_BOUNDS_DYNAMIC)
		dynamicStates.push_back(VK_DYNAMIC_STATE_DEPTH_BOUNDS);

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

	const VkGraphicsPipelineCreateInfo graphicsPipelineParams =
	{
		VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,	// VkStructureType										sType;
		DE_NULL,											// const void*											pNext;
		0u,													// VkPipelineCreateFlags								flags;
		m_shaderStageCount,									// deUint32												stageCount;
		m_shaderStageInfo,									// const VkPipelineShaderStageCreateInfo*				pStages;
		&vertexInputStateParams,							// const VkPipelineVertexInputStateCreateInfo*			pVertexInputState;
		&inputAssemblyStateParams,							// const VkPipelineInputAssemblyStateCreateInfo*		pInputAssemblyState;
		DE_NULL,											// const VkPipelineTessellationStateCreateInfo*			pTessellationState;
		&viewportStateParams,								// const VkPipelineViewportStateCreateInfo*				pViewportState;
		&rasterStateParams,									// const VkPipelineRasterizationStateCreateInfo*		pRasterState;
		&multisampleStateParams,							// const VkPipelineMultisampleStateCreateInfo*			pMultisampleState;
		&depthStencilStateParams,							// const VkPipelineDepthStencilStateCreateInfo*			pDepthStencilState;
		&colorBlendStateParams,								// const VkPipelineColorBlendStateCreateInfo*			pColorBlendState;
		&dynamicStateParams,								// const VkPipelineDynamicStateCreateInfo*				pDynamicState;
		*m_pipelineLayout,									// VkPipelineLayout										layout;
		renderPass,											// VkRenderPass											renderPass;
		0u,													// deUint32												subpass;
		DE_NULL,											// VkPipeline											basePipelineHandle;
		0u,													// deInt32												basePipelineIndex;
	};

	return createGraphicsPipeline(vk, vkDevice, DE_NULL, &graphicsPipelineParams);
}

void DepthRangeUnrestrictedTestInstance::prepareRenderPass (VkRenderPass renderPass, VkFramebuffer framebuffer, VkPipeline pipeline)
{
	const DeviceInterface&	vk				 = m_context.getDeviceInterface();

	const VkClearValue attachmentClearValues[2] =
	{
		defaultClearValue(m_colorFormat),
		m_param.depthBufferClearValue,
	};

	beginRenderPass(vk, *m_cmdBuffer, renderPass, framebuffer, makeRect2D(0, 0, m_renderSize.x(), m_renderSize.y()), 2u, attachmentClearValues);

	vk.cmdBindPipeline(*m_cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
	VkDeviceSize offsets = 0u;
	vk.cmdBindVertexBuffers(*m_cmdBuffer, 0u, 1u, &m_vertexBuffer.get(), &offsets);

	if (m_param.viewportDepthBoundsMode & TEST_MODE_VIEWPORT_DYNAMIC)
	{
		VkViewport	viewport	= makeViewport(m_renderSize);
		viewport.minDepth		= m_param.viewportMinDepth;
		viewport.maxDepth		= m_param.viewportMaxDepth;
		vk.cmdSetViewport(*m_cmdBuffer, 0u, 1u, &viewport);
	}

	if (m_param.viewportDepthBoundsMode & TEST_MODE_DEPTH_BOUNDS_DYNAMIC)
		vk.cmdSetDepthBounds(*m_cmdBuffer, m_param.minDepthBounds, m_param.maxDepthBounds);

	if (!m_vertices.empty() && !m_param.testClearValueOnly)
		vk.cmdDraw(*m_cmdBuffer, (deUint32)m_vertices.size(), 1u, 0u, 0u);

	endRenderPass(vk, *m_cmdBuffer);
}

void DepthRangeUnrestrictedTestInstance::prepareCommandBuffer (void)
{
	const DeviceInterface&	vk				 = m_context.getDeviceInterface();

	beginCommandBuffer(vk, *m_cmdBuffer, 0u);

	vk.cmdPipelineBarrier(*m_cmdBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, (VkDependencyFlags)0,
		0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(m_imageLayoutBarriers), m_imageLayoutBarriers);

	prepareRenderPass(*m_renderPass, *m_framebuffer, *m_pipeline);

	endCommandBuffer(vk, *m_cmdBuffer);
}

DepthRangeUnrestrictedTestInstance::DepthRangeUnrestrictedTestInstance	(Context&							context,
																		 const DepthRangeUnrestrictedParam	param)
	: TestInstance			(context)
	, m_param				(param)
	, m_extensions			(m_context.requireDeviceFunctionality("VK_EXT_depth_range_unrestricted"))
	, m_renderSize			(tcu::UVec2(32,32))
	, m_colorFormat			(VK_FORMAT_R8G8B8A8_UNORM)
	, m_shaderStageCount	(0)
{
	const DeviceInterface&	vk				 = m_context.getDeviceInterface();
	const VkDevice			vkDevice		 = m_context.getDevice();
	const deUint32			queueFamilyIndex = context.getUniversalQueueFamilyIndex();

	if (!isSupportedDepthStencilFormat(m_context.getInstanceInterface(), m_context.getPhysicalDevice(), param.depthFormat))
	{
		throw tcu::NotSupportedError("Unsupported depth format");
	}

	VkPhysicalDeviceFeatures  features = m_context.getDeviceFeatures();
	if (param.depthClampEnable && features.depthClamp == DE_FALSE)
	{
		throw tcu::NotSupportedError("Unsupported feature: depthClamp");
	}

	if (param.depthBoundsTestEnable && features.depthBounds == DE_FALSE)
	{
		throw tcu::NotSupportedError("Unsupported feature: depthBounds");
	}

	// Create vertex buffer
	{
		m_vertexBuffer	= createBufferAndBindMemory(m_context, 1024u, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, &m_vertexBufferMemory);
		m_vertices		= createPoints(m_param.wc);
		// Load vertices into vertex buffer
		deMemcpy(m_vertexBufferMemory->getHostPtr(), m_vertices.data(), m_vertices.size() * sizeof(Vertex4RGBA));
		flushAlloc(vk, vkDevice, *m_vertexBufferMemory);
	}

	// Create render pass
	m_renderPass = makeRenderPass(vk, vkDevice, m_colorFormat, m_param.depthFormat, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_CLEAR);

	const VkComponentMapping	ComponentMappingRGBA = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A};
	// Create color image
	{
		m_colorImage = createImage2DAndBindMemory(m_context,
												  m_colorFormat,
												  m_renderSize.x(),
												  m_renderSize.y(),
												  VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
												  VK_SAMPLE_COUNT_1_BIT,
												  &m_colorImageAlloc);
	}

	// Create depth image
	{
		m_depthImage = createImage2DAndBindMemory(m_context,
												  m_param.depthFormat,
												  m_renderSize.x(),
												  m_renderSize.y(),
												  VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
												  VK_SAMPLE_COUNT_1_BIT,
												  &m_depthImageAlloc);
	}

	deUint32 depthAspectBits = VK_IMAGE_ASPECT_DEPTH_BIT;
	if (depthFormatHasStencilComponent(param.depthFormat))
		depthAspectBits |= VK_IMAGE_ASPECT_STENCIL_BIT;

	// Set up image layout transition barriers
	{
		VkImageMemoryBarrier colorImageBarrier =
		{
			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,				// VkStructureType			sType;
			DE_NULL,											// const void*				pNext;
			0u,													// VkAccessFlags			srcAccessMask;
			VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,				// VkAccessFlags			dstAccessMask;
			VK_IMAGE_LAYOUT_UNDEFINED,							// VkImageLayout			oldLayout;
			VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,			// VkImageLayout			newLayout;
			VK_QUEUE_FAMILY_IGNORED,							// deUint32					srcQueueFamilyIndex;
			VK_QUEUE_FAMILY_IGNORED,							// deUint32					dstQueueFamilyIndex;
			*m_colorImage,										// VkImage					image;
			{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u },		// VkImageSubresourceRange	subresourceRange;
		};

		m_imageLayoutBarriers[0] = colorImageBarrier;

		VkImageMemoryBarrier depthImageBarrier =
		{
			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,				// VkStructureType			sType;
			DE_NULL,											// const void*				pNext;
			0u,													// VkAccessFlags			srcAccessMask;
			VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,		// VkAccessFlags			dstAccessMask;
			VK_IMAGE_LAYOUT_UNDEFINED,							// VkImageLayout			oldLayout;
			VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,	// VkImageLayout			newLayout;
			VK_QUEUE_FAMILY_IGNORED,							// deUint32					srcQueueFamilyIndex;
			VK_QUEUE_FAMILY_IGNORED,							// deUint32					dstQueueFamilyIndex;
			*m_depthImage,										// VkImage					image;
			{ depthAspectBits, 0u, 1u, 0u, 1u },				// VkImageSubresourceRange	subresourceRange;
		};

		m_imageLayoutBarriers[1] = depthImageBarrier;
	}
	// Create color attachment view
	{
		VkImageViewCreateInfo colorAttachmentViewParams =
		{
			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,		// VkStructureType			sType;
			DE_NULL,										// const void*				pNext;
			0u,												// VkImageViewCreateFlags	flags;
			*m_colorImage,									// VkImage					image;
			VK_IMAGE_VIEW_TYPE_2D,							// VkImageViewType			viewType;
			m_colorFormat,									// VkFormat					format;
			ComponentMappingRGBA,							// VkComponentMapping		components;
			{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u },	// VkImageSubresourceRange	subresourceRange;
		};

		m_colorAttachmentView = createImageView(vk, vkDevice, &colorAttachmentViewParams);
	}

	// Create depth attachment view
	{
		const VkImageViewCreateInfo depthAttachmentViewParams =
		{
			VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,		// VkStructureType			sType;
			DE_NULL,										// const void*				pNext;
			0u,												// VkImageViewCreateFlags	flags;
			*m_depthImage,									// VkImage					image;
			VK_IMAGE_VIEW_TYPE_2D,							// VkImageViewType			viewType;
			m_param.depthFormat,							// VkFormat					format;
			ComponentMappingRGBA,							// VkComponentMapping		components;
			{ depthAspectBits, 0u, 1u, 0u, 1u },			// VkImageSubresourceRange	subresourceRange;
		};

		m_depthAttachmentView = createImageView(vk, vkDevice, &depthAttachmentViewParams);
	}

	// Create framebuffer
	{
		VkImageView attachmentBindInfos[2] =
		{
			*m_colorAttachmentView,
			*m_depthAttachmentView,
		};

		const VkFramebufferCreateInfo framebufferParams =
		{
			VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,			// VkStructureType				sType;
			DE_NULL,											// const void*					pNext;
			0u,													// VkFramebufferCreateFlags		flags;
			*m_renderPass,										// VkRenderPass					renderPass;
			2u,													// deUint32						attachmentCount;
			attachmentBindInfos,								// const VkImageView*			pAttachments;
			(deUint32)m_renderSize.x(),							// deUint32						width;
			(deUint32)m_renderSize.y(),							// deUint32						height;
			1u,													// deUint32						layers;
		};

		m_framebuffer = createFramebuffer(vk, vkDevice, &framebufferParams);
	}

	// Bind shader stages
	{
		bindShaderStage(VK_SHADER_STAGE_VERTEX_BIT, "vert", "main");
		bindShaderStage(VK_SHADER_STAGE_FRAGMENT_BIT, "frag", "main");
	}

	// Create pipeline layout
	{
		const VkPipelineLayoutCreateInfo pipelineLayoutParams =
		{
			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;
		};

		m_pipelineLayout = createPipelineLayout(vk, vkDevice, &pipelineLayoutParams);
	}

	// Create pipeline
	m_pipeline = buildPipeline(*m_renderPass);

	// Create command pool
	m_cmdPool = createCommandPool(vk, vkDevice, VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);

	// Create command buffer
	m_cmdBuffer = allocateCommandBuffer(vk, vkDevice, *m_cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
}

DepthRangeUnrestrictedTestInstance::~DepthRangeUnrestrictedTestInstance (void)
{
}

tcu::TestStatus DepthRangeUnrestrictedTestInstance::iterate (void)
{
	const DeviceInterface&	vk					= m_context.getDeviceInterface();
	const VkDevice			vkDevice			= m_context.getDevice();
	const VkQueue			queue				= m_context.getUniversalQueue();

	prepareCommandBuffer();

	submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
	return verifyTestResult();
}

tcu::TestStatus DepthRangeUnrestrictedTestInstance::verifyTestResult (void)
{
	deBool					compareOk			= DE_TRUE;
	const DeviceInterface&	vk					= m_context.getDeviceInterface();
	const VkDevice			vkDevice			= m_context.getDevice();
	const VkQueue			queue				= m_context.getUniversalQueue();
	const deUint32			queueFamilyIndex	= m_context.getUniversalQueueFamilyIndex();
	tcu::TestLog&			log					= m_context.getTestContext().getLog();
	Allocator&				allocator			= m_context.getDefaultAllocator();
	tcu::TextureLevel		refImage			(vk::mapVkFormat(m_colorFormat), 32, 32);
	float					clearValue			= m_param.depthBufferClearValue.depthStencil.depth;
	double					epsilon				= 1e-5;

	// For non-float depth formats, the value in the depth buffer is already clampled to the range [0, 1], which
	// includes the clear depth value.
	if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
		clearValue = de::min(de::max(clearValue, 0.0f), 1.0f);

	// Generate reference image
	{
		VkClearValue			clearColor		= defaultClearValue(m_colorFormat);
		tcu::Vec4				clearColorVec4  (clearColor.color.float32[0], clearColor.color.float32[1],
												 clearColor.color.float32[2], clearColor.color.float32[3]);

		tcu::clear(refImage.getAccess(), clearColorVec4);
		for (std::vector<Vertex4RGBA>::const_iterator vertex = m_vertices.begin(); vertex != m_vertices.end(); ++vertex)
		{
			if (m_param.depthClampEnable == VK_FALSE && (vertex->position.z() < 0.0f || vertex->position.z() > vertex->position.w()))
				continue;

			if (m_param.testClearValueOnly)
				continue;

			// Depth Clamp is enabled, then we clamp point depth to viewport's maxDepth and minDepth values, or [0.0f, 1.0f] is depth format is fixed-point.
			float scaling = ((vertex->position.z() / vertex->position.w()) * (m_param.viewportMaxDepth - m_param.viewportMinDepth)) + m_param.viewportMinDepth;
			float depth = de::min(de::max(scaling, m_param.viewportMinDepth), m_param.viewportMaxDepth);

			// For non-float depth formats, depth value is clampled to the range [0, 1].
			if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
				depth = de::min(de::max(depth, 0.0f), 1.0f);

			if (compareDepthResult(m_param.depthCompareOp, depth, clearValue))
			{
				deInt32 x = static_cast<deInt32>((((vertex->position.x() / vertex->position.w()) + 1.0f) / 2.0f) * static_cast<float>(m_renderSize.x() - 1));
				deInt32 y = static_cast<deInt32>((((vertex->position.y() / vertex->position.w()) + 1.0f) / 2.0f) * static_cast<float>(m_renderSize.y() - 1));
				refImage.getAccess().setPixel(vertex->color, x, y);
			}
		}
	}

	// Check the rendered image
	{
		de::MovePtr<tcu::TextureLevel> result = vkt::pipeline::readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_colorImage, m_colorFormat, m_renderSize);

		compareOk = tcu::intThresholdPositionDeviationCompare(m_context.getTestContext().getLog(),
															  "IntImageCompare",
															  "Image comparison",
															  refImage.getAccess(),
															  result->getAccess(),
															  tcu::UVec4(2, 2, 2, 2),
															  tcu::IVec3(1, 1, 0),
															  true,
															  tcu::COMPARE_LOG_RESULT);
		if (!compareOk)
			return tcu::TestStatus::fail("Image mismatch");
	}

	// Check depth buffer contents
	{
		de::MovePtr<tcu::TextureLevel>	depthResult		= readDepthAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_depthImage, m_param.depthFormat, m_renderSize);

		if (m_param.testClearValueOnly) {
			compareOk = tcu::floatThresholdCompare(m_context.getTestContext().getLog(),
												   "DepthImagecompare",
												   "Depth image comparison",
												   tcu::Vec4(clearValue, 0.0f, 0.0f, 1.0f),
												   depthResult->getAccess(),
												   tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
												   tcu::COMPARE_LOG_RESULT);
			if (!compareOk)
				return tcu::TestStatus::fail("Depth buffer mismatch");
			else
				return tcu::TestStatus::pass("Result images matches references");
		}

		log << tcu::TestLog::Message;
		for (std::vector<Vertex4RGBA>::const_iterator vertex = m_vertices.begin(); vertex != m_vertices.end(); ++vertex)
		{
			deInt32 x = static_cast<deInt32>((((vertex->position.x() / vertex->position.w()) + 1.0f) / 2.0f) * static_cast<float>(m_renderSize.x() - 1));
			deInt32 y = static_cast<deInt32>((((vertex->position.y() / vertex->position.w()) + 1.0f) / 2.0f) * static_cast<float>(m_renderSize.y() - 1));
			tcu::Vec4 depth	= depthResult->getAccess().getPixel(x, y);

			// Check depth values are valid
			if (depth.y() != 0.0f || depth.z() != 0.0f || depth.w() != 1.0f)
			{
				log << tcu::TestLog::Message << "Invalid depth buffer values for pixel (" << x << ", " << y << ") = ("
					<< depth.x() << ", " << depth.y() << ", " << depth.z() << ", " << depth.w() << "." << tcu::TestLog::EndMessage;
				compareOk = DE_FALSE;
			}

			// Check the case where depth clamping is disabled.
			if (m_param.depthClampEnable == VK_FALSE)
			{
				if ((vertex->position.z() < 0.0f || vertex->position.z() > vertex->position.w()) &&
					fabs(clearValue - depth.x()) > epsilon)
				{
					log << tcu::TestLog::Message << "Error pixel (" << x << ", " << y << "). Depth value = " << depth
						<< ", expected " << clearValue << "." << tcu::TestLog::EndMessage;
					compareOk = DE_FALSE;
				}

				float expectedDepth = clearValue;

				if (vertex->position.z() <= vertex->position.w() && vertex->position.z() >= 0.0f)
				{
					// Assert we have a symmetric range around zero.
					DE_ASSERT(m_param.viewportMinDepth == (-m_param.viewportMaxDepth));

					// Calculate the expected depth value: first translate the value to from [0.0f, 1.0f] to [-1.0f, 1.0f].
					expectedDepth = 2 * (vertex->position.z() / vertex->position.w()) - 1.0f;
					// Now multiply by m_param.viewportMaxDepth to get the expected value.
					expectedDepth *= m_param.viewportMaxDepth;
				}

				// For non-float depth formats, depth value is clampled to the range [0, 1].
				if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
					expectedDepth = de::min(de::max(expectedDepth, 0.0f), 1.0f);

				expectedDepth = compareDepthResult(m_param.depthCompareOp, expectedDepth, clearValue) ? expectedDepth : clearValue;

				if (fabs(expectedDepth - depth.x()) > epsilon)
				{
					log << tcu::TestLog::Message << "Error pixel (" << x << ", " << y
						<< "). Depth value " << depth.x() << ", expected " << expectedDepth << ", error " << fabs(expectedDepth - depth.x()) << tcu::TestLog::EndMessage;
					compareOk = DE_FALSE;
				}

				continue;
			}

			// Depth Clamp is enabled, then we clamp point depth to viewport's maxDepth and minDepth values, or 0.0f and 1.0f is format is not float.
			float scaling = (vertex->position.z() / vertex->position.w()) * (m_param.viewportMaxDepth - m_param.viewportMinDepth) + m_param.viewportMinDepth;
			float expectedDepth = de::min(de::max(scaling, m_param.viewportMinDepth), m_param.viewportMaxDepth);

			// For non-float depth formats, depth value is clampled to the range [0, 1].
			if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
				expectedDepth = de::min(de::max(expectedDepth, 0.0f), 1.0f);

			expectedDepth = compareDepthResult(m_param.depthCompareOp, expectedDepth, clearValue) ? expectedDepth : clearValue;

			if (fabs(expectedDepth - depth.x()) > epsilon)
			{
				log << tcu::TestLog::Message << "Error pixel (" << x << ", " << y
					<< "). Depth value " << depth.x() << ", expected " << expectedDepth << ", error " << fabs(expectedDepth - depth.x()) << tcu::TestLog::EndMessage;
				compareOk = DE_FALSE;
			}
		}

		if (!compareOk)
			return tcu::TestStatus::fail("Depth buffer mismatch");
	}

	return tcu::TestStatus::pass("Result images matches references");
}

// Test Classes
class DepthBoundsRangeUnrestrictedTestInstance : public DepthRangeUnrestrictedTestInstance
{
public:
								DepthBoundsRangeUnrestrictedTestInstance		(Context&				context,
																				 const DepthRangeUnrestrictedParam	param);
	virtual						~DepthBoundsRangeUnrestrictedTestInstance		(void);
	virtual tcu::TestStatus		iterate											(void);

protected:
			tcu::TestStatus		verifyTestResult								(bool firstDraw);
			void				prepareCommandBuffer							(bool firstDraw);

protected:
			Move<VkRenderPass>					m_renderPassSecondDraw;
			Move<VkFramebuffer>					m_framebufferSecondDraw;
			Move<VkPipeline>					m_pipelineSecondDraw;
			std::vector<bool>					m_vertexWasRendered;

};

DepthBoundsRangeUnrestrictedTestInstance::DepthBoundsRangeUnrestrictedTestInstance	(Context&							context,
																					 const DepthRangeUnrestrictedParam	param)
	: DepthRangeUnrestrictedTestInstance(context, param)
{
	const DeviceInterface&	vk				 = m_context.getDeviceInterface();
	const VkDevice			vkDevice		 = m_context.getDevice();

	// Create render pass for second draw, we keep the first draw's contents of the depth buffer.
	m_renderPassSecondDraw = makeRenderPass(vk, vkDevice, m_colorFormat, m_param.depthFormat, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_LOAD);

	// Create framebuffer for second draw.
	{
		VkImageView attachmentBindInfos[2] =
		{
			*m_colorAttachmentView,
			*m_depthAttachmentView,
		};

		const VkFramebufferCreateInfo framebufferParams =
		{
			VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,			// VkStructureType				sType;
			DE_NULL,											// const void*					pNext;
			0u,													// VkFramebufferCreateFlags		flags;
			*m_renderPassSecondDraw,							// VkRenderPass					renderPass;
			2u,													// deUint32						attachmentCount;
			attachmentBindInfos,								// const VkImageView*			pAttachments;
			(deUint32)m_renderSize.x(),							// deUint32						width;
			(deUint32)m_renderSize.y(),							// deUint32						height;
			1u,													// deUint32						layers;
		};

		m_framebufferSecondDraw = createFramebuffer(vk, vkDevice, &framebufferParams);
	}

		// Create pipeline
	m_pipelineSecondDraw = buildPipeline(*m_renderPassSecondDraw);
}

DepthBoundsRangeUnrestrictedTestInstance::~DepthBoundsRangeUnrestrictedTestInstance (void)
{
}

tcu::TestStatus DepthBoundsRangeUnrestrictedTestInstance::iterate (void)
{
	const DeviceInterface&	vk					= m_context.getDeviceInterface();
	const VkDevice			vkDevice			= m_context.getDevice();
	const VkQueue			queue				= m_context.getUniversalQueue();

	// This test will draw the same scene two times.
	// First one will render the points depending on if the pass the depth test and if clear depth value passes the
	// depthBounds test.
	//
	// The second one, will render the same scene but the the point positions will have depth buffer values from
	// the first draw. If they pass the depth test, the depthBounds test will check the content of the depth buffer,
	// which is most cases, will make that the second result differs from the first one, hence the need to split
	// the verification in two steps.
	prepareCommandBuffer(true);
	submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
	tcu::TestStatus status = verifyTestResult(true);
	if (status.getCode() != QP_TEST_RESULT_PASS)
		return status;

	prepareCommandBuffer(false);
	submitCommandsAndWait(vk, vkDevice, queue, m_cmdBuffer.get());
	return verifyTestResult(false);
}

void DepthBoundsRangeUnrestrictedTestInstance::prepareCommandBuffer (bool firstDraw)
{
	const DeviceInterface&	vk				 = m_context.getDeviceInterface();

	if (!firstDraw)
	{
		vk.resetCommandBuffer(*m_cmdBuffer, VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
		// Color image layout changed after verifying the first draw call, restore it.
		m_imageLayoutBarriers[0].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
		m_imageLayoutBarriers[0].oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
		// Depth image layout changed after verifying the first draw call, restore it.
		m_imageLayoutBarriers[1].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
		m_imageLayoutBarriers[1].oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
	}

	beginCommandBuffer(vk, *m_cmdBuffer, 0u);

	vk.cmdPipelineBarrier(*m_cmdBuffer, (firstDraw ? VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT : VK_PIPELINE_STAGE_TRANSFER_BIT), VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, (VkDependencyFlags)0,
		0u, DE_NULL, 0u, DE_NULL, DE_LENGTH_OF_ARRAY(m_imageLayoutBarriers), m_imageLayoutBarriers);

	prepareRenderPass((firstDraw ? *m_renderPass : *m_renderPassSecondDraw),
					  (firstDraw ? *m_framebuffer : *m_framebufferSecondDraw),
					  (firstDraw ? *m_pipeline : *m_pipelineSecondDraw));

	endCommandBuffer(vk, *m_cmdBuffer);
}

tcu::TestStatus DepthBoundsRangeUnrestrictedTestInstance::verifyTestResult (bool firstDraw)
{
	deBool					compareOk			= DE_TRUE;
	const DeviceInterface&	vk					= m_context.getDeviceInterface();
	const VkDevice			vkDevice			= m_context.getDevice();
	const VkQueue			queue				= m_context.getUniversalQueue();
	const deUint32			queueFamilyIndex	= m_context.getUniversalQueueFamilyIndex();
	tcu::TestLog&			log					= m_context.getTestContext().getLog();
	Allocator&				allocator			= m_context.getDefaultAllocator();
	tcu::TextureLevel		refImage			(vk::mapVkFormat(m_colorFormat), 32, 32);
	float					clearValue			= m_param.depthBufferClearValue.depthStencil.depth;
	double					epsilon				= 1e-5;

	// For non-float depth formats, depth value is clampled to the range [0, 1].
	if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
		clearValue = de::min(de::max(clearValue, 0.0f), 1.0f);

	// Generate reference image
	{
		VkClearValue			clearColor		= defaultClearValue(m_colorFormat);
		tcu::Vec4				clearColorVec4  (clearColor.color.float32[0], clearColor.color.float32[1],
												 clearColor.color.float32[2], clearColor.color.float32[3]);
		tcu::clear(refImage.getAccess(), clearColorVec4);
		for (std::vector<Vertex4RGBA>::const_iterator vertex = m_vertices.begin(); vertex != m_vertices.end(); ++vertex)
		{
			// Depth Clamp is enabled, then we clamp point depth to viewport's maxDepth and minDepth values and later check if it is inside depthBounds volume.
			float scaling = ((vertex->position.z() / vertex->position.w()) * (m_param.viewportMaxDepth - m_param.viewportMinDepth)) + m_param.viewportMinDepth;
			float depth = de::min(de::max(scaling, m_param.viewportMinDepth), m_param.viewportMaxDepth);
			if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
				depth = de::min(de::max(depth, 0.0f), 1.0f);

			auto i = vertex - m_vertices.begin();

			// Depending if the first draw call succeed, we need to know if the second draw call will render the points because the depth buffer content
			// will determine if it passes the depth test and the depth bounds test.
			bool firstDrawHasPassedDepthBoundsTest = !firstDraw && m_vertexWasRendered[i];
			float depthBufferValue = firstDrawHasPassedDepthBoundsTest ? depth : clearValue;

			// For non-float depth formats, depth value is clampled to the range [0, 1].
			if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
				depthBufferValue = de::min(de::max(depthBufferValue, 0.0f), 1.0f);

			// Check that the point passes the depth test and the depth bounds test.
			if (compareDepthResult(m_param.depthCompareOp, depth, depthBufferValue) &&
				depthBufferValue >= m_param.minDepthBounds && depthBufferValue <= m_param.maxDepthBounds)
			{
				deInt32 x = static_cast<deInt32>((((vertex->position.x() / vertex->position.w()) + 1.0f) / 2.0f) * static_cast<float>(m_renderSize.x() - 1));
				deInt32 y = static_cast<deInt32>((((vertex->position.y() / vertex->position.w()) + 1.0f) / 2.0f) * static_cast<float>(m_renderSize.y() - 1));
				refImage.getAccess().setPixel(vertex->color, x, y);
				if (firstDraw)
					m_vertexWasRendered.push_back(true);
				continue;
			}

			if (firstDraw)
				m_vertexWasRendered.push_back(false);
		}
	}

	// Check the rendered image
	{
		de::MovePtr<tcu::TextureLevel> result = vkt::pipeline::readColorAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_colorImage, m_colorFormat, m_renderSize);
		std::string description = "Image comparison draw ";
		description += (firstDraw ? "1" : "2");

		compareOk = tcu::intThresholdPositionDeviationCompare(m_context.getTestContext().getLog(),
															  "IntImageCompare",
															  description.c_str(),
															  refImage.getAccess(),
															  result->getAccess(),
															  tcu::UVec4(2, 2, 2, 2),
															  tcu::IVec3(1, 1, 0),
															  true,
															  tcu::COMPARE_LOG_RESULT);
		if (!compareOk)
			return tcu::TestStatus::fail("Image mismatch");
	}

	// Check depth buffer contents
	{
		de::MovePtr<tcu::TextureLevel>	depthResult		= readDepthAttachment(vk, vkDevice, queue, queueFamilyIndex, allocator, *m_depthImage, m_param.depthFormat, m_renderSize);

		log << tcu::TestLog::Message;
		for (std::vector<Vertex4RGBA>::const_iterator vertex = m_vertices.begin(); vertex != m_vertices.end(); ++vertex)
		{
			deInt32 x = static_cast<deInt32>((((vertex->position.x() / vertex->position.w()) + 1.0f) / 2.0f) * static_cast<float>(m_renderSize.x() - 1));
			deInt32 y = static_cast<deInt32>((((vertex->position.y() / vertex->position.w()) + 1.0f) / 2.0f) * static_cast<float>(m_renderSize.y() - 1));
			tcu::Vec4 depth	= depthResult->getAccess().getPixel(x, y);

			// Check depth values are valid
			if (depth.y() != 0.0f || depth.z() != 0.0f || depth.w() != 1.0f)
			{
				log << tcu::TestLog::Message << "Draw " << (firstDraw ? "1" : "2") << ": Invalid depth buffer values for pixel (" << x << ", " << y << ") = ("
					<< depth.x() << ", " << depth.y() << ", " << depth.z() << ", " << depth.w() << "." << tcu::TestLog::EndMessage;
				compareOk = DE_FALSE;
			}

			// Depth Clamp is enabled, so we clamp point depth to viewport's maxDepth and minDepth values, or 0.0f and 1.0f is format is not float.
			float scaling = (vertex->position.z() / vertex->position.w()) * (m_param.viewportMaxDepth - m_param.viewportMinDepth) + m_param.viewportMinDepth;
			float expectedDepth = de::min(de::max(scaling, m_param.viewportMinDepth), m_param.viewportMaxDepth);

			auto i = vertex - m_vertices.begin();

			// Depending if the first draw call succeed, we need to know if the second draw call will render the points because the depth buffer content
			// will determine if it passes the depth test and the depth bounds test.
			bool firstDrawHasPassedDepthBoundsTest = !firstDraw && m_vertexWasRendered[i];

			// If we are in the first draw call, the depth buffer content is clearValue. If we are in the second draw call, it is going to be depth.x() if the first
			// succeeded.
			float depthBufferValue = firstDrawHasPassedDepthBoundsTest ? depth.x() : clearValue;

			// For non-float depth formats, depth value is clampled to the range [0, 1].
			if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
				depthBufferValue = de::min(de::max(depthBufferValue, 0.0f), 1.0f);

			// Calculate the expectd depth depending on the depth test and the depth bounds test results.
			expectedDepth =
				(compareDepthResult(m_param.depthCompareOp, expectedDepth, depthBufferValue) && depthBufferValue <= m_param.maxDepthBounds && depthBufferValue >= m_param.minDepthBounds)
				? expectedDepth : depthBufferValue;

			// For non-float depth formats, depth value is clampled to the range [0, 1].
			if (isFloatingPointDepthFormat(m_param.depthFormat) == VK_FALSE)
				expectedDepth = de::min(de::max(expectedDepth, 0.0f), 1.0f);

			if (fabs(expectedDepth - depth.x()) > epsilon)
			{
				log << tcu::TestLog::Message << "Draw " << (firstDraw ? "1" : "2") << ": Error pixel (" << x << ", " << y
					<< "). Depth value " << depth.x() << ", expected " << expectedDepth << ", error " << fabs(expectedDepth - depth.x()) << tcu::TestLog::EndMessage;
				compareOk = DE_FALSE;
			}
		}

		if (!compareOk)
			return tcu::TestStatus::fail("Depth buffer mismatch");
	}

	return tcu::TestStatus::pass("Result images matches references");
}

class DepthRangeUnrestrictedTest : public vkt::TestCase
{
public:
							DepthRangeUnrestrictedTest			(tcu::TestContext&					testContext,
																 const std::string&					name,
																 const std::string&					description,
																 const DepthRangeUnrestrictedParam	param)
								: vkt::TestCase (testContext, name, description)
								, m_param		(param)
								{ }
	virtual					~DepthRangeUnrestrictedTest	(void) { }
	virtual void			initPrograms		(SourceCollections&	programCollection) const;
	virtual TestInstance*	createInstance		(Context&				context) const;

protected:
		const DepthRangeUnrestrictedParam       m_param;
};

void DepthRangeUnrestrictedTest::initPrograms (SourceCollections& programCollection) const
{
	programCollection.glslSources.add("vert") << glu::VertexSource(
				"#version 310 es\n"
				"layout(location = 0) in vec4 position;\n"
				"layout(location = 1) in vec4 color;\n"
				"layout(location = 0) out highp vec4 vtxColor;\n"
				"void main (void)\n"
				"{\n"
				"  gl_Position = position;\n"
				"  gl_PointSize = 1.0f;\n"
				"  vtxColor = color;\n"

				"}\n");


	programCollection.glslSources.add("frag") << glu::FragmentSource(
				"#version 310 es\n"
				"layout(location = 0) in highp vec4 vtxColor;\n"
				"layout(location = 0) out highp vec4 fragColor;\n"
				"void main (void)\n"
				"{\n"
				"  fragColor = vtxColor;\n"
				"}\n");

}

TestInstance* DepthRangeUnrestrictedTest::createInstance (Context& context) const
{
	if (m_param.depthBoundsTestEnable)
		return new DepthBoundsRangeUnrestrictedTestInstance(context, m_param);
	return new DepthRangeUnrestrictedTestInstance(context, m_param);
}
} // anonymous

tcu::TestCaseGroup* createDepthRangeUnrestrictedTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> depthTests (new tcu::TestCaseGroup(testCtx, "depth_range_unrestricted", "VK_EXT_depth_range_unrestricted tests"));
	const VkFormat depthFormats[]	=
	{
		VK_FORMAT_D32_SFLOAT,
		VK_FORMAT_D24_UNORM_S8_UINT,
		VK_FORMAT_D16_UNORM,
	};

	const VkCompareOp compareOps[]	=
	{
		VK_COMPARE_OP_GREATER,
		VK_COMPARE_OP_GREATER_OR_EQUAL,
		VK_COMPARE_OP_LESS,
		VK_COMPARE_OP_LESS_OR_EQUAL,
	};

	float viewportValues[]			= {2.0f, 6.0f, 12.0f};
	float depthBoundsValues[]		= {2.0f, 4.0f, 8.0f};
	float wcValues[]				= {2.0f, 6.0f, 12.0f};
	float clearValues[]				= {2.0f, -3.0f, 6.0f, -7.0f};

	// Depth clear values outside range [0.0f, 1.0f].
	{
		de::MovePtr<tcu::TestCaseGroup> depthClearValueTests (new tcu::TestCaseGroup(testCtx, "clear_value", "Depth Clear value unrestricted"));
		DepthRangeUnrestrictedParam testParams;
		testParams.testClearValueOnly			= VK_TRUE;
		testParams.depthClampEnable				= VK_FALSE;
		testParams.wc							= 1.0f;
		testParams.viewportMinDepth				= 0.0f;
		testParams.viewportMaxDepth				= 1.0f;
		testParams.minDepthBounds				= 0.0f;
		testParams.maxDepthBounds				= 1.0f;
		testParams.depthBoundsTestEnable		= VK_FALSE;
		testParams.depthCompareOp				= VK_COMPARE_OP_LESS_OR_EQUAL;
		testParams.viewportDepthBoundsMode		= TEST_MODE_VIEWPORT_DEPTH_BOUNDS_STATIC;

		for (int format = 0; format < DE_LENGTH_OF_ARRAY(depthFormats); ++format)
		{
			testParams.depthFormat				= depthFormats[format];
			testParams.depthBufferClearValue	= defaultClearValue(depthFormats[format]);
			for (int val = 0; val < DE_LENGTH_OF_ARRAY(clearValues); val++)
			{
				testParams.depthBufferClearValue.depthStencil.depth	= clearValues[val];
				depthClearValueTests->addChild(newTestCase<DepthRangeUnrestrictedTest>(testCtx, testParams));
			}
		}
		depthTests->addChild(depthClearValueTests.release());
	}

	// Viewport's depth unrestricted range
	{
		de::MovePtr<tcu::TestCaseGroup> viewportTests (new tcu::TestCaseGroup(testCtx, "viewport", "Viewport depth unrestricted range"));
		DepthRangeUnrestrictedParam testParams;
		testParams.testClearValueOnly		= VK_FALSE;
		testParams.wc						= 1.0f;
		testParams.depthClampEnable			= VK_TRUE;
		testParams.minDepthBounds			= 0.0f;
		testParams.maxDepthBounds			= 1.0f;
		testParams.depthBoundsTestEnable	= VK_FALSE;

		for (int format = 0; format < DE_LENGTH_OF_ARRAY(depthFormats); ++format)
		{
			testParams.depthFormat				= depthFormats[format];
			testParams.depthBufferClearValue	= defaultClearValue(testParams.depthFormat);
			for (int compareOp = 0; compareOp < DE_LENGTH_OF_ARRAY(compareOps); compareOp++)
			{
				testParams.depthCompareOp		= compareOps[compareOp];
				for (int clearValue = 0; clearValue < DE_LENGTH_OF_ARRAY(clearValues); clearValue++)
				{
					testParams.depthBufferClearValue.depthStencil.depth		= clearValues[clearValue];
					for (int viewportValue = 0; viewportValue < DE_LENGTH_OF_ARRAY(viewportValues); viewportValue++)
					{
						testParams.viewportMinDepth			= -viewportValues[viewportValue];
						testParams.viewportMaxDepth			= viewportValues[viewportValue];
						testParams.viewportDepthBoundsMode	= TEST_MODE_VIEWPORT_DEPTH_BOUNDS_STATIC;
						viewportTests->addChild(newTestCase<DepthRangeUnrestrictedTest>(testCtx, testParams));
						testParams.viewportDepthBoundsMode	= TEST_MODE_VIEWPORT_DYNAMIC;
						viewportTests->addChild(newTestCase<DepthRangeUnrestrictedTest>(testCtx, testParams));
					}
				}
			}
		}

		depthTests->addChild(viewportTests.release());
	}

	// DepthBounds's depth unrestricted range
	{
		de::MovePtr<tcu::TestCaseGroup> depthBoundsTests (new tcu::TestCaseGroup(testCtx, "depthbounds", "Depthbounds unrestricted range"));
		DepthRangeUnrestrictedParam testParams;
		testParams.testClearValueOnly							= VK_FALSE;
		testParams.wc											= 1.0f;
		testParams.depthClampEnable								= VK_TRUE;
		testParams.depthBoundsTestEnable						= VK_TRUE;

		for (int format = 0; format < DE_LENGTH_OF_ARRAY(depthFormats); ++format)
		{
			testParams.depthFormat				= depthFormats[format];
			testParams.depthBufferClearValue	= defaultClearValue(testParams.depthFormat);
			for (int compareOp = 0; compareOp < DE_LENGTH_OF_ARRAY(compareOps); compareOp++)
			{
				testParams.depthCompareOp		= compareOps[compareOp];
				for (int clearValue = 0; clearValue < DE_LENGTH_OF_ARRAY(clearValues); clearValue++)
				{
					testParams.depthBufferClearValue.depthStencil.depth		= clearValues[clearValue];
					for (int viewportValue = 0; viewportValue < DE_LENGTH_OF_ARRAY(viewportValues); viewportValue++)
					{
						testParams.viewportMinDepth				= -viewportValues[viewportValue];
						testParams.viewportMaxDepth				= viewportValues[viewportValue];
						for (int depthValue = 0; depthValue < DE_LENGTH_OF_ARRAY(depthBoundsValues); depthValue++)
						{
							testParams.minDepthBounds			= -depthBoundsValues[depthValue];
							testParams.maxDepthBounds			= depthBoundsValues[depthValue];

							testParams.viewportDepthBoundsMode	= TEST_MODE_VIEWPORT_DEPTH_BOUNDS_STATIC;
							depthBoundsTests->addChild(newTestCase<DepthRangeUnrestrictedTest>(testCtx, testParams));
							testParams.viewportDepthBoundsMode	= TEST_MODE_DEPTH_BOUNDS_DYNAMIC;
							depthBoundsTests->addChild(newTestCase<DepthRangeUnrestrictedTest>(testCtx, testParams));
							testParams.viewportDepthBoundsMode  = TEST_MODE_VIEWPORT_DEPTH_BOUNDS_DYNAMIC;
							depthBoundsTests->addChild(newTestCase<DepthRangeUnrestrictedTest>(testCtx, testParams));
						}
					}
				}
			}
		}

		depthTests->addChild(depthBoundsTests.release());
	}

	// Depth clamping disabled
	{
		de::MovePtr<tcu::TestCaseGroup> noDepthClampingTests (new tcu::TestCaseGroup(testCtx, "depthclampingdisabled", "Depth clamping disabled tests"));
		DepthRangeUnrestrictedParam testParams;
		testParams.testClearValueOnly			= VK_FALSE;
		testParams.depthClampEnable				= VK_FALSE;
		testParams.minDepthBounds				= 0.0f;
		testParams.maxDepthBounds				= 1.0f;
		testParams.depthBoundsTestEnable		= VK_FALSE;
		testParams.viewportDepthBoundsMode		= TEST_MODE_VIEWPORT_DEPTH_BOUNDS_STATIC;

		for (int format = 0; format < DE_LENGTH_OF_ARRAY(depthFormats); ++format)
		{
			testParams.depthFormat					= depthFormats[format];
			testParams.depthBufferClearValue		= defaultClearValue(testParams.depthFormat);
			for (int compareOp = 0; compareOp < DE_LENGTH_OF_ARRAY(compareOps); compareOp++)
			{
				testParams.depthCompareOp			= compareOps[compareOp];
				for (int clearValue = 0; clearValue < DE_LENGTH_OF_ARRAY(clearValues); clearValue++)
				{
					testParams.depthBufferClearValue.depthStencil.depth	= clearValues[clearValue];
					for (int viewportValue = 0; viewportValue < DE_LENGTH_OF_ARRAY(viewportValues); viewportValue++)
					{
						testParams.viewportMinDepth	= -viewportValues[viewportValue];
						testParams.viewportMaxDepth	= viewportValues[viewportValue];
						for (int wc = 0; wc < DE_LENGTH_OF_ARRAY(wcValues); wc++)
						{
							testParams.wc	= wcValues[wc];
							noDepthClampingTests->addChild(newTestCase<DepthRangeUnrestrictedTest>(testCtx, testParams));
						}
					}
				}
			}
		}

		depthTests->addChild(noDepthClampingTests.release());
	}

	return depthTests.release();
}

} // pipeline

} // vkt