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
33using namespace testing;
34using namespace testing::ext;
35using namespace OHOS::Rosen;
36
37namespace vulkan::loader {
38class VulkanLoaderUnitTest : public testing::Test {
39public:
40    static void SetUpTestCase() {}
41    static void TearDownTestCase();
42    void SetUp() {}
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
104bool 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
120void 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
153VkSwapchainCreateInfoKHR 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
183OHNativeWindow* 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
193uint32_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
222VkBool32 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
243void 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 */
265HWTEST_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 */
300HWTEST_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 */
363HWTEST_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 */
395HWTEST_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 */
438HWTEST_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 */
491HWTEST_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