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.c"
23 #include "auth_session_fsm.h"
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(
112 DEVICE_ID_HASH, DEVICE_ID_HASH_LEN, 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_NE(ProcAuthFsm(REQUEST_ID_1, true, &authFsm), SOFTBUS_OK);
131 EXPECT_NE(ProcAuthFsm(REQUEST_ID, true, &authFsm), SOFTBUS_OK);
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_NE(RecoveryFastAuthKey(&authFsm), SOFTBUS_OK);
169 authFsm.info.connInfo.type = AUTH_LINK_TYPE_WIFI;
170 EXPECT_NE(RecoveryFastAuthKey(&authFsm), SOFTBUS_OK);
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 EXPECT_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 EXPECT_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_NE(ClientSetExchangeIdType(&authFsm), SOFTBUS_OK);
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_NE(TrySyncDeviceInfo(AUTH_SEQ_1, &info), SOFTBUS_OK);
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(¶, 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, ¶);
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, ¶);
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, true) == SOFTBUS_OK);
267 EXPECT_TRUE(AuthSessionHandleDeviceDisconnected(CONN_ID, true) == 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_NE(ret, SOFTBUS_OK);
288
289 EXPECT_CALL(bleMock, SoftBusGetBrState()).WillRepeatedly(Return(BR_DISABLE));
290 ret = HandleCloseAckMessage(&authFsm, &info);
291 EXPECT_NE(ret, SOFTBUS_OK);
292
293 info.connInfo.type = AUTH_LINK_TYPE_BLE;
294 info.nodeInfo.feature = 0;
295 ret = HandleCloseAckMessage(&authFsm, &info);
296 EXPECT_NE(ret, SOFTBUS_OK);
297
298 info.nodeInfo.feature = 0x1F7CA;
299 ret = HandleCloseAckMessage(&authFsm, &info);
300 EXPECT_NE(ret, SOFTBUS_OK);
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_NE(ret, SOFTBUS_OK);
350
351 authFsm->info.normalizedKey = (SessionKey *)SoftBusCalloc(sizeof(SessionKey));
352 if (authFsm->info.normalizedKey == nullptr) {
353 SoftBusFree(authFsm);
354 return;
355 }
356 ret = RecoveryNormalizedDeviceKey(authFsm);
357 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
358
359 EXPECT_TRUE(strcpy_s(authFsm->info.udidHash, SHA_256_HEX_HASH_LEN, UDID_HASH) == EOK);
360 ret = RecoveryNormalizedDeviceKey(authFsm);
361 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
362 SoftBusFree(authFsm->info.normalizedKey);
363 SoftBusFree(authFsm);
364 }
365
366 /*
367 * @tc.name: TRY_RECOVERY_KEY_TEST_001
368 * @tc.desc:
369 * @tc.type: FUNC
370 * @tc.require:
371 */
372 HWTEST_F(AuthSessionFsmTest, TRY_RECOVERY_KEY_TEST_001, TestSize.Level1)
373 {
374 AuthFsm authFsm;
375 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
376 authFsm.info.normalizedType = NORMALIZED_SUPPORT;
377 int32_t ret = TryRecoveryKey(&authFsm);
378 EXPECT_TRUE(ret == SOFTBUS_AUTH_SYNC_DEVID_FAIL);
379
380 authFsm.info.normalizedType = NORMALIZED_NOT_SUPPORT;
381 authFsm.info.isSupportFastAuth = true;
382 ret = TryRecoveryKey(&authFsm);
383 EXPECT_TRUE(ret == SOFTBUS_AUTH_SYNC_DEVID_FAIL);
384
385 authFsm.info.isSupportFastAuth = false;
386 ret = TryRecoveryKey(&authFsm);
387 EXPECT_TRUE(ret == SOFTBUS_OK);
388 }
389
390 /*
391 * @tc.name: PROCESS_CLIENT_AUTH_STATE_TEST_001
392 * @tc.desc:
393 * @tc.type: FUNC
394 * @tc.require:
395 */
396 HWTEST_F(AuthSessionFsmTest, PROCESS_CLIENT_AUTH_STATE_TEST_001, TestSize.Level1)
397 {
398 AuthFsm authFsm;
399 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
400 authFsm.info.idType = EXCHANGE_FAIL;
401 int32_t ret = ProcessClientAuthState(&authFsm);
402 EXPECT_TRUE(ret == SOFTBUS_OK);
403
404 authFsm.info.idType = EXCHANGE_TYPE_MAX;
405 ret = ProcessClientAuthState(&authFsm);
406 EXPECT_TRUE(ret != SOFTBUS_OK);
407
408 DeviceAuthStateEnter(nullptr);
409 FsmStateMachine fsm;
410 (void)memset_s(&fsm, sizeof(FsmStateMachine), 0, sizeof(FsmStateMachine));
411 DeviceAuthStateEnter(&fsm);
412 }
413
414 /*
415 * @tc.name: DEVICE_AUTH_STATE_PROCESS_TEST_001
416 * @tc.desc:
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 HWTEST_F(AuthSessionFsmTest, DEVICE_AUTH_STATE_PROCESS_TEST_001, TestSize.Level1)
421 {
422 AuthFsm authFsm;
423 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
424 authFsm.isDead = false;
425 int32_t msgType = FSM_MSG_RECV_DEVICE_ID;
426 MessagePara *para1 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
427 ASSERT_TRUE(para1 != nullptr);
428 bool ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para1);
429 EXPECT_TRUE(ret == true);
430
431 MessagePara *para2 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
432 ASSERT_TRUE(para2 != nullptr);
433 msgType = FSM_MSG_RECV_AUTH_DATA;
434 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para2);
435 EXPECT_TRUE(ret == false);
436
437 MessagePara *para3 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
438 ASSERT_TRUE(para3 != nullptr);
439 msgType = FSM_MSG_SAVE_SESSION_KEY;
440 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para3);
441 EXPECT_TRUE(ret == false);
442
443 MessagePara *para4 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
444 ASSERT_TRUE(para4 != nullptr);
445 msgType = FSM_MSG_AUTH_ERROR;
446 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para4);
447 EXPECT_TRUE(ret == false);
448 }
449
450 /*
451 * @tc.name: DEVICE_AUTH_STATE_PROCESS_TEST_002
452 * @tc.desc:
453 * @tc.type: FUNC
454 * @tc.require:
455 */
456 HWTEST_F(AuthSessionFsmTest, DEVICE_AUTH_STATE_PROCESS_TEST_002, TestSize.Level1)
457 {
458 AuthFsm authFsm;
459 (void)memset_s(&authFsm, sizeof(AuthFsm), 0, sizeof(AuthFsm));
460 authFsm.isDead = false;
461 int32_t msgType = FSM_MSG_AUTH_FINISH;
462 MessagePara *para1 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
463 ASSERT_TRUE(para1 != nullptr);
464 bool ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para1);
465 EXPECT_TRUE(ret == true);
466
467 MessagePara *para2 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
468 ASSERT_TRUE(para2 != nullptr);
469 msgType = FSM_MSG_UNKNOWN;
470 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para2);
471 EXPECT_TRUE(ret == true);
472
473 MessagePara *para3 = NewMessagePara(TMP_IN_DATA, TMP_DATA_LEN);
474 ASSERT_TRUE(para3 != nullptr);
475 msgType = FSM_MSG_RECV_DEVICE_INFO;
476 ret = DeviceAuthStateProcess(&authFsm.fsm, msgType, para3);
477 EXPECT_TRUE(ret == true);
478 authFsm.info.isNodeInfoReceived = true;
479 HandleMsgRecvCloseAck(&authFsm, para1);
480 }
481 } // namespace OHOS
482