Merge "RESTRICT AUTOMERGE: Merge remote-tracking branch 'aosp/upstream-vulkan-cts-1.3.1' into android13-tests-dev" into android13-tests-dev

6 files changed, 154 insertions, 61 deletions

diff --git a/external/vulkancts/modules/vulkan/api/vktApiDeviceInitializationTests.cpp b/external/vulkancts/modules/vulkan/api/vktApiDeviceInitializationTests.cpp
index 7790ad308..12dab26e5 100644
--- a/external/vulkancts/modules/vulkan/api/vktApiDeviceInitializationTests.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiDeviceInitializationTests.cpp
@@ -916,18 +916,21 @@ tcu::TestStatus createDeviceWithGlobalPriorityTest (Context& context, bool useKh
 	std::vector<VkQueueFamilyProperties2>					queueFamilyProperties2		(queueFamilyPropertyCount);
 	std::vector<VkQueueFamilyGlobalPriorityPropertiesKHR>	globalPriorityProperties	(queueFamilyPropertyCount);
 
-	for (deUint32 ndx = 0; ndx < queueFamilyPropertyCount; ndx++)
+	if (useKhrGlobalPriority)
 	{
-		globalPriorityProperties[ndx].sType	= VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
-		globalPriorityProperties[ndx].pNext	= DE_NULL;
-		queueFamilyProperties2[ndx].sType	= VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
-		queueFamilyProperties2[ndx].pNext	= &globalPriorityProperties[ndx];
-	}
+		for (deUint32 ndx = 0; ndx < queueFamilyPropertyCount; ndx++)
+		{
+			globalPriorityProperties[ndx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
+			globalPriorityProperties[ndx].pNext = DE_NULL;
+			queueFamilyProperties2[ndx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
+			queueFamilyProperties2[ndx].pNext = &globalPriorityProperties[ndx];
+		}
 
-	instanceDriver.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queueFamilyPropertyCount, queueFamilyProperties2.data());
-	TCU_CHECK((size_t)queueFamilyPropertyCount == queueFamilyProperties2.size());
+		instanceDriver.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queueFamilyPropertyCount, queueFamilyProperties2.data());
+		TCU_CHECK((size_t)queueFamilyPropertyCount == queueFamilyProperties2.size());
+	}
 
-	std::vector<const char*> enabledExtensions = { "VK_EXT_global_priority", "VK_EXT_global_priority_query" };
+	std::vector<const char*> enabledExtensions = { "VK_EXT_global_priority" };
 	if (useKhrGlobalPriority)
 		enabledExtensions = { "VK_KHR_global_priority" };
 
