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