1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <thread>
20
21 #include "bus_center_info_key.h"
22 #include "lnn_lane.h"
23 #include "lnn_lane_common.h"
24 #include "lnn_lane_deps_mock.h"
25 #include "lnn_lane_def.h"
26 #include "lnn_lane_interface.h"
27 #include "lnn_lane_link.h"
28 #include "lnn_lane_model.h"
29 #include "lnn_lane_power_ctrl_deps_mock.h"
30 #include "lnn_lane_reliability.c"
31 #include "lnn_lane_select.h"
32 #include "lnn_select_rule.h"
33 #include "lnn_wifi_adpter_mock.h"
34 #include "lnn_lane_link_ledger.h"
35 #include "message_handler.h"
36 #include "softbus_adapter_mem.h"
37 #include "softbus_error_code.h"
38 #include "softbus_wifi_api_adapter.h"
39 #include "wifi_direct_error_code.h"
40
41 namespace OHOS {
42 using namespace testing::ext;
43 using namespace testing;
44
45 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
46 constexpr char PEER_IP_HML[] = "172.30.0.1";
47 constexpr char PEER_WLAN_ADDR[] = "172.30.0.1";
48 constexpr char PEER_MAC[] = "a1:b2:c3:d4:e5:f6";
49 constexpr char LOCAL_MAC[] = "a2:b2:c3:d4:e5:f6";
50 constexpr char PEER_UDID[] = "111122223333abcdef";
51 constexpr char LOCAL_UDID[] = "444455556666abcdef";
52 constexpr uint64_t LANE_ID_BASE = 1122334455667788;
53 constexpr uint32_t DEFAULT_SELECT_NUM = 4;
54 constexpr uint32_t DEFAULT_QOSINFO_MIN_BW = 10;
55 constexpr uint32_t DEFAULT_QOSINFO_MAX_LATENCY = 10000;
56 constexpr uint32_t DEFAULT_QOSINFO_MIN_LATENCY = 2500;
57 constexpr uint32_t LOW_BW = 384 * 1024;
58 constexpr uint32_t HIGH_BW = 160 * 1024 * 1024;
59 constexpr uint32_t FREQUENCY_2G_FIRST = 2412;
60 constexpr uint32_t LOCAL_NUM = 8192;
61 constexpr uint32_t ROM_NUM = 8;
62 constexpr uint32_t ROM_NUM2 = 2;
63 constexpr uint32_t LANE_PREFERRED_LINK_NUM = 2;
64 constexpr uint32_t WIFI_DIRECT_EXT_CAP_VALID_TIME = 10000;
65
66 static NodeInfo g_NodeInfo = {
67 .p2pInfo.p2pRole = 1,
68 .p2pInfo.p2pMac = "abc",
69 .p2pInfo.goMac = "abc",
70 };
71
72 class LNNLaneExtMockTest : public testing::Test {
73 public:
74 static void SetUpTestCase();
75 static void TearDownTestCase();
76 void SetUp();
77 void TearDown();
78 };
79
SetUpTestCase()80 void LNNLaneExtMockTest::SetUpTestCase()
81 {
82 int32_t ret = LnnInitLnnLooper();
83 EXPECT_EQ(ret, SOFTBUS_OK);
84 ret = LooperInit();
85 EXPECT_EQ(ret, SOFTBUS_OK);
86 NiceMock<LaneDepsInterfaceMock> mock;
87 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(nullptr));
88 ret = InitLane();
89 EXPECT_EQ(ret, SOFTBUS_OK);
90 GTEST_LOG_(INFO) << "LNNLaneExtMockTest start";
91 }
92
TearDownTestCase()93 void LNNLaneExtMockTest::TearDownTestCase()
94 {
95 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
96 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
97 DeinitLane();
98 LooperDeinit();
99 LnnDeinitLnnLooper();
100 GTEST_LOG_(INFO) << "LNNLaneExtMockTest end";
101 }
102
SetUp()103 void LNNLaneExtMockTest::SetUp()
104 {
105 }
106
TearDown()107 void LNNLaneExtMockTest::TearDown()
108 {
109 }
110
PrejudgeAvailability(const char * remoteNetworkId,enum WifiDirectLinkType connectType)111 static int32_t PrejudgeAvailability(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
112 {
113 (void)remoteNetworkId;
114 (void)connectType;
115 GTEST_LOG_(INFO) << "PrejudgeAvailability Enter";
116 return SOFTBUS_OK;
117 }
118
GetLocalAndRemoteMacByLocalIp(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)119 static int32_t GetLocalAndRemoteMacByLocalIp(const char *localIp, char *localMac, size_t localMacSize,
120 char *remoteMac, size_t remoteMacSize)
121 {
122 (void)localIp;
123 (void)localMac;
124 (void)localMacSize;
125 (void)remoteMac;
126 (void)remoteMacSize;
127 return SOFTBUS_OK;
128 }
129
GetLocalAndRemoteMacByLocalIpError(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)130 static int32_t GetLocalAndRemoteMacByLocalIpError(const char *localIp, char *localMac, size_t localMacSize,
131 char *remoteMac, size_t remoteMacSize)
132 {
133 (void)localIp;
134 (void)localMac;
135 (void)localMacSize;
136 (void)remoteMac;
137 (void)remoteMacSize;
138 return SOFTBUS_INVALID_PARAM;
139 }
140
141 static struct WifiDirectManager g_manager = {
142 .prejudgeAvailability = PrejudgeAvailability,
143 .getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIp,
144 };
145
146 /*
147 * @tc.name: LANE_INFO_001
148 * @tc.desc: LaneInfoProcess BR
149 * @tc.type: FUNC
150 * @tc.require:
151 */
152 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_001, TestSize.Level1)
153 {
154 LaneLinkInfo info = {};
155 info.type = LANE_BR;
156 LaneConnInfo connInfo = {};
157 LaneProfile profile = {};
158 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
159 EXPECT_EQ(ret, SOFTBUS_OK);
160 }
161
162 /*
163 * @tc.name: LANE_INFO_002
164 * @tc.desc: LaneInfoProcess BLE
165 * @tc.type: FUNC
166 * @tc.require:
167 */
168 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_002, TestSize.Level1)
169 {
170 LaneLinkInfo info = {};
171 info.type = LANE_BLE;
172 LaneConnInfo connInfo = {};
173 LaneProfile profile = {};
174 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
175 EXPECT_EQ(ret, SOFTBUS_OK);
176 }
177
178 /*
179 * @tc.name: LANE_INFO_003
180 * @tc.desc: LaneInfoProcess P2P
181 * @tc.type: FUNC
182 * @tc.require:
183 */
184 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_003, TestSize.Level1)
185 {
186 LaneLinkInfo info = {};
187 info.type = LANE_P2P;
188 LaneConnInfo connInfo;
189 LaneProfile profile = {};
190 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
191 EXPECT_EQ(ret, SOFTBUS_OK);
192 }
193
194 /*
195 * @tc.name: LANE_INFO_004
196 * @tc.desc: LaneInfoProcess fail
197 * @tc.type: FAILUE
198 * @tc.require:
199 */
200 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_004, TestSize.Level1)
201 {
202 LaneLinkInfo info = {};
203 info.type = LANE_LINK_TYPE_BUTT;
204 LaneConnInfo *connInfo = nullptr;
205 LaneProfile *profile = nullptr;
206 int32_t ret = LaneInfoProcess(nullptr, connInfo, profile);
207 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
208
209 ret = LaneInfoProcess(&info, nullptr, profile);
210 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
211
212 ret = LaneInfoProcess(&info, connInfo, nullptr);
213 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
214
215 ret = LaneInfoProcess(&info, connInfo, profile);
216 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
217 }
218
219 /*
220 * @tc.name: LANE_INFO_005
221 * @tc.desc: LaneInfoProcess 2.4G
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_005, TestSize.Level1)
226 {
227 LaneLinkInfo info = {};
228 LaneConnInfo connInfo = {};
229 LaneProfile profile = {};
230
231 info.type = LANE_WLAN_2P4G;
232 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
233 EXPECT_EQ(ret, SOFTBUS_OK);
234
235 info.type = LANE_WLAN_5G;
236 ret = LaneInfoProcess(&info, &connInfo, &profile);
237 EXPECT_EQ(ret, SOFTBUS_OK);
238
239 info.type = LANE_P2P_REUSE;
240 ret = LaneInfoProcess(&info, &connInfo, &profile);
241 EXPECT_EQ(ret, SOFTBUS_OK);
242
243 info.type = LANE_BLE_DIRECT;
244 ret = LaneInfoProcess(&info, &connInfo, &profile);
245 EXPECT_EQ(ret, SOFTBUS_OK);
246
247 info.type = LANE_COC;
248 ret = LaneInfoProcess(&info, &connInfo, &profile);
249 EXPECT_EQ(ret, SOFTBUS_OK);
250
251 info.type = LANE_HML_RAW;
252 ret = LaneInfoProcess(&info, &connInfo, &profile);
253 EXPECT_EQ(ret, SOFTBUS_OK);
254
255 info.type = LANE_LINK_TYPE_BUTT;
256 ret = LaneInfoProcess(&info, &connInfo, &profile);
257 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
258 }
259
260 /*
261 * @tc.name: LNN_DATA_001
262 * @tc.desc: LnnCreateData
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266 HWTEST_F(LNNLaneExtMockTest, LNN_DATA_001, TestSize.Level1)
267 {
268 int32_t ret = LnnCreateData(nullptr, 32, nullptr, 0);
269 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
270 LnnDeleteData(nullptr, 32);
271 }
272
273 /*
274 * @tc.name: LNN_LANE_PROFILE_001
275 * @tc.desc: BindLaneIdToProfile
276 * @tc.type: FUNC
277 * @tc.require:
278 */
279 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_PROFILE_001, TestSize.Level1)
280 {
281 uint64_t laneId = 0x1000000000000001;
282 int32_t ret = BindLaneIdToProfile(laneId, nullptr);
283 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
284
285 LaneProfile profile = {};
286 ret = BindLaneIdToProfile(laneId, &profile);
287 EXPECT_EQ(ret, SOFTBUS_OK);
288
289 profile.linkType = LANE_P2P;
290 profile.content = LANE_T_FILE;
291 profile.priority = LANE_PRI_LOW;
292 ret = BindLaneIdToProfile(laneId, &profile);
293 EXPECT_EQ(ret, SOFTBUS_OK);
294
295 LaneGenerateParam param = {};
296 param.linkType = LANE_P2P;
297 param.transType = LANE_T_FILE;
298 param.priority = LANE_PRI_LOW;
299 uint32_t profileId = GenerateLaneProfileId(¶m);
300
301 ret = GetLaneProfile(profileId, &profile);
302 EXPECT_EQ(ret, SOFTBUS_OK);
303
304 ret = GetLaneProfile(profileId, nullptr);
305 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
306
307 uint64_t *laneReqIdList = nullptr;
308 uint32_t listSize = 0;
309 ret = GetLaneIdList(profileId, &laneReqIdList, &listSize);
310 EXPECT_EQ(ret, SOFTBUS_OK);
311 SoftBusFree(laneReqIdList);
312 (void)GetActiveProfileNum();
313 (void)UnbindLaneIdFromProfile(laneId, profileId);
314 (void)UnbindLaneIdFromProfile(0, profileId);
315 }
316
317 /*
318 * @tc.name: LNN_LANE_PROFILE_002
319 * @tc.desc: BindLaneIdToProfile
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_PROFILE_002, TestSize.Level1)
324 {
325 uint64_t laneId = 0x1000000000000002;
326 uint32_t profileId = 111111;
327 LaneProfile profile = {};
328 int32_t ret = GetLaneProfile(profileId, &profile);
329 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
330
331 uint64_t *laneReqIdList = nullptr;
332 uint32_t listSize = 0;
333 ret = GetLaneIdList(profileId, &laneReqIdList, &listSize);
334 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
335
336 profile.linkType = LANE_P2P;
337 profile.content = LANE_T_FILE;
338 profile.priority = LANE_PRI_LOW;
339 ret = BindLaneIdToProfile(laneId, &profile);
340 EXPECT_EQ(ret, SOFTBUS_OK);
341
342 ret = BindLaneIdToProfile(laneId, &profile);
343 EXPECT_EQ(ret, SOFTBUS_OK);
344 (void)UnbindLaneIdFromProfile(laneId, profileId);
345 }
346
347 /*
348 * @tc.name: LNN_SELECT_LANE_001
349 * @tc.desc: SelectLane
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_LANE_001, TestSize.Level1)
354 {
355 NiceMock<LaneDepsInterfaceMock> mock;
356 LanePreferredLinkList *linkList = nullptr;
357 uint32_t listNum = 0;
358 LaneSelectParam selectParam = {};
359 selectParam.transType = LANE_T_FILE;
360 selectParam.expectedBw = 0;
361 selectParam.list.linkTypeNum = 2;
362 selectParam.list.linkType[0] = LANE_WLAN_5G;
363 selectParam.list.linkType[1] = LANE_LINK_TYPE_BUTT;
364
365 int32_t ret = SelectLane(NODE_NETWORK_ID, nullptr, linkList, &listNum);
366 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
367
368 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
369 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
370 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
371 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
372 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
373 wifiMock.SetDefaultResult();
374 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
375 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
376
377 EXPECT_CALL(mock, LnnGetLocalNumInfo)
378 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
379 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
380 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
381 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
382 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
383 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
384
385 selectParam.transType = LANE_T_MIX;
386 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
387 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
388 SoftBusFree(linkList);
389 }
390
391 /*
392 * @tc.name: LNN_SELECT_LANE_002
393 * @tc.desc: SelectLane
394 * @tc.type: FUNC
395 * @tc.require:
396 */
397 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_LANE_002, TestSize.Level1)
398 {
399 NiceMock<LaneDepsInterfaceMock> mock;
400 LanePreferredLinkList *linkList = nullptr;
401 uint32_t listNum = 0;
402 LaneSelectParam selectParam = {};
403 selectParam.transType = LANE_T_FILE;
404 selectParam.expectedBw = 0;
405 selectParam.list.linkTypeNum = DEFAULT_SELECT_NUM;
406 selectParam.list.linkType[0] = LANE_BLE;
407 selectParam.list.linkType[1] = LANE_WLAN_2P4G;
408 selectParam.list.linkType[2] = LANE_WLAN_5G;
409 selectParam.list.linkType[3] = LANE_BR;
410
411 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
412 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
413 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
414 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
415 wifiMock.SetDefaultResult();
416 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
417 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
418
419 EXPECT_CALL(mock, LnnGetLocalNumInfo)
420 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
421 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
422 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
423 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
424 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
425 SoftBusFree(linkList);
426 }
427
428 /*
429 * @tc.name: LNN_SELECT_LANE_003
430 * @tc.desc: SelectLane
431 * @tc.type: FUNC
432 * @tc.require:
433 */
434 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_LANE_003, TestSize.Level1)
435 {
436 NiceMock<LaneDepsInterfaceMock> mock;
437 LanePreferredLinkList linkList = {};
438 uint32_t listNum = 0;
439 LaneSelectParam selectParam = {};
440 NodeInfo node = {};
441
442 selectParam.transType = LANE_T_FILE;
443 selectParam.expectedBw = 0;
444 selectParam.list.linkTypeNum = 7;
445 selectParam.list.linkType[0] = LANE_P2P;
446 selectParam.list.linkType[1] = LANE_ETH;
447 selectParam.list.linkType[2] = LANE_P2P_REUSE;
448 selectParam.list.linkType[3] = LANE_BLE_DIRECT;
449 selectParam.list.linkType[4] = LANE_BLE_REUSE;
450 selectParam.list.linkType[5] = LANE_COC;
451 selectParam.list.linkType[6] = LANE_COC_DIRECT;
452 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
453 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
454 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
455 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
456 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
457 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
458 wifiMock.SetDefaultResult();
459 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
460 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
461
462 node.discoveryType = 3;
463 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById)
464 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(node), Return(SOFTBUS_OK)));
465 EXPECT_CALL(mock, LnnGetLocalNumInfo)
466 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
467 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
468 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
469 EXPECT_CALL(mock, LnnGetLocalNumU64Info)
470 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
471 EXPECT_CALL(mock, LnnGetRemoteNumU64Info)
472 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
473 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
474 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
475 }
476
477 /*
478 * @tc.name: LNN_SELECT_LANE_004
479 * @tc.desc: SelectLane, HmlIsExist == true
480 * @tc.type: FUNC
481 * @tc.require:
482 */
483 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_LANE_004, TestSize.Level1)
484 {
485 LaneSelectParam request = {};
486 request.transType = LANE_T_FILE;
487 request.list.linkTypeNum = 0;
488 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BR;
489 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BLE;
490 request.list.linkType[(request.list.linkTypeNum)++] = LANE_P2P;
491 request.list.linkType[(request.list.linkTypeNum)++] = LANE_HML;
492
493 LanePreferredLinkList recommendList = {};
494 uint32_t listNum = 0;
495
496 NiceMock<LaneDepsInterfaceMock> linkMock;
497 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
498 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_ACTIVED));
499 EXPECT_CALL(linkMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
500 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
501 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
502 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
503 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
504 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
505 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(8), Return(SOFTBUS_OK)));
506 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)\
507 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(8), Return(SOFTBUS_OK)));
508
509 int32_t ret = SelectLane(NODE_NETWORK_ID, &request, &recommendList, &listNum);
510 EXPECT_EQ(ret, SOFTBUS_OK);
511 }
512
513 /*
514 * @tc.name: LNN_SELECT_LANE_005
515 * @tc.desc: SelectLane, HmlIsExist == false && LaneAddHml
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_LANE_005, TestSize.Level1)
520 {
521 LaneSelectParam request = {};
522 request.transType = LANE_T_FILE;
523 request.list.linkTypeNum = 0;
524 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BR;
525 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BLE;
526 request.list.linkType[(request.list.linkTypeNum)++] = LANE_P2P;
527
528 LanePreferredLinkList recommendList = {};
529 uint32_t listNum = 0;
530
531 NiceMock<LaneDepsInterfaceMock> linkMock;
532 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
533 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_ACTIVED));
534 EXPECT_CALL(linkMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
535 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
536 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
537 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
538 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
539 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
540 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(8), Return(SOFTBUS_OK)));
541 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
542 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(8), Return(SOFTBUS_OK)));
543
544 int32_t ret = SelectLane(NODE_NETWORK_ID, &request, &recommendList, &listNum);
545 EXPECT_EQ(ret, SOFTBUS_OK);
546 }
547
548 /*
549 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_001
550 * @tc.desc: SelectExpectLanesByQos
551 * @tc.type: FUNC
552 * @tc.require:
553 */
554 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_001, TestSize.Level1)
555 {
556 NiceMock<LaneDepsInterfaceMock> mock;
557 LanePreferredLinkList linkList;
558 LaneSelectParam selectParam = {};
559 selectParam.transType = LANE_T_FILE;
560 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
561 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
562 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
563 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, nullptr, &linkList);
564 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
565
566 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
567 wifiMock.SetDefaultResult();
568 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
569 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
570 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
571 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
572 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
573 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
574
575 EXPECT_CALL(mock, LnnGetLocalNumInfo)
576 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
577 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
578 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
579 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
580 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
581 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
582
583 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW + LOW_BW;
584 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
585 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
586
587 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW + HIGH_BW;
588 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
589 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
590
591 selectParam.transType = LANE_T_MIX;
592 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
593 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
594 }
595
596 /*
597 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_002
598 * @tc.desc: SelectExpectLanesByQos
599 * @tc.type: FUNC
600 * @tc.require:
601 */
602 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_002, TestSize.Level1)
603 {
604 NiceMock<LaneDepsInterfaceMock> mock;
605 LanePreferredLinkList linkList;
606 LaneSelectParam selectParam = {};
607 selectParam.transType = LANE_T_FILE;
608 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, nullptr, &linkList);
609 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
610
611 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
612 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
613 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
614 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
615 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
616 wifiMock.SetDefaultResult();
617 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
618 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
619
620 EXPECT_CALL(mock, LnnGetLocalNumInfo)
621 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
622 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
623 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
624 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
625 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
626 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
627
628 selectParam.transType = LANE_T_MIX;
629 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
630 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
631 }
632
633 /*
634 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_003
635 * @tc.desc: SelectExpectLanesByQos
636 * @tc.type: FUNC
637 * @tc.require:
638 */
639 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_003, TestSize.Level1)
640 {
641 NiceMock<LaneDepsInterfaceMock> mock;
642 LanePreferredLinkList linkList;
643 LaneSelectParam selectParam = {};
644 selectParam.transType = LANE_T_FILE;
645
646 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
647 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
648 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
649 wifiMock.SetDefaultResult();
650
651 selectParam.qosRequire.rttLevel = LANE_RTT_LEVEL_LOW;
652 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
653 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
654 }
655
656 /*
657 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_004
658 * @tc.desc: lane select fileTransLane by qos
659 * @tc.type: FUNC
660 * @tc.require: I5FBFG
661 */
662 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_004, TestSize.Level1)
663 {
664 LanePreferredLinkList recommendList;
665 NiceMock<LaneDepsInterfaceMock> mock;
666 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
667 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
668 (void)memset_s(&recommendList, sizeof(LanePreferredLinkList), 0, sizeof(LanePreferredLinkList));
669 LaneSelectParam selectParam;
670 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
671 selectParam.transType = LANE_T_FILE;
672 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
673 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
674 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
675 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
676 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(63), Return(SOFTBUS_OK)));
677 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
678 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(63), Return(SOFTBUS_OK)));
679 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
680 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &recommendList);
681 EXPECT_EQ(ret, SOFTBUS_OK);
682 }
683
684 /*
685 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_005
686 * @tc.desc: lane select fileTransLane by qos
687 * @tc.type: FUNC
688 * @tc.require: I5FBFG
689 */
690 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_005, TestSize.Level1)
691 {
692 LanePreferredLinkList recommendList;
693 NiceMock<LaneDepsInterfaceMock> mock;
694 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
695 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
696 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
697 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(63), Return(SOFTBUS_OK)));
698 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
699 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(63), Return(SOFTBUS_OK)));
700 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
701 (void)memset_s(&recommendList, sizeof(LanePreferredLinkList), 0, sizeof(LanePreferredLinkList));
702 LaneSelectParam selectParam;
703 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
704 selectParam.transType = LANE_T_BYTE;
705 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &recommendList);
706 EXPECT_EQ(ret, SOFTBUS_OK);
707 }
708
709 /*
710 * @tc.name: LANE_DECISION_MODELS_001
711 * @tc.desc: LANE DECISION MODELS TEST
712 * @tc.type: FUNC
713 * @tc.require:
714 */
715 HWTEST_F(LNNLaneExtMockTest, LANE_DECISION_MODELS_001, TestSize.Level1)
716 {
717 NiceMock<LaneDepsInterfaceMock> mock;
718 LaneSelectParam selectParam = {};
719 LanePreferredLinkList linkList;
720 selectParam.transType = LANE_T_FILE;
721 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
722 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
723 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
724
725 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
726 wifiMock.SetDefaultResult();
727 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
728 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
729 EXPECT_CALL(mock, LnnGetLocalNumInfo)
730 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
731 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
732 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
733 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
734
735 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
736 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
737 }
738
739 /*
740 * @tc.name: LANE_FIND_LANERESOURCE_BY_LINKADDR_001
741 * @tc.desc: LANE FIND LANERESOURCE BY LINK ADDR TEST
742 * @tc.type: FUNC
743 * @tc.require:
744 */
745 HWTEST_F(LNNLaneExtMockTest, LANE_FIND_LANERESOURCE_BY_LINKADDR_001, TestSize.Level1)
746 {
747 NiceMock<LaneDepsInterfaceMock> mock;
748 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
749 LaneLinkInfo linkInfo;
750 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
751 linkInfo.type = LANE_HML;
752 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
753 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
754
755 LaneResource laneResourse;
756 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
757 int32_t ret = FindLaneResourceByLinkAddr(nullptr, &laneResourse);
758 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
759
760 ret = FindLaneResourceByLinkAddr(&linkInfo, nullptr);
761 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
762
763 ret = FindLaneResourceByLinkAddr(&linkInfo, &laneResourse);
764 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
765
766 uint64_t laneId = LANE_ID_BASE;
767 uint32_t clientRef = 0;
768 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
769 EXPECT_EQ(ret, SOFTBUS_OK);
770 clientRef++;
771
772 LaneLinkInfo linkInfoFind;
773 ASSERT_EQ(memset_s(&linkInfoFind, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
774 linkInfoFind.type = LANE_HML;
775 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
776 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
777
778 ASSERT_EQ(strcpy_s(linkInfoFind.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
779 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
780 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
781
782 ASSERT_EQ(strcpy_s(linkInfoFind.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
783 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
784 EXPECT_EQ(ret, SOFTBUS_OK);
785 EXPECT_FALSE(laneResourse.isServerSide);
786 EXPECT_EQ(laneResourse.clientRef, clientRef);
787 EXPECT_EQ(laneResourse.link.type, LANE_HML);
788 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
789 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
790 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
791
792 DelLaneResourceByLaneId(laneId, false);
793 EXPECT_EQ(ret, SOFTBUS_OK);
794 }
795
796 /*
797 * @tc.name: LANE_FIND_LANERESOURCE_BY_LINKTYPE_001
798 * @tc.desc: LANE FIND LANERESOURCE BY LINK TYPE TEST
799 * @tc.type: FUNC
800 * @tc.require:
801 */
802 HWTEST_F(LNNLaneExtMockTest, LANE_FIND_LANERESOURCE_BY_LINKTYPE_001, TestSize.Level1)
803 {
804 NiceMock<LaneDepsInterfaceMock> mock;
805 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
806 LaneLinkInfo linkInfo;
807 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
808 linkInfo.type = LANE_HML;
809 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
810 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
811
812 LaneResource laneResourse;
813 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
814 int32_t ret = FindLaneResourceByLinkType(nullptr, LANE_HML, &laneResourse);
815 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
816
817 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_LINK_TYPE_BUTT, &laneResourse);
818 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
819
820 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, nullptr);
821 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
822
823 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, &laneResourse);
824 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
825
826 uint64_t laneId = LANE_ID_BASE;
827 uint32_t clientRef = 0;
828 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
829 EXPECT_EQ(ret, SOFTBUS_OK);
830 clientRef++;
831
832 ret = FindLaneResourceByLinkType(LOCAL_UDID, LANE_HML, &laneResourse);
833 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
834
835 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_P2P, &laneResourse);
836 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
837
838 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, &laneResourse);
839 EXPECT_EQ(ret, SOFTBUS_OK);
840 EXPECT_FALSE(laneResourse.isServerSide);
841 EXPECT_EQ(laneResourse.clientRef, clientRef);
842 EXPECT_EQ(laneResourse.link.type, LANE_HML);
843 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
844 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
845 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
846
847 DelLaneResourceByLaneId(laneId, false);
848 EXPECT_EQ(ret, SOFTBUS_OK);
849 }
850
851 /*
852 * @tc.name: LANE_FIND_LANERESOURCE_BY_LANEID_001
853 * @tc.desc: LANE FIND LANERESOURCE BY LANEID TEST
854 * @tc.type: FUNC
855 * @tc.require:
856 */
857 HWTEST_F(LNNLaneExtMockTest, LANE_FIND_LANERESOURCE_BY_LANEID_001, TestSize.Level1)
858 {
859 NiceMock<LaneDepsInterfaceMock> mock;
860 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
861 LaneLinkInfo linkInfo;
862 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
863 linkInfo.type = LANE_HML;
864 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
865 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
866
867 LaneResource laneResourse;
868 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
869 uint64_t laneId = INVALID_LANE_ID;
870 int32_t ret = FindLaneResourceByLaneId(laneId, nullptr);
871 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
872
873 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
874 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
875
876 laneId = LANE_ID_BASE;
877 uint32_t clientRef = 0;
878 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
879 EXPECT_EQ(ret, SOFTBUS_OK);
880 clientRef++;
881
882 ret = FindLaneResourceByLaneId(INVALID_LANE_ID, &laneResourse);
883 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
884
885 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
886 EXPECT_EQ(ret, SOFTBUS_OK);
887 EXPECT_FALSE(laneResourse.isServerSide);
888 EXPECT_EQ(laneResourse.clientRef, clientRef);
889 EXPECT_EQ(laneResourse.link.type, LANE_HML);
890 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
891 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
892 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
893
894 DelLaneResourceByLaneId(laneId, false);
895 EXPECT_EQ(ret, SOFTBUS_OK);
896 }
897
898 /*
899 * @tc.name: LANE_DEL_AND_ADD_LANERESOURCEITEM_001
900 * @tc.desc: LANE_DEL AND ADD LANERESOURCEITEM CLIENT
901 * @tc.type: FUNC
902 * @tc.require:
903 */
904 HWTEST_F(LNNLaneExtMockTest, LANE_DEL_AND_ADD_LANERESOURCEITEM_001, TestSize.Level1)
905 {
906 NiceMock<LaneDepsInterfaceMock> mock;
907 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
908 LaneLinkInfo linkInfo;
909 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
910 linkInfo.type = LANE_HML;
911 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
912 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
913
914 uint64_t laneId = INVALID_LANE_ID;
915 int32_t ret = AddLaneResourceToPool(nullptr, laneId, false);
916 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
917 ret = AddLaneResourceToPool(&linkInfo, INVALID_LANE_ID, false);
918 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
919
920 laneId = LANE_ID_BASE;
921 uint32_t clientRef = 0;
922 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
923 EXPECT_EQ(ret, SOFTBUS_OK);
924 clientRef++;
925 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
926 EXPECT_EQ(ret, SOFTBUS_OK);
927 clientRef++;
928
929 LaneResource laneResourse;
930 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
931 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
932 EXPECT_EQ(ret, SOFTBUS_OK);
933 EXPECT_FALSE(laneResourse.isServerSide);
934 EXPECT_EQ(laneResourse.clientRef, clientRef);
935
936 ret = DelLaneResourceByLaneId(INVALID_LANE_ID, false);
937 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
938 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
939 EXPECT_EQ(laneResourse.clientRef, clientRef);
940
941 ret = DelLaneResourceByLaneId(laneId, false);
942 EXPECT_EQ(ret, SOFTBUS_OK);
943 clientRef--;
944 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
945 EXPECT_EQ(laneResourse.clientRef, clientRef);
946
947 ret = DelLaneResourceByLaneId(laneId, false);
948 EXPECT_EQ(ret, SOFTBUS_OK);
949 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
950 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
951 }
952
953 /*
954 * @tc.name: LANE_DEL_AND_ADD_LANERESOURCEITEM_002
955 * @tc.desc: LANE_DEL AND ADD LANERESOURCEITEM SERVER
956 * @tc.type: FUNC
957 * @tc.require:
958 */
959 HWTEST_F(LNNLaneExtMockTest, LANE_DEL_AND_ADD_LANERESOURCEITEM_002, TestSize.Level1)
960 {
961 NiceMock<LaneDepsInterfaceMock> mock;
962 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
963 LaneLinkInfo linkInfo;
964 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
965 linkInfo.type = LANE_HML;
966 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
967 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
968
969 uint64_t laneId = INVALID_LANE_ID;
970 int32_t ret = AddLaneResourceToPool(nullptr, laneId, true);
971 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
972
973 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
974 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
975
976 laneId = LANE_ID_BASE;
977 uint32_t serverRef = 0;
978 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
979 EXPECT_EQ(ret, SOFTBUS_OK);
980
981 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
982 EXPECT_EQ(ret, SOFTBUS_LANE_TRIGGER_LINK_FAIL);
983
984 LaneResource laneResourse;
985 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
986 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
987 EXPECT_EQ(ret, SOFTBUS_OK);
988 EXPECT_TRUE(laneResourse.isServerSide);
989 EXPECT_EQ(laneResourse.clientRef, serverRef);
990
991 ret = DelLaneResourceByLaneId(laneId, false);
992 EXPECT_EQ(ret, SOFTBUS_OK);
993
994 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
995 EXPECT_EQ(ret, SOFTBUS_OK);
996
997 ret = DelLaneResourceByLaneId(laneId, true);
998 EXPECT_EQ(ret, SOFTBUS_OK);
999 }
1000
1001 /*
1002 * @tc.name: LANE_GENERATE_LANE_ID_001
1003 * @tc.desc: LANE GENERATE LANE ID
1004 * @tc.type: FUNC
1005 * @tc.require:
1006 */
1007 HWTEST_F(LNNLaneExtMockTest, LANE_GENERATE_LANE_ID_001, TestSize.Level1)
1008 {
1009 NiceMock<LaneDepsInterfaceMock> laneMock;
1010 EXPECT_CALL(laneMock, SoftBusGenerateStrHash)
1011 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
1012 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfGenerateStrHash);
1013
1014 uint64_t laneId = GenerateLaneId(LOCAL_UDID, PEER_UDID, LANE_HML);
1015 EXPECT_EQ(laneId, INVALID_LANE_ID);
1016
1017 laneId = GenerateLaneId(LOCAL_UDID, PEER_UDID, LANE_HML);
1018 EXPECT_NE(laneId, INVALID_LANE_ID);
1019 }
1020
1021 /*
1022 * @tc.name: LNN_SELECT_AUTH_LANE_TEST_001
1023 * @tc.desc: SelectAuthLane
1024 * @tc.type: FUNC
1025 * @tc.require:
1026 */
1027 HWTEST_F(LNNLaneExtMockTest, LNN_SELECT_AUTH_LANE_TEST_001, TestSize.Level1)
1028 {
1029 const char *networkId = "testnetworkid123";
1030 NiceMock<LaneDepsInterfaceMock> mock;
1031 LanePreferredLinkList recommendList = {};
1032 LanePreferredLinkList request = {};
1033
1034 request.linkTypeNum = 4;
1035 request.linkType[0] = LANE_P2P;
1036 request.linkType[1] = LANE_BLE;
1037 request.linkType[2] = LANE_BR;
1038 request.linkType[3] = LANE_HML;
1039
1040 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1041 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1042 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1043 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1044 int32_t ret = SelectAuthLane(nullptr, &recommendList, &request);
1045 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1046
1047 ret = SelectAuthLane(networkId, nullptr, &request);
1048 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1049
1050 ret = SelectAuthLane(networkId, &recommendList, nullptr);
1051 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1052
1053 ret = SelectAuthLane(networkId, &recommendList, &request);
1054 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1055 }
1056
1057 /*
1058 * @tc.name: LANE_CLEAR_LANE_RESOURCE_BYLANEID_001
1059 * @tc.desc: ClearLaneResourceByLaneId
1060 * @tc.type: FUNC
1061 * @tc.require:
1062 */
1063 HWTEST_F(LNNLaneExtMockTest, LANE_CLEAR_LANE_RESOURCE_BYLANEID_001, TestSize.Level1)
1064 {
1065 NiceMock<LaneDepsInterfaceMock> mock;
1066 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1067
1068 uint64_t laneId = LANE_ID_BASE;
1069 int32_t ret = ClearLaneResourceByLaneId(laneId);
1070 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
1071
1072 LaneLinkInfo linkInfo = {};
1073 linkInfo.type = LANE_HML;
1074 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1075 EXPECT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1076 uint32_t clientRef = 0;
1077 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
1078 EXPECT_EQ(ret, SOFTBUS_OK);
1079
1080 LaneResource laneResourse = {};
1081 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
1082 EXPECT_EQ(ret, SOFTBUS_OK);
1083 EXPECT_TRUE(laneResourse.isServerSide);
1084 EXPECT_EQ(laneResourse.clientRef, clientRef);
1085
1086 ret = ClearLaneResourceByLaneId(laneId);
1087 EXPECT_EQ(ret, SOFTBUS_OK);
1088
1089 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
1090 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
1091 }
1092
1093 /*
1094 * @tc.name: LANE_PPOCESS_VAP_INFO_001
1095 * @tc.desc: ProcessVapInfo hml
1096 * @tc.type: FUNC
1097 * @tc.require:
1098 */
1099 HWTEST_F(LNNLaneExtMockTest, LANE_PPOCESS_VAP_INFO_001, TestSize.Level1)
1100 {
1101 NiceMock<LaneDepsInterfaceMock> mock;
1102 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1103 LaneLinkInfo linkInfo = {};
1104 linkInfo.type = LANE_P2P;
1105 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1106 EXPECT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1107 uint64_t laneId = LANE_ID_BASE;
1108 uint64_t laneIdExt = LANE_ID_BASE + 1;
1109 uint32_t clientRef = 0;
1110 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, true);
1111 EXPECT_EQ(ret, SOFTBUS_OK);
1112
1113 linkInfo.type = LANE_HML;
1114 ret = AddLaneResourceToPool(&linkInfo, laneIdExt, false);
1115 EXPECT_EQ(ret, SOFTBUS_OK);
1116 clientRef++;
1117
1118 ret = ClearLaneResourceByLaneId(laneId);
1119 EXPECT_EQ(ret, SOFTBUS_OK);
1120
1121 LaneResource laneResourse = {};
1122 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
1123 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
1124
1125 ret = FindLaneResourceByLaneId(laneIdExt, &laneResourse);
1126 EXPECT_EQ(ret, SOFTBUS_OK);
1127 EXPECT_TRUE(!laneResourse.isServerSide);
1128 EXPECT_EQ(laneResourse.clientRef, clientRef);
1129
1130 ret = DelLaneResourceByLaneId(laneIdExt, false);
1131 EXPECT_EQ(ret, SOFTBUS_OK);
1132 }
1133
1134 /*
1135 * @tc.name: LANE_PPOCESS_VAP_INFO_002
1136 * @tc.desc: ProcessVapInfo p2p
1137 * @tc.type: FUNC
1138 * @tc.require:
1139 */
1140 HWTEST_F(LNNLaneExtMockTest, LANE_PPOCESS_VAP_INFO_002, TestSize.Level1)
1141 {
1142 NiceMock<LaneDepsInterfaceMock> mock;
1143 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1144 LaneLinkInfo linkInfo = {};
1145 linkInfo.type = LANE_HML;
1146 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1147 EXPECT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1148 uint64_t laneId = LANE_ID_BASE;
1149 uint64_t laneIdExt = LANE_ID_BASE + 1;
1150 uint32_t clientRef = 0;
1151 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, true);
1152 EXPECT_EQ(ret, SOFTBUS_OK);
1153
1154 linkInfo.type = LANE_P2P;
1155 ret = AddLaneResourceToPool(&linkInfo, laneIdExt, false);
1156 EXPECT_EQ(ret, SOFTBUS_OK);
1157 clientRef++;
1158
1159 ret = ClearLaneResourceByLaneId(laneId);
1160 EXPECT_EQ(ret, SOFTBUS_OK);
1161
1162 LaneResource laneResourse = {};
1163 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
1164 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
1165
1166 ret = FindLaneResourceByLaneId(laneIdExt, &laneResourse);
1167 EXPECT_EQ(ret, SOFTBUS_OK);
1168 EXPECT_TRUE(!laneResourse.isServerSide);
1169 EXPECT_EQ(laneResourse.clientRef, clientRef);
1170
1171 ret = DelLaneResourceByLaneId(laneIdExt, false);
1172 EXPECT_EQ(ret, SOFTBUS_OK);
1173 }
1174
1175 /*
1176 * @tc.name: LNN_LANE_SELECT_01
1177 * @tc.desc: SelectLane
1178 * @tc.type: FUNC
1179 * @tc.require:
1180 */
1181 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_SELECT_01, TestSize.Level1)
1182 {
1183 const char *networkId = "test";
1184 LaneLinkType linkType = LANE_LINK_TYPE_BUTT;
1185 int32_t ret = LaneCheckLinkValid(networkId, linkType, LANE_T_BUTT);
1186 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1187 }
1188
1189 /*
1190 * @tc.name: LNN_LANE_SELECT_02
1191 * @tc.desc: SelectLane
1192 * @tc.type: FUNC
1193 * @tc.require:
1194 */
1195 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_SELECT_02, TestSize.Level1)
1196 {
1197 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1198 NiceMock<LaneDepsInterfaceMock> mock;
1199
1200 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
1201 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
1202 int32_t ret = GetErrCodeOfLink("networkId", LANE_WLAN_2P4G);
1203 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1204
1205 ret = GetErrCodeOfLink("networkId", LANE_P2P_REUSE);
1206 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1207
1208 ret = GetErrCodeOfLink("networkId", LANE_HML);
1209 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1210
1211 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
1212 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_DEACTIVATING));
1213 ret = GetErrCodeOfLink("networkId", LANE_HML);
1214 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1215
1216 ret = GetErrCodeOfLink("networkId", LANE_P2P_REUSE);
1217 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1218
1219 EXPECT_CALL(mock, SoftBusGetBtState)
1220 .WillRepeatedly(Return(0));
1221 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BR), SOFTBUS_LANE_BT_OFF);
1222 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE), SOFTBUS_LANE_BT_OFF);
1223 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_DIRECT), SOFTBUS_LANE_BT_OFF);
1224 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_REUSE), SOFTBUS_LANE_BT_OFF);
1225
1226 EXPECT_CALL(mock, SoftBusGetBtState)
1227 .WillRepeatedly(Return(1));
1228 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BR), SOFTBUS_LANE_LOCAL_NO_BR_STATIC_CAP);
1229 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE), SOFTBUS_LANE_LOCAL_NO_BLE_STATIC_CAP);
1230 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_DIRECT), SOFTBUS_LANE_LOCAL_NO_BLE_STATIC_CAP);
1231 }
1232
1233 /*
1234 * @tc.name: LNN_LANE_SELECT_RULE_01
1235 * @tc.desc: SelectLaneRule
1236 * @tc.type: FUNC
1237 * @tc.require:
1238 */
1239 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_SELECT_RULE_01, TestSize.Level1)
1240 {
1241 LaneLinkType linkList;
1242 uint32_t listNum = 0;
1243 LanePreferredLinkList recommendList;
1244 int32_t ret = FinalDecideLinkType(nullptr, &linkList, listNum, &recommendList);
1245 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1246
1247 ret = FinalDecideLinkType(nullptr, nullptr, listNum, &recommendList);
1248 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1249
1250 ret = FinalDecideLinkType(nullptr, nullptr, listNum, nullptr);
1251 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1252
1253 listNum = LANE_LINK_TYPE_BUTT;
1254 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
1255 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1256 }
1257
1258 /*
1259 * @tc.name: LNN_LANE_SELECT_RULE_02
1260 * @tc.desc: SelectLaneRule
1261 * @tc.type: FUNC
1262 * @tc.require:
1263 */
1264 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_SELECT_RULE_02, TestSize.Level1)
1265 {
1266 LaneLinkType linkList[LANE_LINK_TYPE_BUTT];
1267 uint32_t listNum = 1;
1268 LanePreferredLinkList recommendList;
1269
1270 NiceMock<LaneDepsInterfaceMock> linkMock;
1271 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1272 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1273 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1274 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1275
1276 linkList[0] = LANE_P2P;
1277 int32_t ret = FinalDecideLinkType("test", linkList, listNum, &recommendList);
1278 EXPECT_EQ(ret, SOFTBUS_OK);
1279 }
1280
1281 /*
1282 * @tc.name: LNN_LANE_SELECT_RULE_03
1283 * @tc.desc: SelectLaneRule
1284 * @tc.type: FUNC
1285 * @tc.require:
1286 */
1287 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_SELECT_RULE_03, TestSize.Level1)
1288 {
1289 LaneLinkType linkList;
1290 uint32_t listNum = 1;
1291 LanePreferredLinkList recommendList;
1292
1293 NiceMock<LaneDepsInterfaceMock> linkMock;
1294 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1295 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_NETWORK_NOT_FOUND)));
1296
1297 int32_t ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
1298 EXPECT_EQ(ret, SOFTBUS_OK);
1299
1300 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1301 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(-1), Return(SOFTBUS_OK)));
1302 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
1303 EXPECT_EQ(ret, SOFTBUS_OK);
1304
1305 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1306 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1307 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1308 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_INVALID_PARAM)));
1309 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
1310 EXPECT_EQ(ret, SOFTBUS_OK);
1311
1312 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1313 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(-1), Return(SOFTBUS_OK)));
1314 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
1315 EXPECT_EQ(ret, SOFTBUS_OK);
1316 }
1317
1318 /*
1319 * @tc.name: LNN_LANE_SELECT_RULE_04
1320 * @tc.desc: SelectLaneRule
1321 * @tc.type: FUNC
1322 * @tc.require:
1323 */
1324 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_SELECT_RULE_04, TestSize.Level1)
1325 {
1326 LaneSelectParam request;
1327 LanePreferredLinkList recommendList;
1328 int32_t ret = DecideAvailableLane("test", nullptr, &recommendList);
1329 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1330
1331 ret = DecideAvailableLane("test", &request, nullptr);
1332 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1333
1334 ret = DecideAvailableLane("test", nullptr, nullptr);
1335 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1336 }
1337
1338 /*
1339 * @tc.name: LNN_LANE_SELECT_RULE_05
1340 * @tc.desc: SelectLaneRule
1341 * @tc.type: FUNC
1342 * @tc.require:
1343 */
1344 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_SELECT_RULE_05, TestSize.Level1)
1345 {
1346 NiceMock<LaneDepsInterfaceMock> linkMock;
1347
1348 LnnWifiAdpterInterfaceMock wifiMock;
1349 LaneSelectParam request;
1350 LanePreferredLinkList recommendList;
1351
1352 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
1353 request.qosRequire.minLaneLatency = 0;
1354 EXPECT_CALL(linkMock, LnnGetRemoteNodeInfoById)
1355 .WillRepeatedly(Return(SOFTBUS_OK));
1356 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1357 .WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
1358 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
1359 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
1360 int32_t ret = DecideAvailableLane("test", &request, &recommendList);
1361 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1362
1363 request.transType = LANE_T_FILE;
1364 request.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
1365 request.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
1366 request.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
1367
1368 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo)
1369 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1370 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
1371 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1372
1373 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
1374 .WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1375 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
1376 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1377
1378 int32_t osType = OH_OS_TYPE;
1379 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
1380 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
1381 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
1382 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1383
1384 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1385 .WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
1386 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
1387 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
1388 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
1389 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1390 }
1391
1392 /*
1393 * @tc.name: LNN_LANE_09
1394 * @tc.desc: SelectLaneRule
1395 * @tc.type: FUNC
1396 * @tc.require:
1397 */
1398 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_09, TestSize.Level1)
1399 {
1400 LnnMacInfo macInfo;
1401 LaneLinkInfo linkInfo;
1402 linkInfo.type = LANE_P2P;
1403 NiceMock<LaneDepsInterfaceMock> laneDepMock;
1404 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.localIp, IP_LEN, PEER_IP_HML), EOK);
1405 EXPECT_EQ(strcpy_s(macInfo.localMac, MAX_MAC_LEN, LOCAL_MAC), EOK);
1406 EXPECT_EQ(strcpy_s(macInfo.remoteMac, MAX_MAC_LEN, PEER_MAC), EOK);
1407 int32_t ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
1408 EXPECT_EQ(ret, SOFTBUS_OK);
1409 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
1410 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1411 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1412 EXPECT_EQ(ret, SOFTBUS_OK);
1413
1414 linkInfo.type = LANE_P2P_REUSE;
1415 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
1416 EXPECT_EQ(ret, SOFTBUS_OK);
1417 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
1418 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1419 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1420 EXPECT_EQ(ret, SOFTBUS_OK);
1421
1422 linkInfo.type = LANE_HML;
1423 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
1424 EXPECT_EQ(ret, SOFTBUS_OK);
1425 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
1426 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1427 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1428 EXPECT_EQ(ret, SOFTBUS_OK);
1429
1430 linkInfo.type = LANE_ETH;
1431 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
1432 EXPECT_EQ(ret, SOFTBUS_OK);
1433 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1434 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
1435 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1436 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1437 EXPECT_EQ(ret, SOFTBUS_OK);
1438 }
1439
1440 /*
1441 * @tc.name: LNN_LANE_11
1442 * @tc.desc: SelectLaneRule
1443 * @tc.type: FUNC
1444 * @tc.require:
1445 */
1446 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_11, TestSize.Level1)
1447 {
1448 LaneLinkInfo linkInfo;
1449 NiceMock<LaneDepsInterfaceMock> laneDepMock;
1450 LnnMacInfo macInfo;
1451 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
1452 linkInfo.type = LANE_P2P;
1453 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1454 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1455 uint64_t laneId = LANE_ID_BASE;
1456 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1457 uint32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1458 EXPECT_EQ(ret, SOFTBUS_OK);
1459 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1460 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
1461 EXPECT_EQ(ret, SOFTBUS_OK);
1462 ret = DelLaneResourceByLaneId(laneId, false);
1463 EXPECT_EQ(ret, SOFTBUS_OK);
1464 }
1465
1466 /*
1467 * @tc.name: LNN_LANE_14
1468 * @tc.desc: SelectLaneRule
1469 * @tc.type: FUNC
1470 * @tc.require:
1471 */
1472 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_14, TestSize.Level1)
1473 {
1474 NiceMock<LaneDepsInterfaceMock> mock;
1475 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1476 LaneSelectParam selectParam = {};
1477 LanePreferredLinkList linkList = {};
1478 selectParam.transType = LANE_T_RAW_STREAM;
1479 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
1480 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
1481 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
1482
1483 wifiMock.SetDefaultResult();
1484 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_24G));
1485 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
1486 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1487 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1488 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1489 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1490 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1491 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1492
1493 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
1494 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_WIFI_STATIC_CAP);
1495 }
1496
1497 /*
1498 * @tc.name: LNN_LANE_15
1499 * @tc.desc: SelectLaneRule
1500 * @tc.type: FUNC
1501 * @tc.require:
1502 */
1503 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_15, TestSize.Level1)
1504 {
1505 NiceMock<LaneDepsInterfaceMock> mock;
1506 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1507 LaneSelectParam selectParam = {};
1508 LanePreferredLinkList linkList = {};
1509 selectParam.transType = LANE_T_RAW_STREAM;
1510 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
1511 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
1512 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
1513
1514 wifiMock.SetDefaultResult();
1515 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
1516 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
1517 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1518 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1519 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1520 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1521 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1522 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1523 EXPECT_CALL(mock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
1524 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
1525 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
1526 }
1527
1528 /*
1529 * @tc.name: LNN_LANE_16
1530 * @tc.desc: SelectLaneRule
1531 * @tc.type: FUNC
1532 * @tc.require:
1533 */
1534 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_16, TestSize.Level1)
1535 {
1536 NiceMock<LaneDepsInterfaceMock> mock;
1537 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1538 LaneSelectParam selectParam = {};
1539 LanePreferredLinkList linkList = {};
1540 selectParam.transType = LANE_T_RAW_STREAM;
1541 selectParam.qosRequire.minBW = HIGH_BW;
1542 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
1543 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
1544
1545 wifiMock.SetDefaultResult();
1546 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
1547 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
1548 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1549 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1550 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1551 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1552 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1553 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1554 EXPECT_CALL(mock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_NETWORK_NOT_FOUND));
1555 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
1556 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_FOUND);
1557 }
1558
1559 /*
1560 * @tc.name: LNN_LANE_17
1561 * @tc.desc: SelectLaneRule
1562 * @tc.type: FUNC
1563 * @tc.require:
1564 */
1565 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_17, TestSize.Level1)
1566 {
1567 NiceMock<LaneDepsInterfaceMock> mock;
1568 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1569 uint32_t listNum = 0;
1570 LanePreferredLinkList linkList = {};
1571 LaneSelectParam selectParam = {};
1572 selectParam.transType = LANE_T_FILE;
1573 selectParam.expectedBw = 0;
1574 selectParam.list.linkTypeNum = 2;
1575 selectParam.list.linkType[0] = LANE_WLAN_2P4G;
1576 selectParam.list.linkType[1] = LANE_COC_DIRECT;
1577 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1578 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
1579 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(63), Return(SOFTBUS_OK)));
1580 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
1581 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(63), Return(SOFTBUS_OK)));
1582 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1583 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1584 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1585 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1586 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
1587 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
1588 wifiMock.SetDefaultResult();
1589 SoftBusWifiLinkedInfo wlanInfo;
1590 wlanInfo.frequency = 1;
1591 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
1592 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
1593 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
1594 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
1595 EXPECT_EQ(ret, SOFTBUS_OK);
1596 }
1597
1598 /*
1599 * @tc.name: LNN_LANE_18
1600 * @tc.desc: SelectLaneRule
1601 * @tc.type: FUNC
1602 * @tc.require:
1603 */
1604 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_18, TestSize.Level1)
1605 {
1606 NiceMock<LaneDepsInterfaceMock> mock;
1607 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1608 uint32_t listNum = 0;
1609 LanePreferredLinkList linkList = {};
1610 LaneSelectParam selectParam = {};
1611 selectParam.transType = LANE_T_FILE;
1612 selectParam.expectedBw = 0;
1613 selectParam.list.linkTypeNum = 2;
1614 selectParam.list.linkType[0] = LANE_WLAN_2P4G;
1615 selectParam.list.linkType[1] = LANE_COC_DIRECT;
1616 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1617 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
1618 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(63), Return(SOFTBUS_OK)));
1619 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
1620 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(63), Return(SOFTBUS_OK)));
1621 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1622 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1623 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1624 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1625 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
1626 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
1627 wifiMock.SetDefaultResult();
1628 SoftBusWifiLinkedInfo wlanInfo;
1629 wlanInfo.frequency = FREQUENCY_2G_FIRST + 1;
1630 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
1631 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
1632 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
1633 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
1634 EXPECT_EQ(ret, SOFTBUS_OK);
1635 }
1636
1637 /*
1638 * @tc.name: LNN_LANE_19
1639 * @tc.desc: SelectLaneRule
1640 * @tc.type: FUNC
1641 * @tc.require:
1642 */
1643 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_19, TestSize.Level1)
1644 {
1645 LaneLinkType linkType = LANE_COC_DIRECT;
1646 NiceMock<LaneDepsInterfaceMock> linkMock;
1647 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1648 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1649 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1650 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1651 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1652 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM), Return(SOFTBUS_OK)))
1653 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(LOCAL_NUM), Return(SOFTBUS_OK)));
1654 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1655 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM), Return(SOFTBUS_OK)))
1656 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(LOCAL_NUM), Return(SOFTBUS_OK)));
1657 int32_t ret = LaneCheckLinkValid(NODE_NETWORK_ID, linkType, LANE_T_BUTT);
1658 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_COC_FEATURE);
1659 }
1660
1661 /*
1662 * @tc.name: LNN_LANE_20
1663 * @tc.desc: SelectLaneRule
1664 * @tc.type: FUNC
1665 * @tc.require:
1666 */
1667 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_20, TestSize.Level1)
1668 {
1669 LaneLinkType linkType = LANE_P2P_REUSE;
1670 NiceMock<LaneDepsInterfaceMock> linkMock;
1671 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1672 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1673 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
1674 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1675 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
1676 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_DEACTIVATING));
1677 int32_t ret = LaneCheckLinkValid(NODE_NETWORK_ID, linkType, LANE_T_BUTT);
1678 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_P2P_STATIC_CAP);
1679 }
1680
1681 /*
1682 * @tc.name: LNN_LANE_21
1683 * @tc.desc: SelectLaneRule
1684 * @tc.type: FUNC
1685 * @tc.require:
1686 */
1687 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_21, TestSize.Level1)
1688 {
1689 LaneLinkType linkType = LANE_P2P_REUSE;
1690 NiceMock<LaneDepsInterfaceMock> linkMock;
1691 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1692 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1693 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
1694 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1695 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
1696 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
1697 int32_t ret = LaneCheckLinkValid(NODE_NETWORK_ID, linkType, LANE_T_BUTT);
1698 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_P2P_STATIC_CAP);
1699 }
1700
1701 /*
1702 * @tc.name: LNN_LANE_22
1703 * @tc.desc: SelectLaneRule
1704 * @tc.type: FUNC
1705 * @tc.require:
1706 */
1707 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_22, TestSize.Level1)
1708 {
1709 LaneLinkType linkType = LANE_P2P_REUSE;
1710 NiceMock<LaneDepsInterfaceMock> linkMock;
1711 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1712 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM), Return(SOFTBUS_OK)));
1713 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1714 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM), Return(SOFTBUS_OK)));
1715 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1716 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
1717 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1718 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
1719 int32_t ret = LaneCheckLinkValid(NODE_NETWORK_ID, linkType, LANE_T_BUTT);
1720 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_P2P_REUSE_FEATURE);
1721 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1722 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
1723 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1724 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM2), Return(SOFTBUS_OK)));
1725 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1726 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM2), Return(SOFTBUS_OK)));
1727 ret = LaneCheckLinkValid(NODE_NETWORK_ID, linkType, LANE_T_BUTT);
1728 EXPECT_EQ(ret, SOFTBUS_OK);
1729 }
1730
1731 /*
1732 * @tc.name: LNN_LANE_23
1733 * @tc.desc: SelectLaneRule
1734 * @tc.type: FUNC
1735 * @tc.require:
1736 */
1737 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_23, TestSize.Level1)
1738 {
1739 NiceMock<LaneDepsInterfaceMock> mock;
1740 LanePreferredLinkList linkList = {};
1741 uint32_t listNum = 0;
1742 LaneSelectParam selectParam = {};
1743 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
1744 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
1745 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1746
1747 ret = SelectLane(nullptr, &selectParam, &linkList, &listNum);
1748 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1749 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, nullptr);
1750 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1751 }
1752
1753 /*
1754 * @tc.name: LNN_LANE_24
1755 * @tc.desc: SelectLaneRule
1756 * @tc.type: FUNC
1757 * @tc.require:
1758 */
1759 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_24, TestSize.Level1)
1760 {
1761 LanePreferredLinkList recommendList = {};
1762 LaneSelectParam selectParam = {};
1763 int32_t ret = SelectExpectLanesByQos(nullptr, &selectParam, &recommendList);
1764 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1765 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, nullptr);
1766 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1767 }
1768
1769 /*
1770 * @tc.name: LNN_LANE_25
1771 * @tc.desc: SelectLaneRule
1772 * @tc.type: FUNC
1773 * @tc.require:
1774 */
1775 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_25, TestSize.Level1)
1776 {
1777 NiceMock<LaneDepsInterfaceMock> linkMock;
1778 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1779 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
1780 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1781 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
1782 LaneLinkType linkType = LANE_ETH;
1783 int32_t ret = LaneCheckLinkValid(NODE_NETWORK_ID, linkType, LANE_T_BUTT);
1784 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_ETH_STATIC_CAP);
1785 }
1786
1787 /*
1788 * @tc.name: LNN_LANE_26
1789 * @tc.desc: SelectLaneRule
1790 * @tc.type: FUNC
1791 * @tc.require:
1792 */
1793 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_26, TestSize.Level1)
1794 {
1795 LaneLinkType linkType = LANE_ETH;
1796 int32_t ret = LaneCheckLinkValid(nullptr, linkType, LANE_T_BUTT);
1797 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1798 }
1799
1800 /*
1801 * @tc.name: LNN_LANE_27
1802 * @tc.desc: lane select fileTransLane by LNN
1803 * @tc.type: FUNC
1804 * @tc.require: I5FBFG
1805 */
1806 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_27, TestSize.Level1)
1807 {
1808 NiceMock<LaneDepsInterfaceMock> mock;
1809 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1810 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
1811 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
1812 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
1813 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
1814 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(63), Return(SOFTBUS_OK)));
1815 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
1816 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(63), Return(SOFTBUS_OK)));
1817 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1818 LanePreferredLinkList recommendList;
1819 (void)memset_s(&recommendList, sizeof(LanePreferredLinkList), 0, sizeof(LanePreferredLinkList));
1820 uint32_t listNum = 0;
1821 LaneSelectParam selectParam;
1822 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
1823 selectParam.transType = LANE_T_FILE;
1824 selectParam.expectedBw = 0;
1825 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
1826 EXPECT_EQ(ret, SOFTBUS_OK);
1827 EXPECT_EQ(listNum, 4);
1828 }
1829
1830 /*
1831 * @tc.name: LNN_LANE_28
1832 * @tc.desc: lane select fileTransLane by LNN
1833 * @tc.type: FUNC
1834 * @tc.require: I5FBFG
1835 */
1836 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_28, TestSize.Level1)
1837 {
1838 NiceMock<LaneDepsInterfaceMock> mock;
1839 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1840 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
1841 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
1842 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
1843 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
1844 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(63), Return(SOFTBUS_OK)));
1845 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
1846 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(63), Return(SOFTBUS_OK)));
1847 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1848 LanePreferredLinkList recommendList;
1849 (void)memset_s(&recommendList, sizeof(LanePreferredLinkList), 0, sizeof(LanePreferredLinkList));
1850 uint32_t listNum = 0;
1851 LaneSelectParam selectParam;
1852 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
1853 selectParam.transType = LANE_T_BYTE;
1854 selectParam.expectedBw = 0;
1855 selectParam.list.linkTypeNum = LANE_PREFERRED_LINK_NUM;
1856 selectParam.list.linkType[0] = LANE_WLAN_5G;
1857 selectParam.list.linkType[1] = LANE_BR;
1858 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
1859 EXPECT_EQ(ret, SOFTBUS_OK);
1860 EXPECT_EQ(listNum, 2);
1861 }
1862
1863 /*
1864 * @tc.name: LNN_LANE_UPDATE_LANE_ID_001
1865 * @tc.desc: test UpdateLaneResourceLaneId
1866 * @tc.type: FUNC
1867 * @tc.require:
1868 */
1869 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_UPDATE_LANE_ID_001, TestSize.Level1)
1870 {
1871 LaneLinkInfo linkInfo = {};
1872 linkInfo.type = LANE_HML;
1873 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1874 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1875
1876 NiceMock<LaneDepsInterfaceMock> laneDepMock;
1877 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1878 uint64_t laneId = LANE_ID_BASE;
1879 uint64_t laneIdNew = LANE_ID_BASE + 1;
1880 int32_t ret = UpdateLaneResourceLaneId(INVALID_LANE_ID, laneIdNew, PEER_UDID);
1881 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1882 ret = UpdateLaneResourceLaneId(laneId, INVALID_LANE_ID, PEER_UDID);
1883 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1884 ret = UpdateLaneResourceLaneId(laneId, laneIdNew, nullptr);
1885 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1886 ret = UpdateLaneResourceLaneId(laneId, laneIdNew, PEER_UDID);
1887 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
1888 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1889 EXPECT_EQ(ret, SOFTBUS_OK);
1890 ret = UpdateLaneResourceLaneId(laneId, laneIdNew, PEER_UDID);
1891 EXPECT_EQ(ret, SOFTBUS_OK);
1892 ret = DelLaneResourceByLaneId(laneIdNew, false);
1893 EXPECT_EQ(ret, SOFTBUS_OK);
1894 }
1895
1896 /*
1897 * @tc.name: LNN_LANE_DETECT_WIFI_DIRECT_APPLY_001
1898 * @tc.desc: test DetectEnableWifiDirectApply & DetectDisableWifiDirectApply
1899 * @tc.type: FUNC
1900 * @tc.require:
1901 */
1902 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_DETECT_WIFI_DIRECT_APPLY_001, TestSize.Level1)
1903 {
1904 LaneLinkInfo linkInfo = {};
1905 linkInfo.type = LANE_HML;
1906 linkInfo.linkInfo.p2p.bw = LANE_BW_160M;
1907 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1908 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1909 NiceMock<LaneDepsInterfaceMock> laneDepMock;
1910 NiceMock<LanePowerCtrlDepsInterfaceMock> powerCtrlMock;
1911 struct WifiDirectManager manager = g_manager;
1912 manager.getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIpError;
1913 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillOnce(Return(nullptr)).WillOnce(Return(&manager))
1914 .WillRepeatedly(Return(&g_manager));
1915 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1916 EXPECT_CALL(powerCtrlMock, IsPowerControlEnabled).WillRepeatedly(Return(true));
1917 EXPECT_CALL(powerCtrlMock, EnablePowerControl).WillOnce(Return(SOFTBUS_INVALID_PARAM))
1918 .WillRepeatedly(Return(SOFTBUS_OK));
1919
1920 uint64_t laneId = LANE_ID_BASE;
1921 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1922 EXPECT_EQ(ret, SOFTBUS_OK);
1923 DetectEnableWifiDirectApply();
1924 DetectDisableWifiDirectApply();
1925 DetectEnableWifiDirectApply();
1926 DetectDisableWifiDirectApply();
1927 ret = DelLaneResourceByLaneId(laneId, false);
1928 EXPECT_EQ(ret, SOFTBUS_OK);
1929
1930 linkInfo.linkInfo.p2p.bw = LANE_BW_80P80M;
1931 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1932 EXPECT_EQ(ret, SOFTBUS_OK);
1933 DetectEnableWifiDirectApply();
1934 DetectDisableWifiDirectApply();
1935 uint64_t laneIdRaw = LANE_ID_BASE + 1;
1936 linkInfo.type = LANE_HML_RAW;
1937 ret = AddLaneResourceToPool(&linkInfo, laneIdRaw, false);
1938 EXPECT_EQ(ret, SOFTBUS_OK);
1939 DetectEnableWifiDirectApply();
1940 ret = DelLaneResourceByLaneId(laneIdRaw, false);
1941 EXPECT_EQ(ret, SOFTBUS_OK);
1942 ret = DelLaneResourceByLaneId(laneId, false);
1943 EXPECT_EQ(ret, SOFTBUS_OK);
1944 }
1945
1946 /*
1947 * @tc.name: LNN_CHECK_LANE_RESOURCE_NUM_001
1948 * @tc.desc: test CheckLaneResourceNumByLinkType
1949 * @tc.type: FUNC
1950 * @tc.require:
1951 */
1952 HWTEST_F(LNNLaneExtMockTest, LNN_CHECK_LANE_RESOURCE_NUM_001, TestSize.Level1)
1953 {
1954 LaneLinkInfo linkInfo = {};
1955 linkInfo.type = LANE_HML;
1956 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1957 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1958 NiceMock<LaneDepsInterfaceMock> laneDepMock;
1959 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1960
1961 int32_t laneNum = 0;
1962 int32_t ret = CheckLaneResourceNumByLinkType(nullptr, LANE_HML, &laneNum);
1963 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1964 ret = CheckLaneResourceNumByLinkType(nullptr, LANE_LINK_TYPE_BUTT, &laneNum);
1965 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1966 ret = CheckLaneResourceNumByLinkType(PEER_UDID, LANE_HML, &laneNum);
1967 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
1968 uint64_t laneId = LANE_ID_BASE;
1969 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1970 EXPECT_EQ(ret, SOFTBUS_OK);
1971 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1972 EXPECT_EQ(ret, SOFTBUS_OK);
1973 ret = CheckLaneResourceNumByLinkType(PEER_UDID, LANE_HML, &laneNum);
1974 EXPECT_EQ(ret, SOFTBUS_OK);
1975 ret = DelLaneResourceByLaneId(laneId, false);
1976 EXPECT_EQ(ret, SOFTBUS_OK);
1977 ret = DelLaneResourceByLaneId(laneId, false);
1978 EXPECT_EQ(ret, SOFTBUS_OK);
1979 }
1980
1981 /*
1982 * @tc.name: LNN_ADD_LANE_IS_VALID_LINK_ADDR_001
1983 * @tc.desc: test IsValidLinkAddr(hml/br/ble)
1984 * @tc.type: FUNC
1985 * @tc.require:
1986 */
1987 HWTEST_F(LNNLaneExtMockTest, LNN_ADD_LANE_IS_VALID_LINK_ADDR_001, TestSize.Level1)
1988 {
1989 NiceMock<LaneDepsInterfaceMock> laneDepMock;
1990 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1991
1992 LaneLinkInfo linkInfo = {};
1993 linkInfo.type = LANE_HML;
1994 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1995 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.br.brMac, BT_MAC_LEN, PEER_MAC), EOK);
1996 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.ble.bleMac, BT_MAC_LEN, PEER_MAC), EOK);
1997 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1998 uint64_t laneId = LANE_ID_BASE;
1999 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2000 EXPECT_EQ(ret, SOFTBUS_OK);
2001 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2002 EXPECT_EQ(ret, SOFTBUS_OK);
2003 ret = DelLaneResourceByLaneId(laneId, false);
2004 EXPECT_EQ(ret, SOFTBUS_OK);
2005 ret = DelLaneResourceByLaneId(laneId, false);
2006 EXPECT_EQ(ret, SOFTBUS_OK);
2007
2008 linkInfo.type = LANE_BR;
2009 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2010 EXPECT_EQ(ret, SOFTBUS_OK);
2011 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2012 EXPECT_EQ(ret, SOFTBUS_OK);
2013 ret = DelLaneResourceByLaneId(laneId, false);
2014 EXPECT_EQ(ret, SOFTBUS_OK);
2015 ret = DelLaneResourceByLaneId(laneId, false);
2016 EXPECT_EQ(ret, SOFTBUS_OK);
2017
2018 linkInfo.type = LANE_BLE;
2019 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2020 EXPECT_EQ(ret, SOFTBUS_OK);
2021 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2022 EXPECT_EQ(ret, SOFTBUS_OK);
2023 ret = DelLaneResourceByLaneId(laneId, false);
2024 EXPECT_EQ(ret, SOFTBUS_OK);
2025 ret = DelLaneResourceByLaneId(laneId, false);
2026 EXPECT_EQ(ret, SOFTBUS_OK);
2027 }
2028
2029 /*
2030 * @tc.name: LNN_ADD_LANE_IS_VALID_LINK_ADDR_002
2031 * @tc.desc: test IsValidLinkAddr(coc_direct/wlan)
2032 * @tc.type: FUNC
2033 * @tc.require:
2034 */
2035 HWTEST_F(LNNLaneExtMockTest, LNN_ADD_LANE_IS_VALID_LINK_ADDR_002, TestSize.Level1)
2036 {
2037 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2038 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
2039
2040 LaneLinkInfo linkInfo = {};
2041 linkInfo.type = LANE_COC_DIRECT;
2042 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN,
2043 PEER_WLAN_ADDR), EOK);
2044 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.bleDirect.networkId, NETWORK_ID_BUF_LEN,
2045 NODE_NETWORK_ID), EOK);
2046 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
2047 uint64_t laneId = LANE_ID_BASE;
2048 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2049 EXPECT_EQ(ret, SOFTBUS_OK);
2050 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2051 EXPECT_EQ(ret, SOFTBUS_OK);
2052 ret = DelLaneResourceByLaneId(laneId, false);
2053 EXPECT_EQ(ret, SOFTBUS_OK);
2054 ret = DelLaneResourceByLaneId(laneId, false);
2055 EXPECT_EQ(ret, SOFTBUS_OK);
2056
2057 linkInfo.type = LANE_WLAN_5G;
2058 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2059 EXPECT_EQ(ret, SOFTBUS_OK);
2060 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2061 EXPECT_EQ(ret, SOFTBUS_OK);
2062 ret = DelLaneResourceByLaneId(laneId, false);
2063 EXPECT_EQ(ret, SOFTBUS_OK);
2064 ret = DelLaneResourceByLaneId(laneId, false);
2065 EXPECT_EQ(ret, SOFTBUS_OK);
2066
2067 linkInfo.type = LANE_LINK_TYPE_BUTT;
2068 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2069 EXPECT_EQ(ret, SOFTBUS_OK);
2070 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2071 EXPECT_EQ(ret, SOFTBUS_OK);
2072 ret = DelLaneResourceByLaneId(laneId, false);
2073 EXPECT_EQ(ret, SOFTBUS_OK);
2074 ret = DelLaneResourceByLaneId(laneId, false);
2075 EXPECT_EQ(ret, SOFTBUS_OK);
2076 }
2077
2078 /*
2079 * @tc.name: LNN_LANE_UPDATE_P2P_AVAILABILITY_001
2080 * @tc.desc: test updateP2pAvailability for create new node
2081 * @tc.type: FUNC
2082 * @tc.require:
2083 */
2084 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_UPDATE_P2P_AVAILABILITY_001, TestSize.Level1)
2085 {
2086 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateP2pAvailability(nullptr, false));
2087 EXPECT_EQ(SOFTBUS_OK, UpdateP2pAvailability(PEER_UDID, false));
2088 }
2089
2090 /*
2091 * @tc.name: LNN_LANE_UPDATE_P2P_AVAILABILITY_002
2092 * @tc.desc: test updateP2pAvailability for update exists node
2093 * @tc.type: FUNC
2094 * @tc.require:
2095 */
2096 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_UPDATE_P2P_AVAILABILITY_002, TestSize.Level1)
2097 {
2098 EXPECT_EQ(SOFTBUS_INVALID_PARAM, UpdateP2pAvailability(nullptr, false));
2099 EXPECT_EQ(SOFTBUS_OK, UpdateP2pAvailability(PEER_UDID, false));
2100 EXPECT_EQ(SOFTBUS_OK, UpdateP2pAvailability(PEER_UDID, false));
2101 }
2102
2103 /*
2104 * @tc.name: LNN_LANE_ADJUST_LINK_PRIORITY_FOR_RTT_001
2105 * @tc.desc: test adjustLinkPriorityForRtt with wifidirect ext cap
2106 * @tc.type: FUNC
2107 * @tc.require:
2108 */
2109 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_ADJUST_LINK_PRIORITY_FOR_RTT_001, TestSize.Level1)
2110 {
2111 NiceMock<LaneDepsInterfaceMock> laneMock;
2112 laneMock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2113 EXPECT_CALL(laneMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
2114 EXPECT_CALL(laneMock, LnnGetOsTypeByNetworkId)
2115 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(HO_OS_TYPE), Return(SOFTBUS_OK)));
2116 EXPECT_CALL(laneMock, LnnGetRemoteStrInfo).WillRepeatedly(
2117 DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(PEER_UDID, PEER_UDID + UDID_BUF_LEN), Return(SOFTBUS_OK)));
2118 EXPECT_CALL(laneMock, LnnGetLocalNumU32Info).WillRepeatedly(
2119 DoAll(SetArgPointee<LANE_MOCK_PARAM2>(127), Return(SOFTBUS_OK)));
2120 EXPECT_CALL(laneMock, LnnGetRemoteNumU32Info).WillRepeatedly(
2121 DoAll(SetArgPointee<LANE_MOCK_PARAM3>(127), Return(SOFTBUS_OK)));
2122 EXPECT_CALL(laneMock, LnnGetLocalNumU64Info).WillRepeatedly(
2123 DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
2124 EXPECT_CALL(laneMock, LnnGetRemoteNumU64Info).WillRepeatedly(
2125 DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
2126 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2127 wifiMock.SetDefaultResult();
2128
2129 EXPECT_EQ(SOFTBUS_OK, UpdateP2pAvailability(PEER_UDID, false));
2130 LanePreferredLinkList linkList = {};
2131 LaneSelectParam selectParam = {
2132 .transType = LANE_T_FILE,
2133 .qosRequire.minBW = HIGH_BW,
2134 .qosRequire.rttLevel = LANE_RTT_LEVEL_LOW,
2135 };
2136 EXPECT_EQ(SOFTBUS_OK, SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList));
2137 EXPECT_EQ(LANE_P2P, linkList.linkType[linkList.linkTypeNum - 1]);
2138 GTEST_LOG_(INFO) << "wait wifidirect ext cap exceed timeliness with 10s";
2139 std::this_thread::sleep_for(std::chrono::milliseconds(WIFI_DIRECT_EXT_CAP_VALID_TIME));
2140 EXPECT_EQ(SOFTBUS_OK, SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList));
2141 EXPECT_EQ(LANE_P2P, linkList.linkType[0]);
2142 }
2143
2144 /*
2145 * @tc.name: LNN_LANE_ADJUST_LINK_PRIORITY_FOR_RTT_002
2146 * @tc.desc: test adjustLinkPriorityForRtt with other conditions
2147 * @tc.type: FUNC
2148 * @tc.require:
2149 */
2150 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_ADJUST_LINK_PRIORITY_FOR_RTT_002, TestSize.Level1)
2151 {
2152 NiceMock<LaneDepsInterfaceMock> laneMock;
2153 laneMock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2154 EXPECT_CALL(laneMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
2155 EXPECT_CALL(laneMock, LnnGetOsTypeByNetworkId)
2156 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(OH_OS_TYPE), Return(SOFTBUS_OK)))
2157 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(HO_OS_TYPE), Return(SOFTBUS_OK)));
2158 EXPECT_CALL(laneMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillRepeatedly(
2159 DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(PEER_UDID, PEER_UDID + UDID_BUF_LEN), Return(SOFTBUS_OK)));
2160 EXPECT_CALL(laneMock, LnnGetLocalNumU32Info).WillRepeatedly(
2161 DoAll(SetArgPointee<LANE_MOCK_PARAM2>(127), Return(SOFTBUS_OK)));
2162 EXPECT_CALL(laneMock, LnnGetRemoteNumU32Info).WillRepeatedly(
2163 DoAll(SetArgPointee<LANE_MOCK_PARAM3>(127), Return(SOFTBUS_OK)));
2164 EXPECT_CALL(laneMock, LnnGetLocalNumU64Info).WillRepeatedly(
2165 DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
2166 EXPECT_CALL(laneMock, LnnGetRemoteNumU64Info).WillRepeatedly(
2167 DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
2168 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2169 wifiMock.SetDefaultResult();
2170
2171 EXPECT_EQ(SOFTBUS_OK, UpdateP2pAvailability(PEER_UDID, false));
2172 LanePreferredLinkList linkList = {};
2173 LaneSelectParam selectParam = {
2174 .transType = LANE_T_FILE,
2175 .qosRequire.minBW = HIGH_BW,
2176 .qosRequire.rttLevel = LANE_RTT_LEVEL_LOW,
2177 };
2178 EXPECT_EQ(SOFTBUS_OK, SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList));
2179 EXPECT_EQ(LANE_P2P, linkList.linkType[0]);
2180 EXPECT_EQ(SOFTBUS_OK, SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList));
2181 EXPECT_EQ(LANE_P2P, linkList.linkType[0]);
2182 }
2183 } // namespace OHOS
2184