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