diff --git a/android/cts/master/vk-master.txt b/android/cts/master/vk-master.txt
index f9edce0..f12747c 100644
--- a/android/cts/master/vk-master.txt
+++ b/android/cts/master/vk-master.txt
Binary files differ
diff --git a/external/vulkancts/framework/vulkan/vkBasicTypes.inl b/external/vulkancts/framework/vulkan/vkBasicTypes.inl
index 3f03a73..4fa4153 100644
--- a/external/vulkancts/framework/vulkan/vkBasicTypes.inl
+++ b/external/vulkancts/framework/vulkan/vkBasicTypes.inl
@@ -459,6 +459,9 @@
 	VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT									= 1000238001,
 	VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR								= 1000239000,
 	VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV	= 1000240000,
+	VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR		= 1000241000,
+	VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR							= 1000241001,
+	VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR							= 1000241002,
 	VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT				= 1000244000,
 	VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT									= 1000244001,
 	VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT								= 1000244002,
@@ -922,6 +925,10 @@
 	VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR								= 1000111000,
 	VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV							= 1000164003,
 	VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT				= 1000218000,
+	VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR					= 1000241000,
+	VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR						= 1000241001,
+	VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR					= 1000241002,
+	VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR					= 1000241003,
 	VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR	= VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
 	VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR	= VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
 	VK_IMAGE_LAYOUT_MAX_ENUM										= 0x7FFFFFFF,
@@ -2888,6 +2895,7 @@
 #define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3
 #define VK_KHR_SPIRV_1_4_SPEC_VERSION 1
 #define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1
+#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
 #define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1
 #define VK_EXT_DEBUG_REPORT_SPEC_VERSION 9
diff --git a/external/vulkancts/framework/vulkan/vkDeviceExtensions.inl b/external/vulkancts/framework/vulkan/vkDeviceExtensions.inl
index 95540d6..beb4f8d 100644
--- a/external/vulkancts/framework/vulkan/vkDeviceExtensions.inl
+++ b/external/vulkancts/framework/vulkan/vkDeviceExtensions.inl
@@ -52,5 +52,6 @@
 	"VK_KHR_shader_clock",
 	"VK_KHR_spirv_1_4",
 	"VK_KHR_shader_subgroup_extended_types",
+	"VK_KHR_separate_depth_stencil_layouts",
 };
 
diff --git a/external/vulkancts/framework/vulkan/vkDeviceFeatures.inl b/external/vulkancts/framework/vulkan/vkDeviceFeatures.inl
index 00161a8..acf163f 100644
--- a/external/vulkancts/framework/vulkan/vkDeviceFeatures.inl
+++ b/external/vulkancts/framework/vulkan/vkDeviceFeatures.inl
@@ -35,6 +35,7 @@
 #define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"
 #define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"
 #define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout"
+#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"
 #define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"
 #define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"
 #define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"
@@ -55,36 +56,37 @@
 #define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
 
 
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 48); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 47); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 46); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 45); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0, 44); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 43); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 42); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 41); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 40); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 39); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 38); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 37); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 36); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 35); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 34); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 33); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 32); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 31); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 30); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 29); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 28); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 27); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 26); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 25); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 24); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION, 23); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 22); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 21); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, 20); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION, 19); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 49); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 48); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 47); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 46); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0, 45); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 44); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 43); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 42); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 41); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 40); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 39); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 38); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 37); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 36); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 35); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 34); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 33); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 32); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 31); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 30); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 29); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 28); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 27); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 26); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 25); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION, 24); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 23); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 22); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, 21); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION, 20); }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION, 19); }
 template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION, 18); }
 template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderClockFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, VK_KHR_SHADER_CLOCK_EXTENSION_NAME, VK_KHR_SHADER_CLOCK_SPEC_VERSION, 17); }
 template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION, 16); }
@@ -137,6 +139,7 @@
 	{ createFeatureStructWrapper<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION },
 	{ createFeatureStructWrapper<VkPhysicalDeviceSamplerYcbcrConversionFeatures>, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION },
 	{ createFeatureStructWrapper<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT>, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION },
+	{ createFeatureStructWrapper<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION },
 	{ createFeatureStructWrapper<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION },
 	{ createFeatureStructWrapper<VkPhysicalDeviceShaderClockFeaturesKHR>, VK_KHR_SHADER_CLOCK_EXTENSION_NAME, VK_KHR_SHADER_CLOCK_SPEC_VERSION },
 	{ createFeatureStructWrapper<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION },
diff --git a/external/vulkancts/framework/vulkan/vkDeviceFeaturesForContextDecl.inl b/external/vulkancts/framework/vulkan/vkDeviceFeaturesForContextDecl.inl
index a75d92d..4fcb921 100644
--- a/external/vulkancts/framework/vulkan/vkDeviceFeaturesForContextDecl.inl
+++ b/external/vulkancts/framework/vulkan/vkDeviceFeaturesForContextDecl.inl
@@ -31,6 +31,7 @@
 const vk::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV&			getRepresentativeFragmentTestFeatures		(void) const;
 const vk::VkPhysicalDeviceSamplerYcbcrConversionFeatures&				getSamplerYcbcrConversionFeatures			(void) const;
 const vk::VkPhysicalDeviceScalarBlockLayoutFeaturesEXT&					getScalarBlockLayoutFeatures				(void) const;
+const vk::VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR&		getSeparateDepthStencilLayoutsFeatures		(void) const;
 const vk::VkPhysicalDeviceShaderAtomicInt64FeaturesKHR&					getShaderAtomicInt64Features				(void) const;
 const vk::VkPhysicalDeviceShaderClockFeaturesKHR&						getShaderClockFeatures						(void) const;
 const vk::VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT&	getShaderDemoteToHelperInvocationFeatures	(void) const;
diff --git a/external/vulkancts/framework/vulkan/vkDeviceFeaturesForContextDefs.inl b/external/vulkancts/framework/vulkan/vkDeviceFeaturesForContextDefs.inl
index 2d07873..d2c30e1 100644
--- a/external/vulkancts/framework/vulkan/vkDeviceFeaturesForContextDefs.inl
+++ b/external/vulkancts/framework/vulkan/vkDeviceFeaturesForContextDefs.inl
@@ -31,6 +31,7 @@
 const vk::VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV&			Context::getRepresentativeFragmentTestFeatures			(void) const { return m_device->getRepresentativeFragmentTestFeatures();		}
 const vk::VkPhysicalDeviceSamplerYcbcrConversionFeatures&				Context::getSamplerYcbcrConversionFeatures				(void) const { return m_device->getSamplerYcbcrConversionFeatures();			}
 const vk::VkPhysicalDeviceScalarBlockLayoutFeaturesEXT&					Context::getScalarBlockLayoutFeatures					(void) const { return m_device->getScalarBlockLayoutFeatures();					}
+const vk::VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR&		Context::getSeparateDepthStencilLayoutsFeatures			(void) const { return m_device->getSeparateDepthStencilLayoutsFeatures();		}
 const vk::VkPhysicalDeviceShaderAtomicInt64FeaturesKHR&					Context::getShaderAtomicInt64Features					(void) const { return m_device->getShaderAtomicInt64Features();					}
 const vk::VkPhysicalDeviceShaderClockFeaturesKHR&						Context::getShaderClockFeatures							(void) const { return m_device->getShaderClockFeatures();						}
 const vk::VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT&	Context::getShaderDemoteToHelperInvocationFeatures		(void) const { return m_device->getShaderDemoteToHelperInvocationFeatures();	}
diff --git a/external/vulkancts/framework/vulkan/vkDeviceFeaturesForDefaultDeviceDefs.inl b/external/vulkancts/framework/vulkan/vkDeviceFeaturesForDefaultDeviceDefs.inl
index 52ad7da..ea0e973 100644
--- a/external/vulkancts/framework/vulkan/vkDeviceFeaturesForDefaultDeviceDefs.inl
+++ b/external/vulkancts/framework/vulkan/vkDeviceFeaturesForDefaultDeviceDefs.inl
@@ -31,6 +31,7 @@
 const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV&			getRepresentativeFragmentTestFeatures		(void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>();			}
 const VkPhysicalDeviceSamplerYcbcrConversionFeatures&				getSamplerYcbcrConversionFeatures			(void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceSamplerYcbcrConversionFeatures>();				}
 const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT&					getScalarBlockLayoutFeatures				(void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT>();					}
+const VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR&		getSeparateDepthStencilLayoutsFeatures		(void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>();		}
 const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR&					getShaderAtomicInt64Features				(void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>();					}
 const VkPhysicalDeviceShaderClockFeaturesKHR&						getShaderClockFeatures						(void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderClockFeaturesKHR>();						}
 const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT&	getShaderDemoteToHelperInvocationFeatures	(void) const { return m_deviceFeatures.getFeatureType<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>();		}
diff --git a/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl b/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl
index 5221da0..46d441b 100644
--- a/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl
+++ b/external/vulkancts/framework/vulkan/vkGetStructureTypeImpl.inl
@@ -851,6 +851,21 @@
 	return VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR;
 }
 
+template<> VkStructureType getStructureType<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR> (void)
+{
+	return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR;
+}
+
+template<> VkStructureType getStructureType<VkAttachmentReferenceStencilLayoutKHR> (void)
+{
+	return VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR;
+}
+
+template<> VkStructureType getStructureType<VkAttachmentDescriptionStencilLayoutKHR> (void)
+{
+	return VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR;
+}
+
 template<> VkStructureType getStructureType<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR> (void)
 {
 	return VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR;
diff --git a/external/vulkancts/framework/vulkan/vkStrUtil.inl b/external/vulkancts/framework/vulkan/vkStrUtil.inl
index 8586a53..a60d40e 100644
--- a/external/vulkancts/framework/vulkan/vkStrUtil.inl
+++ b/external/vulkancts/framework/vulkan/vkStrUtil.inl
@@ -630,6 +630,9 @@
 std::ostream&	operator<<	(std::ostream& s, const VkSemaphoreSignalInfoKHR& value);
 std::ostream&	operator<<	(std::ostream& s, const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& value);
 std::ostream&	operator<<	(std::ostream& s, const VkSurfaceProtectedCapabilitiesKHR& value);
+std::ostream&	operator<<	(std::ostream& s, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR& value);
+std::ostream&	operator<<	(std::ostream& s, const VkAttachmentReferenceStencilLayoutKHR& value);
+std::ostream&	operator<<	(std::ostream& s, const VkAttachmentDescriptionStencilLayoutKHR& value);
 std::ostream&	operator<<	(std::ostream& s, const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& value);
 std::ostream&	operator<<	(std::ostream& s, const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value);
 std::ostream&	operator<<	(std::ostream& s, const VkPipelineInfoKHR& value);
diff --git a/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl b/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl
index b11daf5..10ed741 100644
--- a/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl
+++ b/external/vulkancts/framework/vulkan/vkStrUtilImpl.inl
@@ -470,6 +470,9 @@
 		case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:								return "VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT";
 		case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:								return "VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR";
 		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:	return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV";
+		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR:		return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR";
+		case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR:							return "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR";
+		case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR:						return "VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR";
 		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:				return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT";
 		case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT:									return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT";
 		case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:							return "VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT";
@@ -864,6 +867,10 @@
 		case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:							return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR";
 		case VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV:						return "VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV";
 		case VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT:				return "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT";
+		case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR:					return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR";
+		case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR:					return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR";
+		case VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR:				return "VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR";
+		case VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR:					return "VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR";
 		case VK_IMAGE_LAYOUT_MAX_ENUM:										return "VK_IMAGE_LAYOUT_MAX_ENUM";
 		default:															return DE_NULL;
 	}
@@ -6410,6 +6417,37 @@
 	return s;
 }
 
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR& value)
+{
+	s << "VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = {\n";
+	s << "\tsType = " << value.sType << '\n';
+	s << "\tpNext = " << value.pNext << '\n';
+	s << "\tseparateDepthStencilLayouts = " << value.separateDepthStencilLayouts << '\n';
+	s << '}';
+	return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkAttachmentReferenceStencilLayoutKHR& value)
+{
+	s << "VkAttachmentReferenceStencilLayoutKHR = {\n";
+	s << "\tsType = " << value.sType << '\n';
+	s << "\tpNext = " << value.pNext << '\n';
+	s << "\tstencilLayout = " << value.stencilLayout << '\n';
+	s << '}';
+	return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkAttachmentDescriptionStencilLayoutKHR& value)
+{
+	s << "VkAttachmentDescriptionStencilLayoutKHR = {\n";
+	s << "\tsType = " << value.sType << '\n';
+	s << "\tpNext = " << value.pNext << '\n';
+	s << "\tstencilInitialLayout = " << value.stencilInitialLayout << '\n';
+	s << "\tstencilFinalLayout = " << value.stencilFinalLayout << '\n';
+	s << '}';
+	return s;
+}
+
 std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& value)
 {
 	s << "VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = {\n";
diff --git a/external/vulkancts/framework/vulkan/vkStructTypes.inl b/external/vulkancts/framework/vulkan/vkStructTypes.inl
index d30d6ab..9c2640e 100644
--- a/external/vulkancts/framework/vulkan/vkStructTypes.inl
+++ b/external/vulkancts/framework/vulkan/vkStructTypes.inl
@@ -2368,6 +2368,28 @@
 	VkBool32		supportsProtected;
 };
 
+struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR
+{
+	VkStructureType	sType;
+	void*			pNext;
+	VkBool32		separateDepthStencilLayouts;
+};
+
+struct VkAttachmentReferenceStencilLayoutKHR
+{
+	VkStructureType	sType;
+	void*			pNext;
+	VkImageLayout	stencilLayout;
+};
+
+struct VkAttachmentDescriptionStencilLayoutKHR
+{
+	VkStructureType	sType;
+	void*			pNext;
+	VkImageLayout	stencilInitialLayout;
+	VkImageLayout	stencilFinalLayout;
+};
+
 struct VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR
 {
 	VkStructureType	sType;
diff --git a/external/vulkancts/framework/vulkan/vkVulkan_c.inl b/external/vulkancts/framework/vulkan/vkVulkan_c.inl
index 0ab85dc..ac08b81 100644
--- a/external/vulkancts/framework/vulkan/vkVulkan_c.inl
+++ b/external/vulkancts/framework/vulkan/vkVulkan_c.inl
@@ -508,6 +508,9 @@
     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
     VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = 1000241000,
+    VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001,
+    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
@@ -984,6 +987,10 @@
     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003,
     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = 1000241000,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = 1000241001,
+    VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000241002,
+    VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000241003,
     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
     VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
@@ -6487,6 +6494,30 @@
 
 
 
+#define VK_KHR_separate_depth_stencil_layouts 1
+#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
+#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"
+typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           separateDepthStencilLayouts;
+} VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
+
+typedef struct VkAttachmentReferenceStencilLayoutKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkImageLayout      stencilLayout;
+} VkAttachmentReferenceStencilLayoutKHR;
+
+typedef struct VkAttachmentDescriptionStencilLayoutKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkImageLayout      stencilInitialLayout;
+    VkImageLayout      stencilFinalLayout;
+} VkAttachmentDescriptionStencilLayoutKHR;
+
+
+
 #define VK_KHR_uniform_buffer_standard_layout 1
 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"
diff --git a/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
index 4a7addb..9ad1ddf 100644
--- a/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiCopiesAndBlittingTests.cpp
@@ -170,12 +170,14 @@
 	deUint32		mipLevels;
 	deBool			singleCommand;
 	deUint32		barrierCount;
+	deBool			separateDepthStencilLayouts;
 
 	TestParams (void)
 	{
-		mipLevels		= 1u;
-		singleCommand	= DE_TRUE;
-		barrierCount	= 1u;
+		mipLevels					= 1u;
+		singleCommand				= DE_TRUE;
+		barrierCount				= 1u;
+		separateDepthStencilLayouts	= DE_FALSE;
 	}
 };
 
@@ -504,9 +506,10 @@
 		bufferSize										// VkDeviceSize		size;
 	};
 
-	const VkImageAspectFlags		formatAspect		= getAspectFlags(parms.format);
-	const bool						skipPreImageBarrier	= formatAspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) &&
-														  getAspectFlags(imageAccess.getFormat()) == VK_IMAGE_ASPECT_STENCIL_BIT;
+	const VkImageAspectFlags		formatAspect		= (m_params.separateDepthStencilLayouts) ? getAspectFlags(imageAccess.getFormat()) : getAspectFlags(parms.format);
+	const bool						skipPreImageBarrier	= (m_params.separateDepthStencilLayouts) ? false : ((formatAspect == (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT) &&
+														  getAspectFlags(imageAccess.getFormat()) == VK_IMAGE_ASPECT_STENCIL_BIT));
+
 	const VkImageMemoryBarrier		preImageBarrier		=
 	{
 		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,			// VkStructureType			sType;
@@ -1166,6 +1169,10 @@
 				TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
 		}
 
+		if (m_params.separateDepthStencilLayouts)
+			if (!context.isDeviceFunctionalitySupported("VK_KHR_separate_depth_stencil_layouts"))
+				TCU_THROW(NotSupportedError, "VK_KHR_separate_depth_stencil_layouts is not supported");
+
 		if ((m_params.dst.image.imageType == VK_IMAGE_TYPE_3D && m_params.src.image.imageType == VK_IMAGE_TYPE_2D) ||
 			(m_params.dst.image.imageType == VK_IMAGE_TYPE_2D && m_params.src.image.imageType == VK_IMAGE_TYPE_3D))
 		{
@@ -4962,6 +4969,10 @@
 		params.src.image.tiling				= VK_IMAGE_TILING_OPTIMAL;
 		params.dst.image.tiling				= VK_IMAGE_TILING_OPTIMAL;
 		params.allocationKind				= allocationKind;
+		params.separateDepthStencilLayouts	= DE_FALSE;
+
+		bool hasDepth	= tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order);
+		bool hasStencil	= tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order);
 
 		const VkImageSubresourceLayers		defaultDepthSourceLayer		= { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
 		const VkImageSubresourceLayers		defaultStencilSourceLayer	= { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
@@ -4973,7 +4984,7 @@
 			const VkOffset3D	dstOffset	= {i, defaultSize - i - defaultFourthSize, 0};
 			const VkExtent3D	extent		= {defaultFourthSize, defaultFourthSize, 1};
 
-			if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
+			if (hasDepth)
 			{
 				const VkImageCopy				testCopy	=
 				{
@@ -4987,7 +4998,7 @@
 				copyRegion.imageCopy	= testCopy;
 				params.regions.push_back(copyRegion);
 			}
-			if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
+			if (hasStencil)
 			{
 				const VkImageCopy				testCopy	=
 				{
@@ -5084,6 +5095,9 @@
 		const VkImageSubresourceLayers		defaultDepthSourceLayer		= { VK_IMAGE_ASPECT_DEPTH_BIT, 0u, 0u, 1u };
 		const VkImageSubresourceLayers		defaultStencilSourceLayer	= { VK_IMAGE_ASPECT_STENCIL_BIT, 0u, 0u, 1u };
 
+		bool hasDepth	= tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order);
+		bool hasStencil	= tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order);
+
 		for (deInt32 i = 0; i < defaultFourthSize; i += defaultSixteenthSize)
 		{
 			CopyRegion			copyRegion;
@@ -5091,7 +5105,7 @@
 			const VkOffset3D	dstOffset	= {i, defaultFourthSize - i - defaultSixteenthSize, i};
 			const VkExtent3D	extent		= {defaultSixteenthSize, defaultSixteenthSize, defaultSixteenthSize};
 
-			if (tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order))
+			if (hasDepth)
 			{
 				const VkImageCopy				testCopy	=
 				{
@@ -5105,7 +5119,7 @@
 				copyRegion.imageCopy	= testCopy;
 				params.regions.push_back(copyRegion);
 			}
-			if (tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order))
+			if (hasStencil)
 			{
 				const VkImageCopy				testCopy	=
 				{
@@ -5124,6 +5138,14 @@
 		const std::string testName		= "3d_"+ getFormatCaseName(params.src.image.format) + "_" + getFormatCaseName(params.dst.image.format);
 		const std::string description	= "3D copy from " + getFormatCaseName(params.src.image.format) + " to " + getFormatCaseName(params.dst.image.format);
 		addTestGroup(group, testName, description, addImageToImageAllFormatsDepthStencilFormatsTests, params);
+
+		if (hasDepth && hasStencil)
+		{
+			params.separateDepthStencilLayouts	= DE_TRUE;
+			const std::string testName2		= getFormatCaseName(params.src.image.format) + "_" + getFormatCaseName(params.dst.image.format) + "_separate_layouts";
+			const std::string description2	= "Copy from " + getFormatCaseName(params.src.image.format) + " to " + getFormatCaseName(params.dst.image.format) + " with separate depth/stencil layouts";
+			addTestGroup(group, testName2, description2, addImageToImageAllFormatsDepthStencilFormatsTests, params);
+		}
 	}
 }
 
@@ -7104,6 +7126,7 @@
 		params.dst.image.format				= params.src.image.format;
 		params.dst.image.tiling				= VK_IMAGE_TILING_OPTIMAL;
 		params.allocationKind				= allocationKind;
+		params.separateDepthStencilLayouts	= DE_FALSE;
 
 		bool hasDepth	= tcu::hasDepthComponent(mapVkFormat(params.src.image.format).order);
 		bool hasStencil	= tcu::hasStencilComponent(mapVkFormat(params.src.image.format).order);
@@ -7401,6 +7424,16 @@
 		const std::string description	= "3D blit from " + getFormatCaseName(params.src.image.format) +
 										  " to " + getFormatCaseName(params.dst.image.format);
 		addTestGroup(group, testName, description, addBlittingImageAllFormatsDepthStencilFormatsTests, params);
+
+		if (hasDepth && hasStencil)
+		{
+			params.separateDepthStencilLayouts	= DE_TRUE;
+			const std::string testName2		= getFormatCaseName(params.src.image.format) + "_" +
+											  getFormatCaseName(params.dst.image.format) + "_separate_layouts";
+			const std::string description2	= "Blit from " + getFormatCaseName(params.src.image.format) +
+											  " to " + getFormatCaseName(params.dst.image.format) + " with separate depth/stencil layouts";
+			addTestGroup(group, testName2, description2, addBlittingImageAllFormatsDepthStencilFormatsTests, params);
+		}
 	}
 }
 
diff --git a/external/vulkancts/modules/vulkan/api/vktApiImageClearingTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiImageClearingTests.cpp
index b23b1b3..33bfa6b 100644
--- a/external/vulkancts/modules/vulkan/api/vktApiImageClearingTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiImageClearingTests.cpp
@@ -467,20 +467,28 @@
 	return (std::string("_") + de::toString(extent.width) + std::string("x") + de::toString(extent.height) + (extent.depth != 1 ? (std::string("x") + de::toString(extent.depth)) : ""));
 }
 
+enum SeparateDepthStencilLayoutMode
+{
+	SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE = 0,
+	SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH,
+	SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL,
+};
+
 struct TestParams
 {
-	bool			useSingleMipLevel;	//!< only mip level 0, otherwise up to maxMipLevels
-	VkImageType		imageType;
-	VkFormat		imageFormat;
-	VkImageTiling	imageTiling;
-	VkExtent3D		imageExtent;
-	deUint32        imageLayerCount;
-	LayerRange      imageViewLayerRange;
-	VkClearValue	initValue;
-	VkClearValue	clearValue[2];		//!< the second value is used with more than one mip map
-	LayerRange		clearLayerRange;
-	AllocationKind	allocationKind;
-	bool			isCube;
+	bool							useSingleMipLevel;	//!< only mip level 0, otherwise up to maxMipLevels
+	VkImageType						imageType;
+	VkFormat						imageFormat;
+	VkImageTiling					imageTiling;
+	VkExtent3D						imageExtent;
+	deUint32						imageLayerCount;
+	LayerRange						imageViewLayerRange;
+	VkClearValue					initValue;
+	VkClearValue					clearValue[2];		//!< the second value is used with more than one mip map
+	LayerRange						clearLayerRange;
+	AllocationKind					allocationKind;
+	bool							isCube;
+	SeparateDepthStencilLayoutMode	separateDepthStencilLayoutMode;
 };
 
 class ImageClearingTestInstance : public vkt::TestInstance
@@ -501,7 +509,7 @@
 	void								submitCommandBuffer				(void) const;
 	void								beginRenderPass					(VkSubpassContents content, VkClearValue clearValue) const;
 
-	void								pipelineImageBarrier			(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout) const;
+	void								pipelineImageBarrier			(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask = 0u) const;
 	de::MovePtr<TextureLevelPyramid>	readImage						(VkImageAspectFlags aspectMask, deUint32 baseLayer) const;
 	tcu::TestStatus						verifyResultImage				(const std::string& successMessage, const UVec4& clearCoords = UVec4()) const;
 
