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