commit f1d8a4aac2334681ba39e4f00178e6367f6eabdc
author Cort Stratton <cort@google.com> Sat Jan 28 14:17:04 2017 -0800
committer Cort <cdwfs@users.noreply.github.com> Tue Feb 14 14:22:47 2017 -0800
tree cd94f90c32f6445fee63ee359b773bff4cb5d381
parent c21601bb761a6cd9ad40219a4ccefb41b63cf122

tests: Add VU 792,804 to BindInvalidMemory

tests/layer_validation_tests.cpp

diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 2ee3195..670b7ca 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -2529,7 +2529,7 @@
     image_create_info.mipLevels = 1;
     image_create_info.arrayLayers = 1;
     image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
-    image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
+    image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
     image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
     image_create_info.flags = 0;
 
@@ -2631,6 +2631,85 @@
         vkDestroyImage(device(), image, NULL);
         vkDestroyBuffer(device(), buffer, NULL);
     }
+
+    // Try to bind memory to an image created with sparse memory flags
+    {
+        VkImageCreateInfo sparse_image_create_info = image_create_info;
+        sparse_image_create_info.flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
+        VkImageFormatProperties image_format_properties = {};
+        err = vkGetPhysicalDeviceImageFormatProperties(m_device->phy().handle(), sparse_image_create_info.format,
+                                                       sparse_image_create_info.imageType, sparse_image_create_info.tiling,
+                                                       sparse_image_create_info.usage, sparse_image_create_info.flags,
+                                                       &image_format_properties);
+        if (!m_device->phy().features().sparseResidencyImage2D || err == VK_ERROR_FORMAT_NOT_SUPPORTED) {
+            // most likely means sparse formats aren't supported here; skip this test.
+        } else {
+            ASSERT_VK_SUCCESS(err);
+            if (image_format_properties.maxExtent.width == 0) {
+                printf("sparse image format not supported; skipped.\n");
+                return;
+            } else {
+                VkImage sparse_image = VK_NULL_HANDLE;
+                err = vkCreateImage(m_device->device(), &sparse_image_create_info, NULL, &sparse_image);
+                ASSERT_VK_SUCCESS(err);
+                VkMemoryRequirements sparse_mem_reqs = {};
+                vkGetImageMemoryRequirements(m_device->device(), sparse_image, &sparse_mem_reqs);
+                if (sparse_mem_reqs.memoryTypeBits != 0) {
+                    VkMemoryAllocateInfo sparse_mem_alloc = {};
+                    sparse_mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+                    sparse_mem_alloc.pNext = NULL;
+                    sparse_mem_alloc.allocationSize = sparse_mem_reqs.size;
+                    sparse_mem_alloc.memoryTypeIndex = 0;
+                    pass = m_device->phy().set_memory_type(sparse_mem_reqs.memoryTypeBits, &sparse_mem_alloc, 0);
+                    ASSERT_TRUE(pass);
+                    VkDeviceMemory sparse_mem = VK_NULL_HANDLE;
+                    err = vkAllocateMemory(m_device->device(), &sparse_mem_alloc, NULL, &sparse_mem);
+                    ASSERT_VK_SUCCESS(err);
+                    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_00804);
+                    err = vkBindImageMemory(m_device->device(), sparse_image, sparse_mem, 0);
+                    // This may very well return an error.
+                    (void)err;
+                    m_errorMonitor->VerifyFound();
+                    vkFreeMemory(m_device->device(), sparse_mem, NULL);
+                }
+                vkDestroyImage(m_device->device(), sparse_image, NULL);
+            }
+        }
+    }
+
+    // Try to bind memory to a buffer created with sparse memory flags
+    {
+        VkBufferCreateInfo sparse_buffer_create_info = buffer_create_info;
+        sparse_buffer_create_info.flags |= VK_IMAGE_CREATE_SPARSE_BINDING_BIT;
+        if (!m_device->phy().features().sparseResidencyBuffer) {
+            // most likely means sparse formats aren't supported here; skip this test.
+        } else {
+            VkBuffer sparse_buffer = VK_NULL_HANDLE;
+            err = vkCreateBuffer(m_device->device(), &sparse_buffer_create_info, NULL, &sparse_buffer);
+            ASSERT_VK_SUCCESS(err);
+            VkMemoryRequirements sparse_mem_reqs = {};
+            vkGetBufferMemoryRequirements(m_device->device(), sparse_buffer, &sparse_mem_reqs);
+            if (sparse_mem_reqs.memoryTypeBits != 0) {
+                VkMemoryAllocateInfo sparse_mem_alloc = {};
+                sparse_mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
+                sparse_mem_alloc.pNext = NULL;
+                sparse_mem_alloc.allocationSize = sparse_mem_reqs.size;
+                sparse_mem_alloc.memoryTypeIndex = 0;
+                pass = m_device->phy().set_memory_type(sparse_mem_reqs.memoryTypeBits, &sparse_mem_alloc, 0);
+                ASSERT_TRUE(pass);
+                VkDeviceMemory sparse_mem = VK_NULL_HANDLE;
+                err = vkAllocateMemory(m_device->device(), &sparse_mem_alloc, NULL, &sparse_mem);
+                ASSERT_VK_SUCCESS(err);
+                m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, VALIDATION_ERROR_00792);
+                err = vkBindBufferMemory(m_device->device(), sparse_buffer, sparse_mem, 0);
+                // This may very well return an error.
+                (void)err;
+                m_errorMonitor->VerifyFound();
+                vkFreeMemory(m_device->device(), sparse_mem, NULL);
+            }
+            vkDestroyBuffer(m_device->device(), sparse_buffer, NULL);
+        }
+    }
 }
 
 TEST_F(VkLayerTest, BindMemoryToDestroyedObject) {