Remove gmock from mock driver handle

Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
2026-01-09 22:43:00 +08:00 · 2020-12-10 16:18:05 +01:00
parent d46bb59508
commit 714d4c61f9
4 changed files with 47 additions and 153 deletions
--- a/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h
+++ b/level_zero/core/test/unit_tests/mocks/mock_cmdlist.h
@@ -315,6 +315,7 @@ struct MockCommandList : public CommandList {
    uint8_t *batchBuffer = nullptr;
    NEO::GraphicsAllocation *mockAllocation = nullptr;
 };
-
+#undef ADDMETHOD
+#undef ADDMETHOD_NOBASE
 } // namespace ult
 } // namespace L0
--- a/level_zero/core/test/unit_tests/mocks/mock_driver_handle.cpp
+++ b/level_zero/core/test/unit_tests/mocks/mock_driver_handle.cpp
@@ -19,30 +19,17 @@ using namespace testing;
 using ::testing::Invoke;
 using ::testing::Return;

-Mock<DriverHandle>::Mock() {
-    EXPECT_CALL(*this, getDevice)
-        .WillRepeatedly(testing::Invoke(this, &MockDriverHandle::doGetDevice));
-    EXPECT_CALL(*this, getMemoryManager)
-        .WillRepeatedly(Invoke(this, &MockDriverHandle::doGetMemoryManager));
-    EXPECT_CALL(*this, getSvmAllocsManager)
-        .WillRepeatedly(Invoke(this, &MockDriverHandle::doGetSvmAllocManager));
-    EXPECT_CALL(*this, allocHostMem)
-        .WillRepeatedly(Invoke(this, &MockDriverHandle::doAllocHostMem));
-    EXPECT_CALL(*this, allocDeviceMem)
-        .WillRepeatedly(Invoke(this, &MockDriverHandle::doAllocDeviceMem));
-    EXPECT_CALL(*this, freeMem)
-        .WillRepeatedly(Invoke(this, &MockDriverHandle::doFreeMem));
-};
+Mock<DriverHandle>::Mock() = default;

