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_second.h"
17 
18 #include "nlohmann/json.hpp"
19 
20 #include "dm_log.h"
21 #include "dm_crypto.h"
22 #include "dm_constants.h"
23 #include "dm_auth_manager.h"
24 #include "auth_message_processor.h"
25 #include "device_manager_service_listener.h"
26 #include "softbus_error_code.h"
27 
28 namespace OHOS {
29 namespace DistributedHardware {
SetUp()30 void DmAuthManagerTest::SetUp()
31 {
32     authManager_->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager_);
33     authManager_->authMessageProcessor_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
34     authManager_->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
35     authManager_->authRequestState_ = std::make_shared<AuthRequestFinishState>();
36     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
37     authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
38     authManager_->hiChainAuthConnector_ = std::make_shared<HiChainAuthConnector>();
39     authManager_->softbusConnector_ = std::make_shared<SoftbusConnector>();
40     authManager_->softbusConnector_->GetSoftbusSession()->
41         RegisterSessionCallback(std::shared_ptr<ISoftbusSessionCallback>(authManager_));
42     authManager_->timer_ = std::make_shared<DmTimer>();
43 }
TearDown()44 void DmAuthManagerTest::TearDown()
45 {
46 }
SetUpTestCase()47 void DmAuthManagerTest::SetUpTestCase()
48 {
49 }
TearDownTestCase()50 void DmAuthManagerTest::TearDownTestCase()
51 {
52 }
53 
54 namespace {
55 HWTEST_F(DmAuthManagerTest, OnDataReceived_001, testing::ext::TestSize.Level0)
56 {
57     int32_t sessionId = 0;
58     std::string message;
59     authManager_->authResponseContext_ = nullptr;
60     authManager_->OnDataReceived(sessionId, message);
61     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
62 }
63 
64 HWTEST_F(DmAuthManagerTest, OnDataReceived_002, testing::ext::TestSize.Level0)
65 {
66     int32_t sessionId = 0;
67     std::string message;
68     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
69     authManager_->authMessageProcessor_ = nullptr;
70     authManager_->OnDataReceived(sessionId, message);
71     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
72 }
73 
74 HWTEST_F(DmAuthManagerTest, OnDataReceived_003, testing::ext::TestSize.Level0)
75 {
76     int32_t sessionId = 0;
77     std::string message;
78     authManager_->OnDataReceived(sessionId, message);
79     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
80 }
81 
82 HWTEST_F(DmAuthManagerTest, OnDataReceived_004, testing::ext::TestSize.Level0)
83 {
84     int32_t sessionId = 0;
85     nlohmann::json jsonObject;
86     jsonObject[TAG_MSG_TYPE] = 200;
87     std::string message = jsonObject.dump();
88     authManager_->OnDataReceived(sessionId, message);
89     authManager_->authRequestState_ = std::make_shared<AuthRequestSyncDeleteAcl>();
90     authManager_->authResponseState_ = nullptr;
91     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
92 }
93 
94 HWTEST_F(DmAuthManagerTest, OnDataReceived_005, testing::ext::TestSize.Level0)
95 {
96     int32_t sessionId = 0;
97     nlohmann::json jsonObject;
98     jsonObject[TAG_MSG_TYPE] = 200;
99     std::string message = jsonObject.dump();
100     authManager_->OnDataReceived(sessionId, message);
101     authManager_->authRequestState_ = nullptr;
102     authManager_->authResponseState_ = std::make_shared<AuthResponseSyncDeleteAclNone>();
103     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
104 }
105 
106 HWTEST_F(DmAuthManagerTest, OnDataReceived_007, testing::ext::TestSize.Level0)
107 {
108     int32_t sessionId = 0;
109     nlohmann::json jsonObject;
110     jsonObject[TAG_MSG_TYPE] = 200;
111     std::string message = jsonObject.dump();
112     authManager_->OnDataReceived(sessionId, message);
113     authManager_->authRequestState_ = nullptr;
114     authManager_->authResponseState_ = nullptr;
115     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
116 }
117 
118 HWTEST_F(DmAuthManagerTest, OnGroupCreated_001, testing::ext::TestSize.Level0)
119 {
120     int64_t requestId = 0;
121     std::string groupId;
122     authManager_->authResponseContext_ = nullptr;
123     authManager_->OnGroupCreated(requestId, groupId);
124     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
125 }
126 
127 HWTEST_F(DmAuthManagerTest, OnGroupCreated_002, testing::ext::TestSize.Level0)
128 {
129     int64_t requestId = 0;
130     std::string groupId;
131     authManager_->authResponseState_ = nullptr;
132     authManager_->OnGroupCreated(requestId, groupId);
133     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
134 }
135 
136 HWTEST_F(DmAuthManagerTest, OnGroupCreated_003, testing::ext::TestSize.Level0)
137 {
138     int64_t requestId = 0;
139     std::string groupId = "{}";
140     authManager_->OnGroupCreated(requestId, groupId);
141     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
142 }
143 
144 HWTEST_F(DmAuthManagerTest, OnGroupCreated_004, testing::ext::TestSize.Level0)
145 {
146     int64_t requestId = 0;
147     std::string groupId = "groupId";
148     authManager_->authResponseContext_->isShowDialog = true;
149     authManager_->OnGroupCreated(requestId, groupId);
150     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
151 }
152 
153 HWTEST_F(DmAuthManagerTest, OnGroupCreated_005, testing::ext::TestSize.Level0)
154 {
155     int64_t requestId = 0;
156     std::string groupId = "groupId";
157     authManager_->authResponseContext_->isShowDialog = false;
158     authManager_->OnGroupCreated(requestId, groupId);
159     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
160 }
161 
162 HWTEST_F(DmAuthManagerTest, OnMemberJoin_001, testing::ext::TestSize.Level0)
163 {
164     int64_t requestId = 0;
165     int32_t status = 11;
166     authManager_->authResponseContext_ = nullptr;
167     authManager_->OnMemberJoin(requestId, status);
168     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
169 }
170 
171 HWTEST_F(DmAuthManagerTest, OnMemberJoin_002, testing::ext::TestSize.Level0)
172 {
173     int64_t requestId = 0;
174     int32_t status = 11;
175     authManager_->authUiStateMgr_ = nullptr;
176     authManager_->OnMemberJoin(requestId, status);
177     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
178 }
179 
180 HWTEST_F(DmAuthManagerTest, OnMemberJoin_003, testing::ext::TestSize.Level0)
181 {
182     int64_t requestId = 0;
183     int32_t status = 11;
184     authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
185     authManager_->authResponseState_ = nullptr;
186     authManager_->authResponseContext_->authType = 5;
187     authManager_->OnMemberJoin(requestId, status);
188     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
189 }
190 
191 HWTEST_F(DmAuthManagerTest, OnMemberJoin_004, testing::ext::TestSize.Level0)
192 {
193     int64_t requestId = 0;
194     int32_t status = 11;
195     authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
196     authManager_->authResponseState_ = nullptr;
197     authManager_->authResponseContext_->authType = 6;
198     authManager_->authResponseContext_->requestId = 1;
199     authManager_->OnMemberJoin(requestId, status);
200     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
201 }
202 
203 HWTEST_F(DmAuthManagerTest, OnMemberJoin_006, testing::ext::TestSize.Level0)
204 {
205     int64_t requestId = 0;
206     int32_t status = 0;
207     authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
208     authManager_->authResponseState_ = nullptr;
209     authManager_->authResponseContext_->authType = 6;
210     authManager_->authResponseContext_->requestId = 0;
211     authManager_->OnMemberJoin(requestId, status);
212     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
213 }
214 
215 HWTEST_F(DmAuthManagerTest, OnMemberJoin_007, testing::ext::TestSize.Level0)
216 {
217     int64_t requestId = 0;
218     int32_t status = 0;
219     authManager_->authRequestState_ = nullptr;
220     authManager_->authResponseState_ = std::make_shared<AuthResponseShowState>();
221     authManager_->authResponseContext_->authType = 6;
222     authManager_->authResponseContext_->requestId = 0;
223     authManager_->OnMemberJoin(requestId, status);
224     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
225 }
226 
227 HWTEST_F(DmAuthManagerTest, OnMemberJoin_008, testing::ext::TestSize.Level0)
228 {
229     int64_t requestId = 0;
230     int32_t status = 0;
231     authManager_->authRequestState_ = nullptr;
232     authManager_->authResponseState_ = nullptr;
233     authManager_->OnMemberJoin(requestId, status);
234     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
235 }
236 
237 HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_001, testing::ext::TestSize.Level0)
238 {
239     int64_t requestId = 1;
240     int32_t status = 0;
241     authManager_->authResponseContext_->requestId = 1;
242     authManager_->HandleMemberJoinImportAuthCode(requestId, status);
243     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
244 }
245 
246 HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_002, testing::ext::TestSize.Level0)
247 {
248     int64_t requestId = 1;
249     int32_t status = 1;
250     authManager_->authResponseContext_->requestId = 1;
251     authManager_->HandleMemberJoinImportAuthCode(requestId, status);
252     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
253 }
254 
255 HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_003, testing::ext::TestSize.Level0)
256 {
257     int64_t requestId = 1;
258     int32_t status = 1;
259     authManager_->authResponseContext_->requestId = 0;
260     authManager_->HandleMemberJoinImportAuthCode(requestId, status);
261     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
262 }
263 
264 HWTEST_F(DmAuthManagerTest, HandleMemberJoinImportAuthCode_004, testing::ext::TestSize.Level0)
265 {
266     int64_t requestId = 1;
267     int32_t status = 0;
268     authManager_->authResponseContext_->requestId = 0;
269     authManager_->HandleMemberJoinImportAuthCode(requestId, status);
270     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
271 }
272 
273 HWTEST_F(DmAuthManagerTest, RespNegotiate_001, testing::ext::TestSize.Level0)
274 {
275     int64_t requestId = 1;
276     authManager_->authResponseContext_ = nullptr;
277     authManager_->RespNegotiate(requestId);
278     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
279 }
280 
281 HWTEST_F(DmAuthManagerTest, RespNegotiate_002, testing::ext::TestSize.Level0)
282 {
283     int64_t requestId = 1;
284     authManager_->RespNegotiate(requestId);
285     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
286 }
287 
288 HWTEST_F(DmAuthManagerTest, RespNegotiate_003, testing::ext::TestSize.Level0)
289 {
290     int64_t requestId = 1;
291     authManager_->authRequestState_ = nullptr;
292     authManager_->authResponseContext_->dmVersion = "dmVersion";
293     authManager_->authResponseContext_->bindLevel = 1;
294     authManager_->RespNegotiate(requestId);
295     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
296 }
297 
298 HWTEST_F(DmAuthManagerTest, RespNegotiate_004, testing::ext::TestSize.Level0)
299 {
300     int64_t requestId = 1;
301     authManager_->authRequestState_ = nullptr;
302     authManager_->authResponseContext_->dmVersion = "";
303     authManager_->authResponseContext_->bindLevel = 0;
304     authManager_->RespNegotiate(requestId);
305     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
306 }
307 
308 HWTEST_F(DmAuthManagerTest, RespNegotiate_005, testing::ext::TestSize.Level0)
309 {
310     int64_t requestId = 1;
311     authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
312     authManager_->authResponseContext_->dmVersion = "4.1.5.1";
313     authManager_->authResponseContext_->bindLevel = 0;
314     authManager_->RespNegotiate(requestId);
315     authManager_->authResponseContext_->dmVersion = "5.0.1";
316     authManager_->authResponseContext_->bindLevel = 1;
317     authManager_->RespNegotiate(requestId);
318     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
319 }
320 
321 HWTEST_F(DmAuthManagerTest, SendAuthRequest_001, testing::ext::TestSize.Level0)
322 {
323     int64_t sessionId = 1;
324     authManager_->authResponseContext_ = nullptr;
325     authManager_->SendAuthRequest(sessionId);
326     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
327 }
328 
329 HWTEST_F(DmAuthManagerTest, SendAuthRequest_002, testing::ext::TestSize.Level0)
330 {
331     int64_t sessionId = 1;
332     authManager_->authResponseContext_->cryptoSupport = true;
333     authManager_->authResponseContext_->dmVersion = "dmVersion";
334     authManager_->authResponseContext_->bindLevel = 1;
335     authManager_->authResponseContext_->hostPkgName = "hostPkgName";
336     authManager_->authResponseContext_->localDeviceId = "123456789";
337     authManager_->authResponseContext_->deviceId = "deviceId";
338     authManager_->authResponseContext_->reply = -20018;
339     authManager_->SendAuthRequest(sessionId);
340     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
341 }
342 
343 HWTEST_F(DmAuthManagerTest, SendAuthRequest_003, testing::ext::TestSize.Level0)
344 {
345     int64_t sessionId = 1;
346     authManager_->authResponseContext_->cryptoSupport = true;
347     authManager_->authResponseContext_->bindLevel = 0;
348     authManager_->authResponseContext_->dmVersion = "dmVersion";
349     authManager_->authResponseContext_->bindLevel = 1;
350     authManager_->authResponseContext_->hostPkgName = "hostPkgName";
351     authManager_->authResponseContext_->localDeviceId = "123456789";
352     authManager_->authResponseContext_->deviceId = "deviceId";
353     authManager_->authResponseContext_->reply = -20018;
354     authManager_->SendAuthRequest(sessionId);
355     authManager_->authResponseContext_->dmVersion = "5.0.1";
356     authManager_->authResponseContext_->bindLevel = 0;
357     authManager_->SendAuthRequest(sessionId);
358     authManager_->authResponseContext_->dmVersion = "";
359     authManager_->authResponseContext_->bindLevel = 1;
360     authManager_->SendAuthRequest(sessionId);
361     authManager_->authResponseContext_->dmVersion = "5.0.1";
362     authManager_->authResponseContext_->bindLevel = 1;
363     authManager_->SendAuthRequest(sessionId);
364     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
365 }
366 
367 HWTEST_F(DmAuthManagerTest, GetAuthRequestContext_001, testing::ext::TestSize.Level0)
368 {
369     authManager_->authResponseContext_->localDeviceId = "123456789";
370     authManager_->authResponseContext_->localDeviceId = "123456789";
371     authManager_->authResponseContext_->localAccountId = "123456789";
372     authManager_->authRequestContext_->remoteAccountId = "123456789";
373     authManager_->authRequestContext_->localAccountId = "123456789";
374     authManager_->authResponseContext_->localUserId = 123456789;
375     authManager_->GetAuthRequestContext();
376     authManager_->authResponseContext_->isOnline = false;
377     authManager_->GetAuthRequestContext();
378     authManager_->authResponseContext_->isOnline = true;
379     authManager_->authResponseContext_->haveCredential = true;
380     authManager_->GetAuthRequestContext();
381     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
382 }
383 
384 HWTEST_F(DmAuthManagerTest, ProcessAuthRequestExt_001, testing::ext::TestSize.Level0)
385 {
386     int32_t sessionId = 1;
387     authManager_->authResponseContext_->reply = -20018;
388     authManager_->ProcessAuthRequestExt(sessionId);
389     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
390 }
391 
392 HWTEST_F(DmAuthManagerTest, ProcessAuthRequestExt_002, testing::ext::TestSize.Level0)
393 {
394     int32_t sessionId = 1;
395     authManager_->authResponseContext_->reply = -200;
396     authManager_->authResponseContext_->isOnline = false;
397     authManager_->authResponseContext_->authed = false;
398     authManager_->authResponseContext_->isIdenticalAccount = true;
399     authManager_->ProcessAuthRequestExt(sessionId);
400     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
401 }
402 
403 HWTEST_F(DmAuthManagerTest, ProcessAuthRequestExt_004, testing::ext::TestSize.Level0)
404 {
405     int32_t sessionId = 1;
406     authManager_->authResponseContext_->reply = -200;
407     authManager_->authResponseContext_->authType = 5;
408     authManager_->authResponseContext_->isIdenticalAccount = false;
409     authManager_->authResponseContext_->isAuthCodeReady = false;
410     authManager_->ProcessAuthRequestExt(sessionId);
411     authManager_->authResponseContext_->isOnline = true;
412     authManager_->authResponseContext_->authed = true;
413     authManager_->ProcessAuthRequestExt(sessionId);
414     authManager_->authResponseContext_->authed = false;
415     authManager_->authResponseContext_->isOnline = false;
416     authManager_->ProcessAuthRequestExt(sessionId);
417     authManager_->authResponseContext_->isIdenticalAccount = true;
418     authManager_->ProcessAuthRequestExt(sessionId);
419     authManager_->authResponseContext_->isIdenticalAccount = false;
420     authManager_->authResponseContext_->authed = true;
421     authManager_->ProcessAuthRequestExt(sessionId);
422     authManager_->authResponseContext_->isOnline = true;
423     authManager_->ProcessAuthRequestExt(sessionId);
424     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
425 }
426 
427 HWTEST_F(DmAuthManagerTest, ConfirmProcess_001, testing::ext::TestSize.Level0)
428 {
429     int32_t action = 1;
430     authManager_->action_ = 0;
431     authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
432     int32_t ret = authManager_->ConfirmProcess(action);
433     ASSERT_EQ(ret, DM_OK);
434 }
435 
436 HWTEST_F(DmAuthManagerTest, ConfirmProcess_002, testing::ext::TestSize.Level0)
437 {
438     int32_t action = 1;
439     authManager_->action_ = 6;
440     authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
441     int32_t ret = authManager_->ConfirmProcess(action);
442     ASSERT_EQ(ret, DM_OK);
443 }
444 
445 HWTEST_F(DmAuthManagerTest, ConfirmProcess_003, testing::ext::TestSize.Level0)
446 {
447     int32_t action = 3;
448     authManager_->action_ = 4;
449     authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
450     int32_t ret = authManager_->ConfirmProcess(action);
451     ASSERT_EQ(ret, DM_OK);
452 }
453 
454 HWTEST_F(DmAuthManagerTest, ConfirmProcessExt_001, testing::ext::TestSize.Level0)
455 {
456     int32_t action = 1;
457     authManager_->action_ = 0;
458     authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
459     authManager_->authResponseContext_->isShowDialog = false;
460     int32_t ret = authManager_->ConfirmProcessExt(action);
461     ASSERT_EQ(ret, DM_OK);
462 }
463 
464 HWTEST_F(DmAuthManagerTest, ConfirmProcessExt_002, testing::ext::TestSize.Level0)
465 {
466     int32_t action = 1;
467     authManager_->action_ = 6;
468     authManager_->authResponseState_ = std::make_shared<AuthResponseConfirmState>();
469     authManager_->authResponseContext_->isShowDialog = true;
470     int32_t ret = authManager_->ConfirmProcessExt(action);
471     ASSERT_EQ(ret, DM_OK);
472 }
473 
474 HWTEST_F(DmAuthManagerTest, ConfirmProcessExt_003, testing::ext::TestSize.Level0)
475 {
476     int32_t action = 1;
477     authManager_->action_ = 4;
478     int32_t ret = authManager_->ConfirmProcessExt(action);
479     ASSERT_EQ(ret, DM_OK);
480 }
481 
482 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_001, testing::ext::TestSize.Level0)
483 {
484     authManager_->authResponseContext_ = nullptr;
485     authManager_->StartRespAuthProcess();
486     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
487 }
488 
489 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_002, testing::ext::TestSize.Level0)
490 {
491     authManager_->authResponseContext_->groupName = "111111";
492     authManager_->StartRespAuthProcess();
493     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
494 }
495 
496 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_003, testing::ext::TestSize.Level0)
497 {
498     authManager_->authResponseContext_->groupName = "00000";
499     authManager_->StartRespAuthProcess();
500     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
501 }
502 
503 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_004, testing::ext::TestSize.Level0)
504 {
505     authManager_->authResponseContext_->groupName = "00000";
506     authManager_->authResponseContext_->reply = 0;
507     authManager_->StartRespAuthProcess();
508     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
509 }
510 
511 HWTEST_F(DmAuthManagerTest, StartRespAuthProcess_005, testing::ext::TestSize.Level0)
512 {
513     authManager_->authResponseContext_->groupName = "11111";
514     authManager_->authResponseContext_->reply = 1;
515     authManager_->StartRespAuthProcess();
516     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
517 }
518 
519 HWTEST_F(DmAuthManagerTest, GetConnectAddr_001, testing::ext::TestSize.Level0)
520 {
521     std::string deviceId = "deviceId";
522     auto ret = authManager_->GetConnectAddr(deviceId);
523     ASSERT_EQ(ret.empty(), true);
524 }
525 
526 HWTEST_F(DmAuthManagerTest, GetConnectAddr_002, testing::ext::TestSize.Level0)
527 {
528     std::string deviceId = "deviceId";
529     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
530     infoPtr->addrNum = 1;
531     authManager_->softbusConnector_->discoveryDeviceInfoMap_.insert(std::pair<std::string,
532         std::shared_ptr<DeviceInfo>>(deviceId, infoPtr));
533     auto ret = authManager_->GetConnectAddr(deviceId);
534     ASSERT_EQ(ret.empty(), false);
535 }
536 
537 HWTEST_F(DmAuthManagerTest, SinkAuthenticateFinish_001, testing::ext::TestSize.Level0)
538 {
539     authManager_->authResponseState_ = std::make_shared<AuthResponseFinishState>();
540     authManager_->authPtr_ = authManager_->authenticationMap_[1];
541     authManager_->isFinishOfLocal_ = true;
542     authManager_->SinkAuthenticateFinish();
543     ASSERT_EQ(authManager_->authResponseState_, nullptr);
544 }
545 
546 HWTEST_F(DmAuthManagerTest, SrcAuthenticateFinish_001, testing::ext::TestSize.Level0)
547 {
548     authManager_->isFinishOfLocal_ = true;
549     authManager_->authResponseContext_->state = 5;
550     authManager_->authPtr_ = authManager_->authenticationMap_[1];
551     authManager_->SrcAuthenticateFinish();
552     usleep(600);
553     ASSERT_EQ(authManager_->authRequestState_, nullptr);
554 }
555 
556 HWTEST_F(DmAuthManagerTest, SrcAuthenticateFinish_002, testing::ext::TestSize.Level0)
557 {
558     authManager_->isFinishOfLocal_ = false;
559     authManager_->authResponseContext_->state = 7;
560     authManager_->authPtr_ = authManager_->authenticationMap_[1];
561     authManager_->SrcAuthenticateFinish();
562     usleep(600);
563     ASSERT_EQ(authManager_->authRequestState_, nullptr);
564 }
565 
566 HWTEST_F(DmAuthManagerTest, AuthenticateFinish_001, testing::ext::TestSize.Level0)
567 {
568     authManager_->authResponseContext_ = nullptr;
569     authManager_->AuthenticateFinish();
570     ASSERT_EQ(authManager_->authResponseContext_, nullptr);
571 }
572 
573 HWTEST_F(DmAuthManagerTest, AuthenticateFinish_002, testing::ext::TestSize.Level0)
574 {
575     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
576     authManager_->authUiStateMgr_ = nullptr;
577     authManager_->AuthenticateFinish();
578     ASSERT_EQ(authManager_->authUiStateMgr_, nullptr);
579 }
580 
581 HWTEST_F(DmAuthManagerTest, AuthenticateFinish_003, testing::ext::TestSize.Level0)
582 {
583     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
584     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
585     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
586     authManager_->authResponseState_ = std::make_shared<AuthResponseFinishState>();
587     authManager_->authRequestState_ = nullptr;
588     authManager_->AuthenticateFinish();
589     ASSERT_EQ(authManager_->authResponseContext_, nullptr);
590 }
591 
592 HWTEST_F(DmAuthManagerTest, AuthenticateFinish_004, testing::ext::TestSize.Level0)
593 {
594     authManager_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
595     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
596     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
597     authManager_->authResponseState_ = nullptr;
598     authManager_->authRequestState_ = std::make_shared<AuthRequestJoinState>();
599     authManager_->AuthenticateFinish();
600     ASSERT_EQ(authManager_->authResponseContext_, nullptr);
601 }
602 
603 HWTEST_F(DmAuthManagerTest, RegisterUiStateCallback_001, testing::ext::TestSize.Level0)
604 {
605     std::string pkgName = "ohos_test";
606     authManager_->authUiStateMgr_ = nullptr;
607     int32_t ret = authManager_->RegisterUiStateCallback(pkgName);
608     ASSERT_EQ(ret, ERR_DM_FAILED);
609 }
610 
611 HWTEST_F(DmAuthManagerTest, RegisterUiStateCallback_002, testing::ext::TestSize.Level0)
612 {
613     std::string pkgName = "ohos_test";
614     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
615     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
616     int32_t ret = authManager_->RegisterUiStateCallback(pkgName);
617     ASSERT_EQ(ret, DM_OK);
618 }
619 
620 HWTEST_F(DmAuthManagerTest, UnRegisterUiStateCallback_001, testing::ext::TestSize.Level0)
621 {
622     std::string pkgName = "ohos_test";
623     authManager_->authUiStateMgr_ = nullptr;
624     int32_t ret = authManager_->UnRegisterUiStateCallback(pkgName);
625     ASSERT_EQ(ret, ERR_DM_FAILED);
626 }
627 
628 HWTEST_F(DmAuthManagerTest, UnRegisterUiStateCallback_002, testing::ext::TestSize.Level0)
629 {
630     std::string pkgName = "ohos_test";
631     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
632     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
633     int32_t ret = authManager_->UnRegisterUiStateCallback(pkgName);
634     ASSERT_EQ(ret, DM_OK);
635 }
636 
637 HWTEST_F(DmAuthManagerTest, SetAuthRequestState_001, testing::ext::TestSize.Level0)
638 {
639     std::shared_ptr<AuthRequestState> authRequestState = nullptr;
640     int32_t ret = authManager_->SetAuthRequestState(authRequestState);
641     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
642 }
643 
644 HWTEST_F(DmAuthManagerTest, SetAuthRequestState_002, testing::ext::TestSize.Level0)
645 {
646     std::shared_ptr<AuthRequestState> authRequestState = std::make_shared<AuthRequestFinishState>();
647     int32_t ret = authManager_->SetAuthRequestState(authRequestState);
648     ASSERT_EQ(ret, DM_OK);
649 }
650 
651 HWTEST_F(DmAuthManagerTest, ShowConfigDialog_001, testing::ext::TestSize.Level0)
652 {
653     authManager_->authResponseContext_ = nullptr;
654     authManager_->ShowConfigDialog();
655     ASSERT_EQ(authManager_->authResponseContext_, nullptr);
656 }
657 
658 HWTEST_F(DmAuthManagerTest, ShowConfigDialog_002, testing::ext::TestSize.Level0)
659 {
660     authManager_->authResponseContext_->isShowDialog = false;
661     authManager_->ShowConfigDialog();
662     ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, false);
663 }
664 
665 HWTEST_F(DmAuthManagerTest, ShowConfigDialog_003, testing::ext::TestSize.Level0)
666 {
667     authManager_->authResponseContext_->isShowDialog = true;
668     authManager_->ShowConfigDialog();
669     ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, true);
670 }
671 
672 HWTEST_F(DmAuthManagerTest, ShowAuthInfoDialog_001, testing::ext::TestSize.Level0)
673 {
674     authManager_->authResponseContext_ = nullptr;
675     authManager_->ShowAuthInfoDialog();
676     ASSERT_EQ(authManager_->authResponseContext_, nullptr);
677 }
678 
679 HWTEST_F(DmAuthManagerTest, ShowAuthInfoDialog_002, testing::ext::TestSize.Level0)
680 {
681     authManager_->authResponseContext_->isShowDialog = false;
682     authManager_->ShowAuthInfoDialog();
683     ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, false);
684 }
685 
686 HWTEST_F(DmAuthManagerTest, ShowAuthInfoDialog_003, testing::ext::TestSize.Level0)
687 {
688     authManager_->authResponseContext_->isShowDialog = true;
689     authManager_->ShowAuthInfoDialog();
690     ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, true);
691 }
692 
693 HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_001, testing::ext::TestSize.Level0)
694 {
695     authManager_->authResponseContext_ = nullptr;
696     authManager_->ShowStartAuthDialog();
697     ASSERT_EQ(authManager_->authResponseContext_, nullptr);
698 }
699 
700 HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_002, testing::ext::TestSize.Level0)
701 {
702     authManager_->authResponseContext_->authType = 5;
703     authManager_->importAuthCode_ = "";
704     authManager_->importPkgName_ = "";
705     authManager_->ShowStartAuthDialog();
706     ASSERT_EQ(authManager_->authResponseContext_->isShowDialog, false);
707 }
708 
709 HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_003, testing::ext::TestSize.Level0)
710 {
711     authManager_->authResponseContext_->authType = 5;
712     authManager_->importAuthCode_ = "123456";
713     authManager_->importPkgName_ = "hostPkgName";
714     authManager_->authResponseContext_->hostPkgName = "hostPkgName";
715     authManager_->authResponseContext_->dmVersion = "dmVersion";
716     authManager_->authResponseContext_->bindLevel = 1;
717     authManager_->ShowStartAuthDialog();
718     ASSERT_EQ(authManager_->authResponseContext_->bindLevel, 1);
719 }
720 
721 HWTEST_F(DmAuthManagerTest, ShowStartAuthDialog_004, testing::ext::TestSize.Level0)
722 {
723     authManager_->authResponseContext_->authType = 5;
724     authManager_->importAuthCode_ = "123456";
725     authManager_->importPkgName_ = "hostPkgName";
726     authManager_->authResponseContext_->hostPkgName = "hostPkgName";
727     authManager_->authResponseContext_->dmVersion = "";
728     authManager_->authResponseContext_->bindLevel = 0;
729     authManager_->ShowStartAuthDialog();
730     authManager_->authResponseContext_->dmVersion = "5.0.1";
731     authManager_->authResponseContext_->bindLevel = 0;
732     authManager_->ShowStartAuthDialog();
733     authManager_->authResponseContext_->dmVersion = "";
734     authManager_->authResponseContext_->bindLevel = 1;
735     authManager_->ShowStartAuthDialog();
736     authManager_->authResponseContext_->dmVersion = "5.0.1";
737     authManager_->authResponseContext_->bindLevel = 1;
738     authManager_->ShowStartAuthDialog();
739     ASSERT_EQ(authManager_->authResponseContext_->bindLevel, 1);
740 }
741 
742 HWTEST_F(DmAuthManagerTest, ProcessPincode_001, testing::ext::TestSize.Level0)
743 {
744     int32_t pinCode = 123456;
745     authManager_->authResponseContext_ = nullptr;
746     int32_t ret = authManager_->ProcessPincode(pinCode);
747     ASSERT_EQ(ret, ERR_DM_FAILED);
748 }
749 
750 HWTEST_F(DmAuthManagerTest, ProcessPincode_002, testing::ext::TestSize.Level0)
751 {
752     int32_t pinCode = 123456;
753     authManager_->authResponseContext_->dmVersion = "dmVersion";
754     authManager_->authResponseContext_->bindLevel = 1;
755     authManager_->isAuthDevice_ = true;
756     int32_t ret = authManager_->ProcessPincode(pinCode);
757     ASSERT_EQ(ret, ERR_DM_ADD_GROUP_FAILED);
758 }
759 
760 HWTEST_F(DmAuthManagerTest, ProcessPincode_003, testing::ext::TestSize.Level0)
761 {
762     int32_t pinCode = 123456;
763     authManager_->authResponseContext_->dmVersion = "";
764     authManager_->authResponseContext_->bindLevel = 0;
765     authManager_->authUiStateMgr_ = nullptr;
766     int32_t ret = authManager_->ProcessPincode(pinCode);
767     ASSERT_EQ(ret, ERR_DM_FAILED);
768     authManager_->authResponseContext_->dmVersion = "5.0.1";
769     authManager_->authResponseContext_->bindLevel = 0;
770     ret = authManager_->ProcessPincode(pinCode);
771     ASSERT_EQ(ret, ERR_DM_FAILED);
772     authManager_->authResponseContext_->dmVersion = "";
773     authManager_->authResponseContext_->bindLevel = 1;
774     ret = authManager_->ProcessPincode(pinCode);
775     ASSERT_EQ(ret, ERR_DM_FAILED);
776     authManager_->authResponseContext_->dmVersion = "5.0.1";
777     authManager_->authResponseContext_->bindLevel = 1;
778     ret = authManager_->ProcessPincode(pinCode);
779     ASSERT_EQ(ret, ERR_DM_FAILED);
780 }
781 
782 HWTEST_F(DmAuthManagerTest, AuthDevice_001, testing::ext::TestSize.Level0)
783 {
784     int32_t pinCode = 123456;
785     authManager_->isAuthDevice_ = true;
786     int32_t ret = authManager_->AuthDevice(pinCode);
787     ASSERT_EQ(ret, ERR_DM_FAILED);
788 }
789 
790 HWTEST_F(DmAuthManagerTest, AuthDevice_002, testing::ext::TestSize.Level0)
791 {
792     int32_t pinCode = 123456;
793     authManager_->isAuthDevice_ = false;
794     authManager_->authResponseContext_->authType = 5;
795     int32_t ret = authManager_->AuthDevice(pinCode);
796     ASSERT_EQ(ret, ERR_DM_FAILED);
797 }
798 
799 HWTEST_F(DmAuthManagerTest, ImportAuthCode_001, testing::ext::TestSize.Level0)
800 {
801     std::string authCode = "";
802     std::string pkgName = "pkgName";
803     int32_t ret = authManager_->ImportAuthCode(authCode, pkgName);
804     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
805 }
806 
807 HWTEST_F(DmAuthManagerTest, ImportAuthCode_002, testing::ext::TestSize.Level0)
808 {
809     std::string authCode = "123456";
810     std::string pkgName = "";
811     int32_t ret = authManager_->ImportAuthCode(authCode, pkgName);
812     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
813 }
814 
815 HWTEST_F(DmAuthManagerTest, ImportAuthCode_003, testing::ext::TestSize.Level0)
816 {
817     std::string authCode = "123456";
818     std::string pkgName = "pkgName";
819     int32_t ret = authManager_->ImportAuthCode(authCode, pkgName);
820     ASSERT_EQ(ret, DM_OK);
821 }
822 
823 HWTEST_F(DmAuthManagerTest, BindTarget_001, testing::ext::TestSize.Level0)
824 {
825     std::string pkgName;
826     PeerTargetId targetId;
827     std::map<std::string, std::string> bindParam;
828     int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam);
829     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
830 }
831 
832 HWTEST_F(DmAuthManagerTest, BindTarget_002, testing::ext::TestSize.Level0)
833 {
834     std::string pkgName = "pkgName";
835     PeerTargetId targetId;
836     std::map<std::string, std::string> bindParam;
837     int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam);
838     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
839 }
840 
841 HWTEST_F(DmAuthManagerTest, BindTarget_004, testing::ext::TestSize.Level0)
842 {
843     std::string pkgName = "pkgName";
844     PeerTargetId targetId;
845     targetId.deviceId = "123456";
846     std::map<std::string, std::string> bindParam;
847     bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "1"));
848     bindParam.insert(std::pair<std::string, std::string>("CONN_ADDR_TYPE", "3"));
849     int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam);
850     ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
851 }
852 
853 HWTEST_F(DmAuthManagerTest, BindTarget_005, testing::ext::TestSize.Level0)
854 {
855     std::string pkgName = "pkgName";
856     PeerTargetId targetId;
857     targetId.deviceId = "";
858     std::map<std::string, std::string> bindParam;
859     bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "2"));
860     bindParam.insert(std::pair<std::string, std::string>("CONN_ADDR_TYPE", "3"));
861     int32_t ret = authManager_->BindTarget(pkgName, targetId, bindParam);
862     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
863 }
864 
865 HWTEST_F(DmAuthManagerTest, ParseConnectAddr_001, testing::ext::TestSize.Level0)
866 {
867     PeerTargetId targetId;
868     targetId.wifiIp = "12131415";
869     targetId.brMac = "D4G4E5G2B4G";
870     targetId.bleMac = "1463158131321";
871     std::string deviceId;
872     std::string addrType = "123456";
873     int32_t ret = authManager_->ParseConnectAddr(targetId, deviceId, addrType);
874     ASSERT_EQ(ret, DM_OK);
875 }
876 
877 HWTEST_F(DmAuthManagerTest, ParseConnectAddr_002, testing::ext::TestSize.Level0)
878 {
879     PeerTargetId targetId;
880     std::string deviceId;
881     std::string addrType;
882     int32_t ret = authManager_->ParseConnectAddr(targetId, deviceId, addrType);
883     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
884 }
885 
886 HWTEST_F(DmAuthManagerTest, ParseAuthType_001, testing::ext::TestSize.Level0)
887 {
888     int32_t authType = 0;
889     std::map<std::string, std::string> bindParam;
890     int32_t ret = authManager_->ParseAuthType(bindParam, authType);
891     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
892 }
893 
894 HWTEST_F(DmAuthManagerTest, ParseAuthType_002, testing::ext::TestSize.Level0)
895 {
896     int32_t authType = 0;
897     std::map<std::string, std::string> bindParam;
898     bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", ""));
899     int32_t ret = authManager_->ParseAuthType(bindParam, authType);
900     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
901 }
902 
903 HWTEST_F(DmAuthManagerTest, ParseAuthType_003, testing::ext::TestSize.Level0)
904 {
905     int32_t authType = 0;
906     std::map<std::string, std::string> bindParam;
907     bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "12"));
908     int32_t ret = authManager_->ParseAuthType(bindParam, authType);
909     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
910 }
911 
912 HWTEST_F(DmAuthManagerTest, ParseAuthType_004, testing::ext::TestSize.Level0)
913 {
914     int32_t authType = 0;
915     std::map<std::string, std::string> bindParam;
916     bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "S"));
917     int32_t ret = authManager_->ParseAuthType(bindParam, authType);
918     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
919 }
920 
921 HWTEST_F(DmAuthManagerTest, ParseAuthType_005, testing::ext::TestSize.Level0)
922 {
923     int32_t authType = 0;
924     std::map<std::string, std::string> bindParam;
925     bindParam.insert(std::pair<std::string, std::string>("AUTH_TYPE", "1"));
926     int32_t ret = authManager_->ParseAuthType(bindParam, authType);
927     ASSERT_EQ(ret, DM_OK);
928 }
929 
930 HWTEST_F(DmAuthManagerTest, ParseExtraFromMap_001, testing::ext::TestSize.Level0)
931 {
932     std::map<std::string, std::string> bindParam;
933     bindParam.insert(std::pair<std::string, std::string>("BIND_EXTRA_DATA", "12"));
934     std::string ret = authManager_->ParseExtraFromMap(bindParam);
935     ASSERT_EQ(ret, "12");
936 }
937 
938 HWTEST_F(DmAuthManagerTest, ParseExtraFromMap_002, testing::ext::TestSize.Level0)
939 {
940     std::map<std::string, std::string> bindParam;
941     std::string ret = authManager_->ParseExtraFromMap(bindParam);
942     ASSERT_EQ(ret, "");
943 }
944 
945 HWTEST_F(DmAuthManagerTest, IsAuthCodeReady_001, testing::ext::TestSize.Level0)
946 {
947     std::string pkgName;
948     authManager_->importAuthCode_ = "";
949     authManager_->importPkgName_ = "importPkgName_";
950     bool ret = authManager_->IsAuthCodeReady(pkgName);
951     ASSERT_EQ(ret, false);
952 }
953 
954 HWTEST_F(DmAuthManagerTest, IsAuthCodeReady_002, testing::ext::TestSize.Level0)
955 {
956     std::string pkgName;
957     authManager_->importAuthCode_ = "importAuthCode_";
958     authManager_->importPkgName_ = "";
959     bool ret = authManager_->IsAuthCodeReady(pkgName);
960     ASSERT_EQ(ret, false);
961 }
962 
963 HWTEST_F(DmAuthManagerTest, IsAuthCodeReady_003, testing::ext::TestSize.Level0)
964 {
965     std::string pkgName = "pkgName";
966     authManager_->importAuthCode_ = "importAuthCode_";
967     authManager_->importPkgName_ = "importPkgName_";
968     bool ret = authManager_->IsAuthCodeReady(pkgName);
969     ASSERT_EQ(ret, false);
970 }
971 
972 HWTEST_F(DmAuthManagerTest, IsAuthCodeReady_004, testing::ext::TestSize.Level0)
973 {
974     std::string pkgName = "ohos_test";
975     authManager_->importAuthCode_ = "importAuthCode_";
976     authManager_->importPkgName_ = "ohos_test";
977     bool ret = authManager_->IsAuthCodeReady(pkgName);
978     ASSERT_EQ(ret, true);
979 }
980 
981 HWTEST_F(DmAuthManagerTest, DeleteAuthCode_001, testing::ext::TestSize.Level0)
982 {
983     authManager_->authResponseContext_->authType = 5;
984     int32_t ret = authManager_->DeleteAuthCode();
985     ASSERT_EQ(ret, DM_OK);
986 }
987 
988 HWTEST_F(DmAuthManagerTest, GetAuthCode_001, testing::ext::TestSize.Level0)
989 {
990     std::string pkgName;
991     int32_t pinCode = 1;
992     authManager_->importAuthCode_ = "";
993     authManager_->importPkgName_ = "importPkgName_";
994     int32_t ret = authManager_->GetAuthCode(pkgName, pinCode);
995     ASSERT_EQ(ret, ERR_DM_FAILED);
996 }
997 
998 HWTEST_F(DmAuthManagerTest, GetAuthCode_002, testing::ext::TestSize.Level0)
999 {
1000     std::string pkgName;
1001     int32_t pinCode = 1;
1002     authManager_->importAuthCode_ = "importAuthCode_";
1003     authManager_->importPkgName_ = "";
1004     int32_t ret = authManager_->GetAuthCode(pkgName, pinCode);
1005     ASSERT_EQ(ret, ERR_DM_FAILED);
1006 }
1007 
1008 HWTEST_F(DmAuthManagerTest, GetAuthCode_003, testing::ext::TestSize.Level0)
1009 {
1010     std::string pkgName = "pkgName";
1011     int32_t pinCode = 1;
1012     authManager_->importAuthCode_ = "importAuthCode_";
1013     authManager_->importPkgName_ = "importPkgName_";
1014     int32_t ret = authManager_->GetAuthCode(pkgName, pinCode);
1015     ASSERT_EQ(ret, ERR_DM_FAILED);
1016 }
1017 
1018 HWTEST_F(DmAuthManagerTest, GetAuthCode_004, testing::ext::TestSize.Level0)
1019 {
1020     std::string pkgName = "ohos_test";
1021     int32_t pinCode = 1;
1022     authManager_->importAuthCode_ = "123456";
1023     authManager_->importPkgName_ = "ohos_test";
1024     int32_t ret = authManager_->GetAuthCode(pkgName, pinCode);
1025     ASSERT_EQ(ret, DM_OK);
1026 }
1027 
1028 HWTEST_F(DmAuthManagerTest, IsAuthTypeSupported_001, testing::ext::TestSize.Level0)
1029 {
1030     int32_t authType = 7;
1031     bool ret = authManager_->IsAuthTypeSupported(authType);
1032     ASSERT_EQ(ret, false);
1033 }
1034 
1035 HWTEST_F(DmAuthManagerTest, IsAuthTypeSupported_002, testing::ext::TestSize.Level0)
1036 {
1037     int32_t authType = 7;
1038     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1039     bool ret = authManager_->IsAuthTypeSupported(authType);
1040     ASSERT_EQ(ret, true);
1041 }
1042 
1043 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_001, testing::ext::TestSize.Level0)
1044 {
1045     int32_t authType = -1;
1046     std::string extra;
1047     std::string pkgName = "ohos_test";
1048     std::string deviceId = "512156";
1049     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1050     ASSERT_EQ(ret, ERR_DM_AUTH_FAILED);
1051 }
1052 
1053 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_002, testing::ext::TestSize.Level0)
1054 {
1055     int32_t authType = 6;
1056     std::string extra;
1057     std::string pkgName = "ohos_test";
1058     std::string deviceId = "512156";
1059     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1060     ASSERT_EQ(ret, ERR_DM_AUTH_FAILED);
1061 }
1062 
1063 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_003, testing::ext::TestSize.Level0)
1064 {
1065     int32_t authType = 4;
1066     std::string extra;
1067     std::string pkgName;
1068     std::string deviceId = "512156";
1069     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1070     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1071 }
1072 
1073 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_004, testing::ext::TestSize.Level0)
1074 {
1075     int32_t authType = 4;
1076     std::string extra;
1077     std::string pkgName = "ohos_test";
1078     std::string deviceId;
1079     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1080     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1081 }
1082 
1083 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_005, testing::ext::TestSize.Level0)
1084 {
1085     int32_t authType = 4;
1086     std::string extra;
1087     std::string pkgName = "ohos_test";
1088     std::string deviceId = "512156";
1089     authManager_->listener_ = nullptr;
1090     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1091     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1092 }
1093 
1094 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_006, testing::ext::TestSize.Level0)
1095 {
1096     int32_t authType = 4;
1097     std::string extra;
1098     std::string pkgName = "ohos_test";
1099     std::string deviceId = "512156";
1100     authManager_->authUiStateMgr_ = nullptr;
1101     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1102     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1103 }
1104 
1105 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_007, testing::ext::TestSize.Level0)
1106 {
1107     int32_t authType = 4;
1108     std::string extra;
1109     std::string pkgName = "ohos_test";
1110     std::string deviceId = "512156";
1111     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1112     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1113     authManager_->authenticationMap_.clear();
1114     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1115     ASSERT_EQ(ret, ERR_DM_UNSUPPORTED_AUTH_TYPE);
1116 }
1117 
1118 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_008, testing::ext::TestSize.Level0)
1119 {
1120     int32_t authType = 4;
1121     std::string extra;
1122     std::string pkgName = "ohos_test";
1123     std::string deviceId = "512156";
1124     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1125     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1126     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1127     authManager_->authRequestState_ = nullptr;
1128     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1129     ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1130 }
1131 
1132 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_009, testing::ext::TestSize.Level0)
1133 {
1134     int32_t authType = 4;
1135     std::string extra;
1136     std::string pkgName = "ohos_test";
1137     std::string deviceId = "512156";
1138     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1139     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1140     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1141     authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1142     authManager_->authResponseState_ = nullptr;
1143     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1144     ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1145 }
1146 
1147 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_010, testing::ext::TestSize.Level0)
1148 {
1149     int32_t authType = 4;
1150     std::string extra;
1151     std::string pkgName = "ohos_test";
1152     std::string deviceId = "512156";
1153     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1154     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1155     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1156     authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1157     authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1158     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1159     ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1160 }
1161 
1162 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0011, testing::ext::TestSize.Level0)
1163 {
1164     int32_t authType = 4;
1165     std::string extra;
1166     std::string pkgName = "ohos_test";
1167     std::string deviceId = "512156";
1168     authManager_->importPkgName_ = "ohos_test";
1169     authManager_->importAuthCode_ = "156161";
1170     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1171     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1172     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1173     authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1174     authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1175     authManager_->softbusConnector_->discoveryDeviceInfoMap_.clear();
1176     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1177     ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1178 }
1179 
1180 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0012, testing::ext::TestSize.Level0)
1181 {
1182     int32_t authType = 5;
1183     std::string extra;
1184     std::string pkgName = "ohos_test";
1185     std::string deviceId = "512156";
1186     authManager_->importPkgName_ = "";
1187     authManager_->importAuthCode_ = "";
1188     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1189     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1190     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1191     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
1192     authManager_->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
1193     authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1194     authManager_->authResponseState_ = std::make_shared<AuthResponseInitState>();
1195     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1196     ASSERT_EQ(ret, ERR_DM_AUTH_BUSINESS_BUSY);
1197 }
1198 
1199 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0013, testing::ext::TestSize.Level0)
1200 {
1201     int32_t authType = 5;
1202     std::string extra;
1203     std::string pkgName = "ohos_test";
1204     std::string deviceId = "512156";
1205     authManager_->importPkgName_ = "ohos_test";
1206     authManager_->importAuthCode_ = "156161";
1207     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1208     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1209     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1210     authManager_->authRequestState_ = nullptr;
1211     authManager_->authResponseState_ = nullptr;
1212     authManager_->softbusConnector_->discoveryDeviceInfoMap_.clear();
1213     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1214     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1215 }
1216 
1217 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0014, testing::ext::TestSize.Level0)
1218 {
1219     int32_t authType = 4;
1220     std::string extra;
1221     std::string pkgName = "ohos_test";
1222     std::string deviceId = "512156";
1223     authManager_->importAuthCode_ = "";
1224     authManager_->importAuthCode_ = "";
1225     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1226     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1227     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1228     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
1229     authManager_->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
1230     authManager_->authRequestState_ = nullptr;
1231     authManager_->authResponseState_ = nullptr;
1232     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1233     ASSERT_EQ(ret, DM_OK);
1234 }
1235 
1236 HWTEST_F(DmAuthManagerTest, CheckAuthParamVaild_0015, testing::ext::TestSize.Level0)
1237 {
1238     int32_t authType = 5;
1239     std::string extra;
1240     std::string pkgName = "ohos_test";
1241     std::string deviceId = "512156";
1242     authManager_->importAuthCode_ = "";
1243     authManager_->importAuthCode_ = "";
1244     std::shared_ptr<IDeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
1245     authManager_->authUiStateMgr_ = std::make_shared<AuthUiStateManager>(listener);
1246     authManager_->authenticationMap_.insert(std::pair<int32_t, std::shared_ptr<IAuthentication>>(authType, nullptr));
1247     std::shared_ptr<DeviceInfo> infoPtr = std::make_shared<DeviceInfo>();
1248     authManager_->softbusConnector_->discoveryDeviceInfoMap_.emplace(deviceId, infoPtr);
1249     authManager_->authRequestState_ = nullptr;
1250     authManager_->authResponseState_ = nullptr;
1251     int32_t ret = authManager_->CheckAuthParamVaild(pkgName, authType, deviceId, extra);
1252     ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
1253 }
1254 
1255 HWTEST_F(DmAuthManagerTest, StartNegotiate_001, testing::ext::TestSize.Level0)
1256 {
1257     int32_t sessionId = 123;
1258     authManager_->authMessageProcessor_->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
1259     authManager_->StartNegotiate(sessionId);
1260     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1261 }
1262 
1263 HWTEST_F(DmAuthManagerTest, StartNegotiate_002, testing::ext::TestSize.Level0)
1264 {
1265     int32_t sessionId = 123;
1266     authManager_->authResponseContext_ = nullptr;
1267     authManager_->StartNegotiate(sessionId);
1268     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1269 }
1270 
1271 HWTEST_F(DmAuthManagerTest, GetAuthParam_001, testing::ext::TestSize.Level0)
1272 {
1273     int32_t authType = 5;
1274     std::string extra;
1275     std::string pkgName = "ohos_test";
1276     std::string deviceId = "512156";
1277     authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1278     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1279 }
1280 
1281 HWTEST_F(DmAuthManagerTest, GetAuthParam_002, testing::ext::TestSize.Level0)
1282 {
1283     nlohmann::json jsonObject;
1284     jsonObject["targetPkgName"] = 1234;
1285     std::string extra = jsonObject.dump();
1286     int32_t authType = 5;
1287     std::string pkgName = "ohos_test";
1288     std::string deviceId = "512156";
1289     authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1290     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1291 }
1292 
1293 HWTEST_F(DmAuthManagerTest, GetAuthParam_003, testing::ext::TestSize.Level0)
1294 {
1295     nlohmann::json jsonObject;
1296     jsonObject["targetPkgName"] = "1234";
1297     jsonObject["appOperation"] = 1234;
1298     std::string extra = jsonObject.dump();
1299     int32_t authType = 5;
1300     std::string pkgName = "ohos_test";
1301     std::string deviceId = "512156";
1302     authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1303     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1304 }
1305 
1306 HWTEST_F(DmAuthManagerTest, GetAuthParam_004, testing::ext::TestSize.Level0)
1307 {
1308     nlohmann::json jsonObject;
1309     jsonObject["targetPkgName"] = "1234";
1310     jsonObject["appOperation"] = "1234";
1311     jsonObject["customDescription"] = 1234;
1312     std::string extra = jsonObject.dump();
1313     int32_t authType = 5;
1314     std::string pkgName = "ohos_test";
1315     std::string deviceId = "512156";
1316     authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1317     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1318 }
1319 
1320 HWTEST_F(DmAuthManagerTest, GetAuthParam_005, testing::ext::TestSize.Level0)
1321 {
1322     nlohmann::json jsonObject;
1323     jsonObject["targetPkgName"] = "1234";
1324     jsonObject["appOperation"] = "1234";
1325     jsonObject["customDescription"] = "1234";
1326     jsonObject["appThumbnail"] = 1234;
1327     std::string extra = jsonObject.dump();
1328     int32_t authType = 5;
1329     std::string pkgName = "ohos_test";
1330     std::string deviceId = "512156";
1331     authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1332     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1333 }
1334 
1335 HWTEST_F(DmAuthManagerTest, GetAuthParam_006, testing::ext::TestSize.Level0)
1336 {
1337     nlohmann::json jsonObject;
1338     jsonObject["targetPkgName"] = "1234";
1339     jsonObject["appOperation"] = "1234";
1340     jsonObject["customDescription"] = "1234";
1341     jsonObject["appThumbnail"] = "1234";
1342     jsonObject["tokenId"] = "1234";
1343     std::string extra = jsonObject.dump();
1344     int32_t authType = 5;
1345     std::string pkgName = "ohos_test";
1346     std::string deviceId = "512156";
1347     authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1348     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1349 }
1350 
1351 HWTEST_F(DmAuthManagerTest, GetAuthParam_007, testing::ext::TestSize.Level0)
1352 {
1353     nlohmann::json jsonObject;
1354     jsonObject["targetPkgName"] = "1234";
1355     jsonObject["appOperation"] = "1234";
1356     jsonObject["customDescription"] = "1234";
1357     jsonObject["appThumbnail"] = "1234";
1358     jsonObject["tokenId"] = 1234;
1359     jsonObject["bindLevel"] = "1234";
1360     std::string extra = jsonObject.dump();
1361     int32_t authType = 5;
1362     std::string pkgName = "ohos_test";
1363     std::string deviceId = "512156";
1364     authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1365     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1366 }
1367 
1368 HWTEST_F(DmAuthManagerTest, GetAuthParam_008, testing::ext::TestSize.Level0)
1369 {
1370     nlohmann::json jsonObject;
1371     jsonObject["targetPkgName"] = "1234";
1372     jsonObject["appOperation"] = "1234";
1373     jsonObject["customDescription"] = "1234";
1374     jsonObject["appThumbnail"] = "1234";
1375     jsonObject["tokenId"] = 1234;
1376     jsonObject["bindLevel"] = 1234;
1377     std::string extra = jsonObject.dump();
1378     int32_t authType = 5;
1379     std::string pkgName = "ohos_test";
1380     std::string deviceId = "512156";
1381     authManager_->GetAuthParam(pkgName, authType, deviceId, extra);
1382     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1383 }
1384 
1385 HWTEST_F(DmAuthManagerTest, InitAuthState_001, testing::ext::TestSize.Level0)
1386 {
1387     std::string extra;
1388     int32_t authType = 5;
1389     std::string pkgName = "ohos_test";
1390     std::string deviceId = "512156";
1391     authManager_->timer_ = nullptr;
1392     authManager_->InitAuthState(pkgName, authType, deviceId, extra);
1393     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1394     authManager_->timer_ = std::make_shared<DmTimer>();
1395     authManager_->InitAuthState(pkgName, authType, deviceId, extra);
1396     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1397 }
1398 
1399 HWTEST_F(DmAuthManagerTest, HandleSessionHeartbeat_001, testing::ext::TestSize.Level0)
1400 {
1401     std::string name;
1402     authManager_->authRequestState_ = std::make_shared<AuthRequestInitState>();
1403     authManager_->HandleSessionHeartbeat(name);
1404     ASSERT_EQ(authManager_->isFinishOfLocal_, true);
1405 }
1406 
1407 HWTEST_F(DmAuthManagerTest, CheckTrustState_001, testing::ext::TestSize.Level0)
1408 {
1409     authManager_->authResponseContext_->isOnline = true;
1410     authManager_->authResponseContext_->authType = 5;
1411     authManager_->authResponseContext_->importAuthCode = "";
1412     authManager_->importAuthCode_ = "";
1413     int32_t ret = authManager_->CheckTrustState();
1414     ASSERT_NE(ret, DM_OK);
1415 }
1416 
1417 HWTEST_F(DmAuthManagerTest, CheckTrustState_002, testing::ext::TestSize.Level0)
1418 {
1419     authManager_->authResponseContext_->isOnline = false;
1420     authManager_->authResponseContext_->authType = 6;
1421     authManager_->authResponseContext_->importAuthCode = "importAuthCode";
1422     authManager_->importAuthCode_ = "importAuthCode_";
1423     authManager_->authResponseContext_->isIdenticalAccount = true;
1424     int32_t ret = authManager_->CheckTrustState();
1425     ASSERT_EQ(ret, DM_OK);
1426 }
1427 
1428 HWTEST_F(DmAuthManagerTest, CheckTrustState_003, testing::ext::TestSize.Level0)
1429 {
1430     authManager_->authResponseContext_->isOnline = false;
1431     authManager_->authResponseContext_->authType = 6;
1432     authManager_->authResponseContext_->importAuthCode = "importAuthCode";
1433     authManager_->importAuthCode_ = "importAuthCode_";
1434     authManager_->authResponseContext_->isIdenticalAccount = false;
1435     authManager_->authResponseContext_->reply = ERR_DM_AUTH_PEER_REJECT;
1436     int32_t ret = authManager_->CheckTrustState();
1437     ASSERT_EQ(ret, DM_OK);
1438 }
1439 
1440 HWTEST_F(DmAuthManagerTest, CheckTrustState_004, testing::ext::TestSize.Level0)
1441 {
1442     authManager_->authResponseContext_->isOnline = false;
1443     authManager_->authResponseContext_->authType = 6;
1444     authManager_->authResponseContext_->importAuthCode = "importAuthCode";
1445     authManager_->importAuthCode_ = "importAuthCode_";
1446     authManager_->authResponseContext_->isIdenticalAccount = false;
1447     authManager_->authResponseContext_->reply = ERR_DM_UNSUPPORTED_AUTH_TYPE;
1448     authManager_->authResponseContext_->authType = 5;
1449     authManager_->authResponseContext_->isAuthCodeReady = false;
1450     int32_t ret = authManager_->CheckTrustState();
1451     ASSERT_EQ(ret, ERR_DM_BIND_PEER_UNSUPPORTED);
1452 }
1453 
1454 HWTEST_F(DmAuthManagerTest, CheckTrustState_005, testing::ext::TestSize.Level0)
1455 {
1456     authManager_->authResponseContext_->isOnline = false;
1457     authManager_->authResponseContext_->authType = 6;
1458     authManager_->authResponseContext_->importAuthCode = "importAuthCode";
1459     authManager_->importAuthCode_ = "importAuthCode_";
1460     authManager_->authResponseContext_->isIdenticalAccount = false;
1461     authManager_->authResponseContext_->reply = 1;
1462     authManager_->authResponseContext_->authType = 1;
1463     authManager_->authResponseContext_->isAuthCodeReady = true;
1464     int32_t ret = authManager_->CheckTrustState();
1465     ASSERT_EQ(ret, DM_OK);
1466 }
1467 
1468 HWTEST_F(DmAuthManagerTest, CheckTrustState_006, testing::ext::TestSize.Level0)
1469 {
1470     std::string udid = "";
1471     authManager_->authResponseContext_->isOnline = false;
1472     authManager_->authResponseContext_->authType = 6;
1473     authManager_->authResponseContext_->importAuthCode = "importAuthCode";
1474     authManager_->importAuthCode_ = "importAuthCode_";
1475     authManager_->authResponseContext_->isIdenticalAccount = false;
1476     authManager_->authResponseContext_->reply = 1;
1477     authManager_->authResponseContext_->authType = 1;
1478     authManager_->authResponseContext_->isAuthCodeReady = true;
1479     int32_t ret = authManager_->CheckTrustState();
1480     ASSERT_EQ(ret, DM_OK);
1481     authManager_->importAuthCode_ = Crypto::Sha256("importAuthCode_");
1482     ret = authManager_->CheckTrustState();
1483     ASSERT_EQ(ret, DM_OK);
1484     authManager_->authResponseContext_->isOnline = false;
1485     authManager_->authResponseContext_->isIdenticalAccount = true;
1486     ret = authManager_->CheckTrustState();
1487     ASSERT_EQ(ret, DM_OK);
1488     authManager_->authResponseContext_->reply = ERR_DM_AUTH_PEER_REJECT;
1489     ret = authManager_->CheckTrustState();
1490     authManager_->OnScreenLocked();
1491     authManager_->HandleDeviceNotTrust(udid);
1492     udid = "udidTest";
1493     authManager_->HandleDeviceNotTrust(udid);
1494     authManager_->authRequestState_ = nullptr;
1495     authManager_->OnScreenLocked();
1496     ASSERT_EQ(ret, DM_OK);
1497 }
1498 } // namespace
1499 } // namespace DistributedHardware
1500 } // namespace OHOS
1501