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