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, software
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 #include <chrono>
16 #include <thread>
17 #include <unistd.h>
18 #include <vulkan/vulkan.h>
19 #include <window.h>
20 #include <gtest/gtest.h>
21 #include <dlfcn.h>
22 #include <iostream>
23 #include <string>
24 #include <vector>
25 
26 #include "refbase.h"
27 #include "surface.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 VulkanLoaderSystemTest : public testing::Test {
39 public:
SetUpTestCase()40     static void SetUpTestCase() {}
TearDownTestCase()41     static void TearDownTestCase()
42     {
43         if (isSupportedVulkan_) {
44             fpDestroySwapchainKHR(device_, swapChain_, nullptr);
45             vkDestroySurfaceKHR(instance_, surface_, nullptr);
46             fpDestroyInstance(instance_, nullptr);
47         }
48         if (libVulkan_ != nullptr) {
49             dlclose(libVulkan_);
50             libVulkan_ = nullptr;
51         }
52     }
53     static inline void DLOpenLibVulkan();
54     static inline void TrytoCreateVkInstance();
55 
56     static inline PFN_vkCreateInstance vkCreateInstance;
57     static inline PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
58     static inline PFN_vkCreateDevice vkCreateDevice;
59     static inline PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
60     static inline PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
61     static inline PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
62     static inline PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
63     static inline PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
64     static inline PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
65     static inline PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS;
66     static inline PFN_vkGetPhysicalDeviceSurfaceSupportKHR fpGetPhysicalDeviceSurfaceSupportKHR;
67     static inline PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
68     static inline PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fpGetPhysicalDeviceSurfaceFormatsKHR;
69     static inline PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
70     static inline PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
71     static inline PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
72     static inline PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
73     static inline PFN_vkAcquireNextImageKHR fpAcquireNextImageKHR;
74     static inline PFN_vkQueuePresentKHR fpQueuePresentKHR;
75     static inline PFN_vkGetPhysicalDevicePresentRectanglesKHR fpGetPhysicalDevicePresentRectanglesKHR;
76     static inline PFN_vkGetPhysicalDeviceSurfaceFormats2KHR fpGetPhysicalDeviceSurfaceFormats2KHR;
77     static inline PFN_vkSetHdrMetadataEXT fpSetHdrMetadataEXT;
78 
79     static inline PFN_vkDestroyInstance fpDestroyInstance;
80     static inline PFN_vkDestroySurfaceKHR fpDestroySurfaceKHR;
81     static inline PFN_vkDestroyDevice fpDestroyDevice;
82 
83     static inline PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR fpGetPhysicalDeviceSurfaceCapabilities2KHR;
84     static inline PFN_vkGetDeviceGroupPresentCapabilitiesKHR fpGetDeviceGroupPresentCapabilitiesKHR;
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 VkSwapchainKHR swapChain_ = VK_NULL_HANDLE;
91     static inline bool isSupportedVulkan_ = false;
92 };
93 
DLOpenLibVulkan()94 void VulkanLoaderSystemTest::DLOpenLibVulkan()
95 {
96 #if (defined(__aarch64__) || defined(__x86_64__))
97     const char *path = "/system/lib64/platformsdk/libvulkan.so";
98 #else
99     const char *path = "/system/lib/platformsdk/libvulkan.so";
100 #endif
101     libVulkan_ = dlopen(path, RTLD_NOW | RTLD_LOCAL);
102     if (libVulkan_ == nullptr) {
103         std::cout << "dlerror: " << dlerror() << std::endl;
104         isSupportedVulkan_ = false;
105         return;
106     }
107     isSupportedVulkan_ = true;
108 }
109 
TrytoCreateVkInstance()110 void VulkanLoaderSystemTest::TrytoCreateVkInstance()
111 {
112     VkApplicationInfo appInfo = {};
113     appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
114     appInfo.pApplicationName = "pApplicationName";
115     appInfo.pEngineName = "pEngineName";
116     appInfo.apiVersion = VK_API_VERSION_1_0;
117 
118     std::vector<const char*> instanceExtensions = {
119         VK_KHR_SURFACE_EXTENSION_NAME,
120         VK_OHOS_SURFACE_EXTENSION_NAME,
121         VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME
122     };
123 
124     VkInstanceCreateInfo instanceCreateInfo = {};
125     instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
126     instanceCreateInfo.pNext = NULL;
127     instanceCreateInfo.pApplicationInfo = &appInfo;
128 
129     instanceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(instanceExtensions.size());
130     instanceCreateInfo.ppEnabledExtensionNames = instanceExtensions.data();
131 
132     VkResult result = vkCreateInstance(&instanceCreateInfo, nullptr, &instance_);
133     if (result == VK_ERROR_INCOMPATIBLE_DRIVER) {
134         isSupportedVulkan_ = false;
135     } else {
136         isSupportedVulkan_ = true;
137     }
138     std::cout << "TrytoCreateVkInstance result: " << result << std::endl;
139 }
140 
141 /**
142  * @tc.name: Load base Vulkan functions
143  * @tc.desc: Load base Vulkan functions
144  * @tc.type: FUNC
145  * @tc.require: issueI6SKRO
146  */
147 HWTEST_F(VulkanLoaderSystemTest, LoadBaseFuncPtr, TestSize.Level1)
148 {
149     DLOpenLibVulkan();
150     if (isSupportedVulkan_) {
151         EXPECT_NE(libVulkan_, nullptr);
152 
153         // Load base functions
154         vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
155             dlsym(libVulkan_, "vkEnumerateInstanceExtensionProperties"));
156         EXPECT_NE(vkEnumerateInstanceExtensionProperties, nullptr);
157         vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
158             dlsym(libVulkan_, "vkEnumerateInstanceLayerProperties"));
159         EXPECT_NE(vkEnumerateInstanceLayerProperties, nullptr);
160         vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dlsym(libVulkan_, "vkCreateInstance"));
161         EXPECT_NE(vkCreateInstance, nullptr);
162         vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(libVulkan_, "vkGetInstanceProcAddr"));
163         EXPECT_NE(vkGetInstanceProcAddr, nullptr);
164         vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(dlsym(libVulkan_, "vkGetDeviceProcAddr"));
165         EXPECT_NE(vkGetDeviceProcAddr, nullptr);
166         TrytoCreateVkInstance();
167     }
168 }
169 
170 /**
171  * @tc.name: Load instance based Vulkan function pointers
172  * @tc.desc: Load instance based Vulkan function pointers
173  * @tc.type: FUNC
174  * @tc.require: issueI6SKRO
175  */
176 HWTEST_F(VulkanLoaderSystemTest, LoadInstanceFuncPtr, TestSize.Level1)
177 {
178     if (isSupportedVulkan_) {
179         vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(
180             vkGetInstanceProcAddr(instance_, "vkEnumeratePhysicalDevices"));
181         EXPECT_NE(vkEnumeratePhysicalDevices, nullptr);
182         vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(
183             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceQueueFamilyProperties"));
184         EXPECT_NE(vkEnumeratePhysicalDevices, nullptr);
185         vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(
186             vkGetInstanceProcAddr(instance_, "vkCreateDevice"));
187         EXPECT_NE(vkCreateDevice, nullptr);
188         vkCreateSurfaceOHOS = reinterpret_cast<PFN_vkCreateSurfaceOHOS>(
189             vkGetInstanceProcAddr(instance_, "vkCreateSurfaceOHOS"));
190         EXPECT_NE(vkCreateSurfaceOHOS, nullptr);
191         vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(
192             vkGetInstanceProcAddr(instance_, "vkDestroySurfaceKHR"));
193         EXPECT_NE(vkDestroySurfaceKHR, nullptr);
194         fpGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(
195             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceSupportKHR"));
196         EXPECT_NE(fpGetPhysicalDeviceSurfaceSupportKHR, nullptr);
197         fpGetPhysicalDeviceSurfaceCapabilitiesKHR =  reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(
198             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
199         EXPECT_NE(fpGetPhysicalDeviceSurfaceCapabilitiesKHR, nullptr);
200         fpGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(
201             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
202         EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
203         fpGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(
204             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
205         EXPECT_NE(fpGetPhysicalDeviceSurfacePresentModesKHR, nullptr);
206         fpGetPhysicalDevicePresentRectanglesKHR = reinterpret_cast<PFN_vkGetPhysicalDevicePresentRectanglesKHR>(
207             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDevicePresentRectanglesKHR"));
208         EXPECT_NE(fpGetPhysicalDevicePresentRectanglesKHR, nullptr);
209         fpGetPhysicalDeviceSurfaceFormats2KHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormats2KHR>(
210             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceFormats2KHR"));
211         EXPECT_NE(fpGetPhysicalDeviceSurfaceFormats2KHR, nullptr);
212 
213         fpDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
214             vkGetInstanceProcAddr(instance_, "vkDestroyInstance"));
215         EXPECT_NE(fpDestroyInstance, nullptr);
216         fpDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(
217             vkGetInstanceProcAddr(instance_, "vkDestroySurfaceKHR"));
218         EXPECT_NE(fpDestroySurfaceKHR, nullptr);
219         fpDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(
220             vkGetInstanceProcAddr(instance_, "vkDestroyDevice"));
221         EXPECT_NE(fpDestroyDevice, nullptr);
222         fpDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(
223             vkGetInstanceProcAddr(instance_, "vkDestroySwapchainKHR"));
224         EXPECT_NE(fpDestroySwapchainKHR, nullptr);
225 
226         fpGetPhysicalDeviceSurfaceCapabilities2KHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR>(
227             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceCapabilities2KHR"));
228         EXPECT_NE(fpGetPhysicalDeviceSurfaceCapabilities2KHR, nullptr);
229 
230         fpGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(
231             vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
232         EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
233 
234         fpGetDeviceGroupPresentCapabilitiesKHR = reinterpret_cast<PFN_vkGetDeviceGroupPresentCapabilitiesKHR>(
235             vkGetInstanceProcAddr(instance_, "vkGetDeviceGroupPresentCapabilitiesKHR"));
236         EXPECT_NE(fpGetDeviceGroupPresentCapabilitiesKHR, nullptr);
237     }
238 }
239 
240 /**
241  * @tc.name: create device
242  * @tc.desc: create device
243  * @tc.type: FUNC
244  * @tc.require: issueI6SKRO
245  */
246 HWTEST_F(VulkanLoaderSystemTest, createDevice_Test, TestSize.Level1)
247 {
248     if (isSupportedVulkan_) {
249         // Physical Devices
250         uint32_t gpuCount = 0;
251         VkResult err = vkEnumeratePhysicalDevices(instance_, &gpuCount, nullptr);
252         EXPECT_EQ(err, VK_SUCCESS);
253         EXPECT_NE(gpuCount, 0);
254         std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
255         err = vkEnumeratePhysicalDevices(instance_, &gpuCount, physicalDevices.data());
256         EXPECT_EQ(err, VK_SUCCESS);
257         physicalDevice_ = physicalDevices[0];
258         EXPECT_NE(physicalDevice_, nullptr);
259 
260         // Graphics queue
261         uint32_t queueCount;
262         vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueCount, nullptr);
263 
264         std::vector<VkQueueFamilyProperties> queueProps(queueCount);
265         vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice_, &queueCount, queueProps.data());
266 
267         uint32_t graphicsQueueFamilyIndex = UINT32_MAX;
268         for (uint32_t i = 0; i < queueCount; i++) {
269             if (queueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
270                 graphicsQueueFamilyIndex = i;
271                 break;
272             }
273         }
274         EXPECT_NE(graphicsQueueFamilyIndex, UINT32_MAX);
275 
276         VkDeviceQueueCreateInfo queueInfo{};
277         queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
278         queueInfo.pNext = nullptr;
279         queueInfo.flags = 0;
280         queueInfo.queueFamilyIndex = graphicsQueueFamilyIndex;
281         queueInfo.queueCount = 2;
282         const float priorities[1] = {1.0f};
283         queueInfo.pQueuePriorities = priorities;
284 
285         std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
286         queueCreateInfos.push_back(queueInfo);
287 
288         // Device
289         std::vector<const char*> deviceExtensions;
290         deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
291         deviceExtensions.push_back(VK_EXT_HDR_METADATA_EXTENSION_NAME);
292         VkDeviceCreateInfo deviceCreateInfo = {};
293         deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
294         deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
295         deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
296         deviceCreateInfo.enabledExtensionCount = (uint32_t)deviceExtensions.size();
297         deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
298 
299         VkDevice logicalDevice;
300         err = vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &logicalDevice);
301         EXPECT_EQ(err, VK_SUCCESS);
302         EXPECT_NE(logicalDevice, nullptr);
303         device_ = logicalDevice;
304     }
305 }
306 
307 /**
308  * @tc.name: Load device based Vulkan function pointers
309  * @tc.desc: Load device based Vulkan function pointers
310  * @tc.type: FUNC
311  * @tc.require: issueI6SKRO
312  */
313 HWTEST_F(VulkanLoaderSystemTest, LoadDeviceFuncPtr, TestSize.Level1)
314 {
315     if (isSupportedVulkan_) {
316         fpCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(
317             vkGetDeviceProcAddr(device_, "vkCreateSwapchainKHR"));
318         EXPECT_NE(fpCreateSwapchainKHR, nullptr);
319         fpDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(
320             vkGetDeviceProcAddr(device_, "vkDestroySwapchainKHR"));
321         EXPECT_NE(fpDestroySwapchainKHR, nullptr);
322         fpGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(
323             vkGetDeviceProcAddr(device_, "vkGetSwapchainImagesKHR"));
324         EXPECT_NE(fpGetSwapchainImagesKHR, nullptr);
325         fpAcquireNextImageKHR = reinterpret_cast<PFN_vkAcquireNextImageKHR>(
326             vkGetDeviceProcAddr(device_, "vkAcquireNextImageKHR"));
327         EXPECT_NE(fpAcquireNextImageKHR, nullptr);
328         fpQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(vkGetDeviceProcAddr(device_, "vkQueuePresentKHR"));
329         EXPECT_NE(fpQueuePresentKHR, nullptr);
330         fpSetHdrMetadataEXT = reinterpret_cast<PFN_vkSetHdrMetadataEXT>(
331             vkGetDeviceProcAddr(device_, "vkSetHdrMetadataEXT"));
332         EXPECT_NE(fpAcquireNextImageKHR, nullptr);
333     }
334 }
335 
336 /**
337  * @tc.name: create surface
338  * @tc.desc: create surface
339  * @tc.type: FUNC
340  * @tc.require: issueI6SKRO
341  */
342 HWTEST_F(VulkanLoaderSystemTest, createSurface_Test, TestSize.Level1)
343 {
344     if (isSupportedVulkan_) {
345         struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
346         rsSurfaceNodeConfig.SurfaceNodeName = "createSurface_test";
347         auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
348         OHOS::sptr<OHOS::Surface> surf = surfaceNode->GetSurface();
349         OHNativeWindow* nativeWindow = CreateNativeWindowFromSurface(&surf);
350         EXPECT_NE(nativeWindow, nullptr);
351         VkSurfaceCreateInfoOHOS surfaceCreateInfo = {};
352         surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS;
353         surfaceCreateInfo.window = nativeWindow;
354         VkResult err = vkCreateSurfaceOHOS(instance_, &surfaceCreateInfo, NULL, &surface_);
355         EXPECT_EQ(err, VK_SUCCESS);
356         EXPECT_NE(surface_, VK_NULL_HANDLE);
357     }
358 }
359 
360 /**
361  * @tc.name: create swapChain
362  * @tc.desc: create swapChain
363  * @tc.type: FUNC
364  * @tc.require: issueI6SKRO
365  */
366 HWTEST_F(VulkanLoaderSystemTest, createSwapChain_Test, TestSize.Level1)
367 {
368     if (isSupportedVulkan_) {
369         VkSwapchainKHR oldSwapchain = swapChain_;
370         VkSwapchainCreateInfoKHR swapchainCI = {};
371         swapchainCI.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
372         swapchainCI.surface = surface_;
373         VkSurfaceCapabilitiesKHR surfCaps;
374         VkResult err = fpGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice_, surface_, &surfCaps);
375         EXPECT_EQ(err, VK_SUCCESS);
376 
377         uint32_t desiredNumberOfSwapchainImages = surfCaps.minImageCount + 1;
378         if ((surfCaps.maxImageCount > 0) && (desiredNumberOfSwapchainImages > surfCaps.maxImageCount)) {
379             desiredNumberOfSwapchainImages = surfCaps.maxImageCount;
380         }
381         swapchainCI.minImageCount = desiredNumberOfSwapchainImages;
382         swapchainCI.imageFormat = VK_FORMAT_B8G8R8A8_UNORM;
383         uint32_t formatCount;
384         err = fpGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface_, &formatCount, NULL);
385         EXPECT_EQ(err, VK_SUCCESS);
386         EXPECT_GT(formatCount, 0);
387         std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
388         err = fpGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface_, &formatCount, surfaceFormats.data());
389         EXPECT_EQ(err, VK_SUCCESS);
390         swapchainCI.imageColorSpace = surfaceFormats[0].colorSpace;
391         uint32_t width = 1280;
392         uint32_t height = 720;
393         swapchainCI.imageExtent = { width, height };
394         swapchainCI.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
395         swapchainCI.preTransform = (VkSurfaceTransformFlagBitsKHR)VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
396         swapchainCI.imageArrayLayers = 1;
397         swapchainCI.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
398         swapchainCI.queueFamilyIndexCount = 0;
399         swapchainCI.presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
400         swapchainCI.oldSwapchain = oldSwapchain;
401         swapchainCI.clipped = VK_TRUE;
402         swapchainCI.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
403 
404         err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain_);
405         EXPECT_EQ(err, VK_SUCCESS);
406         EXPECT_NE(swapChain_, VK_NULL_HANDLE);
407     }
408 }
409 
410 /**
411  * @tc.name: test vkSetHdrMetadataEXT
412  * @tc.desc: test vkSetHdrMetadataEXT
413  * @tc.type: FUNC
414  * @tc.require: issueI9IN5M
415  */
416 HWTEST_F(VulkanLoaderSystemTest, setHdrMetadataEXT_Test, TestSize.Level1)
417 {
418     if (isSupportedVulkan_) {
419         EXPECT_NE(device_, nullptr);
420         EXPECT_NE(swapChain_, VK_NULL_HANDLE);
421         uint32_t swapchainCount = 1;
422         VkHdrMetadataEXT hdrMetadata = {};
423         hdrMetadata.sType = VK_STRUCTURE_TYPE_HDR_METADATA_EXT;
424         hdrMetadata.displayPrimaryRed.x = 1000;
425         hdrMetadata.displayPrimaryRed.y = 300;
426         hdrMetadata.displayPrimaryGreen.x = 600;
427         hdrMetadata.displayPrimaryGreen.y = 100;
428         hdrMetadata.displayPrimaryBlue.x = 1600;
429         hdrMetadata.displayPrimaryBlue.y = 200;
430         hdrMetadata.whitePoint.x = 15635;
431         hdrMetadata.whitePoint.y = 16450;
432         hdrMetadata.minLuminance = 100;
433         hdrMetadata.maxLuminance = 1000000;
434         hdrMetadata.maxContentLightLevel = 1000;
435         hdrMetadata.maxFrameAverageLightLevel = 400;
436         EXPECT_NE(fpSetHdrMetadataEXT, nullptr);
437         fpSetHdrMetadataEXT(device_, swapchainCount, &swapChain_, &hdrMetadata);
438     }
439 }
440 
441 /**
442  * @tc.name: test vkGetPhysicalDeviceSurfaceFormatsKHR
443  * @tc.desc: test vkGetPhysicalDeviceSurfaceFormatsKHR
444  * @tc.type: FUNC
445  * @tc.require: issueI9IN5M
446  */
447 HWTEST_F(VulkanLoaderSystemTest, getPhysicalDeviceSurfaceFormatsKHR_Test, TestSize.Level1)
448 {
449     if (isSupportedVulkan_) {
450         EXPECT_NE(physicalDevice_, nullptr);
451         EXPECT_NE(surface_, VK_NULL_HANDLE);
452         uint32_t formatCount = 0;
453         VkResult res = fpGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface_, &formatCount, nullptr);
454         EXPECT_EQ(res, VK_SUCCESS);
455         EXPECT_NE(formatCount, 0);
456         std::vector<VkSurfaceFormatKHR> formats(formatCount);
457         res = fpGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface_, &formatCount, formats.data());
458         EXPECT_EQ(formatCount, formats.size());
459         EXPECT_EQ(res, VK_SUCCESS);
460     }
461 }
462 
463 /**
464  * @tc.name: test vkGetPhysicalDeviceSurfaceCapabilities2KHR
465  * @tc.desc: test vkGetPhysicalDeviceSurfaceCapabilities2KHR
466  * @tc.type: FUNC
467  * @tc.require: issueI9IN5M
468  */
469 HWTEST_F(VulkanLoaderSystemTest, getPhysicalDeviceSurfaceCapabilities2KHR_Test, TestSize.Level1)
470 {
471     if (isSupportedVulkan_) {
472         EXPECT_NE(physicalDevice_, nullptr);
473         EXPECT_NE(surface_, VK_NULL_HANDLE);
474         VkPhysicalDeviceSurfaceInfo2KHR surfaceInfo = {};
475         surfaceInfo.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
476         surfaceInfo.surface = surface_;
477 
478         VkSurfaceCapabilities2KHR surfaceCapabilities = {};
479         surfaceCapabilities.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
480         surfaceCapabilities.pNext = nullptr;
481 
482         fpGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice_, &surfaceInfo, &surfaceCapabilities);
483     }
484 }
485 
486 /**
487  * @tc.name: test vkGetPhysicalDevicePresentRectanglesKHR
488  * @tc.desc: test vkGetPhysicalDevicePresentRectanglesKHR
489  * @tc.type: FUNC
490  * @tc.require: issueI9IN5M
491  */
492 HWTEST_F(VulkanLoaderSystemTest, getPhysicalDevicePresentRectanglesKHR_Test, TestSize.Level1)
493 {
494     if (isSupportedVulkan_) {
495         EXPECT_NE(physicalDevice_, nullptr);
496         EXPECT_NE(surface_, VK_NULL_HANDLE);
497         EXPECT_NE(fpGetPhysicalDevicePresentRectanglesKHR, nullptr);
498         uint32_t pRectCount = 0;
499         VkResult res = fpGetPhysicalDevicePresentRectanglesKHR(physicalDevice_, surface_, &pRectCount, nullptr);
500         EXPECT_EQ(res, VK_SUCCESS);
501         if (pRectCount > 0) {
502             std::vector<VkRect2D> pRects(pRectCount);
503             res = fpGetPhysicalDevicePresentRectanglesKHR(physicalDevice_, surface_, &pRectCount, pRects.data());
504             EXPECT_EQ(res, VK_SUCCESS);
505         }
506     }
507 }
508 
509 /**
510  * @tc.name: test vkGetDeviceGroupPresentCapabilitiesKHR
511  * @tc.desc: test vkGetDeviceGroupPresentCapabilitiesKHR
512  * @tc.type: FUNC
513  * @tc.require: issueI9IN5M
514  */
515 
516 HWTEST_F(VulkanLoaderSystemTest, getDeviceGroupPresentCapabilitiesKHR_Test, TestSize.Level1)
517 {
518     if (isSupportedVulkan_) {
519         EXPECT_NE(device_, nullptr);
520         EXPECT_NE(fpGetDeviceGroupPresentCapabilitiesKHR, nullptr);
521         VkDeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities = {};
522         VkResult res = fpGetDeviceGroupPresentCapabilitiesKHR(device_, &deviceGroupPresentCapabilities);
523         EXPECT_EQ(res, VK_SUCCESS);
524     }
525 }
526 
527 }
528