1 /*
2 * Copyright (c) 2023 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 <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "distribute_net_ledger_mock.h"
20 #include "lnn_auth_mock.h"
21 #include "lnn_connection_fsm.h"
22 #include "lnn_connection_fsm.c"
23 #include "lnn_connection_fsm_mock.h"
24 #include "lnn_devicename_info.h"
25 #include "lnn_map.h"
26 #include "lnn_net_builder.h"
27 #include "lnn_net_ledger_mock.h"
28 #include "lnn_service_mock.h"
29 #include "message_handler.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_common.h"
32 #include "softbus_errcode.h"
33
34 #define FUNC_SLEEP_MS 10
35 constexpr char IP[IP_STR_MAX_LEN] = "127.0.0.1";
36 constexpr uint16_t PORT = 1000;
37 constexpr char MACTEST[BT_MAC_LEN] = "00:11:22:33:44";
38 constexpr char PEERUID[MAX_ACCOUNT_HASH_LEN] = "021315ASD";
39 constexpr char PEERUID1[MAX_ACCOUNT_HASH_LEN] = "021315ASE";
40 constexpr char PEERUID2[MAX_ACCOUNT_HASH_LEN] = "021315ASC";
41 constexpr char NETWORKID1[NETWORK_ID_BUF_LEN] = "123456ABD";
42 constexpr char NETWORKID2[NETWORK_ID_BUF_LEN] = "123456ABC";
43 constexpr char NETWORKID3[LNN_CONNECTION_FSM_NAME_LEN] = "123456ABD";
44 constexpr char PEERUDID[UDID_BUF_LEN] = "021315ASD";
45 constexpr char SOFTBUSVERSION[VERSION_MAX_LEN] = "softBusVersion";
46
47 namespace OHOS {
48 using namespace testing;
49 using namespace testing::ext;
50
51 static LnnConnectionFsm *connFsm = nullptr;
52 static ConnectionAddr target = {
53 .type = CONNECTION_ADDR_WLAN,
54 .info.ip.port = PORT,
55 };
56 static LnnConnectionFsm *connFsm2 = nullptr;
57 static ConnectionAddr target3 = {
58 .type = CONNECTION_ADDR_WLAN,
59 .info.ip.port = PORT,
60 };
61 static LnnConnectionFsm *connFsm3 = nullptr;
62 static ConnectionAddr target4 = {
63 .type = CONNECTION_ADDR_WLAN,
64 .info.ip.port = PORT,
65 };
66 static LnnConnectionFsm *connFsm4 = nullptr;
67 class LNNConnectionFsmTest : public testing::Test {
68 public:
69 static void SetUpTestCase();
70 static void TearDownTestCase();
71 void SetUp();
72 void TearDown();
73 };
74
SetUpTestCase()75 void LNNConnectionFsmTest::SetUpTestCase()
76 {
77 LooperInit();
78 const char *ip = IP;
79 NiceMock<LnnConnFsmInterfaceMock> lnnConnMock;
80 EXPECT_CALL(lnnConnMock, LnnPrintConnectionAddr).WillRepeatedly(Return(ip));
81 memcpy_s(target.peerUid, MAX_ACCOUNT_HASH_LEN, PEERUID, strlen(PEERUID));
82 memcpy_s(target.info.ip.ip, IP_STR_MAX_LEN, IP, strlen(IP));
83 connFsm2 = LnnCreateConnectionFsm(&target, "pkgName", true);
84 EXPECT_TRUE(connFsm2 != nullptr);
85
86 (void)memcpy_s(target3.peerUid, MAX_ACCOUNT_HASH_LEN, PEERUID1, strlen(PEERUID1));
87 (void)memcpy_s(target3.info.ip.ip, IP_STR_MAX_LEN, IP, strlen(IP));
88 connFsm3 = LnnCreateConnectionFsm(&target3, "pkgName1", true);
89 EXPECT_TRUE(connFsm3 != nullptr);
90
91 (void)memcpy_s(target4.peerUid, MAX_ACCOUNT_HASH_LEN, PEERUID2, strlen(PEERUID2));
92 (void)memcpy_s(target4.info.ip.ip, IP_STR_MAX_LEN, IP, strlen(IP));
93 connFsm4 = LnnCreateConnectionFsm(&target4, "pkgName2", true);
94 EXPECT_TRUE(connFsm4 != nullptr);
95 }
96
TearDownTestCase()97 void LNNConnectionFsmTest::TearDownTestCase()
98 {
99 LooperDeinit();
100 LnnDestroyConnectionFsm(connFsm2);
101 LnnDestroyConnectionFsm(connFsm3);
102 LnnDestroyConnectionFsm(connFsm4);
103 }
104
SetUp()105 void LNNConnectionFsmTest::SetUp()
106 {
107 }
108
TearDown()109 void LNNConnectionFsmTest::TearDown()
110 {
111 }
112
FsmStopCallback(struct tagLnnConnectionFsm * connFsm)113 void FsmStopCallback(struct tagLnnConnectionFsm *connFsm)
114 {
115 }
116
117 /*
118 * @tc.name: LNN_CREATE_CONNECTION_FSM_TEST_001
119 * @tc.desc: para is null
120 * @tc.type: FUNC
121 * @tc.require:I5PRUD
122 */
123 HWTEST_F(LNNConnectionFsmTest, LNN_CREATE_CONNECTION_FSM_TEST_001, TestSize.Level1)
124 {
125 ConnectionAddr *target1 = nullptr;
126 LnnConnectionFsm *fsm = LnnCreateConnectionFsm(target1, "pkgName", true);
127 EXPECT_TRUE(fsm == nullptr);
128 LnnDestroyConnectionFsm(fsm);
129 DfxRecordConnAuthStart(nullptr, fsm, 0);
130 }
131
132 /*
133 * @tc.name: LNN_START_CONNECTION_FSM_TEST_001
134 * @tc.desc: test LnnStartConnectionFsm
135 * @tc.type: FUNC
136 * @tc.require: I5PRUD
137 */
138 HWTEST_F(LNNConnectionFsmTest, LNN_START_CONNECTION_FSM_TEST_001, TestSize.Level1)
139 {
140 int32_t ret = LnnStartConnectionFsm(connFsm);
141 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
142
143 ret = LnnStartConnectionFsm(connFsm2);
144 EXPECT_TRUE(ret == SOFTBUS_OK);
145 SoftBusSleepMs(200);
146 }
147
148 /*
149 * @tc.name: LNN_SEND_JOIN_REQUEST_TO_CONNFSM_TEST_001
150 * @tc.desc: test LnnSendJoinRequestToConnFsm
151 * @tc.type: FUNC
152 * @tc.require: I5PRUD
153 */
154 HWTEST_F(LNNConnectionFsmTest, LNN_SEND_JOIN_REQUEST_TO_CONNFSM_TEST_001, TestSize.Level1)
155 {
156 int32_t ret = LnnStartConnectionFsm(connFsm2);
157 EXPECT_TRUE(ret == SOFTBUS_OK);
158 NiceMock<LnnAuthtInterfaceMock> authMock;
159 NiceMock<LnnServicetInterfaceMock> serviceMock;
160 const char *ip = IP;
161 NiceMock<LnnConnFsmInterfaceMock> lnnConnMock;
162 EXPECT_CALL(lnnConnMock, LnnPrintConnectionAddr).WillRepeatedly(Return(ip));
163 ON_CALL(serviceMock, AuthGenRequestId).WillByDefault(Return(1));
164 EXPECT_CALL(authMock, AuthStartVerify).WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_ERR));
165 ON_CALL(serviceMock, LnnNotifyJoinResult).WillByDefault(Return());
166 ret = LnnSendJoinRequestToConnFsm(connFsm2);
167 EXPECT_TRUE(ret == SOFTBUS_OK);
168 SoftBusSleepMs(1000);
169 }
170
171 /*
172 * @tc.name: LNN_SEND_AUTH_RESULT_MSG_TO_CONNFSM_TEST_001
173 * @tc.desc: test LnnSendAuthResultMsgToConnFsm
174 * @tc.type: FUNC
175 * @tc.require:
176 */
177 HWTEST_F(LNNConnectionFsmTest, LNN_SEND_AUTH_RESULT_MSG_TO_CONNFSM_TEST_001, TestSize.Level1)
178 {
179 int32_t retCode = 0;
180 int32_t ret = LnnSendAuthResultMsgToConnFsm(connFsm, retCode);
181 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
182 connFsm3->isDead = true;
183 ret = LnnSendAuthResultMsgToConnFsm(connFsm3, retCode);
184 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
185 connFsm3->isDead = false;
186 ret = LnnSendAuthResultMsgToConnFsm(connFsm3, retCode);
187 EXPECT_TRUE(ret == SOFTBUS_OK);
188 FsmStateMachine fsm;
189 connFsm3->fsm = fsm;
190 ret = LnnSendAuthResultMsgToConnFsm(connFsm3, retCode);
191 EXPECT_TRUE(ret == SOFTBUS_ERR);
192 }
193
194 /*
195 * @tc.name: LNN_SEND_NOT_TRUSTED_TO_CONNFSM_TEST_001
196 * @tc.desc: test LnnSendNotTrustedToConnFsm
197 * @tc.type: FUNC
198 * @tc.require:
199 */
200 HWTEST_F(LNNConnectionFsmTest, LNN_SEND_NOT_TRUSTED_TO_CONNFSM_TEST_001, TestSize.Level1)
201 {
202 int32_t ret = LnnSendNotTrustedToConnFsm(connFsm);
203 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
204 ret = LnnSendNotTrustedToConnFsm(connFsm2);
205 EXPECT_TRUE(ret == SOFTBUS_OK);
206 SoftBusSleepMs(FUNC_SLEEP_MS);
207 }
208
209 /*
210 * @tc.name: LNN_SEND_DISCONNECT_MSG_TO_CONNFSM_TEST_001
211 * @tc.desc: test LnnSendDisconnectMsgToConnFsm
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(LNNConnectionFsmTest, LNN_SEND_DISCONNECT_MSG_TO_CONNFSM_TEST_001, TestSize.Level1)
216 {
217 int32_t ret = LnnSendDisconnectMsgToConnFsm(connFsm);
218 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
219 SoftBusSleepMs(FUNC_SLEEP_MS);
220 }
221
222 /*
223 * @tc.name: LNN_SEND_LEAVE_REQUEST_TO_CONNFSM_TEST_001
224 * @tc.desc: test LnnSendLeaveRequestToConnFsm
225 * @tc.type: FUNC
226 * @tc.require:
227 */
228 HWTEST_F(LNNConnectionFsmTest, LNN_SEND_LEAVE_REQUEST_TO_CONNFSM_TEST_001, TestSize.Level1)
229 {
230 int32_t ret = LnnStartConnectionFsm(connFsm2);
231 ret = LnnSendLeaveRequestToConnFsm(connFsm);
232 EXPECT_TRUE(ret == SOFTBUS_ERR);
233 ret = LnnSendLeaveRequestToConnFsm(connFsm2);
234 EXPECT_TRUE(ret == SOFTBUS_OK);
235 SoftBusSleepMs(FUNC_SLEEP_MS);
236 }
237
238 /*
239 * @tc.name: LNN_SEND_SYNC_OFFLINE_FINISH_TO_CONNFSM_TEST_001
240 * @tc.desc: test LnnSendSyncOfflineFinishToConnFsm
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(LNNConnectionFsmTest, LNN_SEND_SYNC_OFFLINE_FINISH_TO_CONNFSM_TEST_001, TestSize.Level1)
245 {
246 int32_t ret = LnnStartConnectionFsm(connFsm2);
247 EXPECT_TRUE(ret == SOFTBUS_OK);
248 ret = LnnSendSyncOfflineFinishToConnFsm(connFsm);
249 EXPECT_TRUE(ret == SOFTBUS_ERR);
250 ret = LnnSendSyncOfflineFinishToConnFsm(connFsm2);
251 EXPECT_TRUE(ret == SOFTBUS_OK);
252 SoftBusSleepMs(FUNC_SLEEP_MS);
253 }
254
255 /*
256 * @tc.name: LNN_SEND_NEW_NETWORK_ONLINE_TO_CONNFSM_TEST_001
257 * @tc.desc: test LnnSendNewNetworkOnlineToConnFsm
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(LNNConnectionFsmTest, LNN_SEND_NEW_NETWORK_ONLINE_TO_CONNFSM_TEST_001, TestSize.Level1)
262 {
263 int32_t ret = LnnSendNewNetworkOnlineToConnFsm(connFsm);
264 EXPECT_TRUE(ret == SOFTBUS_ERR);
265 ret = LnnSendNewNetworkOnlineToConnFsm(connFsm2);
266 EXPECT_TRUE(ret == SOFTBUS_OK);
267 SoftBusSleepMs(FUNC_SLEEP_MS);
268 }
269
270 /*
271 * @tc.name: LNN_CHECK_STATE_MSG_COMMON_ARGS_TEST_001
272 * @tc.desc: test CheckStateMsgCommonArgs
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(LNNConnectionFsmTest, LNN_CHECK_STATE_MSG_COMMON_ARGS_TEST_001, TestSize.Level1)
277 {
278 bool ret = CheckStateMsgCommonArgs(nullptr);
279 EXPECT_TRUE(ret == false);
280 FsmStateMachine fsm;
281 ret = CheckStateMsgCommonArgs(&fsm);
282 EXPECT_TRUE(ret == true);
283 SoftBusSleepMs(FUNC_SLEEP_MS);
284 }
285
286 /*
287 * @tc.name: LNN_REPORT_LNN_RESULT_EVT_TEST_001
288 * @tc.desc: test OnlineTrustGroupProc
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(LNNConnectionFsmTest, LNN_REPORT_LNN_RESULT_EVT_TEST_001, TestSize.Level1)
293 {
294 int32_t ret = LnnStartConnectionFsm(connFsm4);
295 EXPECT_TRUE(ret == SOFTBUS_OK);
296 connFsm4->connInfo.addr.type = CONNECTION_ADDR_MAX;
297 ReportLnnResultEvt(connFsm4, SOFTBUS_HISYSEVT_LINK_TYPE_BR);
298 connFsm4->connInfo.addr.type = CONNECTION_ADDR_SESSION;
299 ReportLnnResultEvt(connFsm4, SOFTBUS_HISYSEVT_LINK_TYPE_BR);
300 ReportLnnResultEvt(connFsm4, SOFTBUS_HISYSEVT_LINK_TYPE_BLE);
301 }
302
303 /*
304 * @tc.name: LNN_POST_PC_ONLINE_UNIQUELY_TEST_001
305 * @tc.desc: test PostPcOnlineUniquely
306 * @tc.type: FUNC
307 * @tc.require:
308 */
309 HWTEST_F(LNNConnectionFsmTest, LNN_POST_PC_ONLINE_UNIQUELY_TEST_001, TestSize.Level1)
310 {
311 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
312 NiceMock<LnnConnFsmInterfaceMock> lnnConnMock;
313 EXPECT_CALL(lnnConnMock, LnnGenerateBtMacHash)
314 .WillOnce(Return(SOFTBUS_ERR))
315 .WillRepeatedly(Return(SOFTBUS_OK));
316 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_ERR));
317 PostPcOnlineUniquely(nullptr);
318 NodeInfo *info = nullptr;
319 info = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
320 EXPECT_TRUE(info != nullptr);
321 info->deviceInfo.deviceTypeId = TYPE_PC_ID;
322 (void)memcpy_s(info->networkId, NETWORK_ID_BUF_LEN, NETWORKID1, NETWORK_ID_BUF_LEN);
323 (void)memcpy_s(info->deviceInfo.deviceUdid, NETWORK_ID_BUF_LEN, NETWORKID1, NETWORK_ID_BUF_LEN);
324 PostPcOnlineUniquely(info);
325 (void)memcpy_s(info->deviceInfo.deviceUdid, NETWORK_ID_BUF_LEN, NETWORKID2, NETWORK_ID_BUF_LEN);
326 PostPcOnlineUniquely(info);
327 PostPcOnlineUniquely(info);
328 info->deviceInfo.deviceTypeId = TYPE_IPCAMERA_ID;
329 PostPcOnlineUniquely(info);
330 SoftBusFree(info);
331 }
332
333 /*
334 * @tc.name: LNN_IS_NODE_INFO_CHANGED_TEST_001
335 * @tc.desc: test IsNodeInfoChanged
336 * @tc.type: FUNC
337 * @tc.require:
338 */
339 HWTEST_F(LNNConnectionFsmTest, LNN_IS_NODE_INFO_CHANGED_TEST_001, TestSize.Level1)
340 {
341 NiceMock<LnnConnFsmInterfaceMock> lnnConnMock;
342 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
343 EXPECT_CALL(lnnConnMock, LnnUpdateNetworkId).WillRepeatedly(Return(SOFTBUS_OK));
344 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
345
346 int32_t ret = LnnStartConnectionFsm(connFsm4);
347 EXPECT_TRUE(ret == SOFTBUS_OK);
348 NodeInfo oldNodeInfo;
349 NodeInfo newNodeInfo;
350 (void)strcpy_s(oldNodeInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID1);
351 (void)strcpy_s(newNodeInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID2);
352 ConnectionAddrType type;
353 bool ret1 = IsNodeInfoChanged(connFsm4, &oldNodeInfo, &newNodeInfo, &type);
354 EXPECT_TRUE(ret1 == true);
355 (void)strcpy_s(newNodeInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID1);
356 connFsm4->connInfo.addr.type = CONNECTION_ADDR_BLE;
357 ret1 = IsNodeInfoChanged(connFsm4, &oldNodeInfo, &newNodeInfo, &type);
358 EXPECT_TRUE(ret1 == false);
359 }
360
361 /*
362 * @tc.name: LNN_CLEAN_INVALID_CONN_STATE_PROCESS_TEST_001
363 * @tc.desc: test CleanInvalidConnStateProcess
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(LNNConnectionFsmTest, LNN_CLEAN_INVALID_CONN_STATE_PROCESS_TEST_001, TestSize.Level1)
368 {
369 int32_t ret = LnnStartConnectionFsm(connFsm4);
370 EXPECT_TRUE(ret == SOFTBUS_OK);
371 void *para = nullptr;
372 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
373 EXPECT_TRUE(para != nullptr);
374 bool ret1 = CleanInvalidConnStateProcess(nullptr, FSM_MSG_TYPE_LEAVE_LNN, para);
375 EXPECT_TRUE(ret1 == false);
376 ret1 = CleanInvalidConnStateProcess(&(connFsm4->fsm), FSM_MSG_TYPE_LEAVE_LNN, nullptr);
377 EXPECT_TRUE(ret1 == true);
378 }
379
380 /*
381 * @tc.name: LNN_CLEAN_INVALID_CONN_STATE_PROCESS_TEST_002
382 * @tc.desc: test CleanInvalidConnStateProcess
383 * @tc.type: FUNC
384 * @tc.require:
385 */
386 HWTEST_F(LNNConnectionFsmTest, LNN_CLEAN_INVALID_CONN_STATE_PROCESS_TEST_002, TestSize.Level1)
387 {
388 int32_t ret = LnnStartConnectionFsm(connFsm4);
389 EXPECT_TRUE(ret == SOFTBUS_OK);
390 void *para = nullptr;
391 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
392 EXPECT_TRUE(para != nullptr);
393 bool ret1 = CleanInvalidConnStateProcess(nullptr, FSM_MSG_TYPE_LEAVE_LNN, para);
394 EXPECT_TRUE(ret1 == false);
395 ret1 = CleanInvalidConnStateProcess(&(connFsm4->fsm), FSM_MSG_TYPE_LEAVE_INVALID_CONN, nullptr);
396 EXPECT_TRUE(ret1 == true);
397 }
398
399 /*
400 * @tc.name: LNN_ONLINE_STAGE_ENTER_TEST_001
401 * @tc.desc: test OnlineStateEnter
402 * @tc.type: FUNC
403 * @tc.require:
404 */
405 HWTEST_F(LNNConnectionFsmTest, LNN_ONLINE_STAGE_ENTER_TEST_001, TestSize.Level1)
406 {
407 OnlineStateEnter(nullptr);
408 }
409
410 /*
411 * @tc.name: LNN_LEAVE_LNN_IN_ONLINE_TEST_001
412 * @tc.desc: test LeaveLNNInOnline
413 * @tc.type: FUNC
414 * @tc.require:
415 */
416 HWTEST_F(LNNConnectionFsmTest, LNN_LEAVE_LNN_IN_ONLINE_TEST_001, TestSize.Level1)
417 {
418 LnnConnectionFsm connFsm;
419 LeaveLNNInOnline(&connFsm);
420 }
421
422 /*
423 * @tc.name: LNN_ONLINE_STATE_PROCESS_TEST_001
424 * @tc.desc: test OnlineStateProcess
425 * @tc.type: FUNC
426 * @tc.require:
427 */
428 HWTEST_F(LNNConnectionFsmTest, LNN_ONLINE_STATE_PROCESS_TEST_001, TestSize.Level1)
429 {
430 int32_t ret = LnnStartConnectionFsm(connFsm4);
431 EXPECT_TRUE(ret == SOFTBUS_OK);
432 void *para = nullptr;
433 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
434 EXPECT_TRUE(para != nullptr);
435 ret = OnlineStateProcess(nullptr, FSM_MSG_TYPE_JOIN_LNN, para);
436 EXPECT_TRUE(ret == false);
437 }
438
439 /*
440 * @tc.name: LNN_ONLINE_STATE_PROCESS_TEST_002
441 * @tc.desc: test OnlineStateProcess
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(LNNConnectionFsmTest, LNN_ONLINE_STATE_PROCESS_TEST_002, TestSize.Level1)
446 {
447 int32_t ret = LnnStartConnectionFsm(connFsm4);
448 EXPECT_TRUE(ret == SOFTBUS_OK);
449 void *para = nullptr;
450 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
451 EXPECT_TRUE(para != nullptr);
452 ret = OnlineStateProcess(&(connFsm4->fsm), FSM_MSG_TYPE_AUTH_DONE, para);
453 EXPECT_TRUE(ret == false);
454 }
455
456 /*
457 * @tc.name: LNN_LEAVING_STATE_ENTER_TEST_001
458 * @tc.desc: test LeavingStateEnter
459 * @tc.type: FUNC
460 * @tc.require:
461 */
462 HWTEST_F(LNNConnectionFsmTest, LNN_LEAVING_STATE_ENTER_TEST_001, TestSize.Level1)
463 {
464 LeavingStateEnter(nullptr);
465 }
466
467 /*
468 * @tc.name: LNN_LEAVING_STATE_PROCESS_TEST_001
469 * @tc.desc: test LeavingStateProcess
470 * @tc.type: FUNC
471 * @tc.require:
472 */
473 HWTEST_F(LNNConnectionFsmTest, LNN_LEAVING_STATE_PROCESS_TEST_001, TestSize.Level1)
474 {
475 void *para = nullptr;
476 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
477 EXPECT_TRUE(para != nullptr);
478 int32_t ret = LeavingStateProcess(nullptr, FSM_MSG_TYPE_JOIN_LNN, para);
479 EXPECT_TRUE(ret == false);
480 }
481
482 /*
483 * @tc.name: LNN_CONNECTION_FSM_DININIT_CALLBACK_TEST_001
484 * @tc.desc: test ConnectionFsmDinitCallback
485 * @tc.type: FUNC
486 * @tc.require:
487 */
488 HWTEST_F(LNNConnectionFsmTest, LNN_CONNECTION_FSM_DININIT_CALLBACK_TEST_001, TestSize.Level1)
489 {
490 ConnectionFsmDinitCallback(nullptr);
491 }
492
493 /*
494 * @tc.name: LNN_INIT_CONNECTION_STATE_MACHINE_TEST_001
495 * @tc.desc: test InitConnectionStateMachine
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(LNNConnectionFsmTest, LNN_INIT_CONNECTION_STATE_MACHINE_TEST_001, TestSize.Level1)
500 {
501 int32_t ret = LnnStartConnectionFsm(connFsm4);
502 EXPECT_TRUE(ret == SOFTBUS_OK);
503 (void)strcpy_s(connFsm4->fsmName, LNN_CONNECTION_FSM_NAME_LEN, NETWORKID3);
504 ret = InitConnectionStateMachine(connFsm4);
505 EXPECT_TRUE(ret == SOFTBUS_OK);
506 }
507
508 /*
509 * @tc.name: DFX_RECORD_LNN_ONLINE_TYPE_TEST_001
510 * @tc.desc: test DfxRecordLnnOnlineType
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(LNNConnectionFsmTest, DFX_RECORD_LNN_ONLINE_TYPE_TEST_001, TestSize.Level1)
515 {
516 NodeInfo info = { .netCapacity = 15, };
517 uint32_t local1 = 1;
518 uint32_t local2 = 15;
519 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
520 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
521 int32_t ret = DfxRecordLnnOnlineType(&info);
522 EXPECT_EQ(ret, ONLINE_TYPE_WIFI);
523 ret = DfxRecordLnnOnlineType(nullptr);
524 EXPECT_EQ(ret, ONLINE_TYPE_INVALID);
525 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType)
526 .WillOnce(Return(false))
527 .WillRepeatedly(Return(true));
528 ret = DfxRecordLnnOnlineType(&info);
529 EXPECT_EQ(ret, ONLINE_TYPE_BR);
530 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
531 ret = DfxRecordLnnOnlineType(&info);
532 EXPECT_EQ(ret, ONLINE_TYPE_INVALID);
533 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType)
534 .WillOnce(Return(false))
535 .WillOnce(Return(false))
536 .WillRepeatedly(Return(true));
537 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info)
538 .WillRepeatedly(Return(SOFTBUS_ERR));
539 ret = DfxRecordLnnOnlineType(&info);
540 EXPECT_EQ(ret, ONLINE_TYPE_INVALID);
541 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType)
542 .WillOnce(Return(false))
543 .WillOnce(Return(false))
544 .WillRepeatedly(Return(true));
545 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info)
546 .WillOnce(DoAll(SetArgPointee<1>(local1), Return(SOFTBUS_OK)));
547 ret = DfxRecordLnnOnlineType(&info);
548 EXPECT_EQ(ret, ONLINE_TYPE_BLE_THREE_STATE);
549 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType)
550 .WillOnce(Return(false))
551 .WillOnce(Return(false))
552 .WillRepeatedly(Return(true));
553 EXPECT_CALL(ledgerMock, LnnGetLocalNumU32Info)
554 .WillRepeatedly(DoAll(SetArgPointee<1>(local2), Return(SOFTBUS_OK)));
555 ret = DfxRecordLnnOnlineType(&info);
556 EXPECT_EQ(ret, ONLINE_TYPE_BLE);
557 }
558
559 /*
560 * @tc.name: IS_EMPTY_SHORT_HASH_STR_TEST_001
561 * @tc.desc: test IsEmptyShortHashStr
562 * @tc.type: FUNC
563 * @tc.require:
564 */
565 HWTEST_F(LNNConnectionFsmTest, IS_EMPTY_SHORT_HASH_STR_TEST_001, TestSize.Level1)
566 {
567 const char *udid = "testuuid";
568 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
569 EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid)
570 .WillOnce(Return(SOFTBUS_ERR))
571 .WillRepeatedly(Return(SOFTBUS_OK));
572 ReportResult(udid, REPORT_CHANGE);
573 ReportResult(udid, REPORT_OFFLINE);
574 ReportResult(udid, REPORT_NONE);
575 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
576 .WillOnce(Return(SOFTBUS_ERR))
577 .WillRepeatedly(Return(SOFTBUS_OK));
578 OnlineTrustGroupProc(udid);
579 const char *udidHash = "testuuid";
580 bool ret = IsEmptyShortHashStr(const_cast<char *>(udidHash));
581 EXPECT_EQ(ret, false);
582 const char *udidHash1 = "";
583 ret = IsEmptyShortHashStr(const_cast<char *>(udidHash1));
584 EXPECT_EQ(ret, true);
585 }
586
587 /*
588 * @tc.name: GET_UDID_HASH_FOR_DFX_TEST_001
589 * @tc.desc: test GetUdidHashForDfx
590 * @tc.type: FUNC
591 * @tc.require:
592 */
593 HWTEST_F(LNNConnectionFsmTest, GET_UDID_HASH_FOR_DFX_TEST_001, TestSize.Level1)
594 {
595 NodeInfo localInfo;
596 (void)memset_s(&localInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
597 EXPECT_EQ(EOK, memcpy_s(localInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, PEERUDID, strlen(PEERUDID)));
598 LnnConntionInfo connInfo = { .addr.type = CONNECTION_ADDR_WLAN, };
599 EXPECT_EQ(EOK, memcpy_s(connInfo.addr.info.ip.udidHash, UDID_BUF_LEN, PEERUDID, strlen(PEERUDID)));
600 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
601 EXPECT_CALL(ledgerMock, LnnGetLocalNodeInfo)
602 .WillOnce(Return(nullptr))
603 .WillRepeatedly(Return(&localInfo));
604 char localUdidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = {0};
605 char peerUdidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = {0};
606 int32_t ret = GetUdidHashForDfx(localUdidHash, peerUdidHash, &connInfo);
607 EXPECT_EQ(ret, SOFTBUS_ERR);
608 ret = GetUdidHashForDfx(localUdidHash, peerUdidHash, &connInfo);
609 EXPECT_EQ(ret, SOFTBUS_OK);
610 connInfo.addr.type = CONNECTION_ADDR_BLE;
611 EXPECT_EQ(EOK, memcpy_s(connInfo.addr.info.ble.udidHash, UDID_BUF_LEN, PEERUDID, strlen(PEERUDID)));
612 ret = GetUdidHashForDfx(localUdidHash, peerUdidHash, &connInfo);
613 EXPECT_EQ(ret, SOFTBUS_OK);
614 }
615
616 /*
617 * @tc.name: GET_PEER_UDID_HASH_TEST_001
618 * @tc.desc: test GetPeerUdidHash
619 * @tc.type: FUNC
620 * @tc.require:
621 */
622 HWTEST_F(LNNConnectionFsmTest, GET_PEER_UDID_HASH_TEST_001, TestSize.Level1)
623 {
624 NodeBasicInfo peerDevInfo = { .deviceTypeId = 1, };
625 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
626 NiceMock<DistributeLedgerInterfaceMock> mock;
627 NiceMock<LnnConnFsmInterfaceMock> lnnConnMock;
628 NiceMock<LnnServicetInterfaceMock> serviceMock;
629 ON_CALL(serviceMock, LnnAsyncCallbackDelayHelper).WillByDefault(Return(SOFTBUS_OK));
630 ON_CALL(ledgerMock, LnnGetRemoteNodeInfoById).WillByDefault(Return(SOFTBUS_OK));
631 ON_CALL(ledgerMock, LnnHasDiscoveryType).WillByDefault(Return(true));
632 ON_CALL(mock, LnnGetRemoteStrInfo).WillByDefault(Return(SOFTBUS_OK));
633 ON_CALL(ledgerMock, LnnGetAllOnlineNodeInfo).WillByDefault(LnnNetLedgertInterfaceMock::ActionOfLnnGetAllOnline);
634 ON_CALL(lnnConnMock, SendDeviceStateToMlps).WillByDefault(Return());
635 const char *udid = "testuuid";
636 char udidData[UDID_BUF_LEN] = {0};
637 ReportDeviceOnlineEvt(udid, &peerDevInfo);
638 DeviceStateChangeProcess(udidData, CONNECTION_ADDR_BLE, false);
639 DeviceStateChangeProcess(nullptr, CONNECTION_ADDR_BLE, false);
640 DeviceStateChangeProcess(nullptr, CONNECTION_ADDR_WLAN, false);
641 NodeInfo nodeInfo;
642 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
643 EXPECT_EQ(EOK, memcpy_s(nodeInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, PEERUDID, strlen(PEERUDID)));
644 char peerUdidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = {0};
645 int32_t ret = GetPeerUdidHash(&nodeInfo, peerUdidHash);
646 EXPECT_EQ(ret, SOFTBUS_OK);
647 ret = GetPeerUdidHash(nullptr, peerUdidHash);
648 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
649 ret = GetPeerUdidHash(&nodeInfo, nullptr);
650 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
651 }
652
653 /*
654 * @tc.name: GET_DEV_TYPE_FOR_DFX_TEST_001
655 * @tc.desc: test GetDevTypeForDfx
656 * @tc.type: FUNC
657 * @tc.require:
658 */
659 HWTEST_F(LNNConnectionFsmTest, GET_DEV_TYPE_FOR_DFX_TEST_001, TestSize.Level1)
660 {
661 NodeInfo localInfo;
662 localInfo.deviceInfo.deviceTypeId = 1;
663 NiceMock<LnnConnFsmInterfaceMock> lnnConnMock;
664 EXPECT_CALL(lnnConnMock, LnnGetLocalNodeInfoSafe)
665 .WillOnce(Return(SOFTBUS_ERR))
666 .WillRepeatedly(DoAll(SetArgPointee<0>(localInfo), Return(SOFTBUS_OK)));
667 LnnConntionInfo connInfo = { .nodeInfo = nullptr, .infoReport.type = DESKTOP_PC, };
668 char localDeviceType[DEVICE_TYPE_SIZE_LEN + 1] = {0};
669 char peerDeviceType[DEVICE_TYPE_SIZE_LEN + 1] = {0};
670 int32_t ret = GetDevTypeForDfx(localDeviceType, peerDeviceType, &connInfo);
671 EXPECT_EQ(ret, SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR);
672 ret = GetDevTypeForDfx(localDeviceType, peerDeviceType, &connInfo);
673 EXPECT_EQ(ret, SOFTBUS_OK);
674 }
675
676 /*
677 * @tc.name: GET_PEER_UDID_INFO_TEST_001
678 * @tc.desc: test GetPeerUdidInfo
679 * @tc.type: FUNC
680 * @tc.require:
681 */
682 HWTEST_F(LNNConnectionFsmTest, GET_PEER_UDID_INFO_TEST_001, TestSize.Level1)
683 {
684 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
685 ON_CALL(ledgerMock, LnnHasDiscoveryType).WillByDefault(Return(true));
686 NodeInfo nodeInfo;
687 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
688 EXPECT_EQ(EOK, strcpy_s(nodeInfo.deviceInfo.deviceUdid, UDID_BUF_LEN, PEERUDID));
689 LnnEventExtra extra;
690 SetOnlineType(SOFTBUS_OK, &nodeInfo, extra);
691 SetOnlineType(SOFTBUS_ERR, &nodeInfo, extra);
692 char udidData[UDID_BUF_LEN] = {0};
693 char peerUdidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = {0};
694 int32_t ret = GetPeerUdidInfo(&nodeInfo, udidData, peerUdidHash);
695 EXPECT_EQ(ret, SOFTBUS_OK);
696 }
697
698 /*
699 * @tc.name: FILL_DEVICE_BLE_REPORT_EXTRA_TEST_001
700 * @tc.desc: test FillDeviceBleReportExtra
701 * @tc.type: FUNC
702 * @tc.require:
703 */
704 HWTEST_F(LNNConnectionFsmTest, FILL_DEVICE_BLE_REPORT_EXTRA_TEST_001, TestSize.Level1)
705 {
706 LnnEventExtra extra = { .onlineType = 0, .errcode = SOFTBUS_AUTH_HICHAIN_NO_CANDIDATE_GROUP, };
707 extra.peerNetworkId = NETWORKID1;
708 extra.peerUdid = PEERUDID;
709 extra.peerUdidHash = PEERUDID;
710 extra.peerBleMac = MACTEST;
711 LnnBleReportExtra bleExtra;
712 (void)memset_s(&bleExtra, sizeof(LnnBleReportExtra), 0, sizeof(LnnBleReportExtra));
713 int32_t ret = FillDeviceBleReportExtra(&extra, &bleExtra);
714 EXPECT_EQ(ret, SOFTBUS_OK);
715 LnnConntionInfo connInfo = { .nodeInfo = nullptr, .infoReport.type = DESKTOP_PC, };
716 extra.localUdidHash = PEERUDID;
717 extra.localDeviceType = PC_DEV_TYPE;
718 extra.peerDeviceType = PC_DEV_TYPE;
719 DfxAddBleReportExtra(&connInfo, &extra, &bleExtra);
720 DfxAddBleReportExtra(&connInfo, &extra, &bleExtra);
721 DfxAddBleReportExtra(nullptr, &extra, &bleExtra);
722 DfxAddBleReportExtra(&connInfo, nullptr, &bleExtra);
723 DfxAddBleReportExtra(&connInfo, &extra, nullptr);
724 connInfo.addr.type = CONNECTION_ADDR_BLE;
725 DfxReportOnlineEvent(nullptr, SOFTBUS_OK, extra);
726 DfxReportOnlineEvent(&connInfo, SOFTBUS_OK, extra);
727 connInfo.addr.type = CONNECTION_ADDR_WLAN;
728 DfxReportOnlineEvent(&connInfo, SOFTBUS_OK, extra);
729 ret = FillDeviceBleReportExtra(nullptr, &bleExtra);
730 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
731 ret = FillDeviceBleReportExtra(&extra, nullptr);
732 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
733 }
734
735 /*
736 * @tc.name: UPDATE_LEAVE_TO_LEDGER_TEST_001
737 * @tc.desc: test UpdateLeaveToLedger
738 * @tc.type: FUNC
739 * @tc.require:
740 */
741 HWTEST_F(LNNConnectionFsmTest, UPDATE_LEAVE_TO_LEDGER_TEST_001, TestSize.Level1)
742 {
743 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
744 NiceMock<LnnConnFsmInterfaceMock> lnnConnMock;
745 NiceMock<LnnServicetInterfaceMock> serviceMock;
746 ON_CALL(serviceMock, LnnNotifyLnnRelationChanged).WillByDefault(Return());
747 EXPECT_CALL(lnnConnMock, LnnGetLocalNodeInfoSafe).WillRepeatedly(Return(SOFTBUS_ERR));
748 LnnConntionInfo connInfo = { .infoReport.bleConnectReason = FIND_REMOTE_CIPHERKEY_FAILED, .nodeInfo = nullptr, };
749 uint32_t connOnlineReason = 0;
750 GetConnectOnlineReason(&connInfo, &connOnlineReason, SOFTBUS_OK);
751 EXPECT_CALL(lnnConnMock, LnnGetLocalNodeInfoSafe).WillRepeatedly(Return(SOFTBUS_OK));
752 GetConnectOnlineReason(&connInfo, &connOnlineReason, SOFTBUS_OK);
753 GetConnectOnlineReason(&connInfo, &connOnlineReason, SOFTBUS_ERR);
754 NodeInfo nodeInfo;
755 connInfo.nodeInfo = &nodeInfo;
756 EXPECT_CALL(lnnConnMock, LnnGetLocalNodeInfoSafe).WillRepeatedly(Return(SOFTBUS_OK));
757 GetConnectOnlineReason(&connInfo, &connOnlineReason, SOFTBUS_OK);
758 GetConnectOnlineReason(&connInfo, &connOnlineReason, SOFTBUS_ERR);
759 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
760 .WillOnce(Return(SOFTBUS_ERR))
761 .WillRepeatedly(Return(SOFTBUS_OK));
762 EXPECT_CALL(ledgerMock, LnnGetBasicInfoByUdid)
763 .WillOnce(Return(SOFTBUS_ERR))
764 .WillRepeatedly(Return(SOFTBUS_OK));
765 EXPECT_CALL(ledgerMock, LnnGetDeviceUdid).WillRepeatedly(Return(nullptr));
766 EXPECT_CALL(ledgerMock, LnnSetNodeOffline).WillRepeatedly(Return(REPORT_OFFLINE));
767 EXPECT_CALL(lnnConnMock, DeleteFromProfile).WillRepeatedly(Return());
768 LnnConnectionFsm connFsm = { .connInfo.cleanInfo = nullptr, };
769 const char *networkId = "networkIdTest";
770 NodeBasicInfo basic;
771 (void)memset_s(&basic, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
772 bool ret = UpdateLeaveToLedger(&connFsm, networkId, &basic);
773 EXPECT_EQ(ret, false);
774 ret = UpdateLeaveToLedger(&connFsm, networkId, &basic);
775 EXPECT_EQ(ret, true);
776 ret = UpdateLeaveToLedger(&connFsm, networkId, &basic);
777 EXPECT_EQ(ret, true);
778 }
779
780 /*
781 * @tc.name: LNN_RECOVERY_BROADCAST_KEY_TEST_001
782 * @tc.desc: test LnnRecoveryBroadcastKey
783 * @tc.type: FUNC
784 * @tc.require:
785 */
786 HWTEST_F(LNNConnectionFsmTest, LNN_RECOVERY_BROADCAST_KEY_TEST_001, TestSize.Level1)
787 {
788 NiceMock<LnnConnFsmInterfaceMock> lnnConnMock;
789 EXPECT_CALL(lnnConnMock, LnnLoadLocalBroadcastCipherKey)
790 .WillOnce(Return(SOFTBUS_ERR))
791 .WillRepeatedly(Return(SOFTBUS_OK));
792 EXPECT_CALL(lnnConnMock, LnnGetLocalBroadcastCipherKey)
793 .WillOnce(Return(SOFTBUS_ERR))
794 .WillRepeatedly(Return(SOFTBUS_OK));
795 int32_t ret = LnnRecoveryBroadcastKey();
796 EXPECT_EQ(ret, SOFTBUS_ERR);
797 ret = LnnRecoveryBroadcastKey();
798 EXPECT_EQ(ret, SOFTBUS_ERR);
799 ret = LnnRecoveryBroadcastKey();
800 EXPECT_EQ(ret, SOFTBUS_OK);
801 ret = LnnRecoveryBroadcastKey();
802 EXPECT_EQ(ret, SOFTBUS_OK);
803 }
804
805 /*
806 * @tc.name: IS_WIFI_CONNECT_INFO_CHANGED_TEST_001
807 * @tc.desc: test IsWifiConnectInfoChanged
808 * @tc.type: FUNC
809 * @tc.require:
810 */
811 HWTEST_F(LNNConnectionFsmTest, IS_WIFI_CONNECT_INFO_CHANGED_TEST_001, TestSize.Level1)
812 {
813 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
814 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType)
815 .WillOnce(Return(false))
816 .WillRepeatedly(Return(true));
817 NodeInfo oldNodeInfo = {
818 .connectInfo.authPort = PORT,
819 .connectInfo.proxyPort = PORT,
820 .connectInfo.sessionPort = PORT,
821 };
822 NodeInfo newNodeInfo = {
823 .connectInfo.authPort = PORT,
824 .connectInfo.proxyPort = PORT,
825 .connectInfo.sessionPort = PORT,
826 };
827 EXPECT_EQ(EOK, memcpy_s(oldNodeInfo.connectInfo.deviceIp, IP_STR_MAX_LEN, IP, strlen(IP)));
828 EXPECT_EQ(EOK, memcpy_s(newNodeInfo.connectInfo.deviceIp, IP_STR_MAX_LEN, IP, strlen(IP)));
829 bool ret = IsWifiConnectInfoChanged(&oldNodeInfo, &newNodeInfo);
830 EXPECT_EQ(ret, false);
831 ret = IsWifiConnectInfoChanged(&oldNodeInfo, &newNodeInfo);
832 EXPECT_EQ(ret, false);
833 oldNodeInfo.connectInfo.sessionPort = PORT + 1;
834 ret = IsWifiConnectInfoChanged(&oldNodeInfo, &newNodeInfo);
835 EXPECT_EQ(ret, true);
836 oldNodeInfo.connectInfo.proxyPort = PORT + 1;
837 ret = IsWifiConnectInfoChanged(&oldNodeInfo, &newNodeInfo);
838 EXPECT_EQ(ret, true);
839 oldNodeInfo.connectInfo.authPort = PORT + 1;
840 ret = IsWifiConnectInfoChanged(&oldNodeInfo, &newNodeInfo);
841 EXPECT_EQ(ret, true);
842 EXPECT_EQ(EOK, memcpy_s(oldNodeInfo.connectInfo.deviceIp, IP_STR_MAX_LEN, PEERUDID, strlen(PEERUDID)));
843 ret = IsWifiConnectInfoChanged(&oldNodeInfo, &newNodeInfo);
844 EXPECT_EQ(ret, true);
845 }
846
847 /*
848 * @tc.name: LNN_IS_NEED_CLEAN_CONNECTION_FSM_TEST_001
849 * @tc.desc: test LnnIsNeedCleanConnectionFsm
850 * @tc.type: FUNC
851 * @tc.require:
852 */
853 HWTEST_F(LNNConnectionFsmTest, LNN_IS_NEED_CLEAN_CONNECTION_FSM_TEST_001, TestSize.Level1)
854 {
855 NodeInfo node;
856 EXPECT_EQ(EOK, memcpy_s(node.networkId, NETWORK_ID_BUF_LEN, NETWORKID1, strlen(NETWORKID1)));
857 EXPECT_EQ(EOK, memcpy_s(node.uuid, UDID_BUF_LEN, PEERUDID, strlen(PEERUDID)));
858 EXPECT_EQ(EOK, memcpy_s(node.softBusVersion, VERSION_MAX_LEN, SOFTBUSVERSION, strlen(SOFTBUSVERSION)));
859 NodeInfo nodeInfo;
860 EXPECT_EQ(EOK, memcpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID1, strlen(NETWORKID1)));
861 EXPECT_EQ(EOK, memcpy_s(nodeInfo.uuid, UDID_BUF_LEN, PEERUDID, strlen(PEERUDID)));
862 EXPECT_EQ(EOK, memcpy_s(nodeInfo.softBusVersion, VERSION_MAX_LEN, SOFTBUSVERSION, strlen(SOFTBUSVERSION)));
863 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
864 EXPECT_CALL(ledgerMock, LnnGetRemoteNodeInfoById)
865 .WillOnce(Return(SOFTBUS_ERR))
866 .WillRepeatedly(DoAll(SetArgPointee<2>(node), Return(SOFTBUS_OK)));
867 EXPECT_CALL(ledgerMock, LnnIsNodeOnline)
868 .WillOnce(Return(false))
869 .WillRepeatedly(Return(true));
870 EXPECT_CALL(ledgerMock, LnnHasDiscoveryType).WillRepeatedly(Return(false));
871 bool ret = LnnIsNeedCleanConnectionFsm(&nodeInfo, CONNECTION_ADDR_ETH);
872 EXPECT_EQ(ret, false);
873 ret = LnnIsNeedCleanConnectionFsm(&nodeInfo, CONNECTION_ADDR_ETH);
874 EXPECT_EQ(ret, false);
875 ret = LnnIsNeedCleanConnectionFsm(&nodeInfo, CONNECTION_ADDR_ETH);
876 EXPECT_EQ(ret, false);
877 ret = LnnIsNeedCleanConnectionFsm(&nodeInfo, CONNECTION_ADDR_WLAN);
878 EXPECT_EQ(ret, false);
879 ret = LnnIsNeedCleanConnectionFsm(&nodeInfo, CONNECTION_ADDR_BR);
880 EXPECT_EQ(ret, false);
881 EXPECT_EQ(EOK, strcpy_s(nodeInfo.networkId, NETWORK_ID_BUF_LEN, NETWORKID2));
882 ret = LnnIsNeedCleanConnectionFsm(&nodeInfo, CONNECTION_ADDR_BR);
883 EXPECT_EQ(ret, true);
884 }
885
886 /*
887 * @tc.name: SYNC_BR_OFFLINE_TEST_001
888 * @tc.desc: test SyncBrOffline
889 * @tc.type: FUNC
890 * @tc.require:
891 */
892 HWTEST_F(LNNConnectionFsmTest, SYNC_BR_OFFLINE_TEST_001, TestSize.Level1)
893 {
894 NiceMock<LnnNetLedgertInterfaceMock> ledgerMock;
895 EXPECT_CALL(ledgerMock, LnnConvertDlId).WillRepeatedly(Return(SOFTBUS_OK));
896 EXPECT_CALL(ledgerMock, LnnGetCnnCode).WillRepeatedly(Return(INVALID_CONNECTION_CODE_VALUE));
897 LnnConnectionFsm connFsm = {
898 .connInfo.addr.type = CONNECTION_ADDR_WLAN,
899 .connInfo.flag = 1,
900 };
901 int32_t ret = SyncBrOffline(&connFsm);
902 EXPECT_EQ(ret, SOFTBUS_ERR);
903 connFsm.connInfo.addr.type = CONNECTION_ADDR_BR;
904 ret = SyncBrOffline(&connFsm);
905 EXPECT_EQ(ret, SOFTBUS_ERR);
906 connFsm.connInfo.flag = LNN_CONN_INFO_FLAG_LEAVE_REQUEST;
907 ret = SyncBrOffline(&connFsm);
908 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
909 ret = SyncBrOffline(&connFsm);
910 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
911 }
912 } // namespace OHOS