@@ -585,6 +593,9 @@
 {
 	if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
 		context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
+
+	if (m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
+		context.requireDeviceFunctionality("VK_KHR_separate_depth_stencil_layouts");
 }
 
 ImageClearingTestInstance::ViewType ImageClearingTestInstance::getViewType (deUint32 imageLayerCount) const
@@ -770,82 +781,182 @@
 
 Move<VkRenderPass> ImageClearingTestInstance::createRenderPass (VkFormat format) const
 {
-	VkImageLayout							imageLayout;
-
-	if (isDepthStencilFormat(format))
-		imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
-	else
-		imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-
-	const VkAttachmentDescription			attachmentDesc			=
+	if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
 	{
-		0u,													// VkAttachmentDescriptionFlags		flags;
-		format,												// VkFormat							format;
-		VK_SAMPLE_COUNT_1_BIT,								// VkSampleCountFlagBits			samples;
-		VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				loadOp;
-		VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp				storeOp;
-		VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				stencilLoadOp;
-		VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp				stencilStoreOp;
-		imageLayout,										// VkImageLayout					initialLayout;
-		imageLayout,										// VkImageLayout					finalLayout;
-	};
+		VkImageLayout							imageLayout;
 
-	const VkAttachmentDescription			attachments[1]			=
-	{
-		attachmentDesc
-	};
+		if (isDepthStencilFormat(format))
+			imageLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+		else
+			imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
-	const VkAttachmentReference				attachmentRef			=
-	{
-		0u,													// deUint32							attachment;
-		imageLayout,										// VkImageLayout					layout;
-	};
-
-	const VkAttachmentReference*			pColorAttachments		= DE_NULL;
-	const VkAttachmentReference*			pDepthStencilAttachment	= DE_NULL;
-	deUint32								colorAttachmentCount	= 1;
-
-	if (isDepthStencilFormat(format))
-	{
-		colorAttachmentCount	= 0;
-		pDepthStencilAttachment	= &attachmentRef;
-	}
-	else
-	{
-		colorAttachmentCount	= 1;
-		pColorAttachments		= &attachmentRef;
-	}
-
-	const VkSubpassDescription				subpassDesc[1]			=
-	{
+		const VkAttachmentDescription			attachmentDesc			=
 		{
+			0u,													// VkAttachmentDescriptionFlags		flags;
+			format,												// VkFormat							format;
+			VK_SAMPLE_COUNT_1_BIT,								// VkSampleCountFlagBits			samples;
+			VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				loadOp;
+			VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp				storeOp;
+			VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				stencilLoadOp;
+			VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp				stencilStoreOp;
+			imageLayout,										// VkImageLayout					initialLayout;
+			imageLayout,										// VkImageLayout					finalLayout;
+		};
+
+		const VkAttachmentDescription			attachments[1]			=
+		{
+			attachmentDesc
+		};
+
+		const VkAttachmentReference				attachmentRef			=
+		{
+			0u,													// deUint32							attachment;
+			imageLayout,										// VkImageLayout					layout;
+		};
+
+		const VkAttachmentReference*			pColorAttachments		= DE_NULL;
+		const VkAttachmentReference*			pDepthStencilAttachment	= DE_NULL;
+		deUint32								colorAttachmentCount	= 1;
+
+		if (isDepthStencilFormat(format))
+		{
+			colorAttachmentCount	= 0;
+			pDepthStencilAttachment	= &attachmentRef;
+		}
+		else
+		{
+			colorAttachmentCount	= 1;
+			pColorAttachments		= &attachmentRef;
+		}
+
+		const VkSubpassDescription				subpassDesc[1]			=
+		{
+			{
+				0u,												// VkSubpassDescriptionFlags		flags;
+				VK_PIPELINE_BIND_POINT_GRAPHICS,				// VkPipelineBindPoint				pipelineBindPoint;
+				0u,												// deUint32							inputAttachmentCount;
+				DE_NULL,										// const VkAttachmentReference*		pInputAttachments;
+				colorAttachmentCount,							// deUint32							colorAttachmentCount;
+				pColorAttachments,								// const VkAttachmentReference*		pColorAttachments;
+				DE_NULL,										// const VkAttachmentReference*		pResolveAttachments;
+				pDepthStencilAttachment,						// const VkAttachmentReference*		pDepthStencilAttachment;
+				0u,												// deUint32							preserveAttachmentCount;
+				DE_NULL,										// const VkAttachmentReference*		pPreserveAttachments;
+			}
+		};
+
+		const VkRenderPassCreateInfo			renderPassCreateInfo	=
+		{
+			VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,			// VkStructureType					sType;
+			DE_NULL,											// const void*						pNext;
+			0u,													// VkRenderPassCreateFlags			flags;
+			1u,													// deUint32							attachmentCount;
+			attachments,										// const VkAttachmentDescription*	pAttachments;
+			1u,													// deUint32							subpassCount;
+			subpassDesc,										// const VkSubpassDescription*		pSubpasses;
+			0u,													// deUint32							dependencyCount;
+			DE_NULL,											// const VkSubpassDependency*		pDependencies;
+		};
+
+		return vk::createRenderPass(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
+	}
+	else
+	{
+		VkImageLayout								initialLayout			= VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+		VkImageLayout								finalLayout				= VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+		VkAttachmentDescriptionStencilLayoutKHR		stencilLayouts			=
+		{
+			VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
+			DE_NULL,
+			VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+			VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+		};
+
+		VkImageLayout								imageLayout;
+		VkAttachmentReferenceStencilLayoutKHR		stencilLayoutRef		=
+		{
+			VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
+			DE_NULL,
+			VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+		};
+
+		if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
+		{
+			initialLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
+			finalLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
+			stencilLayouts.stencilInitialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+			stencilLayouts.stencilFinalLayout = VK_IMAGE_LAYOUT_GENERAL;
+			imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
+			stencilLayoutRef.stencilLayout = VK_IMAGE_LAYOUT_GENERAL;
+		}
+		else
+		{
+			initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+			finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+			stencilLayouts.stencilInitialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+			stencilLayouts.stencilFinalLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
+			imageLayout = VK_IMAGE_LAYOUT_GENERAL;
+			stencilLayoutRef.stencilLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
+		}
+
+		const VkAttachmentDescription2KHR			attachmentDesc			=
+		{
+			VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR,		// VkStructureType					sType;
+			&stencilLayouts,									// const void*						pNext;
+			0u,													// VkAttachmentDescriptionFlags		flags;
+			format,												// VkFormat							format;
+			VK_SAMPLE_COUNT_1_BIT,								// VkSampleCountFlagBits			samples;
+			VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				loadOp;
+			VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp				storeOp;
+			VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				stencilLoadOp;
+			VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp				stencilStoreOp;
+			initialLayout,										// VkImageLayout					initialLayout;
+			finalLayout,										// VkImageLayout					finalLayout;
+		};
+
+		const VkAttachmentReference2KHR				attachmentRef			=
+		{
+			VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR,		// VkStructureType		sType;
+			&stencilLayoutRef,									// const void*			pNext;
+			0u,													// deUint32				attachment;
+			imageLayout,										// VkImageLayout		layout;
+			0u,													// VkImageAspectFlags	aspectMask;
+		};
+
+		const VkSubpassDescription2KHR				subpassDesc			=
+		{
+			VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR,	// VkStructureType					sType;
+			DE_NULL,										// const void*						pNext;
 			0u,												// VkSubpassDescriptionFlags		flags;
 			VK_PIPELINE_BIND_POINT_GRAPHICS,				// VkPipelineBindPoint				pipelineBindPoint;
+			0u,												// deUint32							viewMask;
 			0u,												// deUint32							inputAttachmentCount;
-			DE_NULL,										// const VkAttachmentReference*		pInputAttachments;
-			colorAttachmentCount,							// deUint32							colorAttachmentCount;
-			pColorAttachments,								// const VkAttachmentReference*		pColorAttachments;
-			DE_NULL,										// const VkAttachmentReference*		pResolveAttachments;
-			pDepthStencilAttachment,						// const VkAttachmentReference*		pDepthStencilAttachment;
+			DE_NULL,										// const VkAttachmentReference2KHR*	pInputAttachments;
+			0u,												// deUint32							colorAttachmentCount;
+			DE_NULL,										// const VkAttachmentReference2KHR*	pColorAttachments;
+			DE_NULL,										// const VkAttachmentReference2KHR*	pResolveAttachments;
+			&attachmentRef,									// const VkAttachmentReference2KHR*	pDepthStencilAttachment;
 			0u,												// deUint32							preserveAttachmentCount;
-			DE_NULL,										// const VkAttachmentReference*		pPreserveAttachments;
-		}
-	};
+			DE_NULL,										// const VkAttachmentReference2KHR*	pPreserveAttachments;
+		};
 
-	const VkRenderPassCreateInfo			renderPassCreateInfo	=
-	{
-		VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,			// VkStructureType					sType;
-		DE_NULL,											// const void*						pNext;
-		0u,													// VkRenderPassCreateFlags			flags;
-		1u,													// deUint32							attachmentCount;
-		attachments,										// const VkAttachmentDescription*	pAttachments;
-		1u,													// deUint32							subpassCount;
-		subpassDesc,										// const VkSubpassDescription*		pSubpasses;
-		0u,													// deUint32							dependencyCount;
-		DE_NULL,											// const VkSubpassDependency*		pDependencies;
-	};
+		const VkRenderPassCreateInfo2KHR			renderPassCreateInfo	=
+		{
+			VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR,	// VkStructureType					sType;
+			DE_NULL,											// const void*						pNext;
+			0u,													// VkRenderPassCreateFlags			flags;
+			1u,													// deUint32							attachmentCount;
+			&attachmentDesc,									// const VkAttachmentDescription*	pAttachments;
+			1u,													// deUint32							subpassCount;
+			&subpassDesc,										// const VkSubpassDescription*		pSubpasses;
+			0u,													// deUint32							dependencyCount;
+			DE_NULL,											// const VkSubpassDependency*		pDependencies;
+			0u,													// deUint32							correlatedViewMaskCount;
+			DE_NULL,											// const deUint32*					pCorrelatedViewMasks;
+		};
 
-	return vk::createRenderPass(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
+		return vk::createRenderPass2KHR(m_vkd, m_device, &renderPassCreateInfo, DE_NULL);
+	}
 }
 
 Move<VkFramebuffer> ImageClearingTestInstance::createFrameBuffer (VkImageView imageView, VkRenderPass renderPass, deUint32 imageWidth, deUint32 imageHeight, deUint32 imageLayersCount) const
@@ -886,8 +997,11 @@
 	submitCommandsAndWait(m_vkd, m_device, m_queue, m_commandBuffer.get());
 }
 
-void ImageClearingTestInstance::pipelineImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout) const
+void ImageClearingTestInstance::pipelineImageBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask, VkImageLayout oldLayout, VkImageLayout newLayout, VkImageAspectFlags aspectMask) const
 {
+	if (!aspectMask || m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
+		aspectMask = m_imageAspectFlags;
+
 	const VkImageMemoryBarrier		imageBarrier	=
 	{
 		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,		// VkStructureType			sType;
@@ -900,7 +1014,7 @@
 		VK_QUEUE_FAMILY_IGNORED,					// deUint32					destQueueFamilyIndex;
 		*m_image,									// VkImage					image;
 		{
-			m_imageAspectFlags,							// VkImageAspectFlags	aspectMask;
+			aspectMask,									// VkImageAspectFlags	aspectMask;
 			0u,											// deUint32				baseMipLevel;
 			VK_REMAINING_MIP_LEVELS,					// deUint32				levelCount;
 			0u,											// deUint32				baseArrayLayer;
@@ -992,7 +1106,8 @@
 						 VK_ACCESS_TRANSFER_WRITE_BIT,
 						 VK_ACCESS_TRANSFER_READ_BIT,
 						 VK_IMAGE_LAYOUT_GENERAL,
-						 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
+						 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+						 aspectMask);
 
 	m_vkd.cmdCopyImageToBuffer(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *buffer, static_cast<deUint32>(copyRegions.size()), &copyRegions[0]);
 	m_vkd.cmdPipelineBarrier(*m_commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &bufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
@@ -1002,7 +1117,8 @@
 						 VK_ACCESS_TRANSFER_READ_BIT,
 						 VK_ACCESS_TRANSFER_READ_BIT,
 						 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-						 VK_IMAGE_LAYOUT_GENERAL);
+						 VK_IMAGE_LAYOUT_GENERAL,
+						 aspectMask);
 
 	endCommandBuffer();
 	submitCommandBuffer();
@@ -1030,7 +1146,7 @@
 {
 	DE_ASSERT((clearCoords == UVec4()) || m_params.imageExtent.depth == 1u);
 
-	if (getIsDepthFormat(m_params.imageFormat))
+	if (getIsDepthFormat(m_params.imageFormat) && m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
 	{
 		DE_ASSERT(m_imageMipLevels == 1u);
 
@@ -1059,7 +1175,7 @@
 		}
 	}
 
-	if (getIsStencilFormat(m_params.imageFormat))
+	if (getIsStencilFormat(m_params.imageFormat) && m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
 	{
 		DE_ASSERT(m_imageMipLevels == 1u);
 
@@ -1228,8 +1344,23 @@
 
 TestStatus ClearDepthStencilImageTestInstance::iterate (void)
 {
-	const VkImageSubresourceRange subresourceRange	= makeImageSubresourceRange(m_imageAspectFlags, 0u, 1u,							m_params.clearLayerRange.baseArrayLayer, m_twoStep ? 1 : m_params.clearLayerRange.layerCount);
-	const VkImageSubresourceRange steptwoRange		= makeImageSubresourceRange(m_imageAspectFlags, 0u, VK_REMAINING_MIP_LEVELS,	m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS);
+	VkImageLayout		layout	= (m_isAttachmentFormat
+									?	VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
+									:	VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+	VkImageAspectFlags	aspectMask	= m_imageAspectFlags;
+	if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
+	{
+		layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
+		aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+	}
+	else if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
+	{
+		layout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
+		aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+	}
+
+	const VkImageSubresourceRange subresourceRange	= makeImageSubresourceRange(aspectMask, 0u, 1u,							m_params.clearLayerRange.baseArrayLayer, m_twoStep ? 1 : m_params.clearLayerRange.layerCount);
+	const VkImageSubresourceRange steptwoRange		= makeImageSubresourceRange(aspectMask, 0u, VK_REMAINING_MIP_LEVELS,	m_params.clearLayerRange.baseArrayLayer, VK_REMAINING_ARRAY_LAYERS);
 
 	beginCommandBuffer(0);
 
@@ -1240,9 +1371,8 @@
 							?	VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
 							:	VK_ACCESS_TRANSFER_WRITE_BIT),				// VkAccessFlags			dstAccessMask
 						 VK_IMAGE_LAYOUT_UNDEFINED,							// VkImageLayout			oldLayout;
-						 (m_isAttachmentFormat
-							?	VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
-							:	VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL));		// VkImageLayout			newLayout;
+						 layout,											// VkImageLayout			newLayout;
+						 aspectMask);										// VkImageAspectFlags		aspectMask;
 
 	if (m_isAttachmentFormat)
 	{
@@ -1253,8 +1383,9 @@
 							 VK_PIPELINE_STAGE_TRANSFER_BIT,						// VkPipelineStageFlags		dstStageMask
 							 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,			// VkAccessFlags			srcAccessMask
 							 VK_ACCESS_TRANSFER_WRITE_BIT,							// VkAccessFlags			dstAccessMask
-							 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,		// VkImageLayout			oldLayout;
-							 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);					// VkImageLayout			newLayout;
+							 layout,												// VkImageLayout			oldLayout;
+							 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,					// VkImageLayout			newLayout;
+							 aspectMask);											// VkImageAspectFlags		aspectMask;
 	}
 
 	m_vkd.cmdClearDepthStencilImage(*m_commandBuffer, *m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &m_params.clearValue[0].depthStencil, 1, &subresourceRange);
@@ -1267,7 +1398,8 @@
 						 VK_ACCESS_TRANSFER_WRITE_BIT,						// VkAccessFlags			srcAccessMask
 						 VK_ACCESS_TRANSFER_READ_BIT,						// VkAccessFlags			dstAccessMask
 						 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,				// VkImageLayout			oldLayout;
-						 VK_IMAGE_LAYOUT_GENERAL);							// VkImageLayout			newLayout;
+						 VK_IMAGE_LAYOUT_GENERAL,							// VkImageLayout			newLayout;
+						 aspectMask);										// VkImageAspectFlags		aspectMask;
 
 	endCommandBuffer();
 	submitCommandBuffer();
