1 /*
2 * Copyright (c) 2022-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 "lnn_log.h"
20 #include "lnn_net_builder.c"
21 #include "lnn_net_builder.h"
22 #include "lnn_net_builder_deps_mock.h"
23 #include "lnn_net_builder_init.c"
24 #include "lnn_net_builder_process.c"
25 #include "lnn_ohos_account.h"
26 #include "softbus_adapter_bt_common.h"
27 #include "softbus_common.h"
28 #include "softbus_error_code.h"
29
30 namespace OHOS {
31 using namespace testing::ext;
32 constexpr int32_t LOCAL_WEIGHT = 10;
33 constexpr char NODE_UDID[] = "123456ABCDEF";
34 constexpr char NODE_NETWORK_ID[] = "235689BNHFCF";
35 constexpr char NODE1_NETWORK_ID[] = "345678BNHFCF";
36 constexpr int64_t AUTH_META_ID = 1;
37 constexpr char INVALID_UDID[] = "ASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJK\
38 LPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJ\
39 KLPASDFGHJKLPASDFGHJKLPASDFGHJKLPASDFGHJKLP";
40 constexpr int64_t AUTH_ID = 10;
41 constexpr int64_t AUTH_ID_ADD = 11;
42 constexpr char NODE1_BR_MAC[] = "12345TTU";
43 constexpr char NODE2_BR_MAC[] = "56789TTU";
44 constexpr char ACCOUNT_HASH[] = "5FEC";
45 constexpr uint32_t REQUEST_ID = 1;
46 constexpr uint32_t REQUEST_ID_ADD = 2;
47 constexpr uint16_t FSM_ID = 1;
48 constexpr uint16_t FSM_ID_ADD = 2;
49 constexpr char NODE1_IP[] = "10.146.181.134";
50 constexpr char NODE2_IP[] = "10.147.182.135";
51 constexpr int32_t CONN_COUNT = 10;
52 constexpr int32_t CURRENT_COUNT = 11;
53 constexpr uint32_t CONN_FLAG1 = 128;
54 constexpr uint32_t CONN_FLAG2 = 255;
55 constexpr uint32_t CONN_FLAG3 = 1;
56 constexpr uint32_t MSG_ERR_LEN0 = 0;
57 constexpr uint32_t MSG_ERR_LEN1 = 1;
58 constexpr uint8_t SELECT_MASTER_MSG[] = "{\"MasterWeight\":\"500\", \"MasterUdid\":\"123456\"}";
59 constexpr uint8_t EMPTY_ACCOUNT[] = "5FEC";
60
61 using namespace testing;
62 class LNNNetBuilderMockTest : public testing::Test {
63 public:
64 static void SetUpTestCase();
65 static void TearDownTestCase();
66 void SetUp();
67 void TearDown();
68 };
69
SetUpTestCase()70 void LNNNetBuilderMockTest::SetUpTestCase() { }
71
TearDownTestCase()72 void LNNNetBuilderMockTest::TearDownTestCase() { }
73
SetUp()74 void LNNNetBuilderMockTest::SetUp() { }
75
TearDown()76 void LNNNetBuilderMockTest::TearDown() { }
77
ClearNetBuilderFsmList()78 static void ClearNetBuilderFsmList()
79 {
80 NetBuilder *netBuilder = LnnGetNetBuilder();
81 if (netBuilder == nullptr) {
82 return;
83 }
84 LnnConnectionFsm *item = nullptr;
85 LnnConnectionFsm *next = nullptr;
86 LIST_FOR_EACH_ENTRY_SAFE(item, next, &netBuilder->fsmList, LnnConnectionFsm, node) {
87 ListDelete(&item->node);
88 --netBuilder->connCount;
89 }
90 }
91
92 /*
93 * @tc.name: LNN_INIT_NET_BUILDER_TEST_001
94 * @tc.desc: lnn init netbuilder test
95 * @tc.type: FUNC
96 * @tc.require:
97 */
98 HWTEST_F(LNNNetBuilderMockTest, LNN_INIT_NET_BUILDER_TEST_001, TestSize.Level1)
99 {
100 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
101 EXPECT_CALL(NetBuilderMock, LnnInitSyncInfoManager())
102 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
103 .WillRepeatedly(Return(SOFTBUS_OK));
104 EXPECT_CALL(NetBuilderMock, LnnInitTopoManager()).WillRepeatedly(Return(SOFTBUS_OK));
105 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
106 EXPECT_CALL(NetBuilderMock, RegAuthVerifyListener(_))
107 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
108 .WillRepeatedly(Return(SOFTBUS_OK));
109 EXPECT_CALL(NetBuilderMock, LnnRegSyncInfoHandler(_, _))
110 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
111 .WillRepeatedly(Return(SOFTBUS_OK));
112 EXPECT_CALL(NetBuilderMock, LnnGenLocalNetworkId(_, _))
113 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
114 .WillRepeatedly(Return(SOFTBUS_OK));
115 EXPECT_CALL(NetBuilderMock, LnnGenLocalUuid(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
116 EXPECT_CALL(NetBuilderMock, LnnGenLocalIrk(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
117 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
118 EXPECT_CALL(NetBuilderMock, SoftBusGetBtState()).WillRepeatedly(Return(BLE_ENABLE));
119 EXPECT_TRUE(LnnInitNetBuilder() == SOFTBUS_INVALID_PARAM);
120 EXPECT_TRUE(LnnInitNetBuilder() == SOFTBUS_INVALID_PARAM);
121 EXPECT_TRUE(LnnInitNetBuilder() == SOFTBUS_INVALID_PARAM);
122 EXPECT_TRUE(LnnInitNetBuilder() == SOFTBUS_NOT_FIND);
123 EXPECT_TRUE(LnnInitNetBuilder() == SOFTBUS_LOOPER_ERR);
124 }
125
126 /*
127 * @tc.name: CONFIG_LOCAL_LEDGER_TEST_001
128 * @tc.desc: config local ledger test
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(LNNNetBuilderMockTest, CONFIG_LOCAL_LEDGER_TEST_001, TestSize.Level1)
133 {
134 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
135 EXPECT_CALL(NetBuilderMock, LnnGenLocalNetworkId(_, _))
136 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
137 .WillRepeatedly(Return(SOFTBUS_OK));
138 EXPECT_CALL(NetBuilderMock, LnnGenLocalUuid(_, _, _))
139 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
140 .WillRepeatedly(Return(SOFTBUS_OK));
141 EXPECT_CALL(NetBuilderMock, LnnGenLocalIrk(_, _, _))
142 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
143 .WillRepeatedly(Return(SOFTBUS_OK));
144 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
145 EXPECT_TRUE(ConfigLocalLedger() != SOFTBUS_OK);
146 EXPECT_TRUE(ConfigLocalLedger() != SOFTBUS_OK);
147 EXPECT_TRUE(ConfigLocalLedger() == SOFTBUS_OK);
148 }
149
150 /*
151 * @tc.name: LNN_INIT_NET_BUILDER_DELAY_TEST_001
152 * @tc.desc: lnn init netbuilder delay test
153 * @tc.type: FUNC
154 * @tc.require:
155 */
156 HWTEST_F(LNNNetBuilderMockTest, LNN_INIT_NET_BUILDER_DELAY_TEST_001, TestSize.Level1)
157 {
158 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
159 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
160 EXPECT_CALL(NetBuilderMock, LnnGetLocalWeight()).WillRepeatedly(Return(LOCAL_WEIGHT));
161 EXPECT_CALL(NetBuilderMock, LnnSetLocalNumInfo(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
162 EXPECT_CALL(NetBuilderMock, LnnInitFastOffline())
163 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
164 .WillRepeatedly(Return(SOFTBUS_OK));
165 EXPECT_TRUE(LnnInitNetBuilderDelay() == SOFTBUS_INVALID_PARAM);
166 EXPECT_TRUE(LnnInitNetBuilderDelay() == SOFTBUS_OK);
167 EXPECT_TRUE(LnnInitNetBuilderDelay() == SOFTBUS_OK);
168 }
169
170 /*
171 * @tc.name: PROCESS_LEAVE_BY_ADDR_TYPE_TEST_002
172 * @tc.desc: ProcessLeaveByAddrType test
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_BY_ADDR_TYPE_TEST_002, TestSize.Level1)
177 {
178 ClearNetBuilderFsmList();
179 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusCalloc(sizeof(LnnConnectionFsm)));
180 EXPECT_TRUE(connFsm != nullptr);
181 ListInit(&connFsm->node);
182 (void)strcpy_s(connFsm->connInfo.addr.info.ip.ip, IP_STR_MAX_LEN, NODE1_IP);
183 connFsm->connInfo.addr.type = CONNECTION_ADDR_WLAN;
184 connFsm->connInfo.authHandle.authId = AUTH_ID_ADD;
185 connFsm->isDead = false;
186 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
187 ++LnnGetNetBuilder()->connCount;
188 LnnConnectionFsm *connFsm1 = reinterpret_cast<LnnConnectionFsm *>(SoftBusCalloc(sizeof(LnnConnectionFsm)));
189 EXPECT_TRUE(connFsm1 != nullptr);
190 connFsm1->connInfo.addr.type = CONNECTION_ADDR_BR;
191 connFsm1->isDead = true;
192 ListInit(&connFsm1->node);
193 ListAdd(&g_netBuilder.fsmList, &connFsm1->node);
194 ++LnnGetNetBuilder()->connCount;
195 bool addrType[CONNECTION_ADDR_MAX] = {
196 [CONNECTION_ADDR_BR] = false,
197 [CONNECTION_ADDR_WLAN] = true,
198 [CONNECTION_ADDR_BLE] = false,
199 };
200 bool *para = reinterpret_cast<bool *>(SoftBusMalloc(sizeof(bool) * CONNECTION_ADDR_MAX));
201 EXPECT_TRUE(para != nullptr);
202 EXPECT_EQ(EOK, memcpy_s(para, sizeof(bool) * CONNECTION_ADDR_MAX, addrType, sizeof(bool) * CONNECTION_ADDR_MAX));
203 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
204 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
205 EXPECT_CALL(NetBuilderMock, LnnNotifyAllTypeOffline(_)).WillRepeatedly(Return());
206 int32_t ret = ProcessLeaveByAddrType(reinterpret_cast<const void *>(para));
207 EXPECT_EQ(ret, SOFTBUS_OK);
208 bool *para1 = reinterpret_cast<bool *>(SoftBusMalloc(sizeof(bool) * CONNECTION_ADDR_MAX));
209 EXPECT_TRUE(para1 != nullptr);
210 EXPECT_EQ(EOK, memcpy_s(para1, sizeof(bool) * CONNECTION_ADDR_MAX, addrType, sizeof(bool) * CONNECTION_ADDR_MAX));
211 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_OK));
212 ret = ProcessLeaveByAddrType(reinterpret_cast<const void *>(para1));
213 EXPECT_EQ(ret, SOFTBUS_OK);
214 EXPECT_CALL(NetBuilderMock, LnnDestroyConnectionFsm).WillRepeatedly(Return());
215 EXPECT_CALL(NetBuilderMock, LnnStopConnectionFsm).WillOnce(Return(SOFTBUS_INVALID_PARAM));
216 CleanConnectionFsm(nullptr);
217 CleanConnectionFsm(connFsm);
218 StopConnectionFsm(connFsm);
219 EXPECT_CALL(NetBuilderMock, LnnStopConnectionFsm).WillRepeatedly(Return(SOFTBUS_OK));
220 StopConnectionFsm(connFsm1);
221 ret = FindRequestIdByAddr(nullptr, nullptr);
222 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
223 ClearNetBuilderFsmList();
224 }
225
226 /*
227 * @tc.name: LNN_UPDATE_NODE_ADDR_TEST_001
228 * @tc.desc: lnn update node addr test
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(LNNNetBuilderMockTest, LNN_UPDATE_NODE_ADDR_TEST_001, TestSize.Level1)
233 {
234 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
235 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo(_, _, _))
236 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
237 .WillRepeatedly(Return(SOFTBUS_OK));
238 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _))
239 .WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND))
240 .WillRepeatedly(Return(SOFTBUS_OK));
241 EXPECT_CALL(NetBuilderMock, LnnGetAllOnlineNodeInfo(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
242 EXPECT_CALL(NetBuilderMock, LnnNotifyNodeAddressChanged(_, _, _)).WillRepeatedly(Return());
243 EXPECT_TRUE(LnnUpdateNodeAddr(nullptr) == SOFTBUS_INVALID_PARAM);
244 EXPECT_TRUE(LnnUpdateNodeAddr(NODE_NETWORK_ID) != SOFTBUS_OK);
245 EXPECT_TRUE(LnnUpdateNodeAddr(NODE_NETWORK_ID) != SOFTBUS_OK);
246 EXPECT_TRUE(LnnUpdateNodeAddr(NODE_NETWORK_ID) == SOFTBUS_OK);
247 EXPECT_TRUE(LnnUpdateNodeAddr(NODE_NETWORK_ID) == SOFTBUS_OK);
248 }
249
250 /*
251 * @tc.name: NODE_INFO_SYNC_TEST_001
252 * @tc.desc: node info sync test
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(LNNNetBuilderMockTest, NODE_INFO_SYNC_TEST_001, TestSize.Level1)
257 {
258 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
259 EXPECT_CALL(NetBuilderMock, LnnInitP2p())
260 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
261 .WillRepeatedly(Return(SOFTBUS_OK));
262 EXPECT_CALL(NetBuilderMock, LnnInitNetworkInfo())
263 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
264 .WillRepeatedly(Return(SOFTBUS_OK));
265 EXPECT_CALL(NetBuilderMock, LnnInitDevicename())
266 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
267 .WillRepeatedly(Return(SOFTBUS_OK));
268 EXPECT_CALL(NetBuilderMock, LnnInitOffline())
269 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
270 .WillRepeatedly(Return(SOFTBUS_OK));
271 EXPECT_TRUE(InitNodeInfoSync() == SOFTBUS_INVALID_PARAM);
272 EXPECT_TRUE(InitNodeInfoSync() == SOFTBUS_INVALID_PARAM);
273 EXPECT_TRUE(InitNodeInfoSync() == SOFTBUS_INVALID_PARAM);
274 EXPECT_TRUE(InitNodeInfoSync() == SOFTBUS_INVALID_PARAM);
275 EXPECT_TRUE(InitNodeInfoSync() == SOFTBUS_OK);
276 }
277
278 /*
279 * @tc.name: ON_DEVICE_NOT_TRUSTED_TEST_001
280 * @tc.desc: on device not trusted test
281 * @tc.type: FUNC
282 * @tc.require:
283 */
284 HWTEST_F(LNNNetBuilderMockTest, ON_DEVICE_NOT_TRUSTED_TEST_001, TestSize.Level1)
285 {
286 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
287 SoftBusLooper loop;
288 EXPECT_CALL(NetBuilderMock, LnnGetOnlineStateById(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
289 EXPECT_CALL(NetBuilderMock, AuthGetLatestAuthSeqList(_, _, _))
290 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
291 .WillRepeatedly(Return(SOFTBUS_OK));
292 EXPECT_CALL(NetBuilderMock, LnnSendNotTrustedInfo(_, _, _))
293 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
294 .WillRepeatedly(Return(SOFTBUS_OK));
295 EXPECT_CALL(NetBuilderMock, GetLooper(_)).WillRepeatedly(Return(&loop));
296 EXPECT_CALL(NetBuilderMock, LnnAsyncCallbackDelayHelper(_, _, _, _))
297 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
298 .WillRepeatedly(Return(SOFTBUS_OK));
299 OnDeviceNotTrusted(nullptr);
300 OnDeviceNotTrusted(INVALID_UDID);
301 OnDeviceNotTrusted(NODE_UDID);
302 OnDeviceNotTrusted(NODE_UDID);
303 OnDeviceNotTrusted(NODE_UDID);
304 OnDeviceNotTrusted(NODE_UDID);
305 OnDeviceNotTrusted(NODE_UDID);
306 }
307
308 /*
309 * @tc.name: ON_DEVICE_VERIFY_PASS_TEST_001
310 * @tc.desc: on device verify pass test
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 HWTEST_F(LNNNetBuilderMockTest, ON_DEVICE_VERIFY_PASS_TEST_001, TestSize.Level1)
315 {
316 NodeInfo info;
317 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
318 EXPECT_CALL(NetBuilderMock, AuthGetConnInfo(_, _))
319 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
320 .WillRepeatedly(Return(SOFTBUS_OK));
321 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
322 EXPECT_CALL(NetBuilderMock, LnnConvertAuthConnInfoToAddr(_, _, _))
323 .WillOnce(Return(false))
324 .WillRepeatedly(Return(true));
325 AuthHandle authHandle = { .authId = AUTH_META_ID, .type = AUTH_LINK_TYPE_WIFI };
326 EXPECT_CALL(NetBuilderMock, GetLnnTriggerInfo(_)).WillRepeatedly(Return());
327 OnDeviceVerifyPass(authHandle, &info);
328 OnDeviceVerifyPass(authHandle, &info);
329 OnDeviceVerifyPass(authHandle, nullptr);
330 }
331
332 /*
333 * @tc.name: GET_CURRENT_CONNECT_TYPE_TEST_001
334 * @tc.desc: get current connect type test
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(LNNNetBuilderMockTest, GET_CURRENT_CONNECT_TYPE_TEST_001, TestSize.Level1)
339 {
340 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
341 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo(_, _, _))
342 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
343 .WillRepeatedly(Return(SOFTBUS_OK));
344 EXPECT_CALL(NetBuilderMock, LnnGetAddrTypeByIfName(_, _))
345 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
346 .WillRepeatedly(Return(SOFTBUS_OK));
347 EXPECT_TRUE(GetCurrentConnectType() == CONNECTION_ADDR_MAX);
348 EXPECT_TRUE(GetCurrentConnectType() == CONNECTION_ADDR_MAX);
349 EXPECT_TRUE(GetCurrentConnectType() == CONNECTION_ADDR_MAX);
350 }
351
352 /*
353 * @tc.name: PROCESS_LEAVE_SPECIFIC_TEST_001
354 * @tc.desc: process leave specific test
355 * @tc.type: FUNC
356 * @tc.require:
357 */
358 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_SPECIFIC_TEST_001, TestSize.Level1)
359 {
360 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
361 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_OK));
362 EXPECT_TRUE(ProcessLeaveSpecific(nullptr) == SOFTBUS_INVALID_PARAM);
363 }
364
365 /*
366 * @tc.name: PROCESS_LEAVE_BY_ADDR_TYPE_TEST_001
367 * @tc.desc: process leave by addr type test
368 * @tc.type: FUNC
369 * @tc.require:
370 */
371 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_BY_ADDR_TYPE_TEST_001, TestSize.Level1)
372 {
373 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
374 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_OK));
375 EXPECT_CALL(NetBuilderMock, LnnNotifyAllTypeOffline(_)).WillRepeatedly(Return());
376 EXPECT_TRUE(ProcessLeaveByAddrType(nullptr) == SOFTBUS_INVALID_PARAM);
377 }
378
379 /*
380 * @tc.name: PROCESS_ELETE_TEST_001
381 * @tc.desc: process elect test
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(LNNNetBuilderMockTest, PROCESS_ELETE_TEST_001, TestSize.Level1)
386 {
387 void *para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(ElectMsgPara)));
388 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
389 SoftBusLooper loop;
390 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
391 EXPECT_CALL(NetBuilderMock, RegAuthVerifyListener(_)).WillRepeatedly(Return(SOFTBUS_OK));
392 EXPECT_CALL(NetBuilderMock, LnnRegSyncInfoHandler(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
393 EXPECT_CALL(NetBuilderMock, LnnGenLocalNetworkId(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
394 EXPECT_CALL(NetBuilderMock, LnnGenLocalUuid(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
395 EXPECT_CALL(NetBuilderMock, LnnGenLocalIrk(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
396 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
397 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
398 EXPECT_CALL(NetBuilderMock, LnnUnregSyncInfoHandler(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
399 EXPECT_CALL(NetBuilderMock, GetLooper(_)).WillRepeatedly(Return(&loop));
400 EXPECT_CALL(NetBuilderMock, SoftBusGetBtState()).WillRepeatedly(Return(BLE_ENABLE));
401 EXPECT_TRUE(ProcessMasterElect(nullptr) == SOFTBUS_INVALID_PARAM);
402 EXPECT_TRUE(LnnInitBusCenterEvent() == SOFTBUS_OK);
403 EXPECT_TRUE(LnnInitNetBuilder() == SOFTBUS_OK);
404 EXPECT_TRUE(ProcessMasterElect(para) == SOFTBUS_NETWORK_NOT_FOUND);
405 LnnDeinitNetBuilder();
406 LnnDeinitBusCenterEvent();
407 }
408
409 /*
410 * @tc.name: PROCESS_NODE_STATE_CHANGED_TEST_001
411 * @tc.desc: process node state changed test
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(LNNNetBuilderMockTest, PROCESS_NODE_STATE_CHANGED_TEST_001, TestSize.Level1)
416 {
417 void *para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(ConnectionAddr)));
418 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
419 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
420 EXPECT_TRUE(ProcessNodeStateChanged(nullptr) == SOFTBUS_INVALID_PARAM);
421 EXPECT_TRUE(ProcessNodeStateChanged(para) == SOFTBUS_NETWORK_NOT_FOUND);
422 }
423
424 /*
425 * @tc.name: PROCESS_NODE_STATE_CHANGED_TEST_002
426 * @tc.desc: process node state changed test
427 * @tc.type: FUNC
428 * @tc.require:
429 */
430 HWTEST_F(LNNNetBuilderMockTest, PROCESS_NODE_STATE_CHANGED_TEST_002, TestSize.Level1)
431 {
432 void *para = nullptr;
433 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(ConnectionAddr)));
434 EXPECT_TRUE(para != nullptr);
435 void *para1 = nullptr;
436 para1 = reinterpret_cast<void *>(SoftBusMalloc(sizeof(ConnectionAddr)));
437 EXPECT_TRUE(para1 != nullptr);
438 void *para2 = nullptr;
439 para2 = reinterpret_cast<void *>(SoftBusMalloc(sizeof(ConnectionAddr)));
440 EXPECT_TRUE(para2 != nullptr);
441 LnnConnectionFsm *connFsm = nullptr;
442 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
443 EXPECT_TRUE(connFsm != nullptr);
444 ListInit(&connFsm->node);
445 connFsm->connInfo.version = SOFTBUS_NEW_V1;
446 connFsm->isDead = false;
447 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
448 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
449 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
450 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillRepeatedly(Return(true));
451 EXPECT_CALL(NetBuilderMock, LnnGetOnlineStateById).WillOnce(Return(true)).WillRepeatedly(Return(false));
452 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo)
453 .WillOnce(Return(SOFTBUS_OK))
454 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
455 EXPECT_TRUE(ProcessNodeStateChanged(para) == SOFTBUS_OK);
456 EXPECT_TRUE(ProcessNodeStateChanged(para1) != SOFTBUS_OK);
457 EXPECT_TRUE(ProcessNodeStateChanged(para2) != SOFTBUS_OK);
458 ListDelete(&connFsm->node);
459 SoftBusFree(connFsm);
460 }
461
462 /*
463 * @tc.name: PROCESS_NODE_STATE_CHANGED_TEST_003
464 * @tc.desc: process node state changed test
465 * @tc.type: FUNC
466 * @tc.require:
467 */
468 HWTEST_F(LNNNetBuilderMockTest, PROCESS_NODE_STATE_CHANGED_TEST_003, TestSize.Level1)
469 {
470 void *para = nullptr;
471 para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(ConnectionAddr)));
472 EXPECT_TRUE(para != nullptr);
473 void *para1 = nullptr;
474 para1 = reinterpret_cast<void *>(SoftBusMalloc(sizeof(ConnectionAddr)));
475 EXPECT_TRUE(para1 != nullptr);
476 LnnConnectionFsm *connFsm = nullptr;
477 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
478 EXPECT_TRUE(connFsm != nullptr);
479 ListInit(&connFsm->node);
480 connFsm->connInfo.version = SOFTBUS_OLD_V2;
481 connFsm->isDead = false;
482 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
483 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
484 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
485 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillRepeatedly(Return(true));
486 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo)
487 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
488 .WillRepeatedly(Return(SOFTBUS_OK));
489 EXPECT_CALL(NetBuilderMock, LnnConvertDLidToUdid).WillOnce(Return(NODE_UDID));
490 EXPECT_TRUE(ProcessNodeStateChanged(para) == SOFTBUS_OK);
491 EXPECT_TRUE(ProcessNodeStateChanged(para1) == SOFTBUS_OK);
492 ListDelete(&connFsm->node);
493 SoftBusFree(connFsm);
494 }
495
496 /*
497 * @tc.name: TRY_ELECT_NODE_OFFLINE_TEST_001
498 * @tc.desc: try elect node offline test
499 * @tc.type: FUNC
500 * @tc.require:
501 */
502 HWTEST_F(LNNNetBuilderMockTest, TRY_ELECT_NODE_OFFLINE_TEST_001, TestSize.Level1)
503 {
504 LnnConnectionFsm connFsm;
505 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
506 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo(_, _, _))
507 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
508 .WillRepeatedly(Return(SOFTBUS_OK));
509 EXPECT_TRUE(TryElectMasterNodeOffline(&connFsm) != SOFTBUS_OK);
510 EXPECT_TRUE(TryElectMasterNodeOffline(&connFsm) == SOFTBUS_OK);
511 }
512
513 /*
514 * @tc.name: TRY_ELECT_NODE_ONLINE_TEST_001
515 * @tc.desc: try elect node online test
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(LNNNetBuilderMockTest, TRY_ELECT_NODE_ONLINE_TEST_001, TestSize.Level1)
520 {
521 LnnConnectionFsm connFsm;
522 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
523 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo(_, _, _))
524 .WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND))
525 .WillRepeatedly(Return(SOFTBUS_OK));
526 EXPECT_CALL(NetBuilderMock, LnnGetLocalNumInfo(_, _))
527 .WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND))
528 .WillRepeatedly(Return(SOFTBUS_OK));
529 EXPECT_CALL(NetBuilderMock, LnnGetRemoteStrInfo(_, _, _, _))
530 .WillOnce(Return(SOFTBUS_NOT_FIND))
531 .WillRepeatedly(Return(SOFTBUS_OK));
532 EXPECT_CALL(NetBuilderMock, LnnGetRemoteNumInfo(_, _, _))
533 .WillOnce(Return(SOFTBUS_NOT_FIND))
534 .WillRepeatedly(Return(SOFTBUS_OK));
535 EXPECT_CALL(NetBuilderMock, LnnCompareNodeWeight(_, _, _, _)).WillRepeatedly(Return(0));
536 EXPECT_TRUE(TryElectMasterNodeOnline(&connFsm) != SOFTBUS_OK);
537 EXPECT_TRUE(TryElectMasterNodeOnline(&connFsm) != SOFTBUS_OK);
538 EXPECT_TRUE(TryElectMasterNodeOnline(&connFsm) != SOFTBUS_OK);
539 EXPECT_TRUE(TryElectMasterNodeOnline(&connFsm) != SOFTBUS_OK);
540 EXPECT_TRUE(TryElectMasterNodeOnline(&connFsm) == SOFTBUS_OK);
541 }
542
543 /*
544 * @tc.name: PROCESS_LEAVE_INVALID_CONN_TEST_001
545 * @tc.desc: process leave invalid conn test
546 * @tc.type: FUNC
547 * @tc.require:
548 */
549 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_INVALID_CONN_TEST_001, TestSize.Level1)
550 {
551 void *para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(LeaveInvalidConnMsgPara)));
552 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
553 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
554 EXPECT_TRUE(ProcessLeaveInvalidConn(nullptr) == SOFTBUS_INVALID_PARAM);
555 EXPECT_TRUE(ProcessLeaveInvalidConn(para) == SOFTBUS_OK);
556 }
557
558 /*
559 * @tc.name: IS_INVALID_CONNECTION_FSM_TEST_001
560 * @tc.desc: is invalid connection fsm test
561 * @tc.type: FUNC
562 * @tc.require:
563 */
564 HWTEST_F(LNNNetBuilderMockTest, IS_INVALID_CONNECTION_FSM_TEST_001, TestSize.Level1)
565 {
566 LnnConnectionFsm connFsm;
567 (void)memset_s(&connFsm, sizeof(LnnConnectionFsm), 0, sizeof(LnnConnectionFsm));
568 (void)strncpy_s(connFsm.connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
569 LeaveInvalidConnMsgPara msgPara;
570 (void)memset_s(&msgPara, sizeof(LeaveInvalidConnMsgPara), 0, sizeof(LeaveInvalidConnMsgPara));
571 (void)strncpy_s(msgPara.oldNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE1_NETWORK_ID));
572 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
573 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
574 EXPECT_TRUE(IsInvalidConnectionFsm(&connFsm, &msgPara) == false);
575 (void)memset_s(&msgPara, sizeof(LeaveInvalidConnMsgPara), 0, sizeof(LeaveInvalidConnMsgPara));
576 (void)strncpy_s(msgPara.oldNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
577 connFsm.isDead = true;
578 EXPECT_TRUE(IsInvalidConnectionFsm(&connFsm, &msgPara) == false);
579 connFsm.isDead = false;
580 msgPara.addrType = CONNECTION_ADDR_WLAN;
581 connFsm.connInfo.addr.type = CONNECTION_ADDR_BR;
582 EXPECT_TRUE(IsInvalidConnectionFsm(&connFsm, &msgPara) == false);
583 msgPara.addrType = CONNECTION_ADDR_MAX;
584 connFsm.connInfo.flag = 0;
585 EXPECT_TRUE(IsInvalidConnectionFsm(&connFsm, &msgPara) == false);
586 connFsm.connInfo.flag = 1;
587 EXPECT_TRUE(IsInvalidConnectionFsm(&connFsm, &msgPara) == false);
588 }
589
590 /*
591 * @tc.name: PROCESS_SYNC_OFFLINE_FINISH_TEST_001
592 * @tc.desc: process sync offline finish test
593 * @tc.type: FUNC
594 * @tc.require:
595 */
596 HWTEST_F(LNNNetBuilderMockTest, PROCESS_SYNC_OFFLINE_FINISH_TEST_001, TestSize.Level1)
597 {
598 void *para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(char) * NETWORK_ID_BUF_LEN));
599 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
600 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
601 EXPECT_TRUE(ProcessSyncOfflineFinish(nullptr) == SOFTBUS_INVALID_PARAM);
602 EXPECT_TRUE(ProcessSyncOfflineFinish(para) == SOFTBUS_OK);
603 }
604
605 /*
606 * @tc.name: PROCESS_LEAVE_LNN_REQUEST_TEST_001
607 * @tc.desc: process leave lnn request test
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_LNN_REQUEST_TEST_001, TestSize.Level1)
612 {
613 void *para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(char) * NETWORK_ID_BUF_LEN));
614 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
615 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
616 EXPECT_CALL(NetBuilderMock, LnnNotifyLeaveResult(_, _)).WillRepeatedly(Return());
617 EXPECT_TRUE(ProcessLeaveLNNRequest(nullptr) == SOFTBUS_INVALID_PARAM);
618 EXPECT_TRUE(ProcessLeaveLNNRequest(para) == SOFTBUS_NETWORK_NOT_FOUND);
619 }
620
621 /*
622 * @tc.name: PROCESS_DEVICE_NOT_TRUSTED_TEST_001
623 * @tc.desc: process device not trusted test
624 * @tc.type: FUNC
625 * @tc.require:
626 */
627 HWTEST_F(LNNNetBuilderMockTest, PROCESS_DEVICE_NOT_TRUSTED_TEST_001, TestSize.Level1)
628 {
629 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
630 EXPECT_CALL(NetBuilderMock, LnnGetNetworkIdByUdid(_, _, _)).WillOnce(Return(SOFTBUS_INVALID_PARAM));
631 const char *peerUdid = NODE_UDID;
632 LnnDeleteLinkFinderInfo(peerUdid);
633 EXPECT_CALL(NetBuilderMock, LnnGetNetworkIdByUdid(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
634 LnnDeleteLinkFinderInfo(peerUdid);
635 EXPECT_TRUE(ProcessDeviceNotTrusted(nullptr) == SOFTBUS_INVALID_PARAM);
636 }
637
638 /*
639 * @tc.name: PROCESS_DEVICE_DISCONNECT_TEST_001
640 * @tc.desc: process device disconnect test
641 * @tc.type: FUNC
642 * @tc.require:
643 */
644 HWTEST_F(LNNNetBuilderMockTest, PROCESS_DEVICE_DISCONNECT_TEST_001, TestSize.Level1)
645 {
646 void *para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(int64_t)));
647 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
648 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
649 EXPECT_TRUE(ProcessDeviceDisconnect(nullptr) == SOFTBUS_INVALID_PARAM);
650 EXPECT_TRUE(ProcessDeviceDisconnect(para) != SOFTBUS_OK);
651 }
652
653 /*
654 * @tc.name: PROCESS_DEVICE_VERIFY_PASS_TEST_001
655 * @tc.desc: process device verify pass test
656 * @tc.type: FUNC
657 * @tc.require:
658 */
659 HWTEST_F(LNNNetBuilderMockTest, PROCESS_DEVICE_VERIFY_PASS_TEST_001, TestSize.Level1)
660 {
661 DeviceVerifyPassMsgPara *msgPara =
662 reinterpret_cast<DeviceVerifyPassMsgPara *>(SoftBusMalloc(sizeof(DeviceVerifyPassMsgPara)));
663 msgPara->nodeInfo = nullptr;
664 void *para = reinterpret_cast<void *>(msgPara);
665 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
666 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
667 EXPECT_TRUE(ProcessDeviceVerifyPass(nullptr) == SOFTBUS_INVALID_PARAM);
668 EXPECT_TRUE(ProcessDeviceVerifyPass(para) == SOFTBUS_INVALID_PARAM);
669 }
670
671 /*
672 * @tc.name: PROCESS_VERIFY_RESULT_TEST_001
673 * @tc.desc: process verify result test
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(LNNNetBuilderMockTest, PROCESS_VERIFY_RESULT_TEST_001, TestSize.Level1)
678 {
679 VerifyResultMsgPara *msgPara1 = reinterpret_cast<VerifyResultMsgPara *>(SoftBusMalloc(sizeof(VerifyResultMsgPara)));
680 msgPara1->nodeInfo = nullptr;
681 void *para1 = reinterpret_cast<void *>(msgPara1);
682 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
683 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
684 EXPECT_TRUE(ProcessVerifyResult(nullptr) == SOFTBUS_INVALID_PARAM);
685 EXPECT_TRUE(ProcessVerifyResult(para1) != SOFTBUS_OK);
686 VerifyResultMsgPara *msgPara2 = reinterpret_cast<VerifyResultMsgPara *>(SoftBusMalloc(sizeof(VerifyResultMsgPara)));
687 msgPara2->nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
688 void *para2 = reinterpret_cast<void *>(msgPara2);
689 EXPECT_TRUE(ProcessVerifyResult(para2) != SOFTBUS_OK);
690 }
691
692 /*
693 * @tc.name: PROCESS_CLEAN_CONNECTION_FSM_TEST_001
694 * @tc.desc: process clean connection fsm test
695 * @tc.type: FUNC
696 * @tc.require:
697 */
698 HWTEST_F(LNNNetBuilderMockTest, PROCESS_CLEAN_CONNECTION_FSM_TEST_001, TestSize.Level1)
699 {
700 void *para = reinterpret_cast<void *>(SoftBusMalloc(sizeof(uint16_t)));
701 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
702 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
703 EXPECT_TRUE(ProcessCleanConnectionFsm(nullptr) == SOFTBUS_INVALID_PARAM);
704 EXPECT_TRUE(ProcessCleanConnectionFsm(para) == SOFTBUS_NETWORK_FSM_CLEAN_FAILED);
705 }
706
707 /*
708 * @tc.name: IS_NODE_ONLINE_TEST_001
709 * @tc.desc: is node online test
710 * @tc.type: FUNC
711 * @tc.require:
712 */
713 HWTEST_F(LNNNetBuilderMockTest, IS_NODE_ONLINE_TEST_001, TestSize.Level1)
714 {
715 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
716 EXPECT_CALL(NetBuilderMock, LnnGetOnlineStateById(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
717 bool ret = IsNodeOnline(NODE_NETWORK_ID);
718 EXPECT_TRUE(ret == false);
719 ret = IsNodeOnline(NODE_NETWORK_ID);
720 EXPECT_TRUE(ret == true);
721 ret = IsNodeOnline(NODE_NETWORK_ID);
722 EXPECT_TRUE(ret == true);
723 }
724
725 /*
726 * @tc.name: UPDATE_LOCAL_NODE_TEST_001
727 * @tc.desc: update local node test
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 HWTEST_F(LNNNetBuilderMockTest, UPDATE_LOCAL_NODE_TEST_001, TestSize.Level1)
732 {
733 bool isCurrentNode = false;
734
735 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
736 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND));
737 UpdateLocalMasterNode(isCurrentNode, NODE_UDID, LOCAL_WEIGHT);
738
739 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillOnce(Return(SOFTBUS_OK));
740 EXPECT_CALL(NetBuilderMock, LnnSetLocalNumInfo(_, _)).WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND));
741 EXPECT_CALL(NetBuilderMock, LnnNotifyMasterNodeChanged(_, _, _)).WillOnce(Return());
742 UpdateLocalMasterNode(isCurrentNode, NODE_UDID, LOCAL_WEIGHT);
743
744 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillOnce(Return(SOFTBUS_OK));
745 EXPECT_CALL(NetBuilderMock, LnnSetLocalNumInfo(_, _)).WillOnce(Return(SOFTBUS_OK));
746 EXPECT_CALL(NetBuilderMock, LnnNotifyMasterNodeChanged(_, _, _)).WillOnce(Return());
747 UpdateLocalMasterNode(isCurrentNode, NODE_UDID, LOCAL_WEIGHT);
748 }
749
750 /*
751 * @tc.name: DUP_NODE_INFO_TEST_001
752 * @tc.desc: dup node info test
753 * @tc.type: FUNC
754 * @tc.require:
755 */
756 HWTEST_F(LNNNetBuilderMockTest, DUP_NODE_INFO_TEST_001, TestSize.Level1)
757 {
758 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
759 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
760 NetBuilderConfigInit();
761 NodeInfo info;
762 NodeInfo *ret = nullptr;
763 ret = DupNodeInfo(&info);
764 EXPECT_TRUE(ret != nullptr);
765 if (ret != nullptr) {
766 SoftBusFree(ret);
767 }
768 CleanConnectionFsm(nullptr);
769 EXPECT_TRUE(CreateNetworkIdMsgPara(nullptr) == nullptr);
770 EXPECT_TRUE(CreateConnectionAddrMsgPara(nullptr) == nullptr);
771 }
772
773 /*
774 * @tc.name: FIND_CONNECTION_FSM_TEST_001
775 * @tc.desc: net builder config init test
776 * @tc.type: FUNC
777 * @tc.require:
778 */
779 HWTEST_F(LNNNetBuilderMockTest, FIND_CONNECTION_FSM_TEST_001, TestSize.Level1)
780 {
781 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
782 ListInit(&connFsm->node);
783 (void)strcpy_s(connFsm->connInfo.addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
784 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
785 connFsm->connInfo.addr.type = CONNECTION_ADDR_BR;
786 connFsm->connInfo.requestId = REQUEST_ID;
787 connFsm->connInfo.authHandle.authId = AUTH_ID;
788 connFsm->connInfo.authHandle.type = AUTH_LINK_TYPE_BR;
789 connFsm->id = FSM_ID;
790 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
791 MetaJoinRequestNode *requestNode =
792 reinterpret_cast<MetaJoinRequestNode *>(SoftBusMalloc(sizeof(MetaJoinRequestNode)));
793 ListInit(&requestNode->node);
794 (void)strcpy_s(requestNode->addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
795 requestNode->requestId = REQUEST_ID;
796
797 ConnectionAddr addr;
798 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
799 (void)memset_s(&addr, sizeof(ConnectionAddr), 0, sizeof(ConnectionAddr));
800 (void)strcpy_s(addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
801 addr.type = CONNECTION_ADDR_BR;
802 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillOnce(Return(true));
803 EXPECT_TRUE(FindConnectionFsmByAddr(&addr, false) != nullptr);
804 addr.type = CONNECTION_ADDR_BLE;
805 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillOnce(Return(false));
806 EXPECT_TRUE(FindConnectionFsmByAddr(&addr, false) == nullptr);
807
808 EXPECT_TRUE(FindConnectionFsmByRequestId(REQUEST_ID) != nullptr);
809 EXPECT_TRUE(FindConnectionFsmByRequestId(REQUEST_ID_ADD) == nullptr);
810 AuthHandle authHandle = { .authId = AUTH_ID, .type = AUTH_LINK_TYPE_BR };
811 AuthHandle authHandle2 = { .authId = AUTH_ID_ADD, .type = AUTH_LINK_TYPE_WIFI };
812 EXPECT_TRUE(FindConnectionFsmByAuthHandle(&authHandle) != nullptr);
813 EXPECT_TRUE(FindConnectionFsmByAuthHandle(&authHandle2) == nullptr);
814 EXPECT_TRUE(FindConnectionFsmByNetworkId(NODE_NETWORK_ID) != nullptr);
815 EXPECT_TRUE(FindConnectionFsmByNetworkId(NODE1_NETWORK_ID) == nullptr);
816 EXPECT_TRUE(FindConnectionFsmByConnFsmId(FSM_ID) != nullptr);
817 EXPECT_TRUE(FindConnectionFsmByConnFsmId(FSM_ID_ADD) == nullptr);
818
819 ListDelete(&connFsm->node);
820 ListDelete(&requestNode->node);
821 SoftBusFree(connFsm);
822 SoftBusFree(requestNode);
823 }
824
825 /*
826 * @tc.name: SEND_ELECT_MESSAGE_TO_ALL_TEST_001
827 * @tc.desc: send elect message to all test
828 * @tc.type: FUNC
829 * @tc.require:
830 */
831 HWTEST_F(LNNNetBuilderMockTest, SEND_ELECT_MESSAGE_TO_ALL_TEST_001, TestSize.Level1)
832 {
833 ClearNetBuilderFsmList();
834 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
835 ListInit(&connFsm->node);
836 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
837 connFsm->isDead = false;
838 connFsm->connInfo.flag = CONN_FLAG1;
839 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
840 g_netBuilder.maxConcurrentCount = 0;
841 EXPECT_EQ(false, NeedPendingJoinRequest());
842 g_netBuilder.maxConcurrentCount = 1;
843 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
844 EXPECT_CALL(NetBuilderMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
845 SendElectMessageToAll(NODE1_NETWORK_ID);
846 SendElectMessageToAll(NODE1_NETWORK_ID);
847 EXPECT_TRUE(NeedPendingJoinRequest() == false);
848 LnnConnectionFsm *connFsm1 = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
849 ListInit(&connFsm1->node);
850 (void)strcpy_s(connFsm1->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
851 connFsm1->isDead = true;
852 connFsm1->connInfo.flag = CONN_FLAG3;
853 ListAdd(&g_netBuilder.fsmList, &connFsm1->node);
854 EXPECT_TRUE(NeedPendingJoinRequest() == false);
855 ClearNetBuilderFsmList();
856 }
857
858 /*
859 * @tc.name: SEND_ELECT_MESSAGE_TO_ALL_TEST_002
860 * @tc.desc: send elect message to all test
861 * @tc.type: FUNC
862 * @tc.require:
863 */
864 HWTEST_F(LNNNetBuilderMockTest, SEND_ELECT_MESSAGE_TO_ALL_TEST_002, TestSize.Level1)
865 {
866 LnnConnectionFsm *connFsm = nullptr;
867 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
868 EXPECT_TRUE(connFsm != nullptr);
869 ListInit(&connFsm->node);
870 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
871 connFsm->isDead = false;
872 connFsm->connInfo.flag = CONN_FLAG1;
873 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
874 g_netBuilder.maxConcurrentCount = 1;
875 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
876 EXPECT_CALL(NetBuilderMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
877 EXPECT_CALL(NetBuilderMock, LnnGetRemoteNodeInfoById)
878 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
879 .WillRepeatedly(Return(SOFTBUS_OK));
880 EXPECT_CALL(NetBuilderMock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
881 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo)
882 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
883 .WillRepeatedly(Return(SOFTBUS_OK));
884 EXPECT_CALL(NetBuilderMock, LnnGetLocalNumInfo)
885 .WillOnce(Return(SOFTBUS_NETWORK_NOT_FOUND))
886 .WillRepeatedly(Return(SOFTBUS_OK));
887 EXPECT_CALL(NetBuilderMock, AddStringToJsonObject).WillOnce(Return(true)).WillRepeatedly(Return(false));
888 EXPECT_CALL(NetBuilderMock, AddNumberToJsonObject).WillOnce(Return(true)).WillRepeatedly(Return(false));
889 EXPECT_CALL(NetBuilderMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
890 SendElectMessageToAll(NODE1_NETWORK_ID);
891 SendElectMessageToAll(NODE1_NETWORK_ID);
892 SendElectMessageToAll(NODE1_NETWORK_ID);
893 SendElectMessageToAll(NODE1_NETWORK_ID);
894 SendElectMessageToAll(NODE1_NETWORK_ID);
895 SendElectMessageToAll(NODE1_NETWORK_ID);
896 SendElectMessageToAll(NODE1_NETWORK_ID);
897 EXPECT_TRUE(NeedPendingJoinRequest() == false);
898 ListDelete(&connFsm->node);
899 SoftBusFree(connFsm);
900 }
901
902 /*
903 * @tc.name: INITIATE_NEW_NETWORK_ONLINE_TEST_001
904 * @tc.desc: initiate new network online test
905 * @tc.type: FUNC
906 * @tc.require:
907 */
908 HWTEST_F(LNNNetBuilderMockTest, INITIATE_NEW_NETWORK_ONLINE_TEST_001, TestSize.Level1)
909 {
910 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
911 ListInit(&connFsm->node);
912 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
913 connFsm->connInfo.addr.type = CONNECTION_ADDR_BR;
914 connFsm->isDead = false;
915 connFsm->connInfo.flag = CONN_FLAG2;
916 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
917
918 InitiateNewNetworkOnline(CONNECTION_ADDR_MAX, NODE1_NETWORK_ID);
919 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
920 EXPECT_CALL(NetBuilderMock, LnnSendNewNetworkOnlineToConnFsm(_)).WillOnce(Return(SOFTBUS_OK));
921 InitiateNewNetworkOnline(CONNECTION_ADDR_MAX, NODE_NETWORK_ID);
922
923 EXPECT_CALL(NetBuilderMock, LnnSendNewNetworkOnlineToConnFsm(_)).WillOnce(Return(SOFTBUS_OK));
924 InitiateNewNetworkOnline(CONNECTION_ADDR_BR, NODE_NETWORK_ID);
925 InitiateNewNetworkOnline(CONNECTION_ADDR_BLE, NODE_NETWORK_ID);
926 ListDelete(&connFsm->node);
927 SoftBusFree(connFsm);
928 }
929
930 /*
931 * @tc.name: TRY_DISCONNECT_ALL_CONNECTION_TEST_001
932 * @tc.desc: tyr disconnect all connection test
933 * @tc.type: FUNC
934 * @tc.require:
935 */
936 HWTEST_F(LNNNetBuilderMockTest, TRY_DISCONNECT_ALL_CONNECTION_TEST_001, TestSize.Level1)
937 {
938 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
939 ListInit(&connFsm->node);
940 (void)strcpy_s(connFsm->connInfo.addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
941 connFsm->connInfo.addr.type = CONNECTION_ADDR_BR;
942 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
943
944 LnnConnectionFsm fsmTest;
945 (void)memset_s(&fsmTest, sizeof(LnnConnectionFsm), 0, sizeof(LnnConnectionFsm));
946 fsmTest.connInfo.flag = 1;
947 TryDisconnectAllConnection(&fsmTest);
948
949 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
950 EXPECT_CALL(NetBuilderMock, LnnConvertAddrToOption(_, _)).WillOnce(Return(false));
951 fsmTest.connInfo.flag = CONN_FLAG1;
952 fsmTest.connInfo.addr.type = CONNECTION_ADDR_BLE;
953 TryDisconnectAllConnection(&fsmTest);
954
955 EXPECT_CALL(NetBuilderMock, LnnConvertAddrToOption(_, _)).WillOnce(Return(true));
956 TryDisconnectAllConnection(&fsmTest);
957
958 fsmTest.connInfo.addr.type = CONNECTION_ADDR_BR;
959 (void)strcpy_s(fsmTest.connInfo.addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
960 TryDisconnectAllConnection(&fsmTest);
961
962 (void)strcpy_s(fsmTest.connInfo.addr.info.br.brMac, BT_MAC_LEN, NODE2_BR_MAC);
963 TryDisconnectAllConnection(&fsmTest);
964 ListDelete(&connFsm->node);
965 SoftBusFree(connFsm);
966 }
967
968 /*
969 * @tc.name: TRY_DISCONNECT_ALL_CONNECTION_TEST_003
970 * @tc.desc: tyr disconnect all connection test
971 * @tc.type: FUNC
972 * @tc.require:
973 */
974 HWTEST_F(LNNNetBuilderMockTest, TRY_DISCONNECT_ALL_CONNECTION_TEST_002, TestSize.Level1)
975 {
976 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
977 ListInit(&connFsm->node);
978 (void)strcpy_s(connFsm->connInfo.addr.info.ip.ip, IP_STR_MAX_LEN, NODE1_IP);
979 connFsm->connInfo.addr.type = CONNECTION_ADDR_WLAN;
980 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
981
982 LnnConnectionFsm fsmTest;
983 (void)memset_s(&fsmTest, sizeof(LnnConnectionFsm), 0, sizeof(LnnConnectionFsm));
984 fsmTest.connInfo.flag = CONN_FLAG1;
985 fsmTest.connInfo.addr.type = CONNECTION_ADDR_WLAN;
986 (void)strcpy_s(fsmTest.connInfo.addr.info.ip.ip, IP_STR_MAX_LEN, NODE2_IP);
987
988 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
989 EXPECT_CALL(NetBuilderMock, LnnConvertAddrToOption(_, _)).WillOnce(Return(false));
990 TryDisconnectAllConnection(&fsmTest);
991 TryNotifyAllTypeOffline(&fsmTest);
992
993 (void)strcpy_s(fsmTest.connInfo.addr.info.ip.ip, IP_STR_MAX_LEN, NODE1_IP);
994 TryDisconnectAllConnection(&fsmTest);
995 TryNotifyAllTypeOffline(&fsmTest);
996
997 ListDelete(&connFsm->node);
998 SoftBusFree(connFsm);
999 }
1000
1001 /*
1002 * @tc.name: PROCESS_VERIFY_RESULT_TEST_002
1003 * @tc.desc: process verify result test
1004 * @tc.type: FUNC
1005 * @tc.require:
1006 */
1007 HWTEST_F(LNNNetBuilderMockTest, PROCESS_VERIFY_RESULT_TEST_002, TestSize.Level1)
1008 {
1009 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1010 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1011 VerifyResultMsgPara *msgPara = reinterpret_cast<VerifyResultMsgPara *>(SoftBusMalloc(sizeof(VerifyResultMsgPara)));
1012 msgPara->nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
1013 msgPara->requestId = REQUEST_ID;
1014 void *para = reinterpret_cast<void *>(msgPara);
1015
1016 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1017 ListInit(&connFsm->node);
1018 connFsm->connInfo.requestId = REQUEST_ID;
1019 connFsm->isDead = true;
1020 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1021 EXPECT_TRUE(ProcessVerifyResult(para) != SOFTBUS_OK);
1022 ListDelete(&connFsm->node);
1023 SoftBusFree(connFsm);
1024 }
1025
1026 /*
1027 * @tc.name: PROCESS_VERIFY_RESULT_TEST_003
1028 * @tc.desc: process verify result test
1029 * @tc.type: FUNC
1030 * @tc.require:
1031 */
1032 HWTEST_F(LNNNetBuilderMockTest, PROCESS_VERIFY_RESULT_TEST_003, TestSize.Level1)
1033 {
1034 VerifyResultMsgPara *msgPara = reinterpret_cast<VerifyResultMsgPara *>(SoftBusMalloc(sizeof(VerifyResultMsgPara)));
1035 msgPara->nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
1036 msgPara->requestId = REQUEST_ID;
1037 msgPara->retCode = SOFTBUS_INVALID_PARAM;
1038 void *para = reinterpret_cast<void *>(msgPara);
1039
1040 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1041 ListInit(&connFsm->node);
1042 connFsm->connInfo.requestId = REQUEST_ID;
1043 connFsm->isDead = false;
1044 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1045
1046 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1047 EXPECT_CALL(NetBuilderMock, LnnSendAuthResultMsgToConnFsm(_, _)).WillOnce(Return(SOFTBUS_INVALID_PARAM));
1048 EXPECT_TRUE(ProcessVerifyResult(para) == SOFTBUS_INVALID_PARAM);
1049 ListDelete(&connFsm->node);
1050 SoftBusFree(connFsm);
1051 }
1052
1053 /*
1054 * @tc.name: PROCESS_VERIFY_RESULT_TEST_004
1055 * @tc.desc: process verify result test
1056 * @tc.type: FUNC
1057 * @tc.require:
1058 */
1059 HWTEST_F(LNNNetBuilderMockTest, PROCESS_VERIFY_RESULT_TEST_004, TestSize.Level1)
1060 {
1061 VerifyResultMsgPara *msgPara = reinterpret_cast<VerifyResultMsgPara *>(SoftBusMalloc(sizeof(VerifyResultMsgPara)));
1062 msgPara->nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
1063 msgPara->requestId = REQUEST_ID;
1064 msgPara->retCode = SOFTBUS_INVALID_PARAM;
1065 void *para = reinterpret_cast<void *>(msgPara);
1066 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1067 ListInit(&connFsm->node);
1068 connFsm->connInfo.requestId = REQUEST_ID;
1069 connFsm->isDead = false;
1070 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1071 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1072 EXPECT_CALL(NetBuilderMock, LnnSendAuthResultMsgToConnFsm(_, _)).WillOnce(Return(SOFTBUS_OK));
1073 EXPECT_TRUE(ProcessVerifyResult(para) == SOFTBUS_OK);
1074 ListDelete(&connFsm->node);
1075 SoftBusFree(connFsm);
1076 }
1077
1078 /*
1079 * @tc.name: PROCESS_DEVICE_VERIFY_PASS_TEST_002
1080 * @tc.desc: process device verify pass test
1081 * @tc.type: FUNC
1082 * @tc.require:
1083 */
1084 HWTEST_F(LNNNetBuilderMockTest, PROCESS_DEVICE_VERIFY_PASS_TEST_002, TestSize.Level1)
1085 {
1086 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1087 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1088 DeviceVerifyPassMsgPara *msgPara =
1089 reinterpret_cast<DeviceVerifyPassMsgPara *>(SoftBusMalloc(sizeof(DeviceVerifyPassMsgPara)));
1090 msgPara->nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
1091 (void)strcpy_s(msgPara->nodeInfo->networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1092 msgPara->authHandle.authId = AUTH_ID;
1093
1094 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1095 ListInit(&connFsm->node);
1096 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1097 connFsm->connInfo.authHandle.authId = AUTH_ID_ADD;
1098 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1099 g_netBuilder.connCount = CURRENT_COUNT;
1100 g_netBuilder.maxConnCount = CONN_COUNT;
1101 void *para = reinterpret_cast<void *>(msgPara);
1102 EXPECT_TRUE(ProcessDeviceVerifyPass(para) == SOFTBUS_NETWORK_FSM_START_FAIL);
1103 ListDelete(&connFsm->node);
1104 SoftBusFree(connFsm);
1105 }
1106
1107 /*
1108 * @tc.name: PROCESS_DEVICE_VERIFY_PASS_TEST_003
1109 * @tc.desc: process device verify pass test
1110 * @tc.type: FUNC
1111 * @tc.require:
1112 */
1113 HWTEST_F(LNNNetBuilderMockTest, PROCESS_DEVICE_VERIFY_PASS_TEST_003, TestSize.Level1)
1114 {
1115 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1116 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1117 DeviceVerifyPassMsgPara *msgPara =
1118 reinterpret_cast<DeviceVerifyPassMsgPara *>(SoftBusMalloc(sizeof(DeviceVerifyPassMsgPara)));
1119 msgPara->nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
1120 (void)strcpy_s(msgPara->nodeInfo->networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1121 msgPara->authHandle.authId = AUTH_ID;
1122
1123 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1124 ListInit(&connFsm->node);
1125 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1126 connFsm->connInfo.authHandle.authId = AUTH_ID;
1127 connFsm->isDead = true;
1128 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1129 g_netBuilder.connCount = CURRENT_COUNT;
1130 g_netBuilder.maxConnCount = CONN_COUNT;
1131 void *para = reinterpret_cast<void *>(msgPara);
1132 EXPECT_TRUE(ProcessDeviceVerifyPass(para) == SOFTBUS_NETWORK_FSM_START_FAIL);
1133 ListDelete(&connFsm->node);
1134 SoftBusFree(connFsm);
1135 }
1136
1137 /*
1138 * @tc.name: PROCESS_DEVICE_VERIFY_PASS_TEST_004
1139 * @tc.desc: process device verify pass test
1140 * @tc.type: FUNC
1141 * @tc.require:
1142 */
1143 HWTEST_F(LNNNetBuilderMockTest, PROCESS_DEVICE_VERIFY_PASS_TEST_004, TestSize.Level1)
1144 {
1145 DeviceVerifyPassMsgPara *msgPara =
1146 reinterpret_cast<DeviceVerifyPassMsgPara *>(SoftBusMalloc(sizeof(DeviceVerifyPassMsgPara)));
1147 msgPara->nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
1148 (void)strcpy_s(msgPara->nodeInfo->networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1149 msgPara->authHandle.authId = AUTH_ID;
1150
1151 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1152 ListInit(&connFsm->node);
1153 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1154 connFsm->connInfo.authHandle.authId = AUTH_ID;
1155 connFsm->isDead = false;
1156 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1157
1158 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1159 void *para = reinterpret_cast<void *>(msgPara);
1160 EXPECT_TRUE(ProcessDeviceVerifyPass(para) != SOFTBUS_OK);
1161 ListDelete(&connFsm->node);
1162 SoftBusFree(connFsm);
1163 }
1164
1165 /*
1166 * @tc.name: PROCESS_DEVICE_NOT_TRUSTED_TEST_002
1167 * @tc.desc: process device not trusted test
1168 * @tc.type: FUNC
1169 * @tc.require:
1170 */
1171 HWTEST_F(LNNNetBuilderMockTest, PROCESS_DEVICE_NOT_TRUSTED_TEST_002, TestSize.Level1)
1172 {
1173 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1174 void *msgPara = reinterpret_cast<void *>(SoftBusMalloc(sizeof(char) * UDID_BUF_LEN));
1175 EXPECT_CALL(NetBuilderMock, LnnGetNetworkIdByUdid(_, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1176 EXPECT_CALL(NetBuilderMock, LnnGetDeviceUdid(_)).WillRepeatedly(Return(nullptr));
1177
1178 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1179 ListInit(&connFsm->node);
1180 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1181 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1182
1183 void *para = reinterpret_cast<void *>(msgPara);
1184 EXPECT_TRUE(ProcessDeviceNotTrusted(para) == SOFTBUS_OK);
1185 ListDelete(&connFsm->node);
1186 SoftBusFree(connFsm);
1187 }
1188
1189 /*
1190 * @tc.name: PROCESS_LEAVE_LNN_REQUEST_TEST_002
1191 * @tc.desc: process leave lnn request test
1192 * @tc.type: FUNC
1193 * @tc.require:
1194 */
1195 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_LNN_REQUEST_TEST_002, TestSize.Level1)
1196 {
1197 char *msgPara = reinterpret_cast<char *>(SoftBusMalloc(sizeof(char) * NETWORK_ID_BUF_LEN));
1198 (void)strcpy_s(msgPara, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
1199
1200 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1201 ListInit(&connFsm->node);
1202 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1203 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1204
1205 void *para = reinterpret_cast<void *>(msgPara);
1206 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1207 EXPECT_CALL(NetBuilderMock, LnnNotifyLeaveResult(_, _)).WillRepeatedly(Return());
1208 EXPECT_TRUE(ProcessLeaveLNNRequest(para) == SOFTBUS_NETWORK_NOT_FOUND);
1209 ListDelete(&connFsm->node);
1210 SoftBusFree(connFsm);
1211 }
1212
1213 /*
1214 * @tc.name: PROCESS_LEAVE_LNN_REQUEST_TEST_003
1215 * @tc.desc: process leave lnn request test
1216 * @tc.type: FUNC
1217 * @tc.require:
1218 */
1219 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_LNN_REQUEST_TEST_003, TestSize.Level1)
1220 {
1221 char *msgPara = reinterpret_cast<char *>(SoftBusMalloc(sizeof(char) * NETWORK_ID_BUF_LEN));
1222 (void)strcpy_s(msgPara, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1223
1224 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1225 ListInit(&connFsm->node);
1226 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1227 connFsm->isDead = true;
1228 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1229
1230 void *para = reinterpret_cast<void *>(msgPara);
1231 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1232 EXPECT_CALL(NetBuilderMock, LnnNotifyLeaveResult(_, _)).WillRepeatedly(Return());
1233 EXPECT_TRUE(ProcessLeaveLNNRequest(para) == SOFTBUS_NETWORK_NOT_FOUND);
1234 ListDelete(&connFsm->node);
1235 SoftBusFree(connFsm);
1236 }
1237
1238 /*
1239 * @tc.name: PROCESS_LEAVE_LNN_REQUEST_TEST_004
1240 * @tc.desc: process leave lnn request test
1241 * @tc.type: FUNC
1242 * @tc.require:
1243 */
1244 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_LNN_REQUEST_TEST_004, TestSize.Level1)
1245 {
1246 char *msgPara = reinterpret_cast<char *>(SoftBusMalloc(sizeof(char) * NETWORK_ID_BUF_LEN));
1247 (void)strcpy_s(msgPara, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1248
1249 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1250 ListInit(&connFsm->node);
1251 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1252 connFsm->isDead = false;
1253 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1254
1255 void *para = reinterpret_cast<void *>(msgPara);
1256 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1257 EXPECT_CALL(NetBuilderMock, LnnNotifyLeaveResult(_, _)).WillRepeatedly(Return());
1258 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_OK));
1259 EXPECT_TRUE(ProcessLeaveLNNRequest(para) == SOFTBUS_OK);
1260 ListDelete(&connFsm->node);
1261 SoftBusFree(connFsm);
1262 }
1263
1264 /*
1265 * @tc.name: PROCESS_SYNC_OFFLINE_FINISH_TEST_002
1266 * @tc.desc: process sync offline finish test
1267 * @tc.type: FUNC
1268 * @tc.require:
1269 */
1270 HWTEST_F(LNNNetBuilderMockTest, PROCESS_SYNC_OFFLINE_FINISH_TEST_002, TestSize.Level1)
1271 {
1272 char *msgPara = reinterpret_cast<char *>(SoftBusMalloc(sizeof(char) * NETWORK_ID_BUF_LEN));
1273 (void)strcpy_s(msgPara, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
1274
1275 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1276 ListInit(&connFsm->node);
1277 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1278 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1279
1280 void *para = reinterpret_cast<void *>(msgPara);
1281 EXPECT_TRUE(ProcessSyncOfflineFinish(para) == SOFTBUS_OK);
1282 ListDelete(&connFsm->node);
1283 SoftBusFree(connFsm);
1284 }
1285
1286 /*
1287 * @tc.name: PROCESS_SYNC_OFFLINE_FINISH_TEST_003
1288 * @tc.desc: process sync offline finish test
1289 * @tc.type: FUNC
1290 * @tc.require:
1291 */
1292 HWTEST_F(LNNNetBuilderMockTest, PROCESS_SYNC_OFFLINE_FINISH_TEST_003, TestSize.Level1)
1293 {
1294 char *msgPara = reinterpret_cast<char *>(SoftBusMalloc(sizeof(char) * NETWORK_ID_BUF_LEN));
1295 (void)strcpy_s(msgPara, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1296
1297 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1298 ListInit(&connFsm->node);
1299 connFsm->isDead = true;
1300 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1301 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1302
1303 void *para = reinterpret_cast<void *>(msgPara);
1304 EXPECT_TRUE(ProcessSyncOfflineFinish(para) == SOFTBUS_OK);
1305 ListDelete(&connFsm->node);
1306 SoftBusFree(connFsm);
1307 }
1308
1309 /*
1310 * @tc.name: PROCESS_LEAVE_SPECIFIC_TEST_002
1311 * @tc.desc: process leave specific test
1312 * @tc.type: FUNC
1313 * @tc.require:
1314 */
1315 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_SPECIFIC_TEST_002, TestSize.Level1)
1316 {
1317 SpecificLeaveMsgPara *msgPara =
1318 reinterpret_cast<SpecificLeaveMsgPara *>(SoftBusMalloc(sizeof(SpecificLeaveMsgPara)));
1319 (void)strcpy_s(msgPara->networkId, NETWORK_ID_BUF_LEN, NODE1_NETWORK_ID);
1320 msgPara->addrType = CONNECTION_ADDR_BLE;
1321
1322 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1323 ListInit(&connFsm->node);
1324 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1325 connFsm->connInfo.addr.type = CONNECTION_ADDR_BR;
1326 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1327
1328 void *para = reinterpret_cast<void *>(msgPara);
1329 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1330 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1331 EXPECT_TRUE(ProcessLeaveSpecific(para) == SOFTBUS_OK);
1332 ListDelete(&connFsm->node);
1333 SoftBusFree(connFsm);
1334 }
1335
1336 /*
1337 * @tc.name: PROCESS_LEAVE_SPECIFIC_TEST_003
1338 * @tc.desc: process leave specific test
1339 * @tc.type: FUNC
1340 * @tc.require:
1341 */
1342 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_SPECIFIC_TEST_003, TestSize.Level1)
1343 {
1344 SpecificLeaveMsgPara *msgPara =
1345 reinterpret_cast<SpecificLeaveMsgPara *>(SoftBusMalloc(sizeof(SpecificLeaveMsgPara)));
1346 (void)strcpy_s(msgPara->networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1347 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1348 ListInit(&connFsm->node);
1349 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1350 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1351
1352 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1353 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_OK));
1354 void *para = reinterpret_cast<void *>(msgPara);
1355 EXPECT_TRUE(ProcessLeaveSpecific(para) == SOFTBUS_OK);
1356 ListDelete(&connFsm->node);
1357 SoftBusFree(connFsm);
1358 }
1359
1360 /*
1361 * @tc.name: ON_LNN_PROCESS_NOT_TRUSTED_MSG_DELAY_TEST_001
1362 * @tc.desc: on lnn prodecc not trusted msg delay test
1363 * @tc.type: FUNC
1364 * @tc.require:
1365 */
1366 HWTEST_F(LNNNetBuilderMockTest, ON_LNN_PROCESS_NOT_TRUSTED_MSG_DELAY_TEST_001, TestSize.Level1)
1367 {
1368 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1369 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1370 OnLnnProcessNotTrustedMsgDelay(nullptr);
1371 void *para1 = reinterpret_cast<void *>(SoftBusMalloc(sizeof(NotTrustedDelayInfo)));
1372 EXPECT_CALL(NetBuilderMock, AuthGetLatestAuthSeqList(_, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1373 OnLnnProcessNotTrustedMsgDelay(para1);
1374
1375 void *para2 = reinterpret_cast<void *>(SoftBusMalloc(sizeof(NotTrustedDelayInfo)));
1376 EXPECT_CALL(NetBuilderMock, AuthGetLatestAuthSeqList(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1377 EXPECT_CALL(NetBuilderMock, LnnConvertDlId(_, _, _, _, _)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1378 OnLnnProcessNotTrustedMsgDelay(para2);
1379 }
1380
1381 /*
1382 * @tc.name: PROCESS_ELETE_TEST_002
1383 * @tc.desc: process elect test
1384 * @tc.type: FUNC
1385 * @tc.require:
1386 */
1387 HWTEST_F(LNNNetBuilderMockTest, PROCESS_ELETE_TEST_002, TestSize.Level1)
1388 {
1389 ElectMsgPara *msgPara = reinterpret_cast<ElectMsgPara *>(SoftBusMalloc(sizeof(ElectMsgPara)));
1390 (void)strcpy_s(msgPara->networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1391
1392 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1393 ListInit(&connFsm->node);
1394 connFsm->connInfo.version = SOFTBUS_NEW_V1;
1395 connFsm->isDead = false;
1396 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1397 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1398
1399 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1400 void *para = reinterpret_cast<void *>(msgPara);
1401
1402 EXPECT_CALL(NetBuilderMock, LnnGetOnlineStateById(_, _)).WillRepeatedly(Return(true));
1403 EXPECT_CALL(NetBuilderMock, LnnGetLocalStrInfo(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1404
1405 EXPECT_TRUE(ProcessMasterElect(para) == SOFTBUS_OK);
1406 ListDelete(&connFsm->node);
1407 SoftBusFree(connFsm);
1408 }
1409
1410 /*
1411 * @tc.name: TRY_SEND_JOIN_LNN_REQUEST_TEST_001
1412 * @tc.desc: try send join lnn request test
1413 * @tc.type: FUNC
1414 * @tc.require:
1415 */
1416 HWTEST_F(LNNNetBuilderMockTest, TRY_SEND_JOIN_LNN_REQUEST_TEST_001, TestSize.Level1)
1417 {
1418 JoinLnnMsgPara *para = nullptr;
1419 para = reinterpret_cast<JoinLnnMsgPara *>(SoftBusMalloc(sizeof(JoinLnnMsgPara)));
1420 EXPECT_TRUE(para != nullptr);
1421 LnnConnectionFsm *connFsm = nullptr;
1422 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1423 EXPECT_TRUE(connFsm != nullptr);
1424 ListInit(&connFsm->node);
1425 connFsm->connInfo.version = SOFTBUS_NEW_V1;
1426 connFsm->isDead = false;
1427 connFsm->connInfo.flag = CONN_FLAG3;
1428 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1429 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1430
1431 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1432 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillRepeatedly(Return(false));
1433 para->isNeedConnect = false;
1434 para->dupInfo = nullptr;
1435 (void)strcpy_s(para->pkgName, PKG_NAME_SIZE_MAX, "pkgName");
1436 EXPECT_TRUE(TrySendJoinLNNRequest(nullptr, true, false) == SOFTBUS_INVALID_PARAM);
1437 EXPECT_TRUE(TrySendJoinLNNRequest(para, true, false) == SOFTBUS_NETWORK_JOIN_REQUEST_ERR);
1438
1439 DfxRecordLnnAuthStart(nullptr, para, 0);
1440 ListDelete(&connFsm->node);
1441 SoftBusFree(connFsm);
1442 }
1443
1444 /*
1445 * @tc.name: TRY_SEND_JOIN_LNN_REQUEST_TEST_002
1446 * @tc.desc: try send join lnn request test
1447 * @tc.type: FUNC
1448 * @tc.require:
1449 */
1450 HWTEST_F(LNNNetBuilderMockTest, TRY_SEND_JOIN_LNN_REQUEST_TEST_002, TestSize.Level1)
1451 {
1452 JoinLnnMsgPara *para = nullptr;
1453 para = reinterpret_cast<JoinLnnMsgPara *>(SoftBusMalloc(sizeof(JoinLnnMsgPara)));
1454 EXPECT_TRUE(para != nullptr);
1455 LnnConnectionFsm *connFsm = nullptr;
1456 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1457 EXPECT_TRUE(connFsm != nullptr);
1458 ListInit(&connFsm->node);
1459 connFsm->connInfo.version = SOFTBUS_NEW_V1;
1460 connFsm->isDead = false;
1461 connFsm->connInfo.flag = CONN_FLAG3;
1462 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1463 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1464
1465 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1466 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillRepeatedly(Return(false));
1467 para->isNeedConnect = true;
1468 para->dupInfo = nullptr;
1469 (void)strcpy_s(para->pkgName, PKG_NAME_SIZE_MAX, "pkgName");
1470 EXPECT_TRUE(TrySendJoinLNNRequest(para, true, false) == SOFTBUS_OK);
1471
1472 ListDelete(&connFsm->node);
1473 SoftBusFree(connFsm);
1474 }
1475
1476 /*
1477 * @tc.name: TRY_SEND_JOIN_LNN_REQUEST_TEST_003
1478 * @tc.desc: try send join lnn request test
1479 * @tc.type: FUNC
1480 * @tc.require:
1481 */
1482 HWTEST_F(LNNNetBuilderMockTest, TRY_SEND_JOIN_LNN_REQUEST_TEST_003, TestSize.Level1)
1483 {
1484 JoinLnnMsgPara *para = nullptr;
1485 para = reinterpret_cast<JoinLnnMsgPara *>(SoftBusMalloc(sizeof(JoinLnnMsgPara)));
1486 EXPECT_TRUE(para != nullptr);
1487 LnnConnectionFsm *connFsm = nullptr;
1488 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1489 EXPECT_TRUE(connFsm != nullptr);
1490 ListInit(&connFsm->node);
1491 connFsm->connInfo.version = SOFTBUS_NEW_V1;
1492 connFsm->isDead = false;
1493 connFsm->connInfo.flag = CONN_FLAG3;
1494 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1495 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1496
1497 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1498 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillRepeatedly(Return(true));
1499 para->isNeedConnect = true;
1500 para->dupInfo = nullptr;
1501 (void)strcpy_s(para->pkgName, PKG_NAME_SIZE_MAX, "pkgName");
1502 EXPECT_TRUE(TrySendJoinLNNRequest(para, true, false) == SOFTBUS_OK);
1503
1504 ListDelete(&connFsm->node);
1505 SoftBusFree(connFsm);
1506 }
1507
1508 /*
1509 * @tc.name: TRY_SEND_JOIN_LNN_REQUEST_TEST_004
1510 * @tc.desc: try send join lnn request test
1511 * @tc.type: FUNC
1512 * @tc.require:
1513 */
1514 HWTEST_F(LNNNetBuilderMockTest, TRY_SEND_JOIN_LNN_REQUEST_TEST_004, TestSize.Level1)
1515 {
1516 JoinLnnMsgPara *para = nullptr;
1517 para = reinterpret_cast<JoinLnnMsgPara *>(SoftBusMalloc(sizeof(JoinLnnMsgPara)));
1518 EXPECT_TRUE(para != nullptr);
1519 LnnConnectionFsm *connFsm = nullptr;
1520 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1521 EXPECT_TRUE(connFsm != nullptr);
1522 ListInit(&connFsm->node);
1523 connFsm->connInfo.version = SOFTBUS_NEW_V1;
1524 connFsm->isDead = false;
1525 connFsm->connInfo.flag = CONN_FLAG2;
1526 (void)strcpy_s(connFsm->connInfo.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1527 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1528
1529 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1530 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillRepeatedly(Return(true));
1531 para->isNeedConnect = true;
1532 para->dupInfo = nullptr;
1533 (void)strcpy_s(para->pkgName, PKG_NAME_SIZE_MAX, "pkgName");
1534 EXPECT_TRUE(TrySendJoinLNNRequest(para, true, false) == SOFTBUS_OK);
1535
1536 ListDelete(&connFsm->node);
1537 SoftBusFree(connFsm);
1538 }
1539
1540 /*
1541 * @tc.name: LNN_PROCESS_COMPLETE_NOT_TRUSTED_MSG_TEST_001
1542 * @tc.desc: lnn process complete not trusted msg test
1543 * @tc.type: FUNC
1544 * @tc.require:
1545 */
1546 HWTEST_F(LNNNetBuilderMockTest, LNN_PROCESS_COMPLETE_NOT_TRUSTED_MSG_TEST_001, TestSize.Level1)
1547 {
1548 char jsonStr[] = "{\"1\":10}";
1549 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1550 EXPECT_CALL(NetBuilderMock, LnnGetOnlineStateById).WillOnce(Return(false)).WillRepeatedly(Return(true));
1551 EXPECT_CALL(NetBuilderMock, AuthGetLatestAuthSeqList)
1552 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
1553 .WillRepeatedly(Return(SOFTBUS_OK));
1554 LnnProcessCompleteNotTrustedMsg(LNN_INFO_TYPE_NOT_TRUSTED, nullptr, nullptr, 0);
1555 LnnProcessCompleteNotTrustedMsg(LNN_INFO_TYPE_WIFI_DIRECT, NODE_NETWORK_ID, nullptr, MSG_ERR_LEN0);
1556 LnnProcessCompleteNotTrustedMsg(LNN_INFO_TYPE_NOT_TRUSTED, NODE_NETWORK_ID, nullptr, MSG_ERR_LEN0);
1557 LnnProcessCompleteNotTrustedMsg(
1558 LNN_INFO_TYPE_NOT_TRUSTED, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr), MSG_ERR_LEN0);
1559 LnnProcessCompleteNotTrustedMsg(
1560 LNN_INFO_TYPE_NOT_TRUSTED, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr), MSG_ERR_LEN0);
1561 LnnProcessCompleteNotTrustedMsg(
1562 LNN_INFO_TYPE_NOT_TRUSTED, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr), strlen(jsonStr) + 1);
1563 LnnProcessCompleteNotTrustedMsg(
1564 LNN_INFO_TYPE_NOT_TRUSTED, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr), strlen(jsonStr) + 1);
1565 }
1566
1567 /*
1568 * @tc.name: ON_RE_AUTH_VERIFY_PASSED_TEST_001
1569 * @tc.desc: on re auth verify passed test
1570 * @tc.type: FUNC
1571 * @tc.require:
1572 */
1573 HWTEST_F(LNNNetBuilderMockTest, ON_RE_AUTH_VERIFY_PASSED_TEST_001, TestSize.Level1)
1574 {
1575 NodeInfo info;
1576 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1577 EXPECT_CALL(NetBuilderMock, GetAuthRequest)
1578 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
1579 .WillRepeatedly(Return(SOFTBUS_OK));
1580 EXPECT_CALL(NetBuilderMock, LnnConvertAuthConnInfoToAddr).WillOnce(Return(false)).WillRepeatedly(Return(true));
1581 AuthHandle authHandle = { .authId = AUTH_ID, .type = AUTH_LINK_TYPE_WIFI };
1582 OnReAuthVerifyPassed(REQUEST_ID, authHandle, nullptr);
1583 OnReAuthVerifyPassed(REQUEST_ID, authHandle, &info);
1584 OnReAuthVerifyPassed(REQUEST_ID, authHandle, &info);
1585 OnReAuthVerifyPassed(REQUEST_ID, authHandle, &info);
1586 }
1587
1588 /*
1589 * @tc.name: ON_RE_AUTH_VERIFY_PASSED_TEST_002
1590 * @tc.desc: on re auth verify passed test
1591 * @tc.type: FUNC
1592 * @tc.require:
1593 */
1594 HWTEST_F(LNNNetBuilderMockTest, ON_RE_AUTH_VERIFY_PASSED_TEST_002, TestSize.Level1)
1595 {
1596 LnnConnectionFsm *connFsm = nullptr;
1597 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1598 EXPECT_TRUE(connFsm != nullptr);
1599 ListInit(&connFsm->node);
1600 connFsm->connInfo.version = SOFTBUS_NEW_V1;
1601 connFsm->isDead = false;
1602 connFsm->connInfo.flag = CONN_FLAG2;
1603 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1604 NodeInfo info;
1605 (void)strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE_UDID);
1606
1607 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1608 EXPECT_CALL(NetBuilderMock, GetAuthRequest).WillRepeatedly(Return(SOFTBUS_OK));
1609 EXPECT_CALL(NetBuilderMock, LnnConvertAuthConnInfoToAddr).WillRepeatedly(Return(true));
1610 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
1611 AuthHandle authHandle = { .authId = AUTH_ID, .type = AUTH_LINK_TYPE_WIFI };
1612 OnReAuthVerifyPassed(REQUEST_ID, authHandle, &info);
1613 OnReAuthVerifyPassed(REQUEST_ID, authHandle, &info);
1614
1615 ListDelete(&connFsm->node);
1616 SoftBusFree(connFsm);
1617 }
1618
1619 /*
1620 * @tc.name: FIND_NODE_INFO_BY_RQUESTID_TEST_001
1621 * @tc.desc: find node info by rquestid test
1622 * @tc.type: FUNC
1623 * @tc.require:
1624 */
1625 HWTEST_F(LNNNetBuilderMockTest, FIND_NODE_INFO_BY_RQUESTID_TEST_001, TestSize.Level1)
1626 {
1627 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1628 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr(_, _, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
1629 LnnConnectionFsm *connFsm = nullptr;
1630 connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1631 EXPECT_TRUE(connFsm != nullptr);
1632 ListInit(&connFsm->node);
1633 connFsm->connInfo.requestId = REQUEST_ID;
1634 connFsm->isDead = false;
1635 connFsm->connInfo.nodeInfo = reinterpret_cast<NodeInfo *>(SoftBusMalloc(sizeof(NodeInfo)));
1636 EXPECT_TRUE(connFsm->connInfo.nodeInfo != nullptr);
1637 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1638
1639 ConnectionAddr addr;
1640 uint32_t requestId;
1641 int32_t ret = FindRequestIdByAddr(&addr, &requestId);
1642 EXPECT_TRUE(ret != SOFTBUS_OK);
1643 ret = FindRequestIdByAddr(&addr, &requestId);
1644 EXPECT_TRUE(ret == SOFTBUS_OK);
1645 NodeInfo *info = FindNodeInfoByRquestId(requestId);
1646 EXPECT_TRUE(info != nullptr);
1647
1648 ListDelete(&connFsm->node);
1649 SoftBusFree(connFsm->connInfo.nodeInfo);
1650 SoftBusFree(connFsm);
1651 }
1652
1653 /*
1654 * @tc.name: ON_RECEIVE_NODE_ADDR_CHANGED_MSG_TEST_001
1655 * @tc.desc: on receive node addr changed msg test
1656 * @tc.type: FUNC
1657 * @tc.require:
1658 */
1659 HWTEST_F(LNNNetBuilderMockTest, ON_RECEIVE_NODE_ADDR_CHANGED_MSG_TEST_001, TestSize.Level1)
1660 {
1661 char jsonStr1[] = "{\"NODE_CODE\":1111,\"NODE_ADDR\":\"127.0.0.1\",\"PROXY_PORT\":1000,\"SESSION_PORT\":1001}";
1662 char jsonStr2[] = "{\"NODE_ADDR\":\"127.0.0.1\",\"PROXY_PORT\":1000,\"SESSION_PORT\":1001}";
1663 char jsonStr3[] = "{\"NODE_CODE\":1111,\"PROXY_PORT\":1000,\"SESSION_PORT\":1001}";
1664 char jsonStr4[] = "{\"NODE_CODE\":1111,\"NODE_ADDR\":\"127.0.0.1\",\"SESSION_PORT\":1001}";
1665 char jsonStr5[] = "{\"NODE_CODE\":1111,\"NODE_ADDR\":\"127.0.0.1\",\"PROXY_PORT\":1000}";
1666 uint8_t jsonMsg6[] = { 0 };
1667 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1668 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
1669 OnReceiveNodeAddrChangedMsg(
1670 LNN_INFO_TYPE_DEVICE_NAME, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr1), MSG_ERR_LEN0);
1671 OnReceiveNodeAddrChangedMsg(
1672 LNN_INFO_TYPE_NODE_ADDR, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr1), MSG_ERR_LEN0);
1673 OnReceiveNodeAddrChangedMsg(LNN_INFO_TYPE_NODE_ADDR, NODE_NETWORK_ID, jsonMsg6, MSG_ERR_LEN1);
1674 OnReceiveNodeAddrChangedMsg(
1675 LNN_INFO_TYPE_NODE_ADDR, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr2), strlen(jsonStr2) + 1);
1676 OnReceiveNodeAddrChangedMsg(
1677 LNN_INFO_TYPE_NODE_ADDR, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr3), strlen(jsonStr3) + 1);
1678 OnReceiveNodeAddrChangedMsg(
1679 LNN_INFO_TYPE_NODE_ADDR, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr4), strlen(jsonStr4) + 1);
1680 OnReceiveNodeAddrChangedMsg(
1681 LNN_INFO_TYPE_NODE_ADDR, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr5), strlen(jsonStr5) + 1);
1682 OnReceiveNodeAddrChangedMsg(
1683 LNN_INFO_TYPE_NODE_ADDR, NODE_NETWORK_ID, reinterpret_cast<uint8_t *>(jsonStr1), strlen(jsonStr1) + 1);
1684 }
1685
1686 /*
1687 * @tc.name: ACCOUNT_STATE_CHANGE_HANDLER_TEST_001
1688 * @tc.desc: account state change handler test
1689 * @tc.type: FUNC
1690 * @tc.require:
1691 */
1692 HWTEST_F(LNNNetBuilderMockTest, ACCOUNT_STATE_CHANGE_HANDLER_TEST_001, TestSize.Level1)
1693 {
1694 LnnEventBasicInfo info;
1695 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1696 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
1697 EXPECT_CALL(NetBuilderMock, LnnGetAllOnlineNodeInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1698 AccountStateChangeHandler(nullptr);
1699 AccountStateChangeHandler(&info);
1700 info.event = LNN_EVENT_ACCOUNT_CHANGED;
1701 AccountStateChangeHandler(&info);
1702 UpdatePCInfoWithoutSoftbus();
1703 UpdatePCInfoWithoutSoftbus();
1704 UpdatePCInfoWithoutSoftbus();
1705 }
1706
1707 /*
1708 * @tc.name: TRY_INITIATE_NEW_NETWORK_ONLINE_TEST_001
1709 * @tc.desc: try initiate new network online test
1710 * @tc.type: FUNC
1711 * @tc.require:
1712 */
1713 HWTEST_F(LNNNetBuilderMockTest, TRY_INITIATE_NEW_NETWORK_ONLINE_TEST_001, TestSize.Level1)
1714 {
1715 LnnConnectionFsm *connFsm1 = nullptr;
1716 connFsm1 = reinterpret_cast<LnnConnectionFsm *>(SoftBusMalloc(sizeof(LnnConnectionFsm)));
1717 EXPECT_TRUE(connFsm1 != nullptr);
1718 connFsm1->connInfo.flag = CONN_FLAG1;
1719 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1720 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig).WillRepeatedly(Return(SOFTBUS_OK));
1721 TryInitiateNewNetworkOnline(connFsm1);
1722 SoftBusFree(connFsm1);
1723 }
1724
1725 /*
1726 * @tc.name: LNN_REQUEST_LEAVE_ALL_ONLINE_NODES_TEST_001
1727 * @tc.desc: lnn request leave all online nodes test
1728 * @tc.type: FUNC
1729 * @tc.require:
1730 */
1731 HWTEST_F(LNNNetBuilderMockTest, LNN_REQUEST_LEAVE_ALL_ONLINE_NODES_TEST_001, TestSize.Level1)
1732 {
1733 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1734 EXPECT_CALL(NetBuilderMock, SoftbusGetConfig(_, _, _)).WillRepeatedly(Return(SOFTBUS_OK));
1735 EXPECT_CALL(NetBuilderMock, LnnGetAllOnlineNodeInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1736 LnnRequestLeaveAllOnlineNodes();
1737 LnnRequestLeaveAllOnlineNodes();
1738 }
1739
1740 /*
1741 * @tc.name: PROCESS_LEAVE_BY_AUTH_ID_TEST_001
1742 * @tc.desc: ProcessLeaveByAuthId test
1743 * @tc.type: FUNC
1744 * @tc.require:
1745 */
1746 HWTEST_F(LNNNetBuilderMockTest, PROCESS_LEAVE_BY_AUTH_ID_TEST_001, TestSize.Level1)
1747 {
1748 ClearNetBuilderFsmList();
1749 int32_t maxConnCount = CONN_COUNT;
1750 LnnGetNetBuilder()->connCount = 0;
1751 LnnGetNetBuilder()->maxConnCount = maxConnCount;
1752 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusCalloc(sizeof(LnnConnectionFsm)));
1753 EXPECT_TRUE(connFsm != nullptr);
1754 ListInit(&connFsm->node);
1755 (void)strcpy_s(connFsm->connInfo.addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
1756 connFsm->connInfo.addr.type = CONNECTION_ADDR_BR;
1757 connFsm->connInfo.authHandle.authId = AUTH_ID;
1758 connFsm->isDead = false;
1759 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1760 ++LnnGetNetBuilder()->connCount;
1761 LnnConnectionFsm *connFsm1 = reinterpret_cast<LnnConnectionFsm *>(SoftBusCalloc(sizeof(LnnConnectionFsm)));
1762 EXPECT_TRUE(connFsm1 != nullptr);
1763 ListInit(&connFsm1->node);
1764 (void)strcpy_s(connFsm1->connInfo.addr.info.ip.ip, IP_STR_MAX_LEN, NODE2_IP);
1765 connFsm1->connInfo.addr.type = CONNECTION_ADDR_WLAN;
1766 connFsm1->connInfo.authHandle.authId = AUTH_ID_ADD;
1767 connFsm1->isDead = true;
1768 ListAdd(&g_netBuilder.fsmList, &connFsm1->node);
1769 ++LnnGetNetBuilder()->connCount;
1770 SoftBusMessage msg = {
1771 .what = MSG_TYPE_BUILD_MAX,
1772 };
1773 NetBuilderMessageHandler(nullptr);
1774 NetBuilderMessageHandler(&msg);
1775 int64_t *authId = reinterpret_cast<int64_t *>(SoftBusCalloc(sizeof(int64_t)));
1776 EXPECT_TRUE(authId != nullptr);
1777 *authId = AUTH_ID_ADD;
1778 const void *para = reinterpret_cast<const void *>(authId);
1779 EXPECT_EQ(ProcessLeaveByAuthId(nullptr), SOFTBUS_INVALID_PARAM);
1780 EXPECT_EQ(ProcessLeaveByAuthId(para), SOFTBUS_OK);
1781 int64_t *authId1 = reinterpret_cast<int64_t *>(SoftBusCalloc(sizeof(int64_t)));
1782 EXPECT_TRUE(authId1 != nullptr);
1783 *authId1 = AUTH_ID;
1784 const void *para1 = reinterpret_cast<const void *>(authId1);
1785 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1786 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1787 EXPECT_EQ(ProcessLeaveByAuthId(para1), SOFTBUS_INVALID_PARAM);
1788 int64_t *authId2 = reinterpret_cast<int64_t *>(SoftBusCalloc(sizeof(int64_t)));
1789 EXPECT_TRUE(authId2 != nullptr);
1790 *authId2 = AUTH_ID;
1791 const void *para2 = reinterpret_cast<const void *>(authId2);
1792 EXPECT_CALL(NetBuilderMock, LnnSendLeaveRequestToConnFsm(_)).WillRepeatedly(Return(SOFTBUS_OK));
1793 EXPECT_EQ(ProcessLeaveByAuthId(para2), SOFTBUS_OK);
1794 ClearNetBuilderFsmList();
1795 }
1796
1797 /*
1798 * @tc.name: CREATE_PASSIVE_CONNECTION_FSM_TEST_001
1799 * @tc.desc: CreatePassiveConnectionFsm test
1800 * @tc.type: FUNC
1801 * @tc.require:
1802 */
1803 HWTEST_F(LNNNetBuilderMockTest, CREATE_PASSIVE_CONNECTION_FSM_TEST_001, TestSize.Level1)
1804 {
1805 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1806 EXPECT_CALL(NetBuilderMock, LnnCreateConnectionFsm).WillOnce(Return(nullptr));
1807 ConnectionAddr addr;
1808 const char *pkgName = "testPkgName";
1809 LnnConnectionFsm *fsm = StartNewConnectionFsm(&addr, pkgName, false);
1810 EXPECT_TRUE(fsm == nullptr);
1811 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusCalloc(sizeof(LnnConnectionFsm)));
1812 EXPECT_TRUE(connFsm != nullptr);
1813 ListInit(&connFsm->node);
1814 (void)strcpy_s(connFsm->connInfo.addr.info.br.brMac, BT_MAC_LEN, NODE2_BR_MAC);
1815 connFsm->connInfo.addr.type = CONNECTION_ADDR_BR;
1816 EXPECT_CALL(NetBuilderMock, LnnCreateConnectionFsm).WillRepeatedly(Return(connFsm));
1817 EXPECT_CALL(NetBuilderMock, LnnStartConnectionFsm).WillOnce(Return(SOFTBUS_NETWORK_FSM_START_FAIL));
1818 EXPECT_CALL(NetBuilderMock, LnnDestroyConnectionFsm).WillRepeatedly(Return());
1819 fsm = StartNewConnectionFsm(&addr, pkgName, false);
1820 EXPECT_TRUE(fsm == nullptr);
1821 DeviceVerifyPassMsgPara msgPara;
1822 EXPECT_CALL(NetBuilderMock, LnnStartConnectionFsm).WillOnce(Return(SOFTBUS_NETWORK_FSM_START_FAIL));
1823 int32_t ret = CreatePassiveConnectionFsm(&msgPara);
1824 EXPECT_EQ(ret, SOFTBUS_NETWORK_FSM_START_FAIL);
1825 ClearNetBuilderFsmList();
1826 }
1827
1828 /*
1829 * @tc.name: IS_SAME_PENDING_REQUEST_TEST_001
1830 * @tc.desc: IsSamePendingRequest test
1831 * @tc.type: FUNC
1832 * @tc.require:
1833 */
1834 HWTEST_F(LNNNetBuilderMockTest, IS_SAME_PENDING_REQUEST_TEST_001, TestSize.Level1)
1835 {
1836 PendingJoinRequestNode *request =
1837 reinterpret_cast<PendingJoinRequestNode *>(SoftBusCalloc(sizeof(PendingJoinRequestNode)));
1838 EXPECT_TRUE(request != nullptr);
1839 ListInit(&request->node);
1840 request->needReportFailure = true;
1841 ListAdd(&g_netBuilder.pendingList, &request->node);
1842 PendingJoinRequestNode request1 = {
1843 .needReportFailure = true,
1844 };
1845 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1846 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr).WillRepeatedly(Return(false));
1847 bool ret = IsSamePendingRequest(&request1);
1848 EXPECT_EQ(ret, false);
1849 EXPECT_CALL(NetBuilderMock, LnnIsSameConnectionAddr).WillRepeatedly(Return(true));
1850 ret = IsSamePendingRequest(&request1);
1851 EXPECT_EQ(ret, true);
1852 request1.needReportFailure = false;
1853 EXPECT_EQ(ret, true);
1854 bool addrType[CONNECTION_ADDR_MAX] = {
1855 [CONNECTION_ADDR_BR] = false,
1856 };
1857 const bool *addr = reinterpret_cast<const bool *>(&addrType);
1858 RemovePendingRequestByAddrType(nullptr, CONNECTION_ADDR_MAX);
1859 RemovePendingRequestByAddrType(addr, CONNECTION_ADDR_MAX - 1);
1860 }
1861
1862 /*
1863 * @tc.name: IS_NEED_WIFI_REAUTH_TEST_001
1864 * @tc.desc: IsNeedWifiReauth test
1865 * @tc.type: FUNC
1866 * @tc.require:
1867 */
1868 HWTEST_F(LNNNetBuilderMockTest, IS_NEED_WIFI_REAUTH_TEST_001, TestSize.Level1)
1869 {
1870 const char *networkId = NODE_NETWORK_ID;
1871 const char *newAccountHash = "0000";
1872 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1873 EXPECT_CALL(NetBuilderMock, LnnIsDefaultOhosAccount).WillOnce(Return(false));
1874 bool ret = IsNeedWifiReauth(networkId, newAccountHash, MAX_ACCOUNT_HASH_LEN);
1875 EXPECT_EQ(ret, true);
1876 EXPECT_CALL(NetBuilderMock, LnnIsDefaultOhosAccount).WillOnce(Return(true));
1877 ret = IsNeedWifiReauth(networkId, newAccountHash, MAX_ACCOUNT_HASH_LEN);
1878 EXPECT_EQ(ret, false);
1879 NodeInfo info;
1880 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1881 EXPECT_EQ(EOK, strcpy_s(info.accountHash, SHA_256_HASH_LEN, ACCOUNT_HASH));
1882 EXPECT_CALL(NetBuilderMock, LnnIsDefaultOhosAccount).WillRepeatedly(Return(false));
1883 EXPECT_CALL(NetBuilderMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_INVALID_PARAM));
1884 ret = IsNeedWifiReauth(networkId, newAccountHash, MAX_ACCOUNT_HASH_LEN);
1885 EXPECT_EQ(ret, false);
1886 EXPECT_CALL(NetBuilderMock, LnnGetRemoteNodeInfoById)
1887 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
1888 EXPECT_CALL(NetBuilderMock, SoftBusGenerateStrHash).WillOnce(Return(SOFTBUS_INVALID_PARAM));
1889 ret = IsNeedWifiReauth(networkId, newAccountHash, MAX_ACCOUNT_HASH_LEN);
1890 EXPECT_EQ(ret, false);
1891 char *newAccountHash1 = reinterpret_cast<char *>(const_cast<uint8_t *>(EMPTY_ACCOUNT));
1892 unsigned char *hash = reinterpret_cast<unsigned char *>(const_cast<uint8_t *>(EMPTY_ACCOUNT));
1893 EXPECT_CALL(NetBuilderMock, SoftBusGenerateStrHash).WillOnce(DoAll(SetArgPointee<2>(*hash), Return(SOFTBUS_OK)));
1894 ret = IsNeedWifiReauth(networkId, newAccountHash1, MAX_ACCOUNT_HASH_LEN);
1895 EXPECT_EQ(ret, false);
1896 }
1897
1898 /*
1899 * @tc.name: DELETE_PC_NODE_INFO_TEST_001
1900 * @tc.desc: DeletePcNodeInfo test
1901 * @tc.type: FUNC
1902 * @tc.require:
1903 */
1904 HWTEST_F(LNNNetBuilderMockTest, DELETE_PC_NODE_INFO_TEST_001, TestSize.Level1)
1905 {
1906 LnnEventExtra lnnEventExtra;
1907 (void)memset_s(&lnnEventExtra, sizeof(LnnEventExtra), 0, sizeof(LnnEventExtra));
1908 ConnectionAddr addr = {
1909 .type = CONNECTION_ADDR_BLE,
1910 };
1911 BuildLnnEvent(nullptr, &addr);
1912 BuildLnnEvent(&lnnEventExtra, nullptr);
1913 BuildLnnEvent(&lnnEventExtra, &addr);
1914 const char *packageName = "";
1915 DfxRecordLnnServerjoinStart(nullptr, nullptr, true);
1916 DfxRecordLnnServerjoinStart(&addr, nullptr, true);
1917 AuthConnInfo connInfo;
1918 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
1919 JoinLnnMsgPara para;
1920 (void)memset_s(¶, sizeof(JoinLnnMsgPara), 0, sizeof(JoinLnnMsgPara));
1921 EXPECT_EQ(EOK, strcpy_s(para.pkgName, PKG_NAME_SIZE_MAX, packageName));
1922 DfxRecordLnnAuthStart(nullptr, ¶, REQUEST_ID);
1923 DfxRecordLnnAuthStart(&connInfo, nullptr, REQUEST_ID);
1924 DfxRecordLnnAuthStart(&connInfo, ¶, REQUEST_ID);
1925 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1926 NodeInfo info = {
1927 .accountId = AUTH_ID,
1928 };
1929 EXPECT_EQ(EOK, strcpy_s(info.uuid, UDID_BUF_LEN, NODE_UDID));
1930 EXPECT_EQ(EOK, strcpy_s(info.deviceInfo.deviceUdid, UDID_BUF_LEN, NODE_UDID));
1931 EXPECT_CALL(NetBuilderMock, LnnGetRemoteNodeInfoById).WillOnce(Return(SOFTBUS_INVALID_PARAM));
1932 const char *peerUdid = NODE_UDID;
1933 bool ret = DeletePcNodeInfo(peerUdid);
1934 EXPECT_EQ(ret, false);
1935 EXPECT_CALL(NetBuilderMock, LnnGetRemoteNodeInfoById)
1936 .WillRepeatedly(DoAll(SetArgPointee<2>(info), Return(SOFTBUS_OK)));
1937 EXPECT_CALL(NetBuilderMock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr));
1938 ret = DeletePcNodeInfo(peerUdid);
1939 EXPECT_EQ(ret, false);
1940 NodeInfo localNodeInfo = {
1941 .accountId = AUTH_ID,
1942 };
1943 EXPECT_CALL(NetBuilderMock, LnnGetLocalNodeInfo).WillOnce(Return(&localNodeInfo));
1944 ret = DeletePcNodeInfo(peerUdid);
1945 EXPECT_EQ(ret, false);
1946 localNodeInfo.accountId = AUTH_ID_ADD;
1947 EXPECT_CALL(NetBuilderMock, LnnGetLocalNodeInfo).WillOnce(Return(&localNodeInfo));
1948 EXPECT_CALL(NetBuilderMock, DeleteFromProfile).WillOnce(Return());
1949 EXPECT_CALL(NetBuilderMock, LnnRemoveNode).WillOnce(Return());
1950 ret = DeletePcNodeInfo(peerUdid);
1951 EXPECT_EQ(ret, true);
1952 }
1953
1954 /*
1955 * @tc.name: LNN_NOTIFY_AUTH_HANDLE_LEAVE_LNN_TEST_001
1956 * @tc.desc: LnnNotifyAuthHandleLeaveLNN test
1957 * @tc.type: FUNC
1958 * @tc.require:
1959 */
1960 HWTEST_F(LNNNetBuilderMockTest, LNN_NOTIFY_AUTH_HANDLE_LEAVE_LNN_TEST_001, TestSize.Level1)
1961 {
1962 ClearNetBuilderFsmList();
1963 LnnConnectionFsm *connFsm = reinterpret_cast<LnnConnectionFsm *>(SoftBusCalloc(sizeof(LnnConnectionFsm)));
1964 EXPECT_TRUE(connFsm != nullptr);
1965 ListInit(&connFsm->node);
1966 (void)strcpy_s(connFsm->connInfo.addr.info.br.brMac, BT_MAC_LEN, NODE1_BR_MAC);
1967 connFsm->connInfo.addr.type = CONNECTION_ADDR_BR;
1968 connFsm->connInfo.authHandle.authId = AUTH_ID;
1969 connFsm->isDead = false;
1970 ListAdd(&g_netBuilder.fsmList, &connFsm->node);
1971 ++LnnGetNetBuilder()->connCount;
1972 g_netBuilder.isInit = false;
1973 AuthHandle authHandle = {
1974 .authId = AUTH_ID,
1975 .type = CONNECTION_ADDR_BR,
1976 };
1977 int32_t ret = LnnNotifyAuthHandleLeaveLNN(authHandle);
1978 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
1979 const char *networkId = NODE_NETWORK_ID;
1980 uint8_t *msg = const_cast<uint8_t *>(SELECT_MASTER_MSG);
1981 uint32_t len = strlen(reinterpret_cast<const char *>(msg));
1982 OnReceiveMasterElectMsg(LNN_INFO_TYPE_NICK_NAME, networkId, msg, len);
1983 g_netBuilder.isInit = true;
1984 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
1985 EXPECT_CALL(NetBuilderMock, AuthHandleLeaveLNN).WillRepeatedly(Return());
1986 ret = LnnNotifyAuthHandleLeaveLNN(authHandle);
1987 EXPECT_EQ(ret, SOFTBUS_OK);
1988 authHandle.type = 0;
1989 NodeInfo info;
1990 (void)memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1991 OnVerifyPassed(REQUEST_ID, authHandle, &info);
1992 authHandle.type = AUTH_LINK_TYPE_MAX;
1993 OnVerifyPassed(REQUEST_ID, authHandle, &info);
1994 OnReceiveMasterElectMsg(LNN_INFO_TYPE_MASTER_ELECT, networkId, msg, len);
1995 }
1996
PostMessageFunc(const SoftBusLooper * looper,SoftBusMessage * msg)1997 static void PostMessageFunc(const SoftBusLooper *looper, SoftBusMessage *msg)
1998 {
1999 (void)looper;
2000 if (msg != nullptr) {
2001 SoftBusFree(msg);
2002 }
2003 }
2004
SetNetBuilderLooper()2005 static void SetNetBuilderLooper()
2006 {
2007 g_netBuilder.looper->PostMessage = PostMessageFunc;
2008 }
2009
2010 /*
2011 * @tc.name: LNN_NOTIFY_LEAVE_LNN_BY_AUTH_HANDLE_TEST_001
2012 * @tc.desc: LnnNotifyLeaveLnnByAuthHandle test
2013 * @tc.type: FUNC
2014 * @tc.require:
2015 */
2016 HWTEST_F(LNNNetBuilderMockTest, LNN_NOTIFY_LEAVE_LNN_BY_AUTH_HANDLE_TEST_001, TestSize.Level1)
2017 {
2018 SetNetBuilderLooper();
2019 AuthHandle authHandle;
2020 int32_t ret = LnnNotifyLeaveLnnByAuthHandle(&authHandle);
2021 EXPECT_EQ(ret, SOFTBUS_OK);
2022 ret = LnnNotifyEmptySessionKey(AUTH_ID);
2023 EXPECT_EQ(ret, SOFTBUS_OK);
2024 }
2025
2026 /*
2027 * @tc.name: LNN_BLE_REPORT_EXTRA_MAP_INIT_TEST_001
2028 * @tc.desc: LnnBleReportExtraMapInit test
2029 * @tc.type: FUNC
2030 * @tc.require:
2031 */
2032 HWTEST_F(LNNNetBuilderMockTest, LNN_BLE_REPORT_EXTRA_MAP_INIT_TEST_001, TestSize.Level1)
2033 {
2034 const char *udidHash = NODE_UDID;
2035 LnnBleReportExtra bleExtra = {
2036 .extra.result = SOFTBUS_OK,
2037 .status = BLE_REPORT_EVENT_INIT,
2038 };
2039 LnnBleReportExtra bleExtraDest;
2040 (void)memset_s(&bleExtraDest, sizeof(LnnBleReportExtra), 0, sizeof(LnnBleReportExtra));
2041 AddNodeToLnnBleReportExtraMap(udidHash, &bleExtra);
2042 DeleteNodeFromLnnBleReportExtraMap(udidHash);
2043 int32_t rc = GetNodeFromLnnBleReportExtraMap(udidHash, &bleExtraDest);
2044 EXPECT_EQ(rc, SOFTBUS_INVALID_PARAM);
2045 bool ret = IsExistLnnDfxNodeByUdidHash(udidHash, &bleExtra);
2046 EXPECT_EQ(ret, false);
2047 ret = LnnBleReportExtraMapInit();
2048 EXPECT_EQ(ret, true);
2049 AddNodeToLnnBleReportExtraMap(nullptr, &bleExtra);
2050 AddNodeToLnnBleReportExtraMap(udidHash, nullptr);
2051 AddNodeToLnnBleReportExtraMap(udidHash, &bleExtra);
2052 rc = GetNodeFromLnnBleReportExtraMap(nullptr, &bleExtraDest);
2053 EXPECT_EQ(rc, SOFTBUS_INVALID_PARAM);
2054 rc = GetNodeFromLnnBleReportExtraMap(udidHash, nullptr);
2055 EXPECT_EQ(rc, SOFTBUS_INVALID_PARAM);
2056 rc = GetNodeFromLnnBleReportExtraMap(udidHash, &bleExtraDest);
2057 EXPECT_EQ(rc, SOFTBUS_OK);
2058 const char *udidHash1 = NODE_NETWORK_ID;
2059 rc = GetNodeFromLnnBleReportExtraMap(udidHash1, &bleExtraDest);
2060 EXPECT_EQ(rc, SOFTBUS_NOT_FIND);
2061 }
2062
2063 /*
2064 * @tc.name: IS_EXIST_LNN_DFX_NODE_BY_UDID_HASH_TEST_001
2065 * @tc.desc: IsExistLnnDfxNodeByUdidHash test
2066 * @tc.type: FUNC
2067 * @tc.require:
2068 */
2069 HWTEST_F(LNNNetBuilderMockTest, IS_EXIST_LNN_DFX_NODE_BY_UDID_HASH_TEST_001, TestSize.Level1)
2070 {
2071 const char *udidHash = NODE_UDID;
2072 const char *udidHash1 = NODE_NETWORK_ID;
2073 LnnBleReportExtra bleExtra;
2074 (void)memset_s(&bleExtra, sizeof(LnnBleReportExtra), 0, sizeof(LnnBleReportExtra));
2075 bool ret = IsExistLnnDfxNodeByUdidHash(udidHash, &bleExtra);
2076 EXPECT_EQ(ret, true);
2077 ret = IsExistLnnDfxNodeByUdidHash(udidHash1, &bleExtra);
2078 EXPECT_EQ(ret, false);
2079 ret = IsExistLnnDfxNodeByUdidHash(nullptr, &bleExtra);
2080 EXPECT_EQ(ret, false);
2081 ret = IsExistLnnDfxNodeByUdidHash(udidHash, nullptr);
2082 EXPECT_EQ(ret, false);
2083 DeleteNodeFromLnnBleReportExtraMap(nullptr);
2084 DeleteNodeFromLnnBleReportExtraMap(udidHash1);
2085 DeleteNodeFromLnnBleReportExtraMap(udidHash);
2086 ClearLnnBleReportExtraMap();
2087 }
2088
2089 /*
2090 * @tc.name: GET_NODE_FROM_PC_RESTRICT_MAP_TEST_001
2091 * @tc.desc: GetNodeFromPcRestrictMap test
2092 * @tc.type: FUNC
2093 * @tc.require:
2094 */
2095 HWTEST_F(LNNNetBuilderMockTest, GET_NODE_FROM_PC_RESTRICT_MAP_TEST_001, TestSize.Level1)
2096 {
2097 const char *udidHash = NODE_UDID;
2098 const char *udidHash1 = NODE_NETWORK_ID;
2099 uint32_t count = 0;
2100 AddNodeToPcRestrictMap(udidHash);
2101 DeleteNodeFromPcRestrictMap(udidHash);
2102 int32_t ret = GetNodeFromPcRestrictMap(udidHash, &count);
2103 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2104 ret = UpdateNodeFromPcRestrictMap(udidHash);
2105 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2106 LnnBlePcRestrictMapInit();
2107 AddNodeToPcRestrictMap(udidHash);
2108 AddNodeToPcRestrictMap(nullptr);
2109 ret = GetNodeFromPcRestrictMap(udidHash, &count);
2110 EXPECT_EQ(ret, SOFTBUS_OK);
2111 ret = GetNodeFromPcRestrictMap(udidHash1, &count);
2112 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
2113 ret = GetNodeFromPcRestrictMap(nullptr, &count);
2114 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2115 ret = GetNodeFromPcRestrictMap(udidHash, nullptr);
2116 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2117 ret = UpdateNodeFromPcRestrictMap(udidHash);
2118 EXPECT_EQ(ret, SOFTBUS_OK);
2119 ret = UpdateNodeFromPcRestrictMap(udidHash1);
2120 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
2121 ret = UpdateNodeFromPcRestrictMap(nullptr);
2122 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2123 DeleteNodeFromPcRestrictMap(nullptr);
2124 DeleteNodeFromPcRestrictMap(udidHash);
2125 DeleteNodeFromPcRestrictMap(udidHash1);
2126 ClearPcRestrictMap();
2127 }
2128
2129 /*
2130 * @tc.name: USER_SWITCHED_HANDLER_TEST_001
2131 * @tc.desc: UserSwitchedHandler test
2132 * @tc.type: FUNC
2133 * @tc.require:
2134 */
2135 HWTEST_F(LNNNetBuilderMockTest, USER_SWITCHED_HANDLER_TEST_001, TestSize.Level1)
2136 {
2137 LnnMonitorHbStateChangedEvent event = {
2138 .basic.event = LNN_EVENT_IP_ADDR_CHANGED,
2139 .status = SOFTBUS_USER_SWITCH_UNKNOWN,
2140 };
2141 const LnnEventBasicInfo *info = reinterpret_cast<const LnnEventBasicInfo *>(&event);
2142 UserSwitchedHandler(nullptr);
2143 UserSwitchedHandler(info);
2144 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
2145 EXPECT_CALL(NetBuilderMock, LnnSetUnlockState).WillOnce(Return());
2146 event.basic.event = LNN_EVENT_USER_SWITCHED;
2147 const LnnEventBasicInfo *info1 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
2148 UserSwitchedHandler(info1);
2149 event.status = SOFTBUS_USER_SWITCHED;
2150 const LnnEventBasicInfo *info2 = reinterpret_cast<const LnnEventBasicInfo *>(&event);
2151 UserSwitchedHandler(info2);
2152 AuthHandle authHandle = {
2153 .type = 0,
2154 .authId = AUTH_ID_ADD,
2155 };
2156 OnDeviceDisconnect(authHandle);
2157 authHandle.type = AUTH_LINK_TYPE_MAX;
2158 OnDeviceDisconnect(authHandle);
2159 bool ret = IsSupportMasterNodeElect(SOFTBUS_NEW_V1);
2160 EXPECT_EQ(ret, true);
2161 }
2162
2163 /*
2164 * @tc.name: LNN_UPDATE_LOCAL_UUID_AND_IRK_TEST_001
2165 * @tc.desc: LnnUpdateLocalUuidAndIrk test
2166 * @tc.type: FUNC
2167 * @tc.require:
2168 */
2169 HWTEST_F(LNNNetBuilderMockTest, LNN_UPDATE_LOCAL_UUID_AND_IRK_TEST_001, TestSize.Level1)
2170 {
2171 NiceMock<NetBuilderDepsInterfaceMock> NetBuilderMock;
2172 EXPECT_CALL(NetBuilderMock, LnnGenLocalUuid(_, _, _))
2173 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
2174 .WillRepeatedly(Return(SOFTBUS_OK));
2175 EXPECT_CALL(NetBuilderMock, LnnGenLocalIrk(_, _, _))
2176 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
2177 .WillRepeatedly(Return(SOFTBUS_OK));
2178 EXPECT_CALL(NetBuilderMock, LnnSetLocalStrInfo(_, _)).WillRepeatedly(Return(SOFTBUS_OK));
2179 EXPECT_TRUE(LnnUpdateLocalUuidAndIrk() != SOFTBUS_OK);
2180 EXPECT_TRUE(LnnUpdateLocalUuidAndIrk() == SOFTBUS_OK);
2181 }
2182 } // namespace OHOS
2183