@@ -964,20 +967,20 @@ tcu::TestStatus createDeviceWithGlobalPriorityTest (Context& context, bool useKh
 
 		const VkDeviceCreateInfo		deviceCreateInfo	=
 		{
-			VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,	//sType;
-			&globalPriorityQueryFeatures,			//pNext;
-			(VkDeviceCreateFlags)0u,				//flags;
-			1,										//queueRecordCount;
-			&queueCreateInfo,						//pRequestedQueues;
-			0,										//layerCount;
-			DE_NULL,								//ppEnabledLayerNames;
-			(deUint32)enabledExtensions.size(),		//extensionCount;
-			enabledExtensions.data(),				//ppEnabledExtensionNames;
-			DE_NULL,								//pEnabledFeatures;
+			VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,							//sType;
+			useKhrGlobalPriority ? &globalPriorityQueryFeatures : DE_NULL,	//pNext;
+			(VkDeviceCreateFlags)0u,										//flags;
+			1,																//queueRecordCount;
+			&queueCreateInfo,												//pRequestedQueues;
+			0,																//layerCount;
+			DE_NULL,														//ppEnabledLayerNames;
+			(deUint32)enabledExtensions.size(),								//extensionCount;
+			enabledExtensions.data(),										//ppEnabledExtensionNames;
+			DE_NULL,														//pEnabledFeatures;
 		};
 
 		const bool		mayBeDenied				= globalPriority > VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT;
-		const bool		mustFail				= globalPriority < globalPriorityProperties[0].priorities[0] || globalPriority > globalPriorityProperties[0].priorities[globalPriorityProperties[0].priorityCount - 1];
+		const bool		mustFail				= useKhrGlobalPriority && (globalPriority < globalPriorityProperties[0].priorities[0] || globalPriority > globalPriorityProperties[0].priorities[globalPriorityProperties[0].priorityCount - 1]);
 
 		try
 		{
diff --git a/external/vulkancts/modules/vulkan/binding_model/vktBindingValveMutableTests.cpp b/external/vulkancts/modules/vulkan/binding_model/vktBindingValveMutableTests.cpp
index b67dce5d2..976367a31 100644
--- a/external/vulkancts/modules/vulkan/binding_model/vktBindingValveMutableTests.cpp
+++ b/external/vulkancts/modules/vulkan/binding_model/vktBindingValveMutableTests.cpp
@@ -3959,13 +3959,14 @@ tcu::TestCaseGroup* createDescriptorValveMutableTests (tcu::TestContext& testCtx
 				DescriptorSet::BindingPtrVector setBindings;
 				std::vector<SingleBinding> arrayBindings;
 
-				// Single mutable descriptor as the first binding.
-				setBindings.emplace_back(new SingleBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, mandatoryTypes));
-
-				// Descriptor array as the second binding.
+				// Add single type beyond the mandatory ones.
 				auto arrayBindingDescTypes = mandatoryTypes;
 				arrayBindingDescTypes.push_back(descriptorType);
 
+				// Single mutable descriptor as the first binding.
+				setBindings.emplace_back(new SingleBinding(VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, arrayBindingDescTypes));
+
+				// Descriptor array as the second binding.
 				if (aliasingCase.aliasing)
 				{
 					// With aliasing, the descriptor types rotate in each descriptor.
diff --git a/external/vulkancts/modules/vulkan/robustness/vktRobustnessExtsTests.cpp b/external/vulkancts/modules/vulkan/robustness/vktRobustnessExtsTests.cpp
index f6aa11020..b5fa74d0b 100644
--- a/external/vulkancts/modules/vulkan/robustness/vktRobustnessExtsTests.cpp
+++ b/external/vulkancts/modules/vulkan/robustness/vktRobustnessExtsTests.cpp
@@ -1263,9 +1263,24 @@ void RobustnessExtsTestCase::initPrograms (SourceCollections& programCollection)
 					checks << "    else if (temp == zzzo) temp = " << vecType << "(0);\n";
 
 				// non-volatile value replaced with stored value
-				if (supportsStores(m_data.descriptorType) && !m_data.vol)
+				if (supportsStores(m_data.descriptorType) && !m_data.vol) {
 					checks << "    else if (temp == " << getStoreValue(m_data.descriptorType, numComponents, vecType, bufType) << ") temp = " << vecType << "(0);\n";
 
+					if (m_data.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC || m_data.descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
+
+						for (int mask = (numComponents*numComponents) - 2; mask > 0; mask--) {
+							checks << "    else if (temp == " << vecType << "(";
+							for (int vecIdx = 0; vecIdx < 4; vecIdx++) {
+								if (mask & (1 << vecIdx)) checks << storeValue;
+								else checks << "0";
+
+								if (vecIdx != 3) checks << ",";
+							}
+							checks << ")) temp = " << vecType << "(0);\n";
+						}
+					}
+				}
+
 				// value straddling the boundary, returning a partial vector
 				if (expectedOOB2 != expectedOOB)
 					checks << "    else if (c == inboundcoords && temp == " << expectedOOB2 << ") temp = " << vecType << "(0);\n";
diff --git a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationTimelineSemaphoreTests.cpp b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationTimelineSemaphoreTests.cpp
index 5975df29a..7e7efbaff 100644
--- a/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationTimelineSemaphoreTests.cpp
+++ b/external/vulkancts/modules/vulkan/synchronization/vktSynchronizationTimelineSemaphoreTests.cpp
@@ -427,6 +427,7 @@ public:
 		std::vector<deUint64>								timelineValues;
 		const deUint64										secondInMicroSeconds	= 1000ull * 1000ull * 1000ull;
 		deUint64											startTime;
+		VkResult											result = VK_SUCCESS;
 
 		for (deUint32 i = 0; i < semaphorePtrs.size(); i++)
 		{
@@ -449,7 +450,8 @@ public:
 		do
 		{
 			deUint64	value;
-			VkResult	result	=	vk.getSemaphoreCounterValue(device, semaphores.back(), &value);
+
+			result = vk.getSemaphoreCounterValue(device, semaphores.back(), &value);
 
 			if (result != VK_SUCCESS)
 				break;
@@ -463,12 +465,15 @@ public:
 			}
 
 			if (value > timelineValues.back())
+			{
+				result = VK_ERROR_UNKNOWN;
 				break;
-		} while ((deGetMicroseconds() - startTime) > secondInMicroSeconds);
+			}
+		} while ((deGetMicroseconds() - startTime) < secondInMicroSeconds);
 
 		VK_CHECK(vk.deviceWaitIdle(device));
 
-		if ((deGetMicroseconds() - startTime) < secondInMicroSeconds)
+		if (result != VK_SUCCESS)
 			return tcu::TestStatus::fail("Fail");
 		return tcu::TestStatus::fail("Timeout");
 	}
diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
index dc69ea23d..d8abf0a3f 100644
--- a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
+++ b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
@@ -128,7 +128,8 @@ void checkTextureSupport (Context& context, const Texture2DArrayTestCaseParamete
 		context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
 
 #ifndef CTS_USES_VULKANSC
-	if (testParameters.format == VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 && testParameters.mipmaps && context.getRGBA10X6FormatsFeaturesEXT().formatRgba10x6WithoutYCbCrSampler == VK_FALSE)
+	bool mipmaps = (deLog2Floor32(de::max(testParameters.width, testParameters.height)) + 1) > 1 || testParameters.mipmaps;
+	if (testParameters.format == VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 && mipmaps && context.getRGBA10X6FormatsFeaturesEXT().formatRgba10x6WithoutYCbCrSampler == VK_FALSE)
 		TCU_THROW(NotSupportedError, "formatRgba10x6WithoutYCbCrSampler not supported");
 #endif
 }
diff --git a/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp b/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp
index c4a4fa7fd..4f199bc74 100644
--- a/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp
+++ b/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp
@@ -996,55 +996,123 @@ tcu::TestStatus querySurfacePresentModesTest (Context& context, Type wsiType)
 	return tcu::TestStatus(results.getResult(), results.getMessage());
 }
 
