Merge vk-gl-cts/master into vk-gl-cts/vulkan-cts-next-dev

Change-Id: Id2cecd1c5c13a7947ba93273b432d86522088130

diff --combined external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
index 300efed,70fbb7d..2a14a52
--- 1/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
--- 2/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
@@@ -59,6 -59,8 +59,8 @@@ namespace ap
  namespace
  {
  
+ #include "vkApiExtensionDependencyInfo.inl"
+ 
  using namespace vk;
  using std::vector;
  using std::set;
@@@ -728,7 -730,6 +730,7 @@@ void checkDeviceExtensions (tcu::Result
                "VK_KHR_display_swapchain",
                "VK_KHR_sampler_mirror_clamp_to_edge",
                "VK_KHR_shader_draw_parameters",
 +              "VK_KHR_shader_float_controls",
                "VK_KHR_maintenance1",
                "VK_KHR_push_descriptor",
                "VK_KHR_descriptor_update_template",
@@@ -761,7 -762,6 +763,7 @@@
                "VK_KHR_draw_indirect_count",
                "VK_KHR_create_renderpass2",
                "VK_KHR_driver_properties",
 +              "VK_KHR_swapchain_mutable_format",
                "VK_KHR_shader_atomic_int64",
                "VK_KHR_vulkan_memory_model",
        };
@@@ -770,6 -770,38 +772,38 @@@
        checkDuplicateExtensions(results, extensions);
  }
  
+ void checkInstanceExtensionDependencies(tcu::ResultCollector& results,
+                                                                               int dependencyLength,
+                                                                               const std::pair<const char*, const char*>* dependencies,
+                                                                               const vector<VkExtensionProperties>& extensionProperties)
+ {
+       for (int ndx = 0; ndx < dependencyLength; ndx++)
+       {
+               if (isExtensionSupported(extensionProperties, RequiredExtension(dependencies[ndx].first)) &&
+                       !isExtensionSupported(extensionProperties, RequiredExtension(dependencies[ndx].second)))
+               {
+                       results.fail("Extension " + string(dependencies[ndx].first) + " is missing dependency: " + string(dependencies[ndx].second));
+               }
+       }
+ }
+ 
+ void checkDeviceExtensionDependencies(tcu::ResultCollector& results,
+                                                                         int dependencyLength,
+                                                                         const std::pair<const char*, const char*>* dependencies,
+                                                                         const vector<VkExtensionProperties>& instanceExtensionProperties,
+                                                                         const vector<VkExtensionProperties>& deviceExtensionProperties)
+ {
+       for (int ndx = 0; ndx < dependencyLength; ndx++)
+       {
+               if (isExtensionSupported(deviceExtensionProperties, RequiredExtension(dependencies[ndx].first)) &&
+                       !isExtensionSupported(deviceExtensionProperties, RequiredExtension(dependencies[ndx].second)) &&
+                       !isExtensionSupported(instanceExtensionProperties, RequiredExtension(dependencies[ndx].second)))
+               {
+                       results.fail("Extension " + string(dependencies[ndx].first) + " is missing dependency: " + string(dependencies[ndx].second));
+               }
+       }
+ }
+ 
  tcu::TestStatus enumerateInstanceLayers (Context& context)
  {
        TestLog&                                                log                                     = context.getTestContext().getLog();
@@@ -809,6 -841,19 +843,19 @@@ tcu::TestStatus enumerateInstanceExtens
  
                checkInstanceExtensions(results, extensionNames);
                CheckEnumerateInstanceExtensionPropertiesIncompleteResult()(context, results, properties.size());
+ 
+               if (context.contextSupports(vk::ApiVersion(1, 1, 0)))
+               {
+                       checkInstanceExtensionDependencies(results,
+                                                                                          DE_LENGTH_OF_ARRAY(instanceExtensionDependencies_1_1),
+                                                                                          instanceExtensionDependencies_1_1, properties);
+               }
+               else if (context.contextSupports(vk::ApiVersion(1, 0, 0)))
+               {
+                       checkInstanceExtensionDependencies(results,
+                                                                                          DE_LENGTH_OF_ARRAY(instanceExtensionDependencies_1_0),
+                                                                                          instanceExtensionDependencies_1_0, properties);
+               }
        }
  
        {
@@@ -903,19 -948,37 +950,37 @@@ tcu::TestStatus enumerateDeviceExtensio
        tcu::ResultCollector    results (log);
  
        {
-               const ScopedLogSection                          section         (log, "Global", "Global Extensions");
-               const vector<VkExtensionProperties>     properties      = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL);
-               vector<string>                                          extensionNames;
+               const ScopedLogSection                          section                                         (log, "Global", "Global Extensions");
+               const vector<VkExtensionProperties>     instanceExtensionProperties     = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
+               const vector<VkExtensionProperties>     deviceExtensionProperties       = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL);
+               vector<string>                                          deviceExtensionNames;
  
