openharmony/device_manager
1
0
Fork 0
mirror of https://github.com/openharmony/device_manager.git synced 2026-07-19 18:13:32 -04:00
Code Issues Packages Projects Releases Wiki Activity

!6 修复codecheck

Browse Source 
Merge pull request !6 from renguang1116/master

Signed-off-by: puhui <puhui1@huawei.com>
This commit is contained in:
蒲辉
2022-01-13 08:07:35 +00:00
committed by Gitee
parent d9a9f60882 44c100bb71
commit eb51022e08
27 changed files with 123 additions and 225 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common/include/dm_constants.h
-2
View File
@@ -16,7 +16,6 @@
#ifndef OHOS_DM_CONSTANTS_H
#define OHOS_DM_CONSTANTS_H
#include <cstdint>
#include <string>
namespace OHOS {
@@ -43,7 +42,6 @@ const int32_t MIN_PIN_CODE = 100000;
const int32_t MAX_PIN_CODE = 999999;
const int32_t DISCOVER_STATUS_LEN = 20;
const int32_t COMMON_CALLBACK_MAX_SIZE = 200;
// const int32_t TOKEN_LEN = 9;
enum {
DM_OK = 0,
ext/pin_auth/include/ability/dm_ability_manager.h
-3
View File
@@ -16,9 +16,6 @@
#ifndef OHOS_DM_ABILITY_MANAGER_H
#define OHOS_DM_ABILITY_MANAGER_H
#include <semaphore.h>
#include <mutex>
#include <string>
#include <vector>
ext/pin_auth/src/pin_auth.cpp
+2 -1
View File
@@ -23,6 +23,7 @@
namespace OHOS {
namespace DistributedHardware {
const int32_t MAX_VERIFY_TIMES = 3;
PinAuth::PinAuth()
{
LOGI("PinAuth constructor");
@@ -59,7 +60,7 @@ int32_t PinAuth::VerifyAuthentication(std::string pinToken, int32_t code, const
int32_t inputPinToken = jsonObject[PIN_TOKEN];
if (code == inputPinCode && stoi(pinToken) == inputPinToken) {
return DM_OK;
} else if (code != inputPinCode && times_ < 3) {
} else if (code != inputPinCode && times_ < MAX_VERIFY_TIMES) {
return DM_AUTH_INPUT_FAILED;
} else {
return DM_FAILED;
interfaces/inner_kits/native_cpp/include/device_manager.h
-2
View File
@@ -21,8 +21,6 @@
#include <vector>
#include "device_manager_callback.h"
#include "dm_device_info.h"
#include "dm_subscribe_info.h"
namespace OHOS {
namespace DistributedHardware {
interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_cmd_parser.cpp
-1
View File
@@ -287,7 +287,6 @@ ON_IPC_CMD(SERVER_AUTH_RESULT, IpcIo &reply)
std::string pkgName = (const char *)IpcIoPopString(&reply, &len);
size_t devIdLen = 0;
std::string deviceId = (const char *)IpcIoPopString(&reply, &devIdLen);
// int32_t pinToken = IpcIoPopInt32(&reply);
int32_t status = IpcIoPopInt32(&reply);
int32_t reason = IpcIoPopInt32(&reply);
interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp
-1
View File
@@ -233,7 +233,6 @@ ON_IPC_SET_REQUEST(AUTHENTICATE_DEVICE, std::shared_ptr<IpcReq> pBaseReq, Messag
int32_t authType = pReq->GetAuthType();
DmDeviceInfo deviceInfo = pReq->GetDeviceInfo();
std::string deviceId = deviceInfo.deviceId;
// DmAppImageInfo imageInfo = pReq->GetAppImageInfo();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
interfaces/kits/js/include/native_devicemanager_js.h
-2
View File
@@ -205,8 +205,6 @@ public:
static void JsToDmTokenInfo(const napi_env &env, const napi_value &object, const std::string &fieldStr,
nlohmann::json &jsonObj);
static void JsToDmAuthExtra(const napi_env &env, const napi_value &param, nlohmann::json &jsonObj);
// static void JsToDmFilterOptions(const napi_env &env, const napi_value &object,
// OHOS::DistributedHardware::DmFilterOptions &filterOptions);
static void DmDeviceInfotoJsDeviceInfo(const napi_env &env,
const OHOS::DistributedHardware::DmDeviceInfo &vecDevInfo,
napi_value &result);
interfaces/kits/js/src/native_devicemanager_js.cpp
+5 -12
View File
@@ -530,7 +530,6 @@ void DeviceManagerNapi::JsToDmExtra(const napi_env &env, const napi_value &objec
uint8_t *appThumbnailBufferPtr = nullptr;
int32_t appThumbnailBufferLen = 0;
JsToDmBuffer(env, object, "appThumbnail", &appThumbnailBufferPtr, appThumbnailBufferLen);
// appImageInfo.Reset(appIconBufferPtr, appIconBufferLen, appThumbnailBufferPtr, appThumbnailBufferLen);
if (appIconBufferPtr != nullptr) {
free(appIconBufferPtr);
appIconBufferPtr = nullptr;
@@ -1048,7 +1047,6 @@ napi_value DeviceManagerNapi::CallDeviceList(napi_env env, napi_callback_info in
return result;
} else {
LOGE("CallDeviceList for argc %d Type = %d", argc, (int)eventHandleType);
// DmFilterOptions filterOptions;
napi_deferred deferred;
napi_value promise = 0;
napi_create_promise(env, &deferred, &promise);
@@ -1125,8 +1123,7 @@ napi_value DeviceManagerNapi::GetTrustedDeviceList(napi_env env, napi_callback_i
return promise;
} else if (argc == 1) {
return CallDeviceList(env, info, deviceInfoAsyncCallbackInfo);
} else if (argc == 2) {
// DmFilterOptions filterOptions;
} else if (argc == DM_NAPI_ARGS_TWO) {
GET_PARAMS(env, info, DM_NAPI_ARGS_TWO);
napi_valuetype valueType;
napi_typeof(env, argv[0], &valueType);
@@ -1389,10 +1386,6 @@ napi_value DeviceManagerNapi::JsOnFrench(napi_env env, int32_t num, napi_value t
NAPI_ASSERT(env, typeLen < DM_NAPI_BUF_LENGTH, "typeLen >= MAXLEN");
char type[DM_NAPI_BUF_LENGTH] = {0};
napi_get_value_string_utf8(env, argv[0], type, typeLen + 1, &typeLen);
if (num) {
// DmFilterOptions filterOptions;
// JsToDmFilterOptions(env, argv[1], filterOptions);
}
std::string eventType = type;
DeviceManagerNapi *deviceManagerWrapper = nullptr;
@@ -1413,7 +1406,7 @@ napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info)
size_t argc = 0;
napi_value thisVar = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
if (argc == 3) {
if (argc == DM_NAPI_ARGS_THREE) {
LOGI("JsOff in argc == 3");
GET_PARAMS(env, info, DM_NAPI_ARGS_THREE);
NAPI_ASSERT(env, argc >= DM_NAPI_ARGS_THREE, "Wrong number of arguments, required 2");
@@ -1427,7 +1420,7 @@ napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info)
NAPI_ASSERT(env, valueType == napi_object, "type mismatch for parameter 2");
napi_valuetype eventHandleType = napi_undefined;
napi_typeof(env, argv[2], &eventHandleType);
napi_typeof(env, argv[DM_NAPI_ARGS_TWO], &eventHandleType);
NAPI_ASSERT(env, eventHandleType == napi_function, "type mismatch for parameter 3");
return JsOnFrench(env, 1, thisVar, argv);
@@ -1475,7 +1468,7 @@ napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info)
size_t argc = 0;
napi_value thisVar = nullptr;
NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
if (argc == 3) {
if (argc == DM_NAPI_ARGS_THREE) {
LOGI("JsOff in argc == 3");
GET_PARAMS(env, info, DM_NAPI_ARGS_THREE);
size_t requireArgc = 1;
@@ -1491,7 +1484,7 @@ napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info)
if (argc > requireArgc) {
napi_valuetype eventHandleType = napi_undefined;
napi_typeof(env, argv[2], &eventHandleType);
napi_typeof(env, argv[DM_NAPI_ARGS_TWO], &eventHandleType);
NAPI_ASSERT(env, eventValueType == napi_function, "type mismatch for parameter 2");
}
return JsOffFrench(env, 1, thisVar, argv);
services/devicemanagerservice/include/adapter/crypto_adapter.h
-3
View File
@@ -15,9 +15,6 @@
#ifndef OHOS_DM_CRYPTO_ADAPTER_H
#define OHOS_DM_CRYPTO_ADAPTER_H
#include <cstdint>
namespace OHOS {
namespace DistributedHardware {
class ICryptoAdapter {
services/devicemanagerservice/include/adapter/profile_adapter.h
-1
View File
@@ -16,7 +16,6 @@
#ifndef OHOS_DM_PROFILE_ADAPTER_H
#define OHOS_DM_PROFILE_ADAPTER_H
#include <cstdint>
#include <string>
namespace OHOS {
services/devicemanagerservice/src/ability/lite/dm_ability_manager.cpp
-1
View File
@@ -16,7 +16,6 @@
#include "dm_ability_manager.h"
#include "dm_constants.h"
#include "semaphore.h"
namespace OHOS {
namespace DistributedHardware {
services/devicemanagerservice/src/adapter/standard/dm_adapter_manager.cpp
-2
View File
@@ -15,8 +15,6 @@
#include "dm_adapter_manager.h"
#include <dlfcn.h>
#include "config_manager.h"
#include "dm_constants.h"
#include "dm_log.h"
services/devicemanagerservice/src/authentication/auth_message_processor.cpp
-2
View File
@@ -219,7 +219,6 @@ void AuthMessageProcessor::ParseAuthResponseMessage(nlohmann::json &json)
authResponseContext_->reply = json[TAG_REPLY];
authResponseContext_->deviceId = json[TAG_DEVICE_ID];
authResponseContext_->token = json[TAG_TOKEN];
// authResponseContext_->deviceId = json[TAG_GROUPIDS];
if (authResponseContext_->reply == 0) {
authResponseContext_->code = json[PIN_CODE_KEY];
authResponseContext_->networkId = json[TAG_NET_ID];
@@ -237,7 +236,6 @@ void AuthMessageProcessor::ParseAuthRequestMessage()
nlohmann::json jsonObject = authSplitJsonList_.front();
authResponseContext_->deviceId = jsonObject[TAG_DEVICE_ID];
authResponseContext_->reply = jsonObject[TAG_REPLY];
// authResponseContext_->syncGroupList = jsonObject[TAG_GROUPIDS];
authResponseContext_->authType = jsonObject[TAG_AUTH_TYPE];
LOGI("AuthMessageProcessor::ParseAuthResponseMessage %d,%d", authResponseContext_->reply);
LOGI("AuthMessageProcessor::ParseAuthResponseMessage %s", authResponseContext_->deviceId.c_str());
services/devicemanagerservice/src/authentication/auth_request_state.cpp
-12
View File
@@ -15,8 +15,6 @@
#include "auth_request_state.h"
#include <utility>
#include "dm_auth_manager.h"
#include "dm_constants.h"
@@ -32,10 +30,6 @@ void AuthRequestState::SetAuthManager(std::shared_ptr<DmAuthManager> authManager
authManager_ = std::move(authManager);
}
// void AuthRequestState::SetLastState(std::shared_ptr<AuthRequestState> state) {
// lastState_ = state;
// }
void AuthRequestState::SetAuthContext(std::shared_ptr<DmAuthRequestContext> context)
{
context_ = std::move(context);
@@ -99,12 +93,6 @@ int32_t AuthRequestNegotiateDoneState::GetStateType()
void AuthRequestNegotiateDoneState::Enter()
{
// //1. 获取对端加解密信息,并对比两端状态
//
// //2. 保存加解密状态，发送认证请求
// authMessageProcessor_->CreateMessage(MSG_TYPE_REQ_AUTH);
// std::string message;
// softbusSession_->SendData(context_.sessionId, message);
std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock();
if (stateAuthManager == nullptr) {
LOGE("AuthRequestState::authManager_ null");
services/devicemanagerservice/src/authentication/auth_response_state.cpp
-2
View File
@@ -94,7 +94,6 @@ void AuthResponseConfirmState::Enter()
{
//委托授权UI模块进行用户交互
//如果交互成功
// TransitionTo(new AuthResponseGroupState());
LOGI("AuthResponse:: AuthResponseConfirmState Enter");
std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock();
if (stateAuthManager == nullptr) {
@@ -112,7 +111,6 @@ int32_t AuthResponseGroupState::GetStateType()
void AuthResponseGroupState::Enter()
{
// //1.创建群组,
// authManagerPtr_->GetHiChainConnector()->CreateGroup();
LOGI("AuthResponse:: AuthResponseGroupState Enter");
std::shared_ptr<DmAuthManager> stateAuthManager = authManager_.lock();
if (stateAuthManager == nullptr) {
services/devicemanagerservice/src/authentication/dm_auth_manager.cpp
+21 -31
View File
@@ -80,13 +80,6 @@ DmAuthManager::~DmAuthManager()
int32_t DmAuthManager::AuthenticateDevice(const std::string &pkgName, int32_t authType, const std::string &deviceId,
const std::string &extra)
{
// TODO:检查pkgName的权限
// std::shared_ptr<IAuthentication> authentication = authenticationMap_[authType];
// if (authentication == nullptr) {
// LOGE("DmAuthManager::AuthenticateDevice authType %d not support.", authType);
// return DM_AUTH_NOT_SUPPORT;
// }
LOGE("DmAuthManager::AuthenticateDevice is");
if (authRequestState_ != nullptr && authResponseState_ != nullptr) {
LOGE("DmAuthManager::AuthenticateDevice %s is request authentication.",
@@ -141,7 +134,7 @@ int32_t DmAuthManager::AuthenticateDevice(const std::string &pkgName, int32_t au
}
}
authRequestContext_->token = std::to_string(GenRandInt(MIN_PIN_TOKEN, MAX_PIN_TOKEN));
authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
authRequestState_ = std::make_shared<AuthRequestInitState>();
authRequestState_->SetAuthManager(shared_from_this());
authRequestState_->SetAuthContext(authRequestContext_);
authRequestState_->Enter();
@@ -181,7 +174,6 @@ int32_t DmAuthManager::UnAuthenticateDevice(const std::string &pkgName, const st
LOGE("DmAuthManager::UnAuthenticateDevice groupList.size = 0");
return DM_FAILED;
}
// groupId = authResponseContext_->groupId;
return DM_OK;
}
@@ -201,7 +193,7 @@ int32_t DmAuthManager::VerifyAuthentication(const std::string &authParam)
switch (ret) {
case DM_OK:
{
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestJoinState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestJoinState>());
}
break;
case DM_AUTH_INPUT_FAILED:
@@ -214,7 +206,7 @@ int32_t DmAuthManager::VerifyAuthentication(const std::string &authParam)
default:
{
CancelDisplay();
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestFinishState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestFinishState>());
}
}
@@ -228,7 +220,7 @@ void DmAuthManager::OnSessionOpened(const std::string &pkgName, int32_t sessionI
if (sessionSide == AUTH_SESSION_SIDE_SERVER) {
if (authResponseState_ == nullptr) {
authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(shared_from_this());
authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseInitState());
authResponseState_ = std::make_shared<AuthResponseInitState>();
authResponseState_->SetAuthManager(shared_from_this());
authResponseState_->Enter();
hiChainConnector_->RegisterHiChainCallback(pkgName, shared_from_this());
@@ -255,7 +247,7 @@ void DmAuthManager::OnSessionOpened(const std::string &pkgName, int32_t sessionI
authRequestState_->SetAuthContext(authRequestContext_);
authMessageProcessor_->SetRequestContext(authRequestContext_);
authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestNegotiateState>());
} else {
LOGE("DmAuthManager::OnSessionOpened but request state %d is wrong", authRequestState_->GetStateType());
}
@@ -292,7 +284,7 @@ void DmAuthManager::OnDataReceived(const std::string &pkgName, int32_t sessionId
case MSG_TYPE_NEGOTIATE:
if (authResponseState_->GetStateType() == AuthState::AUTH_RESPONSE_INIT) {
timerMap_[WAIT_NEGOTIATE_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT);
authResponseState_->TransitionTo(std::shared_ptr<AuthResponseState>(new AuthResponseNegotiateState()));
authResponseState_->TransitionTo(std::make_shared<AuthResponseNegotiateState>());
} else {
LOGE("Device manager auth state error");
}
@@ -300,21 +292,21 @@ void DmAuthManager::OnDataReceived(const std::string &pkgName, int32_t sessionId
case MSG_TYPE_REQ_AUTH:
if (authResponseState_->GetStateType() == AuthState::AUTH_RESPONSE_NEGOTIATE) {
timerMap_[WAIT_REQUEST_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT);
authResponseState_->TransitionTo(std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState()));
authResponseState_->TransitionTo(std::make_shared<AuthResponseConfirmState>());
} else {
LOGE("Device manager auth state error");
}
break;
case MSG_TYPE_RESP_AUTH:
if (authRequestState_->GetStateType() == AuthState::AUTH_REQUEST_NEGOTIATE_DONE) {
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestReplyState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestReplyState>());
} else {
LOGE("Device manager auth state error");
}
break;
case MSG_TYPE_RESP_NEGOTIATE:
if (authRequestState_->GetStateType() == AuthState::AUTH_REQUEST_NEGOTIATE) {
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateDoneState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestNegotiateDoneState>());
} else {
LOGE("Device manager auth state error");
}
@@ -322,7 +314,7 @@ void DmAuthManager::OnDataReceived(const std::string &pkgName, int32_t sessionId
case MSG_TYPE_REQ_AUTH_TERMINATE:
if (authResponseState_ != nullptr &&
authResponseState_->GetStateType() != AuthState::AUTH_RESPONSE_FINISH) {
authResponseState_->TransitionTo(std::shared_ptr<AuthResponseState>(new AuthResponseFinishState()));
authResponseState_->TransitionTo(std::make_shared<AuthResponseFinishState>());
} else if (authRequestState_ != nullptr &&
authRequestState_->GetStateType() != AuthState::AUTH_REQUEST_FINISH) {
LOGE("Device manager auth state error");
@@ -353,7 +345,7 @@ void DmAuthManager::OnGroupCreated(int64_t requestId, const std::string &groupId
authMessageProcessor_->SetResponseContext(authResponseContext_);
std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_RESP_AUTH);
softbusConnector_->GetSoftbusSession()->SendData(authResponseContext_->sessionId, message);
authResponseState_->TransitionTo(std::shared_ptr<AuthResponseState>(new AuthResponseShowState()));
authResponseState_->TransitionTo(std::make_shared<AuthResponseShowState>());
}
void DmAuthManager::OnMemberJoin(int64_t requestId, int32_t status)
@@ -365,16 +357,14 @@ void DmAuthManager::OnMemberJoin(int64_t requestId, int32_t status)
if (authRequestState_ != nullptr) {
timerMap_[ADD_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT);
if (status != DM_OK || authResponseContext_->requestId != requestId) {
if (authRequestState_ == nullptr) {
// authResponseState_->TransitionTo(std::shared_ptr<AuthResponseState>(new AuthResponseFinishState()));
} else {
if (authRequestState_ != nullptr) {
authResponseContext_->reply = AuthState::AUTH_REQUEST_JOIN;
authRequestContext_->reason = DM_AUTH_INPUT_FAILED;
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestFinishState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestFinishState>());
return;
}
}
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestNetworkState>());
}
}
@@ -388,7 +378,7 @@ void DmAuthManager::HandleAuthenticateTimeout()
}
authResponseContext_->reply = authRequestState_->GetStateType();
authRequestContext_->reason = DM_TIME_OUT;
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestFinishState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestFinishState>());
}
LOGI("DmAuthManager::HandleAuthenticateTimeout start complete");
}
@@ -403,7 +393,7 @@ void DmAuthManager::EstablishAuthChannel(const std::string &deviceId)
authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authResponseContext_->reply = AuthState::AUTH_REQUEST_NEGOTIATE;
authRequestContext_->reason = DM_AUTH_OPEN_SESSION_FAILED;
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestFinishState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestFinishState>());
}
}
@@ -466,7 +456,7 @@ void DmAuthManager::SendAuthRequest(const int32_t &sessionId)
}
if (authResponseContext_->reply == DM_AUTH_PEER_REJECT) {
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestFinishState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestFinishState>());
return;
}
@@ -488,7 +478,7 @@ void DmAuthManager::StartAuthProcess(const int32_t &action)
authResponseContext_->reply = action;
if (authResponseContext_->reply == USER_OPERATION_TYPE_ALLOW_AUTH &&
authResponseState_->GetStateType() == AuthState::AUTH_RESPONSE_CONFIRM) {
authResponseState_->TransitionTo(std::shared_ptr<AuthResponseState>(new AuthResponseGroupState()));
authResponseState_->TransitionTo(std::make_shared<AuthResponseGroupState>());
} else {
authMessageProcessor_->SetResponseContext(authResponseContext_);
std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_RESP_AUTH);
@@ -504,12 +494,12 @@ void DmAuthManager::StartRespAuthProcess()
std::shared_ptr<DmTimer> inputStartTimer = std::make_shared<DmTimer>(INPUT_TIMEOUT_TASK);
timerMap_[INPUT_TIMEOUT_TASK] = inputStartTimer;
inputStartTimer->Start(INPUT_TIMEOUT, TimeOut, this);
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestInputState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestInputState>());
} else {
LOGE("do not accept");
authResponseContext_->reply = AuthState::AUTH_REQUEST_REPLY;
authRequestContext_->reason = DM_AUTH_PEER_REJECT;
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestFinishState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestFinishState>());
}
}
@@ -557,7 +547,7 @@ void DmAuthManager::JoinNetwork()
timerMap_[AUTHENTICATE_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT);
authResponseContext_->reply = AuthState::AUTH_REQUEST_FINISH;
authRequestContext_->reason = DM_OK;
authRequestState_->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestFinishState()));
authRequestState_->TransitionTo(std::make_shared<AuthRequestFinishState>());
}
void DmAuthManager::AuthenticateFinish()
services/devicemanagerservice/src/dependency/commonevent/event_manager_adapt.cpp
-2
View File
@@ -15,8 +15,6 @@
#include "event_manager_adapt.h"
#include <thread>
#include "dm_constants.h"
using namespace OHOS::EventFwk;
services/devicemanagerservice/src/dependency/hichain/hichain_connector.cpp
-3
View File
@@ -196,9 +196,6 @@ int32_t HiChainConnector::AddMember(std::string deviceId, std::string &connectIn
jsonObj[FIELD_CONNECT_PARAMS] = connectInfomation.c_str();
std::string tmpStr = jsonObj.dump();
int64_t requestId = jsonObject[TAG_REQUEST_ID];
// LOGI("HiChainConnector::AddMember completed requestId%d, jsonObject[TAG_GROUP_ID]%s ", requestId,
// groupId.c_str()); LOGI("HiChainConnector::AddMember completed DM_PKG_NAME %s", DM_PKG_NAME.c_str());
// LOGI("HiChainConnector::AddMember completedtmpStr%s", tmpStr.c_str());
int32_t ret = deviceGroupManager_->addMemberToGroup(requestId, DM_PKG_NAME.c_str(), tmpStr.c_str());
LOGI("HiChainConnector::AddMember completed");
return ret;
services/devicemanagerservice/src/dependency/softbus/softbus_connector.cpp
-5
View File
@@ -16,10 +16,6 @@
#include "softbus_connector.h"
#include <securec.h>
#include <unistd.h>
#include <cstdlib>
#include <string>
#include "dm_anonymous.h"
#include "dm_constants.h"
@@ -110,7 +106,6 @@ int32_t SoftbusConnector::Init()
LOGI("service unpublish result is : %d", ret);
}
// ret = WatchParameter(DISCOVER_STATUS_KEY.c_str(), &SoftbusConnector::OnParameterChgCallback, nullptr);
LOGI("register Watch Parameter result is : %d");
return ret;
}
services/devicemanagerservice/src/device_manager_service_listener.cpp
-3
View File
@@ -15,8 +15,6 @@
#include "device_manager_service_listener.h"
#include <memory>
#include "dm_anonymous.h"
#include "dm_constants.h"
#include "dm_log.h"
@@ -91,7 +89,6 @@ void DeviceManagerServiceListener::OnAuthResult(const std::string &pkgName, cons
pReq->SetDeviceId(deviceId);
pReq->SetToken(token);
pReq->SetStatus(status);
// pReq->SetReason(reason);
ipcServerListener_.SendRequest(SERVER_AUTH_RESULT, pReq, pRsp);
}
services/devicemanagerservice/src/devicestate/dm_device_state_manager.cpp
-1
View File
@@ -100,7 +100,6 @@ void DmDeviceStateManager::OnDeviceReady(const std::string &pkgName, const DmDev
void DmDeviceStateManager::OnProfileReady(const std::string &pkgName, const std::string deviceId)
{
//deviceId is uuid;
DmDeviceInfo saveInfo;
auto iter = remoteDeviceInfos_.find(deviceId);
if (iter == remoteDeviceInfos_.end()) {
test/unittest/UTTest_auth_request_state.cpp
+37 -49
View File
@@ -54,7 +54,7 @@ HWTEST_F(AuthRequestStateTest, SetAuthManager_001, testing::ext::TestSize.Level0
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
authRequestState->SetAuthManager(authManager);
int32_t ret = authRequestState->authManager_.use_count();
authRequestState->authManager_.reset();
@@ -71,7 +71,7 @@ HWTEST_F(AuthRequestStateTest, SetAuthManager_001, testing::ext::TestSize.Level0
*/
HWTEST_F(AuthRequestStateTest, SetAuthManager_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
authRequestState->SetAuthManager(nullptr);
int32_t ret = authRequestState->authManager_.use_count();
authRequestState->authManager_.reset();
@@ -91,10 +91,10 @@ HWTEST_F(AuthRequestStateTest, TransitionTo_001, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
authManager = nullptr;
authRequestState->authManager_ = authManager;
int32_t ret = authRequestState->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState()));
int32_t ret = authRequestState->TransitionTo(std::make_shared<AuthRequestNegotiateState>());
ASSERT_EQ(ret, DM_FAILED);
sleep(15);
}
@@ -113,14 +113,14 @@ HWTEST_F(AuthRequestStateTest, TransitionTo_002, testing::ext::TestSize.Level0)
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
context->sessionId = 123456;
authRequestState->SetAuthContext(context);
authRequestState->SetAuthManager(authManager);
int32_t ret = authRequestState->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState()));
int32_t ret = authRequestState->TransitionTo(std::make_shared<AuthRequestNegotiateState>());
ASSERT_EQ(ret, DM_OK);
sleep(20);
}
@@ -134,7 +134,7 @@ HWTEST_F(AuthRequestStateTest, TransitionTo_002, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthRequestStateTest, GetStateType_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
int32_t ret = authRequestState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_REQUEST_INIT);
sleep(15);
@@ -153,7 +153,7 @@ HWTEST_F(AuthRequestStateTest, Enter_001, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
authManager = nullptr;
authRequestState->SetAuthManager(authManager);
int32_t ret = authRequestState->Enter();
@@ -174,10 +174,10 @@ HWTEST_F(AuthRequestStateTest, Enter_002, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
authManager->authRequestState_ = std::make_shared<AuthRequestInitState>();
authRequestState->SetAuthManager(authManager);
std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
context->deviceId = "123456";
@@ -196,8 +196,7 @@ HWTEST_F(AuthRequestStateTest, Enter_002, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthRequestStateTest, GetStateType_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
int32_t ret = authRequestState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NEGOTIATE);
sleep(15);
@@ -216,8 +215,7 @@ HWTEST_F(AuthRequestStateTest, Enter_003, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
authRequestState->SetAuthManager(nullptr);
int32_t ret = authRequestState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -237,13 +235,12 @@ HWTEST_F(AuthRequestStateTest, Enter_004, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState());
authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
authManager->authRequestContext_->deviceId = "111";
authRequestState->SetAuthManager(authManager);
std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
@@ -264,8 +261,7 @@ HWTEST_F(AuthRequestStateTest, Enter_004, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthRequestStateTest, GetStateType_003, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateDoneState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
int32_t ret = authRequestState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NEGOTIATE_DONE);
sleep(15);
@@ -284,8 +280,7 @@ HWTEST_F(AuthRequestStateTest, Enter_005, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateDoneState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
authRequestState->SetAuthManager(nullptr);
int32_t ret = authRequestState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -305,8 +300,7 @@ HWTEST_F(AuthRequestStateTest, Enter_006, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateDoneState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateDoneState>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
std::shared_ptr<DmTimer> negotiateStartTimer = std::make_shared<DmTimer>(NEGOTIATE_TIMEOUT_TASK);
authManager->timerMap_[NEGOTIATE_TIMEOUT_TASK] = negotiateStartTimer;
@@ -332,7 +326,7 @@ HWTEST_F(AuthRequestStateTest, Enter_006, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthRequestStateTest, GetStateType_004, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestReplyState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
int32_t ret = authRequestState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_REQUEST_REPLY);
sleep(15);
@@ -351,7 +345,7 @@ HWTEST_F(AuthRequestStateTest, Enter_007, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestReplyState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
authRequestState->SetAuthManager(nullptr);
int32_t ret = authRequestState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -371,14 +365,14 @@ HWTEST_F(AuthRequestStateTest, Enter_008, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestReplyState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestReplyState>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
std::shared_ptr<DmTimer> inputStartTimer = std::make_shared<DmTimer>(CONFIRM_TIMEOUT_TASK);
authManager->timerMap_[CONFIRM_TIMEOUT_TASK] = inputStartTimer;
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestReplyState());
authManager->authRequestState_ = std::make_shared<AuthRequestReplyState>();
authManager->authResponseContext_->sessionId = 1;
authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
@@ -401,7 +395,7 @@ HWTEST_F(AuthRequestStateTest, Enter_008, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthRequestStateTest, GetStateType_005, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInputState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInputState>();
int32_t ret = authRequestState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_REQUEST_INPUT);
sleep(15);
@@ -420,7 +414,7 @@ HWTEST_F(AuthRequestStateTest, Enter_009, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInputState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInputState>();
authRequestState->SetAuthManager(nullptr);
int32_t ret = authRequestState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -440,7 +434,7 @@ HWTEST_F(AuthRequestStateTest, Enter_010, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInputState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInputState>();
authRequestState->SetAuthManager(authManager);
int32_t ret = authRequestState->Enter();
ASSERT_EQ(ret, DM_OK);
@@ -456,7 +450,7 @@ HWTEST_F(AuthRequestStateTest, Enter_010, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthRequestStateTest, GetStateType_006, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestJoinState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
int32_t ret = authRequestState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_REQUEST_JOIN);
sleep(15);
@@ -475,7 +469,7 @@ HWTEST_F(AuthRequestStateTest, Enter_011, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestJoinState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
authRequestState->SetAuthManager(nullptr);
int32_t ret = authRequestState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -495,7 +489,7 @@ HWTEST_F(AuthRequestStateTest, Enter_012, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestJoinState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestJoinState>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
std::shared_ptr<DmTimer> joinStartTimer = std::make_shared<DmTimer>(ADD_TIMEOUT_TASK);
@@ -532,8 +526,7 @@ HWTEST_F(AuthRequestStateTest, Enter_012, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthRequestStateTest, GetStateType_007, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
int32_t ret = authRequestState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NETWORK);
sleep(15);
@@ -552,8 +545,7 @@ HWTEST_F(AuthRequestStateTest, Enter_013, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
authRequestState->SetAuthManager(nullptr);
int32_t ret = authRequestState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -573,14 +565,13 @@ HWTEST_F(AuthRequestStateTest, Enter_014, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
std::shared_ptr<DmTimer> authenticateStartTimer = std::make_shared<DmTimer>(AUTHENTICATE_TIMEOUT_TASK);
authManager->timerMap_[AUTHENTICATE_TIMEOUT_TASK] = authenticateStartTimer;
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState());
authManager->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
authManager->SetAuthRequestState(authRequestState);
authRequestState->SetAuthManager(authManager);
int32_t ret = authRequestState->Enter();
@@ -597,8 +588,7 @@ HWTEST_F(AuthRequestStateTest, Enter_014, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthRequestStateTest, GetStateType_008, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
int32_t ret = authRequestState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_REQUEST_FINISH);
sleep(15);
@@ -617,8 +607,7 @@ HWTEST_F(AuthRequestStateTest, Enter_015, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
authRequestState->SetAuthManager(nullptr);
int32_t ret = authRequestState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -638,16 +627,15 @@ HWTEST_F(AuthRequestStateTest, Enter_016, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState =
std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
std::shared_ptr<DmTimer> inputStartTimer = std::make_shared<DmTimer>(CONFIRM_TIMEOUT_TASK);
authManager->timerMap_[CONFIRM_TIMEOUT_TASK] = inputStartTimer;
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseFinishState());
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
authManager->authResponseContext_->sessionId = 1;
authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
test/unittest/UTTest_auth_response_state.cpp
+28 -48
View File
@@ -50,8 +50,7 @@ HWTEST_F(AuthResponseStateTest, SetAuthManager_001, testing::ext::TestSize.Level
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseInitState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
authResponseState->SetAuthManager(authManager);
int32_t ret = authResponseState->authManager_.use_count();
ASSERT_EQ(ret, 1);
@@ -68,8 +67,7 @@ HWTEST_F(AuthResponseStateTest, SetAuthManager_001, testing::ext::TestSize.Level
*/
HWTEST_F(AuthResponseStateTest, SetAuthManager_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseInitState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
authResponseState->SetAuthManager(nullptr);
int32_t ret = authResponseState->authManager_.use_count();
ASSERT_EQ(ret, 0);
@@ -89,11 +87,10 @@ HWTEST_F(AuthResponseStateTest, TransitionTo_001, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseInitState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
authManager = nullptr;
authResponseState->authManager_ = authManager;
int32_t ret = authResponseState->TransitionTo(std::shared_ptr<AuthResponseState>(new AuthResponseNegotiateState()));
int32_t ret = authResponseState->TransitionTo(std::make_shared<AuthResponseNegotiateState>(););
ASSERT_EQ(ret, DM_FAILED);
sleep(15);
}
@@ -112,14 +109,14 @@ HWTEST_F(AuthResponseStateTest, TransitionTo_002, testing::ext::TestSize.Level0)
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
context->sessionId = 123456;
authRequestState->SetAuthContext(context);
authRequestState->SetAuthManager(authManager);
int32_t ret = authRequestState->TransitionTo(std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState()));
int32_t ret = authRequestState->TransitionTo(std::make_shared<AuthRequestNegotiateState>());
ASSERT_EQ(ret, DM_OK);
sleep(20);
}
@@ -133,8 +130,7 @@ HWTEST_F(AuthResponseStateTest, TransitionTo_002, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthResponseStateTest, GetStateType_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseInitState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
int32_t ret = authResponseState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_INIT);
sleep(15);
@@ -149,8 +145,7 @@ HWTEST_F(AuthResponseStateTest, GetStateType_001, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthResponseStateTest, Enter_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseInitState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
int32_t ret = authResponseState->Enter();
ASSERT_EQ(ret, DM_OK);
sleep(15);
@@ -165,8 +160,7 @@ HWTEST_F(AuthResponseStateTest, Enter_001, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthResponseStateTest, GetStateType_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseNegotiateState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
int32_t ret = authResponseState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_NEGOTIATE);
sleep(15);
@@ -185,8 +179,7 @@ HWTEST_F(AuthResponseStateTest, Enter_002, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseNegotiateState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
authManager = nullptr;
authResponseState->SetAuthManager(authManager);
int32_t ret = authResponseState->Enter();
@@ -207,14 +200,13 @@ HWTEST_F(AuthResponseStateTest, Enter_003, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseNegotiateState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseNegotiateState());
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState());
authManager->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
authManager->authResponseContext_->deviceId = "111";
authManager->authResponseContext_->localDeviceId = "222";
authResponseState->SetAuthManager(authManager);
@@ -235,8 +227,7 @@ HWTEST_F(AuthResponseStateTest, Enter_003, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthResponseStateTest, GetStateType_003, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
int32_t ret = authResponseState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_CONFIRM);
sleep(15);
@@ -255,8 +246,7 @@ HWTEST_F(AuthResponseStateTest, Enter_004, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
authResponseState->SetAuthManager(nullptr);
int32_t ret = authResponseState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -276,8 +266,7 @@ HWTEST_F(AuthResponseStateTest, Enter_005, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
authResponseState->SetAuthManager(authManager);
int32_t ret = authResponseState->Enter();
ASSERT_EQ(ret, DM_OK);
@@ -293,8 +282,7 @@ HWTEST_F(AuthResponseStateTest, Enter_005, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthResponseStateTest, GetStateType_004, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseGroupState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
int32_t ret = authResponseState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_GROUP);
sleep(15);
@@ -313,8 +301,7 @@ HWTEST_F(AuthResponseStateTest, Enter_006, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseGroupState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
authResponseState->SetAuthManager(nullptr);
int32_t ret = authResponseState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -334,8 +321,7 @@ HWTEST_F(AuthResponseStateTest, Enter_007, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseGroupState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
@@ -354,8 +340,7 @@ HWTEST_F(AuthResponseStateTest, Enter_007, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthResponseStateTest, GetStateType_005, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseShowState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
int32_t ret = authResponseState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_SHOW);
sleep(15);
@@ -374,8 +359,7 @@ HWTEST_F(AuthResponseStateTest, Enter_008, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseShowState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
authResponseState->SetAuthManager(nullptr);
int32_t ret = authResponseState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -395,8 +379,7 @@ HWTEST_F(AuthResponseStateTest, Enter_009, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseShowState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
authResponseState->SetAuthManager(authManager);
int32_t ret = authResponseState->Enter();
ASSERT_EQ(ret, DM_OK);
@@ -412,8 +395,7 @@ HWTEST_F(AuthResponseStateTest, Enter_009, testing::ext::TestSize.Level0)
*/
HWTEST_F(AuthResponseStateTest, GetStateType_006, testing::ext::TestSize.Level0)
{
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseFinishState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
int32_t ret = authResponseState->GetStateType();
ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_FINISH);
sleep(15);
@@ -432,8 +414,7 @@ HWTEST_F(AuthResponseStateTest, Enter_010, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseFinishState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
authResponseState->SetAuthManager(nullptr);
int32_t ret = authResponseState->Enter();
ASSERT_EQ(ret, DM_FAILED);
@@ -453,10 +434,9 @@ HWTEST_F(AuthResponseStateTest, Enter_011, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState =
std::shared_ptr<AuthResponseState>(new AuthResponseFinishState());
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
authManager->authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseFinishState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
test/unittest/UTTest_device_message.h
+2 -6
View File
@@ -12,11 +12,9 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef OHOS_DEVICE_MESSAGE_TEST_H
#define OHOS_DEVICE_MESSAGE_TEST_H
#define private public
#define protected public
#include <memory>
#include <vector>
@@ -35,6 +33,4 @@ public:
};
}
}
#endif // OHOS_DM_IMPL_TEST_H
#undef private
#undef protected
#endif // OHOS_DEVICE_MESSAGE_TEST_H
test/unittest/UTTest_dm_auth_manager.cpp
+23 -23
View File
@@ -56,7 +56,7 @@ HWTEST_F(DmAuthManagerTest, AuthenticateDevice_001, testing::ext::TestSize.Level
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestInitState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestInitState>();
std::shared_ptr<DmAuthRequestContext> context = std::make_shared<DmAuthRequestContext>();
std::string pkgName = "111";
int32_t authType = 1;
@@ -79,7 +79,7 @@ HWTEST_F(DmAuthManagerTest, AuthenticateDevice_002, testing::ext::TestSize.Level
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState = std::shared_ptr<AuthResponseState>(new AuthResponseInitState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
const std::string pkgName = "111";
int32_t authType = 1;
@@ -285,12 +285,12 @@ HWTEST_F(DmAuthManagerTest, VerifyAuthentication_001, testing::ext::TestSize.Lev
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
std::shared_ptr<DmTimer> negotiateStartTimer = std::make_shared<DmTimer>(INPUT_TIMEOUT_TASK);
authManager->timerMap_[INPUT_TIMEOUT_TASK] = negotiateStartTimer;
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState());
authManager->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
authManager->authResponseContext_=nullptr;
authManager->SetAuthRequestState(authRequestState);
int32_t ret =authManager->HandleAuthenticateTimeout();
@@ -311,10 +311,10 @@ HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_001, testing::ext::TestSiz
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestNetworkState());
authManager->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
authManager->authResponseContext_=nullptr;
authManager->SetAuthRequestState(authRequestState);
int32_t ret =authManager->HandleAuthenticateTimeout();
@@ -332,10 +332,10 @@ HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_002, testing::ext::TestSiz
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
authManager->SetAuthRequestState(authRequestState);
int32_t ret =authManager->HandleAuthenticateTimeout();
ASSERT_EQ(ret,DM_OK);
@@ -356,7 +356,7 @@ HWTEST_F(DmAuthManagerTest, EstablishAuthChannel_001, testing::ext::TestSize.Lev
std::shared_ptr<DmAuthResponseContext> authRequestContext = std::make_shared<DmAuthResponseContext>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
std::string deviceId1;
int32_t ret =authManager->EstablishAuthChannel(deviceId1);
ASSERT_EQ(ret, DM_FAILED);
@@ -373,12 +373,12 @@ HWTEST_F(DmAuthManagerTest, SendAuthRequest_001, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestNegotiateState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNegotiateState>();
std::shared_ptr<DmTimer> negotiateStartTimer = std::make_shared<DmTimer>(NEGOTIATE_TIMEOUT_TASK);
authManager->timerMap_[NEGOTIATE_TIMEOUT_TASK] = negotiateStartTimer;
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();;
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
authManager->authResponseContext_->cryptoSupport = true;
authManager->SetAuthRequestState(authRequestState);
int32_t sessionId=1;
@@ -397,10 +397,10 @@ HWTEST_F(DmAuthManagerTest, StartAuthProcess_001, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState = std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
authManager->SetAuthResponseState(authResponseState);
int32_t action = 0;
int32_t ret =authManager->StartAuthProcess(action);
@@ -418,10 +418,10 @@ HWTEST_F(DmAuthManagerTest, StartAuthProcess_002, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState = std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->SetAuthResponseState(authResponseState);
authManager->authResponseContext_->sessionId=111;
@@ -441,11 +441,11 @@ HWTEST_F(DmAuthManagerTest, CreateGroup_001, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState = std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseConfirmState());
authManager->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->SetAuthResponseState(authResponseState);
authManager->authResponseContext_->requestId=111;
@@ -466,7 +466,7 @@ HWTEST_F(DmAuthManagerTest, AddMember_001, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState = std::shared_ptr<AuthResponseState>(new AuthResponseInitState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
std::shared_ptr<DmTimer> joinStartTimer = std::make_shared<DmTimer>(ADD_TIMEOUT_TASK);
@@ -502,13 +502,13 @@ HWTEST_F(DmAuthManagerTest, JoinNetwork_001, testing::ext::TestSize.Level0)
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthRequestState> authRequestState = std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
std::shared_ptr<DmTimer> authenticateStartTimer = std::make_shared<DmTimer>(AUTHENTICATE_TIMEOUT_TASK);
authManager->timerMap_[AUTHENTICATE_TIMEOUT_TASK] = authenticateStartTimer;
authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
authManager->authRequestState_ = std::shared_ptr<AuthRequestState>(new AuthRequestFinishState());
authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
authManager->SetAuthRequestState(authRequestState);
int32_t ret =authManager->JoinNetwork();
ASSERT_EQ(ret, DM_OK);
@@ -525,7 +525,7 @@ HWTEST_F(DmAuthManagerTest, GetIsCryptoSupport_001, testing::ext::TestSize.Level
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
authManager->authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseFinishState());
authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
bool isCryptoSupport = false;
int32_t ret =authManager->GetIsCryptoSupport(isCryptoSupport);
ASSERT_EQ(ret,DM_OK);
@@ -542,8 +542,8 @@ HWTEST_F(DmAuthManagerTest, SetAuthResponseState_001, testing::ext::TestSize.Lev
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmAuthManager> authManager = std::make_shared<DmAuthManager>(softbusConnector, listener);
std::shared_ptr<AuthResponseState> authResponseState = std::shared_ptr<AuthResponseState>(new AuthResponseFinishState());
authManager->authResponseState_ = std::shared_ptr<AuthResponseState>(new AuthResponseFinishState());
std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
authManager->SetAuthResponseState(authResponseState);
int32_t ret =authManager->SetAuthResponseState(authResponseState);
ASSERT_EQ(ret, DM_OK);
test/unittest/UTTest_dm_device_info_manager.cpp
+2 -4
View File
@@ -40,8 +40,7 @@ namespace {
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmDeviceInfoManager> dmDeviceStateManager =
std::shared_ptr<DmDeviceInfoManager>(new DmDeviceInfoManager(softbusConnector));
std::shared_ptr<DmDeviceInfoManager> dmDeviceStateManager = std::make_shared<DmDeviceInfoManager>(softbusConnector);
/**
* @tc.name: DmDeviceInfoManager_001
@@ -53,8 +52,7 @@ std::shared_ptr<DmDeviceInfoManager> dmDeviceStateManager =
*/
HWTEST_F(DeviceManagerImplTest, DmDeviceInfoManager_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DmDeviceInfoManager> p =
std::shared_ptr<DmDeviceInfoManager>(new DmDeviceInfoManager(softbusConnector));
std::shared_ptr<DmDeviceInfoManager> p = std::make_shared<DmDeviceInfoManager>(softbusConnector);
ASSERT_NE(p, nullptr);
}
} // namespace
test/unittest/UTTest_dm_device_state_manager.cpp
+3 -3
View File
@@ -47,7 +47,7 @@ namespace {
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::shared_ptr<DmDeviceStateManager> dmDeviceStateManager = std::shared_ptr<DmDeviceStateManager>(new DmDeviceStateManager(softbusConnector, listener_));
std::shared_ptr<DmDeviceStateManager> dmDeviceStateManager = std::make_shared<DmDeviceStateManager>(softbusConnector, listener_);
/**
* @tc.name: DmDeviceStateManager_001
@@ -57,7 +57,7 @@ std::shared_ptr<DmDeviceStateManager> dmDeviceStateManager = std::shared_ptr<Dm
*/
HWTEST_F(DmDeviceStateManagerTest, DmDeviceStateManager_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DmDeviceStateManager> p = std::shared_ptr<DmDeviceStateManager>(new DmDeviceStateManager(softbusConnector, listener_));
std::shared_ptr<DmDeviceStateManager> p = std::make_shared<DmDeviceStateManager>(softbusConnector, listener_);
ASSERT_NE(p, nullptr);
}
@@ -70,7 +70,7 @@ HWTEST_F(DmDeviceStateManagerTest, DmDeviceStateManager_001, testing::ext::TestS
*/
HWTEST_F(DmDeviceStateManagerTest, DmDeviceStateManager_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<DmDeviceStateManager> p = std::shared_ptr<DmDeviceStateManager>(new DmDeviceStateManager(softbusConnector, listener_));
std::shared_ptr<DmDeviceStateManager> p = std::make_shared<DmDeviceStateManager>(softbusConnector, listener_);
p.reset();
EXPECT_EQ(p, nullptr);
}