-tcu::TestStatus querySurfacePresentModesTestSurfaceless (Context& context, Type wsiType)
+void checkDeprecatedExtensionGoogleSurfacelessQuery(const vk::InstanceDriver& vk, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, tcu::ResultCollector& result)
 {
-	tcu::TestLog&					log				= context.getTestContext().getLog();
-	tcu::ResultCollector			results			(log);
-
-	const InstanceHelper			instHelper(context, wsiType, vector<string>(1, string("VK_GOOGLE_surfaceless_query")));
-	const NativeObjects				native			(context, instHelper.supportedExtensions, wsiType);
-	const Unique<VkSurfaceKHR>		surface			(createSurface(instHelper.vki, instHelper.instance, wsiType, native.getDisplay(), native.getWindow()));
-	const VkSurfaceKHR				nullSurface		= 0;
-	const vector<VkPhysicalDevice>	physicalDevices	= enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
+	const VkSurfaceKHR				nullSurface		= DE_NULL;
 
-	for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
+	if (isSupportedByAnyQueue(vk, physicalDevice, surface))
 	{
-		if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
+		deUint32	numModesSurface = 0;
+		deUint32	numModesNull	= 0;
+
+		VK_CHECK(vk.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &numModesSurface, DE_NULL));
+		VK_CHECK(vk.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, nullSurface, &numModesNull, DE_NULL));
+
+		if (numModesNull == 0)
+			return;
+
+		// Actual surface needs to have at least the amount of modes that null surface has
+		if (numModesSurface < numModesNull)
 		{
-			deUint32	numModesSurface = 0;
-			deUint32	numModesNull	= 0;
+			result.fail("Number of modes does not match");
+			return;
+		}
 
-			VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModesKHR(physicalDevices[deviceNdx], *surface, &numModesSurface, DE_NULL));
-			VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModesKHR(physicalDevices[deviceNdx], nullSurface, &numModesNull, DE_NULL));
+		vector<VkPresentModeKHR>	modesSurface(numModesSurface);
+		vector<VkPresentModeKHR>	modesNull(numModesNull);
 
-			if (numModesSurface != numModesNull)
+		VK_CHECK(vk.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, &numModesSurface, &modesSurface[0]));
+		VK_CHECK(vk.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, nullSurface, &numModesNull, &modesNull[0]));
+
+		// All modes present in null surface should also be present in actual surface
+		for (deUint32 i = 0; i < modesNull.size(); i++)
+		{
+			if (std::find(modesSurface.begin(), modesSurface.end(), modesNull[i]) == modesSurface.end())
 			{
-				results.fail("Number of modes does not match");
-				continue;
+				std::string error_string	= std::string("Present mode mismatch with mode: ") + getPresentModeKHRName(modesNull[i]);
+				result.fail(error_string);
+				break;
 			}
+		}
+	}
+}
 
