tests: Ensure deprecated device layers are ignored.

LX535 / MI-76
For backwards compatibility, a device-layer list may still be passed to vkCreateDevice, but must be ignored, and not trigger any errors.
Change-Id: I00000000000000decaf15bad0000000000000076

diff --git a/tests/loader_validation_tests.cpp b/tests/loader_validation_tests.cpp
index cd35266..4a62ce0 100644 (file)
--- a/tests/loader_validation_tests.cpp
+++ b/tests/loader_validation_tests.cpp
@@ -184,6 +184,90 @@ TEST(CreateDevice, ExtensionNotPresent)
     }
 }
 
+// LX535 / MI-76: Device layers are deprecated.
+// For backwards compatibility, they are allowed, but must be ignored.
+// Ensure that no errors occur if a bogus device layer list is passed to vkCreateDevice.
+TEST(CreateDevice, LX535_IgnoreDeviceLayers)
+{
+    VkInstanceCreateInfo const instanceInfo =
+    {
+        VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // sType
+        nullptr, // pNext
+        0,       // flags
+        nullptr, // pApplicationInfo
+        0,       // enabledLayerCount
+        nullptr, // ppEnabledLayerNames
+        0,       // enabledExtensionCount
+        nullptr  // ppEnabledExtensionNames
+    };
+
+    VkInstance instance = VK_NULL_HANDLE;
+    VkResult result = vkCreateInstance(&instanceInfo, VK_NULL_HANDLE, &instance);
+    ASSERT_EQ(result, VK_SUCCESS);
+
+    uint32_t physicalCount = 0;
+    result = vkEnumeratePhysicalDevices(instance, &physicalCount, nullptr);
+    ASSERT_EQ(result, VK_SUCCESS);
+    ASSERT_GT(physicalCount, 0u);
+
+    std::unique_ptr<VkPhysicalDevice[]> physical(new VkPhysicalDevice[physicalCount]);
+    result = vkEnumeratePhysicalDevices(instance, &physicalCount, physical.get());
+    ASSERT_EQ(result, VK_SUCCESS);
+    ASSERT_GT(physicalCount, 0u);
+
+    for(uint32_t p = 0; p < physicalCount; ++p)
+    {
+        uint32_t familyCount = 0;
+        vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, nullptr);
+        ASSERT_EQ(result, VK_SUCCESS);
+        ASSERT_GT(familyCount, 0u);
+
+        std::unique_ptr<VkQueueFamilyProperties[]> family(new VkQueueFamilyProperties[familyCount]);
+        vkGetPhysicalDeviceQueueFamilyProperties(physical[p], &familyCount, family.get());
+        ASSERT_EQ(result, VK_SUCCESS);
+        ASSERT_GT(familyCount, 0u);
+
+        for(uint32_t q = 0; q < familyCount; ++q)
+        {
+            if(~family[q].queueFlags & VK_QUEUE_GRAPHICS_BIT)
+            {
+                continue;
+            }
+
+            float const priorities[] = {0.0f}; // Temporary required due to Microsoft compiler bug.
+            VkDeviceQueueCreateInfo queueInfo[1] =
+            {
+                VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
+                nullptr,   // pNext
+                0,         // flags
+                q,         // queueFamilyIndex
+                1,         // queueCount
+                priorities // priorities
+            };
+
+            const char* layer_names[] = {"LAYER1", "LAYER2"};  // bogus layer names
+
+            VkDeviceCreateInfo const deviceInfo =
+            {
+                VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType
+                nullptr,       // pNext
+                0,             // flags
+                1,             // queueCreateInfoCount
+                queueInfo,     // pQueueCreateInfos
+                2,             // enabledLayerCount
+                layer_names,   // ppEnabledLayerNames      (deprecated parameter... must be ignored)
+                0,             // enabledExtensionCount
+                nullptr,       // ppEnabledExtensionNames
+                nullptr        // pEnabledFeatures
+            };
+
+            VkDevice device;
+            result = vkCreateDevice(physical[p], &deviceInfo, nullptr, &device);
+            ASSERT_EQ(result, VK_SUCCESS);
+        }
+    }
+}
+
 int main(int argc, char **argv)
 {
     int result;