@@ -1294,9 +1426,25 @@
 
 	TestStatus iterate (void)
 	{
+		const bool			isDepthStencil		= isDepthStencilFormat(m_params.imageFormat);
+		const VkAccessFlags	accessMask			= (isDepthStencil ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT     : VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
+		VkImageLayout		attachmentLayout	= (isDepthStencil ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+		VkImageAspectFlags	aspectMask			= m_imageAspectFlags;
+
+		if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH)
+		{
+			attachmentLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
+			aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+		}
+		else if (m_params.separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL)
+		{
+			attachmentLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
+			aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+		}
+
 		const VkClearAttachment clearAttachment =
 		{
-			m_imageAspectFlags,					// VkImageAspectFlags	aspectMask;
+			aspectMask,							// VkImageAspectFlags	aspectMask;
 			0u,									// deUint32				colorAttachment;
 			m_params.clearValue[0]				// VkClearValue			clearValue;
 		};
@@ -1352,10 +1500,6 @@
 			clearRects.push_back(rects[1]);
 		}
 
-		const bool			isDepthStencil		= isDepthStencilFormat(m_params.imageFormat);
-		const VkAccessFlags	accessMask			= (isDepthStencil ? VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT     : VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
-		const VkImageLayout	attachmentLayout	= (isDepthStencil ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
-
 		beginCommandBuffer(0);
 
 		pipelineImageBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,				// VkPipelineStageFlags		srcStageMask
@@ -1363,7 +1507,8 @@
 							 0,												// VkAccessFlags			srcAccessMask
 							 accessMask,									// VkAccessFlags			dstAccessMask
 							 VK_IMAGE_LAYOUT_UNDEFINED,						// VkImageLayout			oldLayout;
-							 attachmentLayout);								// VkImageLayout			newLayout;
+							 attachmentLayout,								// VkImageLayout			newLayout;
+							 aspectMask);									// VkImageAspectFlags		aspectMask;
 
 		beginRenderPass(VK_SUBPASS_CONTENTS_INLINE, m_params.initValue);
 		m_vkd.cmdClearAttachments(*m_commandBuffer, 1, &clearAttachment, static_cast<deUint32>(clearRects.size()), &clearRects[0]);
@@ -1374,7 +1519,8 @@
 							 accessMask,									// VkAccessFlags			srcAccessMask
 							 VK_ACCESS_TRANSFER_READ_BIT,					// VkAccessFlags			dstAccessMask
 							 attachmentLayout,								// VkImageLayout			oldLayout;
-							 VK_IMAGE_LAYOUT_GENERAL);						// VkImageLayout			newLayout;
+							 VK_IMAGE_LAYOUT_GENERAL,						// VkImageLayout			newLayout;
+							 aspectMask);									// VkImageAspectFlags		aspectMask;
 
 		endCommandBuffer();
 		submitCommandBuffer();
@@ -1790,24 +1936,25 @@
 							const std::string	testCaseName	= getFormatCaseName(format) + dimensionsString;
 							const TestParams	testParams		=
 							{
-								false,																// bool				useSingleMipLevel;
-								imageTypesToTest[imageTypeIndex],									// VkImageType		imageType;
-								format,																// VkFormat			imageFormat;
-								imageTilingsToTest[imageTilingIndex],								// VkImageTiling	imageTiling;
-								dimensions,															// VkExtent3D		imageExtent;
-								imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,		// deUint32         imageLayerCount;
+								false,																// bool								useSingleMipLevel;
+								imageTypesToTest[imageTypeIndex],									// VkImageType						imageType;
+								format,																// VkFormat							imageFormat;
+								imageTilingsToTest[imageTilingIndex],								// VkImageTiling					imageTiling;
+								dimensions,															// VkExtent3D						imageExtent;
+								imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,		// deUint32							imageLayerCount;
 								{
 									0u,
 									imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
-								},																	// LayerRange		imageViewLayerRange;
-								makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f),				// VkClearValue		initValue;
+								},																	// LayerRange						imageViewLayerRange;
+								makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f),				// VkClearValue						initValue;
 								{
-									makeClearColorValue(format, 0.1f, 0.5f, 0.3f, 0.9f),				// VkClearValue		clearValue[0];
-									makeClearColorValue(format, 0.3f, 0.6f, 0.2f, 0.7f),				// VkClearValue		clearValue[1];
+									makeClearColorValue(format, 0.1f, 0.5f, 0.3f, 0.9f),				// VkClearValue						clearValue[0];
+									makeClearColorValue(format, 0.3f, 0.6f, 0.2f, 0.7f),				// VkClearValue						clearValue[1];
 								},