-			vector<VkPresentModeKHR>	modesSurface(numModesSurface + 1);
-			vector<VkPresentModeKHR>	modesNull(numModesSurface + 1);
+void checkExtensionGoogleSurfacelessQuery(const vk::InstanceDriver& vk, VkPhysicalDevice physicalDevice, tcu::ResultCollector& result)
+{
+	const VkSurfaceKHR				nullSurface		= DE_NULL;
+	const vector<VkPresentModeKHR>	validPresentModes	{ VK_PRESENT_MODE_FIFO_KHR, VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR };
 
-			if (numModesSurface > 0)
-			{
-				VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModesKHR(physicalDevices[deviceNdx], *surface, &numModesSurface, &modesSurface[0]));
-				VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModesKHR(physicalDevices[deviceNdx], nullSurface, &numModesSurface, &modesNull[0]));
-			}
+	deUint32	numModesNull	= 0;
+	VK_CHECK(vk.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, nullSurface, &numModesNull, DE_NULL));
 
-			modesSurface.pop_back();
-			modesNull.pop_back();
+	if (numModesNull == 0u)
+		return;
 
-			for (deUint32 i = 0; i < modesSurface.size(); i++)
+	vector<VkPresentModeKHR>	modesNull(numModesNull);
+
+	VK_CHECK(vk.getPhysicalDeviceSurfacePresentModesKHR(physicalDevice, nullSurface, &numModesNull, &modesNull[0]));
+
+	for (deUint32 i = 0; i < modesNull.size(); i++)
+	{
+		if (std::find(validPresentModes.begin(), validPresentModes.end(), modesNull[i]) == validPresentModes.end())
+		{
+			std::string error_string	= std::string("Present mode mismatch with mode: ") + getPresentModeKHRName(modesNull[i]);
+			result.fail(error_string);
+			break;
+		}
+	}
+}
+
+tcu::TestStatus querySurfacePresentModesTestSurfaceless (Context& context, Type wsiType)
+{
+	tcu::TestLog&					log						= context.getTestContext().getLog();
+	tcu::ResultCollector			results					(log);
+
+	const std::string				extensionName			= "VK_GOOGLE_surfaceless_query";
+	const InstanceHelper			instHelper				(context, wsiType, vector<string>(1, extensionName), DE_NULL);
+	const NativeObjects				native					(context, instHelper.supportedExtensions, wsiType);
+	const Unique<vk::VkSurfaceKHR>	surface					(createSurface(instHelper.vki, instHelper.instance, wsiType, native.getDisplay(), native.getWindow()));
+
+	deUint32						extensionVersion		= 1u;
+
+	// Get "VK_GOOGLE_surfaceless_query" extension's spec version
+	{
+		deUint32									propertyCount = 0u;
+		std::vector<vk::VkExtensionProperties>		extensionsProperties;
+		vk::VkResult								extensionResult;
+
+		extensionResult = context.getPlatformInterface().enumerateInstanceExtensionProperties(DE_NULL, &propertyCount, DE_NULL);
+		if (extensionResult != vk::VK_SUCCESS)
+			return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Failed to retrieve spec version for extension " + extensionName);
+
+		extensionsProperties.resize(propertyCount);
+
+		extensionResult = context.getPlatformInterface().enumerateInstanceExtensionProperties(DE_NULL, &propertyCount, extensionsProperties.data());
+		if (extensionResult != vk::VK_SUCCESS)
+			return tcu::TestStatus(QP_TEST_RESULT_FAIL, "Failed to retrieve spec version for extension " + extensionName);
+
+		for (const auto& property : extensionsProperties)
+		{
+			if (property.extensionName == extensionName)
 			{
-				if (modesSurface[i] != modesNull[i])
-				{
-					results.fail("Present modes mismatch");
-				}
+				extensionVersion = property.specVersion;
+				break;
 			}
 		}
 	}
 
+	log << TestLog::Message << "Checking spec version " << extensionVersion << " for VK_GOOGLE_surfaceless_query" << TestLog::EndMessage;
+
+	const bool						checkDeprecatedVersion	= extensionVersion < 2;
+	const vector<VkPhysicalDevice>	physicalDevices			= enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
+	for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
+	{
+		if (checkDeprecatedVersion)
+			checkDeprecatedExtensionGoogleSurfacelessQuery(instHelper.vki, physicalDevices[deviceNdx], *surface, results);
+		else
+			checkExtensionGoogleSurfacelessQuery(instHelper.vki, physicalDevices[deviceNdx], results);
+	}
+
 	return tcu::TestStatus(results.getResult(), results.getMessage());
 }