From 52d17b16bb797d3e1669e8829d49278f4af8c48a Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Thu, 22 Jun 2023 12:33:25 -0600 Subject: [PATCH] test: Expand MockICD test coverage --- tests/icd/mock_icd_tests.cpp | 1112 +++++++++++++++++++++++++++++++++++++++++- 1 file changed, 1099 insertions(+), 13 deletions(-) diff --git a/tests/icd/mock_icd_tests.cpp b/tests/icd/mock_icd_tests.cpp index c2fcbf5..4605658 100644 --- a/tests/icd/mock_icd_tests.cpp +++ b/tests/icd/mock_icd_tests.cpp @@ -44,66 +44,1152 @@ void setup_mock_icd_env_vars() { set_environment_var("VK_LOADER_LAYERS_DISABLE", "~all~"); } -// Create an instance & device +// Defines a simple context for tests to use. +// Creates an instance, physical_device, device, and queue + class MockICD : public ::testing::Test { protected: void SetUp() override { setup_mock_icd_env_vars(); + // Create an instance with the latest version & necessary surface extensions + VkResult res = VK_SUCCESS; + VkApplicationInfo app_info{}; + app_info.apiVersion = VK_HEADER_VERSION_COMPLETE; VkInstanceCreateInfo instance_create_info{}; - VkResult res = vkCreateInstance(&instance_create_info, nullptr, &instance); + instance_create_info.pApplicationInfo = &app_info; + std::array extension_to_enable = {"VK_KHR_surface", "VK_KHR_display"}; + instance_create_info.enabledExtensionCount = static_cast(extension_to_enable.size()); + instance_create_info.ppEnabledExtensionNames = extension_to_enable.data(); + res = vkCreateInstance(&instance_create_info, nullptr, &instance); ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(instance, nullptr); uint32_t count = 1; res = vkEnumeratePhysicalDevices(instance, &count, &physical_device); ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + ASSERT_NE(physical_device, nullptr); VkDeviceCreateInfo device_create_info{}; + std::array device_extension_to_enable = {"VK_KHR_swapchain"}; + device_create_info.enabledExtensionCount = static_cast(device_extension_to_enable.size()); + device_create_info.ppEnabledExtensionNames = device_extension_to_enable.data(); res = vkCreateDevice(physical_device, &device_create_info, nullptr, &device); ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(device, nullptr); + + vkGetDeviceQueue(device, 0, 0, &queue); + ASSERT_NE(queue, nullptr); + } + + void TearDown() override { + vkDestroyDevice(device, nullptr); + vkDestroyInstance(instance, nullptr); } - // void TearDown() override {} VkInstance instance{}; VkPhysicalDevice physical_device{}; VkDevice device{}; + VkQueue queue{}; }; -TEST_F(MockICD, Basic) { +/* + * Exercises the following commands: + * vkEnumerateInstanceExtensionProperties + * vkEnumerateInstanceLayerProperties + * vkEnumerateInstanceVersion + * vkCreateInstance + * vkEnumeratePhysicalDevices + * vkEnumeratePhysicalDeviceGroups + * vkEnumerateDeviceExtensionProperties + * vkGetPhysicalDeviceQueueFamilyProperties + * vkGetPhysicalDeviceQueueFamilyProperties2 + * vkCreateDevice + * vkDestroyDevice + * vkDestroyInstance + * vkGetDeviceQueue + * vkGetDeviceQueue2 + */ +TEST_F(MockICD, InitializationFunctions) { setup_mock_icd_env_vars(); + VkResult res = VK_SUCCESS; uint32_t count = 0; - VkResult res = vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr); + res = vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr); ASSERT_EQ(res, VK_SUCCESS); ASSERT_GT(count, 0); std::vector inst_ext_props{count, VkExtensionProperties{}}; res = vkEnumerateInstanceExtensionProperties(nullptr, &count, inst_ext_props.data()); ASSERT_EQ(res, VK_SUCCESS); + // Since we disabled layers, count should stay zero + count = 0; + res = vkEnumerateInstanceLayerProperties(&count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 0); + + uint32_t api_version; + res = vkEnumerateInstanceVersion(&api_version); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(api_version, VK_HEADER_VERSION_COMPLETE); + VkInstanceCreateInfo inst_create_info{}; - VkInstance inst{}; - res = vkCreateInstance(&inst_create_info, nullptr, &inst); + VkInstance instance{}; + res = vkCreateInstance(&inst_create_info, nullptr, &instance); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(instance, nullptr); + + count = 0; + VkPhysicalDevice physical_device; + res = vkEnumeratePhysicalDevices(instance, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + + res = vkEnumeratePhysicalDevices(instance, &count, &physical_device); ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + ASSERT_NE(physical_device, nullptr); - res = vkEnumeratePhysicalDevices(inst, &count, nullptr); + count = 0; + res = vkEnumeratePhysicalDeviceGroups(instance, &count, nullptr); ASSERT_EQ(res, VK_SUCCESS); ASSERT_GT(count, 0); - std::vector phys_devs{count}; - res = vkEnumeratePhysicalDevices(inst, &count, phys_devs.data()); + + VkPhysicalDeviceGroupProperties physical_device_groups; + count = 1; + res = vkEnumeratePhysicalDeviceGroups(instance, &count, &physical_device_groups); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + + count = 0; + res = vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_GT(count, 0); + std::vector device_ext_props{count, VkExtensionProperties{}}; + res = vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &count, device_ext_props.data()); + ASSERT_EQ(res, VK_SUCCESS); + + // Device layers are deprecated, should return number of active layers, which is zero + count = 0; + res = vkEnumerateDeviceLayerProperties(physical_device, &count, nullptr); ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 0); + count = 0; + + vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count, nullptr); + ASSERT_EQ(count, 1); + VkQueueFamilyProperties queue_family_properties{}; + vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &count, &queue_family_properties); + ASSERT_EQ(count, 1); + ASSERT_EQ(queue_family_properties.queueFlags, 1 | 2 | 4 | 8 | 16); + ASSERT_EQ(queue_family_properties.queueCount, 1); + ASSERT_EQ(queue_family_properties.timestampValidBits, 16); + ASSERT_EQ(queue_family_properties.minImageTransferGranularity.width, 1); + ASSERT_EQ(queue_family_properties.minImageTransferGranularity.height, 1); + ASSERT_EQ(queue_family_properties.minImageTransferGranularity.depth, 1); + + vkGetPhysicalDeviceQueueFamilyProperties2(physical_device, &count, nullptr); + ASSERT_EQ(count, 1); + VkQueueFamilyProperties2 queue_family_properties2{}; + vkGetPhysicalDeviceQueueFamilyProperties2(physical_device, &count, &queue_family_properties2); + ASSERT_EQ(count, 1); + ASSERT_EQ(queue_family_properties2.queueFamilyProperties.queueFlags, 1 | 2 | 4 | 8 | 16); + ASSERT_EQ(queue_family_properties2.queueFamilyProperties.queueCount, 1); + ASSERT_EQ(queue_family_properties2.queueFamilyProperties.timestampValidBits, 16); + ASSERT_EQ(queue_family_properties2.queueFamilyProperties.minImageTransferGranularity.width, 1); + ASSERT_EQ(queue_family_properties2.queueFamilyProperties.minImageTransferGranularity.height, 1); + ASSERT_EQ(queue_family_properties2.queueFamilyProperties.minImageTransferGranularity.depth, 1); VkDeviceCreateInfo dev_create_info{}; VkDevice device{}; - res = vkCreateDevice(phys_devs.at(0), &dev_create_info, nullptr, &device); + res = vkCreateDevice(physical_device, &dev_create_info, nullptr, &device); ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(device, nullptr); + + VkQueue queue{}; + vkGetDeviceQueue(device, 0, 0, &queue); + ASSERT_NE(queue, nullptr); + + VkDeviceQueueInfo2 queue_info{}; + vkGetDeviceQueue2(device, &queue_info, &queue); + ASSERT_NE(queue, nullptr); + + vkDestroyDevice(device, nullptr); + vkDestroyInstance(instance, nullptr); } -TEST_F(MockICD, AllocateCommandBuffers) { +/* + * Exercises the following commands: + * vkCreateCommandPool + * vkAllocateCommandBuffers + * vkFreeCommandBuffers + * vkDestroyCommandPool + */ +TEST_F(MockICD, CommandBufferOperations) { + VkResult res = VK_SUCCESS; + VkCommandPoolCreateInfo command_pool_create_info{}; + VkCommandPool command_pool; + res = vkCreateCommandPool(device, &command_pool_create_info, nullptr, &command_pool); + ASSERT_EQ(VK_SUCCESS, res); + VkCommandBufferAllocateInfo command_buffer_allocate_info{}; command_buffer_allocate_info.commandBufferCount = 5; std::array command_buffers; - VkResult res = vkAllocateCommandBuffers(device, &command_buffer_allocate_info, command_buffers.data()); + res = vkAllocateCommandBuffers(device, &command_buffer_allocate_info, command_buffers.data()); ASSERT_EQ(VK_SUCCESS, res); for (const auto& command_buffer : command_buffers) { ASSERT_NE(nullptr, command_buffer); } + + vkFreeCommandBuffers(device, command_pool, 5, command_buffers.data()); + + vkDestroyCommandPool(device, command_pool, nullptr); +} + +VkResult create_surface(VkInstance instance, VkSurfaceKHR& surface) { + VkDisplaySurfaceCreateInfoKHR surf_create_info{}; + return vkCreateDisplayPlaneSurfaceKHR(instance, &surf_create_info, nullptr, &surface); +} + +TEST_F(MockICD, vkGetPhysicalDeviceSurfacePresentModesKHR) { + VkResult res = VK_SUCCESS; + VkSurfaceKHR surface{}; + res = create_surface(instance, surface); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(surface, nullptr); + uint32_t count = 0; + std::array present_modes{}; + res = vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, present_modes.size()); + vkGetPhysicalDeviceSurfacePresentModesKHR(physical_device, surface, &count, present_modes.data()); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(present_modes[0], VK_PRESENT_MODE_IMMEDIATE_KHR); + ASSERT_EQ(present_modes[1], VK_PRESENT_MODE_MAILBOX_KHR); + ASSERT_EQ(present_modes[2], VK_PRESENT_MODE_FIFO_KHR); + ASSERT_EQ(present_modes[3], VK_PRESENT_MODE_FIFO_RELAXED_KHR); + ASSERT_EQ(present_modes[4], VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR); + ASSERT_EQ(present_modes[5], VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR); + vkDestroySurfaceKHR(instance, surface, nullptr); +} + +TEST_F(MockICD, vkGetPhysicalDeviceSurfaceFormatsKHR) { + VkResult res = VK_SUCCESS; + VkSurfaceKHR surface{}; + res = create_surface(instance, surface); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(surface, nullptr); + uint32_t count = 0; + std::array surface_formats{}; + res = vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, surface_formats.size()); + vkGetPhysicalDeviceSurfaceFormatsKHR(physical_device, surface, &count, surface_formats.data()); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(surface_formats[0].format, VK_FORMAT_B8G8R8A8_UNORM); + ASSERT_EQ(surface_formats[0].colorSpace, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR); + ASSERT_EQ(surface_formats[1].format, VK_FORMAT_R8G8B8A8_UNORM); + ASSERT_EQ(surface_formats[1].colorSpace, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR); + vkDestroySurfaceKHR(instance, surface, nullptr); +} + +TEST_F(MockICD, vkGetPhysicalDeviceSurfaceFormats2KHR) { + VkResult res = VK_SUCCESS; + VkSurfaceKHR surface{}; + res = create_surface(instance, surface); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(surface, nullptr); + uint32_t count = 0; + std::array surface_formats2{}; + VkPhysicalDeviceSurfaceInfo2KHR surface_info{}; + surface_info.surface = surface; + res = vkGetPhysicalDeviceSurfaceFormats2KHR(physical_device, &surface_info, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, surface_formats2.size()); + vkGetPhysicalDeviceSurfaceFormats2KHR(physical_device, &surface_info, &count, surface_formats2.data()); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(surface_formats2[0].pNext, nullptr); + ASSERT_EQ(surface_formats2[0].surfaceFormat.format, VK_FORMAT_B8G8R8A8_UNORM); + ASSERT_EQ(surface_formats2[0].surfaceFormat.colorSpace, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR); + ASSERT_EQ(surface_formats2[1].pNext, nullptr); + ASSERT_EQ(surface_formats2[1].surfaceFormat.format, VK_FORMAT_R8G8B8A8_UNORM); + ASSERT_EQ(surface_formats2[1].surfaceFormat.colorSpace, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR); + vkDestroySurfaceKHR(instance, surface, nullptr); +} + +TEST_F(MockICD, vkGetPhysicalDeviceSurfaceSupportKHR) { + VkResult res = VK_SUCCESS; + VkSurfaceKHR surface{}; + res = create_surface(instance, surface); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(surface, nullptr); + VkBool32 supported = false; + res = vkGetPhysicalDeviceSurfaceSupportKHR(physical_device, 0, surface, &supported); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(supported, true); + vkDestroySurfaceKHR(instance, surface, nullptr); +} + +TEST_F(MockICD, vkGetPhysicalDeviceSurfaceCapabilitiesKHR) { + VkResult res = VK_SUCCESS; + VkSurfaceKHR surface{}; + res = create_surface(instance, surface); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(surface, nullptr); + VkSurfaceCapabilitiesKHR surface_capabilities{}; + res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &surface_capabilities); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(surface_capabilities.minImageCount, 1); + ASSERT_EQ(surface_capabilities.currentExtent.width, std::numeric_limits::max()); + ASSERT_EQ(surface_capabilities.currentExtent.height, std::numeric_limits::max()); + ASSERT_EQ(surface_capabilities.minImageExtent.width, 1); + ASSERT_EQ(surface_capabilities.minImageExtent.height, 1); + ASSERT_EQ(surface_capabilities.maxImageArrayLayers, 128); + ASSERT_EQ(surface_capabilities.currentTransform, VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR); + vkDestroySurfaceKHR(instance, surface, nullptr); +} + +TEST_F(MockICD, vkGetPhysicalDeviceSurfaceCapabilities2KHR) { + VkResult res = VK_SUCCESS; + VkSurfaceKHR surface{}; + res = create_surface(instance, surface); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(surface, nullptr); + VkSurfaceCapabilities2KHR surface_capabilities2{}; + VkPhysicalDeviceSurfaceInfo2KHR surface_info{}; + surface_info.surface = surface; + res = vkGetPhysicalDeviceSurfaceCapabilities2KHR(physical_device, &surface_info, &surface_capabilities2); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(surface_capabilities2.surfaceCapabilities.minImageCount, 1); + ASSERT_EQ(surface_capabilities2.surfaceCapabilities.currentExtent.width, std::numeric_limits::max()); + ASSERT_EQ(surface_capabilities2.surfaceCapabilities.currentExtent.height, std::numeric_limits::max()); + ASSERT_EQ(surface_capabilities2.surfaceCapabilities.minImageExtent.width, 1); + ASSERT_EQ(surface_capabilities2.surfaceCapabilities.minImageExtent.height, 1); + ASSERT_EQ(surface_capabilities2.surfaceCapabilities.maxImageArrayLayers, 128); + ASSERT_EQ(surface_capabilities2.surfaceCapabilities.currentTransform, VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR); + vkDestroySurfaceKHR(instance, surface, nullptr); +} + +TEST_F(MockICD, vkGetPhysicalDeviceMemoryProperties) { + VkPhysicalDeviceMemoryProperties memory_properties{}; + vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties); + ASSERT_EQ(memory_properties.memoryTypeCount, 6); + ASSERT_EQ(memory_properties.memoryTypes[0].propertyFlags, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + ASSERT_EQ(memory_properties.memoryTypes[0].heapIndex, 0); + ASSERT_EQ(memory_properties.memoryTypes[5].propertyFlags, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + ASSERT_EQ(memory_properties.memoryTypes[5].heapIndex, 1); + ASSERT_EQ(memory_properties.memoryHeapCount, 2); + ASSERT_EQ(memory_properties.memoryHeaps[0].flags, VK_MEMORY_HEAP_MULTI_INSTANCE_BIT); + ASSERT_EQ(memory_properties.memoryHeaps[0].size, 8000000000); + ASSERT_EQ(memory_properties.memoryHeaps[1].flags, VK_MEMORY_HEAP_DEVICE_LOCAL_BIT); + ASSERT_EQ(memory_properties.memoryHeaps[1].size, 8000000000); +} + +TEST_F(MockICD, vkGetPhysicalDeviceMemoryProperties2) { + VkPhysicalDeviceMemoryProperties2 memory_properties2{}; + vkGetPhysicalDeviceMemoryProperties2(physical_device, &memory_properties2); + ASSERT_EQ(memory_properties2.memoryProperties.memoryTypeCount, 6); + ASSERT_EQ(memory_properties2.memoryProperties.memoryTypes[0].propertyFlags, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT); + ASSERT_EQ(memory_properties2.memoryProperties.memoryTypes[0].heapIndex, 0); + ASSERT_EQ(memory_properties2.memoryProperties.memoryTypes[5].propertyFlags, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT); + ASSERT_EQ(memory_properties2.memoryProperties.memoryTypes[5].heapIndex, 1); + ASSERT_EQ(memory_properties2.memoryProperties.memoryHeapCount, 2); + ASSERT_EQ(memory_properties2.memoryProperties.memoryHeaps[0].flags, VK_MEMORY_HEAP_MULTI_INSTANCE_BIT); + ASSERT_EQ(memory_properties2.memoryProperties.memoryHeaps[0].size, 8000000000); + ASSERT_EQ(memory_properties2.memoryProperties.memoryHeaps[1].flags, VK_MEMORY_HEAP_DEVICE_LOCAL_BIT); + ASSERT_EQ(memory_properties2.memoryProperties.memoryHeaps[1].size, 8000000000); +} + +TEST_F(MockICD, vkGetPhysicalDeviceFeatures) { + VkPhysicalDeviceFeatures features{}; + vkGetPhysicalDeviceFeatures(physical_device, &features); + // Make sure the first and last elements are set to true + ASSERT_EQ(features.robustBufferAccess, true); + ASSERT_EQ(features.inheritedQueries, true); +} + +TEST_F(MockICD, vkGetPhysicalDeviceFeatures2) { + VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptor_indexing_features{}; + descriptor_indexing_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT blending_operation_advanced_features{}; + blending_operation_advanced_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; + blending_operation_advanced_features.pNext = static_cast(&descriptor_indexing_features); + + VkPhysicalDeviceFeatures2 features2{}; + features2.pNext = static_cast(&blending_operation_advanced_features); + vkGetPhysicalDeviceFeatures2(physical_device, &features2); + // Make sure the first and last elements are set to true + ASSERT_EQ(features2.features.robustBufferAccess, true); + ASSERT_EQ(features2.features.inheritedQueries, true); + ASSERT_EQ(descriptor_indexing_features.shaderInputAttachmentArrayDynamicIndexing, true); + ASSERT_EQ(descriptor_indexing_features.runtimeDescriptorArray, true); + ASSERT_EQ(blending_operation_advanced_features.advancedBlendCoherentOperations, true); +} + +TEST_F(MockICD, vkGetPhysicalDeviceFormatProperties) { + VkFormatProperties format_properties{}; + vkGetPhysicalDeviceFormatProperties(physical_device, VK_FORMAT_R8G8B8A8_SRGB, &format_properties); + ASSERT_EQ(format_properties.bufferFeatures, 0x00FFFDFF); + ASSERT_EQ(format_properties.linearTilingFeatures, 0x00FFFDFF); + ASSERT_EQ(format_properties.optimalTilingFeatures, 0x00FFFDFF); +} + +TEST_F(MockICD, vkGetPhysicalDeviceFormatProperties2) { + VkFormatProperties3 format_properties3{}; + format_properties3.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3; + VkFormatProperties2 format_properties2{}; + format_properties2.pNext = static_cast(&format_properties3); + vkGetPhysicalDeviceFormatProperties2(physical_device, VK_FORMAT_R8G8B8A8_SRGB, &format_properties2); + ASSERT_EQ(format_properties2.formatProperties.bufferFeatures, 0x00FFFDFF); + ASSERT_EQ(format_properties2.formatProperties.linearTilingFeatures, 0x00FFFDFF); + ASSERT_EQ(format_properties2.formatProperties.optimalTilingFeatures, 0x00FFFDFF); + ASSERT_EQ(format_properties3.bufferFeatures, 0x00FFFDFF); + ASSERT_EQ(format_properties3.linearTilingFeatures, 0x00FFFDFF); + ASSERT_EQ(format_properties3.optimalTilingFeatures, 0x00FFFDFF); +} + +TEST_F(MockICD, vkGetPhysicalDeviceImageFormatProperties) { + VkImageFormatProperties image_format_properties{}; + vkGetPhysicalDeviceImageFormatProperties(physical_device, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_LINEAR, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, &image_format_properties); + ASSERT_EQ(image_format_properties.maxExtent.width, 4096); + ASSERT_EQ(image_format_properties.maxExtent.height, 4096); + ASSERT_EQ(image_format_properties.maxExtent.depth, 256); + ASSERT_EQ(image_format_properties.maxMipLevels, 1); + ASSERT_EQ(image_format_properties.maxArrayLayers, 1); + ASSERT_EQ(image_format_properties.sampleCounts, VK_SAMPLE_COUNT_1_BIT); + ASSERT_EQ(image_format_properties.maxResourceSize, 4294967296 /* this is max of uint32_t + 1*/); +} + +TEST_F(MockICD, vkGetPhysicalDeviceImageFormatProperties2) { + VkImageFormatProperties2 image_format_properties2{}; + VkPhysicalDeviceImageFormatInfo2 image_format_info2{}; + image_format_info2.format = VK_FORMAT_R8G8B8A8_SRGB; + image_format_info2.type = VK_IMAGE_TYPE_2D; + image_format_info2.tiling = VK_IMAGE_TILING_OPTIMAL; + image_format_info2.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + image_format_info2.flags = 0; + vkGetPhysicalDeviceImageFormatProperties2(physical_device, &image_format_info2, &image_format_properties2); + ASSERT_EQ(image_format_properties2.imageFormatProperties.maxExtent.width, 4096); + ASSERT_EQ(image_format_properties2.imageFormatProperties.maxExtent.height, 4096); + ASSERT_EQ(image_format_properties2.imageFormatProperties.maxExtent.depth, 256); + ASSERT_EQ(image_format_properties2.imageFormatProperties.maxMipLevels, 12); + ASSERT_EQ(image_format_properties2.imageFormatProperties.maxArrayLayers, 256); + ASSERT_EQ(image_format_properties2.imageFormatProperties.sampleCounts, 0x7F & ~VK_SAMPLE_COUNT_64_BIT); + ASSERT_EQ(image_format_properties2.imageFormatProperties.maxResourceSize, 4294967296 /* this is max of uint32_t + 1*/); +} + +TEST_F(MockICD, vkGetPhysicalDeviceSparseImageFormatProperties) { + uint32_t count = 0; + VkSparseImageFormatProperties sparse_image_format_properties{}; + vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TYPE_2D, + VK_SAMPLE_COUNT_64_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + VK_IMAGE_TILING_OPTIMAL, &count, nullptr); + ASSERT_EQ(count, 1); + vkGetPhysicalDeviceSparseImageFormatProperties(physical_device, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TYPE_2D, + VK_SAMPLE_COUNT_64_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + VK_IMAGE_TILING_OPTIMAL, &count, &sparse_image_format_properties); + ASSERT_EQ(sparse_image_format_properties.aspectMask, VK_IMAGE_ASPECT_COLOR_BIT); + ASSERT_EQ(sparse_image_format_properties.imageGranularity.width, 4); + ASSERT_EQ(sparse_image_format_properties.imageGranularity.height, 4); + ASSERT_EQ(sparse_image_format_properties.imageGranularity.depth, 4); + ASSERT_EQ(sparse_image_format_properties.flags, VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT); +} + +TEST_F(MockICD, vkGetPhysicalDeviceSparseImageFormatProperties2) { + uint32_t count = 0; + VkSparseImageFormatProperties2 sparse_image_format_properties2{}; + VkPhysicalDeviceSparseImageFormatInfo2 sparse_image_format_info2{}; + sparse_image_format_info2.format = VK_FORMAT_R8G8B8A8_SRGB; + sparse_image_format_info2.type = VK_IMAGE_TYPE_2D; + sparse_image_format_info2.samples = VK_SAMPLE_COUNT_64_BIT; + sparse_image_format_info2.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + sparse_image_format_info2.tiling = VK_IMAGE_TILING_OPTIMAL; + vkGetPhysicalDeviceSparseImageFormatProperties2(physical_device, &sparse_image_format_info2, &count, nullptr); + ASSERT_EQ(count, 1); + vkGetPhysicalDeviceSparseImageFormatProperties2(physical_device, &sparse_image_format_info2, &count, + &sparse_image_format_properties2); + ASSERT_EQ(sparse_image_format_properties2.properties.aspectMask, VK_IMAGE_ASPECT_COLOR_BIT); + ASSERT_EQ(sparse_image_format_properties2.properties.imageGranularity.width, 4); + ASSERT_EQ(sparse_image_format_properties2.properties.imageGranularity.height, 4); + ASSERT_EQ(sparse_image_format_properties2.properties.imageGranularity.depth, 4); + ASSERT_EQ(sparse_image_format_properties2.properties.flags, VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT); +} + +TEST_F(MockICD, vkGetPhysicalDeviceProperties) { + VkPhysicalDeviceProperties physical_device_properties{}; + vkGetPhysicalDeviceProperties(physical_device, &physical_device_properties); + ASSERT_EQ(physical_device_properties.apiVersion, VK_HEADER_VERSION_COMPLETE); + ASSERT_EQ(physical_device_properties.driverVersion, 1); + ASSERT_EQ(physical_device_properties.vendorID, 0xba5eba11); + ASSERT_EQ(physical_device_properties.deviceID, 0xf005ba11); + ASSERT_EQ(physical_device_properties.deviceType, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU); + ASSERT_STREQ(&physical_device_properties.deviceName[0], "Vulkan Mock Device"); + ASSERT_EQ(physical_device_properties.pipelineCacheUUID[0], 18); + ASSERT_EQ(physical_device_properties.limits.maxImageDimension1D, 4096); + ASSERT_EQ(physical_device_properties.limits.nonCoherentAtomSize, 256); + ASSERT_EQ(physical_device_properties.sparseProperties.residencyAlignedMipSize, VK_TRUE); + ASSERT_EQ(physical_device_properties.sparseProperties.residencyNonResidentStrict, VK_TRUE); + ASSERT_EQ(physical_device_properties.sparseProperties.residencyStandard2DBlockShape, VK_TRUE); + ASSERT_EQ(physical_device_properties.sparseProperties.residencyStandard2DMultisampleBlockShape, VK_TRUE); + ASSERT_EQ(physical_device_properties.sparseProperties.residencyStandard3DBlockShape, VK_TRUE); +} + +TEST_F(MockICD, vkGetPhysicalDeviceProperties2) { + VkPhysicalDeviceVulkan11Properties properties11{}; + properties11.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; + + VkPhysicalDeviceVulkan12Properties properties12{}; + properties12.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; + properties12.pNext = static_cast(&properties11); + + VkPhysicalDeviceVulkan13Properties properties13{}; + properties13.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; + properties13.pNext = static_cast(&properties12); + + VkPhysicalDeviceProtectedMemoryProperties protected_memory_properties{}; + protected_memory_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; + protected_memory_properties.pNext = static_cast(&properties13); + + VkPhysicalDeviceFloatControlsProperties float_controls_properties{}; + float_controls_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; + float_controls_properties.pNext = static_cast(&protected_memory_properties); + + VkPhysicalDeviceConservativeRasterizationPropertiesEXT conservative_rasterization_properties{}; + conservative_rasterization_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; + conservative_rasterization_properties.pNext = static_cast(&float_controls_properties); + + VkPhysicalDeviceRayTracingPipelinePropertiesKHR raytracing_pipeline_properties{}; + raytracing_pipeline_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; + raytracing_pipeline_properties.pNext = static_cast(&conservative_rasterization_properties); + + VkPhysicalDeviceRayTracingPropertiesNV ray_tracing_properties{}; + ray_tracing_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; + ray_tracing_properties.pNext = static_cast(&raytracing_pipeline_properties); + + VkPhysicalDeviceTexelBufferAlignmentProperties texel_buffer_alignment_properties{}; + texel_buffer_alignment_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; + texel_buffer_alignment_properties.pNext = static_cast(&ray_tracing_properties); + + VkPhysicalDeviceDescriptorBufferPropertiesEXT descriptor_buffer_properties{}; + descriptor_buffer_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + descriptor_buffer_properties.pNext = static_cast(&texel_buffer_alignment_properties); + + VkPhysicalDeviceMeshShaderPropertiesEXT mesh_shader_properties{}; + mesh_shader_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; + mesh_shader_properties.pNext = static_cast(&descriptor_buffer_properties); + + VkPhysicalDeviceFragmentDensityMap2PropertiesEXT fragment_density_map2_properties{}; + fragment_density_map2_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; + fragment_density_map2_properties.pNext = static_cast(&mesh_shader_properties); + + VkPhysicalDeviceProperties2 properties2{}; + properties2.pNext = static_cast(&fragment_density_map2_properties); + vkGetPhysicalDeviceProperties2(physical_device, &properties2); + ASSERT_EQ(properties2.properties.apiVersion, VK_HEADER_VERSION_COMPLETE); + ASSERT_EQ(properties2.properties.driverVersion, 1); + ASSERT_EQ(properties2.properties.vendorID, 0xba5eba11); + ASSERT_EQ(properties2.properties.deviceID, 0xf005ba11); + ASSERT_EQ(properties2.properties.deviceType, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU); + ASSERT_STREQ(&properties2.properties.deviceName[0], "Vulkan Mock Device"); + ASSERT_EQ(properties2.properties.pipelineCacheUUID[0], 18); + ASSERT_EQ(properties2.properties.limits.maxImageDimension1D, 4096); + ASSERT_EQ(properties2.properties.limits.nonCoherentAtomSize, 256); + ASSERT_EQ(properties2.properties.sparseProperties.residencyAlignedMipSize, VK_TRUE); + ASSERT_EQ(properties2.properties.sparseProperties.residencyNonResidentStrict, VK_TRUE); + ASSERT_EQ(properties2.properties.sparseProperties.residencyStandard2DBlockShape, VK_TRUE); + ASSERT_EQ(properties2.properties.sparseProperties.residencyStandard2DMultisampleBlockShape, VK_TRUE); + ASSERT_EQ(properties2.properties.sparseProperties.residencyStandard3DBlockShape, VK_TRUE); + + ASSERT_EQ(properties11.protectedNoFault, VK_FALSE); + ASSERT_EQ(properties12.denormBehaviorIndependence, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL); + ASSERT_EQ(properties12.roundingModeIndependence, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL); + ASSERT_EQ(properties13.storageTexelBufferOffsetSingleTexelAlignment, VK_TRUE); + ASSERT_EQ(properties13.uniformTexelBufferOffsetSingleTexelAlignment, VK_TRUE); + ASSERT_EQ(properties13.storageTexelBufferOffsetAlignmentBytes, 16); + ASSERT_EQ(properties13.uniformTexelBufferOffsetAlignmentBytes, 16); + ASSERT_EQ(protected_memory_properties.protectedNoFault, VK_FALSE); + ASSERT_EQ(float_controls_properties.denormBehaviorIndependence, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL); + ASSERT_EQ(float_controls_properties.roundingModeIndependence, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL); + ASSERT_EQ(conservative_rasterization_properties.primitiveOverestimationSize, 0.00195313f); + ASSERT_EQ(conservative_rasterization_properties.conservativePointAndLineRasterization, VK_TRUE); + ASSERT_EQ(conservative_rasterization_properties.degenerateTrianglesRasterized, VK_TRUE); + ASSERT_EQ(conservative_rasterization_properties.degenerateLinesRasterized, VK_TRUE); + ASSERT_EQ(raytracing_pipeline_properties.shaderGroupHandleSize, 32); + ASSERT_EQ(raytracing_pipeline_properties.shaderGroupBaseAlignment, 64); + ASSERT_EQ(raytracing_pipeline_properties.shaderGroupHandleCaptureReplaySize, 32); + ASSERT_EQ(ray_tracing_properties.shaderGroupHandleSize, 32); + ASSERT_EQ(ray_tracing_properties.shaderGroupBaseAlignment, 64); + ASSERT_EQ(texel_buffer_alignment_properties.storageTexelBufferOffsetSingleTexelAlignment, VK_TRUE); + ASSERT_EQ(texel_buffer_alignment_properties.uniformTexelBufferOffsetSingleTexelAlignment, VK_TRUE); + ASSERT_EQ(texel_buffer_alignment_properties.storageTexelBufferOffsetAlignmentBytes, 16); + ASSERT_EQ(texel_buffer_alignment_properties.uniformTexelBufferOffsetAlignmentBytes, 16); + ASSERT_EQ(descriptor_buffer_properties.combinedImageSamplerDescriptorSingleArray, VK_TRUE); + ASSERT_EQ(descriptor_buffer_properties.bufferlessPushDescriptors, VK_TRUE); + ASSERT_EQ(descriptor_buffer_properties.allowSamplerImageViewPostSubmitCreation, VK_TRUE); + ASSERT_EQ(descriptor_buffer_properties.descriptorBufferOffsetAlignment, 4); + ASSERT_EQ(mesh_shader_properties.meshOutputPerVertexGranularity, 32); + ASSERT_EQ(mesh_shader_properties.meshOutputPerPrimitiveGranularity, 32); + ASSERT_EQ(mesh_shader_properties.prefersLocalInvocationVertexOutput, VK_TRUE); + ASSERT_EQ(mesh_shader_properties.prefersLocalInvocationPrimitiveOutput, VK_TRUE); + ASSERT_EQ(mesh_shader_properties.prefersCompactVertexOutput, VK_TRUE); + ASSERT_EQ(mesh_shader_properties.prefersCompactPrimitiveOutput, VK_TRUE); + ASSERT_EQ(fragment_density_map2_properties.subsampledLoads, VK_FALSE); + ASSERT_EQ(fragment_density_map2_properties.subsampledCoarseReconstructionEarlyAccess, VK_FALSE); + ASSERT_EQ(fragment_density_map2_properties.maxSubsampledArrayLayers, 2); + ASSERT_EQ(fragment_density_map2_properties.maxDescriptorSetSubsampledSamplers, 1); +} + +TEST_F(MockICD, vkGetPhysicalDeviceExternalSemaphoreProperties) { + VkPhysicalDeviceExternalSemaphoreInfo external_semaphore_info{}; + VkExternalSemaphoreProperties external_semaphore_properties{}; + vkGetPhysicalDeviceExternalSemaphoreProperties(physical_device, &external_semaphore_info, &external_semaphore_properties); + ASSERT_EQ(external_semaphore_properties.exportFromImportedHandleTypes, 0x1F); + ASSERT_EQ(external_semaphore_properties.compatibleHandleTypes, 0x1F); + ASSERT_EQ(external_semaphore_properties.externalSemaphoreFeatures, 0x3); +} + +TEST_F(MockICD, vkGetPhysicalDeviceExternalFenceProperties) { + VkPhysicalDeviceExternalFenceInfo external_fence_info{}; + VkExternalFenceProperties external_fence_properties{}; + vkGetPhysicalDeviceExternalFenceProperties(physical_device, &external_fence_info, &external_fence_properties); + ASSERT_EQ(external_fence_properties.exportFromImportedHandleTypes, 0xF); + ASSERT_EQ(external_fence_properties.compatibleHandleTypes, 0xF); + ASSERT_EQ(external_fence_properties.externalFenceFeatures, 0x3); +} +TEST_F(MockICD, vkGetPhysicalDeviceExternalBufferProperties) { + VkPhysicalDeviceExternalBufferInfo external_buffer_info{}; + external_buffer_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT; + VkExternalBufferProperties external_buffer_properties{}; + vkGetPhysicalDeviceExternalBufferProperties(physical_device, &external_buffer_info, &external_buffer_properties); + ASSERT_EQ(external_buffer_properties.externalMemoryProperties.externalMemoryFeatures, 0x7); + ASSERT_EQ(external_buffer_properties.externalMemoryProperties.exportFromImportedHandleTypes, 0x1FF); + ASSERT_EQ(external_buffer_properties.externalMemoryProperties.compatibleHandleTypes, 0x1FF); + + external_buffer_info.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX; + vkGetPhysicalDeviceExternalBufferProperties(physical_device, &external_buffer_info, &external_buffer_properties); + ASSERT_EQ(external_buffer_properties.externalMemoryProperties.externalMemoryFeatures, 0); + ASSERT_EQ(external_buffer_properties.externalMemoryProperties.exportFromImportedHandleTypes, 0); + ASSERT_EQ(external_buffer_properties.externalMemoryProperties.compatibleHandleTypes, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX); +} + +/* + * Exercises the following commands: + * vkCreateBuffer + * vkGetBufferMemoryRequirements + * vkGetBufferMemoryRequirements2 + * vkGetDeviceBufferMemoryRequirements + * vkAllocateMemory + * vkMapMemory + * vkUnmapMemory + * vkGetBufferDeviceAddress + * vkGetBufferDeviceAddressKHR + * vkGetBufferDeviceAddressEXT + * vkDestroyBuffer + * vkFreeMemory + */ +TEST_F(MockICD, BufferOperations) { + VkResult res = VK_SUCCESS; + + VkBufferCreateInfo buffer_create_info{}; + buffer_create_info.size = 128; + VkBuffer buffer{}; + res = vkCreateBuffer(device, &buffer_create_info, nullptr, &buffer); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(buffer, VK_NULL_HANDLE); + + VkMemoryRequirements memory_requirements{}; + vkGetBufferMemoryRequirements(device, buffer, &memory_requirements); + ASSERT_EQ(memory_requirements.size, 4096); + ASSERT_EQ(memory_requirements.alignment, 1); + ASSERT_EQ(memory_requirements.memoryTypeBits, 0xFFFF); + + VkBufferMemoryRequirementsInfo2 memory_requirements_info2{}; + VkMemoryRequirements2 memory_requirements2{}; + vkGetBufferMemoryRequirements2(device, &memory_requirements_info2, &memory_requirements2); + ASSERT_EQ(memory_requirements2.memoryRequirements.size, 4096); + ASSERT_EQ(memory_requirements2.memoryRequirements.alignment, 1); + ASSERT_EQ(memory_requirements2.memoryRequirements.memoryTypeBits, 0xFFFF); + + VkDeviceBufferMemoryRequirements buffer_memory_requirements{}; + buffer_memory_requirements.pCreateInfo = &buffer_create_info; + vkGetDeviceBufferMemoryRequirements(device, &buffer_memory_requirements, &memory_requirements2); + ASSERT_EQ(memory_requirements2.memoryRequirements.size, 4096); + ASSERT_EQ(memory_requirements2.memoryRequirements.alignment, 1); + ASSERT_EQ(memory_requirements2.memoryRequirements.memoryTypeBits, 0xFFFF); + + VkMemoryAllocateInfo allocate_info{}; + allocate_info.allocationSize = memory_requirements.size; + VkDeviceMemory memory{}; + res = vkAllocateMemory(device, &allocate_info, nullptr, &memory); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(memory, VK_NULL_HANDLE); + + std::array source_data; + void* data = nullptr; + res = vkMapMemory(device, memory, 0, memory_requirements.size, 0, &data); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(data, nullptr); + memcpy(data, source_data.data(), source_data.size()); + vkUnmapMemory(device, memory); + + VkBufferDeviceAddressInfo buffer_device_address_info{}; + buffer_device_address_info.buffer = buffer; + VkDeviceAddress device_address = vkGetBufferDeviceAddress(device, &buffer_device_address_info); + ASSERT_NE(device_address, 0); + + auto vkGetBufferDeviceAddressEXT = + reinterpret_cast(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressEXT")); + ASSERT_NE(vkGetBufferDeviceAddressEXT, nullptr); + device_address = vkGetBufferDeviceAddressEXT(device, &buffer_device_address_info); + ASSERT_NE(device_address, 0); + + auto vkGetBufferDeviceAddressKHR = + reinterpret_cast(vkGetDeviceProcAddr(device, "vkGetBufferDeviceAddressKHR")); + ASSERT_NE(vkGetBufferDeviceAddressKHR, nullptr); + device_address = vkGetBufferDeviceAddressKHR(device, &buffer_device_address_info); + ASSERT_NE(device_address, 0); + + vkDestroyBuffer(device, buffer, nullptr); + vkFreeMemory(device, memory, nullptr); +} + +/* + * Exercises the following commands: + * vkCreateImage + * vkGetImageSubresourceLayout + * vkGetImageMemoryRequirements + * vkGetImageMemoryRequirements2 + * vkGetDeviceImageMemoryRequirements + * vkGetImageSparseMemoryRequirements + * vkGetImageSparseMemoryRequirements2 + * vkAllocateMemory + * vkMapMemory2KHR + * vkUnmapMemory2KHR + * vkDestroyImage + * vkFreeMemory + */ +TEST_F(MockICD, ImageOperations) { + VkResult res = VK_SUCCESS; + + VkImageCreateInfo image_create_info{}; + image_create_info.imageType = VK_IMAGE_TYPE_2D; + image_create_info.format = VK_FORMAT_R8G8B8A8_SRGB; + image_create_info.extent = {8, 8, 8}; + 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_OPTIMAL; + image_create_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + image_create_info.queueFamilyIndexCount = 0; + image_create_info.pQueueFamilyIndices = nullptr; + image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + VkImage image{}; + res = vkCreateImage(device, &image_create_info, nullptr, &image); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(image, VK_NULL_HANDLE); + + VkImageSubresource image_subresource{}; + VkSubresourceLayout subresource_layout{}; + vkGetImageSubresourceLayout(device, image, &image_subresource, &subresource_layout); + ASSERT_EQ(subresource_layout.arrayPitch, 0); + ASSERT_EQ(subresource_layout.depthPitch, 0); + ASSERT_EQ(subresource_layout.offset, 0); + ASSERT_EQ(subresource_layout.rowPitch, 0); + ASSERT_EQ(subresource_layout.size, 0); + + VkMemoryRequirements memory_requirements{}; + vkGetImageMemoryRequirements(device, image, &memory_requirements); + ASSERT_EQ(memory_requirements.size, 8 * 8 * 8 * 32 /*refer to GetImageSizeFromCreateInfo for size calc*/); + ASSERT_EQ(memory_requirements.alignment, 1); + ASSERT_EQ(memory_requirements.memoryTypeBits, 0xFFFF & ~(0x1 << 3)); + + VkImageMemoryRequirementsInfo2 memory_requirements_info2{}; + VkMemoryRequirements2 memory_requirements2{}; + vkGetImageMemoryRequirements2(device, &memory_requirements_info2, &memory_requirements2); + ASSERT_EQ(memory_requirements2.memoryRequirements.size, 0); + ASSERT_EQ(memory_requirements2.memoryRequirements.alignment, 1); + ASSERT_EQ(memory_requirements2.memoryRequirements.memoryTypeBits, 0xFFFF & ~(0x1 << 3)); + + VkDeviceImageMemoryRequirements image_memory_requirements{}; + image_memory_requirements.pCreateInfo = &image_create_info; + vkGetDeviceImageMemoryRequirements(device, &image_memory_requirements, &memory_requirements2); + ASSERT_EQ(memory_requirements2.memoryRequirements.size, 8 * 8 * 8 * 32 /*refer to GetImageSizeFromCreateInfo for size calc*/); + ASSERT_EQ(memory_requirements2.memoryRequirements.alignment, 1); + ASSERT_EQ(memory_requirements2.memoryRequirements.memoryTypeBits, 0xFFFF & ~(0x1 << 3)); + + uint32_t count = 0; + vkGetImageSparseMemoryRequirements(device, image, &count, nullptr); + ASSERT_EQ(count, 1); + VkSparseImageMemoryRequirements sparse_image_memory_requirements{}; + vkGetImageSparseMemoryRequirements(device, image, &count, &sparse_image_memory_requirements); + ASSERT_EQ(count, 1); + ASSERT_EQ(sparse_image_memory_requirements.imageMipTailFirstLod, 0); + ASSERT_EQ(sparse_image_memory_requirements.imageMipTailSize, 8); + ASSERT_EQ(sparse_image_memory_requirements.imageMipTailOffset, 0); + ASSERT_EQ(sparse_image_memory_requirements.imageMipTailStride, 4); + ASSERT_EQ(sparse_image_memory_requirements.formatProperties.imageGranularity.width, 4); + ASSERT_EQ(sparse_image_memory_requirements.formatProperties.imageGranularity.height, 4); + ASSERT_EQ(sparse_image_memory_requirements.formatProperties.imageGranularity.depth, 4); + ASSERT_EQ(sparse_image_memory_requirements.formatProperties.flags, VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT); + ASSERT_EQ(sparse_image_memory_requirements.formatProperties.aspectMask, 1 | 2 | 4 | 8); + + count = 0; + VkImageSparseMemoryRequirementsInfo2 sparse_memory_requirement_info2{}; + sparse_memory_requirement_info2.image = image; + vkGetImageSparseMemoryRequirements2(device, &sparse_memory_requirement_info2, &count, nullptr); + ASSERT_EQ(count, 1); + VkSparseImageMemoryRequirements2 sparse_image_memory_reqs2{}; + vkGetImageSparseMemoryRequirements2(device, &sparse_memory_requirement_info2, &count, &sparse_image_memory_reqs2); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.imageMipTailFirstLod, 0); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.imageMipTailSize, 8); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.imageMipTailOffset, 0); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.imageMipTailStride, 4); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.imageGranularity.width, 4); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.imageGranularity.height, 4); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.imageGranularity.depth, 4); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.flags, VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT); + ASSERT_EQ(sparse_image_memory_reqs2.memoryRequirements.formatProperties.aspectMask, 1 | 2 | 4 | 8); + + VkMemoryAllocateInfo allocate_info{}; + allocate_info.allocationSize = memory_requirements.size; + VkDeviceMemory memory{}; + res = vkAllocateMemory(device, &allocate_info, nullptr, &memory); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(memory, VK_NULL_HANDLE); + + auto vkMapMemory2KHR = reinterpret_cast(vkGetDeviceProcAddr(device, "vkMapMemory2KHR")); + auto vkUnmapMemory2KHR = reinterpret_cast(vkGetDeviceProcAddr(device, "vkUnmapMemory2KHR")); + ASSERT_NE(vkMapMemory2KHR, nullptr); + ASSERT_NE(vkUnmapMemory2KHR, nullptr); + + std::array source_data; + void* data = nullptr; + VkMemoryMapInfoKHR memory_map_info{}; + memory_map_info.memory = memory; + memory_map_info.size = memory_requirements.size; + res = vkMapMemory2KHR(device, &memory_map_info, &data); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(data, nullptr); + memcpy(data, source_data.data(), source_data.size()); + VkMemoryUnmapInfoKHR memory_unmap_info{}; + memory_unmap_info.memory = memory; + vkUnmapMemory2KHR(device, &memory_unmap_info); + + vkDestroyImage(device, image, nullptr); + vkFreeMemory(device, memory, nullptr); +} + +/* + * Exercises the following commands: + * vkCreateSwapchainKHR + * vkGetSwapchainImagesKHR + * vkDestroySwapchainKHR + * vkAcquireNextImageKHR + * vkAcquireNextImage2KHR + */ +TEST_F(MockICD, SwapchainLifeCycle) { + VkResult res = VK_SUCCESS; + VkSurfaceKHR surface{}; + res = create_surface(instance, surface); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(surface, nullptr); + + VkSwapchainCreateInfoKHR swapchain_create_info{}; + swapchain_create_info.surface = surface; + swapchain_create_info.minImageCount = 1; + VkSwapchainKHR swapchain{}; + res = vkCreateSwapchainKHR(device, &swapchain_create_info, nullptr, &swapchain); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(swapchain, nullptr); + + uint32_t count = 0; + res = vkGetSwapchainImagesKHR(device, swapchain, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + std::array swapchain_images; + res = vkGetSwapchainImagesKHR(device, swapchain, &count, swapchain_images.data()); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_NE(swapchain_images[0], nullptr); + + uint32_t image_index = 10; // arbitrary non zero value + res = vkAcquireNextImageKHR(device, swapchain, 0, VK_NULL_HANDLE, VK_NULL_HANDLE, &image_index); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(image_index, 0); + + VkAcquireNextImageInfoKHR acquire_info{}; + acquire_info.swapchain = swapchain; + res = vkAcquireNextImage2KHR(device, &acquire_info, &image_index); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(image_index, 0); + + vkDestroySwapchainKHR(device, swapchain, nullptr); + vkDestroySurfaceKHR(instance, surface, nullptr); +} + +TEST_F(MockICD, vkGetPhysicalDeviceMultisamplePropertiesEXT) { + auto vkGetPhysicalDeviceMultisamplePropertiesEXT = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT")); + ASSERT_NE(vkGetPhysicalDeviceMultisamplePropertiesEXT, nullptr); + VkMultisamplePropertiesEXT multisample_properties{}; + vkGetPhysicalDeviceMultisamplePropertiesEXT(physical_device, VK_SAMPLE_COUNT_16_BIT, &multisample_properties); + ASSERT_EQ(multisample_properties.maxSampleLocationGridSize.width, 32); + ASSERT_EQ(multisample_properties.maxSampleLocationGridSize.height, 32); +} + +TEST_F(MockICD, vkGetPhysicalDeviceFragmentShadingRatesKHR) { + auto vkGetPhysicalDeviceFragmentShadingRatesKHR = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR")); + ASSERT_NE(vkGetPhysicalDeviceFragmentShadingRatesKHR, nullptr); + + VkResult res = VK_SUCCESS; + uint32_t count = 0; + res = vkGetPhysicalDeviceFragmentShadingRatesKHR(physical_device, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + + VkPhysicalDeviceFragmentShadingRateKHR fragment_shading_rates{}; + res = vkGetPhysicalDeviceFragmentShadingRatesKHR(physical_device, &count, &fragment_shading_rates); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + ASSERT_EQ(fragment_shading_rates.sampleCounts, VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT); + ASSERT_EQ(fragment_shading_rates.fragmentSize.width, 8); + ASSERT_EQ(fragment_shading_rates.fragmentSize.height, 8); +} + +TEST_F(MockICD, vkGetPhysicalDeviceCalibrateableTimeDomainsEXT) { + auto vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")); + ASSERT_NE(vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, nullptr); + + VkResult res = VK_SUCCESS; + uint32_t count = 0; + res = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physical_device, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + + VkTimeDomainEXT time_domain{}; + res = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physical_device, &count, &time_domain); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + ASSERT_EQ(time_domain, VK_TIME_DOMAIN_DEVICE_EXT); +} + +#if defined(WIN32) +TEST_F(MockICD, vkGetFenceWin32HandleKHR) { + auto vkGetFenceWin32HandleKHR = + reinterpret_cast(vkGetDeviceProcAddr(device, "vkGetFenceWin32HandleKHR")); + ASSERT_NE(vkGetFenceWin32HandleKHR, nullptr); + VkFenceGetWin32HandleInfoKHR get_win32_handle_info{}; + HANDLE handle{}; + VkResult res = vkGetFenceWin32HandleKHR(device, &get_win32_handle_info, &handle); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(handle, (HANDLE)0x12345678); +} +#endif // defined(WIN32) + +TEST_F(MockICD, vkGetFenceFdKHR) { + auto vkGetFenceFdKHR = reinterpret_cast(vkGetDeviceProcAddr(device, "vkGetFenceFdKHR")); + ASSERT_NE(vkGetFenceFdKHR, nullptr); + VkFenceGetFdInfoKHR get_win32_handle_info{}; + int handle{}; + VkResult res = vkGetFenceFdKHR(device, &get_win32_handle_info, &handle); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(handle, 0x42); +} + +TEST_F(MockICD, vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR) { + auto vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = + reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")); + ASSERT_NE(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, nullptr); + + VkResult res = VK_SUCCESS; + uint32_t count = 0; + res = vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physical_device, 0, &count, nullptr, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 3); + + std::array counters{}; + std::array counter_descriptions{}; + res = vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physical_device, 0, &count, counters.data(), + counter_descriptions.data()); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 3); + ASSERT_EQ(counters[0].unit, VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR); + ASSERT_EQ(counters[0].scope, VK_QUERY_SCOPE_COMMAND_BUFFER_KHR); + ASSERT_EQ(counters[0].storage, VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR); + ASSERT_EQ(counters[0].uuid[0], 0x01); + ASSERT_EQ(counters[1].unit, VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR); + ASSERT_EQ(counters[1].scope, VK_QUERY_SCOPE_RENDER_PASS_KHR); + ASSERT_EQ(counters[1].storage, VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR); + ASSERT_EQ(counters[1].uuid[0], 0x02); + ASSERT_EQ(counters[2].unit, VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR); + ASSERT_EQ(counters[2].scope, VK_QUERY_SCOPE_COMMAND_KHR); + ASSERT_EQ(counters[2].storage, VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR); + ASSERT_EQ(counters[2].uuid[0], 0x03); +} + +TEST_F(MockICD, vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR) { + auto vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = + reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")); + ASSERT_NE(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, nullptr); + VkQueryPoolPerformanceCreateInfoKHR performance_query_create_info{}; + uint32_t num_passes = 0; + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physical_device, &performance_query_create_info, &num_passes); + ASSERT_EQ(num_passes, 1); +} + +TEST_F(MockICD, vkGetShaderModuleIdentifierEXT) { + auto vkGetShaderModuleIdentifierEXT = + reinterpret_cast(vkGetDeviceProcAddr(device, "vkGetShaderModuleIdentifierEXT")); + ASSERT_NE(vkGetShaderModuleIdentifierEXT, nullptr); + VkShaderModule shader_module{}; + VkShaderModuleIdentifierEXT identifier{}; + vkGetShaderModuleIdentifierEXT(device, shader_module, &identifier); + ASSERT_EQ(identifier.identifierSize, 1); + ASSERT_EQ(identifier.identifier[0], 0x01); +} + +TEST_F(MockICD, vkGetDescriptorSetLayoutSizeEXT) { + auto vkGetDescriptorSetLayoutSizeEXT = + reinterpret_cast(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSizeEXT")); + ASSERT_NE(vkGetDescriptorSetLayoutSizeEXT, nullptr); + + VkDescriptorSetLayout layout{}; + VkDeviceSize layout_size_in_bytes = 0; + vkGetDescriptorSetLayoutSizeEXT(device, layout, &layout_size_in_bytes); + ASSERT_EQ(layout_size_in_bytes, 4); +} + +TEST_F(MockICD, vkGetAccelerationStructureBuildSizesKHR) { + auto vkGetAccelerationStructureBuildSizesKHR = reinterpret_cast( + vkGetDeviceProcAddr(device, "vkGetAccelerationStructureBuildSizesKHR")); + ASSERT_NE(vkGetAccelerationStructureBuildSizesKHR, nullptr); + + VkAccelerationStructureBuildGeometryInfoKHR build_info{}; + uint32_t max_primitive_count = 0; + VkAccelerationStructureBuildSizesInfoKHR size_info{}; + vkGetAccelerationStructureBuildSizesKHR(device, VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, &build_info, + &max_primitive_count, &size_info); + ASSERT_EQ(size_info.accelerationStructureSize, 4); + ASSERT_EQ(size_info.updateScratchSize, 4); + ASSERT_EQ(size_info.buildScratchSize, 4); +} + +TEST_F(MockICD, vkGetAccelerationStructureMemoryRequirementsNV) { + auto vkGetAccelerationStructureMemoryRequirementsNV = reinterpret_cast( + vkGetDeviceProcAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV")); + ASSERT_NE(vkGetAccelerationStructureMemoryRequirementsNV, nullptr); + + VkAccelerationStructureMemoryRequirementsInfoNV acceleration_structure_memory_requirements_info{}; + VkMemoryRequirements2KHR memory_requirements{}; + vkGetAccelerationStructureMemoryRequirementsNV(device, &acceleration_structure_memory_requirements_info, &memory_requirements); + ASSERT_EQ(memory_requirements.memoryRequirements.size, 4096); + ASSERT_EQ(memory_requirements.memoryRequirements.alignment, 1); + ASSERT_EQ(memory_requirements.memoryRequirements.memoryTypeBits, 0xFFFF); +} + +TEST_F(MockICD, vkGetVideoSessionMemoryRequirementsKHR) { + auto vkGetVideoSessionMemoryRequirementsKHR = reinterpret_cast( + vkGetDeviceProcAddr(device, "vkGetVideoSessionMemoryRequirementsKHR")); + ASSERT_NE(vkGetVideoSessionMemoryRequirementsKHR, nullptr); + + VkVideoSessionKHR video_session{}; + uint32_t count = 0; + VkResult res = vkGetVideoSessionMemoryRequirementsKHR(device, video_session, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + VkVideoSessionMemoryRequirementsKHR memory_requirements{}; + res = vkGetVideoSessionMemoryRequirementsKHR(device, video_session, &count, &memory_requirements); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 1); + ASSERT_EQ(memory_requirements.memoryBindIndex, 0); + ASSERT_EQ(memory_requirements.memoryRequirements.size, 4096); + ASSERT_EQ(memory_requirements.memoryRequirements.alignment, 1); + ASSERT_EQ(memory_requirements.memoryRequirements.memoryTypeBits, 0xFFFF); +} + +TEST_F(MockICD, vkGetPhysicalDeviceVideoFormatPropertiesKHR) { + auto vkGetPhysicalDeviceVideoFormatPropertiesKHR = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")); + ASSERT_NE(vkGetPhysicalDeviceVideoFormatPropertiesKHR, nullptr); + + VkPhysicalDeviceVideoFormatInfoKHR video_format_info{}; + uint32_t count = 0; + VkResult res = vkGetPhysicalDeviceVideoFormatPropertiesKHR(physical_device, &video_format_info, &count, nullptr); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 2); + std::array video_format_properties{}; + res = vkGetPhysicalDeviceVideoFormatPropertiesKHR(physical_device, &video_format_info, &count, video_format_properties.data()); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(count, 2); + ASSERT_EQ(video_format_properties[0].format, VK_FORMAT_R8G8B8A8_UNORM); + ASSERT_EQ(video_format_properties[0].imageCreateFlags, VK_IMAGE_TYPE_2D); + ASSERT_EQ(video_format_properties[0].imageType, VK_IMAGE_TYPE_2D); + ASSERT_EQ(video_format_properties[0].imageTiling, VK_IMAGE_TILING_OPTIMAL); + ASSERT_EQ(video_format_properties[0].imageUsageFlags, VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | + VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR | + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR); + ASSERT_EQ(video_format_properties[1].format, VK_FORMAT_R8G8B8A8_SNORM); + ASSERT_EQ(video_format_properties[1].imageCreateFlags, VK_IMAGE_TYPE_2D); + ASSERT_EQ(video_format_properties[1].imageType, VK_IMAGE_TYPE_2D); + ASSERT_EQ(video_format_properties[1].imageTiling, VK_IMAGE_TILING_OPTIMAL); + ASSERT_EQ(video_format_properties[1].imageUsageFlags, VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | + VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR | + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR); +} + +TEST_F(MockICD, vkGetPhysicalDeviceVideoCapabilitiesKHR) { + auto vkGetPhysicalDeviceVideoCapabilitiesKHR = reinterpret_cast( + vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR")); + ASSERT_NE(vkGetPhysicalDeviceVideoCapabilitiesKHR, nullptr); + + VkVideoProfileInfoKHR video_profile_info{}; + VkVideoCapabilitiesKHR video_capabilities{}; + VkResult res = vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile_info, &video_capabilities); + ASSERT_EQ(res, VK_SUCCESS); + ASSERT_EQ(video_capabilities.flags, 0); + ASSERT_EQ(video_capabilities.minBitstreamBufferOffsetAlignment, 4); + ASSERT_EQ(video_capabilities.minBitstreamBufferSizeAlignment, 4); + ASSERT_EQ(video_capabilities.pictureAccessGranularity.width, 1); + ASSERT_EQ(video_capabilities.pictureAccessGranularity.height, 1); + ASSERT_EQ(video_capabilities.minCodedExtent.width, 4); + ASSERT_EQ(video_capabilities.minCodedExtent.height, 4); + ASSERT_EQ(video_capabilities.maxCodedExtent.width, 16); + ASSERT_EQ(video_capabilities.maxCodedExtent.height, 16); + ASSERT_EQ(video_capabilities.maxDpbSlots, 4); + ASSERT_EQ(video_capabilities.maxActiveReferencePictures, 4); +} + +TEST_F(MockICD, vkGetDescriptorSetLayoutSupport) { + VkDescriptorSetLayoutCreateInfo create_info{}; + VkDescriptorSetLayoutSupport support{}; + vkGetDescriptorSetLayoutSupport(device, &create_info, &support); + ASSERT_EQ(support.supported, VK_TRUE); +} + +TEST_F(MockICD, vkGetDescriptorSetLayoutSupportKHR) { + auto vkGetDescriptorSetLayoutSupportKHR = + reinterpret_cast(vkGetDeviceProcAddr(device, "vkGetDescriptorSetLayoutSupportKHR")); + ASSERT_NE(vkGetDescriptorSetLayoutSupportKHR, nullptr); + + VkDescriptorSetLayoutCreateInfo create_info{}; + VkDescriptorSetLayoutSupport support{}; + vkGetDescriptorSetLayoutSupportKHR(device, &create_info, &support); + ASSERT_EQ(support.supported, VK_TRUE); +} + +TEST_F(MockICD, vkGetRenderAreaGranularity) { + VkRenderPass render_pass{}; + VkExtent2D granularity{}; + vkGetRenderAreaGranularity(device, render_pass, &granularity); + ASSERT_EQ(granularity.width, 1); + ASSERT_EQ(granularity.height, 1); } -- 2.7.4