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