1 /*
2  * Copyright (c) 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 <cinttypes>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <sys/time.h>
20 
21 #include "auth_request.h"
22 #include "auth_session_fsm.h"
23 #include "auth_session_fsm.c"
24 #include "ble_mock.h"
25 #include "softbus_adapter_mem.h"
26 
27 namespace OHOS {
28 using namespace testing;
29 using namespace testing::ext;
30 constexpr int64_t AUTH_SEQ = 1;
31 constexpr int64_t AUTH_SEQ_1 = 2;
32 constexpr uint64_t CONN_ID = 10;
33 constexpr uint64_t CONN_ID_1 = 11;
34 constexpr int32_t DEVICE_ID_HASH_LEN = 9;
35 constexpr uint32_t REQUEST_ID = 1000;
36 constexpr uint32_t REQUEST_ID_1 = 1001;
37 constexpr int32_t TMP_DATA_LEN = 10;
38 constexpr char UDID_HASH[UDID_HASH_LEN] = "9ada389cd0898797";
39 constexpr char UDID_TEST[UDID_BUF_LEN] = "123456789udidtest";
40 constexpr char INVALID_UDID_TEST[UDID_BUF_LEN] = "nullptr";
41 constexpr char BR_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
42 constexpr char BLE_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
43 constexpr uint8_t DEVICE_ID_HASH[UDID_HASH_LEN] = "123456789";
44 constexpr uint8_t TMP_IN_DATA[TMP_DATA_LEN] = "tmpInData";
45 
46 class AuthSessionFsmTest : public testing::Test {
47 public:
48     static void SetUpTestCase();
49     static void TearDownTestCase();
50     void SetUp();
51     void TearDown();
52 };
53 
SetUpTestCase()54 void AuthSessionFsmTest::SetUpTestCase()
55 {
56     GTEST_LOG_(INFO) << "AuthSessionFsmTest start";
57     AuthCommonInit();
58 }
59 
TearDownTestCase()60 void AuthSessionFsmTest::TearDownTestCase()
61 {
62     AuthCommonDeinit();
63     GTEST_LOG_(INFO) << "AuthSessionFsmTest end";
64 }
65 
SetUp()66 void AuthSessionFsmTest::SetUp() {}
67 
TearDown()68 void AuthSessionFsmTest::TearDown() {}
69 
70 /*
71  * @tc.name: TRANSLATE_TO_AUTH_FSM_TEST_001
72  * @tc.desc: TranslateToAuthFsm test
73  * @tc.type: FUNC
74  * @tc.require:
75  */
76 HWTEST_F(AuthSessionFsmTest, TRANSLATE_TO_AUTH_FSM_TEST_001, TestSize.Level1)
77 {
78     EXPECT_TRUE(strcmp(FsmMsgTypeToStr(-1), "UNKNOWN MSG!!") == EOK);
79     EXPECT_TRUE(strcmp(FsmMsgTypeToStr(FSM_MSG_UNKNOWN), "UNKNOWN MSG!!") == EOK);
80     EXPECT_TRUE(strcmp(FsmMsgTypeToStr(FSM_MSG_AUTH_FINISH), "AUTH_FINISH") == EOK);
81     AuthConnInfo connInfo;
82     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
83     connInfo.type = AUTH_LINK_TYPE_BR;
84     ASSERT_TRUE(memcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
85     AuthFsm *authFsm = CreateAuthFsm(AUTH_SEQ, REQUEST_ID, CONN_ID, &connInfo, true);
86     EXPECT_TRUE(authFsm == nullptr);
87     authFsm = TranslateToAuthFsm(nullptr, FSM_MSG_AUTH_TIMEOUT, nullptr);
88     EXPECT_TRUE(authFsm == nullptr);
89     authFsm = TranslateToAuthFsm(&authFsm->fsm, FSM_MSG_AUTH_TIMEOUT, nullptr);
90     EXPECT_TRUE(authFsm == nullptr);
91     authFsm = TranslateToAuthFsm(&authFsm->fsm, FSM_MSG_RECV_DEVICE_ID, nullptr);
92     EXPECT_TRUE(authFsm == nullptr);
93     authFsm = TranslateToAuthFsm(&authFsm->fsm, FSM_MSG_UNKNOWN, nullptr);
94     EXPECT_TRUE(authFsm == nullptr);
95     AuthFsmDeinitCallback(nullptr);
96 }
97 
98 /*
99  * @tc.name: PROC_AUTH_FSM_TEST_001
100  * @tc.desc: ProcAuthFsm test
101  * @tc.type: FUNC
102  * @tc.require:
103  */
104 HWTEST_F(AuthSessionFsmTest, PROC_AUTH_FSM_TEST_001, TestSize.Level1)
105 {
106     ClearAuthRequest();
107     AuthRequest request;
108     (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
109     request.authId = REQUEST_ID;
110     request.type = REQUEST_TYPE_RECONNECT;
111     EXPECT_TRUE(SoftBusGenerateStrHash(DEVICE_ID_HASH, DEVICE_ID_HASH_LEN,
112         request.connInfo.info.bleInfo.deviceIdHash) == SOFTBUS_OK);
113     EXPECT_TRUE(AddAuthRequest(&request) == 0);
114     AuthConnInfo connInfo;
115     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
116     connInfo.type = AUTH_LINK_TYPE_BR;
117     AddUdidInfo(REQUEST_ID, true, &connInfo);
118     AddUdidInfo(REQUEST_ID, false, &connInfo);
119     connInfo.type = AUTH_LINK_TYPE_WIFI;
120     AddUdidInfo(REQUEST_ID, false, &connInfo);
121     connInfo.type = AUTH_LINK_TYPE_BLE;
122     AddUdidInfo(REQUEST_ID, false, &connInfo);
123     connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
124     AddUdidInfo(REQUEST_ID, false, &connInfo);
125     connInfo.type = AUTH_LINK_TYPE_MAX;
126     AddUdidInfo(REQUEST_ID, false, &connInfo);
127     AuthFsm authFsm;
128     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
129     authFsm.info.connInfo.type = AUTH_LINK_TYPE_BLE;
130     EXPECT_TRUE(ProcAuthFsm(REQUEST_ID_1, true, &authFsm) == SOFTBUS_ERR);
131     EXPECT_TRUE(ProcAuthFsm(REQUEST_ID, true, &authFsm) == SOFTBUS_ERR);
132     authFsm.info.connInfo.type = AUTH_LINK_TYPE_WIFI;
133     EXPECT_TRUE(ProcAuthFsm(REQUEST_ID, true, &authFsm) == SOFTBUS_OK);
134     authFsm.authSeq = AUTH_SEQ_1;
135     authFsm.info.isServer = false;
136     authFsm.info.isSupportFastAuth = false;
137     authFsm.info.connInfo.type = AUTH_LINK_TYPE_BLE;
138     CompleteAuthSession(&authFsm, SOFTBUS_OK);
139     authFsm.info.isSupportFastAuth = true;
140     CompleteAuthSession(&authFsm, SOFTBUS_OK);
141     authFsm.info.normalizedType = NORMALIZED_KEY_ERROR;
142     authFsm.info.isConnectServer = true;
143     authFsm.info.peerState = AUTH_STATE_ACK;
144     CompleteAuthSession(&authFsm, SOFTBUS_OK);
145 }
146 
147 /*
148  * @tc.name: RECOVERY_DEVICE_KEY_TEST_001
149  * @tc.desc: RecoveryFastAuthKey test
150  * @tc.type: FUNC
151  * @tc.require:
152  */
153 HWTEST_F(AuthSessionFsmTest, RECOVERY_DEVICE_KEY_TEST_001, TestSize.Level1)
154 {
155     AuthFsm authFsm;
156     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
157     authFsm.info.isNodeInfoReceived = true;
158     authFsm.info.isCloseAckReceived = true;
159     HandleCommonMsg(&authFsm, FSM_MSG_DEVICE_NOT_TRUSTED, nullptr);
160     HandleCommonMsg(&authFsm, FSM_MSG_DEVICE_DISCONNECTED, nullptr);
161     authFsm.info.isCloseAckReceived = false;
162     HandleCommonMsg(&authFsm, FSM_MSG_DEVICE_DISCONNECTED, nullptr);
163     authFsm.info.isNodeInfoReceived = false;
164     HandleCommonMsg(&authFsm, FSM_MSG_DEVICE_DISCONNECTED, nullptr);
165     HandleCommonMsg(&authFsm, SOFTBUS_AUTH_INNER_ERR, nullptr);
166     ASSERT_TRUE(memcpy_s(authFsm.info.udid, UDID_BUF_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
167     authFsm.info.connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
168     EXPECT_TRUE(RecoveryFastAuthKey(&authFsm) == SOFTBUS_ERR);
169     authFsm.info.connInfo.type = AUTH_LINK_TYPE_WIFI;
170     EXPECT_TRUE(RecoveryFastAuthKey(&authFsm) == SOFTBUS_ERR);
171     SyncDevIdStateEnter(nullptr);
172 }
173 
174 /*
175  * @tc.name: CLIENT_SET_EXCHANGE_ID_TYPE_TEST_001
176  * @tc.desc: ClientSetExchangeIdType test
177  * @tc.type: FUNC
178  * @tc.require:
179  */
180 HWTEST_F(AuthSessionFsmTest, CLIENT_SET_EXCHANGE_ID_TYPE_TEST_001, TestSize.Level1)
181 {
182     LnnAuditExtra *auditData = reinterpret_cast<LnnAuditExtra *>(SoftBusMalloc(sizeof(LnnAuditExtra)));
183     EXPECT_TRUE(auditData != nullptr);
184     AuthSessionInfo info;
185     (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
186     (void)memset_s(auditData, sizeof(LnnAuditExtra), 0, sizeof(LnnAuditExtra));
187     AuditReportSetPeerDevInfo(nullptr, &info);
188     AuditReportSetPeerDevInfo(auditData, nullptr);
189     info.connInfo.type = AUTH_LINK_TYPE_BR;
190     ASSERT_TRUE(memcpy_s(info.connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
191     AuditReportSetPeerDevInfo(auditData, &info);
192     info.connInfo.type = AUTH_LINK_TYPE_BLE;
193     ASSERT_TRUE(memcpy_s(info.connInfo.info.bleInfo.bleMac, BT_MAC_LEN, BLE_MAC, strlen(BLE_MAC)) == EOK);
194     AuditReportSetPeerDevInfo(auditData, &info);
195     info.connInfo.type = AUTH_LINK_TYPE_MAX;
196     AuditReportSetPeerDevInfo(auditData, &info);
197     AuditReportSetLocalDevInfo(nullptr);
198     BuildLnnAuditEvent(nullptr, &info, SOFTBUS_OK, SOFTBUS_OK, AUDIT_EVENT_PACKETS_ERROR);
199     BuildLnnAuditEvent(auditData, nullptr, SOFTBUS_OK, SOFTBUS_OK, AUDIT_EVENT_PACKETS_ERROR);
200     SoftBusFree(auditData);
201     AuthFsm authFsm;
202     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
203     authFsm.info.idType = EXCHANGE_FAIL;
204     EXPECT_TRUE(ClientSetExchangeIdType(&authFsm) == SOFTBUS_ERR);
205     info.connInfo.type = AUTH_LINK_TYPE_WIFI;
206     info.isServer = true;
207     EXPECT_TRUE(TrySyncDeviceInfo(AUTH_SEQ_1, &info) == SOFTBUS_OK);
208     info.isServer = false;
209     EXPECT_TRUE(TrySyncDeviceInfo(AUTH_SEQ_1, &info) == SOFTBUS_ENCRYPT_ERR);
210     info.connInfo.type = AUTH_LINK_TYPE_MAX;
211     EXPECT_TRUE(TrySyncDeviceInfo(AUTH_SEQ_1, &info) == SOFTBUS_ERR);
212 }
213 
214 /*
215  * @tc.name: GET_AUTH_FSM_TEST_001
216  * @tc.desc: GetAuthFsmByConnId test
217  * @tc.type: FUNC
218  * @tc.require:
219  */
220 HWTEST_F(AuthSessionFsmTest, GET_AUTH_FSM_TEST_001, TestSize.Level1)
221 {
222     AuthFsm *authFsm = (AuthFsm *)SoftBusCalloc(sizeof(AuthFsm));
223     ASSERT_TRUE(authFsm != nullptr);
224     (void)memset_s(authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
225     ASSERT_TRUE(memcpy_s(authFsm->info.udid, UDID_BUF_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
226     authFsm->authSeq = AUTH_SEQ;
227     authFsm->info.connId = CONN_ID;
228     authFsm->info.isServer = true;
229     authFsm->isDead = true;
230     ListNodeInsert(&g_authFsmList, &authFsm->node);
231     EXPECT_TRUE(GetAuthFsmByAuthSeq(AUTH_SEQ) == nullptr);
232     EXPECT_TRUE(GetAuthFsmByConnId(CONN_ID_1, false, false) == nullptr);
233     EXPECT_TRUE(GetAuthFsmByConnId(CONN_ID, false, false) == nullptr);
234     EXPECT_TRUE(GetAuthFsmByConnId(CONN_ID, true, false) == nullptr);
235 }
236 
237 /*
238  * @tc.name: AUTH_SESSION_HANDLE_TEST_001
239  * @tc.desc: AuthSessionHandle test
240  * @tc.type: FUNC
241  * @tc.require:
242  */
243 HWTEST_F(AuthSessionFsmTest, AUTH_SESSION_HANDLE_TEST_001, TestSize.Level1)
244 {
245     AuthFsm authFsm;
246     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
247     authFsm.info.deviceInfoData = nullptr;
248     MessagePara para;
249     (void)memset_s(&para, sizeof(MessagePara), 0, sizeof(MessagePara));
250     ASSERT_TRUE(memcpy_s(para.data, TMP_DATA_LEN, TMP_IN_DATA, TMP_DATA_LEN) == EOK);
251     para.len = TMP_DATA_LEN;
252     HandleMsgRecvDevInfoEarly(&authFsm, &para);
253     authFsm.info.deviceInfoData = reinterpret_cast<uint8_t *>(SoftBusMalloc(TMP_DATA_LEN));
254     EXPECT_TRUE(authFsm.info.deviceInfoData != nullptr);
255     para.len = 0;
256     HandleMsgRecvDevInfoEarly(&authFsm, &para);
257     TryFinishAuthSession(&authFsm);
258     authFsm.info.isNodeInfoReceived = true;
259     TryFinishAuthSession(&authFsm);
260     authFsm.info.isCloseAckReceived = true;
261     TryFinishAuthSession(&authFsm);
262     authFsm.info.isAuthFinished = true;
263     TryFinishAuthSession(&authFsm);
264     EXPECT_TRUE(AuthSessionHandleDeviceNotTrusted(INVALID_UDID_TEST) == SOFTBUS_OK);
265     EXPECT_TRUE(AuthSessionHandleDeviceNotTrusted(UDID_TEST) == SOFTBUS_OK);
266     EXPECT_TRUE(AuthSessionHandleDeviceDisconnected(CONN_ID_1) == SOFTBUS_OK);
267     EXPECT_TRUE(AuthSessionHandleDeviceDisconnected(CONN_ID) == SOFTBUS_OK);
268     AuthSessionFsmExit();
269 }
270 
271 /*
272  * @tc.name: HANDLE_CLOSE_ACK_TEST_001
273  * @tc.desc: handle close ack base remote info
274  * @tc.type: FUNC
275  * @tc.require:
276  */
277 HWTEST_F(AuthSessionFsmTest, HANDLE_CLOSE_ACK_TEST_001, TestSize.Level1)
278 {
279     AuthSessionInfo info = {0};
280     info.nodeInfo.feature = 0xF7CA;
281     BleMock bleMock;
282     AuthFsm authFsm;
283     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
284 
285     EXPECT_CALL(bleMock, SoftBusGetBrState()).WillRepeatedly(Return(BR_ENABLE));
286     int32_t ret = HandleCloseAckMessage(&authFsm, &info);
287     EXPECT_TRUE(ret == SOFTBUS_ERR);
288 
289     EXPECT_CALL(bleMock, SoftBusGetBrState()).WillRepeatedly(Return(BR_DISABLE));
290     ret = HandleCloseAckMessage(&authFsm, &info);
291     EXPECT_TRUE(ret == SOFTBUS_ERR);
292 
293     info.connInfo.type = AUTH_LINK_TYPE_BLE;
294     info.nodeInfo.feature = 0;
295     ret = HandleCloseAckMessage(&authFsm, &info);
296     EXPECT_TRUE(ret == SOFTBUS_ERR);
297 
298     info.nodeInfo.feature = 0x1F7CA;
299     ret = HandleCloseAckMessage(&authFsm, &info);
300     EXPECT_TRUE(ret == SOFTBUS_ERR);
301 }
302 
303 /*
304  * @tc.name: IS_NEED_EXCHANGE_NETWORKID_TEST_001
305  * @tc.desc:
306  * @tc.type: FUNC
307  * @tc.require:
308  */
309 HWTEST_F(AuthSessionFsmTest, IS_NEED_EXCHANGE_NETWORKID_TEST_001, TestSize.Level1)
310 {
311     uint32_t feature = 0;
312     bool ret = IsNeedExchangeNetworkId(feature, BIT_SUPPORT_EXCHANGE_NETWORKID);
313     EXPECT_TRUE(ret == false);
314 }
315 
316 /*
317  * @tc.name: ADD_CONCURRENT_AUTH_REQUEST_TEST_001
318  * @tc.desc:
319  * @tc.type: FUNC
320  * @tc.require:
321  */
322 HWTEST_F(AuthSessionFsmTest, ADD_CONCURRENT_AUTH_REQUEST_TEST_001, TestSize.Level1)
323 {
324     AuthFsm authFsm;
325     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
326     uint32_t ret = AddConcurrentAuthRequest(&authFsm);
327     EXPECT_TRUE(ret == 0);
328 
329     EXPECT_TRUE(strcpy_s(authFsm.info.udidHash, SHA_256_HEX_HASH_LEN, UDID_HASH) == EOK);
330     ret = AddConcurrentAuthRequest(&authFsm);
331     EXPECT_TRUE(ret != 0);
332     StopAuthFsm(&authFsm);
333     SyncNegotiationEnter(nullptr);
334 }
335 
336 /*
337  * @tc.name: RECOVERY_NORMALIZED_DEVICE_KEY_TEST_001
338  * @tc.desc:
339  * @tc.type: FUNC
340  * @tc.require:
341  */
342 HWTEST_F(AuthSessionFsmTest, RECOVERY_NORMALIZED_DEVICE_KEY_TEST_001, TestSize.Level1)
343 {
344     AuthFsm *authFsm = (AuthFsm *)SoftBusCalloc(sizeof(AuthFsm));
345     ASSERT_TRUE(authFsm != nullptr);
346     (void)memset_s(authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
347     authFsm->info.normalizedKey = nullptr;
348     int32_t ret = RecoveryNormalizedDeviceKey(authFsm);
349     EXPECT_TRUE(ret == SOFTBUS_ERR);
350 
351     authFsm->info.normalizedKey = (SessionKey *)SoftBusCalloc(sizeof(SessionKey));
352     if (authFsm->info.normalizedKey == nullptr) {
353         SoftBusFree(authFsm);
354     }
355     ret = RecoveryNormalizedDeviceKey(authFsm);
356     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
357 
358     EXPECT_TRUE(strcpy_s(authFsm->info.udidHash, SHA_256_HEX_HASH_LEN, UDID_HASH) == EOK);
359     ret = RecoveryNormalizedDeviceKey(authFsm);
360     EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
361     SoftBusFree(authFsm->info.normalizedKey);
362     SoftBusFree(authFsm);
363 }
364 
365 /*
366  * @tc.name: TRY_RECOVERY_KEY_TEST_001
367  * @tc.desc:
368  * @tc.type: FUNC
369  * @tc.require:
370  */
371 HWTEST_F(AuthSessionFsmTest, TRY_RECOVERY_KEY_TEST_001, TestSize.Level1)
372 {
373     AuthFsm authFsm;
374     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
375     authFsm.info.normalizedType = NORMALIZED_SUPPORT;
376     int32_t ret = TryRecoveryKey(&authFsm);
377     EXPECT_TRUE(ret == SOFTBUS_AUTH_SYNC_DEVID_FAIL);
378 
379     authFsm.info.normalizedType = NORMALIZED_NOT_SUPPORT;
380     authFsm.info.isSupportFastAuth = true;
381     ret = TryRecoveryKey(&authFsm);
382     EXPECT_TRUE(ret == SOFTBUS_AUTH_SYNC_DEVID_FAIL);
383 
384     authFsm.info.isSupportFastAuth = false;
385     ret = TryRecoveryKey(&authFsm);
386     EXPECT_TRUE(ret == SOFTBUS_OK);
387 }
388 
389 /*
390  * @tc.name: PROCESS_CLIENT_AUTH_STATE_TEST_001
391  * @tc.desc:
392  * @tc.type: FUNC
393  * @tc.require:
394  */
395 HWTEST_F(AuthSessionFsmTest, PROCESS_CLIENT_AUTH_STATE_TEST_001, TestSize.Level1)
396 {
397     AuthFsm authFsm;
398     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
399     authFsm.info.idType = EXCHANGE_FAIL;
400     int32_t ret = ProcessClientAuthState(&authFsm);
401     EXPECT_TRUE(ret == SOFTBUS_OK);
402 
403     authFsm.info.idType = EXCHANGE_TYPE_MAX;
404     ret = ProcessClientAuthState(&authFsm);
405     EXPECT_TRUE(ret != SOFTBUS_OK);
406 
407     DeviceAuthStateEnter(nullptr);
408     FsmStateMachine fsm;
409     (void)memset_s(&fsm, sizeof(FsmStateMachine), 0, sizeof(FsmStateMachine));
410     DeviceAuthStateEnter(&fsm);
411 }
412 
413 /*
414  * @tc.name: DEVICE_AUTH_STATE_PROCESS_TEST_001
415  * @tc.desc:
416  * @tc.type: FUNC
417  * @tc.require:
418  */
419 HWTEST_F(AuthSessionFsmTest, DEVICE_AUTH_STATE_PROCESS_TEST_001, TestSize.Level1)
420 {
421     AuthFsm authFsm;
422     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
423     authFsm.isDead = false;
424     int32_t msgType = FSM_MSG_RECV_DEVICE_ID;
425     MessagePara *para1 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
426     ASSERT_TRUE(para1 != nullptr);
427     bool ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para1);
428     EXPECT_TRUE(ret == true);
429 
430     MessagePara *para2 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
431     ASSERT_TRUE(para2 != nullptr);
432     msgType = FSM_MSG_RECV_AUTH_DATA;
433     ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para2);
434     EXPECT_TRUE(ret == false);
435 
436     MessagePara *para3 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
437     ASSERT_TRUE(para3 != nullptr);
438     msgType = FSM_MSG_SAVE_SESSION_KEY;
439     ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para3);
440     EXPECT_TRUE(ret == false);
441 
442     MessagePara *para4 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
443     ASSERT_TRUE(para4 != nullptr);
444     msgType = FSM_MSG_AUTH_ERROR;
445     ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para4);
446     EXPECT_TRUE(ret == false);
447 }
448 
449 /*
450  * @tc.name: DEVICE_AUTH_STATE_PROCESS_TEST_002
451  * @tc.desc:
452  * @tc.type: FUNC
453  * @tc.require:
454  */
455 HWTEST_F(AuthSessionFsmTest, DEVICE_AUTH_STATE_PROCESS_TEST_002, TestSize.Level1)
456 {
457     AuthFsm authFsm;
458     (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
459     authFsm.isDead = false;
460     int32_t msgType = FSM_MSG_AUTH_FINISH;
461     MessagePara *para1 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
462     ASSERT_TRUE(para1 != nullptr);
463     bool ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para1);
464     EXPECT_TRUE(ret == true);
465 
466     MessagePara *para2 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
467     ASSERT_TRUE(para2 != nullptr);
468     msgType = FSM_MSG_UNKNOWN;
469     ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para2);
470     EXPECT_TRUE(ret == true);
471 
472     MessagePara *para3 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
473     ASSERT_TRUE(para3 != nullptr);
474     msgType = FSM_MSG_RECV_DEVICE_INFO;
475     ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para3);
476     EXPECT_TRUE(ret == true);
477     authFsm.info.isNodeInfoReceived = true;
478     HandleMsgRecvCloseAck(&authFsm, para1);
479 }
480 } // namespace OHOS