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_auth_response_state.h"
17 
18 #include "auth_message_processor.h"
19 #include "auth_response_state.h"
20 #include "dm_auth_manager.h"
21 #include "dm_constants.h"
22 #include "dm_log.h"
23 #include "device_manager_service_listener.h"
24 
25 namespace OHOS {
26 namespace DistributedHardware {
SetUp()27 void AuthResponseStateTest::SetUp()
28 {
29 }
TearDown()30 void AuthResponseStateTest::TearDown()
31 {
32 }
SetUpTestCase()33 void AuthResponseStateTest::SetUpTestCase()
34 {
35 }
TearDownTestCase()36 void AuthResponseStateTest::TearDownTestCase()
37 {
38 }
39 
40 namespace {
41 std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
42 std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
43 std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
44 std::shared_ptr<HiChainAuthConnector> hiChainAuthConnector = std::make_shared<HiChainAuthConnector>();
45 /**
46  * @tc.name: AuthResponseInitState::Leave_001
47  * @tc.desc: 1 set authManager not null
48  *           2 call AuthResponseInitState::Leave with authManager ！= null
49  *           3 check ret is authResponseState->authManager_.use_count()
50  * @tc.type: FUNC
51  * @tc.require: AR000GHSJK
52  */
53 HWTEST_F(AuthResponseStateTest, Leave_001, testing::ext::TestSize.Level0)
54 {
55     std::shared_ptr<DmAuthManager> authManager =
56         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
57     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
58     int32_t ret = authResponseState->Leave();
59     ASSERT_EQ(ret, DM_OK);
60 }
61 
62 /**
63  * @tc.name: AuthRequestInitState::GetAuthContext_001
64  * @tc.desc: 1 set authManager not null
65  *           2 call AuthRequestInitState::GetAuthContext with authManager ！= null
66  *           3 check ret is authResponseState->authManager_.use_count()
67  * @tc.type: FUNC
68  * @tc.require: AR000GHSJK
69  */
70 HWTEST_F(AuthResponseStateTest, GetAuthContext_001, testing::ext::TestSize.Level0)
71 {
72     std::shared_ptr<DmAuthManager> authManager =
73         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
74     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
75     std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
76     authResponseState->GetAuthContext();
77     int32_t ret = authResponseState->context_.use_count();
78     authResponseState->context_.reset();
79     ASSERT_EQ(ret, 0);
80 }
81 
82 /**
83  * @tc.name: AuthResponseInitState::SetAuthManager_001
84  * @tc.desc: 1 set authManager not null
85  *           2 call AuthResponseInitState::SetAuthManager with authManager ！= null
86  *           3 check ret is authResponseState->authManager_.use_count()
87  * @tc.type: FUNC
88  * @tc.require: AR000GHSJK
89  */
90 HWTEST_F(AuthResponseStateTest, SetAuthManager_001, testing::ext::TestSize.Level0)
91 {
92     std::shared_ptr<DmAuthManager> authManager =
93         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
94     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
95     authResponseState->SetAuthManager(authManager);
96     int32_t ret = authResponseState->authManager_.use_count();
97     ASSERT_EQ(ret, 1);
98 }
99 
100 /**
101  * @tc.name: AuthResponseInitState::SetAuthManager_002
102  * @tc.desc: 1 set authManager to null
103  *           2 call AuthResponseInitState::SetAuthManager with authManager = null
104  *           3 check ret is authResponseState->authManager_.use_count()
105  * @tc.type: FUNC
106  * @tc.require: AR000GHSJK
107  */
108 HWTEST_F(AuthResponseStateTest, SetAuthManager_002, testing::ext::TestSize.Level0)
109 {
110     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
111     authResponseState->SetAuthManager(nullptr);
112     int32_t ret = authResponseState->authManager_.use_count();
113     ASSERT_EQ(ret, 0);
114 }
115 
116 /**
117  * @tc.name: AuthResponseInitState::TransitionTo_001
118  * @tc.desc: 1 set authManager to null
119  *           2 call AuthResponseInitState::TransitionTo with authManager = null
120  *           4 check ret is ERR_DM_FAILED
121  * @tc.type: FUNC
122  * @tc.require: AR000GHSJK
123  */
124 HWTEST_F(AuthResponseStateTest, TransitionTo_001, testing::ext::TestSize.Level0)
125 {
126     std::shared_ptr<DmAuthManager> authManager =
127         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
128     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
129     authManager = nullptr;
130     authResponseState->authManager_ = authManager;
131     int32_t ret = authResponseState->TransitionTo(std::make_shared<AuthResponseNegotiateState>());
132     ASSERT_EQ(ret, ERR_DM_FAILED);
133 }
134 
135 /**
136  * @tc.name: AuthResponseInitState::TransitionTo_002
137  * @tc.desc: 1 set authManager not null
138  *           2 call AuthResponseInitState::TransitionTo with authManager != null
139  *           4 check ret is DM_OK
140  * @tc.type: FUNC
141  * @tc.require: AR000GHSJK
142  */
143 HWTEST_F(AuthResponseStateTest, TransitionTo_002, testing::ext::TestSize.Level0)
144 {
145     std::shared_ptr<DmAuthManager> authManager =
146         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
147     std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
148     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
149     authManager->authResponseState_ = std::make_shared<AuthResponseInitState>();
150     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
151     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
152     context->sessionId = 123456;
153     authResponseState->SetAuthContext(context);
154     authResponseState->SetAuthManager(authManager);
155     int32_t ret = authResponseState->TransitionTo(std::make_shared<AuthResponseInitState>());
156     ASSERT_EQ(ret, DM_OK);
157 }
158 
159 /**
160  * @tc.name: AuthResponseInitState::GetStateType_001
161  * @tc.desc: 1 call AuthResponseInitState::GetStateType
162  *           2 check ret is AuthState::AUTH_RESPONSE_INIT
163  * @tc.type: FUNC
164  * @tc.require: AR000GHSJK
165  */
166 HWTEST_F(AuthResponseStateTest, GetStateType_001, testing::ext::TestSize.Level0)
167 {
168     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
169     int32_t ret = authResponseState->GetStateType();
170     ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_INIT);
171 }
172 
173 /**
174  * @tc.name: AuthResponseInitState::Enter_001
175  * @tc.desc: 1 call AuthResponseInitState::GetStateType
176  *           2 check ret is AuthResponseInitState::Enter
177  * @tc.type: FUNC
178  * @tc.require: AR000GHSJK
179  */
180 HWTEST_F(AuthResponseStateTest, Enter_001, testing::ext::TestSize.Level0)
181 {
182     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseInitState>();
183     int32_t ret = authResponseState->Enter();
184     ASSERT_EQ(ret, DM_OK);
185 }
186 
187 /**
188  * @tc.name: AuthResponseNegotiateState::GetStateType_002
189  * @tc.desc: 1 call AuthResponseNegotiateState::GetStateType
190  *           2 check ret is AuthState::AUTH_RESPONSE_NEGOTIATE
191  * @tc.type: FUNC
192  * @tc.require: AR000GHSJK
193  */
194 HWTEST_F(AuthResponseStateTest, GetStateType_002, testing::ext::TestSize.Level0)
195 {
196     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
197     int32_t ret = authResponseState->GetStateType();
198     ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_NEGOTIATE);
199 }
200 
201 /**
202  * @tc.name: AuthResponseNegotiateState::Enter_002
203  * @tc.desc: 1 set authManager to null
204  *           2 call AuthResponseNegotiateState::Enter with authManager = null
205  *           3 check ret is ERR_DM_FAILED
206  * @tc.type: FUNC
207  * @tc.require: AR000GHSJK
208  */
209 HWTEST_F(AuthResponseStateTest, Enter_002, testing::ext::TestSize.Level0)
210 {
211     std::shared_ptr<DmAuthManager> authManager =
212         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
213     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
214     authManager = nullptr;
215     authResponseState->SetAuthManager(authManager);
216     int32_t ret = authResponseState->Enter();
217     ASSERT_EQ(ret, ERR_DM_FAILED);
218 }
219 
220 /**
221  * @tc.name: AuthResponseNegotiateState::Enter_003
222  * @tc.desc: 1 set authManager not null
223  *           2 call AuthResponseNegotiateState::Enter with authManager != null
224  *           3 check ret is DM_OK
225  * @tc.type: FUNC
226  * @tc.require: AR000GHSJK
227  */
228 HWTEST_F(AuthResponseStateTest, Enter_003, testing::ext::TestSize.Level0)
229 {
230     std::shared_ptr<DmAuthManager> authManager =
231         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
232     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseNegotiateState>();
233     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
234     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
235     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
236     authManager->authResponseState_ = std::make_shared<AuthResponseNegotiateState>();
237     authManager->authRequestState_ = std::make_shared<AuthRequestNegotiateState>();
238     authManager->authResponseContext_->deviceId = "111";
239     authManager->authResponseContext_->localDeviceId = "222";
240     authManager->authPtr_ = authManager->authenticationMap_[1];
241     authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_);
242     authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_);
243     authManager->softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(authManager);
244     authManager->timer_ = std::make_shared<DmTimer>();
245     authResponseState->SetAuthManager(authManager);
246     std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
247     context->deviceId = "123456";
248     context->sessionId = 22222;
249     authResponseState->SetAuthContext(context);
250     int32_t ret = authResponseState->Enter();
251     ASSERT_EQ(ret, DM_OK);
252 }
253 
254 /**
255  * @tc.name: AuthResponseConfirmState::GetStateType_003
256  * @tc.desc: 1 call AuthResponseConfirmState::GetStateType
257  *           2 check ret is AuthState::AUTH_RESPONSE_CONFIRM
258  * @tc.type: FUNC
259  * @tc.require: AR000GHSJK
260  */
261 HWTEST_F(AuthResponseStateTest, GetStateType_003, testing::ext::TestSize.Level0)
262 {
263     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
264     int32_t ret = authResponseState->GetStateType();
265     ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_CONFIRM);
266 }
267 
268 /**
269  * @tc.name: AuthResponseConfirmState::Enter_004
270  * @tc.desc: 1 set authManager to null
271  *           2 call AuthResponseConfirmState::Enter with authManager = null
272  *           3 check ret is ERR_DM_FAILED
273  * @tc.type: FUNC
274  * @tc.require: AR000GHSJK
275  */
276 HWTEST_F(AuthResponseStateTest, Enter_004, testing::ext::TestSize.Level0)
277 {
278     std::shared_ptr<DmAuthManager> authManager =
279         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
280     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
281     authResponseState->SetAuthManager(nullptr);
282     int32_t ret = authResponseState->Enter();
283     ASSERT_EQ(ret, ERR_DM_FAILED);
284 }
285 
286 /**
287  * @tc.name: AuthResponseConfirmState::Enter_005
288  * @tc.desc: 1 set authManager not null
289  *           2 call AuthResponseConfirmState::Enter with authManager != null
290  *           3 check ret is DM_OK
291  * @tc.type: FUNC
292  * @tc.require: AR000GHSJK
293  */
294 HWTEST_F(AuthResponseStateTest, Enter_005, testing::ext::TestSize.Level0)
295 {
296     std::shared_ptr<DmAuthManager> authManager =
297         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
298     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
299     authManager->authResponseContext_->isShowDialog = true;
300     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseConfirmState>();
301     authResponseState->SetAuthManager(authManager);
302     int32_t ret = authResponseState->Enter();
303     ASSERT_EQ(ret, DM_OK);
304 }
305 
306 /**
307  * @tc.name: AuthResponseGroupState::GetStateType_004
308  * @tc.desc: 1 call AuthResponseGroupState::GetStateType
309  *           2 check ret is AuthState::AUTH_RESPONSE_GROUP
310  * @tc.type: FUNC
311  * @tc.require: AR000GHSJK
312  */
313 HWTEST_F(AuthResponseStateTest, GetStateType_004, testing::ext::TestSize.Level0)
314 {
315     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
316     int32_t ret = authResponseState->GetStateType();
317     ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_GROUP);
318 }
319 
320 /**
321  * @tc.name: AuthResponseGroupState::Enter_006
322  * @tc.desc: 1 set authManager to null
323  *           2 call AuthResponseGroupState::Enter with authManager = null
324  *           3 check ret is ERR_DM_FAILED
325  * @tc.type: FUNC
326  * @tc.require: AR000GHSJK
327  */
328 HWTEST_F(AuthResponseStateTest, Enter_006, testing::ext::TestSize.Level0)
329 {
330     std::shared_ptr<DmAuthManager> authManager =
331         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
332     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
333     authResponseState->SetAuthManager(nullptr);
334     int32_t ret = authResponseState->Enter();
335     ASSERT_EQ(ret, ERR_DM_FAILED);
336 }
337 
338 /**
339  * @tc.name: AuthResponseGroupState::Enter_007
340  * @tc.desc: 1 set authManager not null
341  *           2 call AuthResponseGroupState::Enter with authManager != null
342  *           3 check ret is DM_OK
343  * @tc.type: FUNC
344  * @tc.require: AR000GHSJK
345  */
346 HWTEST_F(AuthResponseStateTest, Enter_007, testing::ext::TestSize.Level0)
347 {
348     std::shared_ptr<DmAuthManager> authManager =
349         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
350     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseGroupState>();
351     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
352     authManager->authResponseState_ = std::make_shared<AuthResponseGroupState>();
353     authResponseState->SetAuthManager(authManager);
354     int32_t ret = authResponseState->Enter();
355     ASSERT_EQ(ret, DM_OK);
356 }
357 
358 /**
359  * @tc.name: AuthResponseShowState::GetStateType_005
360  * @tc.desc: 1 call AuthResponseShowState::GetStateType
361  *           2 check ret is AuthState::AUTH_RESPONSE_SHOW
362  * @tc.type: FUNC
363  * @tc.require: AR000GHSJK
364  */
365 HWTEST_F(AuthResponseStateTest, GetStateType_005, testing::ext::TestSize.Level0)
366 {
367     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
368     int32_t ret = authResponseState->GetStateType();
369     ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_SHOW);
370 }
371 
372 /**
373  * @tc.name: AuthResponseShowState::Enter_008
374  * @tc.desc: 1 set authManager to null
375  *           2 call AuthResponseShowState::Enter with authManager = null
376  *           3 check ret is ERR_DM_FAILED
377  * @tc.type: FUNC
378  * @tc.require: AR000GHSJK
379  */
380 HWTEST_F(AuthResponseStateTest, Enter_008, testing::ext::TestSize.Level0)
381 {
382     std::shared_ptr<DmAuthManager> authManager =
383         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
384     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
385     authResponseState->SetAuthManager(nullptr);
386     int32_t ret = authResponseState->Enter();
387     ASSERT_EQ(ret, ERR_DM_FAILED);
388 }
389 
390 /**
391  * @tc.name: AuthResponseShowState::Enter_009
392  * @tc.desc: 1 set authManager not null
393  *           2 call AuthResponseShowState::Enter with authManager != null
394  *           3 check ret is DM_OK
395  * @tc.type: FUNC
396  * @tc.require: AR000GHSJK
397  */
398 HWTEST_F(AuthResponseStateTest, Enter_009, testing::ext::TestSize.Level0)
399 {
400     std::shared_ptr<DmAuthManager> authManager =
401         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
402     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
403     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseShowState>();
404     authManager->authPtr_ = authManager->authenticationMap_[1];
405     authManager->authResponseContext_->code = 123456;
406     authResponseState->SetAuthManager(authManager);
407     int32_t ret = authResponseState->Enter();
408     ASSERT_EQ(ret, DM_OK);
409 }
410 
411 /**
412  * @tc.name: AuthResponseFinishState::GetStateType_006
413  * @tc.desc: 1 call AuthResponseShowState::GetStateType
414  *           2 check ret is AuthState::AUTH_RESPONSE_SHOW
415  * @tc.type: FUNC
416  * @tc.require: AR000GHSJK
417  */
418 HWTEST_F(AuthResponseStateTest, GetStateType_006, testing::ext::TestSize.Level0)
419 {
420     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
421     int32_t ret = authResponseState->GetStateType();
422     ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_FINISH);
423 }
424 
425 /**
426  * @tc.name: AuthResponseFinishState::Enter_010
427  * @tc.desc: 1 set authManager to null
428  *           2 call AuthResponseFinishState::Enter with authManager = null
429  *           3 check ret is ERR_DM_FAILED
430  * @tc.type: FUNC
431  * @tc.require: AR000GHSJK
432  */
433 HWTEST_F(AuthResponseStateTest, Enter_010, testing::ext::TestSize.Level0)
434 {
435     std::shared_ptr<DmAuthManager> authManager =
436         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
437     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
438     authResponseState->SetAuthManager(nullptr);
439     int32_t ret = authResponseState->Enter();
440     ASSERT_EQ(ret, ERR_DM_FAILED);
441 }
442 
443 /**
444  * @tc.name: AuthResponseFinishState::Enter_011
445  * @tc.desc: 1 set authManager not null
446  *           2 call AuthResponseFinishState::Enter with authManager != null
447  *           3 check ret is DM_OK
448  * @tc.type: FUNC
449  * @tc.require: AR000GHSJK
450  */
451 HWTEST_F(AuthResponseStateTest, Enter_011, testing::ext::TestSize.Level0)
452 {
453     std::shared_ptr<DmAuthManager> authManager =
454         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
455     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseFinishState>();
456     authManager->authRequestState_ = std::make_shared<AuthRequestFinishState>();
457     authManager->authResponseState_ = std::make_shared<AuthResponseFinishState>();
458     authManager->authResponseContext_ = std::make_shared<DmAuthResponseContext>();
459     authManager->authRequestContext_ = std::make_shared<DmAuthRequestContext>();
460     authManager->authMessageProcessor_ = std::make_shared<AuthMessageProcessor>(authManager);
461     authManager->listener_ = std::make_shared<DeviceManagerServiceListener>();
462     authManager->authPtr_ = authManager->authenticationMap_[1];
463     authManager->authResponseContext_->sessionId = 1;
464     authManager->authRequestContext_->deviceId = "2";
465     authManager->authRequestContext_->hostPkgName = "3";
466     authManager->authRequestContext_->token = "4";
467     authManager->authResponseContext_->reply = 5;
468     authManager->authRequestContext_->reason = 6;
469     authManager->SetAuthResponseState(authResponseState);
470     authManager->timer_ = std::make_shared<DmTimer>();
471     authResponseState->SetAuthManager(authManager);
472     std::shared_ptr<DmAuthResponseContext> context = std::make_shared<DmAuthResponseContext>();
473     authResponseState->SetAuthContext(context);
474     int32_t ret = authResponseState->Enter();
475     ASSERT_EQ(ret, DM_OK);
476 }
477 
478 /**
479  * @tc.name: AuthResponseCredential::GetStateType_010
480  * @tc.desc: 1 set authManager to null
481  *           2 call AuthResponseCredential::GetStateType with authManager = null
482  *           3 check ret is AUTH_RESPONSE_CREDENTIAL
483  * @tc.type: FUNC
484  * @tc.require: AR000GHSJK
485  */
486 HWTEST_F(AuthResponseStateTest, GetStateType_010, testing::ext::TestSize.Level0)
487 {
488     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseCredential>();
489     int32_t ret = authResponseState->GetStateType();
490     ASSERT_EQ(ret, AUTH_RESPONSE_CREDENTIAL);
491 }
492 
493 /**
494  * @tc.name: AuthResponseCredential::Enter_012
495  * @tc.desc: 1 set authManager to null
496  *           2 call AuthResponseCredential::Enter with authManager = null
497  *           3 check ret is ERR_DM_FAILED
498  * @tc.type: FUNC
499  * @tc.require: AR000GHSJK
500  */
501 HWTEST_F(AuthResponseStateTest, Enter_012, testing::ext::TestSize.Level0)
502 {
503     std::shared_ptr<DmAuthManager> authManager =
504         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
505     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseCredential>();
506     authResponseState->SetAuthManager(nullptr);
507     int32_t ret = authResponseState->Enter();
508     ASSERT_EQ(ret, ERR_DM_FAILED);
509 }
510 
511 /**
512  * @tc.name: AuthResponseSyncDeleteAcl::GetStateType_011
513  * @tc.desc: 1 set authManager to null
514  *           2 call AuthResponseSyncDeleteAcl::GetStateType with authManager = null
515  *           3 check ret is AUTH_RESPONSE_SYNCDELETE
516  * @tc.type: FUNC
517  * @tc.require: AR000GHSJK
518  */
519 HWTEST_F(AuthResponseStateTest, GetStateType_011, testing::ext::TestSize.Level0)
520 {
521     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseSyncDeleteAcl>();
522     int32_t ret = authResponseState->GetStateType();
523     ASSERT_EQ(ret, AUTH_RESPONSE_SYNCDELETE);
524 }
525 
526 /**
527  * @tc.name: AuthResponseSyncDeleteAcl::Enter_013
528  * @tc.desc: 1 set authManager to null
529  *           2 call AuthResponseSyncDeleteAcl::Enter with authManager = null
530  *           3 check ret is ERR_DM_FAILED
531  * @tc.type: FUNC
532  * @tc.require: AR000GHSJK
533  */
534 HWTEST_F(AuthResponseStateTest, Enter_013, testing::ext::TestSize.Level0)
535 {
536     std::shared_ptr<DmAuthManager> authManager =
537         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
538     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseSyncDeleteAcl>();
539     authResponseState->SetAuthManager(nullptr);
540     int32_t ret = authResponseState->Enter();
541     ASSERT_EQ(ret, ERR_DM_FAILED);
542 }
543 
544 /**
545  * @tc.name: AuthResponseSyncDeleteAclNone::GetStateType_012
546  * @tc.desc: 1 set authManager to null
547  *           2 call AuthResponseSyncDeleteAclNone::GetStateType with authManager = null
548  *           3 check ret is AUTH_RESPONSE_SYNCDELETE_DONE
549  * @tc.type: FUNC
550  * @tc.require: AR000GHSJK
551  */
552 HWTEST_F(AuthResponseStateTest, GetStateType_012, testing::ext::TestSize.Level0)
553 {
554     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseSyncDeleteAclNone>();
555     int32_t ret = authResponseState->GetStateType();
556     ASSERT_EQ(ret, AUTH_RESPONSE_SYNCDELETE_DONE);
557 }
558 
559 /**
560  * @tc.name: AuthResponseSyncDeleteAclNone::Enter_014
561  * @tc.desc: 1 set authManager to null
562  *           2 call AuthResponseSyncDeleteAclNone::Enter with authManager = null
563  *           3 check ret is ERR_DM_FAILED
564  * @tc.type: FUNC
565  * @tc.require: AR000GHSJK
566  */
567 HWTEST_F(AuthResponseStateTest, Enter_014, testing::ext::TestSize.Level0)
568 {
569     std::shared_ptr<DmAuthManager> authManager =
570         std::make_shared<DmAuthManager>(softbusConnector, hiChainConnector, listener, hiChainAuthConnector);
571     std::shared_ptr<AuthResponseState> authResponseState = std::make_shared<AuthResponseSyncDeleteAclNone>();
572     authResponseState->SetAuthManager(nullptr);
573     int32_t ret = authResponseState->Enter();
574     ASSERT_EQ(ret, ERR_DM_FAILED);
575 }
576 } // namespace
577 } // namespace DistributedHardware
578 } // namespace OHOS
579