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 }
581 }
582 }
583
584 /**
585 * @tc.name: load device based function pointer
586 * @tc.desc: load device based function pointer
587 * @tc.type: FUNC
588 * @tc.require: issueI6SKRO
589 */
590 HWTEST_F(VulkanLoaderUnitTest, LoadDeviceFuncPtr, TestSize.Level1)
591 {
592 if (isSupportedVulkan_) {
593 EXPECT_NE(device_, nullptr);
594
595 fpCreateSwapchainKHR = reinterpret_cast<PFN_vkCreateSwapchainKHR>(
596 vkGetDeviceProcAddr(device_, "vkCreateSwapchainKHR"));
597 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
598 fpDestroySwapchainKHR = reinterpret_cast<PFN_vkDestroySwapchainKHR>(
599 vkGetDeviceProcAddr(device_, "vkDestroySwapchainKHR"));
600 EXPECT_NE(fpDestroySwapchainKHR, nullptr);
601 fpAcquireNextImage2KHR = reinterpret_cast<PFN_vkAcquireNextImage2KHR>(
602 vkGetDeviceProcAddr(device_, "vkAcquireNextImage2KHR"));
603 EXPECT_NE(fpAcquireNextImage2KHR, nullptr);
604 fpQueuePresentKHR = reinterpret_cast<PFN_vkQueuePresentKHR>(
605 vkGetDeviceProcAddr(device_, "vkQueuePresentKHR"));
606 EXPECT_NE(fpQueuePresentKHR, nullptr);
607 fpGetSwapchainImagesKHR = reinterpret_cast<PFN_vkGetSwapchainImagesKHR>(
608 vkGetDeviceProcAddr(device_, "vkGetSwapchainImagesKHR"));
609 EXPECT_NE(fpGetSwapchainImagesKHR, nullptr);
610
611 fpSetHdrMetadataEXT = reinterpret_cast<PFN_vkSetHdrMetadataEXT>(
612 vkGetDeviceProcAddr(device_, "vkSetHdrMetadataEXT"));
613 EXPECT_NE(fpSetHdrMetadataEXT, nullptr);
614 }
615 }
616
617 /**
618 * @tc.name: test fpGetPhysicalDeviceSurfaceCapabilitiesKHR
619 * @tc.desc: test fpGetPhysicalDeviceSurfaceCapabilitiesKHR
620 * @tc.type: FUNC
621 * @tc.require: issueI6SKRO
622 */
623 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfaceCapabilitiesKHR_Test, TestSize.Level1)
624 {
625 if (isSupportedVulkan_) {
626 EXPECT_NE(fpGetPhysicalDeviceSurfaceCapabilitiesKHR, nullptr);
627 EXPECT_NE(physicalDevice_, nullptr);
628 EXPECT_NE(surface_, VK_NULL_HANDLE);
629
630 VkResult err = fpGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice_, surface_, &surfCaps_);
631 EXPECT_EQ(err, VK_SUCCESS);
632 }
633 }
634
635 /**
636 * @tc.name: test fpGetPhysicalDeviceSurfacePresentModesKHR
637 * @tc.desc: test fpGetPhysicalDeviceSurfacePresentModesKHR
638 * @tc.type: FUNC
639 * @tc.require: issueI6SKRO
640 */
641 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfacePresentModesKHR_Test, TestSize.Level1)
642 {
643 if (isSupportedVulkan_) {
644 EXPECT_NE(fpGetPhysicalDeviceSurfacePresentModesKHR, nullptr);
645 EXPECT_NE(physicalDevice_, nullptr);
646 EXPECT_NE(surface_, VK_NULL_HANDLE);
647
648 uint32_t presentModeCount;
649 VkResult err = fpGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice_, surface_, &presentModeCount, NULL);
650 EXPECT_EQ(err, VK_SUCCESS);
651 EXPECT_GT(presentModeCount, 0);
652
653 std::vector<VkPresentModeKHR> presentModes(presentModeCount);
654 err = fpGetPhysicalDeviceSurfacePresentModesKHR(
655 physicalDevice_, surface_, &presentModeCount, presentModes.data());
656 EXPECT_EQ(err, VK_SUCCESS);
657 }
658 }
659
660 /**
661 * @tc.name: test fpGetPhysicalDeviceSurfacePresentModesKHR FAIL
662 * @tc.desc: test fpGetPhysicalDeviceSurfacePresentModesKHR FAIL
663 * @tc.type: FUNC
664 * @tc.require: issueI6SKRO
665 */
666 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfacePresentModesKHR_FAIL_Test, TestSize.Level1)
667 {
668 if (isSupportedVulkan_) {
669 EXPECT_NE(fpGetPhysicalDeviceSurfacePresentModesKHR, nullptr);
670 EXPECT_NE(physicalDevice_, nullptr);
671 EXPECT_NE(surface_, VK_NULL_HANDLE);
672
673 uint32_t presentModeCount = 1;
674 std::vector<VkPresentModeKHR> presentModes(presentModeCount);
675 VkResult err = fpGetPhysicalDeviceSurfacePresentModesKHR(
676 physicalDevice_, surface_, &presentModeCount, presentModes.data());
677 EXPECT_NE(err, VK_SUCCESS);
678 }
679 }
680
681 /**
682 * @tc.name: test fpGetPhysicalDeviceSurfaceFormatsKHR
683 * @tc.desc: test fpGetPhysicalDeviceSurfaceFormatsKHR
684 * @tc.type: FUNC
685 * @tc.require: issueI6SKRO
686 */
687 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfaceFormatsKHR_Test, TestSize.Level1)
688 {
689 if (isSupportedVulkan_) {
690 EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
691 EXPECT_NE(physicalDevice_, nullptr);
692 EXPECT_NE(surface_, VK_NULL_HANDLE);
693
694 uint32_t formatCount;
695 VkResult err = fpGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface_, &formatCount, NULL);
696 EXPECT_EQ(err, VK_SUCCESS);
697 EXPECT_GT(formatCount, 0);
698 std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
699 err = fpGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice_, surface_, &formatCount, surfaceFormats.data());
700 EXPECT_EQ(err, VK_SUCCESS);
701 surfaceFormat_ = surfaceFormats[0];
702 }
703 }
704
705 /**
706 * @tc.name: test fpGetPhysicalDeviceSurfaceFormatsKHR FAIL
707 * @tc.desc: test fpGetPhysicalDeviceSurfaceFormatsKHR FAIL
708 * @tc.type: FUNC
709 * @tc.require: issueI6SKRO
710 */
711 HWTEST_F(VulkanLoaderUnitTest, fpGetPhysicalDeviceSurfaceFormatsKHR_FAIL_Test, TestSize.Level1)
712 {
713 if (isSupportedVulkan_) {
714 EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
715 EXPECT_NE(physicalDevice_, nullptr);
716 EXPECT_NE(surface_, VK_NULL_HANDLE);
717
718 uint32_t formatCount = 1;
719 std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
720 VkResult err = fpGetPhysicalDeviceSurfaceFormatsKHR(
721 physicalDevice_, surface_, &formatCount, surfaceFormats.data());
722 EXPECT_NE(err, VK_SUCCESS);
723 }
724 }
725
726 /**
727 * @tc.name: test fpCreateSwapchainKHR Success
728 * @tc.desc: test fpCreateSwapchainKHR Success
729 * @tc.type: FUNC
730 * @tc.require: issueI6SKRO
731 */
732 HWTEST_F(VulkanLoaderUnitTest, fpCreateSwapchainKHR_Success_Test, TestSize.Level1)
733 {
734 if (isSupportedVulkan_) {
735 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
736 EXPECT_NE(device_, nullptr);
737 EXPECT_NE(surface_, VK_NULL_HANDLE);
738
739 std::vector<VkFormat> pixelFormatArray = {
740 VK_FORMAT_R8G8B8A8_UNORM,
741 VK_FORMAT_R8G8B8A8_SRGB,
742 };
743 std::vector<VkColorSpaceKHR> colorDataspaceArray = {
744 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,
745 VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT,
746 VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT,
747 VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT,
748 VK_COLOR_SPACE_DCI_P3_LINEAR_EXT,
749 VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT,
750 VK_COLOR_SPACE_BT709_LINEAR_EXT,
751 VK_COLOR_SPACE_BT709_NONLINEAR_EXT,
752 VK_COLOR_SPACE_BT2020_LINEAR_EXT,
753 VK_COLOR_SPACE_HDR10_ST2084_EXT,
754 VK_COLOR_SPACE_DOLBYVISION_EXT,
755 VK_COLOR_SPACE_HDR10_HLG_EXT,
756 VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT,
757 VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT,
758 VK_COLORSPACE_SRGB_NONLINEAR_KHR,
759 VK_COLOR_SPACE_DCI_P3_LINEAR_EXT
760 };
761 std::vector<VkSurfaceTransformFlagBitsKHR> transformArray = {
762 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
763 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR,
764 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR,
765 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR,
766 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR,
767 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR,
768 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR,
769 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR,
770 };
771
772 for (decltype(pixelFormatArray.size()) i = 0; i < pixelFormatArray.size(); i++) {
773 for (decltype(colorDataspaceArray.size()) j = 0; j < colorDataspaceArray.size(); j++) {
774 for (decltype(transformArray.size()) k = 0; k < transformArray.size(); k++) {
775 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(
776 pixelFormatArray[i], colorDataspaceArray[j], transformArray[k]);
777
778 VkSwapchainKHR swapChainSuccess = VK_NULL_HANDLE;
779 VkSwapchainKHR swapChainSuccess2 = VK_NULL_HANDLE;
780
781 VkResult err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChainSuccess);
782 EXPECT_EQ(err, VK_SUCCESS);
783 EXPECT_NE(swapChainSuccess, VK_NULL_HANDLE);
784
785 swapchainCI.oldSwapchain = swapChainSuccess;
786 err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChainSuccess2);
787 EXPECT_EQ(err, VK_SUCCESS);
788 EXPECT_NE(swapChainSuccess2, VK_NULL_HANDLE);
789 fpDestroySwapchainKHR(device_, swapChainSuccess, nullptr);
790 fpDestroySwapchainKHR(device_, swapChainSuccess2, nullptr);
791 }
792 }
793 }
794 }
795 }
796
797 /**
798 * @tc.name: test fpCreateSwapchainKHR fail
799 * @tc.desc: test fpCreateSwapchainKHR fail
800 * @tc.type: FUNC
801 * @tc.require: issueI6SKRO
802 */
803 HWTEST_F(VulkanLoaderUnitTest, fpCreateSwapchainKHR_Fail_Test, TestSize.Level1)
804 {
805 if (isSupportedVulkan_) {
806 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
807 EXPECT_NE(device_, nullptr);
808 EXPECT_NE(surface_, VK_NULL_HANDLE);
809
810 std::vector<VkColorSpaceKHR> colorDataspaceArray = {
811 VK_COLOR_SPACE_PASS_THROUGH_EXT,
812 VK_COLOR_SPACE_DISPLAY_NATIVE_AMD,
813 VK_COLOR_SPACE_MAX_ENUM_KHR
814 };
815
816 for (decltype(colorDataspaceArray.size()) i = 0; i < colorDataspaceArray.size(); i++) {
817 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(
818 VK_FORMAT_R8G8B8A8_UNORM, colorDataspaceArray[i]);
819
820 VkSwapchainKHR swapChainFail = VK_NULL_HANDLE;
821 VkSwapchainKHR swapChainFail2 = VK_NULL_HANDLE;
822
823 VkResult err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChainFail);
824 EXPECT_EQ(err, VK_SUCCESS);
825 EXPECT_NE(swapChainFail, VK_NULL_HANDLE);
826
827 swapchainCI.oldSwapchain = swapChainFail;
828 err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChainFail2);
829 EXPECT_EQ(err, VK_SUCCESS);
830 EXPECT_NE(swapChainFail2, VK_NULL_HANDLE);
831 fpDestroySwapchainKHR(device_, swapChainFail, nullptr);
832 fpDestroySwapchainKHR(device_, swapChainFail2, nullptr);
833 }
834 }
835 }
836
837 /**
838 * @tc.name: test vkCreateDebugUtilsMessengerEXT
839 * @tc.desc: test vkCreateDebugUtilsMessengerEXT
840 * @tc.type: FUNC
841 * @tc.require: issueI6SKRO
842 */
843 HWTEST_F(VulkanLoaderUnitTest, vkCreateDebugUtilsMessengerEXT_Test, TestSize.Level1)
844 {
845 if (isSupportedVulkan_) {
846 EXPECT_NE(vkCreateDebugUtilsMessengerEXT, nullptr);
847 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
848 EXPECT_NE(instance_, nullptr);
849 EXPECT_NE(device_, nullptr);
850
851 VkDebugUtilsMessengerCreateInfoEXT createInfo{};
852 createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
853 createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
854 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
855 createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
856 VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
857 createInfo.pfnUserCallback = UserCallback;
858 VkResult result = vkCreateDebugUtilsMessengerEXT(instance_, &createInfo, nullptr, &debugUtilsMessenger);
859 EXPECT_EQ(result, VK_SUCCESS);
860
861 debugMessage_.str("");
862 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(VK_FORMAT_MAX_ENUM, surfaceFormat_.colorSpace);
863 VkSwapchainKHR swapChain = VK_NULL_HANDLE;
864 result = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain);
865 EXPECT_EQ(result, VK_SUCCESS);
866 EXPECT_NE(swapChain, VK_NULL_HANDLE);
867 fpDestroySwapchainKHR(device_, swapChain, nullptr);
868
869 EXPECT_EQ((debugMessage_.str().find("unsupported swapchain format") != -1), true);
870 }
871 }
872
873 /**
874 * @tc.name: test vkDestroyDebugUtilsMessengerEXT
875 * @tc.desc: test vkDestroyDebugUtilsMessengerEXT
876 * @tc.type: FUNC
877 * @tc.require: issueI6SKRO
878 */
879 HWTEST_F(VulkanLoaderUnitTest, vkDestroyDebugUtilsMessengerEXT_Test, TestSize.Level1)
880 {
881 if (isSupportedVulkan_) {
882 EXPECT_NE(vkDestroyDebugUtilsMessengerEXT, nullptr);
883 EXPECT_NE(instance_, nullptr);
884 EXPECT_NE(device_, nullptr);
885 EXPECT_NE(debugUtilsMessenger, VK_NULL_HANDLE);
886
887 vkDestroyDebugUtilsMessengerEXT(instance_, debugUtilsMessenger, nullptr);
888
889 debugMessage_.str("");
890 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(VK_FORMAT_MAX_ENUM, surfaceFormat_.colorSpace);
891 VkSwapchainKHR swapChain = VK_NULL_HANDLE;
892 VkResult result = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain);
893 EXPECT_EQ(result, VK_SUCCESS);
894 EXPECT_NE(swapChain, VK_NULL_HANDLE);
895 fpDestroySwapchainKHR(device_, swapChain, nullptr);
896
897 EXPECT_EQ((debugMessage_.str() == ""), true);
898 }
899 }
900
901 /**
902 * @tc.name: test fpCreateSwapchainKHR
903 * @tc.desc: test fpCreateSwapchainKHR
904 * @tc.type: FUNC
905 * @tc.require: issueI6SKRO
906 */
907 HWTEST_F(VulkanLoaderUnitTest, fpCreateSwapchainKHR_Test, TestSize.Level1)
908 {
909 if (isSupportedVulkan_) {
910 EXPECT_NE(fpCreateSwapchainKHR, nullptr);
911 EXPECT_NE(device_, nullptr);
912 EXPECT_NE(surface_, VK_NULL_HANDLE);
913
914 VkSwapchainCreateInfoKHR swapchainCI = GetSwapchainCreateInfo(
915 VK_FORMAT_B8G8R8A8_UNORM, surfaceFormat_.colorSpace);
916
917 VkResult err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain_);
918 EXPECT_EQ(err, VK_SUCCESS);
919 EXPECT_NE(swapChain_, VK_NULL_HANDLE);
920
921 swapchainCI.oldSwapchain = swapChain_;
922 err = fpCreateSwapchainKHR(device_, &swapchainCI, nullptr, &swapChain2_);
923 EXPECT_EQ(err, VK_SUCCESS);
924 EXPECT_NE(swapChain2_, VK_NULL_HANDLE);
925 }
926 }
927
928 /**
929 * @tc.name: test fpGetSwapchainImagesKHR
930 * @tc.desc: test fpGetSwapchainImagesKHR
931 * @tc.type: FUNC
932 * @tc.require: issueI6SKRO
933 */
934 HWTEST_F(VulkanLoaderUnitTest, fpGetSwapchainImagesKHR_Test, TestSize.Level1)
935 {
936 if (isSupportedVulkan_) {
937 uint32_t imageCount;
938 std::vector<VkImage> images;
939 VkResult err = fpGetSwapchainImagesKHR(device_, swapChain_, &imageCount, NULL);
940 EXPECT_EQ(err, VK_SUCCESS);
941 images.resize(imageCount);
942 err = fpGetSwapchainImagesKHR(device_, swapChain_, &imageCount, images.data());
943 EXPECT_EQ(err, VK_SUCCESS);
944 }
945 }
946
947 /**
948 * @tc.name: test fpGetSwapchainImagesKHR FAIL
949 * @tc.desc: test fpGetSwapchainImagesKHR FAIL
950 * @tc.type: FUNC
951 * @tc.require: issueI6SKRO
952 */
953 HWTEST_F(VulkanLoaderUnitTest, fpGetSwapchainImagesKHR_FAIL_Test, TestSize.Level1)
954 {
955 if (isSupportedVulkan_) {
956 uint32_t imageCount = 1;
957 std::vector<VkImage> images(imageCount);
958 VkResult err = fpGetSwapchainImagesKHR(device_, swapChain2_, &imageCount, images.data());
959 EXPECT_NE(err, VK_SUCCESS);
960 }
961 }
962
963 /**
964 * @tc.name: test vkCreateSemaphore
965 * @tc.desc: test vkCreateSemaphore
966 * @tc.type: FUNC
967 * @tc.require: issueI6SKRO
968 */
969 HWTEST_F(VulkanLoaderUnitTest, vkCreateSemaphore_Test, TestSize.Level1)
970 {
971 if (isSupportedVulkan_) {
972 VkSemaphoreCreateInfo semaphoreCreateInfo {};
973 semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
974 PFN_vkCreateSemaphore vkCreateSemaphore = reinterpret_cast<PFN_vkCreateSemaphore>(
975 vkGetInstanceProcAddr(instance_, "vkCreateSemaphore"));
976 EXPECT_NE(vkCreateSemaphore, nullptr);
977 VkResult err = vkCreateSemaphore(device_, &semaphoreCreateInfo, nullptr, &semaphore_);
978 EXPECT_EQ(err, VK_SUCCESS);
979 }
980 }
981
982 /**
983 * @tc.name: test fpAcquireNextImage2KHR
984 * @tc.desc: test fpAcquireNextImage2KHR
985 * @tc.type: FUNC
986 * @tc.require: issueI6SKRO
987 */
988 HWTEST_F(VulkanLoaderUnitTest, fpAcquireNextImage2KHR_Test, TestSize.Level1)
989 {
990 if (isSupportedVulkan_) {
991 VkAcquireNextImageInfoKHR pAcquireInfo;
992 pAcquireInfo.swapchain = swapChain2_;
993 pAcquireInfo.timeout = UINT64_MAX;
994 pAcquireInfo.semaphore = semaphore_;
995 pAcquireInfo.fence = (VkFence)nullptr;
996 uint32_t imageIndex = 0;
997 VkResult err = fpAcquireNextImage2KHR(device_, &pAcquireInfo, &imageIndex);
998 EXPECT_EQ(err, VK_SUCCESS);
999 }
1000 }
1001
1002 /**
1003 * @tc.name: test fpQueuePresentKHR
1004 * @tc.desc: test fpQueuePresentKHR
1005 * @tc.type: FUNC
1006 * @tc.require: issueI6SKRO
1007 */
1008 HWTEST_F(VulkanLoaderUnitTest, fpQueuePresentKHR_Test, TestSize.Level1)
1009 {
1010 if (isSupportedVulkan_) {
1011 VkRectLayerKHR pRectangles = {};
1012
1013 std::vector<VkPresentRegionKHR> pRegions;
1014 VkPresentRegionKHR pRegion;
1015 pRegion.rectangleCount = 1;
1016 pRegion.pRectangles = &pRectangles;
1017 pRegions.push_back(pRegion);
1018
1019 VkPresentRegionsKHR presentRegions;
1020 presentRegions.sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR;
1021 presentRegions.pNext = NULL;
1022 presentRegions.swapchainCount = 1;
1023 presentRegions.pRegions = pRegions.data();
1024
1025 VkQueue queue = nullptr;
1026 PFN_vkGetDeviceQueue vkGetDeviceQueue = reinterpret_cast<PFN_vkGetDeviceQueue>(
1027 vkGetInstanceProcAddr(instance_, "vkGetDeviceQueue"));
1028 EXPECT_NE(vkGetDeviceQueue, nullptr);
1029 vkGetDeviceQueue(device_, 0, 0, &queue);
1030 EXPECT_NE(queue, nullptr);
1031 uint32_t imageIndex = 0;
1032 VkPresentInfoKHR presentInfo = {};
1033 presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
1034 presentInfo.pNext = &presentRegions;
1035 presentInfo.swapchainCount = 1;
1036 presentInfo.pSwapchains = &swapChain2_;
1037 presentInfo.pImageIndices = &imageIndex;
1038 EXPECT_NE(semaphore_, VK_NULL_HANDLE);
1039 presentInfo.pWaitSemaphores = &semaphore_;
1040 presentInfo.waitSemaphoreCount = 1;
1041 VkResult err = fpQueuePresentKHR(queue, &presentInfo);
1042 EXPECT_EQ(err, VK_SUCCESS);
1043 }
1044 }
1045
1046 /**
1047 * @tc.name: test vkDestroySurfaceKHR nullptr
1048 * @tc.desc: test vkDestroySurfaceKHR nullptr
1049 * @tc.type: FUNC
1050 * @tc.require: issueI6SKRO
1051 */
1052 HWTEST_F(VulkanLoaderUnitTest, DestroySurface_NULL_Test, TestSize.Level1)
1053 {
1054 if (isSupportedVulkan_) {
1055 EXPECT_NE(vkDestroySurfaceKHR, nullptr);
1056 vkDestroySurfaceKHR(instance_, VK_NULL_HANDLE, nullptr);
1057 }
1058 }
1059
1060 /**
1061 * @tc.name: test TranslateNativeToVulkanTransform
1062 * @tc.desc: test TranslateNativeToVulkanTransform
1063 * @tc.type: FUNC
1064 * @tc.require: issueI9EYX2
1065 */
1066 HWTEST_F(VulkanLoaderUnitTest, translateNativeToVulkanTransform_Test, TestSize.Level1)
1067 {
1068 if (isSupportedVulkan_) {
1069 EXPECT_NE(vkCreateSurfaceOHOS, nullptr);
1070 EXPECT_NE(instance_, nullptr);
1071
1072 OHNativeWindow* nativeWindow = CreateNativeWindow("translateNativeToVulkanTransform_Test");
1073 EXPECT_NE(nativeWindow, nullptr);
1074 std::vector<OH_NativeBuffer_TransformType> transformArray = {
1075 NATIVEBUFFER_ROTATE_NONE,
1076 NATIVEBUFFER_ROTATE_90,
1077 NATIVEBUFFER_ROTATE_180,
1078 NATIVEBUFFER_ROTATE_270,
1079 NATIVEBUFFER_FLIP_H,
1080 NATIVEBUFFER_FLIP_V,
1081 NATIVEBUFFER_FLIP_H_ROT90,
1082 NATIVEBUFFER_FLIP_V_ROT90,
1083 NATIVEBUFFER_FLIP_H_ROT180,
1084 NATIVEBUFFER_FLIP_V_ROT180,
1085 NATIVEBUFFER_FLIP_H_ROT270,
1086 NATIVEBUFFER_FLIP_V_ROT270,
1087 };
1088 VkSurfaceKHR surface = VK_NULL_HANDLE;
1089 for (decltype(transformArray.size()) i = 0; i < transformArray.size(); i++) {
1090 int res = NativeWindowSetTransformHint(nativeWindow, transformArray[i]);
1091 EXPECT_EQ(res, OHOS::GSERROR_OK);
1092
1093 VkSurfaceCreateInfoOHOS surfaceCreateInfo = {};
1094 surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS;
1095 surfaceCreateInfo.window = nativeWindow;
1096 VkResult err = vkCreateSurfaceOHOS(instance_, &surfaceCreateInfo, NULL, &surface);
1097 EXPECT_EQ(err, VK_SUCCESS);
1098 EXPECT_NE(surface, VK_NULL_HANDLE);
1099
1100
1101 EXPECT_NE(fpGetPhysicalDeviceSurfaceCapabilitiesKHR, nullptr);
1102 EXPECT_NE(physicalDevice_, nullptr);
1103 EXPECT_NE(surface, VK_NULL_HANDLE);
1104
1105 err = fpGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice_, surface, &surfCaps_);
1106 EXPECT_EQ(err, VK_SUCCESS);
1107
1108 vkDestroySurfaceKHR(instance_, surface, nullptr);
1109 surface = VK_NULL_HANDLE;
1110 }
1111 }
1112 }
1113 /**
1114 * @tc.name: test vkEnumerateDeviceExtensionProperties GetExtensionProperties
1115 * @tc.desc: test vkEnumerateDeviceExtensionProperties GetExtensionProperties
1116 * @tc.type: FUNC
1117 * @tc.require: issueI9EYX2
1118 */
1119 HWTEST_F(VulkanLoaderUnitTest, enumerateDeviceExtensionProperties_GetExtensionProperties_Test, TestSize.Level1)
1120 {
1121 if (isSupportedVulkan_) {
1122 uint32_t pPropertyCount = 0;
1123 const char* pLayerName = "VK_LAYER_OHOS_surface";
1124 VkResult err = vkEnumerateDeviceExtensionProperties(physicalDevice_, pLayerName, &pPropertyCount, nullptr);
1125 EXPECT_EQ(err, VK_SUCCESS);
1126 if (pPropertyCount > 0) {
1127 std::vector<VkExtensionProperties> pProperties(pPropertyCount);
1128 err = vkEnumerateDeviceExtensionProperties(
1129 physicalDevice_, pLayerName, &pPropertyCount, pProperties.data());
1130 EXPECT_EQ(err, VK_SUCCESS);
1131 }
1132 }
1133 }
1134
1135 } // vulkan::loader
1136