-								imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,		// LayerRange       clearLayerRange;
-								allocationKind,														// AllocationKind	allocationKind;
-								false																// bool				isCube;
+								imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,		// LayerRange						clearLayerRange;
+								allocationKind,														// AllocationKind					allocationKind;
+								false,																// bool								isCube;
+								SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE,							// SeparateDepthStencilLayoutMode	separateDepthStencilLayoutMode;
 							};
 							if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
 								imageLayersGroup->addChild(new InstanceFactory1<ClearColorImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Image", testParams));
@@ -1844,34 +1991,46 @@
 
 				for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
 				{
-					const VkFormat		format			= depthStencilImageFormatsToTest[imageFormatIndex];
-					const std::string	testCaseName	= getFormatCaseName(format) + dimensionsString;
-					const TestParams	testParams		=
-					{
-						true,																// bool				useSingleMipLevel;
-						VK_IMAGE_TYPE_2D,													// VkImageType		imageType;
-						format,																// VkFormat			format;
-						VK_IMAGE_TILING_OPTIMAL,											// VkImageTiling	tiling;
-						dimensions,															// VkExtent3D		extent;
-						imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,		// deUint32         imageLayerCount;
-						{
-							0u,
-							imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
-						},																	// LayerRange		imageViewLayerRange;
-						makeClearValueDepthStencil(0.5f, 0x03),								// VkClearValue		initValue
-						{
-							makeClearValueDepthStencil(0.1f, 0x06),								// VkClearValue		clearValue[0];
-							makeClearValueDepthStencil(0.3f, 0x04),								// VkClearValue		clearValue[1];
-						},
-						imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,		// LayerRange       clearLayerRange;
-						allocationKind,														// AllocationKind	allocationKind;
-						false																// bool				isCube;
-					};
+					const VkFormat	format						= depthStencilImageFormatsToTest[imageFormatIndex];
+					const bool		hasDepth					= tcu::hasDepthComponent(mapVkFormat(format).order);
+					const bool		hasStencil					= tcu::hasStencilComponent(mapVkFormat(format).order);
+					const int		separateLayoutsLoopCount	= (hasDepth && hasStencil) ? 3 : 1;
 
-					if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
-						imageLayersGroup->addChild(new InstanceFactory1<ClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Image", testParams));
-					else
-						imageLayersGroup->addChild(new InstanceFactory1<TwoStepClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Image", testParams));
+					for (int separateDepthStencilLayoutMode = 0; separateDepthStencilLayoutMode < separateLayoutsLoopCount; ++separateDepthStencilLayoutMode)
+					{
+						const std::string	testCaseName	= getFormatCaseName(format) +
+							((separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH) ? "_separate_layouts_depth" :
+							 (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL) ? "_separate_layouts_stencil" :
+							 "")
+							+ dimensionsString;
+						const TestParams	testParams		=
+						{
+							true,																// bool								useSingleMipLevel;
+							VK_IMAGE_TYPE_2D,													// VkImageType						imageType;
+							format,																// VkFormat							format;
+							VK_IMAGE_TILING_OPTIMAL,											// VkImageTiling					tiling;
+							dimensions,															// VkExtent3D						extent;
+							imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,		// deUint32							imageLayerCount;
+							{
+								0u,
+								imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount
+							},																	// LayerRange						imageViewLayerRange;
+							makeClearValueDepthStencil(0.5f, 0x03),								// VkClearValue						initValue
+							{
+								makeClearValueDepthStencil(0.1f, 0x06),								// VkClearValue						clearValue[0];
+								makeClearValueDepthStencil(0.3f, 0x04),								// VkClearValue						clearValue[1];
+							},
+							imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,		// LayerRange						clearLayerRange;
+							allocationKind,														// AllocationKind					allocationKind;
+							false,																// bool								isCube;
+							SeparateDepthStencilLayoutMode(separateDepthStencilLayoutMode),		// SeparateDepthStencilLayoutMode	separateDepthStencilLayoutMode;
+						};
+
+						if (!imageLayerParamsToTest[imageLayerParamsIndex].twoStep)
+							imageLayersGroup->addChild(new InstanceFactory1<ClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Image", testParams));
+						else
+							imageLayersGroup->addChild(new InstanceFactory1<TwoStepClearDepthStencilImageTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Image", testParams));
+					}
 				}
 			}
 			depthStencilImageClearTests->addChild(imageLayersGroup.release());
@@ -1905,21 +2064,22 @@
 						const std::string	testCaseName	= getFormatCaseName(format) + dimensionsString;
 						const TestParams	testParams		=
 						{
-							true,															// bool				useSingleMipLevel;
-							VK_IMAGE_TYPE_2D,												// VkImageType		imageType;
-							format,															// VkFormat			format;
-							VK_IMAGE_TILING_OPTIMAL,										// VkImageTiling	tiling;
-							dimensions,														// VkExtent3D		extent;
-							imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,	// deUint32         imageLayerCount;
-							imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange,	// LayerRange		imageViewLayerRange;
-							makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f),			// VkClearValue		initValue
+							true,															// bool								useSingleMipLevel;
+							VK_IMAGE_TYPE_2D,												// VkImageType						imageType;
+							format,															// VkFormat							format;
+							VK_IMAGE_TILING_OPTIMAL,										// VkImageTiling					tiling;
+							dimensions,														// VkExtent3D						extent;
+							imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,	// deUint32							imageLayerCount;
+							imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange,	// LayerRange						imageViewLayerRange;
+							makeClearColorValue(format, 0.2f, 0.1f, 0.7f, 0.8f),			// VkClearValue						initValue
 							{
-								makeClearColorValue(format, 0.1f, 0.5f, 0.3f, 0.9f),			// VkClearValue		clearValue[0];
-								makeClearColorValue(format, 0.3f, 0.6f, 0.2f, 0.7f),			// VkClearValue		clearValue[1];
+								makeClearColorValue(format, 0.1f, 0.5f, 0.3f, 0.9f),			// VkClearValue						clearValue[0];
+								makeClearColorValue(format, 0.3f, 0.6f, 0.2f, 0.7f),			// VkClearValue						clearValue[1];
 							},
-							imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,	// LayerRange       clearLayerRange;
-							allocationKind,													// AllocationKind	allocationKind;
-							imageLayerParamsToTest[imageLayerParamsIndex].isCube			// bool				isCube;
+							imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,	// LayerRange						clearLayerRange;
+							allocationKind,													// AllocationKind					allocationKind;
+							imageLayerParamsToTest[imageLayerParamsIndex].isCube,			// bool								isCube;
+							SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE,						// SeparateDepthStencilLayoutMode	separateDepthStencilLayoutMode;
 						};
 						colorAttachmentClearLayersGroup->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Color Attachment", testParams));
 						if (dimensions.width > 1)
@@ -1956,29 +2116,42 @@
 
 					for (size_t imageFormatIndex = 0; imageFormatIndex < numOfDepthStencilImageFormatsToTest; ++imageFormatIndex)
 					{
-						const VkFormat		format			= depthStencilImageFormatsToTest[imageFormatIndex];
-						const std::string	testCaseName	= getFormatCaseName(format) + dimensionsString;
-						const TestParams	testParams		=
+						const VkFormat		format						= depthStencilImageFormatsToTest[imageFormatIndex];
+						const bool			hasDepth					= tcu::hasDepthComponent(mapVkFormat(format).order);
+						const bool			hasStencil					= tcu::hasStencilComponent(mapVkFormat(format).order);
+						const int			separateLayoutsLoopCount	= (hasDepth && hasStencil) ? 3 : 1;
+
+						for (int separateDepthStencilLayoutMode = 0; separateDepthStencilLayoutMode < separateLayoutsLoopCount; ++separateDepthStencilLayoutMode)
 						{
-							true,															// bool				useSingleMipLevel;
-							VK_IMAGE_TYPE_2D,												// VkImageType		imageType;
-							format,															// VkFormat			format;
-							VK_IMAGE_TILING_OPTIMAL,										// VkImageTiling	tiling;
-							dimensions,														// VkExtent3D		extent;
-							imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,	// deUint32         imageLayerCount;
-							imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange,	// LayerRange		imageViewLayerRange;
-							makeClearValueDepthStencil(0.5f, 0x03),							// VkClearValue		initValue
+							const std::string	testCaseName	= getFormatCaseName(format) +
+							((separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_DEPTH) ? "_separate_layouts_depth" :
+							 (separateDepthStencilLayoutMode == SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_STENCIL) ? "_separate_layouts_stencil" :
+							 "")
+							+ dimensionsString;
+
+							const TestParams	testParams						=
 							{
-								makeClearValueDepthStencil(0.1f, 0x06),							// VkClearValue		clearValue[0];
-								makeClearValueDepthStencil(0.3f, 0x04),							// VkClearValue		clearValue[1];
-							},
-							imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,	// LayerRange       clearLayerRange;
-							allocationKind,													// AllocationKind	allocationKind;
-							imageLayerParamsToTest[imageLayerParamsIndex].isCube			// bool				isCube;
-						};
-						depthStencilLayersGroup->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Attachment", testParams));
-						if (dimensions.width > 1)
-							partialDepthStencilLayersGroup->addChild(new InstanceFactory1<PartialClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Partial Clear Depth/Stencil Attachment", testParams));
+								true,															// bool								useSingleMipLevel;
+								VK_IMAGE_TYPE_2D,												// VkImageType						imageType;
+								format,															// VkFormat							format;
+								VK_IMAGE_TILING_OPTIMAL,										// VkImageTiling					tiling;
+								dimensions,														// VkExtent3D						extent;
+								imageLayerParamsToTest[imageLayerParamsIndex].imageLayerCount,	// deUint32							imageLayerCount;
+								imageLayerParamsToTest[imageLayerParamsIndex].imageViewRange,	// LayerRange						imageViewLayerRange;
+								makeClearValueDepthStencil(0.5f, 0x03),							// VkClearValue						initValue
+								{
+									makeClearValueDepthStencil(0.1f, 0x06),							// VkClearValue						clearValue[0];
+									makeClearValueDepthStencil(0.3f, 0x04),							// VkClearValue						clearValue[1];
+								},
+								imageLayerParamsToTest[imageLayerParamsIndex].clearLayerRange,	// LayerRange						clearLayerRange;
+								allocationKind,													// AllocationKind					allocationKind;
+								imageLayerParamsToTest[imageLayerParamsIndex].isCube,			// bool								isCube;
+								SeparateDepthStencilLayoutMode(separateDepthStencilLayoutMode),	// SeparateDepthStencilLayoutMode	separateDepthStencilLayoutMode;
+							};
+							depthStencilLayersGroup->addChild(new InstanceFactory1<ClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Clear Depth/Stencil Attachment", testParams));
+							if (dimensions.width > 1)
+								partialDepthStencilLayersGroup->addChild(new InstanceFactory1<PartialClearAttachmentTestInstance, TestParams>(testCtx, NODETYPE_SELF_VALIDATE, testCaseName, "Partial Clear Depth/Stencil Attachment", testParams));
+						}
 					}
 				}
 				depthStencilAttachmentClearTests->addChild(depthStencilLayersGroup.release());
diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineDepthTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineDepthTests.cpp
index 7a1feba..20c3d4d 100644
--- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineDepthTests.cpp
+++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineDepthTests.cpp
@@ -119,6 +119,7 @@
 																 const std::string&		description,
 																 const VkFormat			depthFormat,
 																 const VkCompareOp		depthCompareOps[QUAD_COUNT],
+																 const bool				separateDepthStencilLayouts,
 																 const bool				depthBoundsTestEnable			= false,
 																 const float			depthBoundsMin					= 0.0f,
 																 const float			depthBoundsMax					= 1.0f,
@@ -132,6 +133,7 @@
 
 private:
 	const VkFormat						m_depthFormat;
+	const bool							m_separateDepthStencilLayouts;
 	const bool							m_depthBoundsTestEnable;
 	const float							m_depthBoundsMin;
 	const float							m_depthBoundsMax;
@@ -147,6 +149,7 @@
 										DepthTestInstance		(Context&			context,
 																 const VkFormat		depthFormat,
 																 const VkCompareOp	depthCompareOps[DepthTest::QUAD_COUNT],
+																 const bool			separateDepthStencilLayouts,
 																 const bool			depthBoundsTestEnable,
 																 const float		depthBoundsMin,
 																 const float		depthBoundsMax,
@@ -164,6 +167,7 @@
 	const tcu::UVec2					m_renderSize;
 	const VkFormat						m_colorFormat;
 	const VkFormat						m_depthFormat;
+	const bool							m_separateDepthStencilLayouts;
 	const bool							m_depthBoundsTestEnable;
 	const float							m_depthBoundsMin;
 	const float							m_depthBoundsMax;
@@ -208,6 +212,7 @@
 					  const std::string&	description,
 					  const VkFormat		depthFormat,
 					  const VkCompareOp		depthCompareOps[QUAD_COUNT],
+					  const bool			separateDepthStencilLayouts,
 					  const bool			depthBoundsTestEnable,
 					  const float			depthBoundsMin,
 					  const float			depthBoundsMax,
@@ -215,13 +220,14 @@
 					  const bool			stencilTestEnable,
 					  const bool			colorAttachmentEnable)
 	: vkt::TestCase	(testContext, name, description)
-	, m_depthFormat				(depthFormat)
-	, m_depthBoundsTestEnable	(depthBoundsTestEnable)
-	, m_depthBoundsMin			(depthBoundsMin)
-	, m_depthBoundsMax			(depthBoundsMax)
-	, m_depthTestEnable			(depthTestEnable)
-	, m_stencilTestEnable		(stencilTestEnable)
-	, m_colorAttachmentEnable	(colorAttachmentEnable)
+	, m_depthFormat					(depthFormat)
+	, m_separateDepthStencilLayouts	(separateDepthStencilLayouts)
+	, m_depthBoundsTestEnable		(depthBoundsTestEnable)
+	, m_depthBoundsMin				(depthBoundsMin)
+	, m_depthBoundsMax				(depthBoundsMax)
+	, m_depthTestEnable				(depthTestEnable)
+	, m_stencilTestEnable			(stencilTestEnable)
+	, m_colorAttachmentEnable		(colorAttachmentEnable)
 {
 	deMemcpy(m_depthCompareOps, depthCompareOps, sizeof(VkCompareOp) * QUAD_COUNT);
 }
@@ -237,11 +243,14 @@
 
 	if (!isSupportedDepthStencilFormat(context.getInstanceInterface(), context.getPhysicalDevice(), m_depthFormat))
 		throw tcu::NotSupportedError(std::string("Unsupported depth/stencil format: ") + getFormatName(m_depthFormat));
+
+	if (m_separateDepthStencilLayouts && !context.isDeviceFunctionalitySupported("VK_KHR_separate_depth_stencil_layouts"))
+		TCU_THROW(NotSupportedError, "VK_KHR_separate_depth_stencil_layouts is not supported");
 }
 
 TestInstance* DepthTest::createInstance (Context& context) const
 {
-	return new DepthTestInstance(context, m_depthFormat, m_depthCompareOps, m_depthBoundsTestEnable, m_depthBoundsMin, m_depthBoundsMax, m_depthTestEnable, m_stencilTestEnable, m_colorAttachmentEnable);
+	return new DepthTestInstance(context, m_depthFormat, m_depthCompareOps, m_separateDepthStencilLayouts, m_depthBoundsTestEnable, m_depthBoundsMin, m_depthBoundsMax, m_depthTestEnable, m_stencilTestEnable, m_colorAttachmentEnable);
 }
 
 void DepthTest::initPrograms (SourceCollections& programCollection) const
@@ -291,22 +300,24 @@
 DepthTestInstance::DepthTestInstance (Context&				context,
 									  const VkFormat		depthFormat,
 									  const VkCompareOp		depthCompareOps[DepthTest::QUAD_COUNT],
+									  const bool			separateDepthStencilLayouts,
 									  const bool			depthBoundsTestEnable,
 									  const float			depthBoundsMin,
 									  const float			depthBoundsMax,
 									  const bool			depthTestEnable,
 									  const bool			stencilTestEnable,
 									  const bool			colorAttachmentEnable)
-	: vkt::TestInstance			(context)
-	, m_renderSize				(32, 32)
-	, m_colorFormat				(colorAttachmentEnable ? VK_FORMAT_R8G8B8A8_UNORM : VK_FORMAT_UNDEFINED)
-	, m_depthFormat				(depthFormat)
-	, m_depthBoundsTestEnable	(depthBoundsTestEnable)
-	, m_depthBoundsMin			(depthBoundsMin)
-	, m_depthBoundsMax			(depthBoundsMax)
-	, m_depthTestEnable			(depthTestEnable)
-	, m_stencilTestEnable		(stencilTestEnable)
-	, m_colorAttachmentEnable	(colorAttachmentEnable)
+	: vkt::TestInstance				(context)
+	, m_renderSize					(32, 32)
+	, m_colorFormat					(colorAttachmentEnable ? VK_FORMAT_R8G8B8A8_UNORM : VK_FORMAT_UNDEFINED)
+	, m_depthFormat					(depthFormat)
+	, m_separateDepthStencilLayouts	(separateDepthStencilLayouts)
+	, m_depthBoundsTestEnable		(depthBoundsTestEnable)
+	, m_depthBoundsMin				(depthBoundsMin)
+	, m_depthBoundsMax				(depthBoundsMax)
+	, m_depthTestEnable				(depthTestEnable)
+	, m_stencilTestEnable			(stencilTestEnable)
+	, m_colorAttachmentEnable		(colorAttachmentEnable)
 {
 	const DeviceInterface&		vk						= context.getDeviceInterface();
 	const VkDevice				vkDevice				= context.getDevice();
@@ -601,7 +612,7 @@
 
 		attachmentClearValues.push_back(defaultClearValue(m_depthFormat));
 
-		const VkImageMemoryBarrier			colorBarrier				=
+		const VkImageMemoryBarrier			colorBarrier					=
 		{
 			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,									// VkStructureType            sType;
 			DE_NULL,																// const void*                pNext;
@@ -615,18 +626,26 @@
 			{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }							// VkImageSubresourceRange    subresourceRange;
 		};
 
-		const VkImageMemoryBarrier			depthBarrier				=
+		VkImageSubresourceRange				depthBarrierSubresourceRange	= m_depthImageSubresourceRange;
+		VkImageLayout						newLayout						= VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+		if (m_separateDepthStencilLayouts)
+		{
+			depthBarrierSubresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
+			newLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
+		}
+
+		const VkImageMemoryBarrier			depthBarrier					=
 		{
 			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,									// VkStructureType            sType;
 			DE_NULL,																// const void*                pNext;
 			(VkAccessFlags)0,														// 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;
+			newLayout										,						// VkImageLayout              newLayout;
 			VK_QUEUE_FAMILY_IGNORED,												// uint32_t                   srcQueueFamilyIndex;
 			VK_QUEUE_FAMILY_IGNORED,												// uint32_t                   dstQueueFamilyIndex;
 			*m_depthImage,															// VkImage                    image;
-			m_depthImageSubresourceRange,											// VkImageSubresourceRange    subresourceRange;
+			depthBarrierSubresourceRange,											// VkImageSubresourceRange    subresourceRange;
 		};
 
 		std::vector<VkImageMemoryBarrier>	imageLayoutBarriers;
@@ -981,67 +1000,80 @@
 
 			for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(depthFormats); formatNdx++)
 			{
-				de::MovePtr<tcu::TestCaseGroup>	formatTest		(new tcu::TestCaseGroup(testCtx,
-							getFormatCaseName(depthFormats[formatNdx]).c_str(),
-							(std::string("Uses format ") + getFormatName(depthFormats[formatNdx])).c_str()));
-				de::MovePtr<tcu::TestCaseGroup>	compareOpsTests	(new tcu::TestCaseGroup(testCtx, "compare_ops", "Combines depth compare operators"));
+				const bool		hasDepth					= tcu::hasDepthComponent(mapVkFormat(depthFormats[formatNdx]).order);
+				const bool		hasStencil					= tcu::hasStencilComponent(mapVkFormat(depthFormats[formatNdx]).order);
+				const int		separateLayoutsLoopCount	= (hasDepth && hasStencil) ? 2 : 1;
 
-				for (size_t opsNdx = 0; opsNdx < DE_LENGTH_OF_ARRAY(depthOps); opsNdx++)
+				for (int separateDepthStencilLayouts = 0; separateDepthStencilLayouts < separateLayoutsLoopCount; ++separateDepthStencilLayouts)
 				{
-					compareOpsTests->addChild(new DepthTest(testCtx,
-								getCompareOpsName(depthOps[opsNdx]),
-								getCompareOpsDescription(depthOps[opsNdx]),
-								depthFormats[formatNdx],
-								depthOps[opsNdx]));
+					const bool			useSeparateDepthStencilLayouts	= bool(separateDepthStencilLayouts);
 
-					compareOpsTests->addChild(new DepthTest(testCtx,
-								getCompareOpsName(depthOps[opsNdx]) + "_depth_bounds_test",
-								getCompareOpsDescription(depthOps[opsNdx]) + " with depth bounds test enabled",
-								depthFormats[formatNdx],
-								depthOps[opsNdx],
-								true,
-								0.1f,
-								0.25f,
-								true,
-								false,
-								colorEnabled));
-				}
-				// Special VkPipelineDepthStencilStateCreateInfo known to have issues
-				{
-					const VkCompareOp depthOpsSpecial[DepthTest::QUAD_COUNT] = { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER };
+					de::MovePtr<tcu::TestCaseGroup>	formatTest		(new tcu::TestCaseGroup(testCtx,
+								(getFormatCaseName(depthFormats[formatNdx]) + ((useSeparateDepthStencilLayouts) ? "_separate_layouts" : "")).c_str(),
+								(std::string("Uses format ") + getFormatName(depthFormats[formatNdx]) + ((useSeparateDepthStencilLayouts) ? " with separate depth/stencil layouts" : "")).c_str()));
+					de::MovePtr<tcu::TestCaseGroup>	compareOpsTests	(new tcu::TestCaseGroup(testCtx, "compare_ops", "Combines depth compare operators"));
 
-					compareOpsTests->addChild(new DepthTest(testCtx,
-								"never_zerodepthbounds_depthdisabled_stencilenabled",
-								"special VkPipelineDepthStencilStateCreateInfo",
-								depthFormats[formatNdx],
-								depthOpsSpecial,
-								true,
-								0.0f,
-								0.0f,
-								false,
-								true,
-								colorEnabled));
-				}
-				formatTest->addChild(compareOpsTests.release());
+					for (size_t opsNdx = 0; opsNdx < DE_LENGTH_OF_ARRAY(depthOps); opsNdx++)
+					{
+						compareOpsTests->addChild(new DepthTest(testCtx,
+									getCompareOpsName(depthOps[opsNdx]),
+									getCompareOpsDescription(depthOps[opsNdx]),
+									depthFormats[formatNdx],
+									depthOps[opsNdx],
+									useSeparateDepthStencilLayouts));
 
-				// Test case with depth test enabled, but depth write disabled
-				de::MovePtr<tcu::TestCaseGroup>	depthTestDisabled(new tcu::TestCaseGroup(testCtx, "depth_test_disabled", "Test for disabled depth test"));
-				{
-					const VkCompareOp depthOpsDepthTestDisabled[DepthTest::QUAD_COUNT] = { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_ALWAYS };
-					depthTestDisabled->addChild(new DepthTest(testCtx,
-								"depth_write_enabled",
-								"Depth writes should not occur if depth test is disabled",
-								depthFormats[formatNdx],
-								depthOpsDepthTestDisabled,
-								false,			/* depthBoundsTestEnable */
-								0.0f,			/* depthBoundMin*/
-								1.0f,			/* depthBoundMax*/
-								false,			/* depthTestEnable */
-								false,			/* stencilTestEnable */
-								colorEnabled	/* colorAttachmentEnable */));
+						compareOpsTests->addChild(new DepthTest(testCtx,
+									getCompareOpsName(depthOps[opsNdx]) + "_depth_bounds_test",
+									getCompareOpsDescription(depthOps[opsNdx]) + " with depth bounds test enabled",
+									depthFormats[formatNdx],
+									depthOps[opsNdx],
+									useSeparateDepthStencilLayouts,
+									true,
+									0.1f,
+									0.25f,
+									true,
+									false,
+									colorEnabled));
+					}
+					// Special VkPipelineDepthStencilStateCreateInfo known to have issues
+					{
+						const VkCompareOp depthOpsSpecial[DepthTest::QUAD_COUNT] = { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER, VK_COMPARE_OP_NEVER };
+
+						compareOpsTests->addChild(new DepthTest(testCtx,
+									"never_zerodepthbounds_depthdisabled_stencilenabled",
+									"special VkPipelineDepthStencilStateCreateInfo",
+									depthFormats[formatNdx],
+									depthOpsSpecial,
+									useSeparateDepthStencilLayouts,
+									true,
+									0.0f,
+									0.0f,
+									false,
+									true,
+									colorEnabled));
+					}
+					formatTest->addChild(compareOpsTests.release());
+
+					// Test case with depth test enabled, but depth write disabled
+					de::MovePtr<tcu::TestCaseGroup>	depthTestDisabled(new tcu::TestCaseGroup(testCtx, "depth_test_disabled", "Test for disabled depth test"));
+					{
+						const VkCompareOp depthOpsDepthTestDisabled[DepthTest::QUAD_COUNT] = { VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_GREATER, VK_COMPARE_OP_ALWAYS };
+						depthTestDisabled->addChild(new DepthTest(testCtx,
+									"depth_write_enabled",
+									"Depth writes should not occur if depth test is disabled",
+									depthFormats[formatNdx],
+									depthOpsDepthTestDisabled,
+									useSeparateDepthStencilLayouts,
+									false,			/* depthBoundsTestEnable */
+									0.0f,			/* depthBoundMin*/
+									1.0f,			/* depthBoundMax*/
+									false,			/* depthTestEnable */
+									false,			/* stencilTestEnable */
+									colorEnabled	/* colorAttachmentEnable */));
+					}
+					formatTest->addChild(depthTestDisabled.release());
+					formatTests->addChild(formatTest.release());
 				}
-				formatTest->addChild(depthTestDisabled.release());
-				formatTests->addChild(formatTest.release());
 			}
 			if (colorEnabled)
 				depthTests->addChild(formatTests.release());
diff --git a/external/vulkancts/modules/vulkan/pipeline/vktPipelineStencilTests.cpp b/external/vulkancts/modules/vulkan/pipeline/vktPipelineStencilTests.cpp
index 9b36392..5a29742 100644
--- a/external/vulkancts/modules/vulkan/pipeline/vktPipelineStencilTests.cpp
+++ b/external/vulkancts/modules/vulkan/pipeline/vktPipelineStencilTests.cpp
@@ -116,7 +116,8 @@
 																	 VkFormat					stencilFormat,
 																	 const VkStencilOpState&	stencilOpStateFront,
 																	 const VkStencilOpState&	stencilOpStateBack,
-																	 const bool					colorAttachmentEnable);
+																	 const bool					colorAttachmentEnable,
+																	 const bool					separateDepthStencilLayouts);
 	virtual									~StencilTest			(void);
 	virtual void							initPrograms			(SourceCollections& sourceCollections) const;
 	virtual void							checkSupport			(Context& context) const;
