Merge vk-gl-cts/vulkan-cts-1.3.4 into vk-gl-cts/vulkan-cts-1.3.5

Change-Id: I5a62110ddac5f402801312208da7eec8d0d6aae5

diff --cc android/cts/main/vk-master-2022-03-01/pipeline.txt
Simple merge

diff --cc android/cts/main/vk-master/pipeline/pipeline-library.txt
Simple merge

diff --cc external/vulkancts/modules/vulkan/pipeline/vktPipelineLibraryTests.cpp
Simple merge

diff --cc external/vulkancts/modules/vulkan/pipeline/vktPipelineSamplerBorderSwizzleTests.cpp
Simple merge

diff --cc external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp
index 00da7dd,d775a41..32b643a
--- 1/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp
--- 2/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp
+++ b/external/vulkancts/modules/vulkan/wsi/vktWsiSurfaceTests.cpp
@@@ -959,64 -949,73 +959,74 @@@ tcu::TestStatus querySurfacePresentMode
  
  tcu::TestStatus querySurfacePresentModes2TestSurfaceless (Context& context, Type wsiType)
  {
-       tcu::TestLog&                                   log                             = context.getTestContext().getLog();
-       tcu::ResultCollector                    results                 (log);
+       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<VkSurfaceKHR>                                              surface                         (createSurface(instHelper.vki, instHelper.instance, wsiType, native.getDisplay(), native.getWindow()));
++      const Unique<VkSurfaceKHR>                                              surface                         (createSurface(instHelper.vki, instHelper.instance, wsiType, native.getDisplay(), native.getWindow(), context.getTestContext().getCommandLine()));
+       const VkSurfaceKHR                                                              nullSurface                     = 0;
+       const vector<VkPhysicalDevice>                                  physicalDevices         = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
+       const std::vector<vk::VkExtensionProperties>    deviceExtensions        (enumerateDeviceExtensionProperties(instHelper.vki, context.getPhysicalDevice(), 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 };
 +
-       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(), context.getTestContext().getCommandLine()));
-       const VkSurfaceKHR                              nullSurface             = 0;
-       const vector<VkPhysicalDevice>  physicalDevices = enumeratePhysicalDevices(instHelper.vki, instHelper.instance);
-       const std::vector<VkExtensionProperties>        deviceExtensions(enumerateDeviceExtensionProperties(instHelper.vki, context.getPhysicalDevice(), DE_NULL));
        if (!isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_full_screen_exclusive")))
-               TCU_THROW(NotSupportedError, "Extension VK_EXT_full_screen_exclusive not supported");
+               return tcu::TestStatus(QP_TEST_RESULT_NOT_SUPPORTED, "Extension VK_EXT_full_screen_exclusive not supported");
  
-       for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
+       // Ensure "VK_GOOGLE_surfaceless_query" extension's spec version is at least 2
        {
-               if (isSupportedByAnyQueue(instHelper.vki, physicalDevices[deviceNdx], *surface))
-               {
-                       const VkPhysicalDeviceSurfaceInfo2KHR   surfaceInfo =
-                       {
-                               VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
-                               DE_NULL,
-                               *surface
-                       };
-                       const VkPhysicalDeviceSurfaceInfo2KHR   nullSurfaceInfo =
-                       {
-                               VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
-                               DE_NULL,
-                               nullSurface
-                       };
-                       deUint32        numModesSurface = 0;
-                       deUint32        numModesNull    = 0;
+               deUint32                                                                        propertyCount = 0u;
+               std::vector<vk::VkExtensionProperties>          extensionsProperties;
+               vk::VkResult                                                            extensionResult;
  
-                       VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModes2EXT(physicalDevices[deviceNdx], &surfaceInfo, &numModesSurface, DE_NULL));
-                       VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModes2EXT(physicalDevices[deviceNdx], &nullSurfaceInfo, &numModesNull, DE_NULL));
+               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);
  
-                       if (numModesSurface != numModesNull)
-                       {
-                               results.fail("Number of modes does not match");
-                               continue;
-                       }
+               extensionsProperties.resize(propertyCount);
  
-                       vector<VkPresentModeKHR>        modesSurface(numModesSurface + 1);
-                       vector<VkPresentModeKHR>        modesNull(numModesSurface + 1);
+               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);
  
-                       if (numModesSurface > 0)
+               for (const auto& property : extensionsProperties)
+               {
+                       if (property.extensionName == extensionName)
                        {
-                               VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModes2EXT(physicalDevices[deviceNdx], &surfaceInfo, &numModesSurface, &modesSurface[0]));
-                               VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModes2EXT(physicalDevices[deviceNdx], &nullSurfaceInfo, &numModesSurface, &modesNull[0]));
+                               if (property.specVersion < 2)
+                                       return tcu::TestStatus(QP_TEST_RESULT_NOT_SUPPORTED, "VK_GOOGLE_surfaceless_query is version 1. Need version 2 or higher");
+                               break;
                        }
+               }
+       }
  
-                       modesSurface.pop_back();
-                       modesNull.pop_back();
+       for (size_t deviceNdx = 0; deviceNdx < physicalDevices.size(); ++deviceNdx)
+       {
+               const VkPhysicalDeviceSurfaceInfo2KHR   nullSurfaceInfo =
+               {
+                       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
+                       DE_NULL,
+                       nullSurface
+               };
+               deUint32        numModesNull    = 0u;
+ 
+               VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModes2EXT(physicalDevices[deviceNdx], &nullSurfaceInfo, &numModesNull, DE_NULL));
+ 
+               if (numModesNull == 0u)
+                       continue;
+ 
+               vector<VkPresentModeKHR>        modesNull(numModesNull);
  
-                       for (deUint32 i = 0; i < modesSurface.size(); i++)
+               VK_CHECK(instHelper.vki.getPhysicalDeviceSurfacePresentModes2EXT(physicalDevices[deviceNdx], &nullSurfaceInfo, &numModesNull, &modesNull[0]));
+ 
+               for (deUint32 i = 0; i < modesNull.size(); i++)
+               {
+                       if (std::find(validPresentModes.begin(), validPresentModes.end(), modesNull[i]) == validPresentModes.end())
                        {
-                               if (modesSurface[i] != modesNull[i])
-                               {
-                                       results.fail("Present modes mismatch");
-                               }
+                               std::string error_string        = std::string("Present mode mismatch with mode: ") + getPresentModeKHRName(modesNull[i]);
+                               results.fail(error_string);
+                               break;
                        }
                }
        }

diff --cc external/vulkancts/mustpass/main/vk-default/pipeline/pipeline-library.txt
Simple merge