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 <window.h>
18 #include <gtest/gtest.h>
19 #include <dlfcn.h>
20 #include <iostream>
21 #include <string>
22 #include <vector>
23 #include <sstream>
24
25 #include "refbase.h"
26 #include "surface.h"
27 #include "vulkan/vulkan.h"
28 #include "render_context/render_context.h"
29 #include "transaction/rs_transaction.h"
30 #include "ui/rs_surface_extractor.h"
31 #include "ui/rs_surface_node.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35 using namespace OHOS::Rosen;
36
37 namespace vulkan::loader {
38 class VulkanLoaderUnitTest : public testing::Test {
39 public:
SetUpTestCase()40 static void SetUpTestCase() {}
41 static void TearDownTestCase();
SetUp()42 void SetUp() {}
TearDown()43 void TearDown() {}
44 uint32_t GetQueueFamilyIndex(VkQueueFlagBits queueFlags);
45 OHNativeWindow* CreateNativeWindow(std::string name);
46 VkSwapchainCreateInfoKHR GetSwapchainCreateInfo(VkFormat imageFormat, VkColorSpaceKHR imageColorSpace);
47 static VkBool32 UserCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
48 VkDebugUtilsMessageTypeFlagsEXT messageType,
49 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
50 void* pUserData);
51
52 static inline bool DLOpenLibVulkan();
53 static inline void TrytoCreateVkInstance();
54
55 static inline PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
56 static inline PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
57 static inline PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
58 static inline PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
59 static inline PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT;
60 static inline PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT;
61 static inline PFN_vkCreateInstance vkCreateInstance;
62 static inline PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
63 static inline PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
64
65 static inline PFN_vkDestroyInstance vkDestroyInstance;
66 static inline PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
67 static inline PFN_vkCreateDevice vkCreateDevice;
68 static inline PFN_vkDestroyDevice vkDestroyDevice;
69 static inline PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
70 static inline PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS;
71 static inline PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fpGetPhysicalDeviceSurfaceCapabilitiesKHR;
72 static inline PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fpGetPhysicalDeviceSurfacePresentModesKHR;
73 static inline PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fpGetPhysicalDeviceSurfaceFormatsKHR;
74 static inline PFN_vkCreateSwapchainKHR fpCreateSwapchainKHR;
75 static inline PFN_vkDestroySwapchainKHR fpDestroySwapchainKHR;
76 static inline PFN_vkAcquireNextImage2KHR fpAcquireNextImage2KHR;
77 static inline PFN_vkQueuePresentKHR fpQueuePresentKHR;
78 static inline PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
79 static inline PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
80 static inline PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
81 static inline PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
82 static inline PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
83 static inline PFN_vkGetSwapchainImagesKHR fpGetSwapchainImagesKHR;
84 static inline PFN_vkGetNativeBufferPropertiesOHOS fpGetNativeBufferPropertiesOHOS;
85 static inline PFN_vkGetMemoryNativeBufferOHOS fpGetMemoryNativeBufferOHOS;
86
87 static inline void *libVulkan_ = nullptr;
88 static inline VkInstance instance_ = nullptr;
89 static inline VkSurfaceKHR surface_ = VK_NULL_HANDLE;
90 static inline VkPhysicalDevice physicalDevice_ = nullptr;
91 static inline VkDevice device_ = nullptr;
92 static inline VkSurfaceCapabilitiesKHR surfCaps_ = {};
93 static inline VkSurfaceFormatKHR surfaceFormat_ = {};
94 static inline VkSwapchainKHR swapChain_ = VK_NULL_HANDLE;
95 static inline VkSwapchainKHR swapChain2_ = VK_NULL_HANDLE;
96 static inline VkSemaphore semaphore_ = VK_NULL_HANDLE;
97 static inline bool isSupportedVulkan_ = false;
98 static inline std::vector<VkQueueFamilyProperties> queueProps_;
99 static inline uint32_t queueCount_;
100 static inline VkDebugUtilsMessengerEXT debugUtilsMessenger = VK_NULL_HANDLE;
101 static inline std::stringstream debugMessage_;
102 };
103
DLOpenLibVulkan()104 bool VulkanLoaderUnitTest::DLOpenLibVulkan()
105 {
106 #if (defined(__aarch64__) || defined(__x86_64__))
107 const char *path = "/system/lib64/libvulkan.so";
108 #else
109 const char *path = "/system/lib/libvulkan.so";
110 #endif
111 libVulkan_ = dlopen(path, RTLD_NOW | RTLD_LOCAL);
112 if (libVulkan_ == nullptr) {
113 std::cout << "dlerror: " << dlerror() << std::endl;
114 std::cout << "isSupportedVulkan_: false" << std::endl;
115 return false;
116 }
117 return true;
118 }
119
TrytoCreateVkInstance()120 void VulkanLoaderUnitTest::TrytoCreateVkInstance()
121 {
122 VkApplicationInfo appInfo = {};
123 appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
124 appInfo.pApplicationName = "pApplicationName";
125 appInfo.pEngineName = "pEngineName";
126 appInfo.apiVersion = VK_API_VERSION_1_0;
127
128 std::vector<const char*> instanceExtensions = {
129 VK_KHR_SURFACE_EXTENSION_NAME,
130 VK_OHOS_SURFACE_EXTENSION_NAME,
131 VK_EXT_DEBUG_UTILS_EXTENSION_NAME
132 };
133
134 VkInstanceCreateInfo instanceCreateInfo = {};
135 instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
136 instanceCreateInfo.pNext = NULL;
137 instanceCreateInfo.pApplicationInfo = &appInfo;
138
139 instanceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(instanceExtensions.size());
140 instanceCreateInfo.ppEnabledExtensionNames = instanceExtensions.data();
141
142 VkResult result = vkCreateInstance(&instanceCreateInfo, nullptr, &instance_);
143 std::cout << "instance_ ptr: " << instance_ << std::endl;
144 if (result != VK_SUCCESS || instance_ == nullptr) {
145 isSupportedVulkan_ = false;
146 std::cout << "set isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
147 } else {
148 isSupportedVulkan_ = true;
149 std::cout << "set isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
150 }
151 std::cout << "set isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
152 std::cout << "TrytoCreateVkInstance result: " << result << std::endl;
153 }
154
GetSwapchainCreateInfo(VkFormat imageFormat,VkColorSpaceKHR imageColorSpace)155 VkSwapchainCreateInfoKHR VulkanLoaderUnitTest::GetSwapchainCreateInfo(
156 VkFormat imageFormat, VkColorSpaceKHR imageColorSpace)
157 {
158 VkSwapchainCreateInfoKHR swapchainCI = {};
159 swapchainCI.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
160 swapchainCI.surface = surface_;
161 uint32_t desiredNumberOfSwapchainImages = surfCaps_.minImageCount + 1;
162 if ((surfCaps_.maxImageCount > 0) &&
163 (desiredNumberOfSwapchainImages > surfCaps_.maxImageCount)) {
164 desiredNumberOfSwapchainImages = surfCaps_.maxImageCount;
165 }
166 swapchainCI.minImageCount = desiredNumberOfSwapchainImages;
167 swapchainCI.imageFormat = imageFormat;
168 swapchainCI.imageColorSpace = imageColorSpace;
169 uint32_t width = 1280;
170 uint32_t height = 720;
171 swapchainCI.imageExtent = { width, height };
172 swapchainCI.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
173 swapchainCI.preTransform = (VkSurfaceTransformFlagBitsKHR)VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
174 swapchainCI.imageArrayLayers = 1;
175 swapchainCI.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
176 swapchainCI.queueFamilyIndexCount = 0;
177 swapchainCI.presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
178 swapchainCI.oldSwapchain = swapChain_;
179 swapchainCI.clipped = VK_TRUE;
180 swapchainCI.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
181
182 return swapchainCI;
183 }
184
CreateNativeWindow(std::string name)185 OHNativeWindow* VulkanLoaderUnitTest::CreateNativeWindow(std::string name)
186 {
187 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
188 rsSurfaceNodeConfig.SurfaceNodeName = "createSurface_test";
189 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
190 OHOS::sptr<OHOS::Surface> surf = surfaceNode->GetSurface();
191 OHNativeWindow* nativeWindow = CreateNativeWindowFromSurface(&surf);
192 return nativeWindow;
193 }
194
GetQueueFamilyIndex(VkQueueFlagBits queueFlags)195 uint32_t VulkanLoaderUnitTest::GetQueueFamilyIndex(VkQueueFlagBits queueFlags)
196 {
197 decltype(queueProps_.size()) i = 0;
198 if (queueFlags & VK_QUEUE_COMPUTE_BIT) {
199 for (i = 0; i < queueProps_.size(); i++) {
200 if ((queueProps_[i].queueFlags & queueFlags) &&
201 ((queueProps_[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)) {
202 return i;
203 }
204 }
205 }
206 if (queueFlags & VK_QUEUE_TRANSFER_BIT) {
207 for (i = 0; i < queueProps_.size(); i++) {
208 if ((queueProps_[i].queueFlags & queueFlags) &&
209 ((queueProps_[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) &&
210 ((queueProps_[i].queueFlags & VK_QUEUE_COMPUTE_BIT) == 0)) {
211 return i;
212 }
213 }
214 }
215 for (i = 0; i < queueProps_.size(); i++) {
216 if (queueProps_[i].queueFlags & queueFlags) {
217 return i;
218 }
219 }
220 std::cout << "Could not find a matching queue family index" << std::endl;
221 return -1;
222 }
223
UserCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,VkDebugUtilsMessageTypeFlagsEXT messageType,const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData,void * pUserData)224 VkBool32 VulkanLoaderUnitTest::UserCallback(
225 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
226 VkDebugUtilsMessageTypeFlagsEXT messageType,
227 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
228 void* pUserData)
229 {
230 std::string prefix("");
231 if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
232 prefix = "ERROR: ";
233 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
234 prefix = "WARN: ";
235 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
236 prefix = "INFO: ";
237 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
238 prefix = "DEBUG: ";
239 }
240 debugMessage_ << prefix << "[" << pCallbackData->messageIdNumber << "]["
241 << pCallbackData->pMessageIdName << "] : " << pCallbackData->pMessage;
242 return VK_FALSE;
243 }
244
TearDownTestCase()245 void VulkanLoaderUnitTest::TearDownTestCase()
246 {
247 if (device_ != nullptr) {
248 if (swapChain_ != VK_NULL_HANDLE) {
249 fpDestroySwapchainKHR(device_, swapChain_, nullptr);
250 }
251 vkDestroyDevice(device_, nullptr);
252 }
253 if (instance_ != nullptr) {
254 if (surface_ != VK_NULL_HANDLE) {
255 vkDestroySurfaceKHR(instance_, surface_, nullptr);
256 }
257 vkDestroyInstance(instance_, nullptr);
258 }
259 }
260
261 /**
262 * @tc.name: Load base Vulkan functions
263 * @tc.desc: Load base Vulkan functions
264 * @tc.type: FUNC
265 * @tc.require: issueI6SKRO
266 */
267 HWTEST_F(VulkanLoaderUnitTest, LoadBaseFuncPtr, TestSize.Level1)
268 {
269 bool opened = DLOpenLibVulkan();
270 std::cout << "LibVulkan opened: " << opened << std::endl;
271 std::cout << "libVulkan_ ptr: " << libVulkan_ << std::endl;
272 if (opened && libVulkan_ != nullptr) {
273 // Load base functions
274 vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
275 dlsym(libVulkan_, "vkEnumerateInstanceExtensionProperties"));
276 EXPECT_NE(vkEnumerateInstanceExtensionProperties, nullptr);
277 vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
278 dlsym(libVulkan_, "vkEnumerateInstanceLayerProperties"));
279 EXPECT_NE(vkEnumerateInstanceLayerProperties, nullptr);
280 vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(
281 dlsym(libVulkan_, "vkEnumerateDeviceExtensionProperties"));
282 EXPECT_NE(vkEnumerateDeviceExtensionProperties, nullptr);
283 vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(
284 dlsym(libVulkan_, "vkEnumerateDeviceLayerProperties"));
285 EXPECT_NE(vkEnumerateDeviceLayerProperties, nullptr);
286 vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dlsym(libVulkan_, "vkCreateInstance"));
287 EXPECT_NE(vkCreateInstance, nullptr);
288 vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(libVulkan_, "vkGetInstanceProcAddr"));
289 EXPECT_NE(vkGetInstanceProcAddr, nullptr);
290 vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(dlsym(libVulkan_, "vkGetDeviceProcAddr"));
291 EXPECT_NE(vkGetDeviceProcAddr, nullptr);
292 TrytoCreateVkInstance();
293 }
294 }
295
296 /**
297 * @tc.name: load instance based function pointer
298 * @tc.desc: load instance based function pointer
299 * @tc.type: FUNC
300 * @tc.require: issueI6SKRO
301 */
302 HWTEST_F(VulkanLoaderUnitTest, LoadInstanceFuncPtr, TestSize.Level1)
303 {
304 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
305 if (isSupportedVulkan_) {
306 std::cout << "instance_ ptr: " << instance_ << std::endl;
307 ASSERT_NE(instance_, nullptr);
308 vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
309 vkGetInstanceProcAddr(instance_, "vkDestroyInstance"));
310 EXPECT_NE(vkDestroyInstance, nullptr);
311 vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(
312 vkGetInstanceProcAddr(instance_, "vkEnumeratePhysicalDevices"));
313 EXPECT_NE(vkEnumeratePhysicalDevices, nullptr);
314 vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(vkGetInstanceProcAddr(instance_, "vkCreateDevice"));
315 EXPECT_NE(vkCreateDevice, nullptr);
316 vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(vkGetInstanceProcAddr(instance_, "vkDestroyDevice"));
317 EXPECT_NE(vkDestroyDevice, nullptr);
318 vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(
319 vkGetInstanceProcAddr(instance_, "vkDestroySurfaceKHR"));
320 EXPECT_NE(vkDestroySurfaceKHR, nullptr);
321
322 vkCreateSurfaceOHOS = reinterpret_cast<PFN_vkCreateSurfaceOHOS>(
323 vkGetInstanceProcAddr(instance_, "vkCreateSurfaceOHOS"));
324 EXPECT_NE(vkCreateSurfaceOHOS, nullptr);
325
326 fpGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(
327 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
328 EXPECT_NE(fpGetPhysicalDeviceSurfaceCapabilitiesKHR, nullptr);
329 fpGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(
330 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
331 EXPECT_NE(fpGetPhysicalDeviceSurfacePresentModesKHR, nullptr);
332 fpGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(
333 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
334 EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
335 vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(
336 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceQueueFamilyProperties"));
337 EXPECT_NE(vkGetPhysicalDeviceQueueFamilyProperties, nullptr);
338 vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(
339 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceProperties"));
340 EXPECT_NE(vkGetPhysicalDeviceProperties, nullptr);
341 vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(
342 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceFeatures"));
343 EXPECT_NE(vkGetPhysicalDeviceFeatures, nullptr);
344 vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(
345 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceMemoryProperties"));
346 EXPECT_NE(vkGetPhysicalDeviceMemoryProperties, nullptr);
347 vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(
348 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceSupportKHR"));
349 EXPECT_NE(vkGetPhysicalDeviceSurfaceSupportKHR, nullptr);
350 vkCreateDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(
351 vkGetInstanceProcAddr(instance_, "vkCreateDebugUtilsMessengerEXT"));
352 EXPECT_NE(vkCreateDebugUtilsMessengerEXT, nullptr);
353 vkDestroyDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(
354 vkGetInstanceProcAddr(instance_, "vkDestroyDebugUtilsMessengerEXT"));
355 EXPECT_NE(vkDestroyDebugUtilsMessengerEXT, nullptr);
356 }
357 }
358
359 /**
360 * @tc.name: test vkEnumeratePhysicalDevices
361 * @tc.desc: test vkEnumeratePhysicalDevices
362 * @tc.type: FUNC
363 * @tc.require: issueI6SKRO
364 */
365 HWTEST_F(VulkanLoaderUnitTest, vkEnumeratePhysicalDevices_Test, TestSize.Level1)
366 {
367 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
368 if (isSupportedVulkan_) {
369 std::cout << "instance_ ptr: " << instance_ << std::endl;
370 ASSERT_NE(instance_, nullptr);
371
372 uint32_t gpuCount = 0;
373 VkResult err = vkEnumeratePhysicalDevices(instance_, &gpuCount, nullptr);
374 EXPECT_EQ(err, VK_SUCCESS);
375 EXPECT_NE(gpuCount, 0);
376 std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
377 err = vkEnumeratePhysicalDevices(instance_, &gpuCount, physicalDevices.data());
378 EXPECT_EQ(err, VK_SUCCESS);
379 physicalDevice_ = physicalDevices[0];
380 EXPECT_NE(physicalDevice_, nullptr);
381
382 VkPhysicalDeviceProperties deviceProperties;
383 VkPhysicalDeviceFeatures deviceFeatures;
384 VkPhysicalDeviceMemoryProperties deviceMemoryProperties;
385 vkGetPhysicalDeviceProperties(physicalDevice_, &deviceProperties);
386 vkGetPhysicalDeviceFeatures(physicalDevice_, &deviceFeatures);
387 vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &deviceMemoryProperties);
388 }
389 }
390
391 /**
392 * @tc.name: test vkCreateDevice
393 * @tc.desc: test vkCreateDevice
394 * @tc.type: FUNC
395 * @tc.require: issueI6SKRO
396 */
397 HWTEST_F(VulkanLoaderUnitTest, vkCreateDevice_Test, TestSize.Level1)
398 {
399 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
400 if (isSupportedVulkan_) {
401 std::cout << "vkCreateDevice ptr: " << vkCreateDevice << std::endl;
402 EXPECT_NE(vkCreateDevice, nullptr);
403 std::cout << "physicalDevice_ ptr: " << physicalDevice_ << std::endl;
404 EXPECT_NE(physicalDevice_, nullptr);
405
406 VkDeviceCreateInfo deviceCreateInfo = {};
407 deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
408
409 std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
410 const float defaultQueuePriority(0.0f);
411 VkDeviceQueueCreateInfo queueInfo{};
412 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
413 queueInfo.queueFamilyIndex = GetQueueFamilyIndex(VK_QUEUE_GRAPHICS_BIT);
414 queueInfo.queueCount = 1;
415 queueInfo.pQueuePriorities = &defaultQueuePriority;
416 queueCreateInfos.push_back(queueInfo);
417 deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
418 deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
419
420 std::vector<const char*> deviceExtensions;
421 deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
422 deviceCreateInfo.enabledExtensionCount = (uint32_t)deviceExtensions.size();
423 deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
424 VkDevice logicalDevice;
425 VkResult err = vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &logicalDevice);
426 std::cout << "vkCreateDevice err: " << err << std::endl;
427 EXPECT_EQ(err, VK_SUCCESS);
428 std::cout << "logicalDevice ptr: " << logicalDevice << std::endl;
429 EXPECT_NE(logicalDevice, nullptr);
430 device_ = logicalDevice;
431 }
432 }
433
434 /**
435 * @tc.name: test vkCreateDevice
436 * @tc.desc: test vkCreateDevice
437 * @tc.type: FUNC
438 * @tc.require: issueI6SKRO
439 */
440 HWTEST_F(VulkanLoaderUnitTest, getNativeBufferPropertiesOHOS_Test, TestSize.Level1)
441 {
442 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
443 if (isSupportedVulkan_) {
444 std::cout << "vkCreateDevice ptr: " << vkCreateDevice << std::endl;
445 EXPECT_NE(vkCreateDevice, nullptr);
446 std::cout << "physicalDevice_ ptr: " << physicalDevice_ << std::endl;
447 EXPECT_NE(physicalDevice_, nullptr);
448 VkDeviceCreateInfo deviceCreateInfo = {};
449 deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
450
451 std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
452 const float defaultQueuePriority(0.0f);
453 VkDeviceQueueCreateInfo queueInfo{};
454 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
455 queueInfo.queueFamilyIndex = GetQueueFamilyIndex(VK_QUEUE_GRAPHICS_BIT);
456 queueInfo.queueCount = 1;
457 queueInfo.pQueuePriorities = &defaultQueuePriority;
458 queueCreateInfos.push_back(queueInfo);
459 deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
460 deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
461
462 std::vector<const char*> deviceExtensions;
463 deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
464 deviceCreateInfo.enabledExtensionCount = (uint32_t)deviceExtensions.size();
465 deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
466 VkDevice logicalDevice;
467 VkResult err = vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &logicalDevice);
468 std::cout << "vkCreateDevice err: " << err << std::endl;
469 EXPECT_EQ(err, VK_SUCCESS);
470 std::cout << "logicalDevice ptr: " << logicalDevice << std::endl;
471 EXPECT_NE(logicalDevice, nullptr);
472 device_ = logicalDevice;
473
474 OH_NativeBuffer *aHardBuffer = {};
475 VkNativeBufferPropertiesOHOS androidHardwareBufferPropertiesOHOS = {};
476 VkNativeBufferFormatPropertiesOHOS nativeBufferFormatPropertiesOHOS = {};
477 nativeBufferFormatPropertiesOHOS.sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS;
478 nativeBufferFormatPropertiesOHOS.pNext = nullptr;
479 androidHardwareBufferPropertiesOHOS.sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS;
480 androidHardwareBufferPropertiesOHOS.pNext = &nativeBufferFormatPropertiesOHOS;
481 fpGetNativeBufferPropertiesOHOS = reinterpret_cast<PFN_vkGetNativeBufferPropertiesOHOS>(
482 vkGetDeviceProcAddr(device_, "vkGetNativeBufferPropertiesOHOS"));
483 fpGetNativeBufferPropertiesOHOS(device_, aHardBuffer, &androidHardwareBufferPropertiesOHOS);
484 }
485 }
486
487 /**
488 * @tc.name: test vkCreateDevice
489 * @tc.desc: test vkCreateDevice
490 * @tc.type: FUNC
491 * @tc.require: issueI6SKRO
492 */
493 HWTEST_F(VulkanLoaderUnitTest, getMemoryNativeBufferOHOS_Test, TestSize.Level1)
494 {
495 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
496 if (isSupportedVulkan_) {
497 std::cout << "vkCreateDevice ptr: " << vkCreateDevice << std::endl;
498 EXPECT_NE(vkCreateDevice, nullptr);
499 std::cout << "physicalDevice_ ptr: " << physicalDevice_ << std::endl;
500 EXPECT_NE(physicalDevice_, nullptr);
501 VkDeviceCreateInfo deviceCreateInfo = {};
502 deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
503
504 std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
505 const float defaultQueuePriority(0.0f);
506 VkDeviceQueueCreateInfo queueInfo{};
507 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
508 queueInfo.queueFamilyIndex = GetQueueFamilyIndex(VK_QUEUE_GRAPHICS_BIT);
509 queueInfo.queueCount = 1;
510 queueInfo.pQueuePriorities = &defaultQueuePriority;
511 queueCreateInfos.push_back(queueInfo);
512 deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
513 deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
514
515 std::vector<const char*> deviceExtensions;
516 deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
517 deviceCreateInfo.enabledExtensionCount = (uint32_t)deviceExtensions.size();
518 deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
519 VkDevice logicalDevice;
520 VkResult err = vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &logicalDevice);
521 std::cout << "vkCreateDevice err: " << err << std::endl;
522 EXPECT_EQ(err, VK_SUCCESS);
523 std::cout << "logicalDevice ptr: " << logicalDevice << std::endl;
524 EXPECT_NE(logicalDevice, nullptr);
525 device_ = logicalDevice;
526
527 OH_NativeBuffer *aHardBuffer = {};
528 VkDeviceMemory handwareBufferMemory = {};
529 VkMemoryGetNativeBufferInfoOHOS getAndroidHardwareBufferInfoOHOS;
530 getAndroidHardwareBufferInfoOHOS.sType = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS;
531 getAndroidHardwareBufferInfoOHOS.pNext = nullptr;
532 getAndroidHardwareBufferInfoOHOS.memory = handwareBufferMemory;
533 fpGetMemoryNativeBufferOHOS = reinterpret_cast<PFN_vkGetMemoryNativeBufferOHOS>(
534 vkGetDeviceProcAddr(device_, "vkGetMemoryNativeBufferOHOS"));
535 fpGetMemoryNativeBufferOHOS(device_, &getAndroidHardwareBufferInfoOHOS, &aHardBuffer);
536 }
537 }
538 } // vulkan::loader
539