mirror of
https://gitee.com/openharmony/third_party_vulkan-loader
synced 2024-11-26 17:02:23 +00:00
0281b281d0
Signed-off-by: andrew0229 <zhangzhao62@huawei.com> Change-Id: Ifc4224db2c6ea7c159d3cabe8f075475d47a41a8
853 lines
37 KiB
C++
853 lines
37 KiB
C++
/*
|
|
* Copyright (c) 2021-2022 The Khronos Group Inc.
|
|
* Copyright (c) 2021-2022 Valve Corporation
|
|
* Copyright (c) 2021-2022 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: Charles Giessen <charles@lunarg.com>
|
|
*/
|
|
|
|
#include "test_environment.h"
|
|
|
|
class WsiTests : public ::testing::Test {};
|
|
|
|
#if defined(VK_USE_PLATFORM_WIN32_KHR)
|
|
|
|
// When ICD doesn't support the extension, create instance should fail
|
|
TEST(WsiTests, CreateSurfaceWin32NoICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
|
|
|
|
InstWrapper inst2{env.vulkan_functions};
|
|
inst2.CheckCreate();
|
|
|
|
ASSERT_EQ(nullptr, env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkCreateWin32SurfaceKHR"));
|
|
}
|
|
|
|
// When ICD doesn't support the surface creation, the loader should handle it
|
|
TEST(WsiTests, CreateSurfaceWin32NoICDCreateSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
VkWin32SurfaceCreateInfoKHR surf_create_info{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateWin32SurfaceKHR(inst, &surf_create_info, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst, surface, nullptr);
|
|
}
|
|
|
|
// When ICD does support the surface creation, the loader should delegat handle it to the ICD
|
|
TEST(WsiTests, CreateSurfaceWin32ICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
cur_icd.enable_icd_wsi = true;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
VkWin32SurfaceCreateInfoKHR surf_create_info{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateWin32SurfaceKHR(inst, &surf_create_info, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst, surface, nullptr);
|
|
}
|
|
|
|
// Some drivers supporting vkCreateWin32SurfaceKHR, and at least one that doesn't
|
|
TEST(WsiTests, CreateSurfaceWin32MixedICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
for (uint32_t icd = 0; icd < 3; ++icd) {
|
|
Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
|
|
Extension second_ext{VK_KHR_WIN32_SURFACE_EXTENSION_NAME};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(icd);
|
|
cur_icd.icd_api_version = VK_API_VERSION_1_0;
|
|
cur_icd.add_instance_extensions({first_ext, second_ext});
|
|
if (icd < 2) {
|
|
// Only enable ICD for first two
|
|
cur_icd.enable_icd_wsi = true;
|
|
}
|
|
}
|
|
|
|
InstWrapper instance(env.vulkan_functions);
|
|
instance.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
instance.CheckCreate();
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
VkWin32SurfaceCreateInfoKHR surf_create_info{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateWin32SurfaceKHR(instance.inst, &surf_create_info, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
|
|
}
|
|
|
|
TEST(WsiTests, GetPhysicalDeviceWin32PresentNoICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
cur_icd.physical_devices.emplace_back("physical_device_0");
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions(
|
|
{VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
uint32_t driver_count = 1;
|
|
VkPhysicalDevice physical_device;
|
|
ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
|
|
ASSERT_EQ(driver_count, 1U);
|
|
|
|
DebugUtilsWrapper log{inst};
|
|
CreateDebugUtilsMessenger(log);
|
|
auto res = env.vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(physical_device, 0);
|
|
ASSERT_EQ(res, VK_FALSE);
|
|
ASSERT_TRUE(log.find("ICD for selected physical device does not export vkGetPhysicalDeviceWin32PresentationSupportKHR!"));
|
|
}
|
|
|
|
TEST(WsiTests, GetPhysicalDeviceWin32PresentICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
cur_icd.physical_devices.emplace_back("physical_device_0");
|
|
cur_icd.enable_icd_wsi = true;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
uint32_t driver_count = 1;
|
|
VkPhysicalDevice physical_device;
|
|
ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
|
|
ASSERT_EQ(driver_count, 1U);
|
|
|
|
ASSERT_EQ(VK_TRUE, env.vulkan_functions.vkGetPhysicalDeviceWin32PresentationSupportKHR(physical_device, 0));
|
|
}
|
|
|
|
TEST(WsiTests, Win32GetPhysicalDeviceSurfaceSupportKHR) {
|
|
FrameworkEnvironment env{};
|
|
const uint32_t max_device_count = 4;
|
|
for (uint32_t icd = 0; icd < max_device_count; ++icd) {
|
|
Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
|
|
Extension second_ext{VK_KHR_WIN32_SURFACE_EXTENSION_NAME};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(icd);
|
|
cur_icd.icd_api_version = VK_API_VERSION_1_0;
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extensions({first_ext, second_ext});
|
|
std::string dev_name = "phys_dev_" + std::to_string(icd);
|
|
cur_icd.physical_devices.emplace_back(dev_name.c_str());
|
|
cur_icd.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true});
|
|
cur_icd.enable_icd_wsi = true;
|
|
}
|
|
|
|
InstWrapper instance(env.vulkan_functions);
|
|
instance.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME});
|
|
instance.CheckCreate();
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
VkWin32SurfaceCreateInfoKHR surf_create_info{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateWin32SurfaceKHR(instance.inst, &surf_create_info, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
uint32_t device_count = max_device_count;
|
|
std::array<VkPhysicalDevice, max_device_count> phys_devs;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumeratePhysicalDevices(instance.inst, &device_count, phys_devs.data()));
|
|
ASSERT_EQ(device_count, max_device_count);
|
|
|
|
for (uint32_t pd = 0; pd < max_device_count; ++pd) {
|
|
VkBool32 supported = VK_FALSE;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(phys_devs[pd], 0, surface, &supported));
|
|
}
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
|
|
}
|
|
#endif
|
|
|
|
#if defined(VK_USE_PLATFORM_XCB_KHR)
|
|
// When ICD doesn't support the extension, create instance should fail
|
|
TEST(WsiTests, CreateSurfaceXCBNoICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
|
|
|
|
InstWrapper inst2{env.vulkan_functions};
|
|
inst2.CheckCreate();
|
|
|
|
ASSERT_EQ(nullptr, env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkCreateXcbSurfaceKHR"));
|
|
}
|
|
|
|
// When ICD doesn't support the surface creation, the loader should handle it
|
|
TEST(WsiTests, CreateSurfaceXCBNoICDCreateSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
VkXcbSurfaceCreateInfoKHR xcb_createInfo{VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateXcbSurfaceKHR(inst, &xcb_createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst, surface, nullptr);
|
|
}
|
|
|
|
// When ICD does support the surface creation, the loader should delegat handle it to the ICD
|
|
TEST(WsiTests, CreateSurfaceXCBICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
cur_icd.enable_icd_wsi = true;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
VkXcbSurfaceCreateInfoKHR xcb_createInfo{VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateXcbSurfaceKHR(inst, &xcb_createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst, surface, nullptr);
|
|
}
|
|
|
|
// Some drivers supporting vkCreateXcbSurfaceKHR, and at least one that doesn't
|
|
TEST(WsiTests, CreateSurfaceXCBMixedICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
for (uint32_t icd = 0; icd < 3; ++icd) {
|
|
Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
|
|
Extension second_ext{VK_KHR_XCB_SURFACE_EXTENSION_NAME};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(icd);
|
|
cur_icd.icd_api_version = VK_API_VERSION_1_0;
|
|
cur_icd.add_instance_extensions({first_ext, second_ext});
|
|
if (icd < 2) {
|
|
// Only enable ICD for first two
|
|
cur_icd.enable_icd_wsi = true;
|
|
}
|
|
}
|
|
|
|
InstWrapper instance(env.vulkan_functions);
|
|
instance.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
instance.CheckCreate();
|
|
|
|
VkXcbSurfaceCreateInfoKHR xcb_createInfo{VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateXcbSurfaceKHR(instance.inst, &xcb_createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
|
|
}
|
|
|
|
TEST(WsiTests, GetPhysicalDeviceXcbPresentNoICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
cur_icd.physical_devices.emplace_back("physical_device_0");
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions(
|
|
{VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
uint32_t driver_count = 1;
|
|
VkPhysicalDevice physical_device;
|
|
ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
|
|
ASSERT_EQ(driver_count, 1U);
|
|
|
|
DebugUtilsWrapper log{inst};
|
|
CreateDebugUtilsMessenger(log);
|
|
auto res = env.vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(physical_device, 0, nullptr, 0);
|
|
ASSERT_EQ(res, VK_FALSE);
|
|
ASSERT_TRUE(log.find("ICD for selected physical device does not export vkGetPhysicalDeviceXcbPresentationSupportKHR!"));
|
|
}
|
|
|
|
TEST(WsiTests, GetPhysicalDeviceXcbPresentICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
cur_icd.physical_devices.emplace_back("physical_device_0");
|
|
cur_icd.enable_icd_wsi = true;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
uint32_t driver_count = 1;
|
|
VkPhysicalDevice physical_device;
|
|
ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
|
|
ASSERT_EQ(driver_count, 1U);
|
|
|
|
ASSERT_EQ(VK_TRUE, env.vulkan_functions.vkGetPhysicalDeviceXcbPresentationSupportKHR(physical_device, 0, nullptr, 0));
|
|
}
|
|
|
|
TEST(WsiTests, XcbGetPhysicalDeviceSurfaceSupportKHR) {
|
|
FrameworkEnvironment env{};
|
|
const uint32_t max_device_count = 4;
|
|
for (uint32_t icd = 0; icd < max_device_count; ++icd) {
|
|
Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
|
|
Extension second_ext{VK_KHR_XCB_SURFACE_EXTENSION_NAME};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(icd);
|
|
cur_icd.icd_api_version = VK_API_VERSION_1_0;
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extensions({first_ext, second_ext});
|
|
std::string dev_name = "phys_dev_" + std::to_string(icd);
|
|
cur_icd.physical_devices.emplace_back(dev_name.c_str());
|
|
cur_icd.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true});
|
|
cur_icd.enable_icd_wsi = true;
|
|
}
|
|
|
|
InstWrapper instance(env.vulkan_functions);
|
|
instance.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XCB_SURFACE_EXTENSION_NAME});
|
|
instance.CheckCreate();
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
VkXcbSurfaceCreateInfoKHR xcb_createInfo{VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateXcbSurfaceKHR(instance.inst, &xcb_createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
uint32_t device_count = max_device_count;
|
|
std::array<VkPhysicalDevice, max_device_count> phys_devs;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumeratePhysicalDevices(instance.inst, &device_count, phys_devs.data()));
|
|
ASSERT_EQ(device_count, max_device_count);
|
|
|
|
for (uint32_t pd = 0; pd < max_device_count; ++pd) {
|
|
VkBool32 supported = VK_FALSE;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(phys_devs[pd], 0, surface, &supported));
|
|
}
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
|
|
}
|
|
#endif
|
|
|
|
#if defined(VK_USE_PLATFORM_XLIB_KHR)
|
|
// When ICD doesn't support the extension, create instance should fail
|
|
TEST(WsiTests, CreateSurfaceXLIBNoICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
|
|
|
|
InstWrapper inst2{env.vulkan_functions};
|
|
inst2.CheckCreate();
|
|
|
|
ASSERT_EQ(nullptr, env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkCreateXlibSurfaceKHR"));
|
|
}
|
|
|
|
// When ICD doesn't support the surface creation, the loader should handle it
|
|
TEST(WsiTests, CreateSurfaceXLIBNoICDCreateSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
VkXlibSurfaceCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateXlibSurfaceKHR(inst, &createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst, surface, nullptr);
|
|
}
|
|
|
|
// When ICD does support the surface creation, the loader should delegat handle it to the ICD
|
|
TEST(WsiTests, CreateSurfaceXLIBICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
cur_icd.enable_icd_wsi = true;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
VkXlibSurfaceCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateXlibSurfaceKHR(inst, &createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst, surface, nullptr);
|
|
}
|
|
|
|
// Some drivers supporting vkCreateXlibSurfaceKHR, and at least one that doesn't
|
|
TEST(WsiTests, CreateSurfaceXLIBMixedICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
for (uint32_t icd = 0; icd < 3; ++icd) {
|
|
Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
|
|
Extension second_ext{VK_KHR_XLIB_SURFACE_EXTENSION_NAME};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(icd);
|
|
cur_icd.icd_api_version = VK_API_VERSION_1_0;
|
|
cur_icd.add_instance_extensions({first_ext, second_ext});
|
|
if (icd < 2) {
|
|
// Only enable ICD for first two
|
|
cur_icd.enable_icd_wsi = true;
|
|
}
|
|
}
|
|
|
|
InstWrapper instance(env.vulkan_functions);
|
|
instance.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
instance.CheckCreate();
|
|
|
|
VkXlibSurfaceCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateXlibSurfaceKHR(instance.inst, &createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
|
|
}
|
|
|
|
TEST(WsiTests, GetPhysicalDeviceXlibPresentNoICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
cur_icd.physical_devices.emplace_back("physical_device_0");
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions(
|
|
{VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
uint32_t driver_count = 1;
|
|
VkPhysicalDevice physical_device;
|
|
ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
|
|
ASSERT_EQ(driver_count, 1U);
|
|
|
|
DebugUtilsWrapper log{inst};
|
|
CreateDebugUtilsMessenger(log);
|
|
auto res = env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(physical_device, 0, nullptr, 0);
|
|
ASSERT_EQ(res, VK_FALSE);
|
|
ASSERT_TRUE(log.find("ICD for selected physical device does not export vkGetPhysicalDeviceXlibPresentationSupportKHR!"));
|
|
}
|
|
|
|
TEST(WsiTests, GetPhysicalDeviceXlibPresentICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
cur_icd.physical_devices.emplace_back("physical_device_0");
|
|
cur_icd.enable_icd_wsi = true;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
uint32_t driver_count = 1;
|
|
VkPhysicalDevice physical_device;
|
|
ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
|
|
ASSERT_EQ(driver_count, 1U);
|
|
|
|
ASSERT_EQ(VK_TRUE, env.vulkan_functions.vkGetPhysicalDeviceXlibPresentationSupportKHR(physical_device, 0, nullptr, 0));
|
|
}
|
|
|
|
TEST(WsiTests, XlibGetPhysicalDeviceSurfaceSupportKHR) {
|
|
FrameworkEnvironment env{};
|
|
const uint32_t max_device_count = 4;
|
|
for (uint32_t icd = 0; icd < max_device_count; ++icd) {
|
|
Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
|
|
Extension second_ext{VK_KHR_XLIB_SURFACE_EXTENSION_NAME};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(icd);
|
|
cur_icd.icd_api_version = VK_API_VERSION_1_0;
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extensions({first_ext, second_ext});
|
|
std::string dev_name = "phys_dev_" + std::to_string(icd);
|
|
cur_icd.physical_devices.emplace_back(dev_name.c_str());
|
|
cur_icd.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true});
|
|
cur_icd.enable_icd_wsi = true;
|
|
}
|
|
|
|
InstWrapper instance(env.vulkan_functions);
|
|
instance.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_XLIB_SURFACE_EXTENSION_NAME});
|
|
instance.CheckCreate();
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
VkXlibSurfaceCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateXlibSurfaceKHR(instance.inst, &createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
uint32_t device_count = max_device_count;
|
|
std::array<VkPhysicalDevice, max_device_count> phys_devs;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumeratePhysicalDevices(instance.inst, &device_count, phys_devs.data()));
|
|
ASSERT_EQ(device_count, max_device_count);
|
|
|
|
for (uint32_t pd = 0; pd < max_device_count; ++pd) {
|
|
VkBool32 supported = VK_FALSE;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(phys_devs[pd], 0, surface, &supported));
|
|
}
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
|
|
}
|
|
#endif
|
|
|
|
#if defined(VK_USE_PLATFORM_WAYLAND_KHR)
|
|
// When ICD doesn't support the extension, create instance should fail
|
|
TEST(WsiTests, CreateSurfaceWaylandNoICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate(VK_ERROR_EXTENSION_NOT_PRESENT);
|
|
|
|
InstWrapper inst2{env.vulkan_functions};
|
|
inst2.CheckCreate();
|
|
|
|
ASSERT_EQ(nullptr, env.vulkan_functions.vkGetInstanceProcAddr(inst2.inst, "vkCreateWaylandSurfaceKHR"));
|
|
}
|
|
|
|
// When ICD doesn't support the surface creation, the loader should handle it
|
|
TEST(WsiTests, CreateSurfaceWaylandNoICDCreateSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
VkWaylandSurfaceCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateWaylandSurfaceKHR(inst, &createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst, surface, nullptr);
|
|
}
|
|
|
|
// When ICD does support the surface creation, the loader should delegat handle it to the ICD
|
|
TEST(WsiTests, CreateSurfaceWaylandICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
cur_icd.enable_icd_wsi = true;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
VkWaylandSurfaceCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateWaylandSurfaceKHR(inst, &createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst, surface, nullptr);
|
|
}
|
|
|
|
// Some drivers supporting vkCreateWaylandSurfaceKHR, and at least one that doesn't
|
|
TEST(WsiTests, CreateSurfaceWaylandMixedICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
for (uint32_t icd = 0; icd < 3; ++icd) {
|
|
Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
|
|
Extension second_ext{VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(icd);
|
|
cur_icd.icd_api_version = VK_API_VERSION_1_0;
|
|
cur_icd.add_instance_extensions({first_ext, second_ext});
|
|
if (icd < 2) {
|
|
// Only enable ICD for first two
|
|
cur_icd.enable_icd_wsi = true;
|
|
}
|
|
}
|
|
|
|
InstWrapper instance(env.vulkan_functions);
|
|
instance.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
instance.CheckCreate();
|
|
|
|
VkWaylandSurfaceCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR};
|
|
|
|
VkSurfaceKHR surface;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateWaylandSurfaceKHR(instance.inst, &createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
|
|
}
|
|
|
|
TEST(WsiTests, GetPhysicalDeviceWaylandPresentNoICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
cur_icd.physical_devices.emplace_back("physical_device_0");
|
|
cur_icd.enable_icd_wsi = false;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions(
|
|
{VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME, VK_EXT_DEBUG_UTILS_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
uint32_t driver_count = 1;
|
|
VkPhysicalDevice physical_device;
|
|
ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
|
|
ASSERT_EQ(driver_count, 1U);
|
|
|
|
DebugUtilsWrapper log{inst};
|
|
CreateDebugUtilsMessenger(log);
|
|
auto res = env.vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(physical_device, 0, nullptr);
|
|
ASSERT_EQ(res, VK_FALSE);
|
|
ASSERT_TRUE(log.find("ICD for selected physical device does not export vkGetPhysicalDeviceWaylandPresentationSupportKHR!"));
|
|
}
|
|
|
|
TEST(WsiTests, GetPhysicalDeviceWaylandPresentICDSupport) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(0);
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extension({VK_KHR_SURFACE_EXTENSION_NAME});
|
|
cur_icd.add_instance_extension({VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
cur_icd.physical_devices.emplace_back("physical_device_0");
|
|
cur_icd.enable_icd_wsi = true;
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
inst.CheckCreate();
|
|
|
|
uint32_t driver_count = 1;
|
|
VkPhysicalDevice physical_device;
|
|
ASSERT_EQ(VK_SUCCESS, inst->vkEnumeratePhysicalDevices(inst, &driver_count, &physical_device));
|
|
ASSERT_EQ(driver_count, 1U);
|
|
|
|
ASSERT_EQ(VK_TRUE, env.vulkan_functions.vkGetPhysicalDeviceWaylandPresentationSupportKHR(physical_device, 0, nullptr));
|
|
}
|
|
|
|
TEST(WsiTests, WaylandGetPhysicalDeviceSurfaceSupportKHR) {
|
|
FrameworkEnvironment env{};
|
|
const uint32_t max_device_count = 4;
|
|
for (uint32_t icd = 0; icd < max_device_count; ++icd) {
|
|
Extension first_ext{VK_KHR_SURFACE_EXTENSION_NAME};
|
|
Extension second_ext{VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2));
|
|
auto& cur_icd = env.get_test_icd(icd);
|
|
cur_icd.icd_api_version = VK_API_VERSION_1_0;
|
|
cur_icd.set_min_icd_interface_version(5);
|
|
cur_icd.add_instance_extensions({first_ext, second_ext});
|
|
std::string dev_name = "phys_dev_" + std::to_string(icd);
|
|
cur_icd.physical_devices.emplace_back(dev_name.c_str());
|
|
cur_icd.physical_devices.back().add_queue_family_properties({{VK_QUEUE_GRAPHICS_BIT, 1, 0, {1, 1, 1}}, true});
|
|
cur_icd.enable_icd_wsi = true;
|
|
}
|
|
|
|
InstWrapper instance(env.vulkan_functions);
|
|
instance.create_info.add_extensions({VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME});
|
|
instance.CheckCreate();
|
|
|
|
VkSurfaceKHR surface{VK_NULL_HANDLE};
|
|
VkWaylandSurfaceCreateInfoKHR createInfo{VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR};
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkCreateWaylandSurfaceKHR(instance.inst, &createInfo, nullptr, &surface));
|
|
ASSERT_TRUE(surface != VK_NULL_HANDLE);
|
|
|
|
uint32_t device_count = max_device_count;
|
|
std::array<VkPhysicalDevice, max_device_count> phys_devs;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkEnumeratePhysicalDevices(instance.inst, &device_count, phys_devs.data()));
|
|
ASSERT_EQ(device_count, max_device_count);
|
|
|
|
for (uint32_t pd = 0; pd < max_device_count; ++pd) {
|
|
VkBool32 supported = VK_FALSE;
|
|
ASSERT_EQ(VK_SUCCESS, env.vulkan_functions.vkGetPhysicalDeviceSurfaceSupportKHR(phys_devs[pd], 0, surface, &supported));
|
|
}
|
|
|
|
env.vulkan_functions.vkDestroySurfaceKHR(instance.inst, surface, nullptr);
|
|
}
|
|
#endif
|
|
|
|
TEST(WsiTests, ForgetEnableSurfaceExtensions) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
|
|
.setup_WSI()
|
|
.add_physical_device(PhysicalDevice{}.add_extension("VK_KHR_swapchain").finish());
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.add_extension("VK_KHR_surface");
|
|
ASSERT_NO_FATAL_FAILURE(inst.CheckCreate());
|
|
|
|
VkSurfaceKHR surface{};
|
|
ASSERT_EQ(VK_ERROR_EXTENSION_NOT_PRESENT, create_surface(inst, surface));
|
|
}
|
|
|
|
TEST(WsiTests, SwapchainFunctional) {
|
|
FrameworkEnvironment env{};
|
|
env.add_icd(TestICDDetails(TEST_ICD_PATH_VERSION_2))
|
|
.setup_WSI()
|
|
.add_physical_device(PhysicalDevice{}.add_extension("VK_KHR_swapchain").finish());
|
|
|
|
InstWrapper inst{env.vulkan_functions};
|
|
inst.create_info.setup_WSI();
|
|
inst.CheckCreate();
|
|
VkSurfaceKHR surface{};
|
|
ASSERT_EQ(VK_SUCCESS, create_surface(inst, surface));
|
|
VkPhysicalDevice phys_dev = inst.GetPhysDev();
|
|
|
|
{ // Use GDPA to get functions
|
|
DeviceWrapper dev{inst};
|
|
dev.create_info.add_extension("VK_KHR_swapchain");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(dev.CheckCreate(phys_dev));
|
|
|
|
VkSwapchainKHR swapchain{};
|
|
VkSwapchainCreateInfoKHR swap_create_info{};
|
|
swap_create_info.surface = surface;
|
|
DeviceFunctions funcs{*inst.functions, dev};
|
|
ASSERT_EQ(VK_SUCCESS, funcs.vkCreateSwapchainKHR(dev, &swap_create_info, nullptr, &swapchain));
|
|
uint32_t count = 0;
|
|
ASSERT_EQ(VK_SUCCESS, funcs.vkGetSwapchainImagesKHR(dev, swapchain, &count, nullptr));
|
|
ASSERT_GT(count, 0U);
|
|
std::array<VkImage, 16> images;
|
|
ASSERT_EQ(VK_SUCCESS, funcs.vkGetSwapchainImagesKHR(dev, swapchain, &count, images.data()));
|
|
funcs.vkDestroySwapchainKHR(dev, swapchain, nullptr);
|
|
}
|
|
{ // Use GIPA gotten functions
|
|
DeviceWrapper dev{inst};
|
|
dev.create_info.add_extension("VK_KHR_swapchain");
|
|
|
|
ASSERT_NO_FATAL_FAILURE(dev.CheckCreate(phys_dev));
|
|
|
|
PFN_vkCreateSwapchainKHR inst_CreateSwapchainKHR = inst.load("vkCreateSwapchainKHR");
|
|
PFN_vkGetSwapchainImagesKHR inst_GetSwapchainImagesKHR = inst.load("vkGetSwapchainImagesKHR");
|
|
PFN_vkDestroySwapchainKHR inst_DestroySwapchainKHR = inst.load("vkDestroySwapchainKHR");
|
|
ASSERT_TRUE(nullptr != inst_CreateSwapchainKHR);
|
|
ASSERT_TRUE(nullptr != inst_GetSwapchainImagesKHR);
|
|
ASSERT_TRUE(nullptr != inst_DestroySwapchainKHR);
|
|
|
|
VkSwapchainKHR swapchain{};
|
|
VkSwapchainCreateInfoKHR swap_create_info{};
|
|
swap_create_info.surface = surface;
|
|
|
|
ASSERT_EQ(VK_SUCCESS, inst_CreateSwapchainKHR(dev, &swap_create_info, nullptr, &swapchain));
|
|
uint32_t count = 0;
|
|
ASSERT_EQ(VK_SUCCESS, inst_GetSwapchainImagesKHR(dev, swapchain, &count, nullptr));
|
|
ASSERT_GT(count, 0U);
|
|
std::array<VkImage, 16> images;
|
|
ASSERT_EQ(VK_SUCCESS, inst_GetSwapchainImagesKHR(dev, swapchain, &count, images.data()));
|
|
inst_DestroySwapchainKHR(dev, swapchain, nullptr);
|
|
}
|
|
{ // forget to enable the extension
|
|
DeviceWrapper dev{inst};
|
|
ASSERT_NO_FATAL_FAILURE(dev.CheckCreate(phys_dev));
|
|
|
|
DeviceFunctions funcs{*inst.functions, dev};
|
|
ASSERT_EQ(funcs.vkCreateSwapchainKHR, nullptr);
|
|
ASSERT_EQ(funcs.vkGetSwapchainImagesKHR, nullptr);
|
|
ASSERT_EQ(funcs.vkDestroySwapchainKHR, nullptr);
|
|
}
|
|
{ // forget to set the surface
|
|
DeviceWrapper dev{inst};
|
|
dev.create_info.add_extension("VK_KHR_swapchain");
|
|
|
|
dev.CheckCreate(phys_dev);
|
|
|
|
VkSwapchainKHR swapchain{};
|
|
VkSwapchainCreateInfoKHR swap_create_info{};
|
|
DeviceFunctions funcs{*inst.functions, dev};
|
|
ASSERT_DEATH(funcs.vkCreateSwapchainKHR(dev, &swap_create_info, nullptr, &swapchain), "");
|
|
}
|
|
env.vulkan_functions.vkDestroySurfaceKHR(inst.inst, surface, nullptr);
|
|
}
|