| /* |
| * Copyright (c) 2015-2016 The Khronos Group Inc. |
| * Copyright (c) 2015-2016 Valve Corporation |
| * Copyright (c) 2015-2016 LunarG, Inc. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and/or associated documentation files (the "Materials"), to |
| * deal in the Materials without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Materials, and to permit persons to whom the Materials are |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice(s) and this permission notice shall be included in |
| * all copies or substantial portions of the Materials. |
| * |
| * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| * |
| * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
| * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
| * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE |
| * USE OR OTHER DEALINGS IN THE MATERIALS. |
| * |
| * Author: Jeremy Hayes <jeremy@lunarG.com> |
| */ |
| |
| #include <algorithm> |
| #include <iostream> |
| #include <memory> |
| #include <string> |
| #include <vector> |
| |
| #include "test_common.h" |
| #include <vulkan/vulkan.h> |
| |
| namespace VK { |
| |
| struct InstanceCreateInfo { |
| InstanceCreateInfo() |
| : info // MSVC can't handle list initialization, thus explicit construction herein. |
| (VkInstanceCreateInfo{ |
| VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // sType |
| nullptr, // pNext |
| 0, // flags |
| nullptr, // pApplicationInfo |
| 0, // enabledLayerCount |
| nullptr, // ppEnabledLayerNames |
| 0, // enabledExtensionCount |
| nullptr // ppEnabledExtensionNames |
| }) {} |
| |
| InstanceCreateInfo &sType(VkStructureType const &sType) { |
| info.sType = sType; |
| |
| return *this; |
| } |
| |
| InstanceCreateInfo &pNext(void const *const pNext) { |
| info.pNext = pNext; |
| |
| return *this; |
| } |
| |
| InstanceCreateInfo &flags(VkInstanceCreateFlags const &flags) { |
| info.flags = flags; |
| |
| return *this; |
| } |
| |
| InstanceCreateInfo &pApplicationInfo(VkApplicationInfo const *const pApplicationInfo) { |
| info.pApplicationInfo = pApplicationInfo; |
| |
| return *this; |
| } |
| |
| InstanceCreateInfo &enabledLayerCount(uint32_t const &enabledLayerCount) { |
| info.enabledLayerCount = enabledLayerCount; |
| |
| return *this; |
| } |
| |
| InstanceCreateInfo &ppEnabledLayerNames(char const *const *const ppEnabledLayerNames) { |
| info.ppEnabledLayerNames = ppEnabledLayerNames; |
| |
| return *this; |
| } |
| |
| InstanceCreateInfo &enabledExtensionCount(uint32_t const &enabledExtensionCount) { |
| info.enabledExtensionCount = enabledExtensionCount; |
| |
| return *this; |
| } |
| |
| InstanceCreateInfo &ppEnabledExtensionNames(char const *const *const ppEnabledExtensionNames) { |
| info.ppEnabledExtensionNames = ppEnabledExtensionNames; |
| |
| return *this; |
| } |
| |
| operator VkInstanceCreateInfo const *() const { return &info; } |
| |
| operator VkInstanceCreateInfo *() { return &info; } |
| |
| VkInstanceCreateInfo info; |
| }; |
| |
| struct DeviceQueueCreateInfo { |
| DeviceQueueCreateInfo() |
| : info // MSVC can't handle list initialization, thus explicit construction herein. |
| (VkDeviceQueueCreateInfo{ |
| VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType |
| nullptr, // pNext |
| 0, // flags |
| 0, // queueFamilyIndex |
| 0, // queueCount |
| nullptr // pQueuePriorities |
| }) {} |
| |
| DeviceQueueCreateInfo &sType(VkStructureType const &sType) { |
| info.sType = sType; |
| |
| return *this; |
| } |
| |
| DeviceQueueCreateInfo &pNext(void const *const pNext) { |
| info.pNext = pNext; |
| |
| return *this; |
| } |
| |
| DeviceQueueCreateInfo &flags(VkDeviceQueueCreateFlags const &flags) { |
| info.flags = flags; |
| |
| return *this; |
| } |
| |
| DeviceQueueCreateInfo &queueFamilyIndex(uint32_t const &queueFamilyIndex) { |
| info.queueFamilyIndex = queueFamilyIndex; |
| |
| return *this; |
| } |
| |
| DeviceQueueCreateInfo &queueCount(uint32_t const &queueCount) { |
| info.queueCount = queueCount; |
| |
| return *this; |
| } |
| |
| DeviceQueueCreateInfo &pQueuePriorities(float const *const pQueuePriorities) { |
| info.pQueuePriorities = pQueuePriorities; |
| |
| return *this; |
| } |
| |
| operator VkDeviceQueueCreateInfo() { return info; } |
| |
| VkDeviceQueueCreateInfo info; |
| }; |
| |
| struct DeviceCreateInfo { |
| DeviceCreateInfo() |
| : info // MSVC can't handle list initialization, thus explicit construction herein. |
| (VkDeviceCreateInfo{ |
| VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, // sType |
| nullptr, // pNext |
| 0, // flags |
| 0, // queueCreateInfoCount |
| nullptr, // pQueueCreateInfos |
| 0, // enabledLayerCount |
| nullptr, // ppEnabledLayerNames |
| 0, // enabledExtensionCount |
| nullptr, // ppEnabledExtensionNames |
| nullptr // pEnabledFeatures |
| }) {} |
| |
| DeviceCreateInfo &sType(VkStructureType const &sType) { |
| info.sType = sType; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &pNext(void const *const pNext) { |
| info.pNext = pNext; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &flags(VkDeviceQueueCreateFlags const &flags) { |
| info.flags = flags; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &queueCreateInfoCount(uint32_t const &queueCreateInfoCount) { |
| info.queueCreateInfoCount = queueCreateInfoCount; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &pQueueCreateInfos(VkDeviceQueueCreateInfo const *const pQueueCreateInfos) { |
| info.pQueueCreateInfos = pQueueCreateInfos; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &enabledLayerCount(uint32_t const &enabledLayerCount) { |
| info.enabledLayerCount = enabledLayerCount; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &ppEnabledLayerNames(char const *const *const ppEnabledLayerNames) { |
| info.ppEnabledLayerNames = ppEnabledLayerNames; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &enabledExtensionCount(uint32_t const &enabledExtensionCount) { |
| info.enabledExtensionCount = enabledExtensionCount; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &ppEnabledExtensionNames(char const *const *const ppEnabledExtensionNames) { |
| info.ppEnabledExtensionNames = ppEnabledExtensionNames; |
| |
| return *this; |
| } |
| |
| DeviceCreateInfo &pEnabledFeatures(VkPhysicalDeviceFeatures const *const pEnabledFeatures) { |
| info.pEnabledFeatures = pEnabledFeatures; |
| |
| return *this; |
| } |
| |
| operator VkDeviceCreateInfo const *() const { return &info; } |
| |
| operator VkDeviceCreateInfo *() { return &info; } |
| |
| VkDeviceCreateInfo info; |
| }; |
| } |
| |
| struct CommandLine : public ::testing::Test { |
| static void Initialize(int argc, char **argv) { arguments.assign(argv, argv + argc); }; |
| |
| static void SetUpTestCase(){}; |
| static void TearDownTestCase(){}; |
| |
| static std::vector<std::string> arguments; |
| }; |
| std::vector<std::string> CommandLine::arguments; |
| |
| struct EnumerateInstanceLayerProperties : public CommandLine {}; |
| struct EnumerateInstanceExtensionProperties : public CommandLine {}; |
| struct ImplicitLayer : public CommandLine {}; |
| |
| // Test groups: |
| // LX = lunar exchange |
| // LVLGH = loader and validation github |
| // LVLGL = lodaer and validation gitlab |
| |
| TEST(LX435, InstanceCreateInfoConst) { |
| VkInstanceCreateInfo const info = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, nullptr, 0, nullptr, 0, nullptr, 0, nullptr}; |
| |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(&info, VK_NULL_HANDLE, &instance); |
| EXPECT_EQ(result, VK_SUCCESS); |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| TEST(LX475, DestroyInstanceNullHandle) { vkDestroyInstance(VK_NULL_HANDLE, nullptr); } |
| |
| TEST(LX475, DestroyDeviceNullHandle) { vkDestroyDevice(VK_NULL_HANDLE, nullptr); } |
| |
| TEST(CreateInstance, ExtensionNotPresent) { |
| char const *const names[] = {"NotPresent"}; // Temporary required due to MSVC bug. |
| auto const info = VK::InstanceCreateInfo().enabledExtensionCount(1).ppEnabledExtensionNames(names); |
| |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(info, VK_NULL_HANDLE, &instance); |
| ASSERT_EQ(result, VK_ERROR_EXTENSION_NOT_PRESENT); |
| |
| // It's not necessary to destroy the instance because it will not be created successfully. |
| } |
| |
| TEST(CreateInstance, LayerNotPresent) { |
| char const *const names[] = {"NotPresent"}; // Temporary required due to MSVC bug. |
| auto const info = VK::InstanceCreateInfo().enabledLayerCount(1).ppEnabledLayerNames(names); |
| |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(info, VK_NULL_HANDLE, &instance); |
| ASSERT_EQ(result, VK_ERROR_LAYER_NOT_PRESENT); |
| |
| // It's not necessary to destroy the instance because it will not be created successfully. |
| } |
| |
| // Used by run_loader_tests.sh to test for layer insertion. |
| TEST(CreateInstance, LayerPresent) { |
| char const *const names[] = {"VK_LAYER_LUNARG_parameter_validation"}; // Temporary required due to MSVC bug. |
| auto const info = VK::InstanceCreateInfo().enabledLayerCount(1).ppEnabledLayerNames(names); |
| |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(info, VK_NULL_HANDLE, &instance); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| TEST(CreateDevice, ExtensionNotPresent) { |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), 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 MSVC bug. |
| VkDeviceQueueCreateInfo const queueInfo[1]{ |
| VK::DeviceQueueCreateInfo().queueFamilyIndex(q).queueCount(1).pQueuePriorities(priorities)}; |
| |
| char const *const names[] = {"NotPresent"}; // Temporary required due to MSVC bug. |
| auto const deviceInfo = VK::DeviceCreateInfo() |
| .queueCreateInfoCount(1) |
| .pQueueCreateInfos(queueInfo) |
| .enabledExtensionCount(1) |
| .ppEnabledExtensionNames(names); |
| |
| VkDevice device; |
| result = vkCreateDevice(physical[p], deviceInfo, nullptr, &device); |
| ASSERT_EQ(result, VK_ERROR_EXTENSION_NOT_PRESENT); |
| |
| // It's not necessary to destroy the device because it will not be created successfully. |
| } |
| } |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| // 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, LayersNotPresent) { |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), 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 MSVC bug. |
| VkDeviceQueueCreateInfo const queueInfo[1]{ |
| VK::DeviceQueueCreateInfo().queueFamilyIndex(q).queueCount(1).pQueuePriorities(priorities)}; |
| |
| char const *const names[] = {"NotPresent"}; // Temporary required due to MSVC bug. |
| auto const deviceInfo = VK::DeviceCreateInfo() |
| .queueCreateInfoCount(1) |
| .pQueueCreateInfos(queueInfo) |
| .enabledLayerCount(1) |
| .ppEnabledLayerNames(names); |
| |
| VkDevice device; |
| result = vkCreateDevice(physical[p], deviceInfo, nullptr, &device); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| vkDestroyDevice(device, nullptr); |
| } |
| } |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| TEST_F(EnumerateInstanceLayerProperties, PropertyCountLessThanAvailable) { |
| uint32_t count = 0u; |
| VkResult result = vkEnumerateInstanceLayerProperties(&count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| // We need atleast two for the test to be relevant. |
| if (count < 2u) { |
| return; |
| } |
| |
| std::unique_ptr<VkLayerProperties[]> properties(new VkLayerProperties[count]); |
| count = 1; |
| result = vkEnumerateInstanceLayerProperties(&count, properties.get()); |
| ASSERT_EQ(result, VK_INCOMPLETE); |
| } |
| |
| TEST(EnumerateDeviceLayerProperties, PropertyCountLessThanAvailable) { |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), 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 count = 0u; |
| result = vkEnumerateDeviceLayerProperties(physical[p], &count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| // We need atleast two for the test to be relevant. |
| if (count < 2u) { |
| continue; |
| } |
| |
| std::unique_ptr<VkLayerProperties[]> properties(new VkLayerProperties[count]); |
| count = 1; |
| result = vkEnumerateDeviceLayerProperties(physical[p], &count, properties.get()); |
| ASSERT_EQ(result, VK_INCOMPLETE); |
| } |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| TEST_F(EnumerateInstanceLayerProperties, Count) { |
| uint32_t count = 0u; |
| VkResult result = vkEnumerateInstanceLayerProperties(&count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| if (std::find(arguments.begin(), arguments.end(), "count") != arguments.end()) { |
| std::cout << "count=" << count << '\n'; |
| } |
| } |
| |
| TEST_F(EnumerateInstanceLayerProperties, OnePass) { |
| // Count required for this test. |
| if (std::find(arguments.begin(), arguments.end(), "count") == arguments.end()) { |
| return; |
| } |
| |
| uint32_t count = std::stoul(arguments[2]); |
| |
| std::unique_ptr<VkLayerProperties[]> properties(new VkLayerProperties[count]); |
| VkResult result = vkEnumerateInstanceLayerProperties(&count, properties.get()); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| if (std::find(arguments.begin(), arguments.end(), "properties") != arguments.end()) { |
| for (uint32_t p = 0; p < count; ++p) { |
| std::cout << "properties[" << p << "] =" << ' ' << properties[p].layerName << ' ' << properties[p].specVersion << ' ' |
| << properties[p].implementationVersion << ' ' << properties[p].description << '\n'; |
| } |
| } |
| } |
| |
| TEST_F(EnumerateInstanceLayerProperties, TwoPass) { |
| uint32_t count = 0u; |
| VkResult result = vkEnumerateInstanceLayerProperties(&count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| std::unique_ptr<VkLayerProperties[]> properties(new VkLayerProperties[count]); |
| result = vkEnumerateInstanceLayerProperties(&count, properties.get()); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| if (std::find(arguments.begin(), arguments.end(), "properties") != arguments.end()) { |
| for (uint32_t p = 0; p < count; ++p) { |
| std::cout << "properties[" << p << "] =" << ' ' << properties[p].layerName << ' ' << properties[p].specVersion << ' ' |
| << properties[p].implementationVersion << ' ' << properties[p].description << '\n'; |
| } |
| } |
| } |
| |
| TEST_F(EnumerateInstanceExtensionProperties, PropertyCountLessThanAvailable) { |
| uint32_t count = 0u; |
| VkResult result = vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| // We need atleast two for the test to be relevant. |
| if (count < 2u) { |
| return; |
| } |
| |
| std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]); |
| count = 1; |
| result = vkEnumerateInstanceExtensionProperties(nullptr, &count, properties.get()); |
| ASSERT_EQ(result, VK_INCOMPLETE); |
| } |
| |
| TEST(EnumerateDeviceExtensionProperties, PropertyCountLessThanAvailable) { |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), 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 count = 0u; |
| result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| // We need atleast two for the test to be relevant. |
| if (count < 2u) { |
| continue; |
| } |
| |
| std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]); |
| count = 1; |
| result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, properties.get()); |
| ASSERT_EQ(result, VK_INCOMPLETE); |
| } |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| TEST_F(EnumerateInstanceExtensionProperties, Count) { |
| uint32_t count = 0u; |
| VkResult result = vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| if (std::find(arguments.begin(), arguments.end(), "count") != arguments.end()) { |
| std::cout << "count=" << count << '\n'; |
| } |
| } |
| |
| TEST_F(EnumerateInstanceExtensionProperties, OnePass) { |
| // Count required for this test. |
| if (std::find(arguments.begin(), arguments.end(), "count") == arguments.end()) { |
| return; |
| } |
| |
| uint32_t count = std::stoul(arguments[2]); |
| |
| std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]); |
| VkResult result = vkEnumerateInstanceExtensionProperties(nullptr, &count, properties.get()); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| if (std::find(arguments.begin(), arguments.end(), "properties") != arguments.end()) { |
| for (uint32_t p = 0; p < count; ++p) { |
| std::cout << "properties[" << p << "] =" << ' ' << properties[p].extensionName << ' ' << properties[p].specVersion |
| << '\n'; |
| } |
| } |
| } |
| |
| TEST_F(EnumerateInstanceExtensionProperties, TwoPass) { |
| uint32_t count = 0u; |
| VkResult result = vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]); |
| result = vkEnumerateInstanceExtensionProperties(nullptr, &count, properties.get()); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| if (std::find(arguments.begin(), arguments.end(), "properties") != arguments.end()) { |
| for (uint32_t p = 0; p < count; ++p) { |
| std::cout << "properties[" << p << "] =" << ' ' << properties[p].extensionName << ' ' << properties[p].specVersion |
| << '\n'; |
| } |
| } |
| } |
| |
| TEST_F(EnumerateInstanceExtensionProperties, InstanceExtensionEnumerated) { |
| uint32_t count = 0u; |
| VkResult result = vkEnumerateInstanceExtensionProperties(nullptr, &count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]); |
| result = vkEnumerateInstanceExtensionProperties(nullptr, &count, properties.get()); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| ASSERT_NE(std::find_if( |
| &properties[0], &properties[count], |
| [](VkExtensionProperties const &properties) { return strcmp(properties.extensionName, "VK_KHR_surface") == 0; }), |
| &properties[count]); |
| } |
| |
| TEST(EnumerateDeviceExtensionProperties, DeviceExtensionEnumerated) { |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), 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 count = 0u; |
| result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, nullptr); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| std::unique_ptr<VkExtensionProperties[]> properties(new VkExtensionProperties[count]); |
| result = vkEnumerateDeviceExtensionProperties(physical[p], nullptr, &count, properties.get()); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| ASSERT_NE(std::find_if(&properties[0], &properties[count], |
| [](VkExtensionProperties const &properties) { |
| return strcmp(properties.extensionName, "VK_KHR_swapchain") == 0; |
| }), |
| &properties[count]); |
| } |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| TEST_F(ImplicitLayer, Present) { |
| auto const info = VK::InstanceCreateInfo(); |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(info, VK_NULL_HANDLE, &instance); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| TEST(WrapObjects, Insert) { |
| VkInstance instance = VK_NULL_HANDLE; |
| VkResult result = vkCreateInstance(VK::InstanceCreateInfo(), 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 MSVC bug. |
| VkDeviceQueueCreateInfo const queueInfo[1]{ |
| VK::DeviceQueueCreateInfo().queueFamilyIndex(q).queueCount(1).pQueuePriorities(priorities)}; |
| |
| auto const deviceInfo = VK::DeviceCreateInfo().queueCreateInfoCount(1).pQueueCreateInfos(queueInfo); |
| |
| VkDevice device; |
| result = vkCreateDevice(physical[p], deviceInfo, nullptr, &device); |
| ASSERT_EQ(result, VK_SUCCESS); |
| |
| vkDestroyDevice(device, nullptr); |
| } |
| } |
| |
| vkDestroyInstance(instance, nullptr); |
| } |
| |
| int main(int argc, char **argv) { |
| int result; |
| |
| ::testing::InitGoogleTest(&argc, argv); |
| |
| if (argc > 0) { |
| CommandLine::Initialize(argc, argv); |
| } |
| |
| result = RUN_ALL_TESTS(); |
| |
| return result; |
| } |