-NEO::MemoryManager *Mock<DriverHandle>::doGetMemoryManager() {
+NEO::MemoryManager *Mock<DriverHandle>::getMemoryManager() {
    return memoryManager;
 }

-NEO::SVMAllocsManager *Mock<DriverHandle>::doGetSvmAllocManager() {
+NEO::SVMAllocsManager *Mock<DriverHandle>::getSvmAllocManager() {
    return svmAllocsManager;
 }

-ze_result_t Mock<DriverHandle>::doGetDevice(uint32_t *pCount, ze_device_handle_t *phDevices) {
+ze_result_t Mock<DriverHandle>::getDevice(uint32_t *pCount, ze_device_handle_t *phDevices) {
    if (*pCount == 0) { // User wants to know number of devices
        *pCount = this->num_devices;
        return ZE_RESULT_SUCCESS;
@@ -56,8 +43,8 @@ ze_result_t Mock<DriverHandle>::doGetDevice(uint32_t *pCount, ze_device_handle_t
    return ZE_RESULT_SUCCESS;
 }

-ze_result_t Mock<DriverHandle>::doAllocHostMem(const ze_host_mem_alloc_desc_t *hostDesc, size_t size, size_t alignment,
-                                               void **ptr) {
+ze_result_t Mock<DriverHandle>::allocHostMem(const ze_host_mem_alloc_desc_t *hostDesc, size_t size, size_t alignment,
+                                             void **ptr) {
    NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::HOST_UNIFIED_MEMORY, NEO::mockDeviceBitfield);

    auto allocation = svmAllocsManager->createUnifiedMemoryAllocation(0u, size, unifiedMemoryProperties);
@@ -71,8 +58,8 @@ ze_result_t Mock<DriverHandle>::doAllocHostMem(const ze_host_mem_alloc_desc_t *h
    return ZE_RESULT_SUCCESS;
 }

-ze_result_t Mock<DriverHandle>::doAllocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
-                                                 size_t size, size_t alignment, void **ptr) {
+ze_result_t Mock<DriverHandle>::allocDeviceMem(ze_device_handle_t hDevice, const ze_device_mem_alloc_desc_t *deviceDesc,
+                                               size_t size, size_t alignment, void **ptr) {
    NEO::SVMAllocsManager::UnifiedMemoryProperties unifiedMemoryProperties(InternalMemoryType::DEVICE_UNIFIED_MEMORY, NEO::mockDeviceBitfield);

    auto allocation = svmAllocsManager->createUnifiedMemoryAllocation(0u, size, unifiedMemoryProperties);
@@ -86,7 +73,7 @@ ze_result_t Mock<DriverHandle>::doAllocDeviceMem(ze_device_handle_t hDevice, con
    return ZE_RESULT_SUCCESS;
 }

-ze_result_t Mock<DriverHandle>::doFreeMem(const void *ptr) {
+ze_result_t Mock<DriverHandle>::freeMem(const void *ptr) {
    auto allocation = svmAllocsManager->getSVMAlloc(ptr);
    if (allocation == nullptr) {
        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
--- a/level_zero/core/test/unit_tests/mocks/mock_driver_handle.h
+++ b/level_zero/core/test/unit_tests/mocks/mock_driver_handle.h
@@ -21,133 +21,42 @@ struct WhiteBox<::L0::DriverHandle> : public ::L0::DriverHandleImp {
 };

 using DriverHandle = WhiteBox<::L0::DriverHandle>;
+#define ADDMETHOD_NOBASE(funcName, retType, defaultReturn, funcParams) \
+    retType funcName##Result = defaultReturn;                          \
+    uint32_t funcName##Called = 0u;                                    \
+    retType funcName funcParams override {                             \
+        funcName##Called++;                                            \
+        return funcName##Result;                                       \
+    }

 template <>
 struct Mock<DriverHandle> : public DriverHandleImp {
    Mock();
    ~Mock() override;

-    MOCK_METHOD(ze_result_t,
-                getDevice,
-                (uint32_t * pCount,
-                 ze_device_handle_t *phDevices),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                getProperties,
-                (ze_driver_properties_t * properties),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                getApiVersion,
-                (ze_api_version_t * version),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                getIPCProperties,
-                (ze_driver_ipc_properties_t * pIPCProperties),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                getMemAllocProperties,
-                (const void *ptr,
-                 ze_memory_allocation_properties_t *pMemAllocProperties,
-                 ze_device_handle_t *phDevice),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                createContext,
-                (const ze_context_desc_t *desc,
-                 ze_context_handle_t *phContext),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                getExtensionProperties,
-                (uint32_t * pCount,
-                 ze_driver_extension_properties_t *pExtensionProperties),
-                (override));
-    MOCK_METHOD(NEO::MemoryManager *,
-                getMemoryManager,
-                (),
-                (override));
-    MOCK_METHOD(void,
-                setMemoryManager,
-                (NEO::MemoryManager *),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                getMemAddressRange,
-                (const void *ptr,
-                 void **pBase,
-                 size_t *pSize),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                getIpcMemHandle,
-                (const void *ptr,
-                 ze_ipc_mem_handle_t *pIpcHandle),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                closeIpcMemHandle,
-                (const void *ptr),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                openIpcMemHandle,
-                (ze_device_handle_t hDevice,
-                 ze_ipc_mem_handle_t handle,
-                 ze_ipc_memory_flag_t flags,
-                 void **ptr),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                createEventPool,
-                (const ze_event_pool_desc_t *desc,
-                 uint32_t numDevices,
-                 ze_device_handle_t *phDevices,
-                 ze_event_pool_handle_t *phEventPool),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                allocHostMem,
-                (const ze_host_mem_alloc_desc_t *hostDesc,
-                 size_t size,
-                 size_t alignment,
-                 void **ptr),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                allocDeviceMem,
-                (ze_device_handle_t hDevice,
-                 const ze_device_mem_alloc_desc_t *deviceDesc,
-                 size_t size,
-                 size_t alignment,
-                 void **ptr),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                allocSharedMem,
-                (ze_device_handle_t hDevice,
-                 const ze_device_mem_alloc_desc_t *deviceDesc,
-                 const ze_host_mem_alloc_desc_t *hostDesc,
-                 size_t size,
-                 size_t alignment,
-                 void **ptr),
-                (override));
-    MOCK_METHOD(ze_result_t,
-                freeMem,
-                (const void *ptr),
-                (override));
-    MOCK_METHOD(NEO::SVMAllocsManager *,
-                getSvmAllocsManager,
-                (),
-                (override));
+    ADDMETHOD_NOBASE(getProperties, ze_result_t, ZE_RESULT_SUCCESS, (ze_driver_properties_t * properties))
+    ADDMETHOD_NOBASE(getApiVersion, ze_result_t, ZE_RESULT_SUCCESS, (ze_api_version_t * version))
+    ADDMETHOD_NOBASE(getIPCProperties, ze_result_t, ZE_RESULT_SUCCESS, (ze_driver_ipc_properties_t * pIPCProperties))
+
    uint32_t num_devices = 1;
    Mock<Device> device;

    void setupDevices(std::vector<std::unique_ptr<NEO::Device>> devices);

-    ze_result_t doFreeMem(const void *ptr);
-    ze_result_t doGetDevice(uint32_t *pCount,
-                            ze_device_handle_t *phDevices);
-    NEO::MemoryManager *doGetMemoryManager();
-    NEO::SVMAllocsManager *doGetSvmAllocManager();
-    ze_result_t doAllocHostMem(const ze_host_mem_alloc_desc_t *hostDesc,
+    ze_result_t freeMem(const void *ptr) override;
+    ze_result_t getDevice(uint32_t *pCount,
+                          ze_device_handle_t *phDevices) override;
+    NEO::MemoryManager *getMemoryManager() override;
+    NEO::SVMAllocsManager *getSvmAllocManager();
+    ze_result_t allocHostMem(const ze_host_mem_alloc_desc_t *hostDesc,
+                             size_t size,
+                             size_t alignment,
+                             void **ptr) override;
+    ze_result_t allocDeviceMem(ze_device_handle_t hDevice,
+                               const ze_device_mem_alloc_desc_t *deviceDesc,
                               size_t size,
                               size_t alignment,
-                               void **ptr);
-    ze_result_t doAllocDeviceMem(ze_device_handle_t hDevice,
-                                 const ze_device_mem_alloc_desc_t *deviceDesc,
-                                 size_t size,
-                                 size_t alignment,
-                                 void **ptr);
+                               void **ptr) override;

    ze_result_t importExternalPointer(void *ptr, size_t size) override {
        return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
@@ -172,6 +81,6 @@ struct Mock<DriverHandle> : public DriverHandleImp {
        return nullptr;
    }
 };
-
+#undef ADDMETHOD_NOBASE
 } // namespace ult
 } // namespace L0
--- a/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
+++ b/level_zero/core/test/unit_tests/sources/driver/test_driver.cpp
@@ -620,39 +620,36 @@ TEST(zeDriverHandleGetProperties, whenZeDriverGetPropertiesIsCalledThenGetProper
    ze_result_t result;
    Mock<DriverHandle> driverHandle;
    ze_driver_properties_t properties;
+    ze_result_t expectedResult = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;

-    EXPECT_CALL(driverHandle, getProperties(&properties))
-        .Times(1)
-        .WillRepeatedly(Return(ZE_RESULT_SUCCESS));
-
+    driverHandle.getPropertiesResult = expectedResult;
    result = zeDriverGetProperties(driverHandle.toHandle(), &properties);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(expectedResult, result);
+    EXPECT_EQ(1u, driverHandle.getPropertiesCalled);
 }

 TEST(zeDriverHandleGetApiVersion, whenZeDriverGetApiIsCalledThenGetApiVersionIsCalled) {
    ze_result_t result;
    Mock<DriverHandle> driverHandle;
    ze_api_version_t version;
+    ze_result_t expectedResult = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;

-    EXPECT_CALL(driverHandle, getApiVersion(&version))
-        .Times(1)
-        .WillRepeatedly(Return(ZE_RESULT_SUCCESS));
-
+    driverHandle.getApiVersionResult = expectedResult;
    result = zeDriverGetApiVersion(driverHandle.toHandle(), &version);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(expectedResult, result);
+    EXPECT_EQ(1u, driverHandle.getApiVersionCalled);
 }

 TEST(zeDriverGetIpcProperties, whenZeDriverGetIpcPropertiesIsCalledThenGetIPCPropertiesIsCalled) {
    ze_result_t result;
    Mock<DriverHandle> driverHandle;
    ze_driver_ipc_properties_t ipcProperties;
+    ze_result_t expectedResult = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;

-    EXPECT_CALL(driverHandle, getIPCProperties(&ipcProperties))
-        .Times(1)
-        .WillRepeatedly(Return(ZE_RESULT_SUCCESS));
-
+    driverHandle.getIPCPropertiesResult = expectedResult;
    result = zeDriverGetIpcProperties(driverHandle.toHandle(), &ipcProperties);
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(expectedResult, result);
+    EXPECT_EQ(1u, driverHandle.getIPCPropertiesCalled);
 }
 } // namespace ult
 } // namespace L0