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
25namespace OHOS {
26namespace DistributedHardware {
27void AuthResponseStateTest::SetUp()
28{
29}
30void AuthResponseStateTest::TearDown()
31{
32}
33void AuthResponseStateTest::SetUpTestCase()
34{
35}
36void AuthResponseStateTest::TearDownTestCase()
37{
38}
39
40namespace {
41std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
42std::shared_ptr<DeviceManagerServiceListener> listener = std::make_shared<DeviceManagerServiceListener>();
43std::shared_ptr<HiChainConnector> hiChainConnector = std::make_shared<HiChainConnector>();
44std::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 */
53HWTEST_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 */
70HWTEST_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 */
90HWTEST_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 */
108HWTEST_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 */
124HWTEST_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 */
143HWTEST_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 */
166HWTEST_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 */
180HWTEST_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 */
194HWTEST_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 */
209HWTEST_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 */
228HWTEST_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 */
261HWTEST_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 */
276HWTEST_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 */
294HWTEST_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 */
313HWTEST_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 */
328HWTEST_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 */
346HWTEST_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 */
365HWTEST_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 */
380HWTEST_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 */
398HWTEST_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 */
418HWTEST_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 */
433HWTEST_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 */
451HWTEST_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 */
486HWTEST_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 */
501HWTEST_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} // namespace
511} // namespace DistributedHardware
512} // namespace OHOS
513