1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, Hardware
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstddef>
17 #include <window.h>
18 #include <gtest/gtest.h>
19 #include <dlfcn.h>
20 #include <iostream>
21 #include <string>
22 #include <vector>
23 #include <sstream>
24
25 #include "refbase.h"
26 #include "surface.h"
27 #include "vulkan/vulkan.h"
28 #include "render_context/render_context.h"
29 #include "transaction/rs_transaction.h"
30 #include "ui/rs_surface_extractor.h"
31 #include "ui/rs_surface_node.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35 using namespace OHOS::Rosen;
36
37 namespace vulkan::loader {
38 class VulkanLoaderUnitTest : public testing::Test {
39 public:
SetUpTestCase()40 static void SetUpTestCase() {}
41 static void TearDownTestCase();
SetUp()42 void SetUp() {}
TearDown()43 void TearDown() {}
44 uint32_t GetQueueFamilyIndex(VkQueueFlagBits queueFlags);
45 OHNativeWindow* CreateNativeWindow(std::string name);
46 VkSwapchainCreateInfoKHR GetSwapchainCreateInfo(VkFormat imageFormat, VkColorSpaceKHR imageColorSpace);
47 static VkBool32 UserCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
48 VkDebugUtilsMessageTypeFlagsEXT messageType,
49 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
50 void* pUserData);
51
52 static inline void DLOpenLibVulkan();
53 static inline void TrytoCreateVkInstance();
54
55 static inline PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
56 static inline PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
57 static inline PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
58 static inline PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
59 static inline PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT;
60 static inline PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT;
61 static inline PFN_vkCreateInstance vkCreateInstance;
62 static inline PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
63 static inline PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
64
65 static inline PFN_vkDestroyInstance vkDestroyInstance;
66 static inline PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
67 static inline PFN_vkCreateDevice vkCreateDevice;
68 static inline PFN_vkDestroyDevice vkDestroyDevice;
69 static inline PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
70 static inline PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS;
71 static inline PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
72 static inline PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
73 static inline PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fpGetPhysicalDeviceSurfaceFormatsKHR;
74 static inline PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
75 static inline PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
76 static inline PFN_vkAcquireNextImage2KHR fpAcquireNextImage2KHR;
77 static inline PFN_vkQueuePresentKHR fpQueuePresentKHR;
78 static inline PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
79 static inline PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
80 static inline PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
81 static inline PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
82 static inline PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
83 static inline PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
84
85 static inline void *libVulkan_ = nullptr;
86 static inline VkInstance instance_ = nullptr;
87 static inline VkSurfaceKHR surface_ = VK_NULL_HANDLE;
88 static inline VkPhysicalDevice physicalDevice_ = nullptr;
89 static inline VkDevice device_ = nullptr;
90 static inline VkSurfaceCapabilitiesKHR surfCaps_ = {};
91 static inline VkSurfaceFormatKHR surfaceFormat_ = {};
92 static inline VkSwapchainKHR swapChain_ = VK_NULL_HANDLE;
93 static inline VkSwapchainKHR swapChain2_ = VK_NULL_HANDLE;
94 static inline VkSemaphore semaphore_ = VK_NULL_HANDLE;
95 static inline bool isSupportedVulkan_ = false;
96 static inline std::vector<VkQueueFamilyProperties> queueProps_;
97 static inline uint32_t queueCount_;
98 static inline VkDebugUtilsMessengerEXT debugUtilsMessenger = VK_NULL_HANDLE;
99 static inline std::stringstream debugMessage_;
100 };
101
DLOpenLibVulkan()102 void VulkanLoaderUnitTest::DLOpenLibVulkan()
103 {
104 #ifdef __aarch64__
105 const char *path = "/system/lib64/libvulkan.so";
106 #else
107 const char *path = "/system/lib/libvulkan.so";
108 #endif
109 libVulkan_ = dlopen(path, RTLD_NOW | RTLD_LOCAL);
110 if (libVulkan_ == nullptr) {
111 std::cout << "dlerror: " << dlerror() << std::endl;
112 isSupportedVulkan_ = false;
113 return;
114 }
115 isSupportedVulkan_ = true;
116 }
117
TrytoCreateVkInstance()118 void VulkanLoaderUnitTest::TrytoCreateVkInstance()
119 {
120 VkApplicationInfo appInfo = {};
121 appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
122 appInfo.pApplicationName = "pApplicationName";
123 appInfo.pEngineName = "pEngineName";
124 appInfo.apiVersion = VK_API_VERSION_1_0;
125
126 std::vector<const char*> instanceExtensions = {
127 VK_KHR_SURFACE_EXTENSION_NAME,
128 VK_OHOS_SURFACE_EXTENSION_NAME,
129 VK_EXT_DEBUG_UTILS_EXTENSION_NAME
130 };
131
132 VkInstanceCreateInfo instanceCreateInfo = {};
133 instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
134 instanceCreateInfo.pNext = NULL;
135 instanceCreateInfo.pApplicationInfo = &appInfo;
136
137 instanceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(instanceExtensions.size());
138 instanceCreateInfo.ppEnabledExtensionNames = instanceExtensions.data();
139
140 VkResult result = vkCreateInstance(&instanceCreateInfo, nullptr, &instance_);
141 if (result == VK_ERROR_INCOMPATIBLE_DRIVER) {
142 isSupportedVulkan_ = false;
143 } else {
144 isSupportedVulkan_ = true;
145 }
146 std::cout << "TrytoCreateVkInstance result: " << result << std::endl;
147 }
148
GetSwapchainCreateInfo(VkFormat imageFormat,VkColorSpaceKHR imageColorSpace)149 VkSwapchainCreateInfoKHR VulkanLoaderUnitTest::GetSwapchainCreateInfo(
150 VkFormat imageFormat, VkColorSpaceKHR imageColorSpace)
151 {
152 VkSwapchainCreateInfoKHR swapchainCI = {};
153 swapchainCI.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
154 swapchainCI.surface = surface_;
155 uint32_t desiredNumberOfSwapchainImages = surfCaps_.minImageCount + 1;
156 swapchainCI.minImageCount = desiredNumberOfSwapchainImages;
157 swapchainCI.imageFormat = imageFormat;
158 swapchainCI.imageColorSpace = imageColorSpace;
159 uint32_t width = 1280;
160 uint32_t height = 720;
161 swapchainCI.imageExtent = { width, height };
162 swapchainCI.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
163 swapchainCI.preTransform = (VkSurfaceTransformFlagBitsKHR)VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
164 swapchainCI.imageArrayLayers = 1;
165 swapchainCI.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
166 swapchainCI.queueFamilyIndexCount = 0;
167 swapchainCI.presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
168 swapchainCI.oldSwapchain = swapChain_;
169 swapchainCI.clipped = VK_TRUE;
170 swapchainCI.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
171
172 return swapchainCI;
173 }
174
CreateNativeWindow(std::string name)175 OHNativeWindow* VulkanLoaderUnitTest::CreateNativeWindow(std::string name)
176 {
177 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
178 rsSurfaceNodeConfig.SurfaceNodeName = "createSurface_test";
179 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
180 OHOS::sptr<OHOS::Surface> surf = surfaceNode->GetSurface();
181 OHNativeWindow* nativeWindow = CreateNativeWindowFromSurface(&surf);
182 return nativeWindow;
183 }
184
GetQueueFamilyIndex(VkQueueFlagBits queueFlags)185 uint32_t VulkanLoaderUnitTest::GetQueueFamilyIndex(VkQueueFlagBits queueFlags)
186 {
187 decltype(queueProps_.size()) i = 0;
188 if (queueFlags & VK_QUEUE_COMPUTE_BIT) {
189 for (i = 0; i < queueProps_.size(); i++) {
190 if ((queueProps_[i].queueFlags & queueFlags) &&
191 ((queueProps_[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)) {
192 return i;
193 }
194 }
195 }
196 if (queueFlags & VK_QUEUE_TRANSFER_BIT) {
197 for (i = 0; i < queueProps_.size(); i++) {
198 if ((queueProps_[i].queueFlags & queueFlags) &&
199 ((queueProps_[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) &&
200 ((queueProps_[i].queueFlags & VK_QUEUE_COMPUTE_BIT) == 0)) {
201 return i;
202 }
203 }
204 }
205 for (i = 0; i < queueProps_.size(); i++) {
206 if (queueProps_[i].queueFlags & queueFlags) {
207 return i;
208 }
209 }
210 std::cout << "Could not find a matching queue family index" << std::endl;
211 return -1;
212 }
213
UserCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VkDebugUtilsMessageTypeFlagsEXT messageType,const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData,void * pUserData)214 VkBool32 VulkanLoaderUnitTest::UserCallback(
215 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
216 VkDebugUtilsMessageTypeFlagsEXT messageType,
217 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
218 void* pUserData)
219 {
220 std::string prefix("");
221 if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
222 prefix = "ERROR: ";
223 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
224 prefix = "WARN: ";
225 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
226 prefix = "INFO: ";
227 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
228 prefix = "DEBUG: ";
229 }
230 debugMessage_ << prefix << "[" << pCallbackData->messageIdNumber << "]["
231 << pCallbackData->pMessageIdName << "] : " << pCallbackData->pMessage;
232 return VK_FALSE;
233 }
234
TearDownTestCase()235 void VulkanLoaderUnitTest::TearDownTestCase()
236 {
237 if (device_ != nullptr) {
238 if (swapChain_ != VK_NULL_HANDLE) {
239 fpDestroySwapchainKHR(device_, swapChain_, nullptr);
240 }
241 vkDestroyDevice(device_, nullptr);
242 }
243 if (instance_ != nullptr) {
244 if (surface_ != VK_NULL_HANDLE) {
245 vkDestroySurfaceKHR(instance_, surface_, nullptr);
246 }
247 vkDestroyInstance(instance_, nullptr);
248 }
249 }
250
251 /**
252 * @tc.name: Load base Vulkan functions
253 * @tc.desc: Load base Vulkan functions
254 * @tc.type: FUNC
255 * @tc.require: issueI6SKRO
256 */
257 HWTEST_F(VulkanLoaderUnitTest, LoadBaseFuncPtr, TestSize.Level1)
258 {
259 DLOpenLibVulkan();
260 if (isSupportedVulkan_) {
261 EXPECT_NE(libVulkan_, nullptr);
262
263 // Load base functions
264 vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
265 dlsym(libVulkan_, "vkEnumerateInstanceExtensionProperties"));
266 EXPECT_NE(vkEnumerateInstanceExtensionProperties, nullptr);
267 vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
268 dlsym(libVulkan_, "vkEnumerateInstanceLayerProperties"));
269 EXPECT_NE(vkEnumerateInstanceLayerProperties, nullptr);
270 vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(
271 dlsym(libVulkan_, "vkEnumerateDeviceExtensionProperties"));
272 EXPECT_NE(vkEnumerateDeviceExtensionProperties, nullptr);
273 vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(
274 dlsym(libVulkan_, "vkEnumerateDeviceLayerProperties"));
275 EXPECT_NE(vkEnumerateDeviceLayerProperties, nullptr);
276 vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dlsym(libVulkan_, "vkCreateInstance"));
277 EXPECT_NE(vkCreateInstance, nullptr);
278 vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(libVulkan_, "vkGetInstanceProcAddr"));
279 EXPECT_NE(vkGetInstanceProcAddr, nullptr);
280 vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(dlsym(libVulkan_, "vkGetDeviceProcAddr"));
281 EXPECT_NE(vkGetDeviceProcAddr, nullptr);
282 TrytoCreateVkInstance();
283 }
284 }
285
286 /**
287 * @tc.name: test vkEnumerateInstanceExtensionProperties
288 * @tc.desc: test vkEnumerateInstanceExtensionProperties
289 * @tc.type: FUNC
290 * @tc.require: issueI6SKRO
291 */
292 HWTEST_F(VulkanLoaderUnitTest, vkEnumerateInstanceExtensionProperties_Test, TestSize.Level1)
293 {
294 if (isSupportedVulkan_) {
295 uint32_t extCount = 0;
296 VkResult err = vkEnumerateInstanceExtensionProperties(nullptr, &extCount, nullptr);
297 EXPECT_EQ(err, VK_SUCCESS);
298 if (extCount > 0) {
299 std::vector<VkExtensionProperties> extensions(extCount);
300 err = vkEnumerateInstanceExtensionProperties(nullptr, &extCount, extensions.data());
301 EXPECT_EQ(err, VK_SUCCESS);
302 }
303 }
304 }
305
306 /**
307 * @tc.name: test vkEnumerateInstanceLayerProperties
308 * @tc.desc: test vkEnumerateInstanceLayerProperties
309 * @tc.type: FUNC
310 * @tc.require: issueI6SKRO
311 */
312 HWTEST_F(VulkanLoaderUnitTest, vkEnumerateInstanceLayerProperties_Test, TestSize.Level1)
313 {
314 if (isSupportedVulkan_) {
315 uint32_t propertyCount = 0;
316 VkResult err = vkEnumerateInstanceLayerProperties(&propertyCount, nullptr);
317 EXPECT_EQ(err, VK_SUCCESS);
318 if (propertyCount > 0) {
319 std::vector<VkLayerProperties> properties(propertyCount);
320 err = vkEnumerateInstanceLayerProperties(&propertyCount, properties.data());
321 EXPECT_EQ(err, VK_SUCCESS);
322 }
323 }
324 }
325
326 /**
327 * @tc.name: load instance based function pointer
328 * @tc.desc: load instance based function pointer
329 * @tc.type: FUNC
330 * @tc.require: issueI6SKRO
331 */
332 HWTEST_F(VulkanLoaderUnitTest, LoadInstanceFuncPtr, TestSize.Level1)
333 {
334 if (isSupportedVulkan_) {
335 vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
336 vkGetInstanceProcAddr(instance_, "vkDestroyInstance"));
337 EXPECT_NE(vkDestroyInstance, nullptr);
338 vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(
339 vkGetInstanceProcAddr(instance_, "vkEnumeratePhysicalDevices"));
340 EXPECT_NE(vkEnumeratePhysicalDevices, nullptr);
341 vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(vkGetInstanceProcAddr(instance_, "vkCreateDevice"));
342 EXPECT_NE(vkCreateDevice, nullptr);
343 vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(vkGetInstanceProcAddr(instance_, "vkDestroyDevice"));
344 EXPECT_NE(vkDestroyDevice, nullptr);
345 vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(
346 vkGetInstanceProcAddr(instance_, "vkDestroySurfaceKHR"));
347 EXPECT_NE(vkDestroySurfaceKHR, nullptr);
348
349 vkCreateSurfaceOHOS = reinterpret_cast<PFN_vkCreateSurfaceOHOS>(
350 vkGetInstanceProcAddr(instance_, "vkCreateSurfaceOHOS"));
351 EXPECT_NE(vkCreateSurfaceOHOS, nullptr);
352
353 fpGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(
354 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
355 EXPECT_NE(fpGetPhysicalDeviceSurfaceCapabilitiesKHR, nullptr);
356 fpGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(
357 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
358 EXPECT_NE(fpGetPhysicalDeviceSurfacePresentModesKHR, nullptr);
359 fpGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(
360 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
361 EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
362 vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(
363 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceQueueFamilyProperties"));
364 EXPECT_NE(vkGetPhysicalDeviceQueueFamilyProperties, nullptr);
365 vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(
366 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceProperties"));
367 EXPECT_NE(vkGetPhysicalDeviceProperties, nullptr);
368 vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(
369 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceFeatures"));
370 EXPECT_NE(vkGetPhysicalDeviceFeatures, nullptr);
371 vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(
372 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceMemoryProperties"));
373 EXPECT_NE(vkGetPhysicalDeviceMemoryProperties, nullptr);
374 vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(
375 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceSupportKHR"));
376 EXPECT_NE(vkGetPhysicalDeviceSurfaceSupportKHR, nullptr);
377 vkCreateDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(
378 vkGetInstanceProcAddr(instance_, "vkCreateDebugUtilsMessengerEXT"));
379 EXPECT_NE(vkCreateDebugUtilsMessengerEXT, nullptr);
380 vkDestroyDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(
381 vkGetInstanceProcAddr(instance_, "vkDestroyDebugUtilsMessengerEXT"));
382 EXPECT_NE(vkDestroyDebugUtilsMessengerEXT, nullptr);
383 }
384 }
385
386 /**
387 * @tc.name: test vkEnumeratePhysicalDevices
388 * @tc.desc: test vkEnumeratePhysicalDevices
389 * @tc.type: FUNC
390 * @tc.require: issueI6SKRO
391 */
392 HWTEST_F(VulkanLoaderUnitTest, vkEnumeratePhysicalDevices_Test, TestSize.Level1)
393 {
394 if (isSupportedVulkan_) {
395 EXPECT_NE(instance_, nullptr);
396
397 uint32_t gpuCount = 0;
398 VkResult err = vkEnumeratePhysicalDevices(instance_, &gpuCount, nullptr);
399 EXPECT_EQ(err, VK_SUCCESS);
400 EXPECT_NE(gpuCount, 0);
401 std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
402 err = vkEnumeratePhysicalDevices(instance_, &gpuCount, physicalDevices.data());
403 EXPECT_EQ(err, VK_SUCCESS);
404 physicalDevice_ = physicalDevices[0];
405 EXPECT_NE(physicalDevice_, nullptr);
406
407 VkPhysicalDeviceProperties deviceProperties;
408 VkPhysicalDeviceFeatures deviceFeatures;
409 VkPhysicalDeviceMemoryProperties deviceMemoryProperties;
410 vkGetPhysicalDeviceProperties(physicalDevice_, &deviceProperties);
411 vkGetPhysicalDeviceFeatures(physicalDevice_, &deviceFeatures);
412 vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &deviceMemoryProperties);
413 }
414 }
415
416 /**
417 * @tc.name: test vkEnumerateDeviceExtensionProperties
418 * @tc.desc: test vkEnumerateDeviceExtensionProperties
419 * @tc.type: FUNC
420 * @tc.require: issueI6SKRO
421 */
422 HWTEST_F(VulkanLoaderUnitTest, vkEnumerateDeviceExtensionProperties_Test, TestSize.Level1)
423 {
424 if (isSupportedVulkan_) {
425 uint32_t extCount = 0;
426 VkResult err = vkEnumerateDeviceExtensionProperties(physicalDevice_, nullptr, &extCount, nullptr);
427 EXPECT_EQ(err, VK_SUCCESS);
428 if (extCount > 0) {
429 std::vector<VkExtensionProperties> extensions(extCount);
430 err = vkEnumerateDeviceExtensionProperties(physicalDevice_, nullptr, &extCount, extensions.data());
431 EXPECT_EQ(err, VK_SUCCESS);
432 }
433 }
434 }
435
436 /**
437 * @tc.name: test vkEnumerateDeviceLayerProperties
438 * @tc.desc: test vkEnumerateDeviceLayerProperties
439 * @tc.type: FUNC
440 * @tc.require: issueI6SKRO
441 */
442 HWTEST_F(VulkanLoaderUnitTest, vkEnumerateDeviceLayerProperties_Test, TestSize.Level1)
443 {
444 if (isSupportedVulkan_) {
445 uint32_t propertyCount = 0;
446 VkResult err = vkEnumerateDeviceLayerProperties(physicalDevice_, &propertyCount, nullptr);
447 EXPECT_EQ(err, VK_SUCCESS);
448 if (propertyCount > 0) {
449 std::vector<VkLayerProperties> properties(propertyCount);
450 err = vkEnumerateDeviceLayerProperties(physicalDevice_, &propertyCount, properties.data());
451 EXPECT_EQ(err, VK_SUCCESS);
452 }
453 }
454 }
455
456 /**
457 * @tc.name: test vkGetPhysicalDeviceQueueFamilyProperties
458 * @tc.desc: test vkGetPhysicalDeviceQueueFamilyProperties
459 * @tc.type: FUNC
460 * @tc.require: issueI6SKRO
461 */
462 HWTEST_F(VulkanLoaderUnitTest, vkGetPhysicalDeviceQueueFamilyProperties_Test, TestSize.Level1)
463 {
464 if (isSupportedVulkan_) {
465 vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueCount_, NULL);
466 EXPECT_GT(queueCount_, 0);
467
468 queueProps_.resize(queueCount_);
469 vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueCount_, queueProps_.data());
470 }
471 }
472
473 /**
474 * @tc.name: test vkCreateDevice
475 * @tc.desc: test vkCreateDevice
476 * @tc.type: FUNC
477 * @tc.require: issueI6SKRO
478 */
479 HWTEST_F(VulkanLoaderUnitTest, vkCreateDevice_Test, TestSize.Level1)
480 {
481 if (isSupportedVulkan_) {
482 EXPECT_NE(vkCreateDevice, nullptr);
483 EXPECT_NE(physicalDevice_, nullptr);
484
485 VkDeviceCreateInfo deviceCreateInfo = {};
486 deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
487
488 std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
489 const float defaultQueuePriority(0.0f);
490 VkDeviceQueueCreateInfo queueInfo{};
491 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
492 queueInfo.queueFamilyIndex = GetQueueFamilyIndex(VK_QUEUE_GRAPHICS_BIT);
493 queueInfo.queueCount = 1;
494 queueInfo.pQueuePriorities = &defaultQueuePriority;
495 queueCreateInfos.push_back(queueInfo);
496 deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());;
497 deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
498
499 std::vector<const char*> deviceExtensions;
500 deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
501 deviceCreateInfo.enabledExtensionCount = (uint32_t)deviceExtensions.size();
502 deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
503 VkDevice logicalDevice;
504 VkResult err = vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &logicalDevice);
505 EXPECT_EQ(err, VK_SUCCESS);
506 EXPECT_NE(logicalDevice, nullptr);
507 device_ = logicalDevice;
508 }
509 }
510
511 /**
512 * @tc.name: test vkCreateSurfaceOHOS
513 * @tc.desc: test vkCreateSurfaceOHOS
514 * @tc.type: FUNC
515 * @tc.require: issueI6SKRO
516 */
517 HWTEST_F(VulkanLoaderUnitTest, vkCreateSurfaceOHOS_Test, TestSize.Level1)
518 {
519 if (isSupportedVulkan_) {
520 EXPECT_NE(vkCreateSurfaceOHOS, nullptr);
521 EXPECT_NE(instance_, nullptr);
522
523 OHNativeWindow* nativeWindow = CreateNativeWindow("createSurfaceUT");
524 EXPECT_NE(nativeWindow, nullptr);
525 VkSurfaceCreateInfoOHOS surfaceCreateInfo = {};
526 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS;
527 surfaceCreateInfo.window = nativeWindow;
528 VkResult err = vkCreateSurfaceOHOS(instance_, &surfaceCreateInfo, NULL, &surface_);
529 EXPECT_EQ(err, VK_SUCCESS);
530 EXPECT_NE(surface_, VK_NULL_HANDLE);
531 }
532 }
533
534 /**
535 * @tc.name: test vkCreateSurfaceOHOS 2
536 * @tc.desc: test vkCreateSurfaceOHOS 2
537 * @tc.type: FUNC
538 * @tc.require: issueI6SKRO
539 */
540 HWTEST_F(VulkanLoaderUnitTest, vkCreateSurfaceOHOS_Test2, TestSize.Level1)
541 {
542 if (isSupportedVulkan_) {
543 EXPECT_NE(vkCreateSurfaceOHOS, nullptr);
544 EXPECT_NE(instance_, nullptr);
545
546 OHNativeWindow* nativeWindow = CreateNativeWindow("createSurfaceUT2");
547 EXPECT_NE(nativeWindow, nullptr);
548 int ret = NativeWindowHandleOpt(nativeWindow, SET_USAGE, 0);
549 EXPECT_EQ(ret, OHOS::GSERROR_OK);
550 VkSurfaceCreateInfoOHOS surfaceCreateInfo = {};
551 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS;
552 surfaceCreateInfo.window = nativeWindow;
553 VkSurfaceKHR surface2 = VK_NULL_HANDLE;
554 VkResult err = vkCreateSurfaceOHOS(instance_, &surfaceCreateInfo, NULL, &surface2);
555 EXPECT_NE(err, VK_SUCCESS);
556 EXPECT_EQ(surface2, VK_NULL_HANDLE);
557 }
558 }
559
560 /**
561 * @tc.name: test vkGetPhysicalDeviceSurfaceSupportKHR
562 * @tc.desc: test vkGetPhysicalDeviceSurfaceSupportKHR
563 * @tc.type: FUNC
564 * @tc.require: issueI6SKRO
565 */
566 HWTEST_F(VulkanLoaderUnitTest, vkGetPhysicalDeviceSurfaceSupportKHR_Test, TestSize.Level1)
567 {
568 if (isSupportedVulkan_) {
569 std::vector<VkBool32> supportsPresent(queueCount_);
570 for (uint32_t i = 0; i < queueCount_; i++) {
571 vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice_, i, surface_, &supportsPresent[i]);
572 }
573 }
574 }
575
576 /**
577 * @tc.name: load device based function pointer
578 * @tc.desc: load device based function pointer
579 * @tc.type: FUNC
580 * @tc.require: issueI6SKRO
581 */
582 HWTEST_F(VulkanLoaderUnitTest, LoadDeviceFuncPtr, TestSize.Level1)
583 {
584 if (isSupportedVulkan_) {
585 EXPECT_NE(device_, nullptr);
586
587 fpCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(
588 vkGetDeviceProcAddr(device_, "vkCreateSwapchainKHR"));
589 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
590 fpDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(
591 vkGetDeviceProcAddr(device_, "vkDestroySwapchainKHR"));
592 EXPECT_NE(fpDestroySwapchainKHR, nullptr);
593 fpAcquireNextImage2KHR = reinterpret_cast<PFN_vkAcquireNextImage2KHR>(
594 vkGetDeviceProcAddr(device_, "vkAcquireNextImage2KHR"));
595 EXPECT_NE(fpAcquireNextImage2KHR, nullptr);
596 fpQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(
597 vkGetDeviceProcAddr(device_, "vkQueuePresentKHR"));
598 EXPECT_NE(fpQueuePresentKHR, nullptr);
599 fpGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(
600 vkGetDeviceProcAddr(device_, "vkGetSwapchainImagesKHR"));
601 EXPECT_NE(fpGetSwapchainImagesKHR, nullptr);
602 }
603 }
604
605 /**
606 * @tc.name: test fpGetPhysicalDeviceSurfaceCapabilitiesKHR
607 * @tc.desc: test fpGetPhysicalDeviceSurfaceCapabilitiesKHR
608 * @tc.type: FUNC
609 * @tc.require: issueI6SKRO
610 */
611 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfaceCapabilitiesKHR_Test, TestSize.Level1)
612 {
613 if (isSupportedVulkan_) {
614 EXPECT_NE(fpGetPhysicalDeviceSurfaceCapabilitiesKHR, nullptr);
615 EXPECT_NE(physicalDevice_, nullptr);
616 EXPECT_NE(surface_, VK_NULL_HANDLE);
617
618 VkResult err = fpGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice_, surface_, &surfCaps_);
619 EXPECT_EQ(err, VK_SUCCESS);
620 }
621 }
622
623 /**
624 * @tc.name: test fpGetPhysicalDeviceSurfacePresentModesKHR
625 * @tc.desc: test fpGetPhysicalDeviceSurfacePresentModesKHR
626 * @tc.type: FUNC
627 * @tc.require: issueI6SKRO
628 */
629 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfacePresentModesKHR_Test, TestSize.Level1)
630 {
631 if (isSupportedVulkan_) {
632 EXPECT_NE(fpGetPhysicalDeviceSurfacePresentModesKHR, nullptr);
633 EXPECT_NE(physicalDevice_, nullptr);
634 EXPECT_NE(surface_, VK_NULL_HANDLE);
635
636 uint32_t presentModeCount;
637 VkResult err = fpGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice_, surface_, &presentModeCount, NULL);
638 EXPECT_EQ(err, VK_SUCCESS);
639 EXPECT_GT(presentModeCount, 0);
640
641 std::vector<VkPresentModeKHR> presentModes(presentModeCount);
642 err = fpGetPhysicalDeviceSurfacePresentModesKHR(
643 physicalDevice_, surface_, &presentModeCount, presentModes.data());
644 EXPECT_EQ(err, VK_SUCCESS);
645 }
646 }
647
648 /**
649 * @tc.name: test fpGetPhysicalDeviceSurfacePresentModesKHR FAIL
650 * @tc.desc: test fpGetPhysicalDeviceSurfacePresentModesKHR FAIL
651 * @tc.type: FUNC
652 * @tc.require: issueI6SKRO
653 */
654 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfacePresentModesKHR_FAIL_Test, TestSize.Level1)
655 {
656 if (isSupportedVulkan_) {
657 EXPECT_NE(fpGetPhysicalDeviceSurfacePresentModesKHR, nullptr);
658 EXPECT_NE(physicalDevice_, nullptr);
659 EXPECT_NE(surface_, VK_NULL_HANDLE);
660
661 uint32_t presentModeCount = 1;
662 std::vector<VkPresentModeKHR> presentModes(presentModeCount);
663 VkResult err = fpGetPhysicalDeviceSurfacePresentModesKHR(
664 physicalDevice_, surface_, &presentModeCount, presentModes.data());
665 EXPECT_NE(err, VK_SUCCESS);
666 }
667 }
668
669 /**
670 * @tc.name: test fpGetPhysicalDeviceSurfaceFormatsKHR
671 * @tc.desc: test fpGetPhysicalDeviceSurfaceFormatsKHR
672 * @tc.type: FUNC
673 * @tc.require: issueI6SKRO
674 */
675 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfaceFormatsKHR_Test, TestSize.Level1)
676 {
677 if (isSupportedVulkan_) {
678 EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
679 EXPECT_NE(physicalDevice_, nullptr);
680 EXPECT_NE(surface_, VK_NULL_HANDLE);
681
682 uint32_t formatCount;
683 VkResult err = fpGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface_, &formatCount, NULL);
684 EXPECT_EQ(err, VK_SUCCESS);
685 EXPECT_GT(formatCount, 0);
686 std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
687 err = fpGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface_, &formatCount, surfaceFormats.data());
688 EXPECT_EQ(err, VK_SUCCESS);
689 surfaceFormat_ = surfaceFormats[0];
690 }
691 }
692
693 /**
694 * @tc.name: test fpGetPhysicalDeviceSurfaceFormatsKHR FAIL
695 * @tc.desc: test fpGetPhysicalDeviceSurfaceFormatsKHR FAIL
696 * @tc.type: FUNC
697 * @tc.require: issueI6SKRO
698 */
699 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfaceFormatsKHR_FAIL_Test, TestSize.Level1)
700 {
701 if (isSupportedVulkan_) {
702 EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
703 EXPECT_NE(physicalDevice_, nullptr);
704 EXPECT_NE(surface_, VK_NULL_HANDLE);
705
706 uint32_t formatCount = 1;
707 std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
708 VkResult err = fpGetPhysicalDeviceSurfaceFormatsKHR(
709 physicalDevice_, surface_, &formatCount, surfaceFormats.data());
710 EXPECT_NE(err, VK_SUCCESS);
711 }
712 }
713
714 /**
715 * @tc.name: test fpCreateSwapchainKHR Success
716 * @tc.desc: test fpCreateSwapchainKHR Success
717 * @tc.type: FUNC
718 * @tc.require: issueI6SKRO
719 */
720 HWTEST_F(VulkanLoaderUnitTest, fpCreateSwapchainKHR_Success_Test, TestSize.Level1)
721 {
722 if (isSupportedVulkan_) {
723 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
724 EXPECT_NE(device_, nullptr);
725 EXPECT_NE(surface_, VK_NULL_HANDLE);
726
727 std::vector<VkFormat> pixelFormatArray = {
728 VK_FORMAT_R8G8B8A8_UNORM,
729 VK_FORMAT_R8G8B8A8_SRGB,
730 };
731 std::vector<VkColorSpaceKHR> colorDataspaceArray = {
732 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
733 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
734 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
735 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT,
736 VK_COLOR_SPACE_DCI_P3_LINEAR_EXT,
737 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
738 VK_COLOR_SPACE_BT709_LINEAR_EXT,
739 VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
740 VK_COLOR_SPACE_BT2020_LINEAR_EXT,
741 VK_COLOR_SPACE_HDR10_ST2084_EXT,
742 VK_COLOR_SPACE_DOLBYVISION_EXT,
743 VK_COLOR_SPACE_HDR10_HLG_EXT,
744 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
745 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
746 VK_COLORSPACE_SRGB_NONLINEAR_KHR,
747 VK_COLOR_SPACE_DCI_P3_LINEAR_EXT
748 };
749
750 for (decltype(pixelFormatArray.size()) i = 0; i < pixelFormatArray.size(); i++) {
751 for (decltype(colorDataspaceArray.size()) j = 0; j < colorDataspaceArray.size(); j++) {
752 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(
753 pixelFormatArray[i], colorDataspaceArray[j]);
754
755 VkSwapchainKHR swapChainSuccess = VK_NULL_HANDLE;
756 VkSwapchainKHR swapChainSuccess2 = VK_NULL_HANDLE;
757
758 VkResult err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChainSuccess);
759 EXPECT_EQ(err, VK_SUCCESS);
760 EXPECT_NE(swapChainSuccess, VK_NULL_HANDLE);
761
762 swapchainCI.oldSwapchain = swapChainSuccess;
763 err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChainSuccess2);
764 EXPECT_EQ(err, VK_SUCCESS);
765 EXPECT_NE(swapChainSuccess2, VK_NULL_HANDLE);
766 fpDestroySwapchainKHR(device_, swapChainSuccess, nullptr);
767 fpDestroySwapchainKHR(device_, swapChainSuccess2, nullptr);
768 }
769 }
770 }
771 }
772
773 /**
774 * @tc.name: test fpCreateSwapchainKHR fail
775 * @tc.desc: test fpCreateSwapchainKHR fail
776 * @tc.type: FUNC
777 * @tc.require: issueI6SKRO
778 */
779 HWTEST_F(VulkanLoaderUnitTest, fpCreateSwapchainKHR_Fail_Test, TestSize.Level1)
780 {
781 if (isSupportedVulkan_) {
782 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
783 EXPECT_NE(device_, nullptr);
784 EXPECT_NE(surface_, VK_NULL_HANDLE);
785
786 std::vector<VkColorSpaceKHR> colorDataspaceArray = {
787 VK_COLOR_SPACE_PASS_THROUGH_EXT,
788 VK_COLOR_SPACE_DISPLAY_NATIVE_AMD,
789 VK_COLOR_SPACE_MAX_ENUM_KHR
790 };
791
792 for (decltype(colorDataspaceArray.size()) i = 0; i < colorDataspaceArray.size(); i++) {
793 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(
794 VK_FORMAT_R8G8B8A8_UNORM, colorDataspaceArray[i]);
795
796 VkSwapchainKHR swapChainFail = VK_NULL_HANDLE;
797 VkSwapchainKHR swapChainFail2 = VK_NULL_HANDLE;
798
799 VkResult err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChainFail);
800 EXPECT_NE(err, VK_SUCCESS);
801 EXPECT_EQ(swapChainFail, VK_NULL_HANDLE);
802
803 swapchainCI.oldSwapchain = swapChainFail;
804 err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChainFail2);
805 EXPECT_NE(err, VK_SUCCESS);
806 EXPECT_EQ(swapChainFail2, VK_NULL_HANDLE);
807 fpDestroySwapchainKHR(device_, swapChainFail, nullptr);
808 fpDestroySwapchainKHR(device_, swapChainFail2, nullptr);
809 }
810 }
811 }
812
813 /**
814 * @tc.name: test vkCreateDebugUtilsMessengerEXT
815 * @tc.desc: test vkCreateDebugUtilsMessengerEXT
816 * @tc.type: FUNC
817 * @tc.require: issueI6SKRO
818 */
819 HWTEST_F(VulkanLoaderUnitTest, vkCreateDebugUtilsMessengerEXT_Test, TestSize.Level1)
820 {
821 if (isSupportedVulkan_) {
822 EXPECT_NE(vkCreateDebugUtilsMessengerEXT, nullptr);
823 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
824 EXPECT_NE(instance_, nullptr);
825 EXPECT_NE(device_, nullptr);
826
827 VkDebugUtilsMessengerCreateInfoEXT createInfo{};
828 createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
829 createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
830 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
831 createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
832 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
833 createInfo.pfnUserCallback = UserCallback;
834 VkResult result = vkCreateDebugUtilsMessengerEXT(instance_, &createInfo, nullptr, &debugUtilsMessenger);
835 EXPECT_EQ(result, VK_SUCCESS);
836
837 debugMessage_.str("");
838 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(VK_FORMAT_MAX_ENUM, surfaceFormat_.colorSpace);
839 VkSwapchainKHR swapChain = VK_NULL_HANDLE;
840 result = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain);
841 EXPECT_EQ(result, VK_SUCCESS);
842 EXPECT_NE(swapChain, VK_NULL_HANDLE);
843 fpDestroySwapchainKHR(device_, swapChain, nullptr);
844
845 EXPECT_EQ((debugMessage_.str().find("unsupported swapchain format") != -1), true);
846 }
847 }
848
849 /**
850 * @tc.name: test vkDestroyDebugUtilsMessengerEXT
851 * @tc.desc: test vkDestroyDebugUtilsMessengerEXT
852 * @tc.type: FUNC
853 * @tc.require: issueI6SKRO
854 */
855 HWTEST_F(VulkanLoaderUnitTest, vkDestroyDebugUtilsMessengerEXT_Test, TestSize.Level1)
856 {
857 if (isSupportedVulkan_) {
858 EXPECT_NE(vkDestroyDebugUtilsMessengerEXT, nullptr);
859 EXPECT_NE(instance_, nullptr);
860 EXPECT_NE(device_, nullptr);
861 EXPECT_NE(debugUtilsMessenger, VK_NULL_HANDLE);
862
863 vkDestroyDebugUtilsMessengerEXT(instance_, debugUtilsMessenger, nullptr);
864
865 debugMessage_.str("");
866 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(VK_FORMAT_MAX_ENUM, surfaceFormat_.colorSpace);
867 VkSwapchainKHR swapChain = VK_NULL_HANDLE;
868 VkResult result = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain);
869 EXPECT_EQ(result, VK_SUCCESS);
870 EXPECT_NE(swapChain, VK_NULL_HANDLE);
871 fpDestroySwapchainKHR(device_, swapChain, nullptr);
872
873 EXPECT_EQ((debugMessage_.str() == ""), true);
874 }
875 }
876
877 /**
878 * @tc.name: test fpCreateSwapchainKHR
879 * @tc.desc: test fpCreateSwapchainKHR
880 * @tc.type: FUNC
881 * @tc.require: issueI6SKRO
882 */
883 HWTEST_F(VulkanLoaderUnitTest, fpCreateSwapchainKHR_Test, TestSize.Level1)
884 {
885 if (isSupportedVulkan_) {
886 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
887 EXPECT_NE(device_, nullptr);
888 EXPECT_NE(surface_, VK_NULL_HANDLE);
889
890 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(
891 VK_FORMAT_B8G8R8A8_UNORM, surfaceFormat_.colorSpace);
892
893 VkResult err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain_);
894 EXPECT_EQ(err, VK_SUCCESS);
895 EXPECT_NE(swapChain_, VK_NULL_HANDLE);
896
897 swapchainCI.oldSwapchain = swapChain_;
898 err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain2_);
899 EXPECT_EQ(err, VK_SUCCESS);
900 EXPECT_NE(swapChain2_, VK_NULL_HANDLE);
901 }
902 }
903
904 /**
905 * @tc.name: test fpGetSwapchainImagesKHR
906 * @tc.desc: test fpGetSwapchainImagesKHR
907 * @tc.type: FUNC
908 * @tc.require: issueI6SKRO
909 */
910 HWTEST_F(VulkanLoaderUnitTest, fpGetSwapchainImagesKHR_Test, TestSize.Level1)
911 {
912 if (isSupportedVulkan_) {
913 uint32_t imageCount;
914 std::vector<VkImage> images;
915 VkResult err = fpGetSwapchainImagesKHR(device_, swapChain_, &imageCount, NULL);
916 EXPECT_EQ(err, VK_SUCCESS);
917 images.resize(imageCount);
918 err = fpGetSwapchainImagesKHR(device_, swapChain_, &imageCount, images.data());
919 EXPECT_EQ(err, VK_SUCCESS);
920 }
921 }
922
923 /**
924 * @tc.name: test fpGetSwapchainImagesKHR FAIL
925 * @tc.desc: test fpGetSwapchainImagesKHR FAIL
926 * @tc.type: FUNC
927 * @tc.require: issueI6SKRO
928 */
929 HWTEST_F(VulkanLoaderUnitTest, fpGetSwapchainImagesKHR_FAIL_Test, TestSize.Level1)
930 {
931 if (isSupportedVulkan_) {
932 uint32_t imageCount = 1;
933 std::vector<VkImage> images(imageCount);
934 VkResult err = fpGetSwapchainImagesKHR(device_, swapChain2_, &imageCount, images.data());
935 EXPECT_NE(err, VK_SUCCESS);
936 }
937 }
938
939 /**
940 * @tc.name: test vkCreateSemaphore
941 * @tc.desc: test vkCreateSemaphore
942 * @tc.type: FUNC
943 * @tc.require: issueI6SKRO
944 */
945 HWTEST_F(VulkanLoaderUnitTest, vkCreateSemaphore_Test, TestSize.Level1)
946 {
947 if (isSupportedVulkan_) {
948 VkSemaphoreCreateInfo semaphoreCreateInfo {};
949 semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
950 PFN_vkCreateSemaphore vkCreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(
951 vkGetInstanceProcAddr(instance_, "vkCreateSemaphore"));
952 EXPECT_NE(vkCreateSemaphore, nullptr);
953 VkResult err = vkCreateSemaphore(device_, &semaphoreCreateInfo, nullptr, &semaphore_);
954 EXPECT_EQ(err, VK_SUCCESS);
955 }
956 }
957
958 /**
959 * @tc.name: test fpAcquireNextImage2KHR
960 * @tc.desc: test fpAcquireNextImage2KHR
961 * @tc.type: FUNC
962 * @tc.require: issueI6SKRO
963 */
964 HWTEST_F(VulkanLoaderUnitTest, fpAcquireNextImage2KHR_Test, TestSize.Level1)
965 {
966 if (isSupportedVulkan_) {
967 VkAcquireNextImageInfoKHR pAcquireInfo;
968 pAcquireInfo.swapchain = swapChain2_;
969 pAcquireInfo.timeout = UINT64_MAX;
970 pAcquireInfo.semaphore = semaphore_;
971 pAcquireInfo.fence = (VkFence)nullptr;
972 uint32_t imageIndex = 0;
973 VkResult err = fpAcquireNextImage2KHR(device_, &pAcquireInfo, &imageIndex);
974 EXPECT_EQ(err, VK_SUCCESS);
975 }
976 }
977
978 /**
979 * @tc.name: test fpQueuePresentKHR
980 * @tc.desc: test fpQueuePresentKHR
981 * @tc.type: FUNC
982 * @tc.require: issueI6SKRO
983 */
984 HWTEST_F(VulkanLoaderUnitTest, fpQueuePresentKHR_Test, TestSize.Level1)
985 {
986 if (isSupportedVulkan_) {
987 VkRectLayerKHR pRectangles = {};
988
989 std::vector<VkPresentRegionKHR> pRegions;
990 VkPresentRegionKHR pRegion;
991 pRegion.rectangleCount = 1;
992 pRegion.pRectangles = &pRectangles;
993 pRegions.push_back(pRegion);
994
995 VkPresentRegionsKHR presentRegions;
996 presentRegions.sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
997 presentRegions.pNext = NULL;
998 presentRegions.swapchainCount = 1;
999 presentRegions.pRegions = pRegions.data();
1000
1001 VkQueue queue = nullptr;
1002 PFN_vkGetDeviceQueue vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(
1003 vkGetInstanceProcAddr(instance_, "vkGetDeviceQueue"));
1004 EXPECT_NE(vkGetDeviceQueue, nullptr);
1005 vkGetDeviceQueue(device_, 0, 0, &queue);
1006 EXPECT_NE(queue, nullptr);
1007 uint32_t imageIndex = 0;
1008 VkPresentInfoKHR presentInfo = {};
1009 presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
1010 presentInfo.pNext = &presentRegions;
1011 presentInfo.swapchainCount = 1;
1012 presentInfo.pSwapchains = &swapChain2_;
1013 presentInfo.pImageIndices = &imageIndex;
1014 EXPECT_NE(semaphore_, VK_NULL_HANDLE);
1015 presentInfo.pWaitSemaphores = &semaphore_;
1016 presentInfo.waitSemaphoreCount = 1;
1017 VkResult err = fpQueuePresentKHR(queue, &presentInfo);
1018 EXPECT_EQ(err, VK_SUCCESS);
1019 }
1020 }
1021
1022 /**
1023 * @tc.name: test vkDestroySurfaceKHR nullptr
1024 * @tc.desc: test vkDestroySurfaceKHR nullptr
1025 * @tc.type: FUNC
1026 * @tc.require: issueI6SKRO
1027 */
1028 HWTEST_F(VulkanLoaderUnitTest, DestroySurface_NULL_Test, TestSize.Level1)
1029 {
1030 if (isSupportedVulkan_) {
1031 EXPECT_NE(vkDestroySurfaceKHR, nullptr);
1032 vkDestroySurfaceKHR(instance_, VK_NULL_HANDLE, nullptr);
1033 }
1034 }
1035 } // vulkan::loader
1036