-               for (size_t ndx = 0; ndx < properties.size(); ndx++)
+               for (size_t ndx = 0; ndx < deviceExtensionProperties.size(); ndx++)
                {
-                       log << TestLog::Message << ndx << ": " << properties[ndx] << TestLog::EndMessage;
+                       log << TestLog::Message << ndx << ": " << deviceExtensionProperties[ndx] << TestLog::EndMessage;
  
-                       extensionNames.push_back(properties[ndx].extensionName);
+                       deviceExtensionNames.push_back(deviceExtensionProperties[ndx].extensionName);
                }
  
-               checkDeviceExtensions(results, extensionNames);
-               CheckEnumerateDeviceExtensionPropertiesIncompleteResult()(context, results, properties.size());
+               checkDeviceExtensions(results, deviceExtensionNames);
+               CheckEnumerateDeviceExtensionPropertiesIncompleteResult()(context, results, deviceExtensionProperties.size());
+ 
+               if (context.contextSupports(vk::ApiVersion(1, 1, 0)))
+               {
+                       checkDeviceExtensionDependencies(results,
+                                                                                        DE_LENGTH_OF_ARRAY(deviceExtensionDependencies_1_1),
+                                                                                        deviceExtensionDependencies_1_1,
+                                                                                        instanceExtensionProperties,
+                                                                                        deviceExtensionProperties);
+               }
+               else if (context.contextSupports(vk::ApiVersion(1, 0, 0)))
+               {
+                       checkDeviceExtensionDependencies(results,
+                                                                                        DE_LENGTH_OF_ARRAY(deviceExtensionDependencies_1_0),
+                                                                                        deviceExtensionDependencies_1_0,
+                                                                                        instanceExtensionProperties,
+                                                                                        deviceExtensionProperties);
+               }
        }
  
        {
@@@ -2680,32 -2743,6 +2745,32 @@@ string toString (const VkPhysicalDevice
        return s.str();
  }
  
 +string toString (const VkPhysicalDeviceFloatControlsPropertiesKHR& value)
 +{
 +      std::ostringstream      s;
 +      s << "VkPhysicalDeviceFloatControlsPropertiesKHR = {\n";
 +      s << "\tsType = " << value.sType << '\n';
 +      s << "\tseparateDenormSettings = " << value.separateDenormSettings << '\n';
 +      s << "\tseparateRoundingModeSettings = " << value.separateRoundingModeSettings << '\n';
 +      s << "\tshaderSignedZeroInfNanPreserveFloat16 = " << value.shaderSignedZeroInfNanPreserveFloat16 << '\n';
 +      s << "\tshaderSignedZeroInfNanPreserveFloat32 = " << value.shaderSignedZeroInfNanPreserveFloat32 << '\n';
 +      s << "\tshaderSignedZeroInfNanPreserveFloat64 = " << value.shaderSignedZeroInfNanPreserveFloat64 << '\n';
 +      s << "\tshaderDenormPreserveFloat16 = " << value.shaderDenormPreserveFloat16 << '\n';
 +      s << "\tshaderDenormPreserveFloat32 = " << value.shaderDenormPreserveFloat32 << '\n';
 +      s << "\tshaderDenormPreserveFloat64 = " << value.shaderDenormPreserveFloat64 << '\n';
 +      s << "\tshaderDenormFlushToZeroFloat16 = " << value.shaderDenormFlushToZeroFloat16 << '\n';
 +      s << "\tshaderDenormFlushToZeroFloat32 = " << value.shaderDenormFlushToZeroFloat32 << '\n';
 +      s << "\tshaderDenormFlushToZeroFloat64 = " << value.shaderDenormFlushToZeroFloat64 << '\n';
 +      s << "\tshaderRoundingModeRTEFloat16 = " << value.shaderRoundingModeRTEFloat16 << '\n';
 +      s << "\tshaderRoundingModeRTEFloat32 = " << value.shaderRoundingModeRTEFloat32 << '\n';
 +      s << "\tshaderRoundingModeRTEFloat64 = " << value.shaderRoundingModeRTEFloat64 << '\n';
 +      s << "\tshaderRoundingModeRTZFloat16 = " << value.shaderRoundingModeRTZFloat16 << '\n';
 +      s << "\tshaderRoundingModeRTZFloat32 = " << value.shaderRoundingModeRTZFloat32 << '\n';
 +      s << "\tshaderRoundingModeRTZFloat64 = " << value.shaderRoundingModeRTZFloat64 << '\n';
 +      s << '}';
 +      return s.str();
 +}
 +
  string toString (const VkPhysicalDeviceMultiviewFeatures& value)
  {
        std::ostringstream      s;
@@@ -2798,7 -2835,7 +2863,7 @@@ tcu::TestStatus deviceFeatures2 (Contex
        log << TestLog::Message << extFeatures << TestLog::EndMessage;
  
        vector<VkExtensionProperties>   properties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
 -      const bool khr_8bit_storage             = checkExtension(properties,"VK_KHR_8bit_storage");;
 +      const bool khr_8bit_storage             = checkExtension(properties,"VK_KHR_8bit_storage");
        bool khr_16bit_storage                  = true;
        bool khr_multiview                              = true;
        bool deviceProtectedMemory              = true;
@@@ -3184,28 -3221,6 +3249,28 @@@ tcu::TestStatus deviceProperties2 (Cont
                        TCU_FAIL("VkPhysicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors must be at least 32");
                }
        }
 +      if (isExtensionSupported(extensions, RequiredExtension("VK_KHR_shader_float_controls")))
 +      {
 +              VkPhysicalDeviceFloatControlsPropertiesKHR floatControlsProperties[count];
 +
 +              for (int ndx = 0; ndx < count; ++ndx)
 +              {
 +                      deMemset(&floatControlsProperties[ndx], 0xFF, sizeof(VkPhysicalDeviceFloatControlsPropertiesKHR));
 +                      floatControlsProperties[ndx].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR;
 +                      floatControlsProperties[ndx].pNext = DE_NULL;
 +
 +                      extProperties.pNext = &floatControlsProperties[ndx];
 +
 +                      vki.getPhysicalDeviceProperties2(physicalDevice, &extProperties);
 +              }
 +
 +              if (deMemCmp(&floatControlsProperties[0], &floatControlsProperties[1], sizeof(VkPhysicalDeviceFloatControlsPropertiesKHR)) != 0)
 +              {
 +                      TCU_FAIL("Mismatch in VkPhysicalDeviceFloatControlsPropertiesKHR");
 +              }
 +
 +              log << TestLog::Message << toString(floatControlsProperties[0]) << TestLog::EndMessage;
 +      }
  
        return tcu::TestStatus::pass("Querying device properties succeeded");
  }