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 } else {
147 isSupportedVulkan_ = true;
148 }
149 std::cout << "set isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
150 std::cout << "TrytoCreateVkInstance result: " << result << std::endl;
151 }
152
GetSwapchainCreateInfo( VkFormat imageFormat, VkColorSpaceKHR imageColorSpace)153 VkSwapchainCreateInfoKHR VulkanLoaderUnitTest::GetSwapchainCreateInfo(
154 VkFormat imageFormat, VkColorSpaceKHR imageColorSpace)
155 {
156 VkSwapchainCreateInfoKHR swapchainCI = {};
157 swapchainCI.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
158 swapchainCI.surface = surface_;
159 uint32_t desiredNumberOfSwapchainImages = surfCaps_.minImageCount + 1;
160 if ((surfCaps_.maxImageCount > 0) &&
161 (desiredNumberOfSwapchainImages > surfCaps_.maxImageCount)) {
162 desiredNumberOfSwapchainImages = surfCaps_.maxImageCount;
163 }
164 swapchainCI.minImageCount = desiredNumberOfSwapchainImages;
165 swapchainCI.imageFormat = imageFormat;
166 swapchainCI.imageColorSpace = imageColorSpace;
167 uint32_t width = 1280;
168 uint32_t height = 720;
169 swapchainCI.imageExtent = { width, height };
170 swapchainCI.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
171 swapchainCI.preTransform = (VkSurfaceTransformFlagBitsKHR)VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
172 swapchainCI.imageArrayLayers = 1;
173 swapchainCI.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
174 swapchainCI.queueFamilyIndexCount = 0;
175 swapchainCI.presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
176 swapchainCI.oldSwapchain = swapChain_;
177 swapchainCI.clipped = VK_TRUE;
178 swapchainCI.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
179
180 return swapchainCI;
181 }
182
CreateNativeWindow(std::string name)183 OHNativeWindow* VulkanLoaderUnitTest::CreateNativeWindow(std::string name)
184 {
185 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
186 rsSurfaceNodeConfig.SurfaceNodeName = "createSurface_test";
187 auto surfaceNode = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
188 OHOS::sptr<OHOS::Surface> surf = surfaceNode->GetSurface();
189 OHNativeWindow* nativeWindow = CreateNativeWindowFromSurface(&surf);
190 return nativeWindow;
191 }
192
GetQueueFamilyIndex(VkQueueFlagBits queueFlags)193 uint32_t VulkanLoaderUnitTest::GetQueueFamilyIndex(VkQueueFlagBits queueFlags)
194 {
195 decltype(queueProps_.size()) i = 0;
196 if (queueFlags & VK_QUEUE_COMPUTE_BIT) {
197 for (i = 0; i < queueProps_.size(); i++) {
198 if ((queueProps_[i].queueFlags & queueFlags) &&
199 ((queueProps_[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)) {
200 return i;
201 }
202 }
203 }
204 if (queueFlags & VK_QUEUE_TRANSFER_BIT) {
205 for (i = 0; i < queueProps_.size(); i++) {
206 if ((queueProps_[i].queueFlags & queueFlags) &&
207 ((queueProps_[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) &&
208 ((queueProps_[i].queueFlags & VK_QUEUE_COMPUTE_BIT) == 0)) {
209 return i;
210 }
211 }
212 }
213 for (i = 0; i < queueProps_.size(); i++) {
214 if (queueProps_[i].queueFlags & queueFlags) {
215 return i;
216 }
217 }
218 std::cout << "Could not find a matching queue family index" << std::endl;
219 return -1;
220 }
221
UserCallback( VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData)222 VkBool32 VulkanLoaderUnitTest::UserCallback(
223 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
224 VkDebugUtilsMessageTypeFlagsEXT messageType,
225 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
226 void* pUserData)
227 {
228 std::string prefix("");
229 if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
230 prefix = "ERROR: ";
231 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
232 prefix = "WARN: ";
233 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT) {
234 prefix = "INFO: ";
235 } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT) {
236 prefix = "DEBUG: ";
237 }
238 debugMessage_ << prefix << "[" << pCallbackData->messageIdNumber << "]["
239 << pCallbackData->pMessageIdName << "] : " << pCallbackData->pMessage;
240 return VK_FALSE;
241 }
242
TearDownTestCase()243 void VulkanLoaderUnitTest::TearDownTestCase()
244 {
245 if (device_ != nullptr) {
246 if (swapChain_ != VK_NULL_HANDLE) {
247 fpDestroySwapchainKHR(device_, swapChain_, nullptr);
248 }
249 vkDestroyDevice(device_, nullptr);
250 }
251 if (instance_ != nullptr) {
252 if (surface_ != VK_NULL_HANDLE) {
253 vkDestroySurfaceKHR(instance_, surface_, nullptr);
254 }
255 vkDestroyInstance(instance_, nullptr);
256 }
257 }
258
259 /**
260 * @tc.name: Load base Vulkan functions
261 * @tc.desc: Load base Vulkan functions
262 * @tc.type: FUNC
263 * @tc.require: issueI6SKRO
264 */
HWTEST_F(VulkanLoaderUnitTest, LoadBaseFuncPtr, TestSize.Level1)265 HWTEST_F(VulkanLoaderUnitTest, LoadBaseFuncPtr, TestSize.Level1)
266 {
267 bool opened = DLOpenLibVulkan();
268 std::cout << "LibVulkan opened: " << opened << std::endl;
269 std::cout << "libVulkan_ ptr: " << libVulkan_ << std::endl;
270 if (opened && libVulkan_ != nullptr) {
271 // Load base functions
272 vkEnumerateInstanceExtensionProperties = reinterpret_cast<PFN_vkEnumerateInstanceExtensionProperties>(
273 dlsym(libVulkan_, "vkEnumerateInstanceExtensionProperties"));
274 EXPECT_NE(vkEnumerateInstanceExtensionProperties, nullptr);
275 vkEnumerateInstanceLayerProperties = reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
276 dlsym(libVulkan_, "vkEnumerateInstanceLayerProperties"));
277 EXPECT_NE(vkEnumerateInstanceLayerProperties, nullptr);
278 vkEnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(
279 dlsym(libVulkan_, "vkEnumerateDeviceExtensionProperties"));
280 EXPECT_NE(vkEnumerateDeviceExtensionProperties, nullptr);
281 vkEnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(
282 dlsym(libVulkan_, "vkEnumerateDeviceLayerProperties"));
283 EXPECT_NE(vkEnumerateDeviceLayerProperties, nullptr);
284 vkCreateInstance = reinterpret_cast<PFN_vkCreateInstance>(dlsym(libVulkan_, "vkCreateInstance"));
285 EXPECT_NE(vkCreateInstance, nullptr);
286 vkGetInstanceProcAddr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(libVulkan_, "vkGetInstanceProcAddr"));
287 EXPECT_NE(vkGetInstanceProcAddr, nullptr);
288 vkGetDeviceProcAddr = reinterpret_cast<PFN_vkGetDeviceProcAddr>(dlsym(libVulkan_, "vkGetDeviceProcAddr"));
289 EXPECT_NE(vkGetDeviceProcAddr, nullptr);
290 TrytoCreateVkInstance();
291 }
292 }
293
294 /**
295 * @tc.name: load instance based function pointer
296 * @tc.desc: load instance based function pointer
297 * @tc.type: FUNC
298 * @tc.require: issueI6SKRO
299 */
HWTEST_F(VulkanLoaderUnitTest, LoadInstanceFuncPtr, TestSize.Level1)300 HWTEST_F(VulkanLoaderUnitTest, LoadInstanceFuncPtr, TestSize.Level1)
301 {
302 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
303 if (isSupportedVulkan_) {
304 std::cout << "instance_ ptr: " << instance_ << std::endl;
305 ASSERT_NE(instance_, nullptr);
306 vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
307 vkGetInstanceProcAddr(instance_, "vkDestroyInstance"));
308 EXPECT_NE(vkDestroyInstance, nullptr);
309 vkEnumeratePhysicalDevices = reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(
310 vkGetInstanceProcAddr(instance_, "vkEnumeratePhysicalDevices"));
311 EXPECT_NE(vkEnumeratePhysicalDevices, nullptr);
312 vkCreateDevice = reinterpret_cast<PFN_vkCreateDevice>(vkGetInstanceProcAddr(instance_, "vkCreateDevice"));
313 EXPECT_NE(vkCreateDevice, nullptr);
314 vkDestroyDevice = reinterpret_cast<PFN_vkDestroyDevice>(vkGetInstanceProcAddr(instance_, "vkDestroyDevice"));
315 EXPECT_NE(vkDestroyDevice, nullptr);
316 vkDestroySurfaceKHR = reinterpret_cast<PFN_vkDestroySurfaceKHR>(
317 vkGetInstanceProcAddr(instance_, "vkDestroySurfaceKHR"));
318 EXPECT_NE(vkDestroySurfaceKHR, nullptr);
319
320 vkCreateSurfaceOHOS = reinterpret_cast<PFN_vkCreateSurfaceOHOS>(
321 vkGetInstanceProcAddr(instance_, "vkCreateSurfaceOHOS"));
322 EXPECT_NE(vkCreateSurfaceOHOS, nullptr);
323
324 fpGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>(
325 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR"));
326 EXPECT_NE(fpGetPhysicalDeviceSurfaceCapabilitiesKHR, nullptr);
327 fpGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR>(
328 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfacePresentModesKHR"));
329 EXPECT_NE(fpGetPhysicalDeviceSurfacePresentModesKHR, nullptr);
330 fpGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR>(
331 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceFormatsKHR"));
332 EXPECT_NE(fpGetPhysicalDeviceSurfaceFormatsKHR, nullptr);
333 vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceQueueFamilyProperties>(
334 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceQueueFamilyProperties"));
335 EXPECT_NE(vkGetPhysicalDeviceQueueFamilyProperties, nullptr);
336 vkGetPhysicalDeviceProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(
337 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceProperties"));
338 EXPECT_NE(vkGetPhysicalDeviceProperties, nullptr);
339 vkGetPhysicalDeviceFeatures = reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures>(
340 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceFeatures"));
341 EXPECT_NE(vkGetPhysicalDeviceFeatures, nullptr);
342 vkGetPhysicalDeviceMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(
343 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceMemoryProperties"));
344 EXPECT_NE(vkGetPhysicalDeviceMemoryProperties, nullptr);
345 vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast<PFN_vkGetPhysicalDeviceSurfaceSupportKHR>(
346 vkGetInstanceProcAddr(instance_, "vkGetPhysicalDeviceSurfaceSupportKHR"));
347 EXPECT_NE(vkGetPhysicalDeviceSurfaceSupportKHR, nullptr);
348 vkCreateDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkCreateDebugUtilsMessengerEXT>(
349 vkGetInstanceProcAddr(instance_, "vkCreateDebugUtilsMessengerEXT"));
350 EXPECT_NE(vkCreateDebugUtilsMessengerEXT, nullptr);
351 vkDestroyDebugUtilsMessengerEXT = reinterpret_cast<PFN_vkDestroyDebugUtilsMessengerEXT>(
352 vkGetInstanceProcAddr(instance_, "vkDestroyDebugUtilsMessengerEXT"));
353 EXPECT_NE(vkDestroyDebugUtilsMessengerEXT, nullptr);
354 }
355 }
356
357 /**
358 * @tc.name: test vkEnumeratePhysicalDevices
359 * @tc.desc: test vkEnumeratePhysicalDevices
360 * @tc.type: FUNC
361 * @tc.require: issueI6SKRO
362 */
HWTEST_F(VulkanLoaderUnitTest, vkEnumeratePhysicalDevices_Test, TestSize.Level1)363 HWTEST_F(VulkanLoaderUnitTest, vkEnumeratePhysicalDevices_Test, TestSize.Level1)
364 {
365 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
366 if (isSupportedVulkan_) {
367 std::cout << "instance_ ptr: " << instance_ << std::endl;
368 ASSERT_NE(instance_, nullptr);
369
370 uint32_t gpuCount = 0;
371 VkResult err = vkEnumeratePhysicalDevices(instance_, &gpuCount, nullptr);
372 EXPECT_EQ(err, VK_SUCCESS);
373 EXPECT_NE(gpuCount, 0);
374 std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
375 err = vkEnumeratePhysicalDevices(instance_, &gpuCount, physicalDevices.data());
376 EXPECT_EQ(err, VK_SUCCESS);
377 physicalDevice_ = physicalDevices[0];
378 EXPECT_NE(physicalDevice_, nullptr);
379
380 VkPhysicalDeviceProperties deviceProperties;
381 VkPhysicalDeviceFeatures deviceFeatures;
382 VkPhysicalDeviceMemoryProperties deviceMemoryProperties;
383 vkGetPhysicalDeviceProperties(physicalDevice_, &deviceProperties);
384 vkGetPhysicalDeviceFeatures(physicalDevice_, &deviceFeatures);
385 vkGetPhysicalDeviceMemoryProperties(physicalDevice_, &deviceMemoryProperties);
386 }
387 }
388
389 /**
390 * @tc.name: test vkCreateDevice
391 * @tc.desc: test vkCreateDevice
392 * @tc.type: FUNC
393 * @tc.require: issueI6SKRO
394 */
HWTEST_F(VulkanLoaderUnitTest, vkCreateDevice_Test, TestSize.Level1)395 HWTEST_F(VulkanLoaderUnitTest, vkCreateDevice_Test, TestSize.Level1)
396 {
397 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
398 if (isSupportedVulkan_) {
399 std::cout << "vkCreateDevice ptr: " << vkCreateDevice << std::endl;
400 EXPECT_NE(vkCreateDevice, nullptr);
401 std::cout << "physicalDevice_ ptr: " << physicalDevice_ << std::endl;
402 EXPECT_NE(physicalDevice_, nullptr);
403
404 VkDeviceCreateInfo deviceCreateInfo = {};
405 deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
406
407 std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
408 const float defaultQueuePriority(0.0f);
409 VkDeviceQueueCreateInfo queueInfo{};
410 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
411 queueInfo.queueFamilyIndex = GetQueueFamilyIndex(VK_QUEUE_GRAPHICS_BIT);
412 queueInfo.queueCount = 1;
413 queueInfo.pQueuePriorities = &defaultQueuePriority;
414 queueCreateInfos.push_back(queueInfo);
415 deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
416 deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
417
418 std::vector<const char*> deviceExtensions;
419 deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
420 deviceCreateInfo.enabledExtensionCount = (uint32_t)deviceExtensions.size();
421 deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
422 VkDevice logicalDevice;
423 VkResult err = vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &logicalDevice);
424 std::cout << "vkCreateDevice err: " << err << std::endl;
425 EXPECT_EQ(err, VK_SUCCESS);
426 std::cout << "logicalDevice ptr: " << logicalDevice << std::endl;
427 EXPECT_NE(logicalDevice, nullptr);
428 device_ = logicalDevice;
429 }
430 }
431
432 /**
433 * @tc.name: test vkCreateDevice
434 * @tc.desc: test vkCreateDevice
435 * @tc.type: FUNC
436 * @tc.require: issueI6SKRO
437 */
HWTEST_F(VulkanLoaderUnitTest, getNativeBufferPropertiesOHOS_Test, TestSize.Level1)438 HWTEST_F(VulkanLoaderUnitTest, getNativeBufferPropertiesOHOS_Test, TestSize.Level1)
439 {
440 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
441 if (isSupportedVulkan_) {
442 std::cout << "vkCreateDevice ptr: " << vkCreateDevice << std::endl;
443 EXPECT_NE(vkCreateDevice, nullptr);
444 std::cout << "physicalDevice_ ptr: " << physicalDevice_ << std::endl;
445 EXPECT_NE(physicalDevice_, nullptr);
446 VkDeviceCreateInfo deviceCreateInfo = {};
447 deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
448
449 std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
450 const float defaultQueuePriority(0.0f);
451 VkDeviceQueueCreateInfo queueInfo{};
452 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
453 queueInfo.queueFamilyIndex = GetQueueFamilyIndex(VK_QUEUE_GRAPHICS_BIT);
454 queueInfo.queueCount = 1;
455 queueInfo.pQueuePriorities = &defaultQueuePriority;
456 queueCreateInfos.push_back(queueInfo);
457 deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
458 deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
459
460 std::vector<const char*> deviceExtensions;
461 deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
462 deviceCreateInfo.enabledExtensionCount = (uint32_t)deviceExtensions.size();
463 deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
464 VkDevice logicalDevice;
465 VkResult err = vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &logicalDevice);
466 std::cout << "vkCreateDevice err: " << err << std::endl;
467 EXPECT_EQ(err, VK_SUCCESS);
468 std::cout << "logicalDevice ptr: " << logicalDevice << std::endl;
469 EXPECT_NE(logicalDevice, nullptr);
470 device_ = logicalDevice;
471
472 OH_NativeBuffer *aHardBuffer = {};
473 VkNativeBufferPropertiesOHOS androidHardwareBufferPropertiesOHOS = {};
474 VkNativeBufferFormatPropertiesOHOS nativeBufferFormatPropertiesOHOS = {};
475 nativeBufferFormatPropertiesOHOS.sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS;
476 nativeBufferFormatPropertiesOHOS.pNext = nullptr;
477 androidHardwareBufferPropertiesOHOS.sType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS;
478 androidHardwareBufferPropertiesOHOS.pNext = &nativeBufferFormatPropertiesOHOS;
479 fpGetNativeBufferPropertiesOHOS = reinterpret_cast<PFN_vkGetNativeBufferPropertiesOHOS>(
480 vkGetDeviceProcAddr(device_, "vkGetNativeBufferPropertiesOHOS"));
481 fpGetNativeBufferPropertiesOHOS(device_, aHardBuffer, &androidHardwareBufferPropertiesOHOS);
482 }
483 }
484
485 /**
486 * @tc.name: test vkCreateDevice
487 * @tc.desc: test vkCreateDevice
488 * @tc.type: FUNC
489 * @tc.require: issueI6SKRO
490 */
HWTEST_F(VulkanLoaderUnitTest, getMemoryNativeBufferOHOS_Test, TestSize.Level1)491 HWTEST_F(VulkanLoaderUnitTest, getMemoryNativeBufferOHOS_Test, TestSize.Level1)
492 {
493 std::cout << "isSupportedVulkan_: " << isSupportedVulkan_ << std::endl;
494 if (isSupportedVulkan_) {
495 std::cout << "vkCreateDevice ptr: " << vkCreateDevice << std::endl;
496 EXPECT_NE(vkCreateDevice, nullptr);
497 std::cout << "physicalDevice_ ptr: " << physicalDevice_ << std::endl;
498 EXPECT_NE(physicalDevice_, nullptr);
499 VkDeviceCreateInfo deviceCreateInfo = {};
500 deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
501
502 std::vector<VkDeviceQueueCreateInfo> queueCreateInfos{};
503 const float defaultQueuePriority(0.0f);
504 VkDeviceQueueCreateInfo queueInfo{};
505 queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
506 queueInfo.queueFamilyIndex = GetQueueFamilyIndex(VK_QUEUE_GRAPHICS_BIT);
507 queueInfo.queueCount = 1;
508 queueInfo.pQueuePriorities = &defaultQueuePriority;
509 queueCreateInfos.push_back(queueInfo);
510 deviceCreateInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
511 deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
512
513 std::vector<const char*> deviceExtensions;
514 deviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
515 deviceCreateInfo.enabledExtensionCount = (uint32_t)deviceExtensions.size();
516 deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
517 VkDevice logicalDevice;
518 VkResult err = vkCreateDevice(physicalDevice_, &deviceCreateInfo, nullptr, &logicalDevice);
519 std::cout << "vkCreateDevice err: " << err << std::endl;
520 EXPECT_EQ(err, VK_SUCCESS);
521 std::cout << "logicalDevice ptr: " << logicalDevice << std::endl;
522 EXPECT_NE(logicalDevice, nullptr);
523 device_ = logicalDevice;
524
525 OH_NativeBuffer *aHardBuffer = {};
526 VkDeviceMemory handwareBufferMemory = {};
527 VkMemoryGetNativeBufferInfoOHOS getAndroidHardwareBufferInfoOHOS;
528 getAndroidHardwareBufferInfoOHOS.sType = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS;
529 getAndroidHardwareBufferInfoOHOS.pNext = nullptr;
530 getAndroidHardwareBufferInfoOHOS.memory = handwareBufferMemory;
531 fpGetMemoryNativeBufferOHOS = reinterpret_cast<PFN_vkGetMemoryNativeBufferOHOS>(
532 vkGetDeviceProcAddr(device_, "vkGetMemoryNativeBufferOHOS"));
533 fpGetMemoryNativeBufferOHOS(device_, &getAndroidHardwareBufferInfoOHOS, &aHardBuffer);
534 }
535 }
536 } // vulkan::loader
537