intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 09:14:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup mock_driver_handle.h

Browse Source 
Change-Id: I003a5afa6af605cf9c78538d6b648439fce72b3a
Signed-off: Jaime Arteaga <jaime.a.arteaga.molina@intel.com>
This commit is contained in:
Jaime Arteaga
2020-07-20 21:58:07 -07:00
committed by sys_ocldev
parent 68fe04e26a
commit af8fdfce62
1 changed files with 94 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
level_zero/core/test/unit_tests/mocks/mock_driver_handle.h
View File

@@ -12,11 +12,6 @@
#include "level_zero/core/test/unit_tests/mocks/mock_memory_manager.h"
#include "level_zero/core/test/unit_tests/white_box.h"
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winconsistent-missing-override"
#endif
namespace L0 {
namespace ult {
@@ -32,52 +27,114 @@ struct Mock<DriverHandle> : public DriverHandleImp {
Mock();
~Mock() override;
MOCK_METHOD2(getDevice, ze_result_t(uint32_t *pCount, ze_device_handle_t *phDevices));
MOCK_METHOD1(getProperties, ze_result_t(ze_driver_properties_t *properties));
MOCK_METHOD1(getApiVersion, ze_result_t(ze_api_version_t *version));
MOCK_METHOD1(getIPCProperties, ze_result_t(ze_driver_ipc_properties_t *pIPCProperties));
MOCK_METHOD3(getMemAllocProperties, ze_result_t(const void *ptr,
ze_memory_allocation_properties_t *pMemAllocProperties,
ze_device_handle_t *phDevice));
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,
getExtensionProperties,
(uint32_t * pCount,
ze_driver_extension_properties_t *pExtensionProperties),
(override));
MOCK_METHOD0(getMemoryManager, NEO::MemoryManager *());
MOCK_METHOD1(setMemoryManager, void(NEO::MemoryManager *));
MOCK_METHOD3(getMemAddressRange, ze_result_t(const void *ptr, void **pBase, size_t *pSize));
MOCK_METHOD2(getIpcMemHandle, ze_result_t(const void *ptr, ze_ipc_mem_handle_t *pIpcHandle));
MOCK_METHOD1(closeIpcMemHandle, ze_result_t(const void *ptr));
MOCK_METHOD4(openIpcMemHandle, ze_result_t(ze_device_handle_t hDevice, ze_ipc_mem_handle_t handle,
ze_ipc_memory_flag_t flags, void **ptr));
MOCK_METHOD4(createEventPool, ze_result_t(const ze_event_pool_desc_t *desc,
uint32_t numDevices,
ze_device_handle_t *phDevices,
ze_event_pool_handle_t *phEventPool));
MOCK_METHOD4(allocHostMem, ze_result_t(ze_host_mem_alloc_flag_t flags, size_t size, size_t alignment, void **ptr));
MOCK_METHOD5(allocDeviceMem, ze_result_t(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t flags, size_t size, size_t alignment, void **ptr));
MOCK_METHOD1(freeMem, ze_result_t(const void *ptr));
MOCK_METHOD0(getSvmAllocsManager, NEO::SVMAllocsManager *());
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,
(ze_host_mem_alloc_flag_t flags,
size_t size,
size_t alignment,
void **ptr),
(override));
MOCK_METHOD(ze_result_t,
allocDeviceMem,
(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
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));
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);
ze_result_t doGetDevice(uint32_t *pCount,
ze_device_handle_t *phDevices);
NEO::MemoryManager *doGetMemoryManager();
NEO::SVMAllocsManager *doGetSvmAllocManager();
ze_result_t doAllocHostMem(ze_host_mem_alloc_flag_t flags, size_t size, size_t alignment, void **ptr);
ze_result_t doAllocDeviceMem(ze_device_handle_t hDevice, ze_device_mem_alloc_flag_t flags, size_t size, size_t alignment, void **ptr);
ze_result_t doAllocHostMem(ze_host_mem_alloc_flag_t flags,
size_t size,
size_t alignment,
void **ptr);
ze_result_t doAllocDeviceMem(ze_device_handle_t hDevice,
ze_device_mem_alloc_flag_t flags,
size_t size,
size_t alignment,
void **ptr);
};
} // namespace ult
} // namespace L0
#if defined(__clang__)
#pragma clang diagnostic pop
#endif