* Copyright (c) 2025 Huawei Technologies Co., Ltd.
* This program is free software, you can redistribute it and/or modify it under the terms and conditions of
* CANN Open Software License Agreement Version 2.0 (the "License").
* Please refer to the License for details. You may not use this file except in compliance with the License.
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
* INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
* See LICENSE in the root of the software repository for the full text of the License.
*/
#include <string>
#include <cassert>
#include <iostream>
#include <cstdint>
#include "mmpa/mmpa_api.h"
#include "acl/acl.h"
#include "acl/error_codes/rt_error_codes.h"
#include "common/log_inner.h"
#include "acl/acl_rt.h"
#include "acl/acl_rt_api.h"
#include "acl_rt_impl_base.h"
#define private public
#include "common/resource_statistics.h"
#undef private
#include "set_device_vxx.h"
#include "runtime/dev.h"
#include "runtime/stream.h"
#include "runtime/context.h"
#include "runtime/event.h"
#include "runtime/mem.h"
#include "runtime/rts/rts_mem.h"
#include "runtime/kernel.h"
#include "runtime/base.h"
#include "runtime/config.h"
#include "acl/acl_rt_allocator.h"
#include "acl/acl_rt_memory_soma.h"
#include "acl_stub.h"
#define private public
#include "aclrt_impl/init_callback_manager.h"
#undef private
#include <gtest/gtest.h>
#include <gmock/gmock.h>
using namespace testing;
using namespace std;
using namespace acl;
namespace {
uint64_t GetResourceCounterValue(ResourceType resourceType, ApplyReleaseType applyReleaseType)
{
return ResourceStatistics::GetInstance().counter_[resourceType].appplyReleaseValue[applyReleaseType].load();
}
}
namespace acl {
extern void resetAclJsonHash();
}
class UTEST_ACL_Runtime : public testing::Test
{
protected:
void SetUp() override
{
MockFunctionTest::aclStubInstance().ResetToDefaultMock();
ON_CALL(MockFunctionTest::aclStubInstance(), GetPlatformResWithLock(_, _))
.WillByDefault(Return(true));
resetAclJsonHash();
}
void TearDown() override
{
Mock::VerifyAndClear((void *)(&MockFunctionTest::aclStubInstance()));
}
};
extern aclError MemcpyKindTranslate(aclrtMemcpyKind kind, rtMemcpyKind_t &rtKind);
rtError_t rtEventQueryWaitStatus_Invoke(rtEvent_t event, rtEventWaitStatus *status)
{
(void) event;
*status = EVENT_STATUS_COMPLETE;
return RT_ERROR_NONE;
}
rtError_t rtEventQueryWaitStatus_Invoke2(rtEvent_t event, rtEventWaitStatus *status)
{
(void) event;
*status = EVENT_STATUS_NOT_READY;
return RT_ERROR_NONE;
}
rtError_t rtEventQueryStatus_Invoke(rtEvent_t event, rtEventStatus *status)
{
(void) event;
*status = RT_EVENT_INIT;
return RT_ERROR_NONE;
}
rtError_t rtEventQueryStatus_Invoke2(rtEvent_t event, rtEventStatus *status)
{
(void) event;
*status = RT_EVENT_RECORDED;
return RT_ERROR_NONE;
}
rtError_t rtMalloc1g(void **devPtr, uint64_t size, rtMemType_t type, uint16_t moduleId) {
(void) devPtr;
(void) moduleId;
std::cout << "call rtMalloc1g" << std::endl;
if (size != 1024UL * 1024UL * 1024UL) {
return -1;
}
if (type == 0x10000U || type == 0x20000U) {
return 0;
}
return -1;
}
rtError_t rtMallocPhysical1g(rtDrvMemHandle *handle, size_t size, rtDrvMemProp_t *prop, uint64_t flags) {
(void) handle;
(void) flags;
std::cout << "call rtMallocPhysical1g" << std::endl;
if (size != 1024UL * 1024UL * 1024UL) {
return -1;
}
if (prop->pg_type == 2) {
return 0;
}
return -1;
}
aclError InitCallback_Success(const char *configStr, size_t len, void *userData) {
(void)configStr;
(void)len;
(void)userData;
return ACL_SUCCESS;
}
aclError InitCallback_Fail(const char *configStr, size_t len, void *userData) {
(void)configStr;
(void)len;
(void)userData;
return ACL_ERROR_FAILURE;
}
aclError FinalizeCallback_Success(void *userData) {
(void)userData;
return ACL_SUCCESS;
}
aclError FinalizeCallback_Fail(void *userData) {
(void)userData;
return ACL_ERROR_FAILURE;
}
namespace {
std::vector<int> g_callbackOrder;
class CallbackMapGuard {
public:
explicit CallbackMapGuard(InitCallbackManager &cbMgr)
: cbMgr_(cbMgr), initCallbackMap_(cbMgr.initCallbackMap_), finalizeCallbackMap_(cbMgr.finalizeCallbackMap_)
{
cbMgr_.initCallbackMap_.clear();
cbMgr_.finalizeCallbackMap_.clear();
g_callbackOrder.clear();
}
~CallbackMapGuard()
{
cbMgr_.initCallbackMap_ = initCallbackMap_;
cbMgr_.finalizeCallbackMap_ = finalizeCallbackMap_;
g_callbackOrder.clear();
}
private:
InitCallbackManager &cbMgr_;
std::multimap<aclRegisterCallbackType, std::pair<aclInitCallbackFunc, void *>> initCallbackMap_;
std::multimap<aclRegisterCallbackType, std::pair<aclFinalizeCallbackFunc, void *>> finalizeCallbackMap_;
};
}
aclError InitCallback_RecordOrder(const char *configStr, size_t len, void *userData) {
(void)configStr;
(void)len;
g_callbackOrder.push_back(static_cast<int>(reinterpret_cast<intptr_t>(userData)));
return ACL_SUCCESS;
}
aclError FinalizeCallback_RecordOrder(void *userData) {
g_callbackOrder.push_back(static_cast<int>(reinterpret_cast<intptr_t>(userData)));
return ACL_SUCCESS;
}
TEST_F(UTEST_ACL_Runtime, aclrtSetDeviceFailedTest)
{
int32_t deviceId = 1;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSetDevice(_))
.WillOnce(Return(ACL_ERROR_RT_INVALID_DEVICEID));
aclError ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_DEVICEID);
}
TEST_F(UTEST_ACL_Runtime, UpdatePlatformInfoTest)
{
int32_t deviceId = 99;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), InitRuntimePlatformInfos(_))
.WillOnce(Return(1))
.WillRepeatedly(Return(0));
auto ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetAiCoreCount(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillRepeatedly(Return(RT_ERROR_NONE));
ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDeviceInfo(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillOnce(Return(RT_ERROR_NONE))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillRepeatedly(Return(RT_ERROR_NONE));
ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), GetRuntimePlatformInfosByDevice(_, _))
.WillOnce(Return(1))
.WillRepeatedly(Return(0));
ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), GetPlatformResWithLock(_, _))
.WillOnce(Return(false))
.WillRepeatedly(Return(true));
ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), UpdateRuntimePlatformInfosByDevice(_, _))
.WillOnce(Return(1));
ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), InitRuntimePlatformInfos(_))
.WillOnce(Return(1));
aclrtContext ctx;
ret = aclrtCreateContext(&ctx, 98);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetDeviceSuccessTest)
{
string testStr = "test";
acl::AclErrorLogManager::ReportInnerError("%s", testStr.c_str());
acl::AclErrorLogManager::ReportCallError("%s", testStr.c_str());
int32_t deviceId = 0;
aclError ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetDeviceTest)
{
int32_t deviceId = 0;
aclError ret = aclrtResetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceReset(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtResetDevice(deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetDeviceForceTest)
{
int32_t deviceId = 0;
aclError ret = aclrtResetDeviceForce(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceResetForce(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillOnce(Return(ACL_SUCCESS));
ret = aclrtResetDeviceForce(deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSetDevice(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtResetDeviceForce(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceReset(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtResetDevice(deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetDeviceWithoutTsdVXXTest)
{
int32_t deviceId = 0;
aclError ret = aclrtSetDeviceWithoutTsdVXX(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSetDeviceWithoutTsd(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtSetDeviceWithoutTsdVXX(deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetDeviceWithoutTsdVXXTest)
{
int32_t deviceId = 0;
aclError ret = aclrtResetDeviceWithoutTsdVXX(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceResetWithoutTsd(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtResetDeviceWithoutTsdVXX(deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceTest)
{
int32_t deviceId = 0;
aclError ret = aclrtGetDevice(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtGetDevice(&deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDevice(_))
.WillRepeatedly(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetDevice(&deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetLogicDevIdByUserDevIdTest)
{
int32_t userDevid = 0;
int32_t logicDevId;
aclError ret = aclrtGetLogicDevIdByUserDevId(userDevid, &logicDevId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetLogicDevIdByUserDevId(_,_))
.WillRepeatedly(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetLogicDevIdByUserDevId(userDevid, &logicDevId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetUserDevIdByLogicDevIdTest)
{
int32_t logicDevId = 0;
int32_t userDevid;
aclError ret = aclrtGetUserDevIdByLogicDevId(logicDevId, &userDevid);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetUserDevIdByLogicDevId(_,_))
.WillRepeatedly(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetUserDevIdByLogicDevId(logicDevId, &userDevid);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetLogicDevIdByPhyDevIdTest)
{
int32_t phyDevId = 0;
int32_t logicDevId;
aclError ret = aclrtGetLogicDevIdByPhyDevId(phyDevId, &logicDevId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetLogicDevIdByPhyDevId(_,_))
.WillRepeatedly(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetLogicDevIdByPhyDevId(phyDevId, &logicDevId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetPhyDevIdByLogicDevIdTest)
{
int32_t logicDevId = 0;
int32_t phyDevId;
aclError ret = aclrtGetPhyDevIdByLogicDevId(logicDevId, &phyDevId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetPhyDevIdByLogicDevId(_,_))
.WillRepeatedly(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetPhyDevIdByLogicDevId(logicDevId, &phyDevId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeDeviceTest)
{
aclError ret = aclrtSynchronizeDevice();
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceSynchronize())
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSynchronizeDevice();
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeDevice_succ)
{
int32_t timeout = 1;
aclError ret = aclrtSynchronizeDeviceWithTimeout(timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeDevice_with_invalid_timeout)
{
int32_t timeout = -2;
aclError ret = aclrtSynchronizeDeviceWithTimeout(timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeDevice_with_timeout)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceSynchronizeWithTimeout(_))
.WillOnce(Return((ACL_ERROR_RT_STREAM_SYNC_TIMEOUT)));
int32_t timeout = 1;
aclError ret = aclrtSynchronizeDeviceWithTimeout(timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_STREAM_SYNC_TIMEOUT);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeDevice_with_rts_fail)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceSynchronizeWithTimeout(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
int32_t timeout = 1;
aclError ret = aclrtSynchronizeDeviceWithTimeout(timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetRunModeTest)
{
aclrtRunMode runMode;
aclError ret = aclrtGetRunMode(&runMode);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetRunMode(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetRunMode(&runMode);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetTsDeviceTest)
{
aclrtTsId tsId = ACL_TS_ID_RESERVED;
aclError ret = aclrtSetTsDevice(tsId);
EXPECT_NE(ret, ACL_SUCCESS);
tsId = ACL_TS_ID_AICORE;
ret = aclrtSetTsDevice(tsId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSetTSDevice(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSetTsDevice(tsId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceCountTest)
{
uint32_t count = 0;
aclError ret = aclrtGetDeviceCount(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtGetDeviceCount(&count);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDeviceCount(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetDeviceCount(&count);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateContextTest)
{
aclrtContext context = (aclrtContext)0x01;
int32_t deviceId = 0;
aclError ret = aclrtCreateContext(&context, deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtCreateContext(nullptr, deviceId);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCtxCreateEx(_, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtCreateContext(&context, deviceId);
EXPECT_NE(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyContextTest)
{
aclrtContext context = (aclrtContext)0x01;
aclError ret = aclrtDestroyContext(context);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtDestroyContext(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCtxDestroyEx(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtDestroyContext(context);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetCurrentContextTest)
{
aclrtContext context = (aclrtContext)0x01;
aclError ret = aclrtSetCurrentContext(context);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSetCurrentContext(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCtxSetCurrent(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSetCurrentContext(context);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetCurrentContextTest)
{
aclrtContext context = (aclrtContext)0x01;
aclError ret = aclrtGetCurrentContext(&context);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtGetCurrentContext(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCtxGetCurrent(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetCurrentContext(&context);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateStreamTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtCreateStream(&stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtCreateStream(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamCreate(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtCreateStream(&stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateStreamWithConfigTest)
{
aclrtStream stream = (aclrtStream)0x01;
uint32_t priority = 0u;
uint32_t flag = ACL_STREAM_FAST_LAUNCH;
aclError ret = aclrtCreateStreamWithConfig(&stream, priority, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
flag |= ACL_STREAM_FAST_SYNC;
ret = aclrtCreateStreamWithConfig(&stream, priority, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
flag = ACL_STREAM_PERSISTENT;
ret = aclrtCreateStreamWithConfig(&stream, priority, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
flag = ACL_STREAM_HUGE;
ret = aclrtCreateStreamWithConfig(&stream, priority, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
flag = ACL_STREAM_CPU_SCHEDULE;
ret = aclrtCreateStreamWithConfig(&stream, priority, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
flag = ACL_STREAM_DEVICE_USE_ONLY;
ret = aclrtCreateStreamWithConfig(&stream, priority, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtCreateStreamWithConfig(nullptr, priority, flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtCreateStreamWithConfig(&stream, 1, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtCreateStreamWithConfig(&stream, 8, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyStreamTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtDestroyStream(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtDestroyStream(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamDestroy(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtDestroyStream(stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyStreamForceTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtDestroyStreamForce(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtDestroyStreamForce(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamDestroyForce(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtDestroyStreamForce(stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeStreamTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtSynchronizeStream(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSynchronizeStream(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSynchronize(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSynchronizeStream(stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSynchronize(_))
.WillOnce(Return((ACL_ERROR_RT_END_OF_SEQUENCE)));
ret = aclrtSynchronizeStream(stream);
EXPECT_EQ(ret, ACL_ERROR_RT_END_OF_SEQUENCE);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeStreamWithTimeoutTest)
{
aclrtStream stream = (aclrtStream)0x01;
int32_t timeout = 100;
aclError ret = aclrtSynchronizeStreamWithTimeout(stream, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSynchronizeStreamWithTimeout(nullptr, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSynchronizeWithTimeout(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSynchronizeStreamWithTimeout(nullptr, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSynchronizeWithTimeout(_, _))
.WillOnce(Return((ACL_ERROR_RT_STREAM_SYNC_TIMEOUT)));
ret = aclrtSynchronizeStreamWithTimeout(stream, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_STREAM_SYNC_TIMEOUT);
timeout = -2;
ret = aclrtSynchronizeStreamWithTimeout(stream, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
timeout = 2;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSynchronizeWithTimeout(_, _))
.WillOnce(Return((ACL_ERROR_RT_END_OF_SEQUENCE)));
ret = aclrtSynchronizeStreamWithTimeout(stream, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_END_OF_SEQUENCE);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamQueryTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclrtStreamStatus status;
aclError ret = aclrtStreamQuery(stream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamQuery(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtStreamQuery(stream, &status);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamQuery(_))
.WillOnce(Return((RT_ERROR_NONE)));
ret = aclrtStreamQuery(stream, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(status, ACL_STREAM_STATUS_COMPLETE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamQuery(_))
.WillOnce(Return((ACL_ERROR_RT_STREAM_NOT_COMPLETE)));
ret = aclrtStreamQuery(stream, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(status, ACL_STREAM_STATUS_NOT_READY);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamGetPriorityTest)
{
aclrtStream stream = (aclrtStream)0x01;
uint32_t priority;
aclError ret = aclrtStreamGetPriority(nullptr, &priority);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtStreamGetPriority(stream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamGetPriority(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtStreamGetPriority(stream, &priority);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamGetPriority(_, _))
.WillOnce(DoAll(SetArgPointee<1>(5), Return(RT_ERROR_NONE)));
ret = aclrtStreamGetPriority(stream, &priority);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(priority, 5);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamGetFlagsTest)
{
aclrtStream stream = (aclrtStream)0x01;
uint32_t flags;
aclError ret = aclrtStreamGetFlags(nullptr, &flags);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtStreamGetFlags(stream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamGetFlags(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtStreamGetFlags(stream, &flags);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamGetFlags(_, _))
.WillOnce(DoAll(SetArgPointee<1>(RT_STREAM_FAST_LAUNCH), Return(RT_ERROR_NONE)));
ret = aclrtStreamGetFlags(stream, &flags);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(flags, ACL_STREAM_FAST_LAUNCH);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamWaitEventTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclrtEvent event = (aclrtEvent)0x01;
aclError ret = aclrtStreamWaitEvent(stream, event);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtStreamWaitEvent(nullptr, event);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamWaitEvent(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtStreamWaitEvent(stream, event);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamWaitEventWithTimeoutTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclrtEvent event = (aclrtEvent)0x01;
int32_t timeout = -1;
aclError ret = aclrtStreamWaitEventWithTimeout(stream, event, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
timeout = 1;
ret = aclrtStreamWaitEventWithTimeout(stream, event, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtStreamWaitEventWithTimeout(nullptr, event, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsEventWait(_, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtStreamWaitEventWithTimeout(stream, event, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamWaitEventWithFlagTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclrtEvent event = (aclrtEvent)0x01;
aclError ret = aclrtStreamWaitEventWithFlag(stream, nullptr, 1, ACL_EVENT_WAIT_DEFAULT);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsEventWait(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtStreamWaitEventWithFlag(stream, event, 1, ACL_EVENT_WAIT_DEFAULT);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtStreamWaitEventWithFlag(stream, event, -1, ACL_EVENT_WAIT_DEFAULT);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamWaitEventWithFlag(_, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtStreamWaitEventWithFlag(stream, event, -1, ACL_EVENT_WAIT_EXTERNAL);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtStreamWaitEventWithFlag(stream, event, -1, ACL_EVENT_WAIT_EXTERNAL + 1U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtStreamWaitEventWithFlag(stream, event, 1, ACL_EVENT_WAIT_EXTERNAL);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamWaitEventWithFlag(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtStreamWaitEventWithFlag(stream, event, -1, ACL_EVENT_WAIT_EXTERNAL);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcGetEventHandleTest)
{
aclrtIpcEventHandle handle;
aclrtEvent event = (aclrtEvent)0x01;
aclError ret = aclrtIpcGetEventHandle(event, &handle);
EXPECT_EQ(ret, ACL_RT_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtIpcGetEventHandle(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtIpcGetEventHandle(event, &handle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtIpcGetEventHandle(_, _))
.WillOnce(Return((ACL_ERROR_RT_FEATURE_NOT_SUPPORT)));
ret = aclrtIpcGetEventHandle(event, &handle);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcOpenEventHandleTest)
{
aclrtIpcEventHandle handle;
(void)memset_s(handle.reserved, ACL_IPC_EVENT_HANDLE_SIZE, 0, ACL_IPC_EVENT_HANDLE_SIZE);
aclrtEvent event;
aclError ret = aclrtIpcOpenEventHandle(handle, &event);
EXPECT_EQ(ret, ACL_RT_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtIpcOpenEventHandle(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtIpcOpenEventHandle(handle, &event);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtIpcOpenEventHandle(_, _))
.WillOnce(Return((ACL_ERROR_RT_FEATURE_NOT_SUPPORT)));
ret = aclrtIpcOpenEventHandle(handle, &event);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamFailureMode_DSTest)
{
aclError ret = aclrtSetStreamFailureMode(nullptr, ACL_STOP_ON_FAILURE);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSetMode(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSetStreamFailureMode(nullptr, ACL_STOP_ON_FAILURE);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamFailureMode_DCTest)
{
aclError ret = aclrtSetStreamFailureMode(nullptr, ACL_CONTINUE_ON_FAILURE);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSetMode(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSetStreamFailureMode(nullptr, ACL_CONTINUE_ON_FAILURE);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamFailureMode_STest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtCreateStream(&stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSetStreamFailureMode(stream, ACL_STOP_ON_FAILURE);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSetMode(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSetStreamFailureMode(stream, ACL_STOP_ON_FAILURE);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamFailureMode_CTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtCreateStream(&stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSetStreamFailureMode(stream, ACL_CONTINUE_ON_FAILURE);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSetMode(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSetStreamFailureMode(stream, ACL_CONTINUE_ON_FAILURE);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamAbortTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtStreamAbort(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtStreamAbort(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamAbort(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtStreamAbort(stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateEventTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclError ret = aclrtCreateEvent(&event);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtCreateEvent(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventCreate(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtCreateEvent(&event);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyEventTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclError ret = aclrtDestroyEvent(event);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtDestroyEvent(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventDestroy(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtDestroyEvent(event);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtRecordEventTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtRecordEvent(event, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtRecordEvent(nullptr, stream);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventRecord(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtRecordEvent(event, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtRecordEventWithFlagTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtRecordEventWithFlag(nullptr, stream, ACL_EVENT_RECORD_DEFAULT);
EXPECT_NE(ret, ACL_SUCCESS);
const uint64_t recordTotalBefore = GetResourceCounterValue(ACL_STATISTICS_RECORD_RESET_EVENT, APPLY_TOTAL);
const uint64_t recordSuccessBefore = GetResourceCounterValue(ACL_STATISTICS_RECORD_RESET_EVENT, APPLY_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventRecord(_, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtRecordEventWithFlag(event, stream, ACL_EVENT_RECORD_DEFAULT);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(GetResourceCounterValue(ACL_STATISTICS_RECORD_RESET_EVENT, APPLY_TOTAL), recordTotalBefore + 1U);
EXPECT_EQ(GetResourceCounterValue(ACL_STATISTICS_RECORD_RESET_EVENT, APPLY_SUCCESS), recordSuccessBefore + 1U);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventRecordWithFlag(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtRecordEventWithFlag(event, stream, ACL_EVENT_RECORD_EXTERNAL);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(GetResourceCounterValue(ACL_STATISTICS_RECORD_RESET_EVENT, APPLY_TOTAL), recordTotalBefore + 1U);
EXPECT_EQ(GetResourceCounterValue(ACL_STATISTICS_RECORD_RESET_EVENT, APPLY_SUCCESS), recordSuccessBefore + 1U);
ret = aclrtRecordEventWithFlag(event, stream, ACL_EVENT_RECORD_EXTERNAL + 1U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventRecordWithFlag(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtRecordEventWithFlag(event, stream, ACL_EVENT_RECORD_EXTERNAL);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetEventTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtResetEvent(event, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtResetEvent(nullptr, stream);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventReset(_, _))
.WillRepeatedly(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtResetEvent(event, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtQueryEventWaitStatusTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclrtEventWaitStatus status;
aclError ret = aclrtQueryEventWaitStatus(nullptr, &status);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtQueryEventWaitStatus(event, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQueryWaitStatus(_,_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtQueryEventWaitStatus(event, &status);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQueryWaitStatus(_,_))
.WillOnce(Invoke(rtEventQueryWaitStatus_Invoke));
ret = aclrtQueryEventWaitStatus(event, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(status, ACL_EVENT_WAIT_STATUS_COMPLETE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQueryWaitStatus(_,_))
.WillOnce(Invoke(rtEventQueryWaitStatus_Invoke2));
ret = aclrtQueryEventWaitStatus(event, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(status, ACL_EVENT_WAIT_STATUS_NOT_READY);
}
TEST_F(UTEST_ACL_Runtime, aclrtQueryEventStatusTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclrtEventRecordedStatus status;
aclError ret = aclrtQueryEventStatus(nullptr, &status);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtQueryEventStatus(event, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQueryStatus(_,_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtQueryEventStatus(event, &status);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQueryStatus(_,_))
.WillOnce(Invoke(rtEventQueryStatus_Invoke));
ret = aclrtQueryEventStatus(event, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(status, ACL_EVENT_RECORDED_STATUS_NOT_READY);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQueryStatus(_,_))
.WillOnce(Invoke(rtEventQueryStatus_Invoke2));
ret = aclrtQueryEventStatus(event, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(status, ACL_EVENT_RECORDED_STATUS_COMPLETE);
}
TEST_F(UTEST_ACL_Runtime, aclrtQueryEventTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclrtEventStatus status;
aclError ret = aclrtResetEvent(nullptr, &status);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventReset(_, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtResetEvent(event, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
ret = aclrtQueryEvent(event, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(status, ACL_EVENT_STATUS_COMPLETE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQuery(_))
.WillOnce(Return((ACL_ERROR_RT_EVENT_NOT_COMPLETE)));
ret = aclrtQueryEvent(event, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(status, ACL_EVENT_STATUS_NOT_READY);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventQuery(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtQueryEvent(event, &status);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeEventTest)
{
aclrtEvent event = (aclrtEvent)0x01;
aclError ret = aclrtSynchronizeEvent(event);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSynchronizeEvent(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventSynchronize(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSynchronizeEvent(event);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSynchronizeEventWithTimeoutTest)
{
aclrtEvent event = (aclrtEvent)0x01;
int32_t timeout = 100;
aclError ret = aclrtSynchronizeEventWithTimeout(event, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSynchronizeEventWithTimeout(nullptr, timeout);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventSynchronizeWithTimeout(_,_))
.WillOnce(Return((ACL_ERROR_RT_EVENT_SYNC_TIMEOUT)));
ret = aclrtSynchronizeEventWithTimeout(event, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_EVENT_SYNC_TIMEOUT);
timeout = -2;
ret = aclrtSynchronizeEventWithTimeout(event, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateEventWithFlagTest)
{
uint32_t flag = 0x00000008u;
aclError ret;
aclrtEvent event = (aclrtEvent)0x01;
ret = aclrtCreateEventWithFlag(nullptr, flag);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtCreateEventWithFlag(&event, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventCreateWithFlag(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtCreateEventWithFlag(&event, flag);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateEventExWithFlagTest)
{
uint32_t flag = 0x00000008u;
aclError ret;
aclrtEvent event = (aclrtEvent)0x01;
ret = aclrtCreateEventExWithFlag(nullptr, flag);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtCreateEventExWithFlag(&event, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventCreateExWithFlag(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtCreateEventExWithFlag(&event, flag);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventCreateExWithFlag(_, _))
.WillOnce(Return((ACL_ERROR_RT_FEATURE_NOT_SUPPORT)));
ret = aclrtCreateEventExWithFlag(&event, flag);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtEventElapsedTimeTest)
{
float time = 0.0f;
aclError ret;
aclrtEvent start = (aclrtEvent)0x01;
aclrtEvent end = (aclrtEvent)0x01;
ret = aclrtEventElapsedTime(nullptr, start, end);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtEventElapsedTime(&time, nullptr, end);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtEventElapsedTime(&time, start, nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtEventElapsedTime(&time, start, end);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventElapsedTime(_, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtEventElapsedTime(&time, start, end);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtEventGetTimestamp)
{
uint64_t ts = 0;
aclrtEvent event = aclrtEvent(&ts);
EXPECT_EQ(aclrtEventGetTimestamp(event, nullptr), ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtEventGetTimestamp(nullptr, &ts), ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtEventGetTimestamp(event, &ts), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetOpWaitTimeout)
{
uint32_t timeout = 3;
aclError ret = aclrtSetOpWaitTimeout(timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSetOpWaitTimeOut(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtSetOpWaitTimeout(timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
void CallBackFuncStub(void *arg)
{
(void) arg;
int a = 1;
a++;
}
TEST_F(UTEST_ACL_Runtime, aclrtSubscribeReportTest)
{
aclError ret;
aclrtStream stream = (aclrtStream)0x01;
ret = aclrtSubscribeReport(1, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtUnSubscribeReportTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtUnSubscribeReport(1, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtUnSubscribeReport(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
EXPECT_EQ(aclrtUnSubscribeReport(1, stream), ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtLaunchCallbackTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtLaunchCallback(CallBackFuncStub, nullptr, ACL_CALLBACK_BLOCK, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtLaunchCallback(CallBackFuncStub, nullptr, static_cast<aclrtCallbackBlockType>(2), stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCallbackLaunch(_, _, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtLaunchCallback(CallBackFuncStub, nullptr, ACL_CALLBACK_BLOCK, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtLaunchHostFuncTest)
{
aclrtStream stream = (aclrtStream)0x01;
aclError ret = aclrtLaunchHostFunc(stream, CallBackFuncStub, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchHostFunc(_, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtLaunchHostFunc(stream, CallBackFuncStub, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtProcessReportTest)
{
aclError ret = aclrtProcessReport(0);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtProcessReport(1);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtProcessReport(_))
.WillOnce(Return((ACL_ERROR_RT_THREAD_SUBSCRIBE)));
EXPECT_EQ(aclrtProcessReport(1), ACL_ERROR_RT_THREAD_SUBSCRIBE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtProcessReport(_))
.WillOnce(Return((ACL_ERROR_RT_REPORT_TIMEOUT)));
EXPECT_EQ(aclrtProcessReport(1), ACL_ERROR_RT_REPORT_TIMEOUT);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtProcessReport(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
EXPECT_EQ(aclrtProcessReport(1), ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemAllocManaged_DeviceTest)
{
void *devPtr = nullptr;
size_t size = 1;
uint32_t errorFlag = 0;
aclError ret = aclrtMemAllocManaged(&devPtr, size, errorFlag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemAllocManaged(&devPtr, size, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemManagedAdvise_DeviceTest)
{
void *ptr = nullptr;
size_t size = 1;
aclrtMemManagedLocation location;
location.type = ACL_MEM_LOCATIONTYPE_HOST;
aclError ret = aclrtMemAllocManaged(&ptr, size, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemManagedAdvise(ptr, size, ACL_MEM_ADVISE_SET_READ_MOSTLY, location);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(ptr);
ptr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemManagedGetAttr_DeviceTest)
{
void *ptr = nullptr;
size_t size = 1;
void *data;
size_t dataSize = 4;
aclError ret = aclrtMemAllocManaged(&ptr, size, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemManagedGetAttr(ACL_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, ptr, size, &data, dataSize);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(ptr);
ptr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemManagedGetAttrs_DeviceTest)
{
void *ptr = nullptr;
size_t size = 1;
void *data;
size_t dataSizes = 8;
size_t numAttributes = 2;
aclrtMemManagedRangeAttribute attributes[2] = {ACL_MEM_RANGE_ATTRIBUTE_READ_MOSTLY, ACL_MEM_RANGE_ATTRIBUTE_ACCESSED_BY};
aclError ret = aclrtMemAllocManaged(&ptr, size, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemManagedGetAttrs(attributes, numAttributes, ptr, size, &data, &dataSizes);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(ptr);
ptr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMalloc_DeviceTest)
{
void *devPtr = nullptr;
size_t size = 1;
aclError ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_FIRST);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(devPtr, nullptr);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_FIRST);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMalloc(nullptr, size, ACL_MEM_MALLOC_HUGE_FIRST);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_NORMAL_ONLY);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_FIRST_P2P);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY_P2P);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_NORMAL_ONLY_P2P);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
size = static_cast<size_t>(-1);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_NORMAL_ONLY);
EXPECT_NE(ret, ACL_SUCCESS);
size = static_cast<size_t>(0);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_NORMAL_ONLY);
EXPECT_NE(ret, ACL_SUCCESS);
size = 1;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMalloc(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclMalloc_1GHuge) {
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMalloc(_, _, _, _))
.WillRepeatedly(Invoke(rtMalloc1g));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMallocCached(_, _, _, _))
.WillRepeatedly(Invoke(rtMalloc1g));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMallocPhysical(_, _, _, _))
.WillRepeatedly(Invoke(rtMallocPhysical1g));
void *devPtr = nullptr;
size_t size = 1024UL * 1024UL * 1024UL;
auto ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE1G_ONLY);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE1G_ONLY_P2P);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMallocAlign32(&devPtr, size, ACL_MEM_MALLOC_HUGE1G_ONLY);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMallocAlign32(&devPtr, size, ACL_MEM_MALLOC_HUGE1G_ONLY_P2P);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMallocCached(&devPtr, size, ACL_MEM_MALLOC_HUGE1G_ONLY);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtDrvMemHandle handle = nullptr;
aclrtPhysicalMemProp prop = {};
prop.handleType = ACL_MEM_HANDLE_TYPE_NONE;
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
prop.memAttr = ACL_HBM_MEM_HUGE1G;
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.location.id = 0;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
prop.memAttr = ACL_HBM_MEM_P2P_HUGE1G;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_NE(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocCached_DeviceTest)
{
void *devPtr = nullptr;
size_t size = 1;
aclError ret = aclrtMallocCached(&devPtr, size, ACL_MEM_MALLOC_HUGE_FIRST);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMallocCached(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMallocCached(&devPtr, size, ACL_MEM_MALLOC_NORMAL_ONLY);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(devPtr, nullptr);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMallocCached(_, _, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtMallocCached(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemFlushTest)
{
void *devPtr = nullptr;
size_t size = 1;
aclError ret = aclrtMemFlush(devPtr, size);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
size = 0;
devPtr = (void *)0x11;
ret = aclrtMemFlush(devPtr, size);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
size = 1;
devPtr = (void *)0x11;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFlushCache(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtMemFlush(devPtr, size);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemInvalidateTest)
{
void *devPtr = nullptr;
size_t size = static_cast<size_t>(1);
aclError ret = aclrtMemInvalidate(devPtr, size);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
size = static_cast<size_t>(0);
devPtr = (void *)0x11;
ret = aclrtMemInvalidate(devPtr, size);
EXPECT_NE(ret, ACL_SUCCESS);
size = static_cast<size_t>(-1);
ret = aclrtMallocCached(&devPtr, size, ACL_MEM_MALLOC_NORMAL_ONLY);
EXPECT_NE(ret, ACL_SUCCESS);
size = static_cast<size_t>(0);
ret = aclrtMallocCached(&devPtr, size, ACL_MEM_MALLOC_NORMAL_ONLY);
EXPECT_NE(ret, ACL_SUCCESS);
size = static_cast<size_t>(1);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtInvalidCache(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtMemInvalidate(devPtr, size);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, memory_free_device)
{
aclError ret = aclrtFree(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
void *devPtr = nullptr;
size_t size = 1;
aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY_P2P);
ret = aclrtFree(devPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY_P2P);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFree(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Invoke([](void *devPtr) {
return aclStub().rtFree(devPtr);
}));
ret = aclrtFree(devPtr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aclrtFree(devPtr), ACL_SUCCESS);
devPtr = nullptr;
}
TEST_F(UTEST_ACL_Runtime, memory_malloc_host)
{
void *hostPtr = nullptr;
size_t size = 0;
aclError ret = aclrtMallocHost(&hostPtr, size);
EXPECT_NE(ret, ACL_SUCCESS);
size = 1;
ret = aclrtMallocHost(&hostPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(hostPtr, nullptr);
ret = aclrtFreeHost(hostPtr);
hostPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMallocHost(nullptr, size);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtMallocHost(&hostPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFreeHost(hostPtr);
hostPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMallocHost(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMallocHost(&hostPtr, size);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, memoryFreeHostTest)
{
void *hostPtr = nullptr;
aclError ret = aclrtFreeHost(hostPtr);
EXPECT_NE(ret, ACL_SUCCESS);
size_t size = 1;
ret = aclrtMallocHost(&hostPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(hostPtr, nullptr);
ret = aclrtFreeHost(hostPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMallocHost(&hostPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFreeHost(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Invoke([](void *hostPtr) {
return aclStub().rtFreeHost(hostPtr);
}));
ret = aclrtFreeHost(hostPtr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aclrtFreeHost(hostPtr), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, device_free_with_dev_sync)
{
aclError ret = aclrtFreeWithDevSync(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
void *devPtr = nullptr;
size_t size = 1;
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY_P2P);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFreeWithDevSync(devPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_ONLY_P2P);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFreeWithDevSync(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Invoke([](void *devPtr) {
return aclStub().rtFreeWithDevSync(devPtr);
}));
ret = aclrtFreeWithDevSync(devPtr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aclrtFreeWithDevSync(devPtr), ACL_SUCCESS);
devPtr = nullptr;
}
TEST_F(UTEST_ACL_Runtime, host_free_with_dev_sync)
{
void *hostPtr = nullptr;
aclError ret = aclrtFreeHostWithDevSync(hostPtr);
EXPECT_NE(ret, ACL_SUCCESS);
size_t size = 1;
ret = aclrtMallocHost(&hostPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFreeHostWithDevSync(hostPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMallocHost(&hostPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFreeHostWithDevSync(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Invoke([](void *hostPtr) {
return aclStub().rtFreeHostWithDevSync(hostPtr);
}));
ret = aclrtFreeHostWithDevSync(hostPtr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aclrtFreeHostWithDevSync(hostPtr), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, memory_memset)
{
aclError ret = aclrtMemset(nullptr, 1, 1, 1);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtMemset(nullptr, 0, 1, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
void *src = (void *)malloc(5);
ret = aclrtMemset(src, 1, 1, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemset(_, _, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtMemset(src, 1, 1, 1);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
free(src);
}
TEST_F(UTEST_ACL_Runtime, memory_memcpy)
{
char src[5] = {};
char dst[5] = {};
aclError ret = aclrtMemcpy(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_HOST);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy(nullptr, 0, nullptr, 0, ACL_MEMCPY_HOST_TO_HOST);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy(nullptr, 0, nullptr, 0, (aclrtMemcpyKind)0x7FFFFFFF);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy(nullptr, 1, src, 1, ACL_MEMCPY_HOST_TO_HOST);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpy(dst, 1, nullptr, 1, ACL_MEMCPY_HOST_TO_HOST);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpy(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_DEVICE);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_HOST);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_DEVICE);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy(dst, 1, src, 1, ACL_MEMCPY_DEFAULT);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy(dst, 1, src, 1, (aclrtMemcpyKind)0x7FFFFFFF);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy(_, _, _, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtMemcpy(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_DEVICE);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, memory_memcpyAsync)
{
void *dst = (void *)0x01;
void *src = (void *)0x02;
aclrtStream stream = (aclrtStream)0x10;
aclError ret = aclrtMemcpyAsync(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_HOST, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(nullptr, 0, nullptr, 0, ACL_MEMCPY_HOST_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(nullptr, 0, nullptr, 0, (aclrtMemcpyKind)0x7FFFFFFF, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(nullptr, 1, src, 1, ACL_MEMCPY_HOST_TO_HOST, stream);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(dst, 1, nullptr, 1, ACL_MEMCPY_HOST_TO_HOST, stream);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_DEVICE, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(dst, 1, src, 1, ACL_MEMCPY_DEFAULT, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsync(dst, 1, src, 1, (aclrtMemcpyKind)0x7FFFFFFF, stream);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsync(_, _, _, _, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtMemcpyAsync(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, zero_size_memory_ops_return_before_runtime_call)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy(_, _, _, _, _)).Times(0);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsync(_, _, _, _, _, _)).Times(0);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsyncEx(_, _, _, _, _, _, _)).Times(0);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemset(_, _, _, _)).Times(0);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemsetAsync(_, _, _, _, _)).Times(0);
EXPECT_EQ(aclrtMemcpy(nullptr, 1, nullptr, 0, static_cast<aclrtMemcpyKind>(0x7FFFFFFF)), ACL_SUCCESS);
EXPECT_EQ(aclrtMemcpyAsync(nullptr, 1, nullptr, 0, static_cast<aclrtMemcpyKind>(0x7FFFFFFF),
reinterpret_cast<aclrtStream>(0x10)), ACL_SUCCESS);
EXPECT_EQ(aclrtMemcpyAsyncWithCondition(nullptr, 1, nullptr, 0,
static_cast<aclrtMemcpyKind>(0x7FFFFFFF), reinterpret_cast<aclrtStream>(0x10)), ACL_SUCCESS);
EXPECT_EQ(aclrtMemset(nullptr, 1, 0, 0), ACL_SUCCESS);
EXPECT_EQ(aclrtMemsetAsync(nullptr, 1, 0, 0, reinterpret_cast<aclrtStream>(0x10)), ACL_SUCCESS);
}
static rtError_t rtsPointerGetAttributesToHost(const void *ptr, rtPtrAttributes_t *attributes)
{
(void)ptr;
attributes->location.type = RT_MEMORY_LOC_HOST;
return RT_ERROR_NONE;
}
static rtError_t rtsPointerGetAttributesToDevice(const void *ptr, rtPtrAttributes_t *attributes)\
{
(void)ptr;
attributes->location.type = RT_MEMORY_LOC_DEVICE;
return RT_ERROR_NONE;
}
static rtError_t rtsPointerGetAttributesToUnregistered(const void *ptr, rtPtrAttributes_t *attributes)
{
(void)ptr;
attributes->location.type = RT_MEMORY_LOC_UNREGISTERED;
return RT_ERROR_NONE;
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_failed_with_nullptr)
{
aclError ret = aclrtMemsetD32(nullptr, 16, 0xDEADBEEF, 4);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_success_with_zero_N)
{
void *ptr = nullptr;
size_t N = 0;
size_t memSize = 16;
aclError ret = aclrtMemsetD32(ptr, memSize, 0xDEADBEEF, N);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_failed_with_insufficient_memSize)
{
void *ptr = nullptr;
size_t N = 4;
size_t memSize = N * sizeof(uint32_t) - 1;
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
aclError ret = aclrtMemsetD32(ptr, memSize, 0xDEADBEEF, N);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_rt_error)
{
void *ptr = nullptr;
size_t N = 4;
size_t memSize = N * sizeof(uint32_t);
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillOnce(Invoke(rtsPointerGetAttributesToHost));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemsetD32(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclError ret = aclrtMemsetD32(ptr, memSize, 0xDEADBEEF, N);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32Async_failed_with_nullptr)
{
aclrtStream stream = (aclrtStream)0x10;
aclError ret = aclrtMemsetD32Async(nullptr, 16, 0xDEADBEEF, 4, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32Async_success_with_zero_N)
{
void *ptr = nullptr;
aclrtStream stream = (aclrtStream)0x10;
size_t N = 0;
size_t memSize = 16;
aclError ret = aclrtMemsetD32Async(ptr, memSize, 0xDEADBEEF, N, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32Async_failed_with_insufficient_memSize)
{
void *ptr = nullptr;
size_t N = 4;
size_t memSize = N * sizeof(uint32_t) - 1;
aclrtStream stream = (aclrtStream)0x10;
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
aclError ret = aclrtMemsetD32Async(ptr, memSize, 0xDEADBEEF, N, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32Async_rt_error)
{
void *ptr = nullptr;
size_t N = 4;
size_t memSize = N * sizeof(uint32_t);
aclrtStream stream = (aclrtStream)0x10;
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillRepeatedly(Invoke(rtsPointerGetAttributesToHost));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemsetD32Async(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclError ret = aclrtMemsetD32Async(ptr, memSize, 0xDEADBEEF, N, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_large_N_success)
{
void *ptr = nullptr;
size_t N = 1024 * 1024;
size_t memSize = N * sizeof(uint32_t);
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillOnce(Invoke(rtsPointerGetAttributesToHost));
aclError ret = aclrtMemsetD32(ptr, memSize, 0xDEADBEEF, N);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_large_N_insufficient_memSize)
{
void *ptr = nullptr;
size_t N = 1024 * 1024;
size_t memSize = N * sizeof(uint32_t) - 1;
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
aclError ret = aclrtMemsetD32(ptr, memSize, 0xDEADBEEF, N);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_exact_memSize_success)
{
void *ptr = nullptr;
size_t N = 1024;
size_t memSize = N * sizeof(uint32_t);
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillOnce(Invoke(rtsPointerGetAttributesToHost));
aclError ret = aclrtMemsetD32(ptr, memSize, 0x12345678, N);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_async_exact_memSize_success)
{
void *ptr = nullptr;
aclrtStream stream = (aclrtStream)0x10;
size_t N = 1024;
size_t memSize = N * sizeof(uint32_t);
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillRepeatedly(Invoke(rtsPointerGetAttributesToHost));
aclError ret = aclrtMemsetD32Async(ptr, memSize, 0x12345678, N, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32Async_large_N_null_stream)
{
void *ptr = nullptr;
size_t N = 1024 * 1024;
size_t memSize = N * sizeof(uint32_t);
aclrtMallocHost(&ptr, memSize);
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillRepeatedly(Invoke(rtsPointerGetAttributesToHost));
aclError ret = aclrtMemsetD32Async(ptr, memSize, 0xDEADBEEF, N, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtFreeHost(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_1GB_N_success)
{
void *ptr = (void *)0x01;
const size_t N = 268435456;
const size_t memSize = N * sizeof(uint32_t);
aclError ret = aclrtMemsetD32(ptr, memSize, 0xDEADBEEF, N);
EXPECT_TRUE(ret == ACL_ERROR_RT_FEATURE_NOT_SUPPORT || ret == ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_1GB_insufficient_memSize)
{
void *ptr = nullptr;
const size_t N = 268435456;
const size_t memSize = N * sizeof(uint32_t) - 1;
aclError ret = aclrtMemsetD32(ptr, memSize, 0xDEADBEEF, N);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_failed_with_malloc_memory)
{
size_t N = 1024;
size_t memSize = N * sizeof(uint32_t);
void *ptr = malloc(memSize);
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillOnce(Invoke(rtsPointerGetAttributesToUnregistered));
aclError ret = aclrtMemsetD32(ptr, memSize, 0xDEADBEEF, N);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
free(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32Async_failed_with_malloc_memory)
{
size_t N = 1024;
size_t memSize = N * sizeof(uint32_t);
void *ptr = malloc(memSize);
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillOnce(Invoke(rtsPointerGetAttributesToUnregistered));
aclrtStream stream = (aclrtStream)0x10;
aclError ret = aclrtMemsetD32Async(ptr, memSize, 0xDEADBEEF, N, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
free(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32Async_success_with_aclrtMalloc_memory)
{
void *ptr = nullptr;
size_t N = 1024;
size_t memSize = N * sizeof(uint32_t);
aclError allocRet = aclrtMalloc(&ptr, memSize, ACL_MEM_MALLOC_NORMAL_ONLY);
if (allocRet != ACL_SUCCESS) {
GTEST_SKIP() << "Device memory allocation failed, skip test.";
}
ASSERT_NE(ptr, nullptr);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillRepeatedly(Invoke(rtsPointerGetAttributesToDevice));
aclrtStream stream = (aclrtStream)0x10;
aclError ret = aclrtMemsetD32Async(ptr, memSize, 0xDEADBEEF, N, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtFree(ptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32_failed_with_unaligned_ptr)
{
void *alignedPtr = nullptr;
size_t N = 4;
size_t memSize = N * sizeof(uint32_t) + 4;
aclrtMallocHost(&alignedPtr, memSize);
ASSERT_NE(alignedPtr, nullptr);
uint8_t *bytePtr = static_cast<uint8_t*>(alignedPtr);
void *unalignedPtr = bytePtr + 2;
size_t availableSize = memSize - 2;
aclError ret = aclrtMemsetD32(unalignedPtr, availableSize, 0xDEADBEEF, N);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtFreeHost(alignedPtr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetD32Async_failed_with_unaligned_ptr)
{
void *alignedPtr = nullptr;
size_t N = 4;
size_t memSize = N * sizeof(uint32_t) + 4;
aclrtMallocHost(&alignedPtr, memSize);
ASSERT_NE(alignedPtr, nullptr);
uint8_t *bytePtr = static_cast<uint8_t*>(alignedPtr);
void *unalignedPtr = bytePtr + 2;
size_t availableSize = memSize - 2;
aclrtStream stream = (aclrtStream)0x10;
aclError ret = aclrtMemsetD32Async(unalignedPtr, availableSize, 0xDEADBEEF, N, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtFreeHost(alignedPtr);
}
TEST_F(UTEST_ACL_Runtime, memory_memcpyAsyncWithCondition)
{
void *dst = (void *)0x01;
void *src = (void *)0x02;
aclrtStream stream = (aclrtStream)0x10;
aclError ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_HOST, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(nullptr, 0, nullptr, 0, ACL_MEMCPY_HOST_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(nullptr, 0, nullptr, 0, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(nullptr, 0, nullptr, 0, (aclrtMemcpyKind)0x7FFFFFFF, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(nullptr, 1, src, 1, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(dst, 1, nullptr, 1, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_DEVICE, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, ACL_MEMCPY_DEFAULT, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, (aclrtMemcpyKind)0x7FFFFFFF, stream);
EXPECT_NE(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsyncEx(_, _, _, _, _, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtMemcpyAsyncWithCondition(dst, 1, src, 1, ACL_MEMCPY_DEVICE_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, memory_getMemInfo)
{
size_t free = 0x01;
size_t total = 0x02;
aclError ret = aclrtGetMemInfo(ACL_DDR_MEM_HUGE, &free, &total);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtGetMemInfo(ACL_DDR_MEM_HUGE, &free, &total);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtGetMemInfo(ACL_HBM_MEM, &free, &total);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemGetInfoEx(_, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtGetMemInfo(ACL_DDR_MEM_HUGE, &free, &total);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetMemUsageInfo)
{
int32_t deviceId = 0;
aclrtMemUsageInfo memUsageInfo[10];
size_t numInput = 10;
size_t numOutput = 0;
aclError ret = aclrtGetMemUsageInfo(deviceId, memUsageInfo, numInput, &numOutput);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetMemUsageInfo(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtGetMemUsageInfo(deviceId, memUsageInfo, numInput, &numOutput);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetAsyncFailedTest)
{
void *devPtr = (void *)0x01;
aclrtStream stream = (aclrtStream)0x10;
aclError ret = aclrtMemsetAsync(nullptr, 1, 1, 1, stream);
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtMemsetAsync(nullptr, 0, 1, 0, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemsetAsync(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMemsetAsync(devPtr, 1, 1, 1, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCheckMemTypeTest)
{
void *devPtr = nullptr;
size_t size = 1;
aclError ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_FIRST);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(devPtr, nullptr);
uint32_t checkResult = 0;
ret = aclrtCheckMemType(&devPtr, size, ACL_RT_MEM_TYPE_DEV, &checkResult, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(checkResult, 0);
ret = aclrtFree(devPtr);
devPtr = nullptr;
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemsetAsyncSuccessTest)
{
void *devPtr = (void *)0x01;
aclrtStream stream = (aclrtStream)0x10;
aclError ret = aclrtMemsetAsync(devPtr, 1, 1, 1, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetGroupCountTest)
{
uint32_t count = 0;
EXPECT_EQ(aclrtGetGroupCount(&count), ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetGroupCount(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
EXPECT_EQ(aclrtGetGroupCount(&count), ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateGroupInfoTest)
{
aclrtGroupInfo *groupInfo = aclrtCreateGroupInfo();
EXPECT_NE(groupInfo, nullptr);
EXPECT_EQ(aclrtDestroyGroupInfo(groupInfo), ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetGroupCount(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
EXPECT_EQ(aclrtCreateGroupInfo(), nullptr);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetGroupInfoDetailTest)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetGroupCount(_))
.WillOnce(Return(RT_ERROR_NONE))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillRepeatedly(Return(RT_ERROR_NONE));
aclrtGroupInfo *groupInfo = aclrtCreateGroupInfo();
uint32_t aicoreNum = 0;
size_t param_ret_size = 0;
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 1, ACL_GROUP_AICORE_INT,
(void *)(&aicoreNum), 4, ¶m_ret_size), ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aicoreNum, 0);
EXPECT_EQ(param_ret_size, 0);
uint32_t aicpuNum = 0;
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 1, ACL_GROUP_AIC_INT,
(void *)(&aicpuNum), 4, ¶m_ret_size), ACL_SUCCESS);
EXPECT_NE(aicpuNum, 0);
uint32_t aivectorNum = 0;
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 1, ACL_GROUP_AIV_INT,
(void *)(&aivectorNum), 4, ¶m_ret_size), ACL_SUCCESS);
EXPECT_NE(aivectorNum, 0);
uint32_t sdmaNum = 0;
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 1, ACL_GROUP_SDMANUM_INT,
(void *)(&sdmaNum), 4, ¶m_ret_size), ACL_SUCCESS);
EXPECT_NE(sdmaNum, 0);
uint32_t activeStreamNum = 0;
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 1, ACL_GROUP_ASQNUM_INT,
(void *)(&activeStreamNum), 4, ¶m_ret_size), ACL_SUCCESS);
EXPECT_NE(activeStreamNum, 0);
uint32_t groupId = 0;
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 1, ACL_GROUP_GROUPID_INT,
(void *)(&groupId), 4, ¶m_ret_size), ACL_SUCCESS);
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 2, ACL_GROUP_ASQNUM_INT,
(void *)(&activeStreamNum), 4, ¶m_ret_size), ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 1, static_cast<aclrtGroupAttr>(6),
(void *)(&activeStreamNum), 4, ¶m_ret_size), ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtDestroyGroupInfo(groupInfo), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetGroupInfoDetail_Fail_ValueLenTooSmall)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetGroupCount(_))
.WillRepeatedly(Return(RT_ERROR_NONE));
aclrtGroupInfo *groupInfo = aclrtCreateGroupInfo();
uint32_t value = 0;
size_t param_ret_size = 0;
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 0, ACL_GROUP_AICORE_INT,
(void *)(&value), 1, ¶m_ret_size), ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 0, ACL_GROUP_AIV_INT,
(void *)(&value), 2, ¶m_ret_size), ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtDestroyGroupInfo(groupInfo), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetGroupInfoDetail_Fail_MemcpySecurecRange)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetGroupCount(_))
.WillRepeatedly(Return(RT_ERROR_NONE));
aclrtGroupInfo *groupInfo = aclrtCreateGroupInfo();
uint32_t value = 0U;
size_t paramRetSize = 0U;
const size_t invalidValueLen = 0x80000000UL;
EXPECT_EQ(aclrtGetGroupInfoDetail(groupInfo, 0, ACL_GROUP_AICORE_INT,
static_cast<void *>(&value), invalidValueLen, ¶mRetSize), ACL_ERROR_FAILURE);
EXPECT_EQ(paramRetSize, 0U);
EXPECT_EQ(aclrtDestroyGroupInfo(groupInfo), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetAllGroupInfoTest)
{
aclrtGroupInfo *groupInfo = aclrtCreateGroupInfo();
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetGroupCount(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtGetAllGroupInfo(groupInfo), ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetGroupInfo(_, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillOnce(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtGetAllGroupInfo(groupInfo), ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aclrtGetAllGroupInfo(groupInfo), ACL_SUCCESS);
EXPECT_EQ(aclrtDestroyGroupInfo(groupInfo), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetGroupFailedTest)
{
int32_t groupId = 1;
EXPECT_EQ(aclrtSetGroup(groupId), ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSetGroup(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
EXPECT_EQ(aclrtSetGroup(groupId), ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclDeviceCanAccessPeerTest)
{
int32_t canAccessPeer = 0;
EXPECT_EQ(aclrtDeviceCanAccessPeer(&canAccessPeer, 0, 0), ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtDeviceCanAccessPeer(&canAccessPeer, 0, 1), ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDevicePhyIdByIndex(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtDeviceCanAccessPeer(&canAccessPeer, 0, 1), ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceCanAccessPeer(_, _, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtDeviceCanAccessPeer(&canAccessPeer, 0, 1), ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclEnablePeerAccessTest)
{
int32_t peerDeviceId = 1;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDevice(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtDeviceEnablePeerAccess(peerDeviceId, 0), ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aclrtDeviceEnablePeerAccess(0, 1), ACL_ERROR_FEATURE_UNSUPPORTED);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDevicePhyIdByIndex(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtDeviceEnablePeerAccess(peerDeviceId, 0), ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEnableP2P(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
EXPECT_EQ(aclrtDeviceEnablePeerAccess(peerDeviceId, 0), ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclDisablePeerAccessTest)
{
int32_t peerDeviceId = 1;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDevice(_))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtDeviceDisablePeerAccess(peerDeviceId), ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aclrtDeviceDisablePeerAccess(0), ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDevicePhyIdByIndex(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtDeviceDisablePeerAccess(peerDeviceId), ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDisableP2P(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
EXPECT_EQ(aclrtDeviceDisablePeerAccess(peerDeviceId), ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSubscribeReportFailedTest)
{
uint64_t threadId = 1;
aclrtStream stream = nullptr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSubscribeReport(_,_))
.WillOnce(Return((1)));
aclError ret = aclrtSubscribeReport(threadId, stream);
EXPECT_EQ(ret, 1);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetExceptionInfoCallbackFailedTest)
{
aclrtExceptionInfoCallback callback = nullptr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtRegTaskFailCallbackByModule(_, _))
.WillOnce(Return((1)));
aclError ret = aclrtSetExceptionInfoCallback(callback);
EXPECT_EQ(ret, 1);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpy2dTest)
{
int32_t temp = 1;
void *dst = reinterpret_cast<void *>(&temp);
void *src = reinterpret_cast<void *>(&temp);
size_t dpitch = 2;
size_t spitch = 2;
size_t width = 3;
size_t height = 1;
aclrtMemcpyKind kind = ACL_MEMCPY_HOST_TO_DEVICE;
aclError ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, kind);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
width = 2;
height = 0;
ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, kind);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy2d(nullptr, 0, nullptr, 0, 0, 1, kind);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy2d(nullptr, 0, nullptr, 0, 0, 1, ACL_MEMCPY_HOST_TO_HOST);
EXPECT_EQ(ret, ACL_SUCCESS);
width = 1;
height = 2;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy2d(_, _, _, _, _, _, _))
.WillOnce(Return(1))
.WillOnce(Return(0))
.WillOnce(Return(0));
ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, kind);
EXPECT_EQ(ret, 1);
width = 1;
height = 2;
kind = ACL_MEMCPY_HOST_TO_HOST;
ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, kind);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
width = 1;
height = 2;
kind = ACL_MEMCPY_HOST_TO_DEVICE;
ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, kind);
EXPECT_EQ(ret, ACL_SUCCESS);
width = 1;
height = 2;
kind = ACL_MEMCPY_DEFAULT;
ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, kind);
EXPECT_EQ(ret, ACL_SUCCESS);
width = 1;
height = 2;
kind = ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE;
ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, kind);
EXPECT_NE(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpy2d_zero_size_return_before_param_check)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy2d(_, _, _, _, _, _, RT_MEMCPY_RESERVED))
.Times(2)
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy2dAsync(_, _, _, _, _, _, RT_MEMCPY_RESERVED, _))
.Times(2)
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_EQ(aclrtMemcpy2d(nullptr, 0, nullptr, 0, 0, 1, static_cast<aclrtMemcpyKind>(0x7FFFFFFF)),
ACL_SUCCESS);
EXPECT_EQ(aclrtMemcpy2d(nullptr, 0, nullptr, 0, 1, 0, ACL_MEMCPY_HOST_TO_HOST), ACL_SUCCESS);
EXPECT_EQ(aclrtMemcpy2dAsync(nullptr, 0, nullptr, 0, 0, 1,
static_cast<aclrtMemcpyKind>(0x7FFFFFFF), reinterpret_cast<aclrtStream>(0x10)), ACL_SUCCESS);
EXPECT_EQ(aclrtMemcpy2dAsync(nullptr, 0, nullptr, 0, 1, 0, ACL_MEMCPY_HOST_TO_HOST,
reinterpret_cast<aclrtStream>(0x10)), ACL_SUCCESS);
int32_t temp = 0;
void *addr = reinterpret_cast<void *>(&temp);
auto stream = reinterpret_cast<aclrtStream>(0x10);
EXPECT_EQ(aclrtMemcpy2d(nullptr, 1, addr, 1, 1, 1, ACL_MEMCPY_HOST_TO_DEVICE),
ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtMemcpy2d(addr, 1, nullptr, 1, 1, 1, ACL_MEMCPY_HOST_TO_DEVICE),
ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtMemcpy2dAsync(nullptr, 1, addr, 1, 1, 1, ACL_MEMCPY_HOST_TO_DEVICE, stream),
ACL_ERROR_INVALID_PARAM);
EXPECT_EQ(aclrtMemcpy2dAsync(addr, 1, nullptr, 1, 1, 1, ACL_MEMCPY_HOST_TO_DEVICE, stream),
ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpy2dAsyncTest)
{
int32_t temp = 1;
void *dst = reinterpret_cast<void *>(&temp);
void *src = reinterpret_cast<void *>(&temp);
size_t dpitch = 2;
size_t spitch = 2;
size_t width = 3;
size_t height = 1;
aclrtStream stream;
aclrtMemcpyKind kind = ACL_MEMCPY_HOST_TO_DEVICE;
aclError ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, kind, &stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
width = 2;
height = 0;
ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, kind, &stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy2dAsync(nullptr, 0, nullptr, 0, 0, 1, kind, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpy2dAsync(nullptr, 0, nullptr, 0, 0, 1, ACL_MEMCPY_HOST_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
width = 1;
height = 2;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy2dAsync(_, _, _, _, _, _, _, _))
.WillOnce(Return(1))
.WillOnce(Return(0))
.WillOnce(Return(0))
.WillOnce(Return(0));
ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, kind, stream);
EXPECT_EQ(ret, 1);
width = 1;
height = 2;
kind = ACL_MEMCPY_HOST_TO_HOST;
ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, kind, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
width = 1;
height = 2;
kind = ACL_MEMCPY_HOST_TO_DEVICE;
ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, kind, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
width = 1;
height = 2;
kind = ACL_MEMCPY_DEVICE_TO_DEVICE;
ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, kind, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
width = 1;
height = 2;
kind = ACL_MEMCPY_DEFAULT;
ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, kind, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
width = 1;
height = 2;
kind = ACL_MEMCPY_HOST_TO_BUF_TO_DEVICE;
ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, kind, stream);
EXPECT_NE(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamOverflowSwitch)
{
aclrtStream stream = nullptr;
aclError ret = aclrtSetStreamOverflowSwitch(stream, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSetStreamOverflowSwitch(_, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtSetStreamOverflowSwitch(stream, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetStreamOverflowSwitch)
{
aclrtStream stream = nullptr;
uint32_t flag;
aclError ret = aclrtGetStreamOverflowSwitch(stream, &flag);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetStreamOverflowSwitch(_, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtGetStreamOverflowSwitch(stream, &flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetDeviceSatMode)
{
aclError ret = aclrtSetDeviceSatMode(ACL_RT_OVERFLOW_MODE_SATURATION);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSetDeviceSatMode(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtSetDeviceSatMode(ACL_RT_OVERFLOW_MODE_SATURATION);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceSatMode)
{
aclrtFloatOverflowMode mode = ACL_RT_OVERFLOW_MODE_UNDEF;
aclError ret = aclrtGetDeviceSatMode(&mode);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDeviceSatMode(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtGetDeviceSatMode(&mode);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
class ExternalAllocatorDesc {
public:
ExternalAllocatorDesc(): obj(nullptr), allocFunc(nullptr), freeFunc(nullptr), allocAdviseFunc(nullptr), getAddrFromBlockFunc(nullptr) {}
ExternalAllocatorDesc(aclrtAllocator allocator,
aclrtAllocatorAllocFunc allocFunc,
aclrtAllocatorFreeFunc freeFunc,
aclrtAllocatorAllocAdviseFunc allocAdviseFunc,
aclrtAllocatorGetAddrFromBlockFunc getAddrFromBlockFunc)
{
this->obj = allocator;
this->allocFunc = allocFunc;
this->freeFunc = freeFunc;
this->allocAdviseFunc = allocAdviseFunc;
this->getAddrFromBlockFunc = getAddrFromBlockFunc;
}
~ExternalAllocatorDesc() {}
bool operator==(const ExternalAllocatorDesc &allocatorDesc) {
return obj == allocatorDesc.obj &&
allocFunc == allocatorDesc.allocFunc &&
freeFunc == allocatorDesc.freeFunc &&
allocAdviseFunc == allocatorDesc.allocAdviseFunc &&
getAddrFromBlockFunc == allocatorDesc.getAddrFromBlockFunc;
}
aclrtAllocator obj;
aclrtAllocatorAllocFunc allocFunc;
aclrtAllocatorFreeFunc freeFunc;
aclrtAllocatorAllocAdviseFunc allocAdviseFunc;
aclrtAllocatorGetAddrFromBlockFunc getAddrFromBlockFunc;
};
TEST_F(UTEST_ACL_Runtime, aclrtAllocatorGetByStream_Fail_StreamNotRegistered)
{
aclrtStream stream = (aclrtStream)0x01;
auto allocatorDesc = aclrtAllocatorCreateDesc();
EXPECT_NE(allocatorDesc, nullptr);
void *obj = (void *)0x10;
aclError ret = aclrtAllocatorSetObjToDesc(allocatorDesc, obj);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtAllocatorAllocFunc alloc_func = (aclrtAllocatorAllocFunc)0x20;
ret = aclrtAllocatorSetAllocFuncToDesc(allocatorDesc, alloc_func);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtAllocatorFreeFunc free_func = (aclrtAllocatorFreeFunc)0x30;
ret = aclrtAllocatorSetFreeFuncToDesc(allocatorDesc, free_func);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtAllocatorAllocAdviseFunc alloc_advise_func = (aclrtAllocatorAllocAdviseFunc)0x40;
ret = aclrtAllocatorSetAllocAdviseFuncToDesc(allocatorDesc, alloc_advise_func);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtAllocatorGetAddrFromBlockFunc get_addr_from_block_func = (aclrtAllocatorGetAddrFromBlockFunc)0x50;
ret = aclrtAllocatorSetGetAddrFromBlockFuncToDesc(allocatorDesc, get_addr_from_block_func);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtAllocatorRegister(stream, static_cast<ExternalAllocatorDesc *>(allocatorDesc));
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtAllocatorDesc aclrt_desc;
ret = aclrtAllocatorGetByStream(stream, &aclrt_desc, nullptr, nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtAllocatorUnregister(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtAllocatorGetByStream(stream, &aclrt_desc, nullptr, nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtAllocatorDestroyDesc(allocatorDesc);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetArgsFromExceptionInfo_failed_with_invalid_exception_type)
{
void *devArgs = nullptr;
uint32_t devArgsLen = 0;
aclrtExceptionInfo exceptionInfo;
(void)memset_s(&exceptionInfo, sizeof(aclrtExceptionInfo), 0, sizeof(aclrtExceptionInfo));
exceptionInfo.expandInfo.type = RT_EXCEPTION_INVALID;
auto ret = aclrtGetArgsFromExceptionInfo(&exceptionInfo, &devArgs, &devArgsLen);
EXPECT_EQ(ret, static_cast<aclError>(0xFFFFFFFFU));
exceptionInfo.expandInfo.type = RT_EXCEPTION_UB;
ret = aclrtGetArgsFromExceptionInfo(&exceptionInfo, &devArgs, &devArgsLen);
EXPECT_EQ(ret, static_cast<aclError>(0xFFFFFFFFU));
exceptionInfo.expandInfo.type = RT_EXCEPTION_CCU;
ret = aclrtGetArgsFromExceptionInfo(&exceptionInfo, &devArgs, &devArgsLen);
EXPECT_EQ(ret, static_cast<aclError>(0xFFFFFFFFU));
exceptionInfo.expandInfo.type = RT_EXCEPTION_FUSION;
exceptionInfo.expandInfo.u.fusionInfo.type = RT_FUSION_AICORE_AICPU;
ret = aclrtGetArgsFromExceptionInfo(&exceptionInfo, &devArgs, &devArgsLen);
EXPECT_EQ(ret, static_cast<aclError>(0xFFFFFFFFU));
}
TEST_F(UTEST_ACL_Runtime, aclrtAllocatorCreateDescTest)
{
aclrtStream stream = (aclrtStream)0x01;
auto allocatorDesc = aclrtAllocatorCreateDesc();
EXPECT_NE(allocatorDesc, nullptr);
static_cast<ExternalAllocatorDesc *>(allocatorDesc)->obj = nullptr;
static_cast<ExternalAllocatorDesc *>(allocatorDesc)->allocFunc = nullptr;
static_cast<ExternalAllocatorDesc *>(allocatorDesc)->freeFunc = nullptr;
static_cast<ExternalAllocatorDesc *>(allocatorDesc)->getAddrFromBlockFunc = nullptr;
aclError ret = aclrtAllocatorRegister(stream, allocatorDesc);
EXPECT_NE(ret, ACL_SUCCESS);
void *obj = (void *)0x10;
ret = aclrtAllocatorSetObjToDesc(allocatorDesc, obj);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(static_cast<ExternalAllocatorDesc *>(allocatorDesc)->obj, obj);
ret = aclrtAllocatorRegister(stream, allocatorDesc);
EXPECT_NE(ret, ACL_SUCCESS);
aclrtAllocatorAllocFunc alloc_func = (aclrtAllocatorAllocFunc)0x20;
ret = aclrtAllocatorSetAllocFuncToDesc(allocatorDesc, alloc_func);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(static_cast<ExternalAllocatorDesc *>(allocatorDesc)->allocFunc, alloc_func);
ret = aclrtAllocatorRegister(stream, allocatorDesc);
EXPECT_NE(ret, ACL_SUCCESS);
aclrtAllocatorFreeFunc free_func = (aclrtAllocatorFreeFunc)0x30;
ret = aclrtAllocatorSetFreeFuncToDesc(allocatorDesc, free_func);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(static_cast<ExternalAllocatorDesc *>(allocatorDesc)->freeFunc, free_func);
aclrtAllocatorAllocAdviseFunc alloc_advise_func = (aclrtAllocatorAllocAdviseFunc)0x40;
ret = aclrtAllocatorSetAllocAdviseFuncToDesc(allocatorDesc, alloc_advise_func);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(static_cast<ExternalAllocatorDesc *>(allocatorDesc)->allocAdviseFunc, alloc_advise_func);
ret = aclrtAllocatorRegister(stream, static_cast<ExternalAllocatorDesc *>(allocatorDesc));
EXPECT_NE(ret, ACL_SUCCESS);
aclrtAllocatorGetAddrFromBlockFunc get_addr_from_block_func = (aclrtAllocatorGetAddrFromBlockFunc)0x50;
ret = aclrtAllocatorSetGetAddrFromBlockFuncToDesc(allocatorDesc, get_addr_from_block_func);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(static_cast<ExternalAllocatorDesc *>(allocatorDesc)->getAddrFromBlockFunc, get_addr_from_block_func);
ret = aclrtAllocatorRegister(stream, static_cast<ExternalAllocatorDesc *>(allocatorDesc));
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtAllocatorDesc aclrt_desc;
ExternalAllocatorDesc desc;
ret = aclrtAllocatorGetByStream(stream, &aclrt_desc, nullptr, nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtAllocatorGetByStream(stream, &aclrt_desc, &desc.obj, &desc.allocFunc, &desc.freeFunc,
&desc.allocAdviseFunc, &desc.getAddrFromBlockFunc);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(allocatorDesc, aclrt_desc);
ret = aclrtAllocatorDestroyDesc(allocatorDesc);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtAllocatorGetByStream(stream, &aclrt_desc, &desc.obj, &desc.allocFunc, &desc.freeFunc,
&desc.allocAdviseFunc, &desc.getAddrFromBlockFunc);
EXPECT_EQ(allocatorDesc, aclrt_desc);
EXPECT_EQ(desc.obj, obj);
EXPECT_EQ(desc.allocFunc, alloc_func);
EXPECT_EQ(desc.freeFunc, free_func);
EXPECT_EQ(desc.allocAdviseFunc, alloc_advise_func);
EXPECT_EQ(desc.getAddrFromBlockFunc, get_addr_from_block_func);
ret = aclrtAllocatorRegister(nullptr, static_cast<ExternalAllocatorDesc *>(allocatorDesc));
EXPECT_NE(ret, ACL_SUCCESS);
ret = aclrtAllocatorUnregister(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtAllocatorUnregister(nullptr);
EXPECT_NE(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceUtilizationRate)
{
const int32_t devId = 1;
aclrtUtilizationInfo utilInfo;
aclrtUtilizationExtendInfo utilizationExtend;
utilInfo.utilizationExtend = &utilizationExtend;
aclError ret = aclrtGetDeviceUtilizationRate(devId, &utilInfo);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
utilInfo.utilizationExtend = nullptr;
ret = aclrtGetDeviceUtilizationRate(devId, &utilInfo);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetAllUtilizations(_,_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT))
.WillRepeatedly(Return(RT_ERROR_NONE));
ret = aclrtGetDeviceUtilizationRate(devId, &utilInfo);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, virtual_memory_address_reserve_release)
{
void *virPtr = nullptr;
size_t size = 1;
aclError ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(virPtr, nullptr);
ret = aclrtReleaseMemAddress(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtReserveMemAddress(&virPtr, 0, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 2);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtReserveMemAddress(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtReserveMemAddress(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtReleaseMemAddress(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtReleaseMemAddress(virPtr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, physical_memory_malloc_free)
{
aclrtDrvMemHandle handle = nullptr;
size_t size = 1;
aclrtPhysicalMemProp prop = {};
prop.handleType = ACL_MEM_HANDLE_TYPE_NONE;
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
prop.memAttr = ACL_HBM_MEM_HUGE;
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.location.id = 0;
aclError ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_HBM_MEM_NORMAL;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_DDR_MEM;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
prop.memAttr = ACL_HBM_MEM_HUGE;
prop.handleType = (aclrtMemHandleType)100;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
prop.handleType = ACL_MEM_HANDLE_TYPE_NONE;
prop.allocationType = (aclrtMemAllocationType)100;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
prop.location.type = ACL_MEM_LOCATION_TYPE_UNREGISTERED;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
ret = aclrtFreePhysical(handle);
EXPECT_EQ(ret, ACL_SUCCESS);
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
ret = aclrtMallocPhysical(&handle, 0, &prop, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMallocPhysical(&handle, size, &prop, 1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMallocPhysical(_,_,_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFreePhysical(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtFreePhysical(handle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, physical_memory_malloc_host)
{
aclrtDrvMemHandle handle = nullptr;
size_t size = 1;
aclrtPhysicalMemProp prop = {};
prop.handleType = ACL_MEM_HANDLE_TYPE_NONE;
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
prop.location.type = ACL_MEM_LOCATION_TYPE_HOST_NUMA;
prop.location.id = 0;
prop.memAttr = ACL_DDR_MEM_HUGE;
aclError ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_DDR_MEM_NORMAL;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_DDR_MEM_P2P_HUGE;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_DDR_MEM_P2P_NORMAL;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_NORMAL;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_HUGE;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_HUGE1G;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_P2P_NORMAL;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_P2P_HUGE;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_P2P_HUGE1G;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
}
TEST_F(UTEST_ACL_Runtime, physical_memory_malloc_device)
{
aclrtDrvMemHandle handle = nullptr;
size_t size = 1;
aclrtPhysicalMemProp prop = {};
prop.handleType = ACL_MEM_HANDLE_TYPE_NONE;
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.location.id = 0;
prop.memAttr = ACL_MEM_NORMAL;
aclError ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_HUGE;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_HUGE1G;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_P2P_NORMAL;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_P2P_HUGE;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_MEM_P2P_HUGE1G;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
prop.memAttr = ACL_DDR_MEM_NORMAL;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_NE(handle, nullptr);
}
TEST_F(UTEST_ACL_Runtime, virtual_physical_memory_map_unmap)
{
void *virPtr = nullptr;
size_t size = 1;
aclError ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(virPtr, nullptr);
aclrtDrvMemHandle handle = nullptr;
aclrtPhysicalMemProp prop = {};
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
prop.memAttr = ACL_HBM_MEM_HUGE;
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.location.id = 0;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
ret = aclrtMapMem(virPtr, size, 0, handle, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtUnmapMem(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMapMem(virPtr, 0, 0, handle, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMapMem(virPtr, size, 0, handle, 1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtReleaseMemAddress(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFreePhysical(handle);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMapMem(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtMapMem(virPtr, size, 0, handle, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtUnmapMem(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtUnmapMem(virPtr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, create_binary_failed_with_nullptr_input)
{
aclrtBinary binary = nullptr;
binary = aclrtCreateBinary(nullptr, 0);
EXPECT_EQ(binary, nullptr);
}
TEST_F(UTEST_ACL_Runtime, create_binary_successful)
{
aclrtBinary binary = nullptr;
char *data = new char[100];
size_t dataLen = 0x333;
binary = aclrtCreateBinary(static_cast<void *>(data), dataLen);
EXPECT_NE(binary, nullptr);
(void)aclrtDestroyBinary(binary);
delete [] data;
}
TEST_F(UTEST_ACL_Runtime, destroy_binary_failed_with_nullptr_input)
{
aclrtBinary binary = nullptr;
aclError ret = aclrtDestroyBinary(binary);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, destroy_binary_successful)
{
char *data = reinterpret_cast<char *>(0x01);
size_t dataLen = 0x333;
aclrtBinary binary = aclrtCreateBinary(static_cast<void *>(data), dataLen);
EXPECT_NE(binary, nullptr);
aclError ret = aclrtDestroyBinary(binary);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, load_binary_failed_with_nullptr_input)
{
aclrtBinary binary = nullptr;
aclrtBinHandle *binHandle = nullptr;
aclError ret = aclrtBinaryLoad(binary, binHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
char *data = reinterpret_cast<char *>(0x01);
size_t dataLen = 0x333;
binary = aclrtCreateBinary(static_cast<void *>(data), dataLen);
EXPECT_NE(binary, nullptr);
ret = aclrtBinaryLoad(binary, binHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
(void)aclrtDestroyBinary(binary);
}
TEST_F(UTEST_ACL_Runtime, load_binary_successful)
{
char *data = reinterpret_cast<char *>(0x01);
size_t dataLen = 0x333;
aclrtBinary binary = aclrtCreateBinary(static_cast<void *>(data), dataLen);
EXPECT_NE(binary, nullptr);
aclrtBinHandle binHandle = nullptr;
aclError ret = aclrtBinaryLoad(binary, &binHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(binHandle, nullptr);
(void)aclrtDestroyBinary(binary);
}
TEST_F(UTEST_ACL_Runtime, load_binary_failed_with_rt_func_failed)
{
char *data = reinterpret_cast<char *>(0x01);
size_t dataLen = 0x333;
aclrtBinary binary = aclrtCreateBinary(static_cast<void *>(data), dataLen);
EXPECT_NE(binary, nullptr);
aclrtBinHandle binHandle = nullptr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtBinaryLoadWithoutTilingKey(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtBinaryLoad(binary, &binHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
(void)aclrtDestroyBinary(binary);
}
TEST_F(UTEST_ACL_Runtime, unload_binary_failed_with_nullptr_input)
{
aclrtBinHandle *binHandle = nullptr;
aclError ret = aclrtBinaryUnLoad(binHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, unload_binary_successful)
{
aclrtBinHandle binHandlePtr;
aclrtBinHandle *binHandle = &binHandlePtr;
aclError ret = aclrtBinaryUnLoad(binHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, unload_binary_failed_with_rt_func_failed)
{
aclrtBinHandle binHandlePtr;
aclrtBinHandle *binHandle = &binHandlePtr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtBinaryUnLoad(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtBinaryUnLoad(binHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, binary_get_func_failed_with_nullptr_input)
{
aclrtBinHandle binHandle = nullptr;
const char *kernelName = nullptr;
aclrtFuncHandle *funcHandle = nullptr;
aclError ret = aclrtBinaryGetFunction(binHandle, kernelName, funcHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
binHandle = (aclrtBinHandle)0x01U;
ret = aclrtBinaryGetFunction(binHandle, kernelName, funcHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
kernelName = "add_0";
ret = aclrtBinaryGetFunction(binHandle, kernelName, funcHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, binary_get_func_successful)
{
aclrtBinHandle binHandle = (aclrtBinHandle)0x01U;
const char *kernelName = "add_0";
aclrtFuncHandle funcHandle = nullptr;
aclError ret = aclrtBinaryGetFunction(binHandle, kernelName, &funcHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(funcHandle, nullptr);
}
TEST_F(UTEST_ACL_Runtime, binary_get_func_failed_with_rt_func_failed)
{
aclrtBinHandle binHandle = (aclrtBinHandle)0x01U;
const char *kernelName = "add_0";
aclrtFuncHandle funcHandle = nullptr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsFuncGetByName(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtBinaryGetFunction(binHandle, kernelName, &funcHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_failed_with_nullptr_input)
{
aclrtFuncHandle funcHandle = nullptr;
void *argsData = nullptr;
aclrtStream stream = nullptr;
aclError ret = aclrtLaunchKernel(funcHandle, 0, argsData, 0, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
funcHandle = (aclrtFuncHandle)0x01U;
ret = aclrtLaunchKernel(funcHandle, 0, argsData, 0, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
argsData = reinterpret_cast<void *>(0x01U);
ret = aclrtLaunchKernel(funcHandle, 0, argsData, 0, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_successful)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *argsData = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
aclError ret = aclrtLaunchKernel(funcHandle, blockDim, argsData, argsSize, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_failed_with_rt_launch_kernel_func_failed)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *argsData = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchKernelByFuncHandleV3(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtLaunchKernel(funcHandle, blockDim, argsData, argsSize, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_failed_with_rt_launch_kernel_func_failed_2)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *argsData = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchKernelByFuncHandleV3(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_HANDLE));
aclError ret = aclrtLaunchKernel(funcHandle, blockDim, argsData, argsSize, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_HANDLE);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_args_array_failed_with_nullptr)
{
void *func = nullptr;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
void *args[2] = {(void *)0x10, (void *)0x20};
aclError ret = aclrtLaunchSIMTKernelWithArgsArray(func, gridDim, blockDim, dynUbufSize, stream, cfg, args);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_args_array_successful)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {2, 2, 2};
aclrtDim3 blockDim = {4, 4, 4};
size_t dynUbufSize = 1024;
aclrtStream stream = (aclrtStream)0x01U;
aclrtLaunchKernelCfg *cfg = nullptr;
void *args[2] = {(void *)0x10, (void *)0x20};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchSIMTKernelWithArgsArray(_, _, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtLaunchSIMTKernelWithArgsArray(func, gridDim, blockDim, dynUbufSize, stream, cfg, args);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_args_array_failed_with_invalid_handle)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
void *args[2] = {(void *)0x10, (void *)0x20};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchSIMTKernelWithArgsArray(_, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_HANDLE));
aclError ret = aclrtLaunchSIMTKernelWithArgsArray(func, gridDim, blockDim, dynUbufSize, stream, cfg, args);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_HANDLE);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_args_array_failed_with_feature_not_support)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
void *args[2] = {(void *)0x10, (void *)0x20};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchSIMTKernelWithArgsArray(_, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
aclError ret = aclrtLaunchSIMTKernelWithArgsArray(func, gridDim, blockDim, dynUbufSize, stream, cfg, args);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_args_array_failed_with_other_error)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
void *args[2] = {(void *)0x10, (void *)0x20};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchSIMTKernelWithArgsArray(_, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclError ret = aclrtLaunchSIMTKernelWithArgsArray(func, gridDim, blockDim, dynUbufSize, stream, cfg, args);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_host_args_failed_with_nullptr_func)
{
void *func = nullptr;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
char hostArgs[128];
aclrtPlaceHolderInfo placeHolders[2];
aclError ret = aclrtLaunchSIMTKernelWithHostArgs(func, gridDim, blockDim, dynUbufSize, stream, cfg,
hostArgs, 128, placeHolders, 2);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_host_args_failed_with_nullptr_hostargs)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
void *hostArgs = nullptr;
aclrtPlaceHolderInfo placeHolders[2];
aclError ret = aclrtLaunchSIMTKernelWithHostArgs(func, gridDim, blockDim, dynUbufSize, stream, cfg,
hostArgs, 128, placeHolders, 2);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_host_args_failed_with_args_size_zero)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
char hostArgs[128];
aclrtPlaceHolderInfo placeHolders[2];
aclError ret = aclrtLaunchSIMTKernelWithHostArgs(func, gridDim, blockDim, dynUbufSize, stream, cfg,
hostArgs, 0, placeHolders, 2);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_host_args_successful)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {2, 2, 2};
aclrtDim3 blockDim = {4, 4, 4};
size_t dynUbufSize = 2048;
aclrtStream stream = (aclrtStream)0x01U;
aclrtLaunchKernelCfg *cfg = nullptr;
char hostArgs[128];
aclrtPlaceHolderInfo placeHolders[2];
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchSIMTKernelWithHostArgs(_, _, _, _, _, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtLaunchSIMTKernelWithHostArgs(func, gridDim, blockDim, dynUbufSize, stream, cfg,
hostArgs, 128, placeHolders, 2);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_host_args_failed_with_invalid_handle)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
char hostArgs[128];
aclrtPlaceHolderInfo placeHolders[2];
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchSIMTKernelWithHostArgs(_, _, _, _, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_HANDLE));
aclError ret = aclrtLaunchSIMTKernelWithHostArgs(func, gridDim, blockDim, dynUbufSize, stream, cfg,
hostArgs, 128, placeHolders, 2);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_HANDLE);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_host_args_failed_with_feature_not_support)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
char hostArgs[128];
aclrtPlaceHolderInfo placeHolders[2];
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchSIMTKernelWithHostArgs(_, _, _, _, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
aclError ret = aclrtLaunchSIMTKernelWithHostArgs(func, gridDim, blockDim, dynUbufSize, stream, cfg,
hostArgs, 128, placeHolders, 2);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, launch_simt_kernel_with_host_args_failed_with_other_error)
{
void *func = (void *)0x01U;
aclrtDim3 gridDim = {1, 1, 1};
aclrtDim3 blockDim = {1, 1, 1};
size_t dynUbufSize = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg *cfg = nullptr;
char hostArgs[128];
aclrtPlaceHolderInfo placeHolders[2];
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchSIMTKernelWithHostArgs(_, _, _, _, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclError ret = aclrtLaunchSIMTKernelWithHostArgs(func, gridDim, blockDim, dynUbufSize, stream, cfg,
hostArgs, 128, placeHolders, 2);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, export_to_shareablehandle_failed_with_rt_func_failed)
{
aclrtDrvMemHandle handle = (aclrtDrvMemHandle)0x01U;
aclrtMemHandleType handleType = ACL_MEM_HANDLE_TYPE_NONE;
uint64_t flag = 0ULL;
uint64_t shareableHandle;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemExportToShareableHandle(_, _, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtMemExportToShareableHandle(handle, handleType, flag, &shareableHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, export_to_shareablehandle_succ_with_rt_func_succ)
{
aclrtDrvMemHandle handle = (aclrtDrvMemHandle)0x01U;
aclrtMemHandleType handleType = ACL_MEM_HANDLE_TYPE_NONE;
uint64_t flag = 0ULL;
uint64_t shareableHandle;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemExportToShareableHandle(_, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemExportToShareableHandle(handle, handleType, flag, &shareableHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(shareableHandle, 0x1111);
}
TEST_F(UTEST_ACL_Runtime, export_to_shareablehandle_failed_with_handle_nullptr)
{
aclrtDrvMemHandle handle = nullptr;
aclrtMemHandleType handleType = ACL_MEM_HANDLE_TYPE_NONE;
uint64_t flag = 0ULL;
uint64_t shareableHandle;
aclError ret = aclrtMemExportToShareableHandle(handle, handleType, flag, &shareableHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, export_to_shareablehandle_failed_with_invalid_handleType)
{
aclrtDrvMemHandle handle = (aclrtDrvMemHandle)0x01U;
aclrtMemHandleType handleType = static_cast<aclrtMemHandleType>(0xFFFFFFFF);
uint64_t flag = 0ULL;
uint64_t shareableHandle;
aclError ret = aclrtMemExportToShareableHandle(handle, handleType, flag, &shareableHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, export_to_shareablehandle_V2_failed_with_rt_func_failed)
{
aclrtDrvMemHandle handle = (aclrtDrvMemHandle)0x01U;
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
uint64_t flag = 0ULL;
uint64_t shareableHandle;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemExportToShareableHandleV2(_, _, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtMemExportToShareableHandleV2(handle, flag, shareType, static_cast<void*>(&shareableHandle));
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, export_to_shareablehandle_V2_succ_with_rt_func_succ)
{
aclrtDrvMemHandle handle = (aclrtDrvMemHandle)0x01U;
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
uint64_t flag = 0ULL;
uint64_t shareableHandle;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemExportToShareableHandleV2(_, _, _, _))
.WillOnce(Return(ACL_RT_SUCCESS));
aclError ret = aclrtMemExportToShareableHandleV2(handle, flag, shareType, static_cast<void*>(&shareableHandle));
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, export_to_shareablehandle_V2_failed_with_handle_nullptr)
{
aclrtDrvMemHandle handle = nullptr;
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
uint64_t flag = 0ULL;
uint64_t shareableHandle;
aclError ret = aclrtMemExportToShareableHandleV2(handle, flag, shareType, static_cast<void*>(&shareableHandle));
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, import_from_shareablehandle_succ_with_rt_func_succ)
{
aclrtDrvMemHandle handle = nullptr;
uint64_t shareableHandle = 0ULL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemImportFromShareableHandle(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemImportFromShareableHandle(shareableHandle, 0, &handle);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, import_from_shareablehandle_failed_with_rt_func_failed)
{
aclrtDrvMemHandle handle = nullptr;
uint64_t shareableHandle = 0ULL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemImportFromShareableHandle(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtMemImportFromShareableHandle(shareableHandle, 0, &handle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, import_from_shareablehandle_failed_with_handle_nullptr)
{
uint64_t shareableHandle = 0ULL;
aclError ret = aclrtMemImportFromShareableHandle(shareableHandle, 0, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, import_from_shareablehandle_V2_succ_with_rts_func_succ)
{
aclrtDrvMemHandle handle = (aclrtDrvMemHandle)0x01U;
uint64_t shareableHandle = 0ULL;
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
uint64_t flag = 0ULL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemImportFromShareableHandleV2(_, _, _, _, _))
.WillOnce(Return(ACL_RT_SUCCESS));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetDevice(_))
.WillOnce(Return(ACL_RT_SUCCESS));
aclError ret = aclrtMemImportFromShareableHandleV2(static_cast<void*>(&shareableHandle), shareType, flag, &handle);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, import_from_shareablehandle_V2_failed_with_rts_func_failed)
{
aclrtDrvMemHandle handle = (aclrtDrvMemHandle)0x01U;
uint64_t shareableHandle = 0ULL;
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
uint64_t flag = 0ULL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetDevice(_))
.WillOnce(Return(ACL_RT_SUCCESS));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemImportFromShareableHandleV2(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtMemImportFromShareableHandleV2(static_cast<void*>(&shareableHandle), shareType, flag, &handle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, import_from_shareablehandle_V2_failed_with_handle_nullptr)
{
uint64_t shareableHandle = 0ULL;
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
uint64_t flag = 0ULL;
aclError ret = aclrtMemImportFromShareableHandleV2(static_cast<void*>(&shareableHandle), shareType, flag, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, import_from_shareablehandle_V2_failed_with_invalid_flags)
{
aclrtDrvMemHandle handle = (aclrtDrvMemHandle)0x01U;
uint64_t shareableHandle = 1ULL;
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
uint64_t flag = 1ULL;
aclError ret = aclrtMemImportFromShareableHandleV2(static_cast<void*>(&shareableHandle), shareType, flag, &handle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, set_pid_to_shareablehandle_succ_with_rt_func_succ)
{
uint64_t shareableHandle = 0ULL;
int32_t pid[1] = {0};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemSetPidToShareableHandle(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemSetPidToShareableHandle(shareableHandle, pid, sizeof(pid)/sizeof(pid[0]));
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, set_pid_to_shareablehandle_failed_with_rt_func_failed)
{
uint64_t shareableHandle = 0ULL;
int32_t pid[1] = {0};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemSetPidToShareableHandle(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtMemSetPidToShareableHandle(shareableHandle, pid, sizeof(pid)/sizeof(pid[0]));
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, set_pid_to_shareablehandle_failed_with_pid_nullptr)
{
uint64_t shareableHandle = 0ULL;
aclError ret = aclrtMemSetPidToShareableHandle(shareableHandle, nullptr, 1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, set_pid_to_shareablehandle_failed_with_invalid_pidNum)
{
uint64_t shareableHandle = 0ULL;
int32_t pid[1] = {0};
aclError ret = aclrtMemSetPidToShareableHandle(shareableHandle, pid, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, set_pid_to_shareablehandle_V2_succ_with_rts_func_succ)
{
uint64_t shareableHandle = 0ULL;
int32_t pid[1] = {0};
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemSetPidToShareableHandleV2(_, _, _, _))
.WillOnce(Return(ACL_RT_SUCCESS));
aclError ret = aclrtMemSetPidToShareableHandleV2(static_cast<void*>(&shareableHandle), shareType, pid, sizeof(pid)/sizeof(pid[0]));
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, set_pid_to_shareablehandle_V2_failed_with_rts_func_failed)
{
uint64_t shareableHandle = 0ULL;
int32_t pid[1] = {0};
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemSetPidToShareableHandleV2(_, _, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtMemSetPidToShareableHandleV2(static_cast<void*>(&shareableHandle), shareType, pid, sizeof(pid)/sizeof(pid[0]));
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, set_pid_to_shareablehandle_V2_failed_with_pid_nullptr)
{
uint64_t shareableHandle = 0ULL;
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
aclError ret = aclrtMemSetPidToShareableHandleV2(static_cast<void*>(&shareableHandle), shareType, nullptr, 1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, set_pid_to_shareablehandle_V2_failed_with_invalid_pidNum)
{
uint64_t shareableHandle = 0ULL;
int32_t pid[1] = {0};
aclrtMemSharedHandleType shareType = ACL_MEM_SHARE_HANDLE_TYPE_DEFAULT;
aclError ret = aclrtMemSetPidToShareableHandleV2(static_cast<void*>(&shareableHandle), shareType, pid, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_succ_with_rt_func_succ_hbm)
{
aclrtPhysicalMemProp prop = {};
prop.memAttr = ACL_HBM_MEM_HUGE;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemGetAllocationGranularity(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_succ_with_rt_func_succ_hbm1g)
{
aclrtPhysicalMemProp prop = {};
prop.memAttr = ACL_HBM_MEM_HUGE1G;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemGetAllocationGranularity(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_succ_with_rt_func_succ_normal)
{
aclrtPhysicalMemProp prop = {};
prop.memAttr = ACL_HBM_MEM_NORMAL;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemGetAllocationGranularity(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_failed_with_unsupport_memAttr)
{
aclrtPhysicalMemProp prop = {};
prop.memAttr = ACL_HBM_MEM_P2P_NORMAL;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_failed_with_rt_func_failed)
{
aclrtPhysicalMemProp prop = {};
prop.memAttr = ACL_HBM_MEM_NORMAL;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemGetAllocationGranularity(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_failed_with_prop_nullptr)
{
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
aclError ret = aclrtMemGetAllocationGranularity(nullptr, option, &granularity);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_failed_with_granularity_nullptr)
{
aclrtPhysicalMemProp prop = {};
prop.memAttr = ACL_HBM_MEM_NORMAL;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_failed_with_device_alloc_ddr_mem_huge)
{
aclrtPhysicalMemProp prop = {};
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.memAttr = ACL_DDR_MEM_HUGE;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_failed_with_device_alloc_ddr_mem_normal)
{
aclrtPhysicalMemProp prop = {};
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.memAttr = ACL_DDR_MEM_NORMAL;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_failed_with_device_alloc_ddr_mem_p2p_huge)
{
aclrtPhysicalMemProp prop = {};
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.memAttr = ACL_DDR_MEM_P2P_HUGE;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_allocation_granularity_failed_with_device_alloc_ddr_mem_p2p_normal)
{
aclrtPhysicalMemProp prop = {};
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.memAttr = ACL_DDR_MEM_P2P_NORMAL;
aclrtMemGranularityOptions option = ACL_RT_MEM_ALLOC_GRANULARITY_MINIMUM;
size_t granularity = 0UL;
aclError ret = aclrtMemGetAllocationGranularity(&prop, option, &granularity);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_tgid_succ_with_rt_func_succ)
{
int32_t pid = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceGetBareTgid(_))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtDeviceGetBareTgid(&pid);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, get_tgid_failed_with_rt_func_failed)
{
int32_t pid = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceGetBareTgid(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtDeviceGetBareTgid(&pid);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_tgid_failed_with_pid_nullptr)
{
aclError ret = aclrtDeviceGetBareTgid(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_mem_uce_info_success)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[RT_MAX_RECORD_PA_NUM_PER_DEV];
size_t arraySize = RT_MAX_RECORD_PA_NUM_PER_DEV;
size_t retSize = 0;
aclError ret = aclrtGetMemUceInfo(deviceId, memUceInfoArray, arraySize, &retSize);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, get_error_verbose_success)
{
int32_t deviceId = 0;
aclrtErrorInfo errorInfo;
aclError ret = aclrtGetErrorVerbose(deviceId, &errorInfo);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, repair_error_success)
{
int32_t deviceId = 0;
aclrtErrorInfo errorInfo{};
aclError ret = aclrtRepairError(deviceId, &errorInfo);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessLock_success)
{
aclError ret = aclrtSnapShotProcessLock(static_cast<int>(mmGetPid()), nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessLock_failed)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSnapShotProcessLock())
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtSnapShotProcessLock(static_cast<int>(mmGetPid()), nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessUnlock_success)
{
aclError ret = aclrtSnapShotProcessUnlock(static_cast<int>(mmGetPid()), nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessUnlock_failed)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSnapShotProcessUnlock())
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtSnapShotProcessUnlock(static_cast<int>(mmGetPid()), nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessBackup_success)
{
aclError ret = aclrtSnapShotProcessBackup(static_cast<int>(mmGetPid()), nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessBackup_failed)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSnapShotProcessBackup())
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtSnapShotProcessBackup(static_cast<int>(mmGetPid()), nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessRestore_success)
{
aclError ret = aclrtSnapShotProcessRestore(static_cast<int>(mmGetPid()), nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessRestore_failed)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSnapShotProcessRestore())
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtSnapShotProcessRestore(static_cast<int>(mmGetPid()), nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotCallbackRegister_failed)
{
aclError ret = aclrtSnapShotCallbackRegister(ACL_RT_SNAPSHOT_LOCK_PRE, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotCallbackUnregister_failed)
{
aclError ret = aclrtSnapShotCallbackUnregister(ACL_RT_SNAPSHOT_LOCK_PRE, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessLock_invalid_pid)
{
aclError ret = aclrtSnapShotProcessLock(9999, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessLock_invalid_reserve)
{
int dummy = 0;
aclError ret = aclrtSnapShotProcessLock(static_cast<int>(mmGetPid()), &dummy);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessBackup_invalid_args)
{
aclrtSnapShotBackupArgs args = {};
aclError ret = aclrtSnapShotProcessBackup(static_cast<int>(mmGetPid()), &args);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, SnapShotProcessRestore_invalid_args)
{
aclrtSnapShotRestoreArgs args = {};
aclError ret = aclrtSnapShotProcessRestore(static_cast<int>(mmGetPid()), &args);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_mem_uce_info__failedwith_invalid_array)
{
int32_t deviceId = 0;
size_t arraySize = RT_MAX_RECORD_PA_NUM_PER_DEV - 1;
size_t retSize = 0;
aclError ret = aclrtGetMemUceInfo(deviceId, nullptr, arraySize, &retSize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_mem_uce_info_failed_with_invalid_ret_size)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[RT_MAX_RECORD_PA_NUM_PER_DEV];
size_t arraySize = RT_MAX_RECORD_PA_NUM_PER_DEV;
aclError ret = aclrtGetMemUceInfo(deviceId, memUceInfoArray, arraySize, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
static rtError_t rtGetMemUceInfo_invoke(int32_t deviceId, rtMemUceInfo* rtUceInfo){
rtUceInfo->devid = deviceId;
rtUceInfo->count = RT_MAX_RECORD_PA_NUM_PER_DEV + 1;
return RT_ERROR_NONE;
}
TEST_F(UTEST_ACL_Runtime, get_mem_uce_info_failed_with_space_not_enough)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[RT_MAX_RECORD_PA_NUM_PER_DEV];
size_t arraySize = RT_MAX_RECORD_PA_NUM_PER_DEV;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetMemUceInfo(_,_))
.WillOnce(Invoke(rtGetMemUceInfo_invoke));
aclError ret = aclrtGetMemUceInfo(deviceId, memUceInfoArray, arraySize, &arraySize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_mem_uce_info_succ_with_valid_addr)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[RT_MAX_RECORD_PA_NUM_PER_DEV + 1];
size_t arraySize = RT_MAX_RECORD_PA_NUM_PER_DEV + 1;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetMemUceInfo(_,_))
.WillOnce(Invoke(rtGetMemUceInfo_invoke));
aclError ret = aclrtGetMemUceInfo(deviceId, memUceInfoArray, arraySize, &arraySize);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, get_mem_uce_info_failed_with_rts_error)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[RT_MAX_RECORD_PA_NUM_PER_DEV];
size_t arraySize = RT_MAX_RECORD_PA_NUM_PER_DEV;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetMemUceInfo(_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtGetMemUceInfo(deviceId, memUceInfoArray, arraySize, &arraySize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, set_device_task_abort_success)
{
int32_t deviceId = 0;
uint32_t timeOut = 100;
aclError ret = aclrtDeviceTaskAbort(deviceId, timeOut);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, set_device_task_abort_failed_with_rts_error)
{
int32_t deviceId = 0;
uint32_t timeOut = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceTaskAbort(_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtDeviceTaskAbort(deviceId, timeOut);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, mem_uce_repair_success)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[8];
size_t arraySize = 8;
for (size_t i = 0; i < arraySize; ++i) {
(void)memset_s(memUceInfoArray[i].reserved, UCE_INFO_RESERVED_SIZE, 0, UCE_INFO_RESERVED_SIZE);
}
aclError ret = aclrtMemUceRepair(deviceId, memUceInfoArray, arraySize);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, mem_uce_repair_failed_with_array_nullptr)
{
int32_t deviceId = 0;
size_t arraySize = 8;
aclError ret = aclrtMemUceRepair(deviceId, nullptr, arraySize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, mem_uce_repair_failed_with_nonzero_reserved_value)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[8];
size_t arraySize = 8;
for (size_t i = 0; i < arraySize; ++i) {
(void)memset_s(memUceInfoArray[i].reserved, UCE_INFO_RESERVED_SIZE, 0, UCE_INFO_RESERVED_SIZE);
memUceInfoArray[i].reserved[0] = 1;
}
aclError ret = aclrtMemUceRepair(deviceId, memUceInfoArray, arraySize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, mem_uce_repair_failed_with_invalid_array_size)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[RT_MAX_RECORD_PA_NUM_PER_DEV + 1];
size_t arraySize = RT_MAX_RECORD_PA_NUM_PER_DEV + 1;
aclError ret = aclrtMemUceRepair(deviceId, memUceInfoArray, arraySize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, mem_uce_repair_failed_with_rts_error)
{
int32_t deviceId = 0;
aclrtMemUceInfo memUceInfoArray[8] = {};
size_t arraySize = 8;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemUceRepair(_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtMemUceRepair(deviceId, memUceInfoArray, arraySize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, cmo_success)
{
void *devPtr = reinterpret_cast<void *>(0x01U);
size_t size = 1024UL;
aclrtStream stream = nullptr;
aclrtCmoType cmoType = ACL_RT_CMO_TYPE_PREFETCH;
aclError ret = aclrtCmoAsync(devPtr, size, cmoType, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, cmo_failed_with_null_address)
{
void *devPtr = nullptr;
size_t size = 1024UL;
aclrtStream stream = nullptr;
aclrtCmoType cmoType = ACL_RT_CMO_TYPE_PREFETCH;
aclError ret = aclrtCmoAsync(devPtr, size, cmoType, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, cmo_failed_with_zero_size)
{
void *devPtr = reinterpret_cast<void *>(0x01U);
size_t size = 0UL;
aclrtStream stream = nullptr;
aclrtCmoType cmoType = ACL_RT_CMO_TYPE_PREFETCH;
aclError ret = aclrtCmoAsync(devPtr, size, cmoType, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, cmo_failed_with_rts_error)
{
void *devPtr = reinterpret_cast<void *>(0x01U);
size_t size = 1024UL;
aclrtStream stream = nullptr;
aclrtCmoType cmoType = ACL_RT_CMO_TYPE_PREFETCH;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCmoAsync(_,_,_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtCmoAsync(devPtr, size, cmoType, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtPeekAtLastError)
{
int32_t level_invalid = 1;
auto ret = aclrtPeekAtLastError(static_cast<aclrtLastErrLevel>(level_invalid));
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtLastErrLevel level = ACL_RT_THREAD_LEVEL;
ret = aclrtPeekAtLastError(level);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetLastError)
{
int32_t level_invalid = 1;
auto ret = aclrtGetLastError(static_cast<aclrtLastErrLevel>(level_invalid));
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtLastErrLevel level = ACL_RT_THREAD_LEVEL;
ret = aclrtGetLastError(level);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyAsyncWithDesc_failed_with_invalid_args)
{
auto ret = aclrtMemcpyAsyncWithDesc(nullptr, ACL_MEMCPY_HOST_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto desc = reinterpret_cast<void *>(0x1000U);
ret = aclrtMemcpyAsyncWithDesc(desc, ACL_MEMCPY_HOST_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyAsyncWithDesc(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto stream = reinterpret_cast<aclrtStream>(0x4000U);;
ret = aclrtMemcpyAsyncWithDesc(desc, ACL_MEMCPY_HOST_TO_HOST, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
desc = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyAsyncWithOffset)
{
auto ret = aclrtMemcpyAsyncWithOffset(nullptr, 0, 0, nullptr, 0, 0, ACL_MEMCPY_INNER_DEVICE_TO_DEVICE, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyAsyncWithOffset(nullptr, 0, 0, nullptr, 0, 0, ACL_MEMCPY_HOST_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsyncWithOffset(_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMemcpyAsyncWithOffset(nullptr, 0, 0, nullptr, 1, 0, ACL_MEMCPY_INNER_DEVICE_TO_DEVICE, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsyncWithOffset(_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
ret = aclrtMemcpyAsyncWithOffset(nullptr, 0, 0, nullptr, 1, 0, ACL_MEMCPY_INNER_DEVICE_TO_DEVICE, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsyncWithOffset(_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMemcpyAsyncWithOffset(nullptr, 0, 0, nullptr, 1, 0, ACL_MEMCPY_HOST_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsyncWithOffset(_,_,_,_,_,_,_,_))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyAsyncWithOffset(nullptr, 0, 0, nullptr, 1, 0, ACL_MEMCPY_HOST_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyAsyncWithDesc_success)
{
auto desc = reinterpret_cast<void *>(0x1000U);
auto stream = reinterpret_cast<aclrtStream>(0x4000U);;
const auto ret = aclrtMemcpyAsyncWithDesc(desc, ACL_MEMCPY_HOST_TO_HOST, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
desc = nullptr;
stream = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtGetMemcpyDescSize_failed_with_invalid_args)
{
size_t descSize = 0U;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetMemcpyDescSize(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
const auto ret = aclrtGetMemcpyDescSize(ACL_MEMCPY_HOST_TO_HOST, &descSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetMemcpyDescSize_success)
{
size_t descSize = 0U;
auto ret = aclrtGetMemcpyDescSize(ACL_MEMCPY_HOST_TO_HOST, &descSize);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetMemcpyDesc_failed_with_invalid_args)
{
auto ret = aclrtSetMemcpyDesc(nullptr, ACL_MEMCPY_HOST_TO_HOST, nullptr, nullptr, 0U, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto desc = reinterpret_cast<void *>(0x1000U);
ret = aclrtSetMemcpyDesc(desc, ACL_MEMCPY_HOST_TO_HOST, nullptr, nullptr, 0U, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto srcAddr = reinterpret_cast<uint32_t *>(0x2000U);
ret = aclrtSetMemcpyDesc(desc, ACL_MEMCPY_HOST_TO_HOST, srcAddr, nullptr, 0U, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto *dstAddr = reinterpret_cast<uint32_t *>(0x3000U);
ret = aclrtSetMemcpyDesc(desc, ACL_MEMCPY_HOST_TO_HOST, srcAddr, dstAddr, 0U, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsSetMemcpyDesc(_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtSetMemcpyDesc(desc, ACL_MEMCPY_HOST_TO_HOST, srcAddr, dstAddr, 0x10U, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetMemcpyDesc_success)
{
auto desc = reinterpret_cast<void *>(0x1000U);
auto *srcAddr = reinterpret_cast<uint32_t *>(0x2000U);
auto *dstAddr = reinterpret_cast<uint32_t *>(0x3000U);
uint64_t count = 0x10U;
const auto ret = aclrtSetMemcpyDesc(desc, ACL_MEMCPY_HOST_TO_HOST, srcAddr, dstAddr, count, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
desc = srcAddr = dstAddr = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryLoadFromFile_failed_with_invalid_args)
{
aclrtBinHandle binHandle = nullptr;
auto ret = aclrtBinaryLoadFromFile(nullptr, nullptr, &binHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsBinaryLoadFromFile(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
const char *binPath = "./binary/add.json";
ret = aclrtBinaryLoadFromFile(binPath, nullptr, &binHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryLoadFromFile_success)
{
const char *binPath = "./binary/add.json";
auto *options = reinterpret_cast<aclrtBinaryLoadOptions *>(0x1000U);
aclrtBinHandle binHandle = nullptr;
const auto ret = aclrtBinaryLoadFromFile(binPath, options, &binHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
options = nullptr;
}
TEST_F(UTEST_ACL_Runtime, binary_get_dev_address_failed)
{
void *binAddr = nullptr;
size_t binSize = 0U;
auto ret = aclrtBinaryGetDevAddress(nullptr, &binAddr, &binSize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsBinaryGetDevAddress(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto binHandle = reinterpret_cast<aclrtBinHandle>(0x1000U);
ret = aclrtBinaryGetDevAddress(binHandle, &binAddr, &binSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
binHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, binary_get_dev_address_success)
{
auto binHandle = reinterpret_cast<aclrtBinHandle>(0x1000U);
size_t binSize = 0U;
void *binAddr = nullptr;
auto ret = aclrtBinaryGetDevAddress(binHandle, &binAddr, &binSize);
EXPECT_EQ(ret, ACL_SUCCESS);
binHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, mem_set_access_failed)
{
void *virPtr = nullptr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemSetAccess(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
auto ret = aclrtMemSetAccess(virPtr, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
ret = aclrtMemSetAccess(virPtr, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, mem_get_access_failed)
{
void *virPtr = nullptr;
size_t size = 1;
aclError ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(virPtr, nullptr);
aclrtMemLocation location;
location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
location.id = 1U;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemGetAccess(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
uint64_t flag = 0U;
ret = aclrtMemGetAccess(virPtr, &location, &flag);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, mem_set_access_success)
{
void *virPtr = nullptr;
size_t size = 1;
aclError ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(virPtr, nullptr);
aclrtDrvMemHandle handle = nullptr;
aclrtPhysicalMemProp prop = {};
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
prop.memAttr = ACL_HBM_MEM_HUGE;
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.location.id = 0;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
ret = aclrtMapMem(virPtr, size, 0, handle, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtMemAccessFlags flags = ACL_RT_MEM_ACCESS_FLAGS_NONE;
aclrtMemLocation location;
location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
location.id = 1U;
aclrtMemAccessDesc desc[1];
desc[0].flags = flags;
desc[0].location = location;
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemAccessDesc::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
desc[0].rsv[i] = 0U;
}
ret = aclrtMemSetAccess(virPtr, size, desc, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtUnmapMem(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFreePhysical(handle);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtReleaseMemAddress(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, mem_set_get_access_success)
{
void *virPtr = nullptr;
size_t size = 1;
aclError ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(virPtr, nullptr);
aclrtMemAccessFlags flags = ACL_RT_MEM_ACCESS_FLAGS_NONE;
aclrtMemLocation location;
location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
location.id = 1U;
aclrtMemAccessDesc desc[1];
desc[0].flags = flags;
desc[0].location = location;
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemAccessDesc::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
desc[0].rsv[i] = 0U;
}
ret = aclrtMemSetAccess(virPtr, size, desc, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
uint64_t flag = 0U;
ret = aclrtMemGetAccess(virPtr, &location, &flag);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtReleaseMemAddress(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetFunctionByEntry_failed_with_invalid_args)
{
aclrtFuncHandle funcHandle = nullptr;
auto ret = aclrtBinaryGetFunctionByEntry(nullptr, 0U, &funcHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsFuncGetByEntry(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto binHandle = reinterpret_cast<aclrtBinHandle>(0x1000U);
ret = aclrtBinaryGetFunctionByEntry(binHandle, 0U, &funcHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
binHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetFunctionByEntry_success)
{
auto binHandle = reinterpret_cast<aclrtBinHandle>(0x1000U);
aclrtFuncHandle funcHandle = nullptr;
auto ret = aclrtBinaryGetFunctionByEntry(binHandle, 0U, &funcHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
binHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFunctionAddr_failed_with_invalid_args)
{
void *aicAddr = nullptr;
void *aivAddr = nullptr;
auto ret = aclrtGetFunctionAddr(nullptr, &aicAddr, &aivAddr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsFuncGetAddr(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
ret = aclrtGetFunctionAddr(funcHandle, &aicAddr, &aivAddr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFunctionAddr_success)
{
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
void *aicAddr = nullptr;
void *aivAddr = nullptr;
const auto ret = aclrtGetFunctionAddr(funcHandle, &aicAddr, &aivAddr);
EXPECT_EQ(ret, ACL_SUCCESS);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFunctionSize_failed_with_invalid_args)
{
size_t aicSize = 0;
size_t aivSize = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFuncGetSize(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
const auto ret = aclrtGetFunctionSize(funcHandle, &aicSize, &aivSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFunctionSize_success)
{
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
size_t aicSize = 0;
size_t aivSize = 0;
const auto ret = aclrtGetFunctionSize(funcHandle, &aicSize, &aivSize);
EXPECT_EQ(ret, ACL_SUCCESS);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtLaunchKernelWithConfig_failed_with_invalid_args)
{
auto ret = aclrtLaunchKernelWithConfig(nullptr, 0U, nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
ret = aclrtLaunchKernelWithConfig(funcHandle, 0U, nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtLaunchKernelWithConfig(funcHandle, 0x10U, nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchKernelWithConfig(_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x3000U);
ret = aclrtLaunchKernelWithConfig(funcHandle, 0x10U, nullptr, nullptr, argsHandle, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
funcHandle = argsHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtLaunchKernelWithConfig_failed_with_invalid_func)
{
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchKernelWithConfig(_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_INVALID_HANDLE));
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x3000U);
auto ret = aclrtLaunchKernelWithConfig(funcHandle, 0x10U, nullptr, nullptr, argsHandle, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_HANDLE);
funcHandle = argsHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtLaunchKernelWithConfig_success)
{
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
aclrtLaunchKernelCfg cfg;
cfg.numAttrs = 1U;
aclrtLaunchKernelAttr attrs[cfg.numAttrs];
attrs[0U].id = ACL_RT_LAUNCH_KERNEL_ATTR_SCHEM_MODE;
aclrtLaunchKernelAttrValue value;
value.schemMode = 1U;
attrs[0U].value = value;
cfg.attrs = attrs;
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x4000U);
const auto ret = aclrtLaunchKernelWithConfig(funcHandle, 0x10U, nullptr, &cfg, argsHandle, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
funcHandle = argsHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsInit_failed_with_invalid_args)
{
aclrtArgsHandle argsHandle = nullptr;
auto ret = aclrtKernelArgsInit(nullptr, &argsHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsInit(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
ret = aclrtKernelArgsInit(funcHandle, &argsHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsInit_success) {
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
aclrtArgsHandle argsHandle = nullptr;
const auto ret = aclrtKernelArgsInit(funcHandle, &argsHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsInitByUserMem_failed_with_invalid_args)
{
auto ret = aclrtKernelArgsInitByUserMem(nullptr, nullptr, nullptr, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
ret = aclrtKernelArgsInitByUserMem(funcHandle, nullptr, nullptr, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x2000U);
ret = aclrtKernelArgsInitByUserMem(funcHandle, argsHandle, nullptr, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto *userHostMem = reinterpret_cast<void *>(0x3000U);
ret = aclrtKernelArgsInitByUserMem(funcHandle, argsHandle, userHostMem, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsInitByUserMem(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtKernelArgsInitByUserMem(funcHandle, argsHandle, userHostMem, 0x10U);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
funcHandle = argsHandle = userHostMem = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsInitByUserMem_success)
{
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x2000U);
auto *userHostMem = reinterpret_cast<void *>(0x3000U);
const auto ret = aclrtKernelArgsInitByUserMem(funcHandle, argsHandle, userHostMem, 0x10U);
EXPECT_EQ(ret, ACL_SUCCESS);
funcHandle = argsHandle = userHostMem = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsFinalize_failed_with_invalid_args)
{
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsFinalize(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
const auto ret = aclrtKernelArgsFinalize(argsHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
argsHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsFinalize_success) {
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
const auto ret = aclrtKernelArgsFinalize(argsHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
argsHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsAppend_failed_with_invalid_args)
{
aclrtParamHandle paramHandle = nullptr;
auto ret = aclrtKernelArgsAppend(nullptr, nullptr, 0U, ¶mHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
ret = aclrtKernelArgsAppend(argsHandle, nullptr, 0U, ¶mHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto *para = reinterpret_cast<void *>(0x2000U);
ret = aclrtKernelArgsAppend(argsHandle, para, 0U, ¶mHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsAppend(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtKernelArgsAppend(argsHandle, para, 0x10U, ¶mHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
argsHandle = para = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsAppend_success)
{
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
auto *para = reinterpret_cast<void *>(0x2000U);
aclrtParamHandle paramHandle = nullptr;
const auto ret = aclrtKernelArgsAppend(argsHandle, para, 1U, ¶mHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
argsHandle = para = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsAppendPlaceHolder_failed_with_invalid_args)
{
aclrtParamHandle paramHandle = nullptr;
auto ret = aclrtKernelArgsAppendPlaceHolder(nullptr, ¶mHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsAppendPlaceHolder(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
ret = aclrtKernelArgsAppendPlaceHolder(argsHandle, ¶mHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
argsHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsAppendPlaceHolder_success)
{
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
aclrtParamHandle paramHandle = nullptr;
const auto ret = aclrtKernelArgsAppendPlaceHolder(argsHandle, ¶mHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
argsHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsGetPlaceHolderBuffer_failed_with_invalid_args)
{
void *bufferAddr = nullptr;
auto ret = aclrtKernelArgsGetPlaceHolderBuffer(nullptr, nullptr, 0U, &bufferAddr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
ret = aclrtKernelArgsGetPlaceHolderBuffer(argsHandle, nullptr, 0U, &bufferAddr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto paramHandle = reinterpret_cast<aclrtArgsHandle>(0x2000U);
ret = aclrtKernelArgsGetPlaceHolderBuffer(argsHandle, paramHandle, 0U, &bufferAddr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsGetPlaceHolderBuffer(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtKernelArgsGetPlaceHolderBuffer(argsHandle, paramHandle, 0x10U, &bufferAddr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
argsHandle = paramHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsGetPlaceHolderBuffer_success)
{
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
auto paramHandle = reinterpret_cast<aclrtArgsHandle>(0x2000U);
void *bufferAddr = nullptr;
auto ret = aclrtKernelArgsGetPlaceHolderBuffer(argsHandle, paramHandle, 0x10U, &bufferAddr);
EXPECT_EQ(ret, ACL_SUCCESS);
argsHandle = paramHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsGetHandleMemSize_failed_with_invalid_args)
{
size_t memSize = 0U;
auto ret = aclrtKernelArgsGetHandleMemSize(nullptr, &memSize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsGetHandleMemSize(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
ret = aclrtKernelArgsGetHandleMemSize(funcHandle, &memSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsGetHandleMemSize_success)
{
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
size_t memSize = 0U;
const auto ret = aclrtKernelArgsGetHandleMemSize(funcHandle, &memSize);
EXPECT_EQ(ret, ACL_SUCCESS);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsGetMemSize_Failed_invalid_args)
{
size_t actualArgsSize = 0U;
auto ret = aclrtKernelArgsGetMemSize(nullptr, 0U, &actualArgsSize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsGetMemSize(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
ret = aclrtKernelArgsGetMemSize(funcHandle, 0x10U, &actualArgsSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsGetMemSize_success)
{
auto funcHandle = reinterpret_cast<aclrtFuncHandle>(0x1000U);
size_t actualArgsSize = 0U;
const auto ret = aclrtKernelArgsGetMemSize(funcHandle, 0x10U, &actualArgsSize);
EXPECT_EQ(ret, ACL_SUCCESS);
funcHandle = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsParaUpdate_failed_with_invalid_args)
{
auto ret = aclrtKernelArgsParaUpdate(nullptr, nullptr, nullptr, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
ret = aclrtKernelArgsParaUpdate(argsHandle, nullptr, nullptr, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto paramHandle = reinterpret_cast<aclrtParamHandle>(0x2000U);
ret = aclrtKernelArgsParaUpdate(argsHandle, paramHandle, nullptr, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
auto *para = reinterpret_cast<void *>(0x3000U);
ret = aclrtKernelArgsParaUpdate(argsHandle, paramHandle, para, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsKernelArgsParaUpdate(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtKernelArgsParaUpdate(argsHandle, paramHandle, para, 0x10U);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
argsHandle = paramHandle = para = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtKernelArgsParaUpdate_success)
{
auto argsHandle = reinterpret_cast<aclrtArgsHandle>(0x1000U);
auto paramHandle = reinterpret_cast<aclrtParamHandle>(0x2000U);
auto *para = reinterpret_cast<void *>(0x3000U);
auto ret = aclrtKernelArgsParaUpdate(argsHandle, paramHandle, para, 0x10U);
EXPECT_EQ(ret, ACL_SUCCESS);
argsHandle = paramHandle = para = nullptr;
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocWithCfg_with_null_addr)
{
size_t size = 1024U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
auto ret = aclrtMallocWithCfg(nullptr, size, policy, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocWithCfg_with_invalid_size_0)
{
void *devPtr = nullptr;
size_t size = 0U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
auto ret = aclrtMallocWithCfg(&devPtr, size, policy, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocWithCfg_succ_without_cfg)
{
void *devPtr = nullptr;
size_t size = 1024U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
auto ret = aclrtMallocWithCfg(&devPtr, size, policy, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtMallocConfig cfg = {nullptr, 0U};
ret = aclrtMallocWithCfg(&devPtr, size, policy, &cfg);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocWithCfg_succ_without_advise)
{
void *devPtr = nullptr;
size_t size = 1024U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
aclrtMallocAttribute attrs;
attrs.attr = ACL_RT_MEM_ATTR_MODULE_ID;
attrs.value.moduleId = APP_MODE_ID;
aclrtMallocConfig cfg = {&attrs, 1U};
auto ret = aclrtMallocWithCfg(&devPtr, size, policy, &cfg);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocWithCfg_fail_with_rts_error)
{
void *devPtr = nullptr;
size_t size = 1024U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMalloc(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillRepeatedly(Return(RT_ERROR_NONE));
auto ret = aclrtMallocWithCfg(&devPtr, size, policy, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocWithCfg_with_invalid_cfg_num)
{
void *devPtr = nullptr;
size_t size = 1024U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
aclrtMallocConfig cfg = {nullptr, 1U};
auto ret = aclrtMallocWithCfg(&devPtr, size, policy, &cfg);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocForTaskScheduler_succ_without_cfg)
{
void *devPtr = nullptr;
size_t size = 1024U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
auto ret = aclrtMallocForTaskScheduler(&devPtr, size, policy, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocForTaskScheduler_succ_whith_cfg02)
{
void *devPtr = nullptr;
size_t size = 1024U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
aclrtMallocAttribute attrs;
attrs.attr = ACL_RT_MEM_ATTR_MODULE_ID;
attrs.value.moduleId = APP_MODE_ID;
aclrtMallocConfig cfg = {&attrs, 1U};
auto ret = aclrtMallocForTaskScheduler(&devPtr, size, policy, &cfg);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocForTaskScheduler_fail_with_rts_error)
{
void *devPtr = nullptr;
size_t size = 1024U;
aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMalloc(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillRepeatedly(Return(RT_ERROR_NONE));
auto ret = aclrtMallocForTaskScheduler(&devPtr, size, policy, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocHostWithCfg_succ_without_cfg)
{
void *hostPtr;
uint64_t size = 1024U;
auto ret = aclrtMallocHostWithCfg(&hostPtr, size, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocHostWithCfg_succ_with_cfg)
{
void *hostPtr;
uint64_t size = 1024U;
aclrtMallocAttribute attrs;
attrs.attr = ACL_RT_MEM_ATTR_MODULE_ID;
attrs.value.moduleId = APP_MODE_ID;
aclrtMallocConfig cfg = {&attrs, 1U};
auto ret = aclrtMallocHostWithCfg(&hostPtr, size, &cfg);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocHostWithCfg_fail_with_invalid_addr)
{
uint64_t size = 1024U;
auto ret = aclrtMallocHostWithCfg(nullptr, size, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocHostWithCfg_fail_with_invalid_0_size)
{
void *hostPtr;
uint64_t size = 0U;
auto ret = aclrtMallocHostWithCfg(&hostPtr, size, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMallocHostWithCfg_fail_with_rts_error)
{
void *hostPtr;
uint64_t size = 1024U;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMallocHost(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID))
.WillRepeatedly(Return(RT_ERROR_NONE));
auto ret = aclrtMallocHostWithCfg(&hostPtr, size, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtPointerGetAttributes_succ)
{
void *ptr = (void*)0xff;
aclrtPtrAttributes attributes;
auto ret = aclrtPointerGetAttributes(ptr, &attributes);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtPointerGetAttributes_failed01)
{
void *ptr = nullptr;
aclrtPtrAttributes attributes;
auto ret = aclrtPointerGetAttributes(ptr, &attributes);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtPointerGetAttributes_failed02)
{
void *ptr = (void*)0xff;
aclrtPtrAttributes attributes;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_,_))
.WillOnce(Return(ACL_ERROR_RT_FAILURE));
auto ret = aclrtPointerGetAttributes(ptr, &attributes);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostRegister_succ)
{
void *ptr = (void*)0xff;
uint64_t size = 1024UL;
aclrtHostRegisterType type = {};
void *devPtr = nullptr;
auto ret = aclrtHostRegister(ptr, size, type, &devPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostRegister_failed01)
{
void *ptr = nullptr;
uint64_t size = 1024UL;
aclrtHostRegisterType type = {};
void *devPtr = nullptr;
auto ret = aclrtHostRegister(ptr, size, type, &devPtr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostRegister_failed02)
{
void *ptr = (void*)0xff;
uint64_t size = 0UL;
aclrtHostRegisterType type = {};
void *devPtr = nullptr;
auto ret = aclrtHostRegister(ptr, size, type, &devPtr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostRegister_failed03)
{
void *ptr = (void*)0xff;
uint64_t size = 1024UL;
aclrtHostRegisterType type = {};
void *devPtr = nullptr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsHostRegister(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_FAILURE));
auto ret = aclrtHostRegister(ptr, size, type, &devPtr);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostUnregister_succ)
{
void *ptr = (void*)0xff;
auto ret = aclrtHostUnregister(ptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostUnregister_failed01)
{
void *ptr = nullptr;
auto ret = aclrtHostUnregister(ptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostUnregister_failed02)
{
void *ptr = (void*)0xff;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsHostUnregister(_))
.WillOnce(Return(ACL_ERROR_RT_FAILURE));
auto ret = aclrtHostUnregister(ptr);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostRegisterV2_succ)
{
void *ptr = (void*)0xff;
uint64_t size = 1024UL;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostRegisterV2(ptr, size, ACL_HOST_REG_MAPPED))
.WillOnce(Return(ACL_SUCCESS));
uint32_t flag = ACL_HOST_REG_MAPPED;
auto ret = aclrtHostRegisterV2(ptr, size, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostRegisterV2(ptr, size, ACL_HOST_REG_PINNED))
.WillOnce(Return(ACL_SUCCESS));
flag = ACL_HOST_REG_PINNED;
ret = aclrtHostRegisterV2(ptr, size, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostRegisterV2(ptr, size, ACL_HOST_REG_IOMEMORY))
.WillOnce(Return(ACL_SUCCESS));
flag = ACL_HOST_REG_IOMEMORY;
ret = aclrtHostRegisterV2(ptr, size, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostRegisterV2(ptr, size, ACL_HOST_REG_READONLY))
.WillOnce(Return(ACL_SUCCESS));
flag = ACL_HOST_REG_READONLY;
ret = aclrtHostRegisterV2(ptr, size, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(),
rtHostRegisterV2(ptr, size, ACL_HOST_REG_IOMEMORY | ACL_HOST_REG_READONLY))
.WillOnce(Return(ACL_SUCCESS));
flag = ACL_HOST_REG_IOMEMORY | ACL_HOST_REG_READONLY;
ret = aclrtHostRegisterV2(ptr, size, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostRegisterV2_failed01)
{
void *ptr = nullptr;
uint64_t size = 1024UL;
uint32_t flag = ACL_HOST_REG_MAPPED;
auto ret = aclrtHostRegisterV2(ptr, size, flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostRegisterV2_failed02)
{
void *ptr = (void*)0xff;
uint64_t size = 0UL;
uint32_t flag = ACL_HOST_REG_MAPPED;
auto ret = aclrtHostRegisterV2(ptr, size, flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostRegisterV2_failed03)
{
void *ptr = (void*)0xff;
uint64_t size = 1024UL;
uint32_t flag = ACL_HOST_REG_MAPPED;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostRegisterV2(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_FAILURE));
auto ret = aclrtHostRegisterV2(ptr, size, flag);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostGetDevicePointer_succ)
{
void *pHost = (void*)0xff;
void *pDevice = nullptr;
uint32_t flag = 0U;
auto ret = aclrtHostGetDevicePointer(pHost, &pDevice, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostGetDevicePointer_failed01)
{
void *pHost = nullptr;
void *pDevice = nullptr;
uint32_t flag = 0U;
auto ret = aclrtHostGetDevicePointer(pHost, &pDevice, flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostGetDevicePointer_failed02)
{
void *pHost = (void*)0xff;
void *pDevice = nullptr;
uint32_t flag = 1U;
auto ret = aclrtHostGetDevicePointer(pHost, &pDevice, flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostGetDevicePointer_failed03)
{
void *pHost = (void*)0xff;
void *pDevice = nullptr;
uint32_t flag = 0U;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostGetDevicePointer(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_FAILURE));
auto ret = aclrtHostGetDevicePointer(pHost, &pDevice, flag);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceInfo_hd_connect_type)
{
uint32_t deviceId = 0;
int64_t value = 0;
auto ret = aclrtGetDeviceInfo(deviceId, ACL_DEV_ATTR_HD_CONNECT_TYPE, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtGetDeviceInfo(deviceId, ACL_DEV_ATTR_HD_CONNECT_TYPE, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_TRUE(value >= ACL_HOST_DEVICE_CONNECT_TYPE_PCIE && value <= ACL_HOST_DEVICE_CONNECT_TYPE_UB);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostMemMapCapabilities_succ)
{
uint32_t deviceId = 0U;
aclrtHacType hacType = ACL_RT_HAC_TYPE_AIC;
aclrtHostMemMapCapability capabilities;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostMemMapCapabilities(_,_,_))
.WillOnce(Return(RT_ERROR_NONE));
auto ret = aclrtHostMemMapCapabilities(deviceId, hacType, &capabilities);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtHostMemMapCapabilities_failed)
{
uint32_t deviceId = 0U;
aclrtHacType hacType = ACL_RT_HAC_TYPE_AIC;
aclrtHostMemMapCapability capabilities;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostMemMapCapabilities(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto ret = aclrtHostMemMapCapabilities(deviceId, hacType, &capabilities);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetThreadLastTaskId_succ)
{
uint32_t taskId = 0;
auto ret = aclrtGetThreadLastTaskId(&taskId);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetThreadLastTaskId_failed)
{
uint32_t taskId = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetThreadLastTaskId(_))
.WillOnce(Return(ACL_ERROR_RT_FAILURE));
auto ret = aclrtGetThreadLastTaskId(&taskId);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamGetId_succ)
{
aclrtStream stream = (aclrtStream)0x01;
int32_t streamId = 0;
auto ret = aclrtStreamGetId(stream, &streamId);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtStreamGetId_failed)
{
aclrtStream stream = (aclrtStream)0x01;
int32_t streamId = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsStreamGetId(_,_))
.WillOnce(Return(ACL_ERROR_RT_FAILURE));
auto ret = aclrtStreamGetId(stream, &streamId);
EXPECT_EQ(ret, ACL_ERROR_RT_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtValueWrite_failed_with_invalid_args)
{
auto ret = aclrtValueWrite(nullptr, 100, 0, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsValueWrite(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto devAddr = reinterpret_cast<void *>(0x1000U);
ret = aclrtValueWrite(devAddr, 100, 0, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtValueWrite_success)
{
auto devAddr = reinterpret_cast<void *>(0x1000U);
const auto ret = aclrtValueWrite(devAddr, 100, 0, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtValueWait_failed_with_invalid_args)
{
auto ret = aclrtValueWait(nullptr, 100, ACL_STREAM_WAIT_VALUE_GEQ, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsValueWait(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
auto devAddr = reinterpret_cast<void *>(0x1000U);
ret = aclrtValueWait(devAddr, 100, ACL_STREAM_WAIT_VALUE_GEQ, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtValueWait_success)
{
auto devAddr = reinterpret_cast<void *>(0x1000U);
const auto ret = aclrtValueWait(devAddr, 100, ACL_STREAM_WAIT_VALUE_GEQ, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetStreamAvailableNum_failed_with_invalid_args)
{
auto ret = aclrtGetStreamAvailableNum(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsStreamGetAvailableNum(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
uint32_t streamCount = 0;
ret = aclrtGetStreamAvailableNum(&streamCount);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetStreamAvailableNum_success)
{
uint32_t streamCount = 0;
const auto ret = aclrtGetStreamAvailableNum(&streamCount);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamAttribute_failed_with_invalid_args)
{
aclrtStreamAttr stmAttrType = ACL_STREAM_ATTR_FAILURE_MODE;
auto ret = aclrtSetStreamAttribute(nullptr, stmAttrType, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtStream stream = (aclrtStream)0x01;
ret = aclrtSetStreamAttribute(stream, stmAttrType, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsStreamSetAttribute(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclrtStreamAttrValue value;
ret = aclrtSetStreamAttribute(stream, stmAttrType, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamAttribute_success)
{
aclrtStreamAttr stmAttrType = ACL_STREAM_ATTR_FAILURE_MODE;
aclrtStream stream = (aclrtStream)0x01;
aclrtStreamAttrValue value;
const auto ret = aclrtSetStreamAttribute(stream, stmAttrType, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetStreamAttribute_failed_with_invalid_args)
{
aclrtStreamAttr stmAttrType = ACL_STREAM_ATTR_FAILURE_MODE;
auto ret = aclrtGetStreamAttribute(nullptr, stmAttrType, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtStream stream = (aclrtStream)0x01;
ret = aclrtGetStreamAttribute(stream, stmAttrType, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsStreamGetAttribute(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclrtStreamAttrValue value;
ret = aclrtGetStreamAttribute(stream, stmAttrType, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetStreamAttribute_success)
{
aclrtStreamAttr stmAttrType = ACL_STREAM_ATTR_FAILURE_MODE;
aclrtStream stream = (aclrtStream)0x01;
aclrtStreamAttrValue value;
const auto ret = aclrtGetStreamAttribute(stream, stmAttrType, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateNotify_failed_with_invalid_args)
{
auto ret = aclrtCreateNotify(nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifyCreate(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclrtNotify notify = (aclrtNotify)0x01;
ret = aclrtCreateNotify(¬ify, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateNotify_success)
{
aclrtNotify notify = (aclrtNotify)0x01;
const auto ret = aclrtCreateNotify(¬ify, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyNotify_failed_with_invalid_args)
{
auto ret = aclrtDestroyNotify(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifyDestroy(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclrtNotify notify = (aclrtNotify)0x01;
ret = aclrtDestroyNotify(notify);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyNotify_success)
{
aclrtNotify notify = (aclrtNotify)0x01;
const auto ret = aclrtDestroyNotify(notify);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtCntNotifyCreate)
{
aclrtNotify cntNotify = nullptr;
auto ret = aclrtCntNotifyCreate(&cntNotify, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCntNotifyCreateServer(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCntNotifyCreate(&cntNotify, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCntNotifyDestroy)
{
aclrtNotify cntNotify = nullptr;
auto ret = aclrtCntNotifyDestroy(cntNotify);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCntNotifyDestroy(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCntNotifyDestroy(cntNotify);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtRecordNotify_failed_with_invalid_args)
{
auto ret = aclrtRecordNotify(nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifyRecord(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclrtNotify notify = (aclrtNotify)0x01;
ret = aclrtRecordNotify(notify, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtRecordNotify_success)
{
aclrtNotify notify = (aclrtNotify)0x01;
const auto ret = aclrtRecordNotify(notify, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtWaitAndResetNotify_failed_with_invalid_args)
{
auto ret = aclrtWaitAndResetNotify(nullptr, nullptr, 1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifyWaitAndReset(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclrtNotify notify = (aclrtNotify)0x01;
ret = aclrtWaitAndResetNotify(notify, nullptr, 1);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtWaitAndResetNotify_success)
{
aclrtNotify notify = (aclrtNotify)0x01;
const auto ret = aclrtWaitAndResetNotify(notify, nullptr, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetNotifyId_failed_with_invalid_args)
{
auto ret = aclrtGetNotifyId(nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtNotify notify = (aclrtNotify)0x01;
ret = aclrtGetNotifyId(notify, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifyGetId(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
uint32_t notifyId = 0;
ret = aclrtGetNotifyId(notify, ¬ifyId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetNotifyId_success)
{
aclrtNotify notify = (aclrtNotify)0x01;
uint32_t notifyId = 0;
const auto ret = aclrtGetNotifyId(notify, ¬ifyId);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetEventId_failed_with_invalid_args)
{
auto ret = aclrtGetEventId(nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
aclrtEvent event = (aclrtEvent)0x01;
ret = aclrtGetEventId(event, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsEventGetId(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
uint32_t eventId = 0;
ret = aclrtGetEventId(event, &eventId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetEventId_success)
{
aclrtEvent event = (aclrtEvent)0x01;
uint32_t eventId = 0;
const auto ret = aclrtGetEventId(event, &eventId);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetEventAvailNum_failed_with_invalid_args)
{
auto ret = aclrtGetEventAvailNum(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsEventGetAvailNum(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
uint32_t eventCount = 0;
ret = aclrtGetEventAvailNum(&eventCount);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetEventAvailNum_success)
{
uint32_t eventCount = 0;
const auto ret = aclrtGetEventAvailNum(&eventCount);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceInfo_failed_with_invalid_args)
{
uint32_t deviceId = 0;
aclrtDevAttr attr = ACL_DEV_ATTR_AICPU_CORE_NUM;
auto ret = aclrtGetDeviceInfo(deviceId, attr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsDeviceGetInfo(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
int64_t value = 0;
ret = aclrtGetDeviceInfo(deviceId, attr, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceInfo_success)
{
uint32_t deviceId = 0;
aclrtDevAttr attr = ACL_DEV_ATTR_AICPU_CORE_NUM;
int64_t value = 0;
const auto ret = aclrtGetDeviceInfo(deviceId, attr, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceInfo_npu_arch_failed_with_invalid_args)
{
uint32_t deviceId = 0;
auto ret = aclrtGetDeviceInfo(deviceId, ACL_DEV_ATTR_NPU_ARCH, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsDeviceGetInfo(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
int64_t value = 0;
ret = aclrtGetDeviceInfo(deviceId, ACL_DEV_ATTR_NPU_ARCH, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceInfo_npu_arch_success)
{
uint32_t deviceId = 0;
int64_t value = 0;
const auto ret = aclrtGetDeviceInfo(deviceId, ACL_DEV_ATTR_NPU_ARCH, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtDeviceGetStreamPriorityRange_success)
{
int32_t leastPriority = 0;
int32_t greatestPriority = 0;
auto ret = aclrtDeviceGetStreamPriorityRange(&leastPriority, &greatestPriority);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtDeviceGetStreamPriorityRange(nullptr, &greatestPriority);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtDeviceGetStreamPriorityRange(&leastPriority, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtDeviceGetStreamPriorityRange(nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceCapability_failed_with_invalid_args)
{
int32_t deviceId = 0;
aclrtDevFeatureType devFeatureType = ACL_FEATURE_TSCPU_TASK_UPDATE_SUPPORT_AIC_AIV;
auto ret = aclrtGetDeviceCapability(deviceId, devFeatureType, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsDeviceGetCapability(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
int32_t value = 0;
ret = aclrtGetDeviceCapability(deviceId, devFeatureType, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceCapability_success)
{
int32_t deviceId = 0;
aclrtDevFeatureType devFeatureType = ACL_FEATURE_TSCPU_TASK_UPDATE_SUPPORT_AIC_AIV;
int32_t value = 0;
const auto ret = aclrtGetDeviceCapability(deviceId, devFeatureType, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtDeviceGetUuid_failed_with_invalid_args)
{
int32_t deviceId = 0;
aclrtUuid uuid = {0};
auto ret = aclrtDeviceGetUuid(deviceId, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDeviceUuid(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtDeviceGetUuid(deviceId, &uuid);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtDeviceGetUuid_feature_not_support)
{
int32_t deviceId = 0;
aclrtUuid uuid = {0};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDeviceUuid(_, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
const auto ret = aclrtDeviceGetUuid(deviceId, &uuid);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtDeviceGetUuid_success)
{
int32_t deviceId = 0;
aclrtUuid uuid = {0};
const auto ret = aclrtDeviceGetUuid(deviceId, &uuid);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtCtxGetCurrentDefaultStream_failed_with_invalid_args)
{
auto ret = aclrtCtxGetCurrentDefaultStream(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsCtxGetCurrentDefaultStream(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclrtStream stream = (aclrtStream)0x01;
ret = aclrtCtxGetCurrentDefaultStream(&stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCtxGetCurrentDefaultStream_success)
{
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtCtxGetCurrentDefaultStream(&stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetPrimaryCtxState_success)
{
int32_t devId = 0;
uint32_t *flags = nullptr;
int active = 0;
const auto ret = aclrtGetPrimaryCtxState(devId, flags, &active);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGrimaryCtxState_iled_with_invliad_active)
{
int32_t devId = 0;
uint32_t *flags = nullptr;
const auto ret = aclrtGetPrimaryCtxState(devId, flags, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtGrimaryCtxState_iled_with_invliad_flags)
{
int32_t devId = 0;
uint32_t flags;
int active = 0;
const auto ret = aclrtGetPrimaryCtxState(devId, &flags, &active);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtGrimaryCtxState_iled_with_rts_error)
{
int32_t devId = 0;
uint32_t *flags = nullptr;
int active = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetPrimaryCtxState(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
const auto ret = aclrtGetPrimaryCtxState(devId, flags, &active);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIBuildBegin_failed_with_invalid_args)
{
auto ret = aclmdlRIBuildBegin(nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsModelCreate(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclmdlRI modelRI = (aclmdlRI)0x01;
ret = aclmdlRIBuildBegin(&modelRI, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIBuildBegin_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
const auto ret = aclmdlRIBuildBegin(&modelRI, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIBindStream_failed_with_invalid_args)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
auto ret = aclmdlRIBindStream(nullptr, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsModelBindStream(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIBindStream(modelRI, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIBindStream_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclmdlRIBindStream(modelRI, stream, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIEndTask_failed_with_invalid_args)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
auto ret = aclmdlRIEndTask(nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsEndGraph(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIEndTask(modelRI, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIEndTask_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
const auto ret = aclmdlRIEndTask(modelRI, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIBuildEnd_failed_with_invalid_args)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
void *reserve = (void *)0x01;
auto ret = aclmdlRIBuildEnd(nullptr, reserve);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclmdlRIBuildEnd(modelRI, reserve);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsModelLoadComplete(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIBuildEnd(modelRI, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIBuildEnd_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
const auto ret = aclmdlRIBuildEnd(modelRI, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIUnbindStream_failed_with_invalid_args)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
auto ret = aclmdlRIUnbindStream(nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsModelUnbindStream(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIUnbindStream(modelRI, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIUnbindStream_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
const auto ret = aclmdlRIUnbindStream(modelRI, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIExecute_failed_with_invalid_args)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
int32_t timeout = -1;
auto ret = aclmdlRIExecute(nullptr, timeout);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsModelExecute(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIExecute(modelRI, timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIExecute_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
int32_t timeout = -1;
const auto ret = aclmdlRIExecute(modelRI, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtReduceAsync_failed_with_invalid_args)
{
void *dst = reinterpret_cast<void *>(0x04);
void *src = reinterpret_cast<void *>(0x04);
void *reserve = (void *)0x01;
uint64_t count = 10;
aclrtReduceKind kind = ACL_RT_MEMCPY_SDMA_AUTOMATIC_SUM;
aclDataType type = ACL_INT8;
auto ret = aclrtReduceAsync(nullptr, nullptr, count, kind, type, nullptr, reserve);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtReduceAsync(dst, nullptr, count, kind, type, nullptr, reserve);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
type = ACL_DT_UNDEFINED;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, reserve);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchReduceAsyncTask(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
type = ACL_INT8;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtReduceAsync_success)
{
void *dst = reinterpret_cast<void *>(0x04);
void *src = reinterpret_cast<void *>(0x04);
uint64_t count = 10;
aclrtReduceKind kind = ACL_RT_MEMCPY_SDMA_AUTOMATIC_SUM;
aclDataType type = ACL_FLOAT;
auto ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_FLOAT16;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_INT16;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_INT4;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_INT8;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_INT32;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_BF16;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_UINT8;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_UINT16;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
type = ACL_UINT32;
ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtReduceAsync_failed_with_unsupported_data_type)
{
void *dst = reinterpret_cast<void *>(0x04);
void *src = reinterpret_cast<void *>(0x04);
uint64_t count = 10;
aclrtReduceKind kind = ACL_RT_MEMCPY_SDMA_AUTOMATIC_SUM;
aclDataType type = ACL_INT64;
auto ret = aclrtReduceAsync(dst, src, count, kind, type, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceResLimit_failed_with_invalid_args)
{
const int32_t deviceId = 0x01;
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
uint32_t value = 0;
auto ret = aclrtGetDeviceResLimit(deviceId, type, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetDeviceResLimit(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtGetDeviceResLimit(deviceId, type, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDeviceResLimit_success)
{
const int32_t deviceId = 0x01;
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
uint32_t value = 0;
const auto ret = aclrtGetDeviceResLimit(deviceId, type, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetDeviceResLimit_failed_with_invalid_args)
{
const int32_t deviceId = 0x01;
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
uint32_t value = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsSetDeviceResLimit(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
const auto ret = aclrtSetDeviceResLimit(deviceId, type, value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetDeviceResLimit_success)
{
const int32_t deviceId = 0x01;
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
uint32_t value = 0;
const auto ret = aclrtSetDeviceResLimit(deviceId, type, value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetDeviceResLimit_failed_with_invalid_args)
{
const int32_t deviceId = 0x01;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsResetDeviceResLimit(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
const auto ret = aclrtResetDeviceResLimit(deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetDeviceResLimit_success)
{
const int32_t deviceId = 0x01;
const auto ret = aclrtResetDeviceResLimit(deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetStreamResLimit_failed_with_invalid_args)
{
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
aclrtStream stream = (aclrtStream)0x01;
auto ret = aclrtGetStreamResLimit(stream, type, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetStreamResLimit(_,_,_))
.WillRepeatedly(Return(ACL_ERROR_RT_PARAM_INVALID));
uint32_t value = 0;
ret = aclrtGetStreamResLimit(nullptr, type, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
stream = (aclrtStream)0x01;
ret = aclrtGetStreamResLimit(stream, type, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetStreamResLimit_success)
{
aclrtStream stream = (aclrtStream)0x01;
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
uint32_t value = 0;
const auto ret = aclrtGetStreamResLimit(stream, type, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamResLimit_failed_with_invalid_args)
{
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsSetStreamResLimit(_,_,_))
.WillRepeatedly(Return(ACL_ERROR_RT_PARAM_INVALID));
uint32_t value = 0;
auto ret = aclrtSetStreamResLimit(nullptr, type, value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
aclrtStream stream = (aclrtStream)0x01;
ret = aclrtSetStreamResLimit(stream, type, value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetStreamResLimit_success)
{
aclrtStream stream = (aclrtStream)0x01;
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
uint32_t value = 0;
const auto ret = aclrtSetStreamResLimit(stream, type, value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetStreamResLimit_failed_with_invalid_args)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsResetStreamResLimit(_))
.WillRepeatedly(Return(ACL_ERROR_RT_PARAM_INVALID));
auto ret = aclrtResetStreamResLimit(nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
aclrtStream stream = (aclrtStream)0x01;
ret = aclrtResetStreamResLimit(stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetStreamResLimit_success)
{
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtResetStreamResLimit(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtUseStreamResInCurrentThread_failed_with_invalid_args)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsUseStreamResInCurrentThread(_))
.WillRepeatedly(Return(ACL_ERROR_RT_PARAM_INVALID));
auto ret = aclrtUseStreamResInCurrentThread(nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
aclrtStream stream = (aclrtStream)0x01;
ret = aclrtUseStreamResInCurrentThread(stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtUseStreamResInCurrentThread_success)
{
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtUseStreamResInCurrentThread(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtUnuseStreamResInCurrentThread_failed_with_invalid_args)
{
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotUseStreamResInCurrentThread(_))
.WillRepeatedly(Return(ACL_ERROR_RT_PARAM_INVALID));
auto ret = aclrtUnuseStreamResInCurrentThread(nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
aclrtStream stream = (aclrtStream)0x01;
ret = aclrtUnuseStreamResInCurrentThread(stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtUnuseStreamResInCurrentThread_success)
{
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtUnuseStreamResInCurrentThread(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetResInCurrentThread_failed_with_invalid_args)
{
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
auto ret = aclrtGetResInCurrentThread(type, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetResInCurrentThread(_, _))
.WillRepeatedly(Return(ACL_ERROR_RT_PARAM_INVALID));
uint32_t value = 0;
ret = aclrtGetResInCurrentThread(type, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetResInCurrentThread_success)
{
aclrtDevResLimitType type = ACL_RT_DEV_RES_CUBE_CORE;
uint32_t value = 0;
const auto ret = aclrtGetResInCurrentThread(type, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRISetName_failed_with_invalid_args)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
const char *name = "name";
auto ret = aclmdlRISetName(nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclmdlRISetName(modelRI, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsModelSetName(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRISetName(modelRI, name);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRISetName_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
const char *name = "name";
const auto ret = aclmdlRISetName(modelRI, name);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIGetName_failed_with_invalid_args)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
constexpr uint32_t maxLen = 10;
char name[maxLen] = {0};
auto ret = aclmdlRIGetName(nullptr, maxLen, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclmdlRIGetName(modelRI, maxLen, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsModelGetName(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIGetName(modelRI, maxLen, name);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIGetName_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
constexpr uint32_t maxLen = 10;
char name[maxLen] = {0};
const auto ret = aclmdlRIGetName(modelRI, maxLen, name);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIGetId_failed_with_invalid_args)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
uint32_t modelRIId = 0;
auto ret = aclmdlRIGetId(nullptr, &modelRIId);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclmdlRIGetId(modelRI, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtModelGetId(_, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIGetId(modelRI, &modelRIId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIGetId_success)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
uint32_t modelRIId = 0;
const auto ret = aclmdlRIGetId(modelRI, &modelRIId);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateLabel_failed_with_invalid_args)
{
aclrtLabel label = (aclrtLabel)0x01;
auto ret = aclrtCreateLabel(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLabelCreate(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCreateLabel(&label);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateLabel_success)
{
aclrtLabel label = (aclrtLabel)0x01;
const auto ret = aclrtCreateLabel(&label);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetLabel_failed_with_invalid_args)
{
aclrtLabel label = (aclrtLabel)0x01;
aclrtStream stream = (aclrtStream)0x01;
auto ret = aclrtSetLabel(nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtSetLabel(label, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLabelSet(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtSetLabel(label, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetLabel_success)
{
aclrtLabel label = (aclrtLabel)0x01;
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtSetLabel(label, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyLabel_failed_with_invalid_args)
{
aclrtLabel label = (aclrtLabel)0x01;
auto ret = aclrtDestroyLabel(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLabelDestroy(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtDestroyLabel(label);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyLabel_success)
{
aclrtLabel label = (aclrtLabel)0x01;
const auto ret = aclrtDestroyLabel(label);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateLabelList_failed_with_invalid_args)
{
aclrtLabel label = (aclrtLabel)0x01;
size_t num = 1;
aclrtLabelList labelList = (aclrtLabelList)0x01;
auto ret = aclrtCreateLabelList(nullptr, num, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtCreateLabelList(&label, num, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLabelSwitchListCreate(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCreateLabelList(&label, num, &labelList);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCreateLabelList_success)
{
aclrtLabel label = (aclrtLabel)0x01;
size_t num = 1;
aclrtLabelList labelList = (aclrtLabelList)0x01;
const auto ret = aclrtCreateLabelList(&label, num, &labelList);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyLabelList_failed_with_invalid_args)
{
aclrtLabelList labelList = (aclrtLabelList)0x01;
auto ret = aclrtDestroyLabelList(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLabelSwitchListDestroy(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtDestroyLabelList(labelList);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtDestroyLabelList_success)
{
aclrtLabelList labelList = (aclrtLabelList)0x01;
const auto ret = aclrtDestroyLabelList(labelList);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSwitchLabelByIndex_failed_with_invalid_args)
{
void *ptr = (void*)0xff;
uint32_t maxValue = 1;
aclrtLabelList labelList = (aclrtLabelList)0x01;
aclrtStream stream = (aclrtStream)0x01;
auto ret = aclrtSwitchLabelByIndex(nullptr, maxValue, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtSwitchLabelByIndex(ptr, maxValue, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtSwitchLabelByIndex(ptr, maxValue, labelList, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLabelSwitchByIndex(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtSwitchLabelByIndex(ptr, maxValue, labelList, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSwitchLabelByIndex_success)
{
void *ptr = (void*)0xff;
uint32_t maxValue = 1;
aclrtLabelList labelList = (aclrtLabelList)0x01;
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtSwitchLabelByIndex(ptr, maxValue, labelList, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtActiveStream_failed_with_invalid_args)
{
aclrtStream activeStream = (aclrtStream)0x01;
aclrtStream stream = (aclrtStream)0x01;
auto ret = aclrtActiveStream(nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtActiveStream(activeStream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsActiveStream(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtActiveStream(activeStream, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtActiveStream_success)
{
aclrtStream activeStream = (aclrtStream)0x01;
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtActiveStream(activeStream, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtSwitchStream_failed_with_invalid_args)
{
void *leftValue = (void*)0xff;
aclrtCondition cond = ACL_RT_EQUAL;
void *rightValue = (void*)0xff;
aclrtCompareDataType dataType = ACL_RT_SWITCH_INT32;
aclrtStream trueStream = (aclrtStream)0x01;
aclrtStream falseStream = (aclrtStream)0x01;
aclrtStream stream = (aclrtStream)0x01;
auto ret = aclrtSwitchStream(nullptr, cond, nullptr, dataType, nullptr, falseStream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtSwitchStream(leftValue, cond, nullptr, dataType, nullptr, falseStream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtSwitchStream(leftValue, cond, rightValue, dataType, nullptr, falseStream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtSwitchStream(leftValue, cond, rightValue, dataType, trueStream, falseStream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtSwitchStream(leftValue, cond, rightValue, dataType, trueStream, falseStream, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsSwitchStream(_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtSwitchStream(leftValue, cond, rightValue, dataType, trueStream, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtSwitchStream_success)
{
void *leftValue = (void*)0xff;
aclrtCondition cond = ACL_RT_EQUAL;
void *rightValue = (void*)0xff;
aclrtCompareDataType dataType = ACL_RT_SWITCH_INT32;
aclrtStream trueStream = (aclrtStream)0x01;
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtSwitchStream(leftValue, cond, rightValue, dataType, trueStream, nullptr, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFunctionName_failed_with_invalid_args)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01;
constexpr uint32_t maxLen = 10;
char name[maxLen] = {0};
auto ret = aclrtGetFunctionName(nullptr, maxLen, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtGetFunctionName(funcHandle, maxLen, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsFuncGetName(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtGetFunctionName(funcHandle, maxLen, name);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFunctionName_success)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01;
constexpr uint32_t maxLen = 10;
char name[maxLen] = {0};
const auto ret = aclrtGetFunctionName(funcHandle, maxLen, name);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtAllocBuf_failed_with_invalid_args)
{
aclrtMbuf mbuf = nullptr;
uint64_t size = 1;
auto ret = aclrtAllocBuf(nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtAllocBuf(&mbuf, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMbufAlloc(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtAllocBuf(&mbuf, size);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_EQ(aclrtFreeBuf(mbuf), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtAllocBuf_success)
{
aclrtMbuf mbuf = nullptr;
size_t size = 1;
const auto ret = aclrtAllocBuf(&mbuf, size);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(aclrtFreeBuf(mbuf), ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetBufUserData_failed_with_size_offset_exceed_max)
{
aclrtMbuf mbuf = reinterpret_cast<aclrtMbuf>(0x01);
char data[100] = {0};
size_t size = 50;
size_t offset = 50;
auto ret = aclrtGetBufUserData(mbuf, data, size, offset);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetBufUserData_failed_with_size_offset_exceed_max)
{
aclrtMbuf mbuf = reinterpret_cast<aclrtMbuf>(0x01);
char data[100] = {0};
size_t size = 50;
size_t offset = 50;
auto ret = aclrtSetBufUserData(mbuf, data, size, offset);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetBufUserData_failed_when_memcpy_returns_error)
{
char privateData[96] = {0};
char data[1] = {0};
aclrtMbuf mbuf = reinterpret_cast<aclrtMbuf>(privateData);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMbufGetPrivInfo(_, _, _))
.WillOnce(DoAll(SetArgPointee<1>(privateData), SetArgPointee<2>(sizeof(privateData)),
Return(RT_ERROR_NONE)));
auto ret = aclrtGetBufUserData(mbuf, data, 0U, 0U);
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtSetBufUserData_failed_when_memcpy_returns_error)
{
char privateData[96] = {0};
char data[1] = {0};
aclrtMbuf mbuf = reinterpret_cast<aclrtMbuf>(privateData);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMbufGetPrivInfo(_, _, _))
.WillOnce(DoAll(SetArgPointee<1>(privateData), SetArgPointee<2>(sizeof(privateData)),
Return(RT_ERROR_NONE)));
auto ret = aclrtSetBufUserData(mbuf, data, 0U, sizeof(privateData));
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryLoadFromData_failed_with_invalid_args)
{
void *data = (void*)0x01;
size_t length = 1;
aclrtBinHandle *binHandle = (aclrtBinHandle*)0x01;
auto ret = aclrtBinaryLoadFromData(nullptr, length, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtBinaryLoadFromData(data, length, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsBinaryLoadFromData(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtBinaryLoadFromData(data, length, nullptr, binHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryLoadFromData_success)
{
void *data = (void*)0x01;
size_t length = 1;
aclrtBinHandle *binHandle = (aclrtBinHandle*)0x01;
const auto ret = aclrtBinaryLoadFromData(data, length, nullptr, binHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtRegisterCpuFunc_failed_with_invalid_args)
{
aclrtBinHandle handle = (aclrtBinHandle)0x01;
const char *funcName = "funcName";
const char *kernelName = "kernelName";
aclrtFuncHandle *funcHandle = (aclrtFuncHandle*)0x01;
auto ret = aclrtRegisterCpuFunc(nullptr, nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtRegisterCpuFunc(handle, nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtRegisterCpuFunc(handle, funcName, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtRegisterCpuFunc(handle, funcName, kernelName, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsRegisterCpuFunc(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtRegisterCpuFunc(handle, funcName, kernelName, funcHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtRegisterCpuFunc_success)
{
aclrtBinHandle handle = (aclrtBinHandle)0x01;
const char *funcName = "funcName";
const char *kernelName = "kernelName";
aclrtFuncHandle *funcHandle = (aclrtFuncHandle*)0x01;
const auto ret = aclrtRegisterCpuFunc(handle, funcName, kernelName, funcHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtCmoAsyncWithBarrier_failed_with_invalid_args)
{
void *src = (void*)0xff;
size_t size = 1;
aclrtCmoType cmoType = ACL_RT_CMO_TYPE_PREFETCH;
uint32_t barrierId = 1;
aclrtStream stream = (aclrtStream)0x01;
auto ret = aclrtCmoAsyncWithBarrier(nullptr, size, cmoType, barrierId, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsCmoAsyncWithBarrier(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCmoAsyncWithBarrier(src, size, cmoType, barrierId, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCmoAsyncWithBarrier_success)
{
void *src = (void*)0xff;
size_t size = 1;
aclrtCmoType cmoType = ACL_RT_CMO_TYPE_PREFETCH;
uint32_t barrierId = 1;
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtCmoAsyncWithBarrier(src, size, cmoType, barrierId, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtCmoWaitBarrier_failed_with_invalid_args)
{
aclrtBarrierTaskInfo taskInfo;
aclrtStream stream = (aclrtStream)0x01;
uint32_t flag = 0;
auto ret = aclrtCmoWaitBarrier(nullptr, stream, flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
taskInfo.barrierNum = 0U;
ret = aclrtCmoWaitBarrier(&taskInfo, stream, flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
taskInfo.barrierNum = 7U;
ret = aclrtCmoWaitBarrier(&taskInfo, stream, flag);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchBarrierTask(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
taskInfo.barrierNum = 1U;
ret = aclrtCmoWaitBarrier(&taskInfo, stream, flag);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCmoWaitBarrier_success)
{
aclrtBarrierTaskInfo taskInfo;
taskInfo.barrierNum = 1U;
uint32_t flag = 0;
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtCmoWaitBarrier(&taskInfo, stream, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDevicesTopo_failed_with_invalid_args)
{
uint32_t deviceId = 1;
uint32_t otherDeviceId = 2;
uint64_t value = 0;
auto ret = aclrtGetDevicesTopo(deviceId, otherDeviceId, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetPairDevicesInfo(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtGetDevicesTopo(deviceId, otherDeviceId, &value);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetDevicesTopo_success)
{
uint32_t deviceId = 1;
uint32_t otherDeviceId = 2;
uint64_t value = 0;
auto ret = aclrtGetDevicesTopo(deviceId, otherDeviceId, &value);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatch_failed_with_invalid_args)
{
constexpr size_t numBatches = 10UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1, 0, 1, 1, 1, 1, 1, 1, 1, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
aclrtMemcpyBatchAttr attrs;
size_t attrsIndexes = 0;
size_t numAttrs = 1;
size_t failIndex = 0;
auto ret = aclrtMemcpyBatch(nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr, numAttrs, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatch(dsts, nullptr, nullptr, nullptr, 0, nullptr, nullptr, numAttrs, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatch(dsts, destMax, nullptr, nullptr, 0, nullptr, nullptr, numAttrs, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatch(dsts, destMax, srcs, nullptr, 0, nullptr, nullptr, numAttrs, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, 0, nullptr, nullptr, numAttrs, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, 0, &attrs, nullptr, numAttrs, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, 0, &attrs, &attrsIndexes, numAttrs, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, 0, &attrs, &attrsIndexes, numAttrs, &failIndex);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
destMax[1] = 1;
attrs.rsv[0] = 1;
ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatch(_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
attrs.rsv[i] = 0U;
}
ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatch_success)
{
constexpr size_t numBatches = 10UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
aclrtMemcpyBatchAttr attrs;
size_t attrsIndexes = 0;
size_t numAttrs = 1;
size_t failIndex = 0;
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
attrs.rsv[i] = 0U;
}
const auto ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatch_success_with_all_zero_sizes)
{
constexpr size_t numBatches = 2UL;
void *dsts[numBatches] = {nullptr, nullptr};
size_t destMax[numBatches] = {0, 0};
void *srcs[numBatches] = {nullptr, nullptr};
size_t sizes[numBatches] = {0, 0};
aclrtMemcpyBatchAttr attrs = {};
size_t attrsIndexes = 0;
size_t failIndex = 0;
const auto ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, 1, &failIndex);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(failIndex, SIZE_MAX);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatch_success_with_mixed_zero_sizes)
{
constexpr size_t numBatches = 2UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {0, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {0, 1};
aclrtMemcpyBatchAttr attrs = {};
size_t attrsIndexes = 0;
constexpr size_t numAttrs = 1UL;
size_t failIndex = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatch(_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_SUCCESS));
auto ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatch(_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatch_feature_not_support)
{
constexpr size_t numBatches = 1UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1};
aclrtMemcpyBatchAttr attrs = {};
size_t attrsIndexes = 0;
constexpr size_t numAttrs = 1UL;
size_t failIndex = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatch(_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
auto ret = aclrtMemcpyBatch(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatchAsync(_,_,_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex,
nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatchAsync_failed_with_invalid_args)
{
constexpr size_t numBatches = 5UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1, 0, 1, 1, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1, 1, 1, 1, 1};
aclrtMemcpyBatchAttr attrs;
size_t attrsIndexes = 0;
size_t numAttrs = 1;
size_t failIndex = 0;
aclrtStream stream = nullptr;
auto ret = aclrtMemcpyBatchAsync(nullptr, nullptr, nullptr, nullptr, 0,nullptr, nullptr, numAttrs, nullptr,
stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsync(dsts, nullptr, nullptr, nullptr, 0, nullptr, nullptr, numAttrs, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsync(dsts, destMax, nullptr, nullptr, 0, nullptr, nullptr, numAttrs, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, nullptr, 0, nullptr, nullptr, numAttrs, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, 0, nullptr, nullptr, numAttrs, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, 0, &attrs, nullptr, numAttrs, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, 0, &attrs, &attrsIndexes, numAttrs, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, 0, &attrs, &attrsIndexes, numAttrs, &failIndex, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
destMax[1] = 1;
attrs.rsv[0] = 1;
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatchAsync(_,_,_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
attrs.rsv[i] = 0U;
}
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatchAsync_success)
{
constexpr size_t numBatches = 5UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1, 1, 1, 1, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1, 1, 1, 1, 1};
aclrtMemcpyBatchAttr attrs;
size_t attrsIndexes = 0;
size_t numAttrs = 1;
size_t failIndex = 0;
attrs.dstLoc.type = ACL_MEM_LOCATION_TYPE_DEVICE;
attrs.srcLoc.type = ACL_MEM_LOCATION_TYPE_DEVICE;
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
attrs.rsv[i] = 0U;
}
const auto ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs,
&failIndex, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatchAsync_success_with_all_zero_sizes)
{
constexpr size_t numBatches = 2UL;
void *dsts[numBatches] = {nullptr, nullptr};
size_t destMax[numBatches] = {0, 0};
void *srcs[numBatches] = {nullptr, nullptr};
size_t sizes[numBatches] = {0, 0};
aclrtMemcpyBatchAttr attrs = {};
size_t attrsIndexes = 0;
size_t failIndex = 0;
const auto ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, 1,
&failIndex, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(failIndex, SIZE_MAX);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatchAsync_success_with_mixed_zero_sizes)
{
constexpr size_t numBatches = 2UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {0, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {0, 1};
aclrtMemcpyBatchAttr attrs = {};
size_t attrsIndexes = 0;
constexpr size_t numAttrs = 1UL;
size_t failIndex = 0;
aclrtStream stream = nullptr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatchAsync(_,_,_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_SUCCESS));
auto ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs,
&failIndex, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatchAsync(_,_,_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMemcpyBatchAsync(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, &failIndex,
stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatchV2_failed_with_invalid_args)
{
constexpr size_t numBatches = 10UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1, 0, 1, 1, 1, 1, 1, 1, 1, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
aclrtMemcpyBatchAttr attrs;
size_t attrsIndexes = 0;
size_t numAttrs = 1;
auto ret = aclrtMemcpyBatchV2(nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchV2(dsts, nullptr, nullptr, nullptr, 0, nullptr, nullptr, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchV2(dsts, destMax, nullptr, nullptr, 0, nullptr, nullptr, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchV2(dsts, destMax, srcs, nullptr, 0, nullptr, nullptr, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchV2(dsts, destMax, srcs, sizes, 0, nullptr, nullptr, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchV2(dsts, destMax, srcs, sizes, 0, &attrs, nullptr, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchV2(dsts, destMax, srcs, sizes, 0, &attrs, &attrsIndexes, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchV2(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
destMax[1] = 1;
attrs.rsv[0] = 1;
ret = aclrtMemcpyBatchV2(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatch(_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
attrs.rsv[i] = 0U;
}
ret = aclrtMemcpyBatchV2(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatchV2_success)
{
constexpr size_t numBatches = 10UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
aclrtMemcpyBatchAttr attrs;
size_t attrsIndexes = 0;
size_t numAttrs = 1;
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
attrs.rsv[i] = 0U;
}
const auto ret = aclrtMemcpyBatchV2(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs);
EXPECT_EQ(ret, ACL_SUCCESS);
for(size_t i = 0; i < numBatches; ++i) {
sizes[i] = 0;
}
const auto ret_size_zero = aclrtMemcpyBatchV2(nullptr, nullptr, nullptr, sizes, numBatches, &attrs, &attrsIndexes, numAttrs);
EXPECT_EQ(ret_size_zero, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatchAsyncV2_failed_with_invalid_args)
{
constexpr size_t numBatches = 5UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1, 0, 1, 1, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1, 1, 1, 1, 1};
aclrtMemcpyBatchAttr attrs;
size_t attrsIndexes = 0;
size_t numAttrs = 1;
aclrtStream stream = nullptr;
auto ret = aclrtMemcpyBatchAsyncV2(nullptr, nullptr, nullptr, nullptr, 0, nullptr, nullptr, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsyncV2(dsts, nullptr, nullptr, nullptr, 0, nullptr, nullptr, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, nullptr, nullptr, 0, nullptr, nullptr, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, srcs, nullptr, 0, nullptr, nullptr, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, srcs, sizes, 0, nullptr, nullptr, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, srcs, sizes, 0, &attrs, nullptr, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, srcs, sizes, 0, &attrs, &attrsIndexes, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
destMax[1] = 1;
attrs.rsv[0] = 1;
ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMemcpyBatchAsync(_,_,_,_,_,_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
attrs.rsv[i] = 0U;
}
ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyBatchAsyncV2_success)
{
constexpr size_t numBatches = 5UL;
void **dsts = reinterpret_cast<void **>(0x04);
size_t destMax[numBatches] = {1, 1, 1, 1, 1};
void **srcs = reinterpret_cast<void **>(0x04);
size_t sizes[numBatches] = {1, 1, 1, 1, 1};
aclrtMemcpyBatchAttr attrs;
size_t attrsIndexes = 0;
size_t numAttrs = 1;
attrs.dstLoc.type = ACL_MEM_LOCATION_TYPE_DEVICE;
attrs.srcLoc.type = ACL_MEM_LOCATION_TYPE_DEVICE;
constexpr uint32_t rsvMaxSize = sizeof(aclrtMemcpyBatchAttr::rsv) / sizeof(uint8_t);
for (uint32_t i = 0U; i < rsvMaxSize; i++) {
attrs.rsv[i] = 0U;
}
const auto ret = aclrtMemcpyBatchAsyncV2(dsts, destMax, srcs, sizes, numBatches, &attrs, &attrsIndexes,
numAttrs, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
for(size_t i = 0; i < numBatches; ++i) {
sizes[i] = 0;
}
const auto ret_size_zero = aclrtMemcpyBatchAsyncV2(nullptr, nullptr, nullptr, sizes, numBatches, &attrs, &attrsIndexes, numAttrs, nullptr);
EXPECT_EQ(ret_size_zero, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemGetExportKey_failed_with_invalid_args)
{
void *devPtr = (void*)0xff;
size_t size = 1;
char key[] = "key";
size_t len = 3;
uint64_t flags = 1;
auto ret = aclrtIpcMemGetExportKey(nullptr, size, nullptr, len, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtIpcMemGetExportKey(devPtr, size, nullptr, len, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsIpcMemGetExportKey(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtIpcMemGetExportKey(devPtr, size, key, len, flags);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemGetExportKey_success)
{
void *devPtr = (void*)0xff;
size_t size = 1;
char key[] = "key";
size_t len = 3;
uint64_t flags = 1;
const auto ret = aclrtIpcMemGetExportKey(devPtr, size, key, len, flags);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemClose_failed_with_invalid_args)
{
const char *key = "key";
auto ret = aclrtIpcMemClose(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsIpcMemClose(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtIpcMemClose(key);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemClose_success)
{
const char *key = "key";
const auto ret = aclrtIpcMemClose(key);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemImportByKey_failed_with_invalid_args)
{
void *devPtr = nullptr;
const char *key = "key";
uint64_t flags = 1;
auto ret = aclrtIpcMemImportByKey(nullptr, nullptr, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtIpcMemImportByKey(&devPtr, nullptr, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsIpcMemImportByKey(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtIpcMemImportByKey(&devPtr, key, flags);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemImportByKey_success)
{
void *devPtr = nullptr;
const char *key = "key";
uint64_t flags = 1;
const auto ret = aclrtIpcMemImportByKey(&devPtr, key, flags);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemSetImportPid_failed_with_invalid_args)
{
const char *key = "key";
int32_t pid[] = {1, 2, 3};
size_t num = 3;
auto ret = aclrtIpcMemSetImportPid(nullptr, nullptr, num);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtIpcMemSetImportPid(key, nullptr, num);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsIpcMemSetImportPid(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtIpcMemSetImportPid(key, pid, num);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemSetImportPid_success)
{
const char *key = "key";
int32_t pid[] = {1, 2, 3};
size_t num = 3;
const auto ret = aclrtIpcMemSetImportPid(key, pid, num);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcMemImportPidInterServer)
{
const char *key = "key";
aclrtServerPid serverPids[3] = {};
size_t num = 3;
auto ret = aclrtIpcMemImportPidInterServer(key, serverPids, num);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtIpcMemImportPidInterServer(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtIpcMemImportPidInterServer(key, serverPids, num);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtIpcSetMemoryAttr)
{
const char *key = "key";
aclrtIpcMemAttrType type = ACL_RT_IPC_MEM_ATTR_ACCESS_LINK;
uint64_t attr = ACL_RT_IPC_MEM_ATTR_ACCESS_LINK_SIO;
auto ret = aclrtIpcMemSetAttr(key, type, attr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtIpcSetMemoryAttr(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtIpcMemSetAttr(key, type, attr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifyBatchReset_failed_with_invalid_args)
{
aclrtNotify notifies = nullptr;
size_t num = 3;
auto ret = aclrtNotifyBatchReset(nullptr, num);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifyBatchReset(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtNotifyBatchReset(¬ifies, num);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifyBatchReset_success)
{
aclrtNotify notifies = nullptr;
size_t num = 3;
const auto ret = aclrtNotifyBatchReset(¬ifies, num);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifyGetExportKey_failed_with_invalid_args)
{
aclrtNotify notify = (aclrtNotify)0x01;
char key[] = "key";
size_t len = 3;
uint64_t flags = 1;
auto ret = aclrtNotifyGetExportKey(nullptr, nullptr, len, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtNotifyGetExportKey(notify, nullptr, len, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifyGetExportKey(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtNotifyGetExportKey(notify, key, len, flags);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifyGetExportKey_success)
{
aclrtNotify notify = (aclrtNotify)0x01;
char key[] = "key";
size_t len = 3;
uint64_t flags = 1;
const auto ret = aclrtNotifyGetExportKey(notify, key, len, flags);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifyImportByKey_failed_with_invalid_args)
{
aclrtNotify notify = nullptr;
const char *key = "key";
uint64_t flags = 1;
auto ret = aclrtNotifyImportByKey(nullptr, nullptr, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtNotifyImportByKey(¬ify, nullptr, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifyImportByKey(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtNotifyImportByKey(¬ify, key, flags);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifyImportByKey_success)
{
aclrtNotify notify = nullptr;
const char *key = "key";
uint64_t flags = 1;
const auto ret = aclrtNotifyImportByKey(¬ify, key, flags);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifySetImportPid_failed_with_invalid_args)
{
aclrtNotify notify = (aclrtNotify)0x01;
int32_t pid[] = {1, 2, 3};
size_t num = 3;
auto ret = aclrtNotifySetImportPid(nullptr, nullptr, num);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtNotifySetImportPid(notify, nullptr, num);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNotifySetImportPid(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtNotifySetImportPid(notify, pid, num);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifySetImportPid_success)
{
aclrtNotify notify = (aclrtNotify)0x01;
int32_t pid[] = {1, 2, 3};
size_t num = 3;
const auto ret = aclrtNotifySetImportPid(notify, pid, num);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtNotifySetImportPidInterServer)
{
aclrtNotify notify = (aclrtNotify)0x01;
aclrtServerPid serverPid[3] = {};
size_t num = 3;
auto ret = aclrtNotifySetImportPidInterServer(notify, serverPid, num);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtNotifySetImportPidInterServer(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtNotifySetImportPidInterServer(notify, serverPid, num);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, InitCallbackManager_InitCallbackTest)
{
auto &cbMgrInstance = InitCallbackManager::GetInstance();
auto bakInitCbMap = cbMgrInstance.initCallbackMap_;
cbMgrInstance.initCallbackMap_.clear();
auto ret = cbMgrInstance.RegInitCallback(ACL_REG_TYPE_ACL_MODEL, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = cbMgrInstance.RegInitCallback(ACL_REG_TYPE_ACL_MODEL, InitCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.RegInitCallback(ACL_REG_TYPE_ACL_MODEL, InitCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = cbMgrInstance.RegInitCallback(ACL_REG_TYPE_OTHER, InitCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.RegInitCallback(ACL_REG_TYPE_OTHER, InitCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.UnRegInitCallback(ACL_REG_TYPE_ACL_MODEL, InitCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.UnRegInitCallback(ACL_REG_TYPE_ACL_MODEL, InitCallback_Fail);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = cbMgrInstance.UnRegInitCallback(ACL_REG_TYPE_OTHER, InitCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.UnRegInitCallback(ACL_REG_TYPE_OTHER, InitCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.UnRegInitCallback(ACL_REG_TYPE_OTHER, InitCallback_Success);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
cbMgrInstance.initCallbackMap_ = bakInitCbMap;
}
TEST_F(UTEST_ACL_Runtime, aclCallbackManager_FinalizeCallbackTest)
{
auto &cbMgrInstance = InitCallbackManager::GetInstance();
auto bakFinalizeCbMap = cbMgrInstance.finalizeCallbackMap_;
cbMgrInstance.finalizeCallbackMap_.clear();
auto ret = cbMgrInstance.RegFinalizeCallback(ACL_REG_TYPE_ACL_MODEL, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = cbMgrInstance.RegFinalizeCallback(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.RegFinalizeCallback(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = cbMgrInstance.RegFinalizeCallback(ACL_REG_TYPE_OTHER, FinalizeCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.RegFinalizeCallback(ACL_REG_TYPE_OTHER, FinalizeCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.UnRegFinalizeCallback(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.UnRegFinalizeCallback(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Fail);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = cbMgrInstance.UnRegFinalizeCallback(ACL_REG_TYPE_OTHER, FinalizeCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.UnRegFinalizeCallback(ACL_REG_TYPE_OTHER, FinalizeCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.UnRegFinalizeCallback(ACL_REG_TYPE_OTHER, FinalizeCallback_Success);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
cbMgrInstance.finalizeCallbackMap_ = bakFinalizeCbMap;
}
TEST_F(UTEST_ACL_Runtime, InitCallbackManager_NotifyOrderForOtherType)
{
auto &cbMgrInstance = InitCallbackManager::GetInstance();
CallbackMapGuard callbackMapGuard(cbMgrInstance);
auto ret = cbMgrInstance.RegInitCallback(ACL_REG_TYPE_OTHER, InitCallback_RecordOrder, reinterpret_cast<void *>(1));
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.RegInitCallback(ACL_REG_TYPE_OTHER, InitCallback_RecordOrder, reinterpret_cast<void *>(2));
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.NotifyInitCallback(ACL_REG_TYPE_OTHER, nullptr, 0U);
EXPECT_EQ(ret, ACL_SUCCESS);
ASSERT_EQ(g_callbackOrder.size(), 2U);
EXPECT_EQ(g_callbackOrder[0], 1);
EXPECT_EQ(g_callbackOrder[1], 2);
}
TEST_F(UTEST_ACL_Runtime, InitCallbackManager_FinalizeNotifyOrderForOtherType)
{
auto &cbMgrInstance = InitCallbackManager::GetInstance();
CallbackMapGuard callbackMapGuard(cbMgrInstance);
auto ret = cbMgrInstance.RegFinalizeCallback(ACL_REG_TYPE_OTHER, FinalizeCallback_RecordOrder,
reinterpret_cast<void *>(1));
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.RegFinalizeCallback(ACL_REG_TYPE_OTHER, FinalizeCallback_RecordOrder,
reinterpret_cast<void *>(2));
EXPECT_EQ(ret, ACL_SUCCESS);
ret = cbMgrInstance.NotifyFinalizeCallback(ACL_REG_TYPE_OTHER);
EXPECT_EQ(ret, ACL_SUCCESS);
ASSERT_EQ(g_callbackOrder.size(), 2U);
EXPECT_EQ(g_callbackOrder[0], 1);
EXPECT_EQ(g_callbackOrder[1], 2);
}
TEST_F(UTEST_ACL_Runtime, aclInitCallbackApiTest) {
auto ret = aclInit(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
auto &cbMgrInstance = InitCallbackManager::GetInstance();
auto bakInitCbMap = cbMgrInstance.initCallbackMap_;
cbMgrInstance.initCallbackMap_.clear();
ret = aclInitCallbackRegister(ACL_REG_TYPE_ACL_MODEL, InitCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInitCallbackUnRegister(ACL_REG_TYPE_ACL_MODEL, InitCallback_Fail);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = aclInitCallbackRegister(ACL_REG_TYPE_ACL_MODEL, InitCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = aclInitCallbackUnRegister(ACL_REG_TYPE_ACL_MODEL, InitCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInitCallbackUnRegister(ACL_REG_TYPE_ACL_MODEL, InitCallback_Fail);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = aclInitCallbackRegister(ACL_REG_TYPE_ACL_MODEL, InitCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInitCallbackRegister(ACL_REG_TYPE_OTHER, InitCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInitCallbackRegister(ACL_REG_TYPE_OTHER, InitCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInitCallbackUnRegister(ACL_REG_TYPE_OTHER, InitCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInitCallbackUnRegister(ACL_REG_TYPE_OTHER, InitCallback_Fail);
EXPECT_EQ(ret, ACL_SUCCESS);
cbMgrInstance.initCallbackMap_ = bakInitCbMap;
ret = aclFinalize();
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclInitCallbackTest) {
const std::string configPath = ACL_BASE_DIR "/tests/ut/acl/json/handleOpConfig.json";
auto &cbMgrInstance = InitCallbackManager::GetInstance();
auto bakInitCbMap = cbMgrInstance.initCallbackMap_;
auto bakFinalizeCbMap = cbMgrInstance.finalizeCallbackMap_;
cbMgrInstance.initCallbackMap_.clear();
cbMgrInstance.finalizeCallbackMap_.clear();
auto ret = aclInitCallbackRegister(ACL_REG_TYPE_ACL_MODEL, InitCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInit(nullptr);
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
cbMgrInstance.initCallbackMap_.clear();
resetAclJsonHash();
ret = aclInitCallbackRegister(ACL_REG_TYPE_ACL_OP_EXECUTOR, InitCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInit(configPath.c_str());
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
cbMgrInstance.initCallbackMap_.clear();
ret = aclInitCallbackRegister(ACL_REG_TYPE_ACL_DVPP, InitCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInit(nullptr);
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
cbMgrInstance.initCallbackMap_.clear();
ret = aclInitCallbackRegister(ACL_REG_TYPE_OTHER, InitCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclInit(nullptr);
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
cbMgrInstance.initCallbackMap_.clear();
ret = aclInit(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalize();
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
cbMgrInstance.finalizeCallbackMap_.clear();
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_ACL_OP_COMPILER, FinalizeCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalize();
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
cbMgrInstance.finalizeCallbackMap_.clear();
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_ACL_DVPP, FinalizeCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalize();
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
cbMgrInstance.finalizeCallbackMap_.clear();
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_OTHER, FinalizeCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalize();
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
cbMgrInstance.finalizeCallbackMap_.clear();
ret = aclFinalize();
EXPECT_EQ(ret, ACL_SUCCESS);
cbMgrInstance.initCallbackMap_ = bakInitCbMap;
cbMgrInstance.finalizeCallbackMap_ = bakFinalizeCbMap;
}
TEST_F(UTEST_ACL_Runtime, aclFinalizeCallbackApiTest) {
auto ret = aclInit(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
auto &cbMgrInstance = InitCallbackManager::GetInstance();
auto bakFinalizeCbMap = cbMgrInstance.finalizeCallbackMap_;
cbMgrInstance.finalizeCallbackMap_.clear();
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalizeCallbackUnRegister(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Fail);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = aclFinalizeCallbackUnRegister(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalizeCallbackUnRegister(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Fail);
EXPECT_EQ(ret, ACL_ERROR_INTERNAL_ERROR);
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_ACL_MODEL, FinalizeCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_OTHER, FinalizeCallback_Success, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalizeCallbackRegister(ACL_REG_TYPE_OTHER, FinalizeCallback_Fail, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalizeCallbackUnRegister(ACL_REG_TYPE_OTHER, FinalizeCallback_Success);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclFinalizeCallbackUnRegister(ACL_REG_TYPE_OTHER, FinalizeCallback_Fail);
EXPECT_EQ(ret, ACL_SUCCESS);
cbMgrInstance.finalizeCallbackMap_ = bakFinalizeCbMap;
ret = aclFinalize();
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtProfTrace_invalid_userdata)
{
int32_t length = 18;
aclrtStream stream = (aclrtStream)0x01;
const auto ret = aclrtProfTrace(nullptr, length, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtProfTrace_invalid_length)
{
int32_t length = 20;
aclrtStream stream = (aclrtStream)0x01;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsProfTrace(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
uint8_t data[length] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
0x10, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10};
const auto ret = aclrtProfTrace(&data, length, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtProfTrace_success_1)
{
int32_t length = 15;
aclrtStream stream = (aclrtStream)0x01;
uint8_t data[length] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsProfTrace(_,_,_))
.WillOnce(Return(ACL_SUCCESS));
const auto ret = aclrtProfTrace(&data, length, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtProfTrace_success_2)
{
int32_t length = 18;
aclrtStream stream = (aclrtStream)0x01;
uint8_t data[length] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x10, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsProfTrace(_,_,_))
.WillOnce(Return(ACL_SUCCESS));
const auto ret = aclrtProfTrace(&data, length, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_V2_failed_with_nullptr_input)
{
aclrtFuncHandle funcHandle = nullptr;
void *argsData = nullptr;
aclrtStream stream = nullptr;
aclError ret = aclrtLaunchKernelV2(funcHandle, 0, argsData, 0, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
funcHandle = (aclrtFuncHandle)0x01U;
ret = aclrtLaunchKernelV2(funcHandle, 0, argsData, 0, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_V2_successful)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *argsData = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
aclrtLaunchKernelCfg cfg;
cfg.numAttrs = 1U;
aclrtLaunchKernelAttr attrs[cfg.numAttrs];
attrs[0U].id = ACL_RT_LAUNCH_KERNEL_ATTR_SCHEM_MODE;
aclrtLaunchKernelAttrValue value;
value.schemMode = 1U;
attrs[0U].value = value;
cfg.attrs = attrs;
aclError ret = aclrtLaunchKernelV2(funcHandle, blockDim, argsData, argsSize, &cfg, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtLaunchKernelV2(funcHandle, blockDim, argsData, argsSize, nullptr, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_V2_failed_with_rt_launch_kernel_func_failed)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *argsData = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchKernelWithDevArgs(_, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtLaunchKernelV2(funcHandle, blockDim, argsData, argsSize, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_V2_failed_with_rt_launch_kernel_func_failed_2)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *argsData = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchKernelWithDevArgs(_, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_HANDLE));
aclError ret = aclrtLaunchKernelV2(funcHandle, blockDim, argsData, argsSize, nullptr, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_HANDLE);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_with_host_args_failed_with_nullptr_input)
{
aclrtFuncHandle funcHandle = nullptr;
void *hostArgs = nullptr;
aclrtStream stream = nullptr;
aclError ret = aclrtLaunchKernelWithHostArgs(funcHandle, 0, stream, nullptr, hostArgs, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
funcHandle = (aclrtFuncHandle)0x01U;
ret = aclrtLaunchKernelWithHostArgs(funcHandle, 0, stream, nullptr, hostArgs, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_with_host_args_successful)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *hostArgs = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
aclrtLaunchKernelCfg cfg;
cfg.numAttrs = 1U;
aclrtLaunchKernelAttr attrs[cfg.numAttrs];
attrs[0U].id = ACL_RT_LAUNCH_KERNEL_ATTR_SCHEM_MODE;
aclrtLaunchKernelAttrValue value;
value.schemMode = 1U;
attrs[0U].value = value;
cfg.attrs = attrs;
aclrtPlaceHolderInfo placeHolderArray;
placeHolderArray.addrOffset = 0;
placeHolderArray.dataOffset = 0;
aclError ret = aclrtLaunchKernelWithHostArgs(funcHandle, blockDim, stream, &cfg, hostArgs, argsSize, &placeHolderArray, 1);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtLaunchKernelWithHostArgs(funcHandle, blockDim, stream, nullptr, hostArgs, argsSize, nullptr, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_with_host_args_failed_with_rt_launch_kernel_func_failed)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *hostArgs = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchKernelWithHostArgs(_, _, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
aclError ret = aclrtLaunchKernelWithHostArgs(funcHandle, blockDim, stream, nullptr, hostArgs, argsSize, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_kernel_with_host_args_failed_with_rt_launch_kernel_func_failed_2)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01U;
void *hostArgs = reinterpret_cast<void *>(0x01U);
aclrtStream stream = (aclrtStream)0x01U;
uint32_t blockDim = 24;
size_t argsSize = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchKernelWithHostArgs(_, _, _, _, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_HANDLE));
aclError ret = aclrtLaunchKernelWithHostArgs(funcHandle, blockDim, stream, nullptr, hostArgs, argsSize, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_HANDLE);
}
TEST_F(UTEST_ACL_Runtime, aclrtCtxGetFloatOverflowAddr_success)
{
aclError ret = aclrtCtxGetFloatOverflowAddr(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsCtxGetFloatOverflowAddr(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCtxGetFloatOverflowAddr(nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFloatOverflowStatus_success)
{
aclError ret = aclrtGetFloatOverflowStatus(0, 0, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetFloatOverflowStatus(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtGetFloatOverflowStatus(0, 0, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtResetFloatOverflowStatus_success)
{
aclError ret = aclrtResetFloatOverflowStatus(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsResetFloatOverflowStatus(_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtResetFloatOverflowStatus(nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtNpuGetFloatOverFlowStatus_success)
{
aclError ret = aclrtNpuGetFloatOverFlowStatus(nullptr, 0, 0, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNpuGetFloatOverFlowStatus(_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtNpuGetFloatOverFlowStatus(nullptr, 0, 0, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtNpuClearFloatOverFlowStatus_success)
{
aclError ret = aclrtNpuClearFloatOverFlowStatus(0, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsNpuClearFloatOverFlowStatus(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtNpuClearFloatOverFlowStatus(0, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, get_hardware_sync_addr)
{
void *addr = nullptr;
aclError ret = aclrtGetHardwareSyncAddr(&addr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetHardwareSyncAddr(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtGetHardwareSyncAddr(&addr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_random_task)
{
aclrtStream stream = (aclrtStream)0x01U;
aclrtRandomNumTaskInfo info = {};
void *resv = reinterpret_cast<void *>(0x01U);
aclError ret = aclrtRandomNumAsync(nullptr, stream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
info.dataType = ACL_BOOL;
ret = aclrtRandomNumAsync(&info, nullptr, resv);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
info.dataType = ACL_FLOAT16;
ret = aclrtRandomNumAsync(&info, stream, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
info.dataType = ACL_FLOAT16;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchRandomNumTask(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtRandomNumAsync(&info, stream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
void taskFailCallback(aclrtExceptionInfo exceptionInfo)
{
(void)exceptionInfo;
}
void streamStateCallback(aclrtStream stm, aclrtStreamState state, void *args)
{
(void)stm;
(void)state;
(void)args;
}
TEST_F(UTEST_ACL_Runtime, set_stream_state_callback)
{
const char_t *name = "callback";
void *resv = reinterpret_cast<void *>(0x01U);
aclError ret = aclrtRegStreamStateCallback(nullptr, streamStateCallback, resv);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtRegStreamStateCallback(name, nullptr, resv);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtRegStreamStateCallback(name, streamStateCallback, resv);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsRegStreamStateCallback(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtRegStreamStateCallback(name, streamStateCallback, resv);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
void deviceStateCallback(int32_t deviceId, aclrtDeviceState state, void *args)
{
(void)deviceId;
(void)state;
(void)args;
}
TEST_F(UTEST_ACL_Runtime, set_device_state_callback)
{
const char_t *name = "callback";
void *resv = reinterpret_cast<void *>(0x01U);
aclError ret = aclrtRegDeviceStateCallback(nullptr, deviceStateCallback, resv);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtRegDeviceStateCallback(name, nullptr, resv);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtRegDeviceStateCallback(name, deviceStateCallback, resv);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsRegDeviceStateCallback(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtRegDeviceStateCallback(name, deviceStateCallback, resv);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
int32_t taskAbortCallback(int32_t deviceId, aclrtDeviceTaskAbortStage stage, uint32_t timeout, void *args)
{
(void)deviceId;
(void)stage;
(void)timeout;
(void)args;
return 0;
}
TEST_F(UTEST_ACL_Runtime, set_task_abort_callback)
{
const char_t *name = "callback";
aclError ret = aclrtSetDeviceTaskAbortCallback(nullptr, taskAbortCallback, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtSetDeviceTaskAbortCallback(name, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtSetDeviceTaskAbortCallback(name, taskAbortCallback, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsSetDeviceTaskAbortCallback(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
void *resv = reinterpret_cast<void *>(0x01U);
ret = aclrtSetDeviceTaskAbortCallback(name, taskAbortCallback, resv);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, get_op_execute_timeout)
{
uint32_t timeout = 0U;
aclError ret = aclrtGetOpExecuteTimeout(nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtGetOpExecuteTimeout(&timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetOpExecuteTimeoutV2(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtGetOpExecuteTimeout(&timeout);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, device_peer_access_status)
{
int32_t devIdDes = 0U;
int32_t phyIdSrc = 0U;
int32_t status = 0U;
aclError ret = aclrtDevicePeerAccessStatus(devIdDes, phyIdSrc, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtDevicePeerAccessStatus(devIdDes, phyIdSrc, &status);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetP2PStatus(_, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtDevicePeerAccessStatus(devIdDes, phyIdSrc, &status);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, stream_stop)
{
aclrtStream stream = (aclrtStream)0x01U;
aclError ret = aclrtStreamStop(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtStreamStop(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsStreamStop(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtStreamStop(stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, launch_update_task)
{
aclrtStream stream = (aclrtStream)0x01U;
uint32_t taskId = 0U;
aclrtStream execStream = (aclrtStream)0x01U;
aclrtTaskUpdateInfo info = {};
aclError ret = aclrtTaskUpdateAsync(nullptr, taskId, &info, execStream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtTaskUpdateAsync(stream, UINT32_MAX, &info, execStream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtTaskUpdateAsync(stream, taskId, nullptr, execStream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtTaskUpdateAsync(stream, taskId, &info, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtTaskUpdateAsync(stream, taskId, &info, execStream);
EXPECT_EQ(ret, ACL_SUCCESS);
info.id = ACL_RT_UPDATE_RANDOM_TASK;
ret = aclrtTaskUpdateAsync(stream, taskId, &info, execStream);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchUpdateTask(_, _, _, _))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtTaskUpdateAsync(stream, taskId, &info, execStream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclAppLog_success)
{
const char *strLog = "hello, acl";
std::string strLogOverflow(1025, 'a');
std::string strLogNearOverflow(1023, 'a');
aclAppLog(ACL_INFO, __FUNCTION__, __FILE__, __LINE__, strLog);
aclAppLog(ACL_INFO, __FUNCTION__, __FILE__, __LINE__, strLogOverflow.c_str());
aclAppLog(ACL_INFO, __FUNCTION__, __FILE__, __LINE__, strLogNearOverflow.c_str());
}
TEST_F(UTEST_ACL_Runtime, aclrtCheckArchCompatibilityTest)
{
int32_t canCompatible = 255;
aclError ret = aclrtCheckArchCompatibility("SOC_ASCEND910", &canCompatible);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCheckArchCompatibility(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
ret = aclrtCheckArchCompatibility("SOC_ASCEND910B1", &canCompatible);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCmoGetDescSizeTest)
{
size_t size = 0;
auto ret = aclrtCmoGetDescSize(&size);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(size, 0U);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsGetCmoDescSize(_)).WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCmoGetDescSize(&size);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCmoSetDescTest)
{
void *cmodesc = (void *)0x1;
void *srcAddr = nullptr;
size_t memLen = 64;
auto ret = aclrtCmoSetDesc(cmodesc, srcAddr, memLen);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsSetCmoDesc(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCmoSetDesc(&cmodesc, srcAddr, memLen);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCmoAsyncWithDescTest)
{
void *cmodesc = (void *)0x1;
auto ret = aclrtCmoAsyncWithDesc(cmodesc, ACL_RT_CMO_TYPE_PREFETCH, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsLaunchCmoAddrTask(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCmoAsyncWithDesc(&cmodesc, ACL_RT_CMO_TYPE_PREFETCH, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIAbortTest)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
auto ret = aclmdlRIAbort(modelRI);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsModelAbort(_)).WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIAbort(modelRI);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemRetainAllocationHandletest)
{
void *virPtr = nullptr;
size_t size = 1;
auto ret = aclrtReserveMemAddress(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(virPtr, nullptr);
aclrtDrvMemHandle handle = nullptr;
aclrtPhysicalMemProp prop = {};
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
prop.memAttr = ACL_HBM_MEM_HUGE;
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.location.id = 0;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(handle, nullptr);
ret = aclrtMapMem(virPtr, size, 0, handle, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtDrvMemHandle handle1 = nullptr;
ret = aclrtMemRetainAllocationHandle(nullptr, &handle1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemRetainAllocationHandle(virPtr, &handle1);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtUnmapMem(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFreePhysical(handle);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtReleaseMemAddress(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemRetainAllocationHandle(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMemRetainAllocationHandle(virPtr, &handle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemGetAllocationPropertiesFromHandletest)
{
size_t size = 1;
aclrtDrvMemHandle handle = nullptr;
aclrtPhysicalMemProp prop = {};
prop.allocationType = ACL_MEM_ALLOCATION_TYPE_PINNED;
prop.memAttr = ACL_HBM_MEM_HUGE;
prop.location.type = ACL_MEM_LOCATION_TYPE_DEVICE;
prop.location.id = 0;
auto ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
aclrtPhysicalMemProp prop1 = {};
ret = aclrtMemGetAllocationPropertiesFromHandle(nullptr, &prop1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemGetAllocationPropertiesFromHandle(handle, &prop1);
EXPECT_EQ(ret, ACL_SUCCESS);
prop.memAttr = ACL_HBM_MEM_NORMAL;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemGetAllocationPropertiesFromHandle(handle, &prop1);
EXPECT_EQ(ret, ACL_SUCCESS);
prop.memAttr = ACL_HBM_MEM_HUGE1G;
ret = aclrtMallocPhysical(&handle, size, &prop, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemGetAllocationPropertiesFromHandle(handle, &prop1);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtFreePhysical(handle);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemGetAllocationPropertiesFromHandle(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMemGetAllocationPropertiesFromHandle(handle, &prop1);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCntNotifyRecord)
{
aclrtStream stream = (aclrtStream)0x01U;
aclrtNotify cntNotify = nullptr;
aclrtCntNotifyRecordInfo info = {ACL_RT_CNT_NOTIFY_RECORD_SET_VALUE_MODE, 0};
auto ret = aclrtCntNotifyRecord(&cntNotify, stream, &info);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtCntNotifyRecord(&cntNotify, stream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsCntNotifyRecord(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCntNotifyRecord(&cntNotify, stream, &info);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCntNotifyWaitWithTimeout)
{
aclrtStream stream = (aclrtStream)0x01U;
aclrtNotify cntNotify = nullptr;
aclrtCntNotifyWaitInfo info = {ACL_RT_CNT_NOTIFY_WAIT_LESS_MODE, 0, 0, true, 0};
auto ret = aclrtCntNotifyWaitWithTimeout(&cntNotify, stream, &info);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtCntNotifyWaitWithTimeout(&cntNotify, stream, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsCntNotifyWaitWithTimeout(_,_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCntNotifyWaitWithTimeout(&cntNotify, stream, &info);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCntNotifyReset)
{
aclrtStream stream = (aclrtStream)0x01U;
aclrtNotify cntNotify = nullptr;
auto ret = aclrtCntNotifyReset(&cntNotify, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsCntNotifyReset(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCntNotifyReset(&cntNotify, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtCntNotifyGetId)
{
aclrtNotify cntNotify = nullptr;
auto ret = aclrtCntNotifyGetId(&cntNotify, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsCntNotifyGetId(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
uint32_t notifyId = 0U;
ret = aclrtCntNotifyGetId(&cntNotify, ¬ifyId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtPersistentTaskClean)
{
aclrtStream stream = (aclrtStream)0x01U;
aclError ret = aclrtPersistentTaskClean(nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtPersistentTaskClean(stream);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPersistentTaskClean(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtPersistentTaskClean(stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtCacheLastTaskOpInfo)
{
char rawInfo[] = "test_op_info_data";
size_t infoSize = sizeof(rawInfo);
auto ret = aclrtCacheLastTaskOpInfo(nullptr, infoSize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtCacheLastTaskOpInfo(rawInfo, 0U);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtCacheLastTaskOpInfo(rawInfo, infoSize);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCacheLastTaskOpInfo(_,_))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCacheLastTaskOpInfo(rawInfo, infoSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCacheLastTaskOpInfo(_,_))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
ret = aclrtCacheLastTaskOpInfo(rawInfo, infoSize);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtCacheLastTaskExtendInfo)
{
char extendInfo[] = "test_extend_info_data";
size_t infoSize = sizeof(extendInfo) - 1U;
auto ret = aclrtCacheLastTaskExtendInfo(extendInfo, infoSize);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCacheLastTaskExtendInfo(_, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtCacheLastTaskExtendInfo(extendInfo, infoSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtCacheLastTaskExtendInfo(_, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
ret = aclrtCacheLastTaskExtendInfo(extendInfo, infoSize);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFunctionAttribute)
{
aclrtFuncAttribute attrType = ACL_FUNC_ATTR_KERNEL_TYPE;
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01;
int64_t attrValue = 0U;
auto ret = aclrtGetFunctionAttribute(nullptr, attrType, &attrValue);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtGetFunctionAttribute(funcHandle, attrType, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetAttribute(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtGetFunctionAttribute(funcHandle, attrType, &attrValue);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetBinary)
{
aclrtFuncHandle funcHandle = (aclrtFuncHandle)0x01;
aclrtBinHandle binHandle = nullptr;
auto ret = aclrtFunctionGetBinary(funcHandle, &binHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetBinary(_, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtFunctionGetBinary(funcHandle, &binHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtReserveMemAddressNoUCMemory)
{
void *virPtr = nullptr;
size_t size = 1;
aclError ret = aclrtReserveMemAddressNoUCMemory(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_NE(virPtr, nullptr);
ret = aclrtReleaseMemAddress(virPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtReserveMemAddressNoUCMemory(&virPtr, 0, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtReserveMemAddressNoUCMemory(&virPtr, size, 0, nullptr, 2);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtReserveMemAddress(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtReserveMemAddressNoUCMemory(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtReserveMemAddress(_,_,_,_,_))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
ret = aclrtReserveMemAddressNoUCMemory(&virPtr, size, 0, nullptr, 0);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtReleaseMemAddress(_))
.WillOnce(Return(ACL_ERROR_INVALID_PARAM));
ret = aclrtReleaseMemAddress(virPtr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemGetAddressRange)
{
void *ptr = nullptr;
void *pbase = reinterpret_cast<void *>(0x01U);
size_t psize = 0;
aclError ret = aclrtMemGetAddressRange(ptr, &pbase, &psize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ptr = (void*)0xff;
ret = aclrtMemGetAddressRange(ptr, &pbase, &psize);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemGetAddressRange_failed_with_rt_error)
{
void *ptr = (void*)0xff;
void *pbase = nullptr;
size_t psize = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemGetAddressRange(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclError ret = aclrtMemGetAddressRange(ptr, &pbase, &psize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolCreate)
{
aclrtMemPool memPool = 0;
aclrtMemPoolProps poolProp;
poolProp.handleType = aclrtMemHandleType::ACL_MEM_HANDLE_TYPE_NONE;
poolProp.allocType = aclrtMemAllocationType::ACL_MEM_ALLOCATION_TYPE_PINNED;
poolProp.location.type = aclrtMemLocationType::ACL_MEM_LOCATION_TYPE_DEVICE;
poolProp.maxSize = 10;
memset_s(poolProp.reserved, sizeof(poolProp.reserved), 0, sizeof(poolProp.reserved));
rtError_t error = aclrtMemPoolCreate(&memPool, &poolProp);
EXPECT_EQ(error, RT_ERROR_NONE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolCreateInvalidReserved)
{
aclrtMemPool memPool = 0;
aclrtMemPoolProps poolProp;
poolProp.handleType = aclrtMemHandleType::ACL_MEM_HANDLE_TYPE_NONE;
poolProp.allocType = aclrtMemAllocationType::ACL_MEM_ALLOCATION_TYPE_PINNED;
poolProp.location.type = aclrtMemLocationType::ACL_MEM_LOCATION_TYPE_DEVICE;
poolProp.maxSize = 10;
memset_s(poolProp.reserved, sizeof(poolProp.reserved), 0, sizeof(poolProp.reserved));
memcpy_s(poolProp.reserved, sizeof(poolProp.reserved), "test", 4);
rtError_t error = aclrtMemPoolCreate(&memPool, &poolProp);
EXPECT_NE(error, RT_ERROR_NONE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolCreateErrorLocationType)
{
aclrtMemPool memPool = 0;
aclrtMemPoolProps poolProp;
poolProp.handleType = aclrtMemHandleType::ACL_MEM_HANDLE_TYPE_NONE;
poolProp.allocType = aclrtMemAllocationType::ACL_MEM_ALLOCATION_TYPE_PINNED;
poolProp.location.type = aclrtMemLocationType::ACL_MEM_LOCATION_TYPE_HOST;
poolProp.maxSize = 10;
rtError_t error = aclrtMemPoolCreate(&memPool, &poolProp);
EXPECT_NE(error, RT_ERROR_NONE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolDestroy)
{
aclrtMemPool memPool = (void*)0xff;
rtError_t error = aclrtMemPoolDestroy(memPool);
EXPECT_EQ(error, RT_ERROR_NONE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolSetAttr)
{
aclrtMemPool memPool = (void*)0xff;
aclrtMemPoolAttr attr = aclrtMemPoolAttr::ACL_RT_MEM_POOL_ATTR_RELEASE_THRESHOLD;
uint64_t waterMark = (2UL << 30);
rtError_t error = aclrtMemPoolSetAttr(memPool, attr, (void *)&waterMark);
EXPECT_EQ(error, RT_ERROR_NONE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolGetAttr)
{
aclrtMemPool memPool = (void*)0xff;
aclrtMemPoolAttr attr = aclrtMemPoolAttr::ACL_RT_MEM_POOL_ATTR_RELEASE_THRESHOLD;
uint64_t waterMark = (2UL << 30);
rtError_t error = aclrtMemPoolGetAttr(memPool, attr, (void *)&waterMark);
EXPECT_EQ(error, RT_ERROR_NONE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolFreeAsync)
{
aclrtStream stream = (aclrtStream)0x01U;
void *ptr = nullptr;
rtError_t error = aclrtMemPoolFreeAsync(ptr, stream);
EXPECT_NE(error, RT_ERROR_NONE);
ptr = (void*)0xff;
error = aclrtMemPoolFreeAsync(ptr, stream);
EXPECT_EQ(error, RT_ERROR_NONE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolMallocAsync)
{
aclrtStream stream = (aclrtStream)0x01U;
aclrtMemPool memPool = (void*)0xff;
size_t size = 10 * 1024;
void *ptr = nullptr;
rtError_t error = aclrtMemPoolMallocAsync(&ptr, size, memPool, stream);
EXPECT_EQ(error, RT_ERROR_NONE);
size = 0;
error = aclrtMemPoolMallocAsync(&ptr, size, memPool, stream);
EXPECT_EQ(error, RT_ERROR_NONE);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemPoolTrimTo)
{
aclrtMemPool memPool = (void*)0xff;
rtError_t error = aclrtMemPoolTrimTo(memPool, 0);
EXPECT_EQ(error, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemPoolTrimTo(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)));
error = aclrtMemPoolTrimTo(memPool, 0);
EXPECT_NE(error, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetArgsFromExceptionInfo)
{
void *devArgs = nullptr;
uint32_t devArgsLen = 0;
const uint32_t ACL_ERROR_INVALID_EXCEPTION_INFO = 0xFFFFFFFFU;
auto ret = aclrtGetArgsFromExceptionInfo(nullptr, &devArgs, &devArgsLen);
EXPECT_EQ(ret, ACL_ERROR_INVALID_EXCEPTION_INFO);
aclrtExceptionInfo exceptionInfo;
(void)memset_s(&exceptionInfo, sizeof(aclrtExceptionInfo), 0, sizeof(aclrtExceptionInfo));
exceptionInfo.expandInfo.type = RT_EXCEPTION_AICORE;
uint32_t args[3] = {1, 2, 3};
uint32_t argsLen = 3;
exceptionInfo.expandInfo.u.aicoreInfo.exceptionArgs.argAddr = (void *)(&args);
exceptionInfo.expandInfo.u.aicoreInfo.exceptionArgs.argsize = argsLen;
ret = aclrtGetArgsFromExceptionInfo(&exceptionInfo, &devArgs, &devArgsLen);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(devArgs, (void *)(&args));
EXPECT_EQ(devArgsLen, argsLen);
exceptionInfo.expandInfo.type = RT_EXCEPTION_FUSION;
exceptionInfo.expandInfo.u.fusionInfo.u.aicoreCcuInfo.exceptionArgs.argAddr = (void *)(&args);
exceptionInfo.expandInfo.u.fusionInfo.u.aicoreCcuInfo.exceptionArgs.argsize = argsLen;
exceptionInfo.expandInfo.u.fusionInfo.type = RT_FUSION_AICORE_CCU;
ret = aclrtGetArgsFromExceptionInfo(&exceptionInfo, &devArgs, &devArgsLen);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(devArgs, (void *)(&args));
EXPECT_EQ(devArgsLen, argsLen);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFuncHandleFromExceptionInfo)
{
aclrtExceptionInfo info;
aclrtFuncHandle func;
const uint32_t ACL_ERROR_INVALID_EXCEPTION_INFO = 0xFFFFFFFFU;
auto ret = aclrtGetFuncHandleFromExceptionInfo(nullptr, &func);
EXPECT_EQ(ret, ACL_ERROR_INVALID_EXCEPTION_INFO);
ret = aclrtGetFuncHandleFromExceptionInfo(&info, &func);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetFuncHandleFromExceptionInfo(_, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtGetFuncHandleFromExceptionInfo(&info, &func);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinarySetExceptionCallback)
{
aclrtBinHandle handle = (aclrtBinHandle)0x01;
aclrtOpExceptionCallback funcHandle = (aclrtOpExceptionCallback)0x01;
auto ret = aclrtBinarySetExceptionCallback(nullptr, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtBinarySetExceptionCallback(handle, funcHandle, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtBinarySetExceptionCallback(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtBinarySetExceptionCallback(handle, funcHandle, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemP2PMap)
{
void *devPtr = (void *)0x01;
size_t size = 1;
int32_t dstDevId = 0;
uint64_t flags = 0;
aclError ret = aclrtMemP2PMap(devPtr, size, dstDevId, flags);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemP2PMap(devPtr, size, dstDevId, 1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemP2PMap(NULL, size, dstDevId, 0);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemP2PMap(devPtr, 0, dstDevId, flags);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDevicePhyIdByIndex(_, _))
.WillOnce(Return((ACL_ERROR_RT_PARAM_INVALID)))
.WillRepeatedly(Return(RT_ERROR_NONE));
ret = aclrtMemP2PMap(devPtr, size, dstDevId, flags);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemP2PMap_failed_with_rtMemPrefetchToDevice_error)
{
void *devPtr = (void *)0x01;
size_t size = 1;
int32_t dstDevId = 0;
uint64_t flags = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetDevicePhyIdByIndex(_, _))
.WillRepeatedly(Return(RT_ERROR_NONE));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemPrefetchToDevice(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
aclError ret = aclrtMemP2PMap(devPtr, size, dstDevId, flags);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclmdlRIDestroyRegisterCallback)
{
aclmdlRI modelRI = (aclmdlRI)0x01;
auto ret = aclmdlRIDestroyRegisterCallback(&modelRI, nullptr, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclmdlRIDestroyUnregisterCallback(&modelRI, nullptr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtModelDestroyRegisterCallback(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIDestroyRegisterCallback(&modelRI, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtModelDestroyUnregisterCallback(_, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclmdlRIDestroyUnregisterCallback(&modelRI, nullptr);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemManagedPrefetchAsyncTest)
{
void *ptr = nullptr;
size_t size = 1;
aclrtMemManagedLocation location = { ACL_MEM_LOCATIONTYPE_HOST, 1 };
uint32_t flags = 0;
aclrtStream stream = nullptr;
aclError ret = aclrtMemManagedPrefetchAsync(ptr, size, location, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ptr = (void *)0x01;
size = 0;
ret = aclrtMemManagedPrefetchAsync(ptr, size, location, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
size = 1;
flags = 1;
ret = aclrtMemManagedPrefetchAsync(ptr, size, location, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
size = 1;
flags = 0;
ret = aclrtMemManagedPrefetchAsync(ptr, size, location, flags, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemManagedPrefetchBatchAsyncTest)
{
constexpr size_t numUvmPtrs = 6UL;
constexpr size_t numPrefetchLocsArr = 4UL;
void *ptrs[numUvmPtrs] = { (void *)0x01, (void *)0x10, (void *)0x20, (void *)0x30, (void *)0x40, (void *)0x50 };
size_t sizes[numUvmPtrs] = { 3, 6, 9, 6, 5, 8 };
size_t count = numUvmPtrs;
aclrtMemManagedLocation prefetchLocs[numPrefetchLocsArr] = {
{ ACL_MEM_LOCATIONTYPE_HOST, 1 }, { ACL_MEM_LOCATIONTYPE_DEVICE, 2 },
{ ACL_MEM_LOCATIONTYPE_HOST_NUMA, 3 }, { ACL_MEM_LOCATIONTYPE_HOST_NUMA_CURRENT, 0 },
};
size_t prefetchLocIdxs[numPrefetchLocsArr] = { 0, 2, 3, 5 };
size_t numPrefetchLocs = numPrefetchLocsArr;
uint64_t flags = 1;
aclrtStream stream = nullptr;
aclError ret = aclrtMemManagedPrefetchBatchAsync((const void**)ptrs, sizes, count, prefetchLocs, prefetchLocIdxs,
numPrefetchLocs, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
flags = 0;
ret = aclrtMemManagedPrefetchBatchAsync(nullptr, sizes, count, prefetchLocs, prefetchLocIdxs,
numPrefetchLocs, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemManagedPrefetchBatchAsync((const void**)ptrs, nullptr, count, prefetchLocs, prefetchLocIdxs,
numPrefetchLocs, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemManagedPrefetchBatchAsync((const void**)ptrs, sizes, count, nullptr, prefetchLocIdxs,
numPrefetchLocs, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemManagedPrefetchBatchAsync((const void**)ptrs, sizes, 0UL, prefetchLocs, prefetchLocIdxs,
numPrefetchLocs, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemManagedPrefetchBatchAsync((const void**)ptrs, sizes, count, prefetchLocs, prefetchLocIdxs,
0UL, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
numPrefetchLocs = numUvmPtrs + 1;
ret = aclrtMemManagedPrefetchBatchAsync((const void**)ptrs, sizes, count, prefetchLocs, prefetchLocIdxs,
numPrefetchLocs, flags, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
numPrefetchLocs = numPrefetchLocsArr;
count = numPrefetchLocsArr;
ret = aclrtMemManagedPrefetchBatchAsync((const void**)ptrs, sizes, count, prefetchLocs, prefetchLocIdxs,
numPrefetchLocs, flags, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
count = numUvmPtrs;
ret = aclrtMemManagedPrefetchBatchAsync((const void**)ptrs, sizes, count, prefetchLocs, prefetchLocIdxs,
numPrefetchLocs, flags, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtDeviceGetHostAtomicCapabilities)
{
uint32_t capabilities[2] = {0};
aclrtAtomicOperation operations[2] = {ACL_RT_ATOMIC_OPERATION_INTEGER_ADD, ACL_RT_ATOMIC_OPERATION_SIMD_SCALAR_EXCH};
uint32_t count = 2;
int32_t deviceId = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceGetHostAtomicCapabilities(_, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtDeviceGetHostAtomicCapabilities(capabilities, operations, count, deviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceGetHostAtomicCapabilities(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtDeviceGetHostAtomicCapabilities(capabilities, operations, count, deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceGetHostAtomicCapabilities(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_DEVICEID));
ret = aclrtDeviceGetHostAtomicCapabilities(capabilities, operations, count, deviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_DEVICEID);
}
TEST_F(UTEST_ACL_Runtime, aclrtDeviceGetP2PAtomicCapabilities)
{
uint32_t capabilities[1] = {0};
aclrtAtomicOperation operations[1] = {ACL_RT_ATOMIC_OPERATION_DMA_MAX};
uint32_t count = 1;
int32_t srcDeviceId = 0;
int32_t dstDeviceId = 1;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceGetP2PAtomicCapabilities(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDeviceId, dstDeviceId);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceGetP2PAtomicCapabilities(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_DEVICEID));
ret = aclrtDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDeviceId, dstDeviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_DEVICEID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceGetP2PAtomicCapabilities(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtDeviceGetP2PAtomicCapabilities(capabilities, operations, count, srcDeviceId, dstDeviceId);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemMapSelectedLinkTest)
{
uint32_t mem1[8];
uint32_t mem2[8];
size_t size = 32;
uint32_t linkIdx = ACL_RT_MEM_LINK_IDX_1;
aclError ret = aclrtMemMapSelectedLink(nullptr, size, (void *)mem2, linkIdx);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemMapSelectedLink((void *)mem1, 0, (void *)mem2, linkIdx);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemMapSelectedLink((void *)mem1, size, nullptr, linkIdx);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemMapSelectedLink((void *)mem1, size, (void *)mem2, linkIdx + 1);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemMapSelectedLink(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtMemMapSelectedLink((void *)mem1, size, (void *)mem2, linkIdx);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemMapSelectedLink(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
ret = aclrtMemMapSelectedLink((void *)mem1, size, (void *)mem2, linkIdx);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemMapSelectedLink(_, _, _, _))
.WillOnce(Return(ACL_RT_SUCCESS));
ret = aclrtMemMapSelectedLink((void *)mem1, size, (void *)mem2, linkIdx);
EXPECT_EQ(ret, ACL_RT_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtApiHeaderIncludeTest)
{
float *devPtr = nullptr;
size_t size = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMalloc(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMalloc(&devPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceSynchronizeWithTimeout(_))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtSynchronizeDevice(5000);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateMallocTest)
{
float *devPtr = nullptr;
size_t size = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMalloc(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMalloc(&devPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMalloc(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMalloc(&devPtr, size, ACL_MEM_MALLOC_HUGE_FIRST);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateMallocHostTest)
{
float *hostPtr = nullptr;
size_t size = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsMallocHost(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMallocHost(&hostPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemcpyTest)
{
float src[10] = {1.0f};
float dst[10] = {0.0f};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemcpy(dst, 10 * sizeof(float), src, 10 * sizeof(float), ACL_MEMCPY_HOST_TO_HOST);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemcpyAsyncTest)
{
float *src = reinterpret_cast<float *>(0x01);
float *dst = reinterpret_cast<float *>(0x02);
aclrtStream stream = reinterpret_cast<aclrtStream>(0x03);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsync(_, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemcpyAsync(dst, 10 * sizeof(float), src, 10 * sizeof(float), ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemcpy2dTest)
{
float *src = reinterpret_cast<float *>(0x01);
float *dst = reinterpret_cast<float *>(0x02);
size_t dpitch = 2;
size_t spitch = 2;
size_t width = 1;
size_t height = 2;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy2d(_, _, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemcpy2d(dst, dpitch, src, spitch, width, height, ACL_MEMCPY_HOST_TO_DEVICE);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemcpy2dAsyncTest)
{
float *src = reinterpret_cast<float *>(0x01);
float *dst = reinterpret_cast<float *>(0x02);
aclrtStream stream = reinterpret_cast<aclrtStream>(0x03);
size_t dpitch = 2;
size_t spitch = 2;
size_t width = 1;
size_t height = 2;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy2dAsync(_, _, _, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtMemcpy2dAsync(dst, dpitch, src, spitch, width, height, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtOverloadSynchronizeDeviceTest)
{
int32_t timeout = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtDeviceSynchronizeWithTimeout(_))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtSynchronizeDevice(timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
timeout = -2;
ret = aclrtSynchronizeDevice(timeout);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtOverloadSynchronizeStreamTest)
{
aclrtStream stream = reinterpret_cast<aclrtStream>(0x01);
int32_t timeout = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtStreamSynchronizeWithTimeout(_, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtSynchronizeStream(stream, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtOverloadSynchronizeEventTest)
{
aclrtEvent event = reinterpret_cast<aclrtEvent>(0x01);
int32_t timeout = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventSynchronizeWithTimeout(_, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtSynchronizeEvent(event, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtOverloadStreamWaitEventTest)
{
aclrtStream stream = reinterpret_cast<aclrtStream>(0x01);
aclrtEvent event = reinterpret_cast<aclrtEvent>(0x02);
int32_t timeout = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsEventWait(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtStreamWaitEvent(stream, event, timeout);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtOverloadCreateEventTest)
{
aclrtEvent event = nullptr;
uint32_t flag = 0x00000008u;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtEventCreateExWithFlag(_, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtCreateEvent(&event, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplatePointerGetAttributesTest)
{
float *ptr = reinterpret_cast<float *>(0x01);
aclrtPtrAttributes attributes;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsPointerGetAttributes(_, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtPointerGetAttributes(ptr, &attributes);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateHostRegisterTest)
{
float *hostPtr = reinterpret_cast<float *>(0x01);
float *devPtr = nullptr;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsHostRegister(_, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtHostRegister(hostPtr, 100, ACL_HOST_REGISTER_MAPPED, &devPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
uint32_t flag = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostRegisterV2(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtHostRegister(hostPtr, 100, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateHostGetDevicePointerTest)
{
float *hostPtr = reinterpret_cast<float *>(0x01);
float *devPtr = nullptr;
uint32_t flag = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtHostGetDevicePointer(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtHostGetDevicePointer(hostPtr, &devPtr, flag);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateHostUnregisterTest)
{
float *hostPtr = reinterpret_cast<float *>(0x01);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtsHostUnregister(_))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtHostUnregister(hostPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtTemplateMemAllocManagedTest)
{
float *devPtr = nullptr;
size_t size = 100;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemAllocManaged(_, _, _, _))
.WillRepeatedly(Return(RT_ERROR_NONE));
aclError ret = aclrtMemAllocManaged(&devPtr, size);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemAllocManaged(&devPtr, size, ACL_RT_MEM_ATTACH_GLOBAL);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetGlobal_failed_with_nullptr_binHandle)
{
aclrtBinHandle binHandle = nullptr;
const char *name = "global_var";
void *dptr = nullptr;
size_t size = 0;
aclError ret = aclrtBinaryGetGlobal(binHandle, name, &dptr, &size);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetGlobal_failed_with_nullptr_name)
{
aclrtBinHandle binHandle = (aclrtBinHandle)0x01U;
const char *name = nullptr;
void *dptr = nullptr;
size_t size = 0;
aclError ret = aclrtBinaryGetGlobal(binHandle, name, &dptr, &size);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetGlobal_failed_with_both_nullptr_output)
{
aclrtBinHandle binHandle = (aclrtBinHandle)0x01U;
const char *name = "global_var";
aclError ret = aclrtBinaryGetGlobal(binHandle, name, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetGlobal_success)
{
aclrtBinHandle binHandle = (aclrtBinHandle)0x01U;
const char *name = "global_var";
void *dptr = nullptr;
size_t size = 0;
aclError ret = aclrtBinaryGetGlobal(binHandle, name, &dptr, &size);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetGlobal_feature_not_support)
{
aclrtBinHandle binHandle = (aclrtBinHandle)0x01U;
const char *name = "global_var";
void *dptr = nullptr;
size_t size = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtBinaryGetGlobal(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
aclError ret = aclrtBinaryGetGlobal(binHandle, name, &dptr, &size);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetGlobal_global_symbol_not_found)
{
aclrtBinHandle binHandle = (aclrtBinHandle)0x01U;
const char *name = "global_var";
void *dptr = nullptr;
size_t size = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtBinaryGetGlobal(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_SYMBOL_NOT_FOUND));
aclError ret = aclrtBinaryGetGlobal(binHandle, name, &dptr, &size);
EXPECT_EQ(ret, ACL_ERROR_RT_SYMBOL_NOT_FOUND);
}
TEST_F(UTEST_ACL_Runtime, aclrtBinaryGetGlobal_rt_error)
{
aclrtBinHandle binHandle = (aclrtBinHandle)0x01U;
const char *name = "global_var";
void *dptr = nullptr;
size_t size = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtBinaryGetGlobal(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_HANDLE));
aclError ret = aclrtBinaryGetGlobal(binHandle, name, &dptr, &size);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_HANDLE);
}
TEST_F(UTEST_ACL_Runtime, aclrtLaunchKernelWithArgsArrayTest)
{
void *func = (void *)0x01;
uint32_t numBlocks = 1;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg cfg = {};
void *argsArray[2] = {(void *)0x10, (void *)0x20};
aclError ret = aclrtLaunchKernelWithArgsArray(nullptr, numBlocks, stream, &cfg, argsArray);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchKernelWithArgsArray(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtLaunchKernelWithArgsArray(func, numBlocks, stream, &cfg, argsArray);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchKernelWithArgsArray(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_HANDLE));
ret = aclrtLaunchKernelWithArgsArray(func, numBlocks, stream, &cfg, argsArray);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_HANDLE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchKernelWithArgsArray(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
ret = aclrtLaunchKernelWithArgsArray(func, numBlocks, stream, &cfg, argsArray);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchKernelWithArgsArray(_, _, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtLaunchKernelWithArgsArray(func, numBlocks, stream, &cfg, argsArray);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetParamCountTest)
{
void *func = (void *)0x01;
size_t paramCount = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetParamCount(_, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtFunctionGetParamCount(func, ¶mCount);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetParamCount(_, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtFunctionGetParamCount(func, ¶mCount);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetParamInfoTest)
{
void *func = (void *)0x01;
size_t paramIndex = 0;
size_t paramOffset = 0;
size_t paramSize = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetParamInfo(_, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtFunctionGetParamInfo(func, paramIndex, ¶mOffset, ¶mSize);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetParamInfo(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtFunctionGetParamInfo(func, paramIndex, ¶mOffset, ¶mSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetAvailDynUbufPerBlockTest)
{
void *func = (void *)0x01;
uint32_t flags = 0U;
size_t dynamicUbufSize = 0U;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetAvailDynUbufPerBlock(_, _, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtFunctionGetAvailDynUbufPerBlock(func, flags, &dynamicUbufSize);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetAvailDynUbufPerBlock(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtFunctionGetAvailDynUbufPerBlock(func, flags, &dynamicUbufSize);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetAvailDynUbufPerBlock_ReturnDynamicUbufSizeTest)
{
void *func = (void *)0x01;
uint32_t flags = 0U;
size_t dynamicUbufSize = 0U;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetAvailDynUbufPerBlock(func, flags, _))
.WillOnce(DoAll(SetArgPointee<2>(4096U), Return(RT_ERROR_NONE)));
aclError ret = aclrtFunctionGetAvailDynUbufPerBlock(func, flags, &dynamicUbufSize);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(dynamicUbufSize, 4096U);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetAvailDynUbufPerBlock_FlagsNotZeroTest)
{
void *func = (void *)0x01;
uint32_t flags = 1U;
size_t dynamicUbufSize = 0U;
aclError ret = aclrtFunctionGetAvailDynUbufPerBlock(func, flags, &dynamicUbufSize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetAvailDynUbufPerBlock_InternalErrorTest)
{
void *func = (void *)0x01;
uint32_t flags = 0U;
size_t dynamicUbufSize = 0U;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetAvailDynUbufPerBlock(func, flags, _))
.WillOnce(Return(ACL_ERROR_RT_INTERNAL_ERROR));
aclError ret = aclrtFunctionGetAvailDynUbufPerBlock(func, flags, &dynamicUbufSize);
EXPECT_EQ(ret, ACL_ERROR_RT_INTERNAL_ERROR);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetAvailDynUbufPerBlock_FeatureNotSupportTest)
{
void *func = (void *)0x01;
uint32_t flags = 0U;
size_t dynamicUbufSize = 0U;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetAvailDynUbufPerBlock(func, flags, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
aclError ret = aclrtFunctionGetAvailDynUbufPerBlock(func, flags, &dynamicUbufSize);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtLaunchKernelWithArgsArray_NumBlocksZeroTest)
{
void *func = (void *)0x01;
uint32_t numBlocks = 0;
aclrtStream stream = nullptr;
aclrtLaunchKernelCfg cfg = {};
void *argsArray[2] = {(void *)0x10, (void *)0x20};
aclError ret = aclrtLaunchKernelWithArgsArray(func, numBlocks, stream, &cfg, argsArray);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtLaunchKernelWithArgsArray_CfgNullptrTest)
{
void *func = (void *)0x01;
uint32_t numBlocks = 1;
aclrtStream stream = nullptr;
void *argsArray[2] = {(void *)0x10, (void *)0x20};
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtLaunchKernelWithArgsArray(_, _, _, nullptr, _))
.WillOnce(Return(RT_ERROR_NONE));
aclError ret = aclrtLaunchKernelWithArgsArray(func, numBlocks, stream, nullptr, argsArray);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetParamCount_FeatureNotSupportTest)
{
void *func = (void *)0x01;
size_t paramCount = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetParamCount(_, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
aclError ret = aclrtFunctionGetParamCount(func, ¶mCount);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetParamInfo_FeatureNotSupportTest)
{
void *func = (void *)0x01;
size_t paramIndex = 0;
size_t paramOffset = 0;
size_t paramSize = 0;
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtFunctionGetParamInfo(_, _, _, _))
.WillOnce(Return(ACL_ERROR_RT_FEATURE_NOT_SUPPORT));
aclError ret = aclrtFunctionGetParamInfo(func, paramIndex, ¶mOffset, ¶mSize);
EXPECT_EQ(ret, ACL_ERROR_RT_FEATURE_NOT_SUPPORT);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFuncBySymbol_success)
{
const void *symbol = (const void *)0x01;
aclrtFuncHandle funcHandle = nullptr;
const auto ret = aclrtGetFuncBySymbol(symbol, &funcHandle);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetFuncBySymbol_failed_with_invalid_args)
{
const void *symbol = (const void *)0x01;
aclrtFuncHandle funcHandle = nullptr;
auto ret = aclrtGetFuncBySymbol(nullptr, &funcHandle);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtGetFuncBySymbol(symbol, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtGetFuncBySymbol(_, _))
.WillOnce(Return(ACL_ERROR_RT_PARAM_INVALID));
ret = aclrtGetFuncBySymbol(symbol, &funcHandle);
EXPECT_EQ(ret, ACL_ERROR_RT_PARAM_INVALID);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetParamCount_FuncNullptrTest)
{
size_t paramCount = 0;
aclError ret = aclrtFunctionGetParamCount(nullptr, ¶mCount);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetParamCount_ParamCountNullptrTest)
{
void *func = (void *)0x01;
aclError ret = aclrtFunctionGetParamCount(func, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetParamInfo_FuncNullptrTest)
{
size_t paramIndex = 0;
size_t paramOffset = 0;
size_t paramSize = 0;
aclError ret = aclrtFunctionGetParamInfo(nullptr, paramIndex, ¶mOffset, ¶mSize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetParamInfo_BothOutputNullptrTest)
{
void *func = (void *)0x01;
size_t paramIndex = 0;
aclError ret = aclrtFunctionGetParamInfo(func, paramIndex, nullptr, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetAvailDynUbufPerBlock_FuncNullptrTest)
{
uint32_t flags = 0U;
size_t dynamicUbufSize = 0U;
aclError ret = aclrtFunctionGetAvailDynUbufPerBlock(nullptr, flags, &dynamicUbufSize);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtFunctionGetAvailDynUbufPerBlock_OutputNullptrTest)
{
void *func = (void *)0x01;
uint32_t flags = 0U;
aclError ret = aclrtFunctionGetAvailDynUbufPerBlock(func, flags, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
}
TEST_F(UTEST_ACL_Runtime, aclrtGetSymbolAddressTest)
{
int hostVar = 0;
void *devPtr = nullptr;
aclError ret = aclrtGetSymbolAddress(static_cast<const void *>(nullptr), &devPtr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtGetSymbolAddress(hostVar, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_SYMBOL));
ret = aclrtGetSymbolAddress(hostVar, &devPtr);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_SYMBOL);
void *expectedDevPtr = reinterpret_cast<void *>(0x1234);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<1>(expectedDevPtr), Return(RT_ERROR_NONE)));
ret = aclrtGetSymbolAddress(hostVar, &devPtr);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_EQ(devPtr, expectedDevPtr);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyFromSymbolTest)
{
char dst[10] = {};
int hostVar = 0;
size_t symbolSize = 100;
aclError ret = aclrtMemcpyFromSymbol(nullptr, 10, hostVar, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyFromSymbol(dst, 5, hostVar, 10, 0, ACL_MEMCPY_DEVICE_TO_HOST);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyFromSymbol(dst, 10, hostVar, 5, 0, (aclrtMemcpyKind)999);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyFromSymbol(dst, 10, hostVar, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_SYMBOL));
ret = aclrtMemcpyFromSymbol(dst, 10, hostVar, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_SYMBOL);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(5), Return(RT_ERROR_NONE)));
ret = aclrtMemcpyFromSymbol(dst, 10, hostVar, 5, 3, ACL_MEMCPY_DEVICE_TO_HOST);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
ret = aclrtMemcpyFromSymbol(dst, 10, hostVar, 1, SIZE_MAX, ACL_MEMCPY_DEVICE_TO_HOST);
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyFromSymbol(dst, 10, hostVar, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyFromSymbol(dst, 10, hostVar, 5, 0, ACL_MEMCPY_DEFAULT);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyFromSymbol(dst, 10, hostVar, 0, 0, ACL_MEMCPY_DEFAULT);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyFromSymbolAsyncTest)
{
char dst[10] = {};
int hostVar = 0;
aclrtStream stream = (aclrtStream)0x10;
size_t symbolSize = 100;
aclError ret = aclrtMemcpyFromSymbolAsync(nullptr, 10, hostVar, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyFromSymbolAsync(dst, 5, hostVar, 10, 0, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 5, 0, (aclrtMemcpyKind)999, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_SYMBOL));
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_SYMBOL);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(5), Return(RT_ERROR_NONE)));
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 5, 3, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 1, SIZE_MAX, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsync(_, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsync(_, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 5, 0, ACL_MEMCPY_DEFAULT, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyFromSymbolAsync(dst, 10, hostVar, 0, 0, ACL_MEMCPY_DEFAULT, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyToSymbolTest)
{
int hostVar = 0;
char src[10] = {};
size_t symbolSize = 100;
aclError ret = aclrtMemcpyToSymbol(hostVar, nullptr, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyToSymbol(hostVar, src, 5, 0, (aclrtMemcpyKind)999);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyToSymbol(hostVar, src, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_SYMBOL));
ret = aclrtMemcpyToSymbol(hostVar, src, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_SYMBOL);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(5), Return(RT_ERROR_NONE)));
ret = aclrtMemcpyToSymbol(hostVar, src, 5, 3, ACL_MEMCPY_HOST_TO_DEVICE);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
ret = aclrtMemcpyToSymbol(hostVar, src, 1, SIZE_MAX, ACL_MEMCPY_HOST_TO_DEVICE);
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyToSymbol(hostVar, src, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpy(_, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyToSymbol(hostVar, src, 5, 0, ACL_MEMCPY_DEFAULT);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyToSymbol(hostVar, src, 0, 0, ACL_MEMCPY_DEFAULT);
EXPECT_EQ(ret, ACL_SUCCESS);
}
TEST_F(UTEST_ACL_Runtime, aclrtMemcpyToSymbolAsyncTest)
{
int hostVar = 0;
char src[10] = {};
aclrtStream stream = (aclrtStream)0x10;
size_t symbolSize = 100;
aclError ret = aclrtMemcpyToSymbolAsync(hostVar, nullptr, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 5, 0, (aclrtMemcpyKind)999, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 5, 0, ACL_MEMCPY_DEVICE_TO_HOST, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE, nullptr);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(Return(ACL_ERROR_RT_INVALID_SYMBOL));
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_ERROR_RT_INVALID_SYMBOL);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(5), Return(RT_ERROR_NONE)));
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 5, 3, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_ERROR_INVALID_PARAM);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 1, SIZE_MAX, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_ERROR_FAILURE);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsync(_, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 5, 0, ACL_MEMCPY_HOST_TO_DEVICE, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtSymbolLookup(_, _, _))
.WillOnce(DoAll(SetArgPointee<2>(symbolSize), Return(RT_ERROR_NONE)));
EXPECT_CALL(MockFunctionTest::aclStubInstance(), rtMemcpyAsync(_, _, _, _, _, _))
.WillOnce(Return(RT_ERROR_NONE));
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 5, 0, ACL_MEMCPY_DEFAULT, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
ret = aclrtMemcpyToSymbolAsync(hostVar, src, 0, 0, ACL_MEMCPY_DEFAULT, stream);
EXPECT_EQ(ret, ACL_SUCCESS);
}
