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