@@ -127,6 +128,7 @@
 	const VkStencilOpState					m_stencilOpStateFront;
 	const VkStencilOpState					m_stencilOpStateBack;
 	const bool								m_colorAttachmentEnable;
+	const bool								m_separateDepthStencilLayouts;
 };
 
 class StencilTestInstance : public vkt::TestInstance
@@ -136,7 +138,8 @@
 																 VkFormat					stencilFormat,
 																 const VkStencilOpState&	stencilOpStatesFront,
 																 const VkStencilOpState&	stencilOpStatesBack,
-																 const bool					colorAttachmentEnable);
+																 const bool					colorAttachmentEnable,
+																 const bool					separateDepthStencilLayouts);
 	virtual								~StencilTestInstance	(void);
 	virtual tcu::TestStatus				iterate					(void);
 
@@ -146,6 +149,7 @@
 	VkStencilOpState					m_stencilOpStateFront;
 	VkStencilOpState					m_stencilOpStateBack;
 	const bool							m_colorAttachmentEnable;
+	const bool							m_separateDepthStencilLayouts;
 	const tcu::UVec2					m_renderSize;
 	const VkFormat						m_colorFormat;
 	const VkFormat						m_stencilFormat;
@@ -265,12 +269,14 @@
 						  VkFormat					stencilFormat,
 						  const VkStencilOpState&	stencilOpStateFront,
 						  const VkStencilOpState&	stencilOpStateBack,
-						  const bool				colorAttachmentEnable)
-	: vkt::TestCase				(testContext, name, description)
-	, m_stencilFormat			(stencilFormat)
-	, m_stencilOpStateFront		(stencilOpStateFront)
-	, m_stencilOpStateBack		(stencilOpStateBack)
-	, m_colorAttachmentEnable	(colorAttachmentEnable)
+						  const bool				colorAttachmentEnable,
+						  const bool				separateDepthStencilLayouts)
+	: vkt::TestCase					(testContext, name, description)
+	, m_stencilFormat				(stencilFormat)
+	, m_stencilOpStateFront			(stencilOpStateFront)
+	, m_stencilOpStateBack			(stencilOpStateBack)
+	, m_colorAttachmentEnable		(colorAttachmentEnable)
+	, m_separateDepthStencilLayouts	(separateDepthStencilLayouts)
 {
 }
 
@@ -282,11 +288,14 @@
 {
 	if (!isSupportedDepthStencilFormat(context.getInstanceInterface(), context.getPhysicalDevice(), m_stencilFormat))
 		throw tcu::NotSupportedError(std::string("Unsupported depth/stencil format: ") + getFormatName(m_stencilFormat));
+
+	if (m_separateDepthStencilLayouts && !context.isDeviceFunctionalitySupported("VK_KHR_separate_depth_stencil_layouts"))
+		TCU_THROW(NotSupportedError, "VK_KHR_separate_depth_stencil_layouts is not supported");
 }
 
 TestInstance* StencilTest::createInstance (Context& context) const
 {
-	return new StencilTestInstance(context, m_stencilFormat, m_stencilOpStateFront, m_stencilOpStateBack, m_colorAttachmentEnable);
+	return new StencilTestInstance(context, m_stencilFormat, m_stencilOpStateFront, m_stencilOpStateBack, m_colorAttachmentEnable, m_separateDepthStencilLayouts);
 }
 
 void StencilTest::initPrograms (SourceCollections& sourceCollections) const
@@ -339,14 +348,16 @@
 										  VkFormat					stencilFormat,
 										  const VkStencilOpState&	stencilOpStateFront,
 										  const VkStencilOpState&	stencilOpStateBack,
-										  const bool				colorAttachmentEnable)
-	: vkt::TestInstance			(context)
-	, m_stencilOpStateFront		(stencilOpStateFront)
-	, m_stencilOpStateBack		(stencilOpStateBack)
-	, m_colorAttachmentEnable	(colorAttachmentEnable)
-	, m_renderSize				(32, 32)
-	, m_colorFormat				(colorAttachmentEnable ? VK_FORMAT_R8G8B8A8_UNORM : VK_FORMAT_UNDEFINED)
-	, m_stencilFormat			(stencilFormat)
+										  const bool				colorAttachmentEnable,
+										  const bool				separateDepthStencilLayouts)
+	: vkt::TestInstance				(context)
+	, m_stencilOpStateFront			(stencilOpStateFront)
+	, m_stencilOpStateBack			(stencilOpStateBack)
+	, m_colorAttachmentEnable		(colorAttachmentEnable)
+	, m_separateDepthStencilLayouts	(separateDepthStencilLayouts)
+	, m_renderSize					(32, 32)
+	, m_colorFormat					(colorAttachmentEnable ? VK_FORMAT_R8G8B8A8_UNORM : VK_FORMAT_UNDEFINED)
+	, m_stencilFormat				(stencilFormat)
 {
 	const DeviceInterface&		vk						= context.getDeviceInterface();
 	const VkDevice				vkDevice				= context.getDevice();
@@ -629,7 +640,7 @@
 
 	// Create command buffer
 	{
-		const VkImageMemoryBarrier	colorImageBarrier	=
+		const VkImageMemoryBarrier	colorImageBarrier					=
 		{
 			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,			// VkStructureType            sType;
 			DE_NULL,										// const void*                pNext;
@@ -643,18 +654,26 @@
 			{ VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u }	// VkImageSubresourceRange    subresourceRange;
 		};
 
-		const VkImageMemoryBarrier	stencilImageBarrier	=
+		VkImageSubresourceRange		stencilImageBarrierSubresourceRange	= m_stencilImageSubresourceRange;
+		VkImageLayout				newLayout							= VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+		if (m_separateDepthStencilLayouts)
 		{
-			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,				// VkStructureType            sType;
-			DE_NULL,											// const void*                pNext;
-			(VkAccessFlags)0,									// 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,							// uint32_t                   srcQueueFamilyIndex;
-			VK_QUEUE_FAMILY_IGNORED,							// uint32_t                   dstQueueFamilyIndex;
-			*m_stencilImage,									// VkImage                    image;
-			m_stencilImageSubresourceRange,						// VkImageSubresourceRange    subresourceRange;
+			stencilImageBarrierSubresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
+			newLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
+		}
+
+		const VkImageMemoryBarrier	stencilImageBarrier					=
+		{
+			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,									// VkStructureType            sType;
+			DE_NULL,																// const void*                pNext;
+			(VkAccessFlags)0,														// VkAccessFlags              srcAccessMask;
+			VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,							// VkAccessFlags              dstAccessMask;
+			VK_IMAGE_LAYOUT_UNDEFINED,												// VkImageLayout              oldLayout;
+			newLayout,																// VkImageLayout              newLayout;
+			VK_QUEUE_FAMILY_IGNORED,												// uint32_t                   srcQueueFamilyIndex;
+			VK_QUEUE_FAMILY_IGNORED,												// uint32_t                   dstQueueFamilyIndex;
+			*m_stencilImage,														// VkImage                    image;
+			stencilImageBarrierSubresourceRange,									// VkImageSubresourceRange    subresourceRange;
 		};
 
 		std::vector<VkClearValue>			attachmentClearValues;
@@ -904,80 +923,89 @@
 
 		for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(stencilFormats); formatNdx++)
 		{
-			const VkFormat					stencilFormat	= stencilFormats[formatNdx];
-			de::MovePtr<tcu::TestCaseGroup>	formatTest		(new tcu::TestCaseGroup(testCtx,
-																					getFormatCaseName(stencilFormat).c_str(),
-																					(std::string("Uses format ") + getFormatName(stencilFormat)).c_str()));
+			const VkFormat	stencilFormat				= stencilFormats[formatNdx];
+			const bool		hasDepth					= tcu::hasDepthComponent(mapVkFormat(stencilFormat).order);
+			const bool		hasStencil					= tcu::hasStencilComponent(mapVkFormat(stencilFormat).order);
+			const int		separateLayoutsLoopCount	= (hasDepth && hasStencil) ? 2 : 1;
 
-			de::MovePtr<tcu::TestCaseGroup>	stencilStateTests;
+			for (int separateDepthStencilLayouts = 0; separateDepthStencilLayouts < separateLayoutsLoopCount; ++separateDepthStencilLayouts)
 			{
-				std::ostringstream desc;
-				desc << "Draws 4 quads with the following depths and dynamic stencil states: ";
+				const bool			useSeparateDepthStencilLayouts	= bool(separateDepthStencilLayouts);
 
-				for (int quadNdx = 0; quadNdx < StencilTest::QUAD_COUNT; quadNdx++)
+				de::MovePtr<tcu::TestCaseGroup>	formatTest		(new tcu::TestCaseGroup(testCtx,
+																						(getFormatCaseName(stencilFormat) + ((useSeparateDepthStencilLayouts) ? "_separate_layouts" : "")).c_str(),
+																						(std::string("Uses format ") + getFormatName(stencilFormat) + ((useSeparateDepthStencilLayouts) ? " with separate depth/stencil layouts" : "")).c_str()));
+
+				de::MovePtr<tcu::TestCaseGroup>	stencilStateTests;
 				{
-					const StencilTest::StencilStateConfig& stencilConfig = StencilTest::s_stencilStateConfigs[quadNdx];
+					std::ostringstream desc;
+					desc << "Draws 4 quads with the following depths and dynamic stencil states: ";
 
-					desc << "(" << quadNdx << ") "
-						 << "z = " << StencilTest::s_quadDepths[quadNdx] << ", "
-						 << "frontReadMask = " << stencilConfig.frontReadMask << ", "
-						 << "frontWriteMask = " << stencilConfig.frontWriteMask << ", "
-						 << "frontRef = " << stencilConfig.frontRef << ", "
-						 << "backReadMask = " << stencilConfig.backReadMask << ", "
-						 << "backWriteMask = " << stencilConfig.backWriteMask << ", "
-						 << "backRef = " << stencilConfig.backRef;
-				}
-
-				stencilStateTests = de::MovePtr<tcu::TestCaseGroup>(new tcu::TestCaseGroup(testCtx, "states", desc.str().c_str()));
-			}
-
-			stencilOpItr.reset();
-
-			for (deUint32 failOpNdx = 0u; failOpNdx < DE_LENGTH_OF_ARRAY(stencilOps); failOpNdx++)
-			{
-				const std::string				failOpName	= std::string("fail_") + getShortName(stencilOps[failOpNdx]);
-				de::MovePtr<tcu::TestCaseGroup>	failOpTest	(new tcu::TestCaseGroup(testCtx, failOpName.c_str(), ""));
-
-				for (deUint32 passOpNdx = 0u; passOpNdx < DE_LENGTH_OF_ARRAY(stencilOps); passOpNdx++)
-				{
-					const std::string				passOpName	= std::string("pass_") + getShortName(stencilOps[passOpNdx]);
-					de::MovePtr<tcu::TestCaseGroup>	passOpTest	(new tcu::TestCaseGroup(testCtx, passOpName.c_str(), ""));
-
-					for (deUint32 dFailOpNdx = 0u; dFailOpNdx < DE_LENGTH_OF_ARRAY(stencilOps); dFailOpNdx++)
+					for (int quadNdx = 0; quadNdx < StencilTest::QUAD_COUNT; quadNdx++)
 					{
-						const std::string				dFailOpName	= std::string("dfail_") + getShortName(stencilOps[dFailOpNdx]);
-						de::MovePtr<tcu::TestCaseGroup>	dFailOpTest	(new tcu::TestCaseGroup(testCtx, dFailOpName.c_str(), ""));
+						const StencilTest::StencilStateConfig& stencilConfig = StencilTest::s_stencilStateConfigs[quadNdx];
 
-						for (deUint32 compareOpNdx = 0u; compareOpNdx < DE_LENGTH_OF_ARRAY(compareOps); compareOpNdx++)
-						{
-							// Iterate front set of stencil state in ascending order
-							const VkStencilOpState	stencilStateFront	=
-							{
-								stencilOps[failOpNdx],		// failOp
-								stencilOps[passOpNdx],		// passOp
-								stencilOps[dFailOpNdx],		// depthFailOp
-								compareOps[compareOpNdx],	// compareOp
-								0x0,						// compareMask
-								0x0,						// writeMask
-								0x0							// reference
-							};
-
-							// Iterate back set of stencil state in random order
-							const VkStencilOpState	stencilStateBack	= stencilOpItr.next();
-							const std::string		caseName			= compareOpNames[compareOpNdx];
-							const std::string		caseDesc			= getStencilStateSetDescription(stencilStateFront, stencilStateBack);
-
-							dFailOpTest->addChild(new StencilTest(testCtx, caseName, caseDesc, stencilFormat, stencilStateFront, stencilStateBack, colorEnabled));
-						}
-						passOpTest->addChild(dFailOpTest.release());
+						desc << "(" << quadNdx << ") "
+							 << "z = " << StencilTest::s_quadDepths[quadNdx] << ", "
+							 << "frontReadMask = " << stencilConfig.frontReadMask << ", "
+							 << "frontWriteMask = " << stencilConfig.frontWriteMask << ", "
+							 << "frontRef = " << stencilConfig.frontRef << ", "
+							 << "backReadMask = " << stencilConfig.backReadMask << ", "
+							 << "backWriteMask = " << stencilConfig.backWriteMask << ", "
+							 << "backRef = " << stencilConfig.backRef;
 					}
-					failOpTest->addChild(passOpTest.release());
-				}
-				stencilStateTests->addChild(failOpTest.release());
-			}
 
-			formatTest->addChild(stencilStateTests.release());
-			formatTests->addChild(formatTest.release());
+					stencilStateTests = de::MovePtr<tcu::TestCaseGroup>(new tcu::TestCaseGroup(testCtx, "states", desc.str().c_str()));
+				}
+
+				stencilOpItr.reset();
+
+				for (deUint32 failOpNdx = 0u; failOpNdx < DE_LENGTH_OF_ARRAY(stencilOps); failOpNdx++)
+				{
+					const std::string				failOpName	= std::string("fail_") + getShortName(stencilOps[failOpNdx]);
+					de::MovePtr<tcu::TestCaseGroup>	failOpTest	(new tcu::TestCaseGroup(testCtx, failOpName.c_str(), ""));
+
+					for (deUint32 passOpNdx = 0u; passOpNdx < DE_LENGTH_OF_ARRAY(stencilOps); passOpNdx++)
+					{
+						const std::string				passOpName	= std::string("pass_") + getShortName(stencilOps[passOpNdx]);
+						de::MovePtr<tcu::TestCaseGroup>	passOpTest	(new tcu::TestCaseGroup(testCtx, passOpName.c_str(), ""));
+
+						for (deUint32 dFailOpNdx = 0u; dFailOpNdx < DE_LENGTH_OF_ARRAY(stencilOps); dFailOpNdx++)
+						{
+							const std::string				dFailOpName	= std::string("dfail_") + getShortName(stencilOps[dFailOpNdx]);
+							de::MovePtr<tcu::TestCaseGroup>	dFailOpTest	(new tcu::TestCaseGroup(testCtx, dFailOpName.c_str(), ""));
+
+							for (deUint32 compareOpNdx = 0u; compareOpNdx < DE_LENGTH_OF_ARRAY(compareOps); compareOpNdx++)
+							{
+								// Iterate front set of stencil state in ascending order
+								const VkStencilOpState	stencilStateFront	=
+								{
+									stencilOps[failOpNdx],		// failOp
+									stencilOps[passOpNdx],		// passOp
+									stencilOps[dFailOpNdx],		// depthFailOp
+									compareOps[compareOpNdx],	// compareOp
+									0x0,						// compareMask
+									0x0,						// writeMask
+									0x0							// reference
+								};
+
+								// Iterate back set of stencil state in random order
+								const VkStencilOpState	stencilStateBack	= stencilOpItr.next();
+								const std::string		caseName			= compareOpNames[compareOpNdx];
+								const std::string		caseDesc			= getStencilStateSetDescription(stencilStateFront, stencilStateBack);
+
+								dFailOpTest->addChild(new StencilTest(testCtx, caseName, caseDesc, stencilFormat, stencilStateFront, stencilStateBack, colorEnabled, useSeparateDepthStencilLayouts));
+							}
+							passOpTest->addChild(dFailOpTest.release());
+						}
+						failOpTest->addChild(passOpTest.release());
+					}
+					stencilStateTests->addChild(failOpTest.release());
+				}
+
+				formatTest->addChild(stencilStateTests.release());
+				formatTests->addChild(formatTest.release());
+			}
 		}
 
 		if (colorEnabled)
diff --git a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassDepthStencilResolveTests.cpp b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassDepthStencilResolveTests.cpp
index c40801c..17437ca 100644
--- a/external/vulkancts/modules/vulkan/renderpass/vktRenderPassDepthStencilResolveTests.cpp
+++ b/external/vulkancts/modules/vulkan/renderpass/vktRenderPassDepthStencilResolveTests.cpp
@@ -106,6 +106,7 @@
 	VkClearDepthStencilValue	clearValue;
 	float						depthExpectedValue;
 	deUint8						stencilExpectedValue;
+	bool						separateDepthStencilLayouts;
 };
 
 float get16bitDepthComponent(deUint8* pixelPtr)
@@ -221,6 +222,9 @@
 	if (m_config.imageLayers > 1)
 		m_context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER);
 
+	if (m_config.separateDepthStencilLayouts)
+		m_context.requireDeviceFunctionality("VK_KHR_separate_depth_stencil_layouts");
+
 	VkPhysicalDeviceDepthStencilResolvePropertiesKHR dsResolveProperties;
 	deMemset(&dsResolveProperties, 0, sizeof(VkPhysicalDeviceDepthStencilResolvePropertiesKHR));
 	dsResolveProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR;
@@ -382,10 +386,48 @@
 {
 	const VkSampleCountFlagBits samples(sampleCountBitFromSampleCount(m_config.sampleCount));
 
+	VkImageLayout layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
+	VkAttachmentReferenceStencilLayoutKHR stencilLayout =
+	{
+		VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR,
+		DE_NULL,
+		VK_IMAGE_LAYOUT_UNDEFINED,
+	};
+	void * attachmentRefStencil = DE_NULL;
+	VkImageLayout finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+	VkAttachmentDescriptionStencilLayoutKHR stencilFinalLayout =
+	{
+		VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR,
+		DE_NULL,
+		VK_IMAGE_LAYOUT_UNDEFINED,
+		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+	};
+	void * attachmentDescriptionStencil = DE_NULL;
+
+	if (m_config.separateDepthStencilLayouts)
+	{
+		if (m_config.verifyBuffer == VB_DEPTH)
+		{
+			layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR;
+			stencilLayout.stencilLayout = VK_IMAGE_LAYOUT_GENERAL;
+			finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+			stencilFinalLayout.stencilFinalLayout = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR; // This aspect should be unused.
+		}
+		else
+		{
+			layout = VK_IMAGE_LAYOUT_GENERAL;
+			stencilLayout.stencilLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR;
+			finalLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR; // This aspect should be unused.
+			stencilFinalLayout.stencilFinalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+		}
+		attachmentRefStencil = &stencilLayout;
+		attachmentDescriptionStencil = &stencilFinalLayout;
+	}
+
 	const AttachmentDescription2 multisampleAttachment		// VkAttachmentDescription2KHR
 	(
 															// VkStructureType					sType;
-		DE_NULL,											// const void*						pNext;
+		attachmentDescriptionStencil,						// const void*						pNext;
 		0u,													// VkAttachmentDescriptionFlags		flags;
 		m_config.format,									// VkFormat							format;
 		samples,											// VkSampleCountFlagBits			samples;
@@ -394,21 +436,21 @@
 		VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				stencilLoadOp;
 		VK_ATTACHMENT_STORE_OP_DONT_CARE,					// VkAttachmentStoreOp				stencilStoreOp;
 		VK_IMAGE_LAYOUT_UNDEFINED,							// VkImageLayout					initialLayout;
-		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL				// VkImageLayout					finalLayout;
+		finalLayout											// VkImageLayout					finalLayout;
 	);
 	const AttachmentReference2 multisampleAttachmentRef		// VkAttachmentReference2KHR
 	(
 															// VkStructureType					sType;
-		DE_NULL,											// const void*						pNext;
+		attachmentRefStencil,								// const void*						pNext;
 		0u,													// deUint32							attachment;
-		VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,	// VkImageLayout					layout;
+		layout,												// VkImageLayout					layout;
 		0u													// VkImageAspectFlags				aspectMask;
 	);
 
 	const AttachmentDescription2 singlesampleAttachment		// VkAttachmentDescription2KHR
 	(
 															// VkStructureType					sType;
-		DE_NULL,											// const void*						pNext;
+		attachmentDescriptionStencil,						// const void*						pNext;
 		0u,													// VkAttachmentDescriptionFlags		flags;
 		m_config.format,									// VkFormat							format;
 		VK_SAMPLE_COUNT_1_BIT,								// VkSampleCountFlagBits			samples;
@@ -417,14 +459,14 @@
 		VK_ATTACHMENT_LOAD_OP_CLEAR,						// VkAttachmentLoadOp				stencilLoadOp;
 		VK_ATTACHMENT_STORE_OP_STORE,						// VkAttachmentStoreOp				stencilStoreOp;
 		VK_IMAGE_LAYOUT_UNDEFINED,							// VkImageLayout					initialLayout;
-		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL				// VkImageLayout					finalLayout;
+		finalLayout											// VkImageLayout					finalLayout;
 	);
 	AttachmentReference2 singlesampleAttachmentRef			// VkAttachmentReference2KHR
 	(
 															// VkStructureType					sType;
 		DE_NULL,											// const void*						pNext;
 		1u,													// deUint32							attachment;
-		VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,	// VkImageLayout					layout;
+		layout,												// VkImageLayout					layout;
 		0u													// VkImageAspectFlags				aspectMask;
 	);
 
@@ -743,7 +785,7 @@
 
 			**m_singlesampleImage,
 			{
-				m_config.aspectFlag,
+				(m_config.separateDepthStencilLayouts) ? VkImageAspectFlags(testingDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT) : m_config.aspectFlag,
 				0u,
 				1u,
 				0u,
@@ -761,7 +803,7 @@
 		0u,
 		0u,
 		{
-			testingDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT,
+			VkImageAspectFlags(testingDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT),
 			0u,
 			0u,
 			m_config.viewLayers,
@@ -1153,104 +1195,112 @@
 			// iterate over depth/stencil formats
 			for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
 			{
-				const FormatData&			formatData	= formats[formatNdx];
-				VkFormat					format		= formatData.format;
-				const char*					formatName	= formatData.name;
-				const bool					hasDepth	= formatData.hasDepth;
-				const bool					hasStencil	= formatData.hasStencil;
-				VkImageAspectFlags			aspectFlags	= (hasDepth * VK_IMAGE_ASPECT_DEPTH_BIT) |
-														  (hasStencil * VK_IMAGE_ASPECT_STENCIL_BIT);
+				const FormatData&			formatData					= formats[formatNdx];
+				VkFormat					format						= formatData.format;
+				const char*					formatName					= formatData.name;
+				const bool					hasDepth					= formatData.hasDepth;
+				const bool					hasStencil					= formatData.hasStencil;
+				VkImageAspectFlags			aspectFlags					= (hasDepth * VK_IMAGE_ASPECT_DEPTH_BIT) |
+																		  (hasStencil * VK_IMAGE_ASPECT_STENCIL_BIT);
+				const int					separateLayoutsLoopCount	= (hasDepth && hasStencil) ? 2 : 1;
 
-				// create test group for format
-				de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, formatName, formatName));
-
-				// iterate over depth resolve modes
-				for (size_t depthResolveModeNdx = 0; depthResolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); depthResolveModeNdx++)
+				for (int separateDepthStencilLayouts = 0; separateDepthStencilLayouts < separateLayoutsLoopCount; ++separateDepthStencilLayouts)
 				{
-					// iterate over stencil resolve modes
-					for (size_t stencilResolveModeNdx = 0; stencilResolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); stencilResolveModeNdx++)
+					const bool			useSeparateDepthStencilLayouts	= bool(separateDepthStencilLayouts);
+					const std::string	groupName						= std::string(formatName) + ((useSeparateDepthStencilLayouts) ? "_separate_layouts" : "");
+
+					// create test group for format
+					de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupName.c_str()));
+
+					// iterate over depth resolve modes
+					for (size_t depthResolveModeNdx = 0; depthResolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); depthResolveModeNdx++)
 					{
-						// there is no average resolve mode for stencil - go to next iteration
-						ResolveModeData& sResolve = resolveModes[stencilResolveModeNdx];
-						if (sResolve.flag == VK_RESOLVE_MODE_AVERAGE_BIT_KHR)
-							continue;
-
-						// if pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED,
-						// depthResolveMode and stencilResolveMode must not both be VK_RESOLVE_MODE_NONE_KHR
-						ResolveModeData& dResolve = resolveModes[depthResolveModeNdx];
-						if ((dResolve.flag == VK_RESOLVE_MODE_NONE_KHR) && (sResolve.flag == VK_RESOLVE_MODE_NONE_KHR))
-							continue;
-
-						// If there is no depth, the depth resolve mode should be NONE, or
-						// match the stencil resolve mode.
-						if (!hasDepth && (dResolve.flag != VK_RESOLVE_MODE_NONE_KHR) &&
-							(dResolve.flag != sResolve.flag))
-							continue;
-
-						// If there is no stencil, the stencil resmove mode should be NONE, or
-						// match the depth resolve mode.
-						if (!hasStencil && (sResolve.flag != VK_RESOLVE_MODE_NONE_KHR) &&
-							(dResolve.flag != sResolve.flag))
-							continue;
-
-						std::string baseName = "depth_" + dResolve.name + "_stencil_" + sResolve.name;
-
-						if (hasDepth)
+						// iterate over stencil resolve modes
+						for (size_t stencilResolveModeNdx = 0; stencilResolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); stencilResolveModeNdx++)
 						{
-							std::string	name			= baseName + "_testing_depth";
-							const char*	testName		= name.c_str();
-							float		expectedValue	= depthExpectedValue[depthResolveModeNdx][sampleCountNdx];
+							// there is no average resolve mode for stencil - go to next iteration
+							ResolveModeData& sResolve = resolveModes[stencilResolveModeNdx];
+							if (sResolve.flag == VK_RESOLVE_MODE_AVERAGE_BIT_KHR)
+								continue;
 
-							const TestConfig testConfig =
-							{
-								format,
-								imageData.width,
-								imageData.height,
-								1u,
-								1u,
-								0u,
-								imageData.renderArea,
-								aspectFlags,
-								sampleCount,
-								dResolve.flag,
-								sResolve.flag,
-								VB_DEPTH,
-								imageData.clearValue,
-								expectedValue,
-								0u
-							};
-							formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
-						}
-						if (hasStencil)
-						{
-							std::string	name			= baseName + "_testing_stencil";
-							const char*	testName		= name.c_str();
-							deUint8		expectedValue	= stencilExpectedValue[stencilResolveModeNdx][sampleCountNdx];
+							// if pDepthStencilResolveAttachment is not NULL and does not have the value VK_ATTACHMENT_UNUSED,
+							// depthResolveMode and stencilResolveMode must not both be VK_RESOLVE_MODE_NONE_KHR
+							ResolveModeData& dResolve = resolveModes[depthResolveModeNdx];
+							if ((dResolve.flag == VK_RESOLVE_MODE_NONE_KHR) && (sResolve.flag == VK_RESOLVE_MODE_NONE_KHR))
+								continue;
 
-							const TestConfig testConfig =
+							// If there is no depth, the depth resolve mode should be NONE, or
+							// match the stencil resolve mode.
+							if (!hasDepth && (dResolve.flag != VK_RESOLVE_MODE_NONE_KHR) &&
+								(dResolve.flag != sResolve.flag))
+								continue;
+
+							// If there is no stencil, the stencil resmove mode should be NONE, or
+							// match the depth resolve mode.
+							if (!hasStencil && (sResolve.flag != VK_RESOLVE_MODE_NONE_KHR) &&
+								(dResolve.flag != sResolve.flag))
+								continue;
+
+							std::string baseName = "depth_" + dResolve.name + "_stencil_" + sResolve.name;
+
+							if (hasDepth)
 							{
-								format,
-								imageData.width,
-								imageData.height,
-								1u,
-								1u,
-								0u,
-								imageData.renderArea,
-								aspectFlags,
-								sampleCount,
-								dResolve.flag,
-								sResolve.flag,
-								VB_STENCIL,
-								imageData.clearValue,
-								0.0f,
-								expectedValue
-							};
-							formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
+								std::string	name			= baseName + "_testing_depth";
+								const char*	testName		= name.c_str();
+								float		expectedValue	= depthExpectedValue[depthResolveModeNdx][sampleCountNdx];
+
+								const TestConfig testConfig =
+								{
+									format,
+									imageData.width,
+									imageData.height,
+									1u,
+									1u,
+									0u,
+									imageData.renderArea,
+									aspectFlags,
+									sampleCount,
+									dResolve.flag,
+									sResolve.flag,
+									VB_DEPTH,
+									imageData.clearValue,
+									expectedValue,
+									0u,
+									useSeparateDepthStencilLayouts
+								};
+								formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
+							}
+							if (hasStencil)
+							{
+								std::string	name			= baseName + "_testing_stencil";
+								const char*	testName		= name.c_str();
+								deUint8		expectedValue	= stencilExpectedValue[stencilResolveModeNdx][sampleCountNdx];
+
+								const TestConfig testConfig =
+								{
+									format,
+									imageData.width,
+									imageData.height,
+									1u,
+									1u,
+									0u,
+									imageData.renderArea,
+									aspectFlags,
+									sampleCount,
+									dResolve.flag,
+									sResolve.flag,
+									VB_STENCIL,
+									imageData.clearValue,
+									0.0f,
+									expectedValue,
+									useSeparateDepthStencilLayouts
+								};
+								formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
+							}
 						}
 					}
+					sampleGroup->addChild(formatGroup.release());
 				}
-
-				sampleGroup->addChild(formatGroup.release());
 			}
 
 			imageGroup->addChild(sampleGroup.release());
@@ -1282,78 +1332,87 @@
 			// iterate over depth/stencil formats
 			for (size_t formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++)
 			{
-				const FormatData&			formatData	= formats[formatNdx];
-				VkFormat					format		= formatData.format;
-				const char*					formatName	= formatData.name;
-				const bool					hasDepth	= formatData.hasDepth;
-				const bool					hasStencil	= formatData.hasStencil;
-				VkImageAspectFlags			aspectFlags	= (hasDepth * VK_IMAGE_ASPECT_DEPTH_BIT) |
-														  (hasStencil * VK_IMAGE_ASPECT_STENCIL_BIT);
+				const FormatData&			formatData					= formats[formatNdx];
+				VkFormat					format						= formatData.format;
+				const char*					formatName					= formatData.name;
+				const bool					hasDepth					= formatData.hasDepth;
+				const bool					hasStencil					= formatData.hasStencil;
+				VkImageAspectFlags			aspectFlags					= (hasDepth * VK_IMAGE_ASPECT_DEPTH_BIT) |
+																		  (hasStencil * VK_IMAGE_ASPECT_STENCIL_BIT);
+				const int					separateLayoutsLoopCount	= (hasDepth && hasStencil) ? 2 : 1;
 
-				// create test group for format
-				de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, formatName, formatName));
-
-				for (size_t resolveModeNdx = 0; resolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); resolveModeNdx++)
+				for (int separateDepthStencilLayouts = 0; separateDepthStencilLayouts < separateLayoutsLoopCount; ++separateDepthStencilLayouts)
 				{
-					ResolveModeData& mode = resolveModes[resolveModeNdx];
+					const bool			useSeparateDepthStencilLayouts	= bool(separateDepthStencilLayouts);
+					const std::string	groupName						= std::string(formatName) + ((useSeparateDepthStencilLayouts) ? "_separate_layouts" : "");
 
-					if (hasDepth)
+					// create test group for format
+					de::MovePtr<tcu::TestCaseGroup> formatGroup(new tcu::TestCaseGroup(testCtx, groupName.c_str(), groupName.c_str()));
+
+					for (size_t resolveModeNdx = 0; resolveModeNdx < DE_LENGTH_OF_ARRAY(resolveModes); resolveModeNdx++)
 					{
-						std::string	name			= "depth_" + mode.name;
-						const char*	testName		= name.c_str();
-						float		expectedValue	= depthExpectedValue[resolveModeNdx][sampleCountNdx];
-						const TestConfig testConfig =
-						{
-							format,
-							layeredTextureTestData.width,
-							layeredTextureTestData.height,
-							layeredTextureTestData.imageLayers,
-							3u,
-							0u,
-							layeredTextureTestData.renderArea,
-							aspectFlags,
-							sampleCount,
-							mode.flag,
-							VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR,
-							VB_DEPTH,
-							layeredTextureTestData.clearValue,
-							expectedValue,
-							0u
-						};
-						formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
-					}
+						ResolveModeData& mode = resolveModes[resolveModeNdx];
 
-					// there is no average resolve mode for stencil - go to next iteration
-					if (mode.flag == VK_RESOLVE_MODE_AVERAGE_BIT_KHR)
-						continue;
-
-					if (hasStencil)
-					{
-						std::string	name			= "stencil_" + mode.name;
-						const char*	testName		= name.c_str();
-						deUint8		expectedValue	= stencilExpectedValue[resolveModeNdx][sampleCountNdx];
-						const TestConfig testConfig =
+						if (hasDepth)
 						{
-							format,
-							layeredTextureTestData.width,
-							layeredTextureTestData.height,
-							layeredTextureTestData.imageLayers,
-							3u,
-							0u,
-							layeredTextureTestData.renderArea,
-							aspectFlags,
-							sampleCount,
-							VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR,
-							mode.flag,
-							VB_STENCIL,
-							layeredTextureTestData.clearValue,
-							0.0f,
-							expectedValue
-						};
-						formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
+							std::string	name			= "depth_" + mode.name;
+							const char*	testName		= name.c_str();
+							float		expectedValue	= depthExpectedValue[resolveModeNdx][sampleCountNdx];
+							const TestConfig testConfig =
+							{
+								format,
+								layeredTextureTestData.width,
+								layeredTextureTestData.height,
+								layeredTextureTestData.imageLayers,
+								3u,
+								0u,
+								layeredTextureTestData.renderArea,
+								aspectFlags,
+								sampleCount,
+								mode.flag,
+								VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR,
+								VB_DEPTH,
+								layeredTextureTestData.clearValue,
+								expectedValue,
+								0u,
+								useSeparateDepthStencilLayouts
+							};
+							formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
+						}
+
+						// there is no average resolve mode for stencil - go to next iteration
+						if (mode.flag == VK_RESOLVE_MODE_AVERAGE_BIT_KHR)
+							continue;
+
+						if (hasStencil)
+						{
+							std::string	name			= "stencil_" + mode.name;
+							const char*	testName		= name.c_str();
+							deUint8		expectedValue	= stencilExpectedValue[resolveModeNdx][sampleCountNdx];
+							const TestConfig testConfig =
+							{
+								format,
+								layeredTextureTestData.width,
+								layeredTextureTestData.height,
+								layeredTextureTestData.imageLayers,
+								3u,
+								0u,
+								layeredTextureTestData.renderArea,
+								aspectFlags,
+								sampleCount,
+								VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR,
+								mode.flag,
+								VB_STENCIL,
+								layeredTextureTestData.clearValue,
+								0.0f,
+								expectedValue,
+								useSeparateDepthStencilLayouts
+							};
+							formatGroup->addChild(new DSResolveTestInstance(testCtx, tcu::NODETYPE_SELF_VALIDATE, testName, testName, testConfig));
+						}
 					}
+					sampleGroup->addChild(formatGroup.release());
 				}
-				sampleGroup->addChild(formatGroup.release());
 			}
 			imageGroup->addChild(sampleGroup.release());
 		}
diff --git a/external/vulkancts/mustpass/master/vk-default-no-waivers.txt b/external/vulkancts/mustpass/master/vk-default-no-waivers.txt
index dab01dc..8bce20d 100644
--- a/external/vulkancts/mustpass/master/vk-default-no-waivers.txt
+++ b/external/vulkancts/mustpass/master/vk-default-no-waivers.txt
Binary files differ
diff --git a/external/vulkancts/mustpass/master/vk-default.txt b/external/vulkancts/mustpass/master/vk-default.txt
index b7d2c08..251566c 100644
--- a/external/vulkancts/mustpass/master/vk-default.txt
+++ b/external/vulkancts/mustpass/master/vk-default.txt
Binary files differ
diff --git a/external/vulkancts/scripts/src/extensions_data.txt b/external/vulkancts/scripts/src/extensions_data.txt
index 835e8b8..abeda1f 100644
--- a/external/vulkancts/scripts/src/extensions_data.txt
+++ b/external/vulkancts/scripts/src/extensions_data.txt
@@ -70,4 +70,5 @@
 VK_KHR_timeline_semaphore					DEVICE
 VK_KHR_shader_clock							DEVICE
 VK_KHR_spirv_1_4							DEVICE
-VK_KHR_shader_subgroup_extended_types		DEVICE
\ No newline at end of file
+VK_KHR_shader_subgroup_extended_types		DEVICE
+VK_KHR_separate_depth_stencil_layouts		DEVICE
diff --git a/external/vulkancts/scripts/src/vulkan_core.h b/external/vulkancts/scripts/src/vulkan_core.h
index 0fa5eff..b60eb6e 100644
--- a/external/vulkancts/scripts/src/vulkan_core.h
+++ b/external/vulkancts/scripts/src/vulkan_core.h
@@ -505,6 +505,9 @@
     VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,
     VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,
+    VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = 1000241000,
+    VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = 1000241001,
+    VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = 1000241002,
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,
     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = 1000244001,
     VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,
@@ -981,6 +984,10 @@
     VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,
     VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = 1000164003,
     VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,
+    VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = 1000241000,
+    VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = 1000241001,
+    VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000241002,
+    VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000241003,
     VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,
     VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
@@ -6484,6 +6491,30 @@
 
 
 
+#define VK_KHR_separate_depth_stencil_layouts 1
+#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1
+#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"
+typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkBool32           separateDepthStencilLayouts;
+} VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
+
+typedef struct VkAttachmentReferenceStencilLayoutKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkImageLayout      stencilLayout;
+} VkAttachmentReferenceStencilLayoutKHR;
+
+typedef struct VkAttachmentDescriptionStencilLayoutKHR {
+    VkStructureType    sType;
+    void*              pNext;
+    VkImageLayout      stencilInitialLayout;
+    VkImageLayout      stencilFinalLayout;
+} VkAttachmentDescriptionStencilLayoutKHR;
+
+
+
 #define VK_KHR_uniform_buffer_standard_layout 1
 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1
 #define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"