1 /*
2  * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "UTTest_dm_auth_manager_first.h"
17 
18 #include "nlohmann/json.hpp"
19 
20 #include "dm_log.h"
21 #include "dm_constants.h"
22 #include "dm_auth_manager.h"
23 #include "auth_message_processor.h"
24 #include "device_manager_service_listener.h"
25 #include "softbus_error_code.h"
26 
27 namespace OHOS {
28 namespace DistributedHardware {
29 
30 class SoftbusStateCallbackTest : public ISoftbusStateCallback {
31 public:
SoftbusStateCallbackTest()32     SoftbusStateCallbackTest() {}
~SoftbusStateCallbackTest()33     virtual ~SoftbusStateCallbackTest() {}
OnDeviceOnline(std::string deviceId,int32_t authForm)34     void OnDeviceOnline(std::string deviceId, int32_t authForm) {}
OnDeviceOffline(std::string deviceId)35     void OnDeviceOffline(std::string deviceId) {}
DeleteOffLineTimer(std::string udidHash)36     void DeleteOffLineTimer(std::string udidHash) {}
37 };
38 
SetUp()39 void DmAuthManagerTest::SetUp()
40 {
41     authManager_->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager_);
42     authManager_->authMessageProcessor_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
43     authManager_->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
44     authManager_->authRequestState_ = std::make_shared<AuthRequestFinishState>();
45     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
46     authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
47     authManager_->hiChainAuthConnector_ = std::make_shared<HiChainAuthConnector>();
48     authManager_->softbusConnector_ = std::make_shared<SoftbusConnector>();
49     authManager_->softbusConnector_->GetSoftbusSession()->
50         RegisterSessionCallback(std::shared_ptr<ISoftbusSessionCallback>(authManager_));
51     authManager_->timer_ = std::make_shared<DmTimer>();
52 }
TearDown()53 void DmAuthManagerTest::TearDown()
54 {
55 }
SetUpTestCase()56 void DmAuthManagerTest::SetUpTestCase()
57 {
58 }
TearDownTestCase()59 void DmAuthManagerTest::TearDownTestCase()
60 {
61 }
62 
63 namespace {
64 const int32_t MIN_PIN_CODE = 100000;
65 const int32_t MAX_PIN_CODE = 999999;
66 
CheckSoftbusRes(int32_t ret)67 bool CheckSoftbusRes(int32_t ret)
68 {
69     return ret == SOFTBUS_NETWORK_NOT_INIT || ret == SOFTBUS_NETWORK_LOOPER_ERR || ret == SOFTBUS_IPC_ERR;
70 }
71 
72 HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0)
73 {
74     std::string pkgName = "";
75     std::string networkId = "222";
76     int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
77     ASSERT_EQ(ret, ERR_DM_FAILED);
78 }
79 
80 HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0)
81 {
82     std::string pkgName = "ohos_test";
83     std::string networkId = "222";
84     authManager_->authRequestState_ = nullptr;
85     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
86     authManager_->isAuthenticateDevice_ = false;
87     int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
88     ASSERT_TRUE(CheckSoftbusRes(ret));
89 }
90 
91 HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0)
92 {
93     std::string pkgName = "ohos_test";
94     std::string networkId = "222";
95     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
96     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
97     authManager_->isAuthenticateDevice_ = true;
98     authManager_->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
99     int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
100     ASSERT_TRUE(CheckSoftbusRes(ret));
101 }
102 
103 HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_004, testing::ext::TestSize.Level0)
104 {
105     std::string pkgName = "ohos_test";
106     std::string networkId = "222";
107     authManager_->authRequestState_ = std::make_shared<AuthRequestReplyState>();
108     authManager_->isAuthenticateDevice_ = false;
109     int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
110     ASSERT_TRUE(CheckSoftbusRes(ret));
111 }
112 
113 HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_005, testing::ext::TestSize.Level0)
114 {
115     std::string pkgName = "ohos_test";
116     std::string networkId = "networkId";
117     authManager_->authRequestState_ = nullptr;
118     authManager_->authResponseContext_ = nullptr;
119     int32_t ret = authManager_->UnAuthenticateDevice(pkgName, networkId);
120     ASSERT_TRUE(CheckSoftbusRes(ret));
121 }
122 
123 HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_001, testing::ext::TestSize.Level0)
124 {
125     std::string name = "test";
126     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestNetworkState>();
127     authManager_->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
128     authManager_->authResponseContext_ = nullptr;
129     authManager_->SetAuthRequestState(authRequestState);
130     authManager_->HandleAuthenticateTimeout(name);
131     ASSERT_TRUE(authManager_->authResponseContext_ != nullptr);
132 }
133 
134 HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_002, testing::ext::TestSize.Level0)
135 {
136     std::string name = "test";
137     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
138     authManager_->SetAuthRequestState(authRequestState);
139     authManager_->HandleAuthenticateTimeout(name);
140     ASSERT_TRUE(authManager_->authRequestState_ != nullptr);
141 }
142 
143 HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_003, testing::ext::TestSize.Level0)
144 {
145     std::string name = "test";
146     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
147     authManager_->SetAuthRequestState(authRequestState);
148     authManager_->HandleAuthenticateTimeout(name);
149     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
150     authManager_->SetAuthResponseState(authResponseState);
151     ASSERT_TRUE(authManager_->authRequestState_ != nullptr);
152 }
153 
154 HWTEST_F(DmAuthManagerTest, EstablishAuthChannel_001, testing::ext::TestSize.Level0)
155 {
156     std::shared_ptr<SoftbusSession> sessionSession = std::shared_ptr<SoftbusSession>();
157     std::shared_ptr<DmAuthResponseContext> authRequestContext = std::make_shared<DmAuthResponseContext>();
158     std::string deviceId1;
159     authManager_->AbilityNegotiate();
160     int32_t ret = authManager_->EstablishAuthChannel(deviceId1);
161     ASSERT_EQ(ret, DM_OK);
162 }
163 
164 HWTEST_F(DmAuthManagerTest, StartAuthProcess_001, testing::ext::TestSize.Level0)
165 {
166     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
167     authManager_->SetAuthResponseState(authResponseState);
168     int32_t action = 0;
169     authManager_->StartAuthProcess(action);
170     bool ret = authManager_->authRequestContext_->deviceName.empty();
171     ASSERT_EQ(ret, true);
172 }
173 
174 HWTEST_F(DmAuthManagerTest, StartAuthProcess_002, testing::ext::TestSize.Level0)
175 {
176     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
177     authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
178     authManager_->SetAuthResponseState(authResponseState);
179     authManager_->authResponseContext_->sessionId = 111;
180     authManager_->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager_);
181     int32_t action = 1;
182     int32_t ret = authManager_->StartAuthProcess(action);
183     ASSERT_EQ(ret, DM_OK);
184 }
185 
186 HWTEST_F(DmAuthManagerTest, StartAuthProcess_003, testing::ext::TestSize.Level0)
187 {
188     authManager_->authResponseContext_ = nullptr;
189     int32_t action = 1;
190     int32_t ret = authManager_->StartAuthProcess(action);
191     ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
192 }
193 
194 HWTEST_F(DmAuthManagerTest, CreateGroup_001, testing::ext::TestSize.Level0)
195 {
196     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
197     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
198     authManager_->SetAuthResponseState(authResponseState);
199     authManager_->authResponseContext_->requestId = 111;
200     authManager_->authResponseContext_->groupName = "111";
201     int32_t ret = authManager_->CreateGroup();
202     ASSERT_EQ(ret, DM_OK);
203 }
204 
205 HWTEST_F(DmAuthManagerTest, CreateGroup_002, testing::ext::TestSize.Level0)
206 {
207     authManager_->authResponseContext_ = nullptr;
208     int32_t ret = authManager_->CreateGroup();
209     ASSERT_EQ(ret, ERR_DM_FAILED);
210 }
211 
212 HWTEST_F(DmAuthManagerTest, AddMember_001, testing::ext::TestSize.Level0)
213 {
214     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
215     std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
216     nlohmann::json jsonObject;
217     authManager_->authResponseContext_->groupId = "111";
218     authManager_->authResponseContext_->groupName = "222";
219     authManager_->authResponseContext_->code = 123;
220     authManager_->authResponseContext_->requestId = 234;
221     authManager_->authResponseContext_->deviceId = "234";
222     int32_t pinCode = 444444;
223     authManager_->hiChainConnector_->RegisterHiChainCallback(authManager_);
224     authManager_->SetAuthResponseState(authResponseState);
225     int32_t ret = authManager_->AddMember(pinCode);
226     ASSERT_NE(ret, -1);
227 }
228 
229 HWTEST_F(DmAuthManagerTest, AddMember_002, testing::ext::TestSize.Level0)
230 {
231     int32_t pinCode = 33333;
232     authManager_->authResponseContext_ = nullptr;
233     int32_t ret = authManager_->AddMember(pinCode);
234     ASSERT_EQ(ret, ERR_DM_FAILED);
235     authManager_->isAddingMember_ = true;
236     ret = authManager_->AddMember(pinCode);
237     ASSERT_EQ(ret, ERR_DM_FAILED);
238 }
239 
240 HWTEST_F(DmAuthManagerTest, JoinNetwork_001, testing::ext::TestSize.Level0)
241 {
242     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
243     const int32_t sessionId = 65;
244     const std::string message = "messageTest";
245     int64_t requestId = 444;
246     const std::string groupId = "{}";
247     int32_t status = 1;
248     authManager_->OnGroupCreated(requestId, groupId);
249     authManager_->OnMemberJoin(requestId, status);
250     authManager_->OnDataReceived(sessionId, message);
251     authManager_->SetAuthRequestState(authRequestState);
252     int32_t ret = authManager_->JoinNetwork();
253     ASSERT_EQ(ret, DM_OK);
254 }
255 
256 HWTEST_F(DmAuthManagerTest, JoinNetwork_002, testing::ext::TestSize.Level0)
257 {
258     authManager_->authResponseContext_ = nullptr;
259     int32_t userId = 1;
260     authManager_->UserSwitchEventCallback(userId);
261     authManager_->AuthenticateFinish();
262     authManager_->CancelDisplay();
263     int32_t ret = authManager_->JoinNetwork();
264     ASSERT_EQ(ret, ERR_DM_FAILED);
265 }
266 
267 HWTEST_F(DmAuthManagerTest, SetAuthResponseState_001, testing::ext::TestSize.Level0)
268 {
269     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
270     authManager_->authResponseState_ = std::make_shared<AuthResponseFinishState>();
271     int32_t ret = authManager_->SetAuthResponseState(authResponseState);
272     ASSERT_EQ(ret, DM_OK);
273 }
274 
275 HWTEST_F(DmAuthManagerTest, SetAuthResponseState_002, testing::ext::TestSize.Level0)
276 {
277     std::shared_ptr<AuthResponseState> authResponseState = nullptr;
278     int32_t ret = authManager_->SetAuthResponseState(authResponseState);
279     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
280 }
281 
282 HWTEST_F(DmAuthManagerTest, GetPinCode_001, testing::ext::TestSize.Level0)
283 {
284     authManager_->authResponseContext_->code = 123456;
285     int32_t code = 0;
286     authManager_->GetPinCode(code);
287     ASSERT_EQ(code, 123456);
288 }
289 
290 HWTEST_F(DmAuthManagerTest, GetPinCode_002, testing::ext::TestSize.Level0)
291 {
292     authManager_->authResponseContext_ = nullptr;
293     authManager_->ShowConfigDialog();
294     authManager_->ShowAuthInfoDialog();
295     authManager_->ShowStartAuthDialog();
296     int32_t code = 0;
297     authManager_->GetPinCode(code);
298     ASSERT_EQ(code, ERR_DM_AUTH_NOT_START);
299 }
300 
301 HWTEST_F(DmAuthManagerTest, SetPageId_001, testing::ext::TestSize.Level0)
302 {
303     int32_t pageId = 123;
304     int32_t ret = authManager_->SetPageId(pageId);
305     ASSERT_EQ(ret, DM_OK);
306 }
307 
308 HWTEST_F(DmAuthManagerTest, SetPageId_002, testing::ext::TestSize.Level0)
309 {
310     int32_t pageId = 123;
311     authManager_->authResponseContext_ = nullptr;
312     authManager_->authMessageProcessor_ = nullptr;
313     const int32_t sessionId = 65;
314     const std::string message = "messageTest";
315     int64_t requestId = 555;
316     int32_t status = 2;
317     authManager_->OnMemberJoin(requestId, status);
318     authManager_->OnDataReceived(sessionId, message);
319     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
320     authManager_->authRequestState_ = std::make_shared<AuthRequestFinishState>();
321     authManager_->authResponseState_ = nullptr;
322     authManager_->OnDataReceived(sessionId, message);
323     authManager_->authRequestState_ = nullptr;
324     authManager_->authResponseState_ = std::make_shared<AuthResponseFinishState>();
325     authManager_->OnDataReceived(sessionId, message);
326     int32_t ret = authManager_->SetPageId(pageId);
327     ASSERT_EQ(ret, DM_OK);
328 }
329 
330 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_001, testing::ext::TestSize.Level0)
331 {
332     const int32_t sessionId = 78;
333     int32_t reason = 123;
334     int32_t state = 456;
335     authManager_->OnSessionClosed(sessionId);
336     authManager_->authResponseContext_ = nullptr;
337     int64_t requestId = 333;
338     const std::string groupId = "{}";
339     authManager_->OnGroupCreated(requestId, groupId);
340     int32_t ret = authManager_->SetReasonAndFinish(reason, state);
341     ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
342 }
343 
344 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_002, testing::ext::TestSize.Level0)
345 {
346     int32_t reason = 1234;
347     int32_t state = 5678;
348     int64_t requestId = 22;
349     const std::string groupId = "{}";
350     authManager_->OnGroupCreated(requestId, groupId);
351     int32_t ret = authManager_->SetReasonAndFinish(reason, state);
352     ASSERT_EQ(ret, DM_OK);
353 }
354 
355 HWTEST_F(DmAuthManagerTest, SetReasonAndFinish_003, testing::ext::TestSize.Level0)
356 {
357     authManager_->authRequestState_ = nullptr;
358     authManager_->authResponseState_ = std::make_shared<AuthResponseFinishState>();
359     int32_t reason = 12;
360     int32_t state = 36;
361     int32_t ret = authManager_->SetReasonAndFinish(reason, state);
362     ASSERT_EQ(ret, DM_OK);
363 }
364 
365 HWTEST_F(DmAuthManagerTest, IsIdenticalAccount_001, testing::ext::TestSize.Level0)
366 {
367     bool ret = authManager_->IsIdenticalAccount();
368     ASSERT_EQ(ret, false);
369 }
370 
371 HWTEST_F(DmAuthManagerTest, GetAccountGroupIdHash_001, testing::ext::TestSize.Level0)
372 {
373     auto ret = authManager_->GetAccountGroupIdHash();
374     ASSERT_EQ(ret.empty(), true);
375 }
376 
377 HWTEST_F(DmAuthManagerTest, GeneratePincode_001, testing::ext::TestSize.Level0)
378 {
379     int32_t openedSessionId = 66;
380     int32_t sessionSide = 0;
381     int32_t result = 3;
382     const int32_t closedSessionId = 11;
383     authManager_->authResponseState_ = nullptr;
384     authManager_->authRequestState_ = nullptr;
385     authManager_->timer_ = nullptr;
386     authManager_->OnSessionOpened(openedSessionId, sessionSide, result);
387     authManager_->OnSessionClosed(closedSessionId);
388     int32_t ret = authManager_->GeneratePincode();
389     ASSERT_LE(ret, MAX_PIN_CODE);
390     ASSERT_GE(ret, MIN_PIN_CODE);
391 }
392 
393 HWTEST_F(DmAuthManagerTest, GeneratePincode_002, testing::ext::TestSize.Level0)
394 {
395     int32_t openedSessionId = 66;
396     int32_t sessionSide = 0;
397     int32_t result = 3;
398     const int32_t closedSessionId = 11;
399     authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
400     authManager_->authRequestState_ = std::make_shared<AuthRequestFinishState>();
401     authManager_->timer_ = std::make_shared<DmTimer>();
402     authManager_->OnSessionOpened(openedSessionId, sessionSide, result);
403     authManager_->OnSessionClosed(closedSessionId);
404     int32_t ret = authManager_->GeneratePincode();
405     ASSERT_LE(ret, MAX_PIN_CODE);
406     ASSERT_GE(ret, MIN_PIN_CODE);
407 }
408 
409 HWTEST_F(DmAuthManagerTest, GeneratePincode_003, testing::ext::TestSize.Level0)
410 {
411     int32_t openedSessionId = 66;
412     int32_t sessionSide = 1;
413     int32_t result = 3;
414     const int32_t closedSessionId = 11;
415     authManager_->authResponseState_ = nullptr;
416     authManager_->authRequestState_ = nullptr;
417     authManager_->timer_ = nullptr;
418     authManager_->OnSessionOpened(openedSessionId, sessionSide, result);
419     authManager_->OnSessionClosed(closedSessionId);
420     int32_t ret = authManager_->GeneratePincode();
421     ASSERT_LE(ret, MAX_PIN_CODE);
422     ASSERT_GE(ret, MIN_PIN_CODE);
423 }
424 
425 HWTEST_F(DmAuthManagerTest, GeneratePincode_004, testing::ext::TestSize.Level0)
426 {
427     int32_t openedSessionId = 66;
428     int32_t sessionSide = 1;
429     int32_t result = 3;
430     const int32_t closedSessionId = 11;
431     authManager_->authResponseState_ = nullptr;
432     authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
433     authManager_->timer_ = std::make_shared<DmTimer>();
434     authManager_->OnSessionOpened(openedSessionId, sessionSide, result);
435     authManager_->OnSessionClosed(closedSessionId);
436     int32_t ret = authManager_->GeneratePincode();
437     ASSERT_LE(ret, MAX_PIN_CODE);
438     ASSERT_GE(ret, MIN_PIN_CODE);
439 }
440 
441 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_001, testing::ext::TestSize.Level0)
442 {
443     std::string pkgName = "com.ohos.test";
444     int32_t authType = -1;
445     std::string deviceId = "113456";
446     std::string extra = "extraTest";
447     int32_t ret = authManager_->AuthenticateDevice(pkgName, authType, deviceId, extra);
448     ASSERT_EQ(ret, ERR_DM_AUTH_FAILED);
449 }
450 
451 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_002, testing::ext::TestSize.Level0)
452 {
453     int32_t authType = 0;
454     std::string extra;
455     std::string pkgName = "ohos_test";
456     std::string deviceId = "512156";
457     authManager_->importPkgName_ = "ohos_test";
458     authManager_->importAuthCode_ = "156161";
459     authManager_->authRequestState_ = nullptr;
460     authManager_->authResponseState_ = nullptr;
461     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
462     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
463     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
464     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
465     authManager_->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
466     int32_t ret = authManager_->AuthenticateDevice(pkgName, authType, deviceId, extra);
467     ASSERT_EQ(ret, DM_OK);
468 }
469 
470 HWTEST_F(DmAuthManagerTest, AuthenticateDevice_003, testing::ext::TestSize.Level0)
471 {
472     std::string pkgName = "com.ohos.test";
473     int32_t authType = 1;
474     std::string deviceId = "deviceIdTest";
475     std::string extra = "extraTest";
476     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
477     authManager_->authRequestState_ = nullptr;
478     authManager_->authResponseState_ = nullptr;
479     authManager_->timer_ = nullptr;
480     authManager_->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
481     int32_t ret = authManager_->AuthenticateDevice(pkgName, authType, deviceId, extra);
482     ASSERT_EQ(ret, DM_OK);
483 }
484 
485 HWTEST_F(DmAuthManagerTest, GenerateGroupName_001, testing::ext::TestSize.Level0)
486 {
487     authManager_->authResponseContext_ = nullptr;
488     std::string ret = authManager_->GenerateGroupName();
489     ASSERT_TRUE(ret.empty());
490 }
491 
492 HWTEST_F(DmAuthManagerTest, GenerateGroupName_002, testing::ext::TestSize.Level0)
493 {
494     authManager_->authResponseContext_->targetPkgName = "targetPkgNameTest";
495     authManager_->authResponseContext_->localDeviceId = "localDeviceIdTest";
496     authManager_->action_ = 6;
497     std::string ret = authManager_->GenerateGroupName();
498     ASSERT_TRUE(!ret.empty());
499 }
500 
501 HWTEST_F(DmAuthManagerTest, GenerateGroupName_003, testing::ext::TestSize.Level0)
502 {
503     authManager_->authResponseContext_->targetPkgName = "targetPkgNameTest";
504     authManager_->authResponseContext_->localDeviceId = "localDeviceIdTest";
505     authManager_->action_ = 7;
506     std::string ret = authManager_->GenerateGroupName();
507     ASSERT_TRUE(!ret.empty());
508 }
509 
510 HWTEST_F(DmAuthManagerTest, GetIsCryptoSupport_001, testing::ext::TestSize.Level0)
511 {
512     authManager_->authResponseState_ = nullptr;
513     bool ret = authManager_->GetIsCryptoSupport();
514     ASSERT_EQ(ret, false);
515 }
516 
517 HWTEST_F(DmAuthManagerTest, GetIsCryptoSupport_002, testing::ext::TestSize.Level0)
518 {
519     authManager_->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
520     authManager_->authRequestState_ = nullptr;
521     bool ret = authManager_->GetIsCryptoSupport();
522     ASSERT_EQ(ret, false);
523 }
524 
525 HWTEST_F(DmAuthManagerTest, GetIsCryptoSupport_003, testing::ext::TestSize.Level0)
526 {
527     authManager_->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
528     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
529     bool ret = authManager_->GetIsCryptoSupport();
530     ASSERT_EQ(ret, false);
531 }
532 
533 HWTEST_F(DmAuthManagerTest, OnUserOperation_001, testing::ext::TestSize.Level0)
534 {
535     int32_t action = 0;
536     std::string params = "paramsTest";
537     authManager_->authResponseContext_ = nullptr;
538     int32_t ret = authManager_->OnUserOperation(action, params);
539     ASSERT_EQ(ret, ERR_DM_AUTH_NOT_START);
540 }
541 
542 HWTEST_F(DmAuthManagerTest, OnUserOperation_002, testing::ext::TestSize.Level0)
543 {
544     int32_t action = 1;
545     std::string params = "paramsTest1";
546     int32_t ret = authManager_->OnUserOperation(action, params);
547     ASSERT_EQ(ret, DM_OK);
548 }
549 
550 HWTEST_F(DmAuthManagerTest, OnUserOperation_003, testing::ext::TestSize.Level0)
551 {
552     int32_t action = 2;
553     std::string params = "paramsTest2";
554     int32_t ret = authManager_->OnUserOperation(action, params);
555     ASSERT_EQ(ret, DM_OK);
556 }
557 
558 HWTEST_F(DmAuthManagerTest, OnUserOperation_004, testing::ext::TestSize.Level0)
559 {
560     int32_t action = 3;
561     std::string params = "paramsTest3";
562     int32_t ret = authManager_->OnUserOperation(action, params);
563     ASSERT_EQ(ret, DM_OK);
564 }
565 
566 HWTEST_F(DmAuthManagerTest, OnUserOperation_005, testing::ext::TestSize.Level0)
567 {
568     int32_t action = 4;
569     std::string params = "paramsTest4";
570     int32_t ret = authManager_->OnUserOperation(action, params);
571     ASSERT_EQ(ret, DM_OK);
572 }
573 
574 HWTEST_F(DmAuthManagerTest, OnUserOperation_006, testing::ext::TestSize.Level0)
575 {
576     int32_t action = 5;
577     std::string params = "5";
578     int32_t ret = authManager_->OnUserOperation(action, params);
579     ASSERT_EQ(ret, DM_OK);
580 }
581 
582 HWTEST_F(DmAuthManagerTest, OnUserOperation_007, testing::ext::TestSize.Level0)
583 {
584     int32_t action = 1111;
585     std::string params = "paramsTest1111";
586     int32_t ret = authManager_->OnUserOperation(action, params);
587     ASSERT_EQ(ret, DM_OK);
588 }
589 
590 HWTEST_F(DmAuthManagerTest, UnBindDevice_001, testing::ext::TestSize.Level0)
591 {
592     std::string pkgName;
593     std::string udidHash = "udidHash";
594     int32_t ret = authManager_->UnBindDevice(pkgName, udidHash);
595     ASSERT_EQ(ret, ERR_DM_FAILED);
596 }
597 
598 HWTEST_F(DmAuthManagerTest, UnBindDevice_002, testing::ext::TestSize.Level0)
599 {
600     std::string pkgName = "ohos_test";
601     std::string udidHash = "222";
602     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
603     authManager_->isAuthenticateDevice_ = true;
604     int32_t ret = authManager_->UnBindDevice(pkgName, udidHash);
605     ASSERT_EQ(ret, ERR_DM_FAILED);
606 }
607 
608 HWTEST_F(DmAuthManagerTest, UnBindDevice_003, testing::ext::TestSize.Level0)
609 {
610     std::string pkgName = "ohos_test";
611     std::string udidHash = "222";
612     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
613     authManager_->isAuthenticateDevice_ = false;
614     int32_t ret = authManager_->UnBindDevice(pkgName, udidHash);
615     ASSERT_EQ(ret, ERR_DM_FAILED);
616 }
617 
618 HWTEST_F(DmAuthManagerTest, UnBindDevice_004, testing::ext::TestSize.Level0)
619 {
620     std::string pkgName = "ohos_test";
621     std::string udidHash = "networkId";
622     authManager_->authRequestState_ = nullptr;
623     authManager_->authResponseContext_ = nullptr;
624     int32_t ret = authManager_->UnBindDevice(pkgName, udidHash);
625     ASSERT_EQ(ret, ERR_DM_FAILED);
626 }
627 
628 HWTEST_F(DmAuthManagerTest, UnBindDevice_005, testing::ext::TestSize.Level0)
629 {
630     std::string pkgName = "ohos_test";
631     std::string udidHash = "networkId";
632     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
633     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
634     authManager_->isAuthenticateDevice_ = false;
635     int32_t ret = authManager_->UnBindDevice(pkgName, udidHash);
636     ASSERT_EQ(ret, ERR_DM_FAILED);
637     authManager_->isAuthenticateDevice_ = true;
638     ret = authManager_->UnBindDevice(pkgName, udidHash);
639     ASSERT_EQ(ret, ERR_DM_FAILED);
640 }
641 
642 HWTEST_F(DmAuthManagerTest, RequestCredential001, testing::ext::TestSize.Level0)
643 {
644     authManager_->hiChainAuthConnector_ = std::make_shared<HiChainAuthConnector>();
645     authManager_->RequestCredential();
646     ASSERT_EQ(authManager_->isAuthDevice_, false);
647 }
648 
649 HWTEST_F(DmAuthManagerTest, GenerateCredential001, testing::ext::TestSize.Level0)
650 {
651     std::string publicKey = "publicKey";
652     authManager_->GenerateCredential(publicKey);
653     ASSERT_EQ(authManager_->isAuthDevice_, false);
654 }
655 
656 HWTEST_F(DmAuthManagerTest, RequestCredentialDone001, testing::ext::TestSize.Level0)
657 {
658     authManager_->authResponseContext_ = nullptr;
659     authManager_->RequestCredentialDone();
660     ASSERT_EQ(authManager_->isAuthDevice_, false);
661 }
662 
663 HWTEST_F(DmAuthManagerTest, RequestCredentialDone002, testing::ext::TestSize.Level0)
664 {
665     authManager_->hiChainAuthConnector_ = std::make_shared<HiChainAuthConnector>();
666     authManager_->RequestCredential();
667     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
668     authManager_->RequestCredentialDone();
669     ASSERT_EQ(authManager_->isAuthDevice_, false);
670 }
671 
672 HWTEST_F(DmAuthManagerTest, ImportCredential001, testing::ext::TestSize.Level0)
673 {
674     std::string deviceId = "deviceId";
675     std::string publicKey = "publicKey";
676     int32_t ret = authManager_->ImportCredential(deviceId, publicKey);
677     ASSERT_NE(ret, DM_OK);
678 }
679 
680 HWTEST_F(DmAuthManagerTest, EstablishUnbindChannel001, testing::ext::TestSize.Level0)
681 {
682     std::string deviceIdHash = "deviceIdHash";
683     int32_t ret = authManager_->EstablishUnbindChannel(deviceIdHash);
684     ASSERT_EQ(ret, DM_OK);
685 }
686 
687 HWTEST_F(DmAuthManagerTest, RequestSyncDeleteAcl001, testing::ext::TestSize.Level0)
688 {
689     authManager_->RequestSyncDeleteAcl();
690     ASSERT_EQ(authManager_->isAuthDevice_, false);
691 }
692 
693 HWTEST_F(DmAuthManagerTest, RequestSyncDeleteAcl002, testing::ext::TestSize.Level0)
694 {
695     authManager_->timer_ = nullptr;
696     authManager_->RequestSyncDeleteAcl();
697     ASSERT_EQ(authManager_->isAuthDevice_, false);
698 }
699 
700 HWTEST_F(DmAuthManagerTest, SrcSyncDeleteAclDonel001, testing::ext::TestSize.Level0)
701 {
702     authManager_->isFinishOfLocal_ = true;
703     authManager_->authResponseContext_->reply = 0;
704     authManager_->SrcSyncDeleteAclDone();
705     ASSERT_EQ(authManager_->isAuthDevice_, false);
706 }
707 
708 HWTEST_F(DmAuthManagerTest, SinkSyncDeleteAclDone001, testing::ext::TestSize.Level0)
709 {
710     authManager_->isFinishOfLocal_ = true;
711     authManager_->authResponseContext_->reply = 0;
712     authManager_->SinkSyncDeleteAclDone();
713     ASSERT_EQ(authManager_->isAuthDevice_, false);
714 }
715 
716 HWTEST_F(DmAuthManagerTest, SyncDeleteAclDone001, testing::ext::TestSize.Level0)
717 {
718     authManager_->SyncDeleteAclDone();
719     ASSERT_EQ(authManager_->isAuthDevice_, false);
720 }
721 
722 HWTEST_F(DmAuthManagerTest, SyncDeleteAclDone002, testing::ext::TestSize.Level0)
723 {
724     authManager_->authRequestState_ = nullptr;
725     authManager_->SyncDeleteAclDone();
726     ASSERT_EQ(authManager_->isAuthDevice_, false);
727 }
728 
729 HWTEST_F(DmAuthManagerTest, ResponseCredential001, testing::ext::TestSize.Level0)
730 {
731     authManager_->ResponseCredential();
732     ASSERT_EQ(authManager_->isAuthDevice_, false);
733 }
734 
735 HWTEST_F(DmAuthManagerTest, ResponseSyncDeleteAcl001, testing::ext::TestSize.Level0)
736 {
737     authManager_->ResponseSyncDeleteAcl();
738     ASSERT_EQ(authManager_->isAuthDevice_, false);
739 }
740 
741 HWTEST_F(DmAuthManagerTest, AuthDeviceTransmit001, testing::ext::TestSize.Level0)
742 {
743     int64_t requestId = 0;
744     authManager_->authResponseContext_->requestId = 11;
745     uint8_t *data = nullptr;
746     uint32_t dataLen = 0;
747     bool ret = authManager_->AuthDeviceTransmit(requestId, data, dataLen);
748     ASSERT_EQ(ret, false);
749 }
750 
751 HWTEST_F(DmAuthManagerTest, AuthDeviceTransmit002, testing::ext::TestSize.Level0)
752 {
753     int64_t requestId = 0;
754     authManager_->authResponseContext_->requestId = 0;
755     authManager_->authResponseState_ = nullptr;
756     uint8_t *data = nullptr;
757     uint32_t dataLen = 0;
758     bool ret = authManager_->AuthDeviceTransmit(requestId, data, dataLen);
759     ASSERT_EQ(ret, false);
760 }
761 
762 HWTEST_F(DmAuthManagerTest, AuthDeviceTransmit003, testing::ext::TestSize.Level0)
763 {
764     int64_t requestId = 0;
765     authManager_->authResponseContext_->requestId = 0;
766     authManager_->authRequestState_ = nullptr;
767     uint8_t *data = nullptr;
768     uint32_t dataLen = 0;
769     bool ret = authManager_->AuthDeviceTransmit(requestId, data, dataLen);
770     ASSERT_EQ(ret, false);
771 }
772 
773 HWTEST_F(DmAuthManagerTest, AuthDeviceTransmit004, testing::ext::TestSize.Level0)
774 {
775     int64_t requestId = 0;
776     uint8_t *data = nullptr;
777     uint32_t dataLen = 0;
778     bool ret = authManager_->AuthDeviceTransmit(requestId, data, dataLen);
779     ASSERT_EQ(ret, false);
780 }
781 
782 HWTEST_F(DmAuthManagerTest, SrcAuthDeviceFinish001, testing::ext::TestSize.Level0)
783 {
784     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
785     authManager_->SrcAuthDeviceFinish();
786     ASSERT_EQ(authManager_->isAuthDevice_, false);
787 }
788 
789 HWTEST_F(DmAuthManagerTest, SrcAuthDeviceFinish002, testing::ext::TestSize.Level0)
790 {
791     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
792     authManager_->softbusConnector_->RegisterSoftbusStateCallback(std::make_shared<SoftbusStateCallbackTest>());
793     authManager_->authResponseContext_->isOnline = true;
794     authManager_->authResponseContext_->confirmOperation = 0;
795     authManager_->authResponseContext_->haveCredential = true;
796     authManager_->authResponseContext_->bindLevel = 3;
797     authManager_->authResponseContext_->isIdenticalAccount = false;
798     authManager_->SrcAuthDeviceFinish();
799     ASSERT_EQ(authManager_->isAuthDevice_, false);
800 }
801 
802 HWTEST_F(DmAuthManagerTest, SrcAuthDeviceFinish003, testing::ext::TestSize.Level0)
803 {
804     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
805     authManager_->softbusConnector_->RegisterSoftbusStateCallback(std::make_shared<SoftbusStateCallbackTest>());
806     authManager_->authResponseContext_->isOnline = true;
807     authManager_->authResponseContext_->confirmOperation = 6;
808     authManager_->authResponseContext_->haveCredential = true;
809     authManager_->authResponseContext_->bindLevel = 3;
810     authManager_->SrcAuthDeviceFinish();
811     ASSERT_EQ(authManager_->isAuthDevice_, false);
812 }
813 
814 HWTEST_F(DmAuthManagerTest, SrcAuthDeviceFinish004, testing::ext::TestSize.Level0)
815 {
816     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
817     authManager_->softbusConnector_->RegisterSoftbusStateCallback(std::make_shared<SoftbusStateCallbackTest>());
818     authManager_->authResponseContext_->isOnline = true;
819     authManager_->authResponseContext_->confirmOperation = 6;
820     authManager_->authResponseContext_->haveCredential = false;
821     authManager_->authResponseContext_->bindLevel = 3;
822     authManager_->authResponseContext_->isIdenticalAccount = false;
823     authManager_->SrcAuthDeviceFinish();
824     ASSERT_EQ(authManager_->isAuthDevice_, false);
825 }
826 
827 HWTEST_F(DmAuthManagerTest, SrcAuthDeviceFinish005, testing::ext::TestSize.Level0)
828 {
829     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
830     authManager_->softbusConnector_->RegisterSoftbusStateCallback(std::make_shared<SoftbusStateCallbackTest>());
831     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
832     authManager_->authResponseContext_->isOnline = false;
833     authManager_->authResponseContext_->haveCredential = true;
834     authManager_->SrcAuthDeviceFinish();
835     ASSERT_EQ(authManager_->isAuthDevice_, false);
836 }
837 
838 HWTEST_F(DmAuthManagerTest, SrcAuthDeviceFinish006, testing::ext::TestSize.Level0)
839 {
840     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
841     authManager_->softbusConnector_->RegisterSoftbusStateCallback(std::make_shared<SoftbusStateCallbackTest>());
842     authManager_->authResponseContext_->isOnline = false;
843     authManager_->authResponseContext_->haveCredential = false;
844     authManager_->SrcAuthDeviceFinish();
845     ASSERT_EQ(authManager_->isAuthDevice_, false);
846 }
847 
848 HWTEST_F(DmAuthManagerTest, SinkAuthDeviceFinish001, testing::ext::TestSize.Level0)
849 {
850     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
851     authManager_->softbusConnector_->RegisterSoftbusStateCallback(std::make_shared<SoftbusStateCallbackTest>());
852     authManager_->authResponseContext_->haveCredential = false;
853     authManager_->authResponseContext_->isOnline = true;
854     authManager_->authResponseContext_->bindLevel = 3;
855     authManager_->authResponseContext_->isIdenticalAccount = false;
856     authManager_->SinkAuthDeviceFinish();
857     ASSERT_EQ(authManager_->isAuthDevice_, false);
858 }
859 
860 HWTEST_F(DmAuthManagerTest, AuthDeviceFinish001, testing::ext::TestSize.Level0)
861 {
862     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
863     int64_t requestId = 0;
864     authManager_->authResponseContext_->requestId = 1;
865     authManager_->AuthDeviceFinish(requestId);
866     ASSERT_EQ(authManager_->isAuthDevice_, false);
867 }
868 
869 HWTEST_F(DmAuthManagerTest, AuthDeviceFinish002, testing::ext::TestSize.Level0)
870 {
871     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
872     authManager_->authResponseState_ = nullptr;
873     int64_t requestId = 0;
874     authManager_->authResponseContext_->requestId = 0;
875     authManager_->AuthDeviceFinish(requestId);
876     ASSERT_EQ(authManager_->isAuthDevice_, false);
877 }
878 
879 HWTEST_F(DmAuthManagerTest, AuthDeviceFinish003, testing::ext::TestSize.Level0)
880 {
881     authManager_->authRequestState_ = nullptr;
882     authManager_->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
883     int64_t requestId = 0;
884     authManager_->authResponseContext_->requestId = 0;
885     authManager_->AuthDeviceFinish(requestId);
886     ASSERT_EQ(authManager_->isAuthDevice_, false);
887 }
888 
889 HWTEST_F(DmAuthManagerTest, AuthDeviceError001, testing::ext::TestSize.Level0)
890 {
891     authManager_->authRequestState_ = nullptr;
892     authManager_->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
893     int64_t requestId = 0;
894     int32_t errorCode = -1;
895     authManager_->AuthDeviceError(requestId, errorCode);
896     ASSERT_EQ(authManager_->isAuthDevice_, false);
897 }
898 
899 HWTEST_F(DmAuthManagerTest, AuthDeviceError002, testing::ext::TestSize.Level0)
900 {
901     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
902     authManager_->authResponseState_ = nullptr;
903     authManager_->authResponseContext_->authType = 5;
904     int64_t requestId = 0;
905     int32_t errorCode = -1;
906     authManager_->AuthDeviceError(requestId, errorCode);
907     ASSERT_EQ(authManager_->isAuthDevice_, false);
908 }
909 
910 HWTEST_F(DmAuthManagerTest, AuthDeviceError003, testing::ext::TestSize.Level0)
911 {
912     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
913     authManager_->authResponseState_ = nullptr;
914     authManager_->authResponseContext_->authType = 6;
915     authManager_->authResponseContext_->requestId = 2;
916     int64_t requestId = 0;
917     int32_t errorCode = -1;
918     authManager_->AuthDeviceError(requestId, errorCode);
919     ASSERT_EQ(authManager_->isAuthDevice_, false);
920 }
921 
922 HWTEST_F(DmAuthManagerTest, AuthDeviceSessionKey001, testing::ext::TestSize.Level0)
923 {
924     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
925     int64_t requestId = 0;
926     uint8_t *sessionKey = nullptr;
927     uint32_t sessionKeyLen = 0;
928     authManager_->AuthDeviceSessionKey(requestId, sessionKey, sessionKeyLen);
929     ASSERT_EQ(authManager_->isAuthDevice_, false);
930 }
931 
932 HWTEST_F(DmAuthManagerTest, GetRemoteDeviceId001, testing::ext::TestSize.Level0)
933 {
934     std::string deviceId;
935     authManager_->GetRemoteDeviceId(deviceId);
936     ASSERT_EQ(authManager_->isAuthDevice_, false);
937 }
938 
939 HWTEST_F(DmAuthManagerTest, CompatiblePutAcl001, testing::ext::TestSize.Level0)
940 {
941     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
942     authManager_->CompatiblePutAcl();
943     ASSERT_EQ(authManager_->isAuthDevice_, false);
944 }
945 
946 HWTEST_F(DmAuthManagerTest, CommonEventCallback001, testing::ext::TestSize.Level0)
947 {
948     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
949     int32_t userId = 0;
950     authManager_->CommonEventCallback(userId, "");
951     ASSERT_EQ(authManager_->isAuthDevice_, false);
952 }
953 
954 HWTEST_F(DmAuthManagerTest, AccountIdLogoutEventCallback001, testing::ext::TestSize.Level0)
955 {
956     int32_t userId = 0;
957     authManager_->AccountIdLogoutEventCallback(userId);
958     ASSERT_EQ(authManager_->isAuthDevice_, false);
959 }
960 
961 HWTEST_F(DmAuthManagerTest, UserSwitchEventCallback001, testing::ext::TestSize.Level0)
962 {
963     int32_t userId = 0;
964     authManager_->UserSwitchEventCallback(userId);
965     ASSERT_EQ(authManager_->isAuthDevice_, false);
966 }
967 
968 HWTEST_F(DmAuthManagerTest, UserChangeEventCallback001, testing::ext::TestSize.Level0)
969 {
970     int32_t userId = 0;
971     authManager_->UserChangeEventCallback(userId);
972     ASSERT_EQ(authManager_->isAuthDevice_, false);
973 }
974 
975 HWTEST_F(DmAuthManagerTest, HandleSyncDeleteTimeout001, testing::ext::TestSize.Level0)
976 {
977     std::string name;
978     authManager_->HandleSyncDeleteTimeout(name);
979     ASSERT_EQ(authManager_->isAuthDevice_, false);
980 }
981 
982 HWTEST_F(DmAuthManagerTest, DeleteAcl001, testing::ext::TestSize.Level0)
983 {
984     std::string pkgName;
985     std::string deviceId;
986     int32_t ret = authManager_->DeleteAcl(pkgName, deviceId);
987     ASSERT_NE(ret, DM_OK);
988 }
989 
990 HWTEST_F(DmAuthManagerTest, ProcRespNegotiateExt001, testing::ext::TestSize.Level0)
991 {
992     int32_t sessionId = 0;
993     authManager_->ProcRespNegotiateExt(sessionId);
994     ASSERT_EQ(authManager_->isAuthDevice_, false);
995 }
996 
997 HWTEST_F(DmAuthManagerTest, ProcRespNegotiate001, testing::ext::TestSize.Level0)
998 {
999     int32_t sessionId = 0;
1000     authManager_->ProcRespNegotiate(sessionId);
1001     ASSERT_EQ(authManager_->isAuthDevice_, false);
1002 }
1003 
1004 HWTEST_F(DmAuthManagerTest, GenerateBindResultContent001, testing::ext::TestSize.Level0)
1005 {
1006     auto ret = authManager_->GenerateBindResultContent();
1007     ASSERT_EQ(ret.empty(), false);
1008 }
1009 
1010 HWTEST_F(DmAuthManagerTest, OnAuthDeviceDataReceived001, testing::ext::TestSize.Level0)
1011 {
1012     int32_t sessionId = 0;
1013     std::string message;
1014     authManager_->OnAuthDeviceDataReceived(sessionId, message);
1015     ASSERT_EQ(authManager_->isAuthDevice_, false);
1016 }
1017 
1018 HWTEST_F(DmAuthManagerTest, OnAuthDeviceDataReceived002, testing::ext::TestSize.Level0)
1019 {
1020     int32_t sessionId = 0;
1021     nlohmann::json jsonObject;
1022     jsonObject[TAG_DATA] = 123;
1023     std::string message = jsonObject.dump();
1024     authManager_->OnAuthDeviceDataReceived(sessionId, message);
1025     ASSERT_EQ(authManager_->isAuthDevice_, false);
1026 }
1027 
1028 HWTEST_F(DmAuthManagerTest, OnAuthDeviceDataReceived003, testing::ext::TestSize.Level0)
1029 {
1030     int32_t sessionId = 0;
1031     nlohmann::json jsonObject;
1032     jsonObject[TAG_DATA] = "123";
1033     jsonObject[TAG_DATA_LEN] = "123";
1034     std::string message = jsonObject.dump();
1035     authManager_->OnAuthDeviceDataReceived(sessionId, message);
1036     ASSERT_EQ(authManager_->isAuthDevice_, false);
1037 }
1038 
1039 HWTEST_F(DmAuthManagerTest, OnAuthDeviceDataReceived004, testing::ext::TestSize.Level0)
1040 {
1041     int32_t sessionId = 0;
1042     nlohmann::json jsonObject;
1043     jsonObject[TAG_DATA] = "123";
1044     jsonObject[TAG_DATA_LEN] = 123;
1045     jsonObject[TAG_MSG_TYPE] = "123";
1046     std::string message = jsonObject.dump();
1047     authManager_->OnAuthDeviceDataReceived(sessionId, message);
1048     ASSERT_EQ(authManager_->isAuthDevice_, false);
1049 }
1050 
1051 HWTEST_F(DmAuthManagerTest, OnAuthDeviceDataReceived005, testing::ext::TestSize.Level0)
1052 {
1053     int32_t sessionId = 0;
1054     nlohmann::json jsonObject;
1055     jsonObject[TAG_DATA] = "123";
1056     jsonObject[TAG_DATA_LEN] = 123;
1057     jsonObject[TAG_MSG_TYPE] = 123;
1058     std::string message = jsonObject.dump();
1059     authManager_->OnAuthDeviceDataReceived(sessionId, message);
1060     ASSERT_EQ(authManager_->isAuthDevice_, false);
1061 }
1062 
1063 HWTEST_F(DmAuthManagerTest, OnUnbindSessionOpened001, testing::ext::TestSize.Level0)
1064 {
1065     int32_t sessionId = 1;
1066     std::string name = "nameTest";
1067     std::string networkId = "159753681387291";
1068     std::string pkgName = "com.ohos.test";
1069     PeerSocketInfo info = {
1070         .name = const_cast<char*>(name.c_str()),
1071         .pkgName = const_cast<char*>(pkgName.c_str()),
1072         .networkId = const_cast<char*>(networkId.c_str()),
1073     };
1074     authManager_->authResponseState_ = nullptr;
1075     authManager_->authRequestState_ = nullptr;
1076     authManager_->timer_ = nullptr;
1077     authManager_->OnUnbindSessionOpened(sessionId, info);
1078     ASSERT_EQ(authManager_->isAuthDevice_, false);
1079 }
1080 
1081 HWTEST_F(DmAuthManagerTest, OnUnbindSessionOpened002, testing::ext::TestSize.Level0)
1082 {
1083     int32_t sessionId = 1;
1084     std::string name = "nameTest";
1085     std::string networkId = "159753681387291";
1086     std::string pkgName = "com.ohos.test";
1087     PeerSocketInfo info = {
1088         .name = const_cast<char*>(name.c_str()),
1089         .pkgName = const_cast<char*>(pkgName.c_str()),
1090         .networkId = const_cast<char*>(networkId.c_str()),
1091     };
1092     authManager_->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
1093     authManager_->authRequestState_ = std::make_shared<AuthRequestDeleteInit>();
1094     authManager_->timer_ = nullptr;
1095     authManager_->OnUnbindSessionOpened(sessionId, info);
1096     ASSERT_EQ(authManager_->isAuthDevice_, false);
1097 }
1098 
1099 HWTEST_F(DmAuthManagerTest, DeleteGroup001, testing::ext::TestSize.Level0)
1100 {
1101     std::string pkgName;
1102     std::string deviceId;
1103     int32_t ret = authManager_->DeleteGroup(pkgName, deviceId);
1104     ASSERT_EQ(ret, ERR_DM_FAILED);
1105 }
1106 
1107 HWTEST_F(DmAuthManagerTest, DeleteGroup002, testing::ext::TestSize.Level0)
1108 {
1109     std::string pkgName = "pkgName";
1110     std::string deviceId;
1111     int32_t ret = authManager_->DeleteGroup(pkgName, deviceId);
1112     ASSERT_NE(ret, DM_OK);
1113 }
1114 
1115 HWTEST_F(DmAuthManagerTest, PutAccessControlList001, testing::ext::TestSize.Level0)
1116 {
1117     authManager_->PutAccessControlList();
1118     ASSERT_EQ(authManager_->isAuthDevice_, false);
1119     authManager_->authResponseContext_->isIdenticalAccount = true;
1120     authManager_->PutAccessControlList();
1121     ASSERT_EQ(authManager_->isAuthDevice_, false);
1122     authManager_->authResponseContext_->isIdenticalAccount = true;
1123     authManager_->PutAccessControlList();
1124     ASSERT_EQ(authManager_->isAuthDevice_, false);
1125 }
1126 
1127 HWTEST_F(DmAuthManagerTest, BindSocketFail_001, testing::ext::TestSize.Level0)
1128 {
1129     authManager_->BindSocketFail();
1130     ASSERT_EQ(authManager_->isFinishOfLocal_, false);
1131 }
1132 
1133 HWTEST_F(DmAuthManagerTest, BindSocketSuccess_001, testing::ext::TestSize.Level0)
1134 {
1135     int32_t socket = 1;
1136     authManager_->authResponseState_ = nullptr;
1137     authManager_->authRequestState_ = std::make_shared<AuthRequestDeleteInit>();
1138     authManager_->BindSocketSuccess(socket);
1139     ASSERT_EQ(authManager_->authRequestContext_->sessionId, socket);
1140 }
1141 
1142 HWTEST_F(DmAuthManagerTest, BindSocketSuccess_002, testing::ext::TestSize.Level0)
1143 {
1144     int32_t socket = 1;
1145     authManager_->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
1146     authManager_->authRequestState_ = nullptr;
1147     authManager_->BindSocketSuccess(socket);
1148     ASSERT_NE(authManager_->authRequestContext_->sessionId, socket);
1149 }
1150 
1151 HWTEST_F(DmAuthManagerTest, SyncDeleteAcl_001, testing::ext::TestSize.Level0)
1152 {
1153     std::string pkgName = "pkgName";
1154     std::string deviceId = "deviceId";
1155     authManager_->SyncDeleteAcl(pkgName, deviceId);
1156     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1157 }
1158 
1159 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_001, testing::ext::TestSize.Level0)
1160 {
1161     authManager_->authResponseContext_->msgType = 200;
1162     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
1163     authManager_->ProcessSourceMsg();
1164     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1165 }
1166 
1167 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_002, testing::ext::TestSize.Level0)
1168 {
1169     authManager_->authResponseContext_->msgType = 200;
1170     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
1171     authManager_->ProcessSourceMsg();
1172     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1173 }
1174 
1175 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_003, testing::ext::TestSize.Level0)
1176 {
1177     authManager_->authResponseContext_->msgType = 501;
1178     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
1179     authManager_->ProcessSourceMsg();
1180     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1181 }
1182 
1183 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_004, testing::ext::TestSize.Level0)
1184 {
1185     authManager_->authResponseContext_->msgType = 501;
1186     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
1187     authManager_->ProcessSourceMsg();
1188     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1189 }
1190 
1191 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_005, testing::ext::TestSize.Level0)
1192 {
1193     authManager_->authResponseContext_->msgType = 90;
1194     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
1195     authManager_->ProcessSourceMsg();
1196     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1197 }
1198 
1199 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_006, testing::ext::TestSize.Level0)
1200 {
1201     authManager_->authResponseContext_->msgType = 90;
1202     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
1203     authManager_->ProcessSourceMsg();
1204     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1205 }
1206 
1207 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_007, testing::ext::TestSize.Level0)
1208 {
1209     authManager_->authResponseContext_->msgType = 104;
1210     authManager_->authRequestState_ = std::make_shared<AuthRequestNetworkState>();
1211     authManager_->ProcessSourceMsg();
1212     ASSERT_EQ(authManager_->isFinishOfLocal_, false);
1213 }
1214 
1215 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_008, testing::ext::TestSize.Level0)
1216 {
1217     authManager_->authResponseContext_->msgType = 104;
1218     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
1219     authManager_->ProcessSourceMsg();
1220     ASSERT_EQ(authManager_->isFinishOfLocal_, false);
1221 }
1222 
1223 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_009, testing::ext::TestSize.Level0)
1224 {
1225     authManager_->authResponseContext_->msgType = 503;
1226     authManager_->authRequestState_ = std::make_shared<AuthRequestCredential>();
1227     authManager_->ProcessSourceMsg();
1228     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1229 }
1230 
1231 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_010, testing::ext::TestSize.Level0)
1232 {
1233     authManager_->authResponseContext_->msgType = 503;
1234     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
1235     authManager_->ProcessSourceMsg();
1236     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1237 }
1238 
1239 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_0011, testing::ext::TestSize.Level0)
1240 {
1241     authManager_->authResponseContext_->msgType = 505;
1242     authManager_->authRequestState_ = std::make_shared<AuthRequestSyncDeleteAcl>();
1243     authManager_->ProcessSourceMsg();
1244     ASSERT_EQ(authManager_->isFinishOfLocal_, false);
1245 }
1246 
1247 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_0012, testing::ext::TestSize.Level0)
1248 {
1249     authManager_->authResponseContext_->msgType = 505;
1250     authManager_->authRequestState_ = std::make_shared<AuthRequestNegotiateDoneState>();
1251     authManager_->ProcessSourceMsg();
1252     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1253 }
1254 
1255 HWTEST_F(DmAuthManagerTest, ProcessSourceMsg_013, testing::ext::TestSize.Level0)
1256 {
1257     authManager_->authResponseContext_->msgType = 1000;
1258     authManager_->authRequestState_ = std::make_shared<AuthRequestSyncDeleteAcl>();
1259     authManager_->ProcessSourceMsg();
1260     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1261 }
1262 
1263 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_001, testing::ext::TestSize.Level0)
1264 {
1265     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1266     authManager_->authResponseContext_->msgType = 80;
1267     authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1268     authManager_->ProcessSinkMsg();
1269     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1270 }
1271 
1272 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_002, testing::ext::TestSize.Level0)
1273 {
1274     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1275     authManager_->authResponseContext_->msgType = 80;
1276     authManager_->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
1277     authManager_->ProcessSinkMsg();
1278     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1279 }
1280 
1281 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_003, testing::ext::TestSize.Level0)
1282 {
1283     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1284     authManager_->authResponseContext_->msgType = 100;
1285     authManager_->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
1286     authManager_->ProcessSinkMsg();
1287     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1288 }
1289 
1290 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_004, testing::ext::TestSize.Level0)
1291 {
1292     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1293     authManager_->authResponseContext_->msgType = 100;
1294     authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1295     authManager_->ProcessSinkMsg();
1296     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1297 }
1298 
1299 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_005, testing::ext::TestSize.Level0)
1300 {
1301     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1302     authManager_->authResponseContext_->msgType = 104;
1303     authManager_->authResponseState_ = std::make_shared<AuthResponseShowState>();
1304     authManager_->ProcessSinkMsg();
1305     ASSERT_EQ(authManager_->isFinishOfLocal_, false);
1306 }
1307 
1308 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_006, testing::ext::TestSize.Level0)
1309 {
1310     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1311     authManager_->authResponseContext_->msgType = 502;
1312     authManager_->authResponseState_ = std::make_shared<AuthResponseShowState>();
1313     authManager_->ProcessSinkMsg();
1314     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1315 }
1316 
1317 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_007, testing::ext::TestSize.Level0)
1318 {
1319     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1320     authManager_->authResponseContext_->msgType = 504;
1321     authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1322     authManager_->ProcessSinkMsg();
1323     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1324 }
1325 
1326 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_008, testing::ext::TestSize.Level0)
1327 {
1328     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1329     authManager_->authResponseContext_->msgType = 505;
1330     authManager_->authResponseState_ = std::make_shared<AuthResponseSyncDeleteAclNone>();
1331     authManager_->ProcessSinkMsg();
1332     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1333 }
1334 
1335 HWTEST_F(DmAuthManagerTest, ProcessSinkMsg_009, testing::ext::TestSize.Level0)
1336 {
1337     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1338     authManager_->authResponseContext_->msgType = 1000;
1339     authManager_->authResponseState_ = std::make_shared<AuthResponseSyncDeleteAclNone>();
1340     authManager_->ProcessSinkMsg();
1341     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1342 }
1343 } // namespace
1344 } // namespace DistributedHardware
1345 } // namespace OHOS
1346