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_ctrl_lane.h"
23 #include "lnn_feature_capability.h"
24 #include "lnn_lane.h"
25 #include "lnn_lane_common.h"
26 #include "lnn_lane_deps_mock.h"
27 #include "lnn_lane_def.h"
28 #include "lnn_lane_interface.h"
29 #include "lnn_lane_link.h"
30 #include "lnn_lane_model.h"
31 #include "lnn_lane_select.h"
32 #include "lnn_select_rule.h"
33 #include "lnn_wifi_adpter_mock.h"
34 #include "message_handler.h"
35 #include "softbus_adapter_mem.h"
36 #include "softbus_adapter_thread.h"
37 #include "softbus_error_code.h"
38 #include "softbus_wifi_api_adapter.h"
39 #include "lnn_lane_reliability.h"
40 #include "lnn_lane_reliability.c"
41 #include "wifi_direct_error_code.h"
42
43 namespace OHOS {
44 using namespace testing::ext;
45 using namespace testing;
46
47 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
48 constexpr char PEER_IP_HML[] = "172.30.0.1";
49 constexpr char PEER_MAC[] = "a1:b2:c3:d4:e5:f6";
50 constexpr char LOCAL_MAC[] = "a2:b2:c3:d4:e5:f6";
51 constexpr char PEER_UDID[] = "111122223333abcdef";
52 constexpr char LOCAL_UDID[] = "444455556666abcdef";
53 constexpr uint64_t LANE_ID_BASE = 1122334455667788;
54 constexpr uint32_t DEFAULT_SELECT_NUM = 4;
55 constexpr uint32_t DEFAULT_QOSINFO_MIN_BW = 10;
56 constexpr uint32_t DEFAULT_QOSINFO_MAX_LATENCY = 10000;
57 constexpr uint32_t DEFAULT_QOSINFO_MIN_LATENCY = 2500;
58 constexpr uint32_t DEFAULT_LANE_RESOURCE_LANE_REF = 0;
59 constexpr uint32_t LOW_BW = 384 * 1024;
60 constexpr uint32_t MID_BW = 30 * 1024 * 1024;
61 constexpr uint32_t HIGH_BW = 160 * 1024 * 1024;
62 constexpr uint32_t MESH_MAGIC_NUMBER = 0x5A5A5A5A;
63 constexpr uint32_t PORT_A = 22;
64 constexpr uint32_t PORT_B = 25;
65 constexpr uint32_t FD = 888;
66 constexpr uint32_t SLEEP_FOR_LOOP_COMPLETION_MS = 50;
67 constexpr uint32_t NET_CAP = 63;
68 constexpr uint32_t FREQUENCY_2G_FIRST = 2412;
69 constexpr uint32_t LOCAL_NUM = 8192;
70 constexpr uint32_t ROM_NUM = 8;
71 constexpr uint32_t ROM_NUM2 = 2;
72
73 static SoftBusCond g_cond = {0};
74 static SoftBusMutex g_lock = {0};
75
76 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info);
77 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode);
78 static void OnLaneFreeSuccess(uint32_t laneHandle);
79 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode);
80
81 static int32_t g_errCode = 0;
82 static LaneAllocListener g_listener = {
83 .onLaneAllocSuccess = OnLaneAllocSuccess,
84 .onLaneAllocFail = OnLaneAllocFail,
85 .onLaneFreeSuccess = OnLaneFreeSuccess,
86 .onLaneFreeFail = OnLaneFreeFail,
87 };
88
OnLaneRequestSuccess(uint32_t laneId,const LaneConnInfo * info)89 static void OnLaneRequestSuccess(uint32_t laneId, const LaneConnInfo *info)
90 {
91 GTEST_LOG_(INFO) << "OnLaneRequestSuccess";
92 }
93
OnLaneRequestFail(uint32_t laneId,int32_t reason)94 static void OnLaneRequestFail(uint32_t laneId, int32_t reason)
95 {
96 GTEST_LOG_(INFO) << "OnLaneRequestFail";
97 }
98
99 static ILaneListener g_listener2 = {
100 .onLaneRequestSuccess = OnLaneRequestSuccess,
101 .onLaneRequestFail = OnLaneRequestFail,
102 };
103
104 static NodeInfo g_NodeInfo = {
105 .p2pInfo.p2pRole = 1,
106 .p2pInfo.p2pMac = "abc",
107 .p2pInfo.goMac = "abc",
108 };
109
110 class LNNLaneMockTest : public testing::Test {
111 public:
112 static void SetUpTestCase();
113 static void TearDownTestCase();
114 void SetUp();
115 void TearDown();
116 };
117
SetUpTestCase()118 void LNNLaneMockTest::SetUpTestCase()
119 {
120 int32_t ret = LnnInitLnnLooper();
121 EXPECT_TRUE(ret == SOFTBUS_OK);
122 ret = LooperInit();
123 NiceMock<LaneDepsInterfaceMock> mock;
124 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(LaneDepsInterfaceMock::ActionOfStartBaseClient);
125 ret = InitLane();
126 EXPECT_TRUE(ret == SOFTBUS_OK);
127 GTEST_LOG_(INFO) << "LNNLaneMockTest start";
128 }
129
TearDownTestCase()130 void LNNLaneMockTest::TearDownTestCase()
131 {
132 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
133 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
134 DeinitLane();
135 LooperDeinit();
136 LnnDeinitLnnLooper();
137 GTEST_LOG_(INFO) << "LNNLaneMockTest end";
138 }
139
SetUp()140 void LNNLaneMockTest::SetUp()
141 {
142 (void)SoftBusMutexInit(&g_lock, nullptr);
143 (void)SoftBusCondInit(&g_cond);
144 }
145
TearDown()146 void LNNLaneMockTest::TearDown()
147 {
148 (void)SoftBusCondDestroy(&g_cond);
149 (void)SoftBusCondDestroy(&g_lock);
150 }
151
CondSignal(void)152 static void CondSignal(void)
153 {
154 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
155 return;
156 }
157 if (SoftBusCondSignal(&g_cond) != SOFTBUS_OK) {
158 (void)SoftBusMutexUnlock(&g_lock);
159 return;
160 }
161 (void)SoftBusMutexUnlock(&g_lock);
162 }
163
CondWait(void)164 static void CondWait(void)
165 {
166 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
167 return;
168 }
169 if (SoftBusCondWait(&g_cond, &g_lock, nullptr) != SOFTBUS_OK) {
170 (void)SoftBusMutexUnlock(&g_lock);
171 return;
172 }
173 (void)SoftBusMutexUnlock(&g_lock);
174 }
175
OnLaneAllocSuccess(uint32_t laneHandle,const LaneConnInfo * info)176 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info)
177 {
178 ASSERT_NE(info, nullptr) << "invalid info";
179 GTEST_LOG_(INFO) << "alloc lane successful, laneReqId=" << laneHandle << ", linkType=" << info->type;
180 const LnnLaneManager *laneManager = GetLaneManager();
181 int32_t ret = laneManager->lnnFreeLane(laneHandle);
182 EXPECT_TRUE(ret == SOFTBUS_OK);
183 CondSignal();
184 }
185
OnLaneAllocFail(uint32_t laneHandle,int32_t errCode)186 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode)
187 {
188 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
189 EXPECT_NE(errCode, SOFTBUS_OK);
190 g_errCode = errCode;
191 const LnnLaneManager *laneManager = GetLaneManager();
192 int32_t ret = laneManager->lnnFreeLane(laneHandle);
193 EXPECT_TRUE(ret == SOFTBUS_OK);
194 CondSignal();
195 }
196
OnLaneFreeSuccess(uint32_t laneHandle)197 static void OnLaneFreeSuccess(uint32_t laneHandle)
198 {
199 GTEST_LOG_(INFO) << "free lane success, laneReqId=" << laneHandle;
200 CondSignal();
201 }
202
OnLaneFreeFail(uint32_t laneHandle,int32_t errCode)203 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode)
204 {
205 GTEST_LOG_(INFO) << "free lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
206 CondSignal();
207 }
208
OnLaneLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)209 static void OnLaneLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
210 {
211 (void)reqId;
212 (void)reason;
213 (void)linkType;
214 return;
215 }
216
OnLaneLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)217 static void OnLaneLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
218 {
219 (void)reqId;
220 (void)linkType;
221 (void)linkInfo;
222 return;
223 }
224
OnLaneLinkSuccessForDetect(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)225 static void OnLaneLinkSuccessForDetect(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
226 {
227 (void)reqId;
228 (void)linkInfo;
229 GTEST_LOG_(INFO) << "on laneLink success for detect";
230 EXPECT_EQ(linkType, LANE_WLAN_5G);
231 }
232
OnLaneLinkFailForDetect(uint32_t reqId,int32_t reason,LaneLinkType linkType)233 static void OnLaneLinkFailForDetect(uint32_t reqId, int32_t reason, LaneLinkType linkType)
234 {
235 (void)reqId;
236 (void)linkType;
237 GTEST_LOG_(INFO) << "on laneLink fail for detect";
238 EXPECT_EQ(reason, SOFTBUS_OK);
239 }
240
OnLaneAllocSuccessForHml(uint32_t laneHandle,const LaneConnInfo * info)241 static void OnLaneAllocSuccessForHml(uint32_t laneHandle, const LaneConnInfo *info)
242 {
243 (void)laneHandle;
244 ASSERT_NE(info, nullptr) << "invalid connInfo";
245 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
246 EXPECT_EQ(info->type, LANE_HML);
247 CondSignal();
248 }
249
OnLaneAllocSuccessForP2p(uint32_t laneHandle,const LaneConnInfo * info)250 static void OnLaneAllocSuccessForP2p(uint32_t laneHandle, const LaneConnInfo *info)
251 {
252 (void)laneHandle;
253 ASSERT_NE(info, nullptr) << "invalid connInfo";
254 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
255 EXPECT_EQ(info->type, LANE_P2P);
256 CondSignal();
257 }
258
OnLaneAllocSuccessForBr(uint32_t laneHandle,const LaneConnInfo * info)259 static void OnLaneAllocSuccessForBr(uint32_t laneHandle, const LaneConnInfo *info)
260 {
261 (void)laneHandle;
262 ASSERT_NE(info, nullptr) << "invalid connInfo";
263 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
264 EXPECT_EQ(info->type, LANE_BR);
265 CondSignal();
266 }
267
OnLaneAllocSuccessForWlan5g(uint32_t laneHandle,const LaneConnInfo * info)268 static void OnLaneAllocSuccessForWlan5g(uint32_t laneHandle, const LaneConnInfo *info)
269 {
270 (void)laneHandle;
271 ASSERT_NE(info, nullptr) << "invalid connInfo";
272 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
273 EXPECT_EQ(info->type, LANE_WLAN_5G);
274 CondSignal();
275 }
276
OnLaneAllocSuccessForBle(uint32_t laneHandle,const LaneConnInfo * info)277 static void OnLaneAllocSuccessForBle(uint32_t laneHandle, const LaneConnInfo *info)
278 {
279 (void)laneHandle;
280 ASSERT_NE(info, nullptr) << "invalid connInfo";
281 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
282 EXPECT_EQ(info->type, LANE_BLE);
283 CondSignal();
284 }
285
OnLaneAllocFailNoExcept(uint32_t laneHandle,int32_t errCode)286 static void OnLaneAllocFailNoExcept(uint32_t laneHandle, int32_t errCode)
287 {
288 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle;
289 EXPECT_EQ(errCode, SOFTBUS_LANE_SUCC_AFTER_CANCELED);
290 CondSignal();
291 }
292
OnLaneAllocFailNoExcept2(uint32_t laneHandle,int32_t errCode)293 static void OnLaneAllocFailNoExcept2(uint32_t laneHandle, int32_t errCode)
294 {
295 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle;
296 EXPECT_EQ(errCode, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
297 CondSignal();
298 }
299
300 static LaneAllocListener g_listenerCbForHml = {
301 .onLaneAllocSuccess = OnLaneAllocSuccessForHml,
302 .onLaneAllocFail = OnLaneAllocFailNoExcept,
303 .onLaneFreeSuccess = OnLaneFreeSuccess,
304 .onLaneFreeFail = OnLaneFreeFail,
305 };
306
307 static LaneAllocListener g_listenerCbForP2p = {
308 .onLaneAllocSuccess = OnLaneAllocSuccessForP2p,
309 .onLaneAllocFail = OnLaneAllocFailNoExcept,
310 .onLaneFreeSuccess = OnLaneFreeSuccess,
311 .onLaneFreeFail = OnLaneFreeFail,
312 };
313
314 static LaneAllocListener g_listenerCbForP2p2 = {
315 .onLaneAllocSuccess = OnLaneAllocSuccessForP2p,
316 .onLaneAllocFail = OnLaneAllocFailNoExcept2,
317 .onLaneFreeSuccess = OnLaneFreeSuccess,
318 .onLaneFreeFail = OnLaneFreeFail,
319 };
320
321 static LaneAllocListener g_listenerCbForBr = {
322 .onLaneAllocSuccess = OnLaneAllocSuccessForBr,
323 .onLaneAllocFail = OnLaneAllocFailNoExcept,
324 .onLaneFreeSuccess = OnLaneFreeSuccess,
325 .onLaneFreeFail = OnLaneFreeFail,
326 };
327
328 static LaneAllocListener g_listenerCbForWlan5g = {
329 .onLaneAllocSuccess = OnLaneAllocSuccessForWlan5g,
330 .onLaneAllocFail = OnLaneAllocFailNoExcept,
331 .onLaneFreeSuccess = OnLaneFreeSuccess,
332 .onLaneFreeFail = OnLaneFreeFail,
333 };
334
335 static LaneAllocListener g_listenerCbForBle = {
336 .onLaneAllocSuccess = OnLaneAllocSuccessForBle,
337 .onLaneAllocFail = OnLaneAllocFailNoExcept,
338 .onLaneFreeSuccess = OnLaneFreeSuccess,
339 .onLaneFreeFail = OnLaneFreeFail,
340 };
341
AddLaneResourceForAllocTest(LaneLinkType linkType)342 static int32_t AddLaneResourceForAllocTest(LaneLinkType linkType)
343 {
344 LaneLinkInfo linkInfo = {};
345 linkInfo.type = linkType;
346 if (strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)) != EOK) {
347 return SOFTBUS_STRCPY_ERR;
348 }
349 if (strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)) != EOK) {
350 return SOFTBUS_STRCPY_ERR;
351 }
352 return AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
353 }
354
CreateAllocInfoForAllocTest(LaneTransType transType,uint32_t minBW,uint32_t maxLaneLatency,uint32_t minLaneLatency,LaneAllocInfo * allocInfo)355 static void CreateAllocInfoForAllocTest(LaneTransType transType, uint32_t minBW, uint32_t maxLaneLatency,
356 uint32_t minLaneLatency, LaneAllocInfo *allocInfo)
357 {
358 ASSERT_NE(allocInfo, nullptr) << "invalid allocInfo";
359 allocInfo->type = LANE_TYPE_TRANS;
360 ASSERT_EQ(strncpy_s(allocInfo->networkId, NETWORK_ID_BUF_LEN,
361 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
362 allocInfo->transType = transType;
363 allocInfo->qosRequire.minBW = minBW;
364 allocInfo->qosRequire.maxLaneLatency = maxLaneLatency;
365 allocInfo->qosRequire.minLaneLatency = minLaneLatency;
366 }
367
PrejudgeAvailability(const char * remoteNetworkId,enum WifiDirectLinkType connectType)368 static int32_t PrejudgeAvailability(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
369 {
370 (void)remoteNetworkId;
371 (void)connectType;
372 GTEST_LOG_(INFO) << "PrejudgeAvailability Enter";
373 return SOFTBUS_OK;
374 }
375
GetLocalAndRemoteMacByLocalIp(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)376 static int32_t GetLocalAndRemoteMacByLocalIp(const char *localIp, char *localMac, size_t localMacSize,
377 char *remoteMac, size_t remoteMacSize)
378 {
379 (void)localIp;
380 (void)localMac;
381 (void)localMacSize;
382 (void)remoteMac;
383 (void)remoteMacSize;
384 return SOFTBUS_OK;
385 }
386
387 static struct WifiDirectManager g_manager = {
388 .prejudgeAvailability = PrejudgeAvailability,
389 .getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIp,
390 };
391 /*
392 * @tc.name: LANE_ALLOC_ErrTest_001
393 * @tc.desc: lane errcode test
394 * @tc.type: FUNC
395 * @tc.require:
396 */
397 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_ERRTEST_001, TestSize.Level1)
398 {
399 const LnnLaneManager *laneManager = GetLaneManager();
400 LaneType laneType = LANE_TYPE_TRANS;
401 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
402 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
403
404 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
405 wifiMock.SetDefaultResult();
406 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
407 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfOnConnectP2pFail);
408 NiceMock<LaneDepsInterfaceMock> mock;
409 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
410 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
411 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_CONN_FAIL));
412 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
413
414 LaneAllocInfo allocInfo = {};
415 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
416 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
417 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listener);
418 EXPECT_EQ(ret, SOFTBUS_OK);
419 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_LOOP_COMPLETION_MS));
420 EXPECT_EQ(g_errCode, ERROR_WIFI_OFF);
421
422 (void)laneManager->lnnFreeLane(laneReqId);
423 }
424
425 /*
426 * @tc.name: LANE_ALLOC_Test_001
427 * @tc.desc: lane alloc by select default link for T_MSG (build wlan5g)
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_001, TestSize.Level1)
432 {
433 const LnnLaneManager *laneManager = GetLaneManager();
434 LaneType laneType = LANE_TYPE_TRANS;
435 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
436 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
437
438 NiceMock<LaneDepsInterfaceMock> mock;
439 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
440 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
441 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
442 char buf[] = "lanedetect";
443 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
444 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
445 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
446 wifiMock.SetDefaultResult();
447 SoftBusWifiLinkedInfo wlanInfo;
448 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
449 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
450 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
451
452 LaneAllocInfo allocInfo = {};
453 CreateAllocInfoForAllocTest(LANE_T_MSG, 0, 0, 0, &allocInfo);
454 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
455 EXPECT_EQ(ret, SOFTBUS_OK);
456 CondWait();
457 ret = laneManager->lnnFreeLane(laneReqId);
458 EXPECT_EQ(ret, SOFTBUS_OK);
459 CondWait();
460 }
461
462 /*
463 * @tc.name: LANE_ALLOC_Test_002
464 * @tc.desc: lane alloc by select default link for T_BYTE (not enable wlan and br, build ble)
465 * @tc.type: FUNC
466 * @tc.require:
467 */
468 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_002, TestSize.Level1)
469 {
470 const LnnLaneManager *laneManager = GetLaneManager();
471 LaneType laneType = LANE_TYPE_TRANS;
472 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
473 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
474
475 NiceMock<LaneDepsInterfaceMock> mock;
476 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
477 mock.SetDefaultResultForAlloc(1 << BIT_BLE, 1 << BIT_BLE, 0, 0);
478 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
479 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
480 wifiMock.SetDefaultResult();
481 LaneAllocInfo allocInfo = {};
482 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
483 PEER_MAC, strlen(PEER_MAC)), EOK);
484 CreateAllocInfoForAllocTest(LANE_T_BYTE, 0, 0, 0, &allocInfo);
485 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBle);
486 EXPECT_EQ(ret, SOFTBUS_OK);
487 CondWait();
488 ret = laneManager->lnnFreeLane(laneReqId);
489 EXPECT_EQ(ret, SOFTBUS_OK);
490 CondWait();
491 }
492
493 /*
494 * @tc.name: LANE_ALLOC_Test_003
495 * @tc.desc: lane alloc by select default link for T_FILE (not enable wlan and hml, build p2p)
496 * @tc.type: FUNC
497 * @tc.require:
498 */
499 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_003, TestSize.Level1)
500 {
501 const LnnLaneManager *laneManager = GetLaneManager();
502 LaneType laneType = LANE_TYPE_TRANS;
503 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
504 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
505
506 NiceMock<LaneDepsInterfaceMock> mock;
507 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
508 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
509 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
510 wifiMock.SetDefaultResult();
511 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
512 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
513
514 LaneAllocInfo allocInfo = {};
515 CreateAllocInfoForAllocTest(LANE_T_FILE, 0, 0, 0, &allocInfo);
516 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
517 EXPECT_EQ(ret, SOFTBUS_OK);
518 CondWait();
519
520 ret = laneManager->lnnFreeLane(laneReqId);
521 EXPECT_EQ(ret, SOFTBUS_OK);
522 }
523
524 /*
525 * @tc.name: LANE_ALLOC_Test_004
526 * @tc.desc: lane alloc by select default link for T_RAW_STREAM (not enable wlan, build p2p)
527 * @tc.type: FUNC
528 * @tc.require:
529 */
530 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_004, TestSize.Level1)
531 {
532 const LnnLaneManager *laneManager = GetLaneManager();
533 LaneType laneType = LANE_TYPE_TRANS;
534 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
535 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
536
537 NiceMock<LaneDepsInterfaceMock> mock;
538 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
539 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
540 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
541 wifiMock.SetDefaultResult();
542 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
543 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
544
545 LaneAllocInfo allocInfo = {};
546 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, 0, 0, 0, &allocInfo);
547 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
548 EXPECT_EQ(ret, SOFTBUS_OK);
549 CondWait();
550 ret = laneManager->lnnFreeLane(laneReqId);
551 EXPECT_EQ(ret, SOFTBUS_OK);
552 }
553
554 /*
555 * @tc.name: LANE_ALLOC_Test_005
556 * @tc.desc: lane alloc by mesh link (not enable wlan, build br)
557 * @tc.type: FUNC
558 * @tc.require:
559 */
560 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_005, TestSize.Level1)
561 {
562 const LnnLaneManager *laneManager = GetLaneManager();
563 LaneType laneType = LANE_TYPE_TRANS;
564 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
565 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
566
567 NiceMock<LaneDepsInterfaceMock> mock;
568 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
569 mock.SetDefaultResultForAlloc(1 << BIT_BR, 1 << BIT_BR, 0, 0);
570 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
571 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
572 wifiMock.SetDefaultResult();
573
574 LaneAllocInfo allocInfo = {};
575 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, MESH_MAGIC_NUMBER, 0, 0, &allocInfo);
576 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
577 EXPECT_EQ(ret, SOFTBUS_OK);
578 CondWait();
579 ret = laneManager->lnnFreeLane(laneReqId);
580 EXPECT_EQ(ret, SOFTBUS_OK);
581 CondWait();
582 }
583
584 /*
585 * @tc.name: LANE_ALLOC_Test_006
586 * @tc.desc: lane alloc by RTT link (not enable hml, build p2p)
587 * @tc.type: FUNC
588 * @tc.require:
589 */
590 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_006, TestSize.Level1)
591 {
592 const LnnLaneManager *laneManager = GetLaneManager();
593 LaneType laneType = LANE_TYPE_TRANS;
594 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
595 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
596
597 NiceMock<LaneDepsInterfaceMock> mock;
598 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
599 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
600 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
601 wifiMock.SetDefaultResult();
602 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
603 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
604
605 LaneAllocInfo allocInfo = {};
606 allocInfo.qosRequire.rttLevel = LANE_RTT_LEVEL_LOW;
607 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, DEFAULT_QOSINFO_MIN_BW, 0, 0, &allocInfo);
608 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
609 EXPECT_EQ(ret, SOFTBUS_OK);
610 CondWait();
611 ret = laneManager->lnnFreeLane(laneReqId);
612 EXPECT_EQ(ret, SOFTBUS_OK);
613 }
614
615 /*
616 * @tc.name: LANE_ALLOC_Test_007
617 * @tc.desc: lane alloc by qos require (HIGH_BW, build hml)
618 * @tc.type: FUNC
619 * @tc.require:
620 */
621 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_007, TestSize.Level1)
622 {
623 const LnnLaneManager *laneManager = GetLaneManager();
624 LaneType laneType = LANE_TYPE_TRANS;
625 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
626 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
627
628 NiceMock<LaneDepsInterfaceMock> mock;
629 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
630 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 1 << BIT_WIFI_DIRECT_TLV_NEGOTIATION,
631 1 << BIT_WIFI_DIRECT_TLV_NEGOTIATION);
632 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
633 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
634 wifiMock.SetDefaultResult();
635 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
636 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
637
638 LaneAllocInfo allocInfo = {};
639 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
640 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
641 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForHml);
642 EXPECT_EQ(ret, SOFTBUS_OK);
643 CondWait();
644 ret = laneManager->lnnFreeLane(laneReqId);
645 EXPECT_EQ(ret, SOFTBUS_OK);
646 }
647
648 /*
649 * @tc.name: LANE_ALLOC_Test_008
650 * @tc.desc: lane alloc by qos require (MID_HIGH_BW, not enable hml, build wlan5g)
651 * @tc.type: FUNC
652 * @tc.require:
653 */
654 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_008, TestSize.Level1)
655 {
656 const LnnLaneManager *laneManager = GetLaneManager();
657 LaneType laneType = LANE_TYPE_TRANS;
658 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
659 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
660
661 NiceMock<LaneDepsInterfaceMock> mock;
662 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
663 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
664 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
665 char buf[] = "lanedetect";
666 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
667 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
668 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
669 wifiMock.SetDefaultResult();
670 SoftBusWifiLinkedInfo wlanInfo;
671 wlanInfo.band = 0;
672 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
673 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
674 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
675
676 LaneAllocInfo allocInfo = {};
677 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + MID_BW, DEFAULT_QOSINFO_MAX_LATENCY,
678 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
679 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
680 EXPECT_EQ(ret, SOFTBUS_OK);
681 CondWait();
682 ret = laneManager->lnnFreeLane(laneReqId);
683 EXPECT_EQ(ret, SOFTBUS_OK);
684 CondWait();
685 }
686
687 /*
688 * @tc.name: LANE_ALLOC_Test_009
689 * @tc.desc: lane alloc by qos require (MID_LOW_BW, not enable wlan5g and hml, build wlan24g)
690 * @tc.type: FUNC
691 * @tc.require:
692 */
693 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_009, TestSize.Level1)
694 {
695 const LnnLaneManager *laneManager = GetLaneManager();
696 LaneType laneType = LANE_TYPE_TRANS;
697 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
698 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
699
700 NiceMock<LaneDepsInterfaceMock> mock;
701 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
702 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
703 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
704 char buf[] = "lanedetect";
705 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
706 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
707 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
708 wifiMock.SetDefaultResult();
709 SoftBusWifiLinkedInfo wlanInfo;
710 wlanInfo.band = 1;
711 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
712 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
713 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
714
715 LaneAllocInfo allocInfo = {};
716 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
717 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
718 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
719 EXPECT_EQ(ret, SOFTBUS_OK);
720 CondWait();
721 ret = laneManager->lnnFreeLane(laneReqId);
722 EXPECT_EQ(ret, SOFTBUS_OK);
723 CondWait();
724 }
725
726 /*
727 * @tc.name: LANE_ALLOC_Test_010
728 * @tc.desc: lane alloc by qos require (LOW_BW, not enable wlan5g\hml\br\p2p\coc_direct, build ble)
729 * @tc.type: FUNC
730 * @tc.require:
731 */
732 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_010, TestSize.Level1)
733 {
734 const LnnLaneManager *laneManager = GetLaneManager();
735 LaneType laneType = LANE_TYPE_TRANS;
736 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
737 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
738
739 NiceMock<LaneDepsInterfaceMock> mock;
740 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
741 mock.SetDefaultResultForAlloc(1 << BIT_BLE, 1 << BIT_BLE, 0, 0);
742 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
743 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
744 wifiMock.SetDefaultResult();
745
746 LaneAllocInfo allocInfo = {};
747 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
748 PEER_MAC, strlen(PEER_MAC)), EOK);
749 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
750 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
751 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBle);
752 EXPECT_EQ(ret, SOFTBUS_OK);
753 CondWait();
754 ret = laneManager->lnnFreeLane(laneReqId);
755 EXPECT_EQ(ret, SOFTBUS_OK);
756 CondWait();
757 }
758
759 /*
760 * @tc.name: LANE_ALLOC_Test_011
761 * @tc.desc: lane alloc for exception deal before select link
762 * @tc.type: FAILUE
763 * @tc.require:
764 */
765 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_011, TestSize.Level1)
766 {
767 const LnnLaneManager *laneManager = GetLaneManager();
768 LaneType laneType = LANE_TYPE_TRANS;
769 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
770 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
771
772 NiceMock<LaneDepsInterfaceMock> mock;
773 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
774
775 LaneAllocInfo allocInfo = {};
776 int32_t ret = laneManager->lnnAllocLane(laneReqId, nullptr, &g_listenerCbForP2p);
777 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
778
779 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, nullptr);
780 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
781
782 allocInfo.type = LANE_TYPE_BUTT;
783 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
784 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
785
786 allocInfo.type = (LaneType)-1;
787 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
788 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
789
790 ret = laneManager->lnnAllocLane(INVALID_LANE_REQ_ID, &allocInfo, &g_listenerCbForP2p);
791 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
792
793 allocInfo.type = LANE_TYPE_HDLC;
794 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
795 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
796
797 allocInfo.type = laneType;
798 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
799 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
800
801 ret = laneManager->lnnFreeLane(laneReqId);
802 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
803 }
804
805 /*
806 * @tc.name: LANE_RE_ALLOC_Test_001
807 * @tc.desc: lane re alloc for invalid param
808 * @tc.type: FUNC
809 * @tc.require:
810 */
811 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_001, TestSize.Level1)
812 {
813 const LnnLaneManager *laneManager = GetLaneManager();
814 LaneType laneType = LANE_TYPE_TRANS;
815 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
816 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
817
818 int32_t ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, nullptr, &g_listenerCbForP2p);
819 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
820
821 LaneAllocInfo allocInfo;
822 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
823 allocInfo.type = LANE_TYPE_BUTT;
824
825 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, nullptr);
826 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
827
828 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
829 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
830
831 ret = laneManager->lnnReAllocLane(INVALID_LANE_REQ_ID, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
832 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
833
834 ret = laneManager->lnnReAllocLane(laneReqId, INVALID_LANE_ID, &allocInfo, &g_listenerCbForP2p);
835 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
836
837 allocInfo.type = LANE_TYPE_HDLC;
838 ret = laneManager->lnnReAllocLane(laneReqId, INVALID_LANE_ID, &allocInfo, &g_listenerCbForP2p);
839 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
840 }
841
842 /*
843 * @tc.name: LANE_RE_ALLOC_Test_002
844 * @tc.desc: lane re alloc for MSG HIGH_BW
845 * @tc.type: FUNC
846 * @tc.require:
847 */
848 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_002, TestSize.Level1)
849 {
850 const LnnLaneManager *laneManager = GetLaneManager();
851 LaneType laneType = LANE_TYPE_TRANS;
852 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
853 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
854
855 NiceMock<LaneDepsInterfaceMock> mock;
856 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
857 mock.SetDefaultResultForAlloc(63, 63, 8, 8);
858 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
859 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
860 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
861 EXPECT_EQ(ret, SOFTBUS_OK);
862
863 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
864 wifiMock.SetDefaultResult();
865 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
866 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
867
868 LaneAllocInfo allocInfo;
869 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
870 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
871 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
872 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
873 EXPECT_EQ(ret, SOFTBUS_OK);
874 CondWait();
875 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
876 EXPECT_EQ(ret, SOFTBUS_OK);
877 ret = laneManager->lnnFreeLane(laneReqId);
878 EXPECT_TRUE(ret == SOFTBUS_OK);
879 }
880
881 /*
882 * @tc.name: LANE_RE_ALLOC_Test_003
883 * @tc.desc: lane re alloc for MSG MID_HIGH_BW
884 * @tc.type: FUNC
885 * @tc.require:
886 */
887 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_003, TestSize.Level1)
888 {
889 const LnnLaneManager *laneManager = GetLaneManager();
890 LaneType laneType = LANE_TYPE_TRANS;
891 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
892 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
893
894 NiceMock<LaneDepsInterfaceMock> mock;
895 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
896 mock.SetDefaultResultForAlloc(63, 63, 8, 8);
897 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
898 char buf[] = "lanedetect";
899 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
900 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
901 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
902
903 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
904 EXPECT_EQ(ret, SOFTBUS_OK);
905
906 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
907 wifiMock.SetDefaultResult();
908 SoftBusWifiLinkedInfo wlanInfo;
909 wlanInfo.band = 0;
910 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
911 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
912 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
913
914 LaneAllocInfo allocInfo;
915 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
916 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + MID_BW, DEFAULT_QOSINFO_MAX_LATENCY,
917 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
918 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForWlan5g);
919 EXPECT_EQ(ret, SOFTBUS_OK);
920 CondWait();
921 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
922 EXPECT_EQ(ret, SOFTBUS_OK);
923 ret = laneManager->lnnFreeLane(laneReqId);
924 EXPECT_TRUE(ret == SOFTBUS_OK);
925 CondWait();
926 }
927
928 /*
929 * @tc.name: LANE_RE_ALLOC_Test_004
930 * @tc.desc: lane re alloc for MSG MID_LOW_BW
931 * @tc.type: FUNC
932 * @tc.require:
933 */
934 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_004, TestSize.Level1)
935 {
936 const LnnLaneManager *laneManager = GetLaneManager();
937 LaneType laneType = LANE_TYPE_TRANS;
938 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
939 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
940
941 NiceMock<LaneDepsInterfaceMock> mock;
942 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
943 mock.SetDefaultResultForAlloc(63, 63, 8, 8);
944 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
945 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
946 int32_t ret = AddLaneResourceForAllocTest(LANE_WLAN_5G);
947 EXPECT_EQ(ret, SOFTBUS_OK);
948
949 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
950 wifiMock.SetDefaultResult();
951 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
952 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
953
954 LaneAllocInfo allocInfo;
955 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
956 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
957 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
958 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForHml);
959 EXPECT_EQ(ret, SOFTBUS_OK);
960 CondWait();
961 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
962 EXPECT_EQ(ret, SOFTBUS_OK);
963 ret = laneManager->lnnFreeLane(laneReqId);
964 EXPECT_TRUE(ret == SOFTBUS_OK);
965 }
966
967 /*
968 * @tc.name: LANE_RE_ALLOC_Test_005
969 * @tc.desc: lane re alloc for MSG LOW_BW
970 * @tc.type: FUNC
971 * @tc.require:
972 */
973 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_005, TestSize.Level1)
974 {
975 const LnnLaneManager *laneManager = GetLaneManager();
976 LaneType laneType = LANE_TYPE_TRANS;
977 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
978 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
979
980 NiceMock<LaneDepsInterfaceMock> mock;
981 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
982 mock.SetDefaultResultForAlloc(15, 15, 8, 8);
983 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
984 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
985 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
986 EXPECT_EQ(ret, SOFTBUS_OK);
987
988 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
989 wifiMock.SetDefaultResult();
990
991 LaneAllocInfo allocInfo;
992 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
993 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
994 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
995 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForBr);
996 EXPECT_EQ(ret, SOFTBUS_OK);
997 CondWait();
998 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
999 EXPECT_EQ(ret, SOFTBUS_OK);
1000 ret = laneManager->lnnFreeLane(laneReqId);
1001 EXPECT_TRUE(ret == SOFTBUS_OK);
1002 CondWait();
1003 }
1004
1005 /*
1006 * @tc.name: LANE_CANCEL_Test_001
1007 * @tc.desc: lane cancel after notify
1008 * @tc.type: FUNC
1009 * @tc.require:
1010 */
1011 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_001, TestSize.Level1)
1012 {
1013 const LnnLaneManager *laneManager = GetLaneManager();
1014 LaneType laneType = LANE_TYPE_TRANS;
1015 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1016 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1017
1018 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1019 wifiMock.SetDefaultResult();
1020 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1021 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1022 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1023 NiceMock<LaneDepsInterfaceMock> mock;
1024 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1025 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1026
1027 LaneAllocInfo allocInfo;
1028 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1029 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1030 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1031 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1032 EXPECT_EQ(ret, SOFTBUS_OK);
1033 CondWait();
1034 ret = laneManager->lnnCancelLane(laneReqId);
1035 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1036 ret = laneManager->lnnFreeLane(laneReqId);
1037 EXPECT_TRUE(ret == SOFTBUS_OK);
1038 }
1039
1040 /*
1041 * @tc.name: LANE_CANCEL_Test_002
1042 * @tc.desc: lane cancel before notify
1043 * @tc.type: FUNC
1044 * @tc.require:
1045 */
1046 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_002, TestSize.Level1)
1047 {
1048 const LnnLaneManager *laneManager = GetLaneManager();
1049 LaneType laneType = LANE_TYPE_TRANS;
1050 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1051 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1052
1053 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1054 LnnWifiAdpterInterfaceMock::delayNotifyLinkSuccess = true;
1055 wifiMock.SetDefaultResult();
1056 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1057 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1058 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1059 NiceMock<LaneDepsInterfaceMock> mock;
1060 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1061 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1062
1063 LaneAllocInfo allocInfo;
1064 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1065 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1066 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1067 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1068 EXPECT_EQ(ret, SOFTBUS_OK);
1069 ret = laneManager->lnnCancelLane(laneReqId);
1070 EXPECT_EQ(ret, SOFTBUS_OK);
1071 LnnWifiAdpterInterfaceMock::delayNotifyLinkSuccess = false;
1072 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_LOOP_COMPLETION_MS));
1073 }
1074
1075 /*
1076 * @tc.name: LANE_CANCEL_Test_003
1077 * @tc.desc: lane cancel after free
1078 * @tc.type: FUNC
1079 * @tc.require:
1080 */
1081 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_003, TestSize.Level1)
1082 {
1083 const LnnLaneManager *laneManager = GetLaneManager();
1084 LaneType laneType = LANE_TYPE_TRANS;
1085 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1086 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1087
1088 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1089 wifiMock.SetDefaultResult();
1090 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1091 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1092 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1093 NiceMock<LaneDepsInterfaceMock> mock;
1094 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1095 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1096
1097 LaneAllocInfo allocInfo;
1098 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1099 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1100 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1101 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1102 EXPECT_EQ(ret, SOFTBUS_OK);
1103 CondWait();
1104 ret = laneManager->lnnFreeLane(laneReqId);
1105 EXPECT_TRUE(ret == SOFTBUS_OK);
1106 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_LOOP_COMPLETION_MS));
1107 ret = laneManager->lnnCancelLane(laneReqId);
1108 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1109 }
1110
1111 /*
1112 * @tc.name: LANE_FREE_001
1113 * @tc.desc: lane free
1114 * @tc.type: FUNC
1115 * @tc.require:
1116 */
1117 HWTEST_F(LNNLaneMockTest, LANE_FREE_001, TestSize.Level1)
1118 {
1119 const LnnLaneManager *laneManager = GetLaneManager();
1120 LaneType laneType = LANE_TYPE_BUTT;
1121 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1122 int32_t ret = laneManager->lnnFreeLane(laneReqId);
1123 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1124
1125 laneType = LANE_TYPE_TRANS;
1126 laneReqId = laneManager->lnnGetLaneHandle(laneType);
1127 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1128 ret = laneManager->lnnFreeLane(laneReqId);
1129 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1130 ret = laneManager->lnnFreeLane(laneReqId);
1131 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1132 }
1133
1134 /*
1135 * @tc.name: LANE_INFO_001
1136 * @tc.desc: LaneInfoProcess BR
1137 * @tc.type: FUNC
1138 * @tc.require:
1139 */
1140 HWTEST_F(LNNLaneMockTest, LANE_INFO_001, TestSize.Level1)
1141 {
1142 LaneLinkInfo info = {};
1143 info.type = LANE_BR;
1144 LaneConnInfo connInfo = {};
1145 LaneProfile profile = {};
1146 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
1147 EXPECT_EQ(ret, SOFTBUS_OK);
1148 }
1149
1150 /*
1151 * @tc.name: LANE_INFO_002
1152 * @tc.desc: LaneInfoProcess BLE
1153 * @tc.type: FUNC
1154 * @tc.require:
1155 */
1156 HWTEST_F(LNNLaneMockTest, LANE_INFO_002, TestSize.Level1)
1157 {
1158 LaneLinkInfo info = {};
1159 info.type = LANE_BLE;
1160 LaneConnInfo connInfo = {};
1161 LaneProfile profile = {};
1162 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
1163 EXPECT_EQ(ret, SOFTBUS_OK);
1164 }
1165
1166 /*
1167 * @tc.name: LANE_INFO_003
1168 * @tc.desc: LaneInfoProcess P2P
1169 * @tc.type: FUNC
1170 * @tc.require:
1171 */
1172 HWTEST_F(LNNLaneMockTest, LANE_INFO_003, TestSize.Level1)
1173 {
1174 LaneLinkInfo info = {};
1175 info.type = LANE_P2P;
1176 LaneConnInfo connInfo;
1177 LaneProfile profile = {};
1178 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
1179 EXPECT_EQ(ret, SOFTBUS_OK);
1180 }
1181
1182 /*
1183 * @tc.name: LANE_INFO_004
1184 * @tc.desc: LaneInfoProcess fail
1185 * @tc.type: FAILUE
1186 * @tc.require:
1187 */
1188 HWTEST_F(LNNLaneMockTest, LANE_INFO_004, TestSize.Level1)
1189 {
1190 LaneLinkInfo info = {};
1191 info.type = LANE_LINK_TYPE_BUTT;
1192 LaneConnInfo *connInfo = nullptr;
1193 LaneProfile *profile = nullptr;
1194 int32_t ret = LaneInfoProcess(nullptr, connInfo, profile);
1195 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1196
1197 ret = LaneInfoProcess(&info, nullptr, profile);
1198 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1199
1200 ret = LaneInfoProcess(&info, connInfo, nullptr);
1201 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1202
1203 ret = LaneInfoProcess(&info, connInfo, profile);
1204 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1205 }
1206
1207 /*
1208 * @tc.name: LANE_INFO_005
1209 * @tc.desc: LaneInfoProcess 2.4G
1210 * @tc.type: FUNC
1211 * @tc.require:
1212 */
1213 HWTEST_F(LNNLaneMockTest, LANE_INFO_005, TestSize.Level1)
1214 {
1215 LaneLinkInfo info = {};
1216 LaneConnInfo connInfo = {};
1217 LaneProfile profile = {};
1218
1219 info.type = LANE_WLAN_2P4G;
1220 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
1221 EXPECT_EQ(ret, SOFTBUS_OK);
1222
1223 info.type = LANE_WLAN_5G;
1224 ret = LaneInfoProcess(&info, &connInfo, &profile);
1225 EXPECT_EQ(ret, SOFTBUS_OK);
1226
1227 info.type = LANE_P2P_REUSE;
1228 ret = LaneInfoProcess(&info, &connInfo, &profile);
1229 EXPECT_EQ(ret, SOFTBUS_OK);
1230
1231 info.type = LANE_BLE_DIRECT;
1232 ret = LaneInfoProcess(&info, &connInfo, &profile);
1233 EXPECT_EQ(ret, SOFTBUS_OK);
1234
1235 info.type = LANE_COC;
1236 ret = LaneInfoProcess(&info, &connInfo, &profile);
1237 EXPECT_EQ(ret, SOFTBUS_OK);
1238 }
1239
1240 /*
1241 * @tc.name: LNN_DATA_001
1242 * @tc.desc: LnnCreateData
1243 * @tc.type: FUNC
1244 * @tc.require:
1245 */
1246 HWTEST_F(LNNLaneMockTest, LNN_DATA_001, TestSize.Level1)
1247 {
1248 int32_t ret = LnnCreateData(nullptr, 32, nullptr, 0);
1249 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1250
1251 LnnDeleteData(nullptr, 32);
1252 }
1253
1254 /*
1255 * @tc.name: LNN_LANE_PROFILE_001
1256 * @tc.desc: BindLaneIdToProfile
1257 * @tc.type: FUNC
1258 * @tc.require:
1259 */
1260 HWTEST_F(LNNLaneMockTest, LNN_LANE_PROFILE_001, TestSize.Level1)
1261 {
1262 uint64_t laneId = 0x1000000000000001;
1263 int32_t ret = BindLaneIdToProfile(laneId, nullptr);
1264 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1265
1266 LaneProfile profile = {};
1267 ret = BindLaneIdToProfile(laneId, &profile);
1268 EXPECT_EQ(ret, SOFTBUS_OK);
1269
1270 profile.linkType = LANE_P2P;
1271 profile.content = LANE_T_FILE;
1272 profile.priority = LANE_PRI_LOW;
1273 ret = BindLaneIdToProfile(laneId, &profile);
1274 EXPECT_EQ(ret, SOFTBUS_OK);
1275
1276 LaneGenerateParam param = {};
1277 param.linkType = LANE_P2P;
1278 param.transType = LANE_T_FILE;
1279 param.priority = LANE_PRI_LOW;
1280 uint32_t profileId = GenerateLaneProfileId(¶m);
1281
1282 ret = GetLaneProfile(profileId, &profile);
1283 EXPECT_EQ(ret, SOFTBUS_OK);
1284
1285 ret = GetLaneProfile(profileId, nullptr);
1286 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1287
1288 uint64_t *laneReqIdList = nullptr;
1289 uint32_t listSize = 0;
1290 ret = GetLaneIdList(profileId, &laneReqIdList, &listSize);
1291 EXPECT_EQ(ret, SOFTBUS_OK);
1292 SoftBusFree(laneReqIdList);
1293
1294 (void)GetActiveProfileNum();
1295
1296 (void)UnbindLaneIdFromProfile(laneId, profileId);
1297
1298 (void)UnbindLaneIdFromProfile(0, profileId);
1299 }
1300
1301 /*
1302 * @tc.name: LNN_SELECT_LANE_001
1303 * @tc.desc: SelectLane
1304 * @tc.type: FUNC
1305 * @tc.require:
1306 */
1307 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_001, TestSize.Level1)
1308 {
1309 NiceMock<LaneDepsInterfaceMock> mock;
1310 LanePreferredLinkList *linkList = nullptr;
1311 uint32_t listNum = 0;
1312 LaneSelectParam selectParam = {};
1313 selectParam.transType = LANE_T_FILE;
1314 selectParam.expectedBw = 0;
1315 selectParam.list.linkTypeNum = 2;
1316 selectParam.list.linkType[0] = LANE_WLAN_5G;
1317 selectParam.list.linkType[1] = LANE_LINK_TYPE_BUTT;
1318
1319 int32_t ret = SelectLane(NODE_NETWORK_ID, nullptr, linkList, &listNum);
1320 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1321
1322 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1323 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1324 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1325 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
1326 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1327 wifiMock.SetDefaultResult();
1328 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1329 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1330
1331 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1332 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
1333 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1334 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
1335 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1336 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1337 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1338
1339 selectParam.transType = LANE_T_MIX;
1340 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1341 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1342 SoftBusFree(linkList);
1343 }
1344
1345 /*
1346 * @tc.name: LNN_SELECT_LANE_002
1347 * @tc.desc: SelectLane
1348 * @tc.type: FUNC
1349 * @tc.require:
1350 */
1351 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_002, TestSize.Level1)
1352 {
1353 NiceMock<LaneDepsInterfaceMock> mock;
1354 LanePreferredLinkList *linkList = nullptr;
1355 uint32_t listNum = 0;
1356 LaneSelectParam selectParam = {};
1357 selectParam.transType = LANE_T_FILE;
1358 selectParam.expectedBw = 0;
1359 selectParam.list.linkTypeNum = DEFAULT_SELECT_NUM;
1360 selectParam.list.linkType[0] = LANE_BLE;
1361 selectParam.list.linkType[1] = LANE_WLAN_2P4G;
1362 selectParam.list.linkType[2] = LANE_WLAN_5G;
1363 selectParam.list.linkType[3] = LANE_BR;
1364
1365 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1366 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1367 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1368 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1369 wifiMock.SetDefaultResult();
1370 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1371 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1372
1373 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1374 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1375 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1376 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1377 ret = SelectLane(NODE_NETWORK_ID, &selectParam, linkList, &listNum);
1378 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1379 SoftBusFree(linkList);
1380 }
1381
1382 /*
1383 * @tc.name: LNN_SELECT_LANE_003
1384 * @tc.desc: SelectLane
1385 * @tc.type: FUNC
1386 * @tc.require:
1387 */
1388 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_003, TestSize.Level1)
1389 {
1390 NiceMock<LaneDepsInterfaceMock> mock;
1391 LanePreferredLinkList linkList = {};
1392 uint32_t listNum = 0;
1393 LaneSelectParam selectParam = {};
1394 NodeInfo node = {};
1395
1396 selectParam.transType = LANE_T_FILE;
1397 selectParam.expectedBw = 0;
1398 selectParam.list.linkTypeNum = 7;
1399 selectParam.list.linkType[0] = LANE_P2P;
1400 selectParam.list.linkType[1] = LANE_ETH;
1401 selectParam.list.linkType[2] = LANE_P2P_REUSE;
1402 selectParam.list.linkType[3] = LANE_BLE_DIRECT;
1403 selectParam.list.linkType[4] = LANE_BLE_REUSE;
1404 selectParam.list.linkType[5] = LANE_COC;
1405 selectParam.list.linkType[6] = LANE_COC_DIRECT;
1406 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1407 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1408 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1409 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1410 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1411 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1412 wifiMock.SetDefaultResult();
1413 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
1414 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1415
1416 node.discoveryType = 3;
1417 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById)
1418 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(node), Return(SOFTBUS_OK)));
1419 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1420 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1421 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1422 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1423 EXPECT_CALL(mock, LnnGetLocalNumU64Info)
1424 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1425 EXPECT_CALL(mock, LnnGetRemoteNumU64Info)
1426 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1427 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
1428 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1429 }
1430
1431 /*
1432 * @tc.name: LNN_SELECT_LANE_004
1433 * @tc.desc: SelectLane, HmlIsExist == true
1434 * @tc.type: FUNC
1435 * @tc.require:
1436 */
1437 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_004, TestSize.Level1)
1438 {
1439 LaneSelectParam request = {};
1440 request.transType = LANE_T_FILE;
1441 request.list.linkTypeNum = 0;
1442 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BR;
1443 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BLE;
1444 request.list.linkType[(request.list.linkTypeNum)++] = LANE_P2P;
1445 request.list.linkType[(request.list.linkTypeNum)++] = LANE_HML;
1446
1447 LanePreferredLinkList recommendList = {};
1448 uint32_t listNum = 0;
1449
1450 NiceMock<LaneDepsInterfaceMock> linkMock;
1451 EXPECT_CALL(linkMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1452 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1453 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
1454 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1455 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
1456 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1457 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(8), Return(SOFTBUS_OK)));
1458 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)\
1459 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(8), Return(SOFTBUS_OK)));
1460
1461 int32_t ret = SelectLane(NODE_NETWORK_ID, &request, &recommendList, &listNum);
1462 EXPECT_EQ(ret, SOFTBUS_OK);
1463 }
1464
1465 /*
1466 * @tc.name: LNN_SELECT_LANE_005
1467 * @tc.desc: SelectLane, HmlIsExist == false && LaneAddHml
1468 * @tc.type: FUNC
1469 * @tc.require:
1470 */
1471 HWTEST_F(LNNLaneMockTest, LNN_SELECT_LANE_005, TestSize.Level1)
1472 {
1473 LaneSelectParam request = {};
1474 request.transType = LANE_T_FILE;
1475 request.list.linkTypeNum = 0;
1476 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BR;
1477 request.list.linkType[(request.list.linkTypeNum)++] = LANE_BLE;
1478 request.list.linkType[(request.list.linkTypeNum)++] = LANE_P2P;
1479
1480 LanePreferredLinkList recommendList = {};
1481 uint32_t listNum = 0;
1482
1483 NiceMock<LaneDepsInterfaceMock> linkMock;
1484 EXPECT_CALL(linkMock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1485 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
1486 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
1487 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
1488 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
1489 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1490 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(8), Return(SOFTBUS_OK)));
1491 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1492 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(8), Return(SOFTBUS_OK)));
1493
1494 int32_t ret = SelectLane(NODE_NETWORK_ID, &request, &recommendList, &listNum);
1495 EXPECT_EQ(ret, SOFTBUS_OK);
1496 }
1497
1498 /*
1499 * @tc.name: LNN_BUILD_LINK_001
1500 * @tc.desc: BUILDLINK
1501 * @tc.type: FUNC
1502 * @tc.require:
1503 */
1504 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_001, TestSize.Level1)
1505 {
1506 LinkRequest reqInfo = {};
1507 reqInfo.linkType = LANE_P2P;
1508 LaneLinkCb cb = {
1509 .onLaneLinkSuccess = OnLaneLinkSuccess,
1510 .onLaneLinkFail = OnLaneLinkFail,
1511 };
1512 int32_t ret;
1513 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1514 EXPECT_CALL(wifiMock, LnnDisconnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
1515 EXPECT_CALL(wifiMock, LnnConnectP2p)
1516 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL))
1517 .WillRepeatedly(Return(SOFTBUS_OK));
1518 ret = BuildLink(&reqInfo, 0, &cb);
1519 EXPECT_EQ(ret, SOFTBUS_LANE_BUILD_LINK_FAIL);
1520
1521 ret = BuildLink(&reqInfo, 0, &cb);
1522 EXPECT_TRUE(ret == SOFTBUS_OK);
1523
1524 cb.onLaneLinkFail = nullptr;
1525 ret = BuildLink(&reqInfo, 0, &cb);
1526 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1527
1528 cb.onLaneLinkSuccess = nullptr;
1529 ret = BuildLink(&reqInfo, 0, &cb);
1530 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1531
1532 ret = BuildLink(&reqInfo, 0, nullptr);
1533 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1534
1535 reqInfo.linkType = LANE_BLE;
1536 ret = BuildLink(&reqInfo, 0, nullptr);
1537 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1538
1539 reqInfo.linkType = LANE_LINK_TYPE_BUTT;
1540 ret = BuildLink(&reqInfo, 0, &cb);
1541 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1542
1543 ret = BuildLink(nullptr, 0, nullptr);
1544 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1545
1546 ret = DestroyLink(NODE_NETWORK_ID, 0, LANE_BLE);
1547 EXPECT_TRUE(ret == SOFTBUS_OK);
1548
1549 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
1550 ret = DestroyLink(NODE_NETWORK_ID, 0, LANE_P2P);
1551 EXPECT_TRUE(ret == SOFTBUS_OK);
1552 ret = DestroyLink(nullptr, 0, LANE_P2P);
1553 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1554 }
1555
1556 /*
1557 * @tc.name: LNN_BUILD_LINK_002
1558 * @tc.desc: BUILDLINK
1559 * @tc.type: FUNC
1560 * @tc.require:
1561 */
1562 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_002, TestSize.Level1)
1563 {
1564 NiceMock<LaneDepsInterfaceMock> mock;
1565 LinkRequest reqInfo = {};
1566 reqInfo.linkType = LANE_P2P;
1567 LaneLinkCb cb = {
1568 .onLaneLinkSuccess = OnLaneLinkSuccess,
1569 .onLaneLinkFail = OnLaneLinkFail,
1570 };
1571 int32_t ret;
1572 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1573 const char *udid = "testuuid";
1574 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1575 ret = BuildLink(&reqInfo, 0, &cb);
1576 EXPECT_TRUE(ret == SOFTBUS_OK);
1577 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1578 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(NULL));
1579 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1580 ON_CALL(wifiMock, LnnConnectP2p).WillByDefault(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
1581 ret = BuildLink(&reqInfo, 0, &cb);
1582 EXPECT_EQ(ret, SOFTBUS_LANE_BUILD_LINK_FAIL);
1583 }
1584
1585 /*
1586 * @tc.name: LNN_BUILD_LINK_003
1587 * @tc.desc: BUILDLINK
1588 * @tc.type: FUNC
1589 * @tc.require:
1590 */
1591 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_003, TestSize.Level1)
1592 {
1593 NiceMock<LaneDepsInterfaceMock> mock;
1594 LinkRequest reqInfo = {};
1595 reqInfo.linkType = LANE_P2P;
1596 LaneLinkCb cb = {
1597 .onLaneLinkSuccess = OnLaneLinkSuccess,
1598 .onLaneLinkFail = OnLaneLinkFail,
1599 };
1600 int32_t ret;
1601 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1602
1603 ConnBleConnection *connection = (ConnBleConnection*)SoftBusCalloc(sizeof(ConnBleConnection));
1604 if (connection == NULL) {
1605 return;
1606 }
1607 const char *udid = "testuuid";
1608 NodeInfo *nodeInfo = (NodeInfo*)SoftBusCalloc(sizeof(NodeInfo));
1609 if (nodeInfo == NULL) {
1610 return;
1611 }
1612 connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
1613 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1614 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(connection));
1615 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1616 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
1617 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
1618 ret = BuildLink(&reqInfo, 0, &cb);
1619 EXPECT_TRUE(ret == SOFTBUS_OK);
1620 SoftBusFree(connection);
1621 SoftBusFree(nodeInfo);
1622 }
1623
1624 /*
1625 * @tc.name: LNN_BUILD_LINK_004
1626 * @tc.desc: BUILDLINK
1627 * @tc.type: FUNC
1628 * @tc.require:
1629 */
1630 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_004, TestSize.Level1)
1631 {
1632 NiceMock<LaneDepsInterfaceMock> mock;
1633 LinkRequest reqInfo = {};
1634 int32_t ret;
1635 const char *udid = "testuuid";
1636 LaneLinkCb cb = {
1637 .onLaneLinkSuccess = OnLaneLinkSuccess,
1638 .onLaneLinkFail = OnLaneLinkFail,
1639 };
1640
1641 reqInfo.linkType = LANE_BLE;
1642 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1643 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1644 ON_CALL(mock, LnnGetRemoteStrInfo).WillByDefault(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1645 ret = BuildLink(&reqInfo, 0, &cb);
1646 EXPECT_NE(ret, SOFTBUS_OK);
1647
1648 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1649 ON_CALL(mock, SoftBusGenerateStrHash).WillByDefault(Return(SOFTBUS_ENCRYPT_ERR));
1650 ret = BuildLink(&reqInfo, 0, &cb);
1651 EXPECT_NE(ret, SOFTBUS_OK);
1652 ret = BuildLink(&reqInfo, 0, &cb);
1653 EXPECT_NE(ret, SOFTBUS_OK);
1654 }
1655
1656 /*
1657 * @tc.name: LNN_BUILD_LINK_005
1658 * @tc.desc: BUILDLINK
1659 * @tc.type: FUNC
1660 * @tc.require:
1661 */
1662 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_005, TestSize.Level1)
1663 {
1664 NiceMock<LaneDepsInterfaceMock> mock;
1665 LinkRequest reqInfo = {};
1666 int32_t ret;
1667 const char *udid = "testuuid";
1668 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1669 LaneLinkCb cb = {
1670 .onLaneLinkSuccess = OnLaneLinkSuccess,
1671 .onLaneLinkFail = OnLaneLinkFail,
1672 };
1673
1674 reqInfo.linkType = LANE_BLE;
1675 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
1676 if (connection == nullptr) {
1677 return;
1678 }
1679 connection->state = BLE_CONNECTION_STATE_INVALID;
1680 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1681 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(connection));
1682 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1683 ON_CALL(mock, LnnGetRemoteNodeInfoById).WillByDefault(Return(SOFTBUS_OK));
1684 ret = BuildLink(&reqInfo, 0, &cb);
1685 EXPECT_TRUE(ret == SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1686 SoftBusFree(connection);
1687 }
1688
1689 /*
1690 * @tc.name: LNN_BUILD_LINK_006
1691 * @tc.desc: BUILDLINK
1692 * @tc.type: FUNC
1693 * @tc.require:
1694 */
1695 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_006, TestSize.Level1)
1696 {
1697 uint32_t reqId = 0;
1698 const char *networkId = "testnetworkid123";
1699 const char *networkIdNotFound = "testnetworkid133";
1700 const char *ipAddr = "127.0.0.1";
1701 const char *ipAddrDiff = "127.0.0.2";
1702 uint16_t portA = 22;
1703 uint16_t portB = 33;
1704 LaneLinkCb cb = {
1705 .onLaneLinkSuccess = OnLaneLinkSuccess,
1706 .onLaneLinkFail = OnLaneLinkFail,
1707 };
1708 NiceMock<LaneDepsInterfaceMock> mock;
1709 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1710 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1711 if (request == nullptr) {
1712 return;
1713 }
1714 LaneAddP2pAddress(networkId, ipAddr, portA);
1715 LaneAddP2pAddress(networkId, ipAddr, portB);
1716 LaneAddP2pAddressByIp(ipAddr, portB);
1717 LaneAddP2pAddressByIp(ipAddrDiff, portB);
1718 request->linkType = LANE_P2P_REUSE;
1719 (void)strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkId);
1720 int32_t ret = BuildLink(request, reqId, &cb);
1721 EXPECT_TRUE(ret == SOFTBUS_OK);
1722
1723 (void)strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkIdNotFound);
1724 ret = BuildLink(request, reqId, &cb);
1725 EXPECT_TRUE(ret == SOFTBUS_LANE_NOT_FOUND);
1726 SoftBusFree(request);
1727 LaneDeleteP2pAddress(networkId, true);
1728 }
1729
1730 /*
1731 * @tc.name: LNN_BUILD_LINK_007
1732 * @tc.desc: BUILDLINK
1733 * @tc.type: FUNC
1734 * @tc.require:
1735 */
1736 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_007, TestSize.Level1)
1737 {
1738 NiceMock<LaneDepsInterfaceMock> mock;
1739 uint32_t reqId = 0;
1740 LaneLinkCb cb = {
1741 .onLaneLinkSuccess = OnLaneLinkSuccess,
1742 .onLaneLinkFail = OnLaneLinkFail,
1743 };
1744 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1745 if (request == nullptr) {
1746 return;
1747 }
1748 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1749 if (nodeInfo == nullptr) {
1750 SoftBusFree(request);
1751 return;
1752 }
1753 request->linkType = LANE_BLE_DIRECT;
1754 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1755 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
1756
1757 int32_t ret = BuildLink(request, reqId, &cb);
1758 ret = BuildLink(request, reqId, &cb);
1759 EXPECT_TRUE(ret == SOFTBUS_OK);
1760 SoftBusFree(request);
1761 SoftBusFree(nodeInfo);
1762 }
1763
1764 /*
1765 * @tc.name: LNN_BUILD_LINK_008
1766 * @tc.desc: BUILDLINK
1767 * @tc.type: FUNC
1768 * @tc.require:
1769 */
1770 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_008, TestSize.Level1)
1771 {
1772 NiceMock<LaneDepsInterfaceMock> mock;
1773 LinkRequest reqInfo = {};
1774 int32_t ret;
1775 const char *udid = "testuuid";
1776 const char *bleMac = "127.1.1.1";
1777 LaneLinkCb cb = {
1778 .onLaneLinkSuccess = OnLaneLinkSuccess,
1779 .onLaneLinkFail = OnLaneLinkFail,
1780 };
1781
1782 reqInfo.linkType = LANE_COC;
1783 if (strcpy_s(reqInfo.peerBleMac, MAX_MAC_LEN, bleMac) != EOK) {
1784 return;
1785 }
1786 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1787 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1788 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1789 ret = BuildLink(&reqInfo, 0, &cb);
1790 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1791
1792 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1793 EXPECT_CALL(mock, SoftBusGenerateStrHash)
1794 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
1795 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfGenerateStrHash);
1796 ret = BuildLink(&reqInfo, 0, &cb);
1797 EXPECT_EQ(ret, SOFTBUS_ENCRYPT_ERR);
1798 ret = BuildLink(&reqInfo, 0, &cb);
1799 EXPECT_TRUE(ret == SOFTBUS_OK);
1800 }
1801
1802 /*
1803 * @tc.name: LNN_BUILD_LINK_009
1804 * @tc.desc: BUILDLINK
1805 * @tc.type: FUNC
1806 * @tc.require:
1807 */
1808 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_009, TestSize.Level1)
1809 {
1810 uint32_t reqId = 0;
1811 const char *networkId = "testnetworkid123";
1812 const char *networkIdNotFound = "testnetworkid133";
1813 LaneLinkCb cb = {
1814 .onLaneLinkSuccess = OnLaneLinkSuccess,
1815 .onLaneLinkFail = OnLaneLinkFail,
1816 };
1817 NiceMock<LaneDepsInterfaceMock> mock;
1818 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1819 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1820 if (request == nullptr) {
1821 return;
1822 }
1823 request->linkType = LANE_COC_DIRECT;
1824 if (strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
1825 return;
1826 }
1827 int32_t ret = BuildLink(request, reqId, &cb);
1828 EXPECT_TRUE(ret == SOFTBUS_OK);
1829
1830 if (strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkIdNotFound) != EOK) {
1831 return;
1832 }
1833 ret = BuildLink(request, reqId, &cb);
1834 EXPECT_TRUE(ret == SOFTBUS_OK);
1835 SoftBusFree(request);
1836 LaneDeleteP2pAddress(networkId, true);
1837 }
1838
1839 /*
1840 * @tc.name: LNN_BUILD_LINK_010
1841 * @tc.desc: BUILDLINK
1842 * @tc.type: FUNC
1843 * @tc.require:
1844 */
1845 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_010, TestSize.Level1)
1846 {
1847 NiceMock<LaneDepsInterfaceMock> mock;
1848 LinkRequest reqInfo = {};
1849 int32_t ret;
1850 const char *udid = "testuuid";
1851 const char *bleMac = "127.1.1.1";
1852 LaneLinkCb cb = {
1853 .onLaneLinkSuccess = OnLaneLinkSuccess,
1854 .onLaneLinkFail = OnLaneLinkFail,
1855 };
1856 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
1857 if (connection == nullptr) {
1858 return;
1859 }
1860 connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
1861 reqInfo.linkType = LANE_BLE_REUSE;
1862 if (strcpy_s(reqInfo.peerBleMac, MAX_MAC_LEN, bleMac) != EOK) {
1863 return;
1864 }
1865 ON_CALL(mock, ConnBleGetConnectionByUdid).WillByDefault(Return(connection));
1866 ON_CALL(mock, ConnBleReturnConnection).WillByDefault(Return());
1867 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1868 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
1869 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1870 ret = BuildLink(&reqInfo, 0, &cb);
1871 EXPECT_TRUE(ret == SOFTBUS_OK);
1872
1873 EXPECT_CALL(mock, ConnBleGetConnectionByUdid).WillRepeatedly(Return(connection));
1874 ret = BuildLink(&reqInfo, 0, &cb);
1875 EXPECT_TRUE(ret == SOFTBUS_OK);
1876 SoftBusFree(connection);
1877 }
1878
1879 /*
1880 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_001
1881 * @tc.desc: SelectExpectLanesByQos
1882 * @tc.type: FUNC
1883 * @tc.require:
1884 */
1885 HWTEST_F(LNNLaneMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_001, TestSize.Level1)
1886 {
1887 NiceMock<LaneDepsInterfaceMock> mock;
1888 LanePreferredLinkList linkList;
1889 LaneSelectParam selectParam = {};
1890 selectParam.transType = LANE_T_FILE;
1891 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
1892 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
1893 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
1894 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, nullptr, &linkList);
1895 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1896
1897 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1898 wifiMock.SetDefaultResult();
1899 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1900 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1901 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1902 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
1903 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1904 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1905
1906 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1907 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
1908 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1909 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
1910 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1911 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1912 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1913
1914 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW + LOW_BW;
1915 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1916 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1917
1918 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW + HIGH_BW;
1919 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1920 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1921
1922 selectParam.transType = LANE_T_MIX;
1923 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1924 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1925 }
1926
1927 /*
1928 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_002
1929 * @tc.desc: SelectExpectLanesByQos
1930 * @tc.type: FUNC
1931 * @tc.require:
1932 */
1933 HWTEST_F(LNNLaneMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_002, TestSize.Level1)
1934 {
1935 NiceMock<LaneDepsInterfaceMock> mock;
1936 LanePreferredLinkList linkList;
1937 LaneSelectParam selectParam = {};
1938 selectParam.transType = LANE_T_FILE;
1939 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, nullptr, &linkList);
1940 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1941
1942 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1943 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1944 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1945 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
1946 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1947 wifiMock.SetDefaultResult();
1948 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1949 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
1950
1951 EXPECT_CALL(mock, LnnGetLocalNumInfo)
1952 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
1953 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
1954 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
1955 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1956 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1957 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1958
1959 selectParam.transType = LANE_T_MIX;
1960 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1961 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1962 }
1963
1964 /*
1965 * @tc.name: LNN_SELECT_EXPECT_LANES_BY_QOS_003
1966 * @tc.desc: SelectExpectLanesByQos
1967 * @tc.type: FUNC
1968 * @tc.require:
1969 */
1970 HWTEST_F(LNNLaneMockTest, LNN_SELECT_EXPECT_LANES_BY_QOS_003, TestSize.Level1)
1971 {
1972 NiceMock<LaneDepsInterfaceMock> mock;
1973 LanePreferredLinkList linkList;
1974 LaneSelectParam selectParam = {};
1975 selectParam.transType = LANE_T_FILE;
1976
1977
1978 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1979 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1980 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1981 wifiMock.SetDefaultResult();
1982
1983 selectParam.qosRequire.rttLevel = LANE_RTT_LEVEL_LOW;
1984 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, &linkList);
1985 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
1986 }
1987
1988 /*
1989 * @tc.name: LANE_FLOAD_EXPLORE_001
1990 * @tc.desc: LANE FLOAD EXPLORE TEST
1991 * @tc.type: FUNC
1992 * @tc.require:
1993 */
1994 HWTEST_F(LNNLaneMockTest, LANE_FLOAD_EXPLORE_001, TestSize.Level1)
1995 {
1996 LaneResource resourceItem = {};
1997 resourceItem.clientRef = DEFAULT_LANE_RESOURCE_LANE_REF;
1998 int32_t ret = LaneDetectFload(&resourceItem);
1999 EXPECT_EQ(ret, SOFTBUS_OK);
2000 }
2001
2002 /*
2003 * @tc.name: LANE_DECISION_MODELS_001
2004 * @tc.desc: LANE DECISION MODELS TEST
2005 * @tc.type: FUNC
2006 * @tc.require:
2007 */
2008 HWTEST_F(LNNLaneMockTest, LANE_DECISION_MODELS_001, TestSize.Level1)
2009 {
2010 NiceMock<LaneDepsInterfaceMock> mock;
2011 LaneSelectParam selectParam = {};
2012 LanePreferredLinkList linkList;
2013 selectParam.transType = LANE_T_FILE;
2014 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
2015 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
2016 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
2017
2018 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2019 wifiMock.SetDefaultResult();
2020 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
2021 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2022 EXPECT_CALL(mock, LnnGetLocalNumInfo)
2023 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
2024 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
2025 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
2026 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
2027
2028 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
2029 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2030 }
2031
2032 /*
2033 * @tc.name: LANE_FIND_LANERESOURCE_BY_LINKADDR_001
2034 * @tc.desc: LANE FIND LANERESOURCE BY LINK ADDR TEST
2035 * @tc.type: FUNC
2036 * @tc.require:
2037 */
2038 HWTEST_F(LNNLaneMockTest, LANE_FIND_LANERESOURCE_BY_LINKADDR_001, TestSize.Level1)
2039 {
2040 NiceMock<LaneDepsInterfaceMock> mock;
2041 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2042 LaneLinkInfo linkInfo;
2043 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2044 linkInfo.type = LANE_HML;
2045 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2046 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2047
2048 LaneResource laneResourse;
2049 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2050 int32_t ret = FindLaneResourceByLinkAddr(nullptr, &laneResourse);
2051 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2052
2053 ret = FindLaneResourceByLinkAddr(&linkInfo, nullptr);
2054 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2055
2056 ret = FindLaneResourceByLinkAddr(&linkInfo, &laneResourse);
2057 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2058
2059 uint64_t laneId = LANE_ID_BASE;
2060 uint32_t clientRef = 0;
2061 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2062 EXPECT_EQ(ret, SOFTBUS_OK);
2063 clientRef++;
2064
2065 LaneLinkInfo linkInfoFind;
2066 ASSERT_EQ(memset_s(&linkInfoFind, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2067 linkInfoFind.type = LANE_HML;
2068 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
2069 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2070
2071 ASSERT_EQ(strncpy_s(linkInfoFind.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2072 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
2073 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2074
2075 ASSERT_EQ(strncpy_s(linkInfoFind.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2076 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
2077 EXPECT_EQ(ret, SOFTBUS_OK);
2078 EXPECT_FALSE(laneResourse.isServerSide);
2079 EXPECT_EQ(laneResourse.clientRef, clientRef);
2080 EXPECT_EQ(laneResourse.link.type, LANE_HML);
2081 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
2082 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
2083 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
2084
2085 DelLaneResourceByLaneId(laneId, false);
2086 EXPECT_EQ(ret, SOFTBUS_OK);
2087 }
2088
2089 /*
2090 * @tc.name: LANE_FIND_LANERESOURCE_BY_LINKTYPE_001
2091 * @tc.desc: LANE FIND LANERESOURCE BY LINK TYPE TEST
2092 * @tc.type: FUNC
2093 * @tc.require:
2094 */
2095 HWTEST_F(LNNLaneMockTest, LANE_FIND_LANERESOURCE_BY_LINKTYPE_001, TestSize.Level1)
2096 {
2097 NiceMock<LaneDepsInterfaceMock> mock;
2098 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2099 LaneLinkInfo linkInfo;
2100 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2101 linkInfo.type = LANE_HML;
2102 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2103 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2104
2105 LaneResource laneResourse;
2106 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2107 int32_t ret = FindLaneResourceByLinkType(nullptr, LANE_HML, &laneResourse);
2108 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2109
2110 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_LINK_TYPE_BUTT, &laneResourse);
2111 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2112
2113 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, nullptr);
2114 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2115
2116 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, &laneResourse);
2117 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2118
2119 uint64_t laneId = LANE_ID_BASE;
2120 uint32_t clientRef = 0;
2121 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2122 EXPECT_EQ(ret, SOFTBUS_OK);
2123 clientRef++;
2124
2125 ret = FindLaneResourceByLinkType(LOCAL_UDID, LANE_HML, &laneResourse);
2126 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2127
2128 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_P2P, &laneResourse);
2129 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2130
2131 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, &laneResourse);
2132 EXPECT_EQ(ret, SOFTBUS_OK);
2133 EXPECT_FALSE(laneResourse.isServerSide);
2134 EXPECT_EQ(laneResourse.clientRef, clientRef);
2135 EXPECT_EQ(laneResourse.link.type, LANE_HML);
2136 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
2137 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
2138 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
2139
2140 DelLaneResourceByLaneId(laneId, false);
2141 EXPECT_EQ(ret, SOFTBUS_OK);
2142 }
2143
2144 /*
2145 * @tc.name: LANE_FIND_LANERESOURCE_BY_LANEID_001
2146 * @tc.desc: LANE FIND LANERESOURCE BY LANEID TEST
2147 * @tc.type: FUNC
2148 * @tc.require:
2149 */
2150 HWTEST_F(LNNLaneMockTest, LANE_FIND_LANERESOURCE_BY_LANEID_001, TestSize.Level1)
2151 {
2152 NiceMock<LaneDepsInterfaceMock> mock;
2153 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2154 LaneLinkInfo linkInfo;
2155 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2156 linkInfo.type = LANE_HML;
2157 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2158 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2159
2160 LaneResource laneResourse;
2161 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2162 uint64_t laneId = INVALID_LANE_ID;
2163 int32_t ret = FindLaneResourceByLaneId(laneId, nullptr);
2164 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2165
2166 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2167 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2168
2169 laneId = LANE_ID_BASE;
2170 uint32_t clientRef = 0;
2171 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2172 EXPECT_EQ(ret, SOFTBUS_OK);
2173 clientRef++;
2174
2175 ret = FindLaneResourceByLaneId(INVALID_LANE_ID, &laneResourse);
2176 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2177
2178 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2179 EXPECT_EQ(ret, SOFTBUS_OK);
2180 EXPECT_FALSE(laneResourse.isServerSide);
2181 EXPECT_EQ(laneResourse.clientRef, clientRef);
2182 EXPECT_EQ(laneResourse.link.type, LANE_HML);
2183 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
2184 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
2185 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
2186
2187 DelLaneResourceByLaneId(laneId, false);
2188 EXPECT_EQ(ret, SOFTBUS_OK);
2189 }
2190
2191 /*
2192 * @tc.name: LANE_DETECT_RELIABILITY_001
2193 * @tc.desc: LANE DETECT RELIABILITY TEST
2194 * @tc.type: FUNC
2195 * @tc.require:
2196 */
2197 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_001, TestSize.Level1)
2198 {
2199 LaneLinkCb cb = {
2200 .onLaneLinkSuccess = OnLaneLinkSuccess,
2201 .onLaneLinkFail = OnLaneLinkFail,
2202 };
2203
2204 NiceMock<LaneDepsInterfaceMock> mock;
2205 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
2206 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
2207
2208 LaneLinkInfo linkInfo;
2209 linkInfo.type = LANE_WLAN_2P4G;
2210 const LnnLaneManager *laneManager = GetLaneManager();
2211 LaneType laneType = LANE_TYPE_TRANS;
2212 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2213 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2214
2215 uint64_t laneId = LANE_ID_BASE;
2216 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2217 EXPECT_EQ(ret, SOFTBUS_OK);
2218
2219 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2220 EXPECT_EQ(ret, SOFTBUS_OK);
2221
2222 DelLaneResourceByLaneId(laneId, false);
2223 EXPECT_EQ(ret, SOFTBUS_OK);
2224 }
2225
2226 /*
2227 * @tc.name: LANE_DETECT_RELIABILITY_002
2228 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
2229 * @tc.type: FUNC
2230 * @tc.require:
2231 */
2232 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_002, TestSize.Level1)
2233 {
2234 NiceMock<LaneDepsInterfaceMock> mock;
2235 int32_t events = 0;
2236 ListenerModule module = LANE;
2237 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
2238 LaneLinkCb cb = {
2239 .onLaneLinkSuccess = OnLaneLinkSuccess,
2240 .onLaneLinkFail = OnLaneLinkFail,
2241 };
2242
2243 LaneLinkInfo linkInfo;
2244 linkInfo.type = LANE_WLAN_5G;
2245 const LnnLaneManager *laneManager = GetLaneManager();
2246 LaneType laneType = LANE_TYPE_TRANS;
2247 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2248 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2249
2250 uint64_t laneId = LANE_ID_BASE;
2251 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2252 EXPECT_EQ(ret, SOFTBUS_OK);
2253
2254 ret = LaneDetectOnDataEvent(module, events, FD);
2255 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
2256 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
2257 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
2258
2259 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2260 EXPECT_EQ(ret, SOFTBUS_OK);
2261
2262 LaneDetectInfo requestItem = {};
2263 if (GetLaneDetectInfoByWlanFd(SOFTBUS_OK, &requestItem) != SOFTBUS_OK) {
2264 return;
2265 }
2266 bool isSendSuc = true;
2267 ret = NotifyWlanDetectResult(&requestItem, isSendSuc);
2268 EXPECT_EQ(ret, SOFTBUS_OK);
2269
2270 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2271 EXPECT_EQ(ret, SOFTBUS_OK);
2272 ret = LaneDetectOnDataEvent(module, events, SOFTBUS_OK);
2273 EXPECT_EQ(ret, SOFTBUS_OK);
2274 ret = LaneDetectReliability(INVALID_LANE_REQ_ID, &linkInfo, &cb);
2275 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2276
2277 ret = DelLaneResourceByLaneId(laneId, false);
2278 EXPECT_EQ(ret, SOFTBUS_OK);
2279 }
2280
2281 /*
2282 * @tc.name: LANE_DETECT_RELIABILITY_003
2283 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
2284 * @tc.type: FUNC
2285 * @tc.require:
2286 */
2287 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_003, TestSize.Level1)
2288 {
2289 const char *ipAddr = "127.0.0.1";
2290 NiceMock<LaneDepsInterfaceMock> mock;
2291 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
2292 LaneLinkCb cb = {
2293 .onLaneLinkSuccess = OnLaneLinkSuccess,
2294 .onLaneLinkFail = OnLaneLinkFail,
2295 };
2296
2297 LaneLinkInfo linkInfo;
2298 linkInfo.type = LANE_WLAN_5G;
2299 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
2300 if (strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr) != EOK) {
2301 return;
2302 }
2303 const LnnLaneManager *laneManager = GetLaneManager();
2304 LaneType laneType = LANE_TYPE_TRANS;
2305 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2306 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2307
2308 uint64_t laneId = LANE_ID_BASE;
2309 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2310 EXPECT_EQ(ret, SOFTBUS_OK);
2311
2312 EXPECT_CALL(mock, ConnOpenClientSocket)
2313 .WillOnce(Return(SOFTBUS_TCPCONNECTION_SOCKET_ERR))
2314 .WillRepeatedly(Return(SOFTBUS_OK));
2315 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_LANE_DETECT_FAIL));
2316
2317 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2318 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
2319 linkInfo.linkInfo.wlan.connInfo.port = PORT_B;
2320
2321 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2322 EXPECT_EQ(ret, SOFTBUS_LANE_DETECT_FAIL);
2323 ret = DelLaneResourceByLaneId(laneId, false);
2324 EXPECT_EQ(ret, SOFTBUS_OK);
2325 }
2326
2327 /*
2328 * @tc.name: LANE_DETECT_RELIABILITY_004
2329 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
2330 * @tc.type: FUNC
2331 * @tc.require:
2332 */
2333 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_004, TestSize.Level1)
2334 {
2335 const char *ipAddr = "127.0.0.1";
2336 LaneLinkCb cb = {
2337 .onLaneLinkSuccess = OnLaneLinkSuccessForDetect,
2338 .onLaneLinkFail = OnLaneLinkFailForDetect,
2339 };
2340
2341 LaneLinkInfo linkInfo;
2342 linkInfo.type = LANE_WLAN_5G;
2343 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
2344 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr), EOK);
2345 const LnnLaneManager *laneManager = GetLaneManager();
2346 LaneType laneType = LANE_TYPE_TRANS;
2347 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2348 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2349
2350 NiceMock<LaneDepsInterfaceMock> mock;
2351 EXPECT_CALL(mock, ConnOpenClientSocket)
2352 .WillOnce(Return(SOFTBUS_TCPCONNECTION_SOCKET_ERR))
2353 .WillRepeatedly(Return(SOFTBUS_OK));
2354 EXPECT_CALL(mock, AddTrigger).WillOnce(Return(SOFTBUS_CONN_FAIL))
2355 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
2356 char buf[] = "lanedetect";
2357 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
2358
2359 int32_t ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2360 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
2361
2362 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2363 EXPECT_EQ(ret, SOFTBUS_CONN_FAIL);
2364
2365 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2366 EXPECT_EQ(ret, SOFTBUS_OK);
2367 }
2368
2369 /*
2370 * @tc.name: LANE_INIT_RELIABLITY_001
2371 * @tc.desc: LANE INIT RELIABLITY TEST
2372 * @tc.type: FUNC
2373 * @tc.require:
2374 */
2375 HWTEST_F(LNNLaneMockTest, LANE_INIT_RELIABLITY_001, TestSize.Level1)
2376 {
2377 NiceMock<LaneDepsInterfaceMock> mock;
2378 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
2379 int32_t ret = InitLaneReliability();
2380 EXPECT_EQ(ret, SOFTBUS_OK);
2381 }
2382
2383 /*
2384 * @tc.name: LANE_DEL_AND_ADD_LANERESOURCEITEM_001
2385 * @tc.desc: LANE_DEL AND ADD LANERESOURCEITEM CLIENT
2386 * @tc.type: FUNC
2387 * @tc.require:
2388 */
2389 HWTEST_F(LNNLaneMockTest, LANE_DEL_AND_ADD_LANERESOURCEITEM_001, TestSize.Level1)
2390 {
2391 NiceMock<LaneDepsInterfaceMock> mock;
2392 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2393 LaneLinkInfo linkInfo;
2394 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2395 linkInfo.type = LANE_HML;
2396 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2397 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2398
2399 uint64_t laneId = INVALID_LANE_ID;
2400 int32_t ret = AddLaneResourceToPool(nullptr, laneId, false);
2401 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2402 ret = AddLaneResourceToPool(&linkInfo, INVALID_LANE_ID, false);
2403 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2404
2405 laneId = LANE_ID_BASE;
2406 uint32_t clientRef = 0;
2407 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2408 EXPECT_EQ(ret, SOFTBUS_OK);
2409 clientRef++;
2410 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
2411 EXPECT_EQ(ret, SOFTBUS_OK);
2412 clientRef++;
2413
2414 LaneResource laneResourse;
2415 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2416 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2417 EXPECT_EQ(ret, SOFTBUS_OK);
2418 EXPECT_FALSE(laneResourse.isServerSide);
2419 EXPECT_EQ(laneResourse.clientRef, clientRef);
2420
2421 ret = DelLaneResourceByLaneId(INVALID_LANE_ID, false);
2422 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2423 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2424 EXPECT_EQ(laneResourse.clientRef, clientRef);
2425
2426 ret = DelLaneResourceByLaneId(laneId, false);
2427 EXPECT_EQ(ret, SOFTBUS_OK);
2428 clientRef--;
2429 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2430 EXPECT_EQ(laneResourse.clientRef, clientRef);
2431
2432 ret = DelLaneResourceByLaneId(laneId, false);
2433 EXPECT_EQ(ret, SOFTBUS_OK);
2434 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2435 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2436 }
2437
2438 /*
2439 * @tc.name: LANE_DEL_AND_ADD_LANERESOURCEITEM_002
2440 * @tc.desc: LANE_DEL AND ADD LANERESOURCEITEM SERVER
2441 * @tc.type: FUNC
2442 * @tc.require:
2443 */
2444 HWTEST_F(LNNLaneMockTest, LANE_DEL_AND_ADD_LANERESOURCEITEM_002, TestSize.Level1)
2445 {
2446 NiceMock<LaneDepsInterfaceMock> mock;
2447 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2448 LaneLinkInfo linkInfo;
2449 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
2450 linkInfo.type = LANE_HML;
2451 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2452 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2453
2454 uint64_t laneId = INVALID_LANE_ID;
2455 int32_t ret = AddLaneResourceToPool(nullptr, laneId, true);
2456 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2457
2458 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2459 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2460
2461 laneId = LANE_ID_BASE;
2462 uint32_t serverRef = 0;
2463 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2464 EXPECT_EQ(ret, SOFTBUS_OK);
2465
2466 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2467 EXPECT_EQ(ret, SOFTBUS_LANE_TRIGGER_LINK_FAIL);
2468
2469 LaneResource laneResourse;
2470 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
2471 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2472 EXPECT_EQ(ret, SOFTBUS_OK);
2473 EXPECT_TRUE(laneResourse.isServerSide);
2474 EXPECT_EQ(laneResourse.clientRef, serverRef);
2475
2476 ret = DelLaneResourceByLaneId(laneId, false);
2477 EXPECT_EQ(ret, SOFTBUS_OK);
2478
2479 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2480 EXPECT_EQ(ret, SOFTBUS_OK);
2481
2482 ret = DelLaneResourceByLaneId(laneId, true);
2483 EXPECT_EQ(ret, SOFTBUS_OK);
2484 }
2485
2486 /*
2487 * @tc.name: LANE_GENERATE_LANE_ID_001
2488 * @tc.desc: LANE GENERATE LANE ID
2489 * @tc.type: FUNC
2490 * @tc.require:
2491 */
2492 HWTEST_F(LNNLaneMockTest, LANE_GENERATE_LANE_ID_001, TestSize.Level1)
2493 {
2494 NiceMock<LaneDepsInterfaceMock> laneMock;
2495 EXPECT_CALL(laneMock, SoftBusGenerateStrHash)
2496 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
2497 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfGenerateStrHash);
2498
2499 uint64_t laneId = GenerateLaneId(LOCAL_UDID, PEER_UDID, LANE_HML);
2500 EXPECT_EQ(laneId, INVALID_LANE_ID);
2501
2502 laneId = GenerateLaneId(LOCAL_UDID, PEER_UDID, LANE_HML);
2503 EXPECT_NE(laneId, INVALID_LANE_ID);
2504 }
2505
2506 /*
2507 * @tc.name: LNN_SELECT_AUTH_LANE_TEST_001
2508 * @tc.desc: SelectAuthLane
2509 * @tc.type: FUNC
2510 * @tc.require:
2511 */
2512 HWTEST_F(LNNLaneMockTest, LNN_SELECT_AUTH_LANE_TEST_001, TestSize.Level1)
2513 {
2514 const char *networkId = "testnetworkid123";
2515 NiceMock<LaneDepsInterfaceMock> mock;
2516 LanePreferredLinkList recommendList = {};
2517 LanePreferredLinkList request = {};
2518
2519 request.linkTypeNum = 4;
2520 request.linkType[0] = LANE_P2P;
2521 request.linkType[1] = LANE_BLE;
2522 request.linkType[2] = LANE_BR;
2523 request.linkType[3] = LANE_HML;
2524
2525 EXPECT_CALL(mock, LnnGetLocalNumInfo)
2526 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
2527 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
2528 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
2529 int32_t ret = SelectAuthLane(nullptr, &recommendList, &request);
2530 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2531
2532 ret = SelectAuthLane(networkId, nullptr, &request);
2533 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2534
2535 ret = SelectAuthLane(networkId, &recommendList, nullptr);
2536 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2537
2538 ret = SelectAuthLane(networkId, &recommendList, &request);
2539 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
2540 }
2541
2542 /*
2543 * @tc.name: LNN_AUTH_ALLOC_TEST_001
2544 * @tc.desc: AuthAlloc
2545 * @tc.type: FUNC
2546 * @tc.require:
2547 */
2548 HWTEST_F(LNNLaneMockTest, LNN_AUTH_ALLOC_TEST_001, TestSize.Level1)
2549 {
2550 const LnnLaneManager *laneManager = GetLaneManager();
2551 LaneType laneType = LANE_TYPE_CTRL;
2552 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2553 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2554
2555 NiceMock<LaneDepsInterfaceMock> mock;
2556 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2557 EXPECT_CALL(mock, LnnGetLocalNumInfo)
2558 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
2559 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
2560 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
2561 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
2562 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
2563 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
2564 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
2565
2566 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2567 wifiMock.SetDefaultResult();
2568
2569 LaneAllocInfo allocInfo = {};
2570 allocInfo.type = laneType;
2571 (void)strncpy_s(allocInfo.networkId, NETWORK_ID_BUF_LEN,
2572 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
2573 allocInfo.transType = LANE_T_BYTE;
2574 allocInfo.qosRequire.minBW = 0;
2575 allocInfo.qosRequire.maxLaneLatency = 0;
2576 allocInfo.qosRequire.minLaneLatency = 0;
2577
2578 int32_t ret = laneManager->lnnAllocLane(laneReqId, nullptr, &g_listener);
2579 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2580
2581 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, nullptr);
2582 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2583
2584 ret = laneManager->lnnAllocLane(INVALID_LANE_REQ_ID, &allocInfo, &g_listener);
2585 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2586
2587 AuthLinkTypeList mockList = {};
2588 mockList.linkType[0] = AUTH_LINK_TYPE_WIFI;
2589 mockList.linkTypeNum = 1;
2590 EXPECT_CALL(mock, GetAuthLinkTypeList)
2591 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(mockList), Return(SOFTBUS_OK)));
2592 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listener);
2593 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
2594 }
2595
2596 /*
2597 * @tc.name: LANE_CLEAR_LANE_RESOURCE_BYLANEID_001
2598 * @tc.desc: ClearLaneResourceByLaneId
2599 * @tc.type: FUNC
2600 * @tc.require:
2601 */
2602 HWTEST_F(LNNLaneMockTest, LANE_CLEAR_LANE_RESOURCE_BYLANEID_001, TestSize.Level1)
2603 {
2604 NiceMock<LaneDepsInterfaceMock> mock;
2605 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2606
2607 uint64_t laneId = LANE_ID_BASE;
2608 int32_t ret = ClearLaneResourceByLaneId(laneId);
2609 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2610
2611 LaneLinkInfo linkInfo = {};
2612 linkInfo.type = LANE_HML;
2613 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2614 EXPECT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2615 uint32_t clientRef = 0;
2616 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2617 EXPECT_EQ(ret, SOFTBUS_OK);
2618
2619 LaneResource laneResourse = {};
2620 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2621 EXPECT_EQ(ret, SOFTBUS_OK);
2622 EXPECT_TRUE(laneResourse.isServerSide);
2623 EXPECT_EQ(laneResourse.clientRef, clientRef);
2624
2625 ret = ClearLaneResourceByLaneId(laneId);
2626 EXPECT_EQ(ret, SOFTBUS_OK);
2627
2628 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2629 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2630 }
2631
2632 /*
2633 * @tc.name: LANE_PPOCESS_VAP_INFO_001
2634 * @tc.desc: ProcessVapInfo hml
2635 * @tc.type: FUNC
2636 * @tc.require:
2637 */
2638 HWTEST_F(LNNLaneMockTest, LANE_PPOCESS_VAP_INFO_001, TestSize.Level1)
2639 {
2640 NiceMock<LaneDepsInterfaceMock> mock;
2641 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2642 LaneLinkInfo linkInfo = {};
2643 linkInfo.type = LANE_P2P;
2644 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2645 EXPECT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2646 uint64_t laneId = LANE_ID_BASE;
2647 uint64_t laneIdExt = LANE_ID_BASE + 1;
2648 uint32_t clientRef = 0;
2649 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2650 EXPECT_EQ(ret, SOFTBUS_OK);
2651
2652 linkInfo.type = LANE_HML;
2653 ret = AddLaneResourceToPool(&linkInfo, laneIdExt, false);
2654 EXPECT_EQ(ret, SOFTBUS_OK);
2655 clientRef++;
2656
2657 ret = ClearLaneResourceByLaneId(laneId);
2658 EXPECT_EQ(ret, SOFTBUS_OK);
2659
2660 LaneResource laneResourse = {};
2661 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2662 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2663
2664 ret = FindLaneResourceByLaneId(laneIdExt, &laneResourse);
2665 EXPECT_EQ(ret, SOFTBUS_OK);
2666 EXPECT_TRUE(!laneResourse.isServerSide);
2667 EXPECT_EQ(laneResourse.clientRef, clientRef);
2668
2669 ret = DelLaneResourceByLaneId(laneIdExt, false);
2670 EXPECT_EQ(ret, SOFTBUS_OK);
2671 }
2672
2673 /*
2674 * @tc.name: LANE_PPOCESS_VAP_INFO_002
2675 * @tc.desc: ProcessVapInfo p2p
2676 * @tc.type: FUNC
2677 * @tc.require:
2678 */
2679 HWTEST_F(LNNLaneMockTest, LANE_PPOCESS_VAP_INFO_002, TestSize.Level1)
2680 {
2681 NiceMock<LaneDepsInterfaceMock> mock;
2682 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2683 LaneLinkInfo linkInfo = {};
2684 linkInfo.type = LANE_HML;
2685 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
2686 EXPECT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
2687 uint64_t laneId = LANE_ID_BASE;
2688 uint64_t laneIdExt = LANE_ID_BASE + 1;
2689 uint32_t clientRef = 0;
2690 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, true);
2691 EXPECT_EQ(ret, SOFTBUS_OK);
2692
2693 linkInfo.type = LANE_P2P;
2694 ret = AddLaneResourceToPool(&linkInfo, laneIdExt, false);
2695 EXPECT_EQ(ret, SOFTBUS_OK);
2696 clientRef++;
2697
2698 ret = ClearLaneResourceByLaneId(laneId);
2699 EXPECT_EQ(ret, SOFTBUS_OK);
2700
2701 LaneResource laneResourse = {};
2702 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
2703 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
2704
2705 ret = FindLaneResourceByLaneId(laneIdExt, &laneResourse);
2706 EXPECT_EQ(ret, SOFTBUS_OK);
2707 EXPECT_TRUE(!laneResourse.isServerSide);
2708 EXPECT_EQ(laneResourse.clientRef, clientRef);
2709
2710 ret = DelLaneResourceByLaneId(laneIdExt, false);
2711 EXPECT_EQ(ret, SOFTBUS_OK);
2712 }
2713
2714 /*
2715 * @tc.name: LNN_LANE_SELECT_01
2716 * @tc.desc: SelectLane
2717 * @tc.type: FUNC
2718 * @tc.require:
2719 */
2720 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_01, TestSize.Level1)
2721 {
2722 const char *networkId = "test";
2723 LaneLinkType linkType = LANE_LINK_TYPE_BUTT;
2724 int32_t ret = LaneCapCheck(networkId, linkType);
2725 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2726 }
2727
2728 /*
2729 * @tc.name: LNN_LANE_SELECT_02
2730 * @tc.desc: SelectLane
2731 * @tc.type: FUNC
2732 * @tc.require:
2733 */
2734 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_02, TestSize.Level1)
2735 {
2736 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2737 NiceMock<LaneDepsInterfaceMock> mock;
2738
2739 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
2740 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
2741 int32_t ret = GetErrCodeOfLink("networkId", LANE_WLAN_2P4G);
2742 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2743
2744 ret = GetErrCodeOfLink("networkId", LANE_P2P_REUSE);
2745 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2746
2747 ret = GetErrCodeOfLink("networkId", LANE_HML);
2748 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2749
2750 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
2751 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_DEACTIVATING));
2752 ret = GetErrCodeOfLink("networkId", LANE_HML);
2753 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2754
2755 ret = GetErrCodeOfLink("networkId", LANE_P2P_REUSE);
2756 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2757
2758 EXPECT_CALL(mock, SoftBusGetBtState)
2759 .WillRepeatedly(Return(0));
2760 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BR), SOFTBUS_LANE_BT_OFF);
2761 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE), SOFTBUS_LANE_BT_OFF);
2762 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_DIRECT), SOFTBUS_LANE_BT_OFF);
2763 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_REUSE), SOFTBUS_LANE_BT_OFF);
2764
2765 EXPECT_CALL(mock, SoftBusGetBtState)
2766 .WillRepeatedly(Return(1));
2767 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BR), SOFTBUS_LANE_LOCAL_NO_BR_CAP);
2768 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE), SOFTBUS_LANE_LOCAL_NO_BLE_CAP);
2769 EXPECT_EQ(GetErrCodeOfLink("networkId", LANE_BLE_DIRECT), SOFTBUS_LANE_LOCAL_NO_BLE_CAP);
2770 }
2771
2772 /*
2773 * @tc.name: LNN_LANE_SELECT_RULE_01
2774 * @tc.desc: SelectLaneRule
2775 * @tc.type: FUNC
2776 * @tc.require:
2777 */
2778 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_01, TestSize.Level1)
2779 {
2780 LaneLinkType linkList;
2781 uint32_t listNum = 0;
2782 LanePreferredLinkList recommendList;
2783 int32_t ret = FinalDecideLinkType(nullptr, &linkList, listNum, &recommendList);
2784 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2785
2786 ret = FinalDecideLinkType(nullptr, nullptr, listNum, &recommendList);
2787 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2788
2789 ret = FinalDecideLinkType(nullptr, nullptr, listNum, nullptr);
2790 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2791
2792 listNum = LANE_LINK_TYPE_BUTT;
2793 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2794 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2795 }
2796
2797 /*
2798 * @tc.name: LNN_LANE_SELECT_RULE_02
2799 * @tc.desc: SelectLaneRule
2800 * @tc.type: FUNC
2801 * @tc.require:
2802 */
2803 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_02, TestSize.Level1)
2804 {
2805 LaneLinkType linkList[LANE_LINK_TYPE_BUTT];
2806 uint32_t listNum = 1;
2807 LanePreferredLinkList recommendList;
2808
2809 NiceMock<LaneDepsInterfaceMock> linkMock;
2810 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2811 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
2812 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
2813 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
2814
2815 linkList[0] = LANE_P2P;
2816 int32_t ret = FinalDecideLinkType("test", linkList, listNum, &recommendList);
2817 EXPECT_EQ(ret, SOFTBUS_OK);
2818 }
2819
2820 /*
2821 * @tc.name: LNN_LANE_SELECT_RULE_03
2822 * @tc.desc: SelectLaneRule
2823 * @tc.type: FUNC
2824 * @tc.require:
2825 */
2826 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_03, TestSize.Level1)
2827 {
2828 LaneLinkType linkList;
2829 uint32_t listNum = 1;
2830 LanePreferredLinkList recommendList;
2831
2832 NiceMock<LaneDepsInterfaceMock> linkMock;
2833 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2834 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_ERR)));
2835
2836 int32_t ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2837 EXPECT_EQ(ret, SOFTBUS_OK);
2838
2839 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2840 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(-1), Return(SOFTBUS_OK)));
2841 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2842 EXPECT_EQ(ret, SOFTBUS_OK);
2843
2844 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2845 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
2846 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
2847 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_ERR)));
2848 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2849 EXPECT_EQ(ret, SOFTBUS_OK);
2850
2851 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
2852 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(-1), Return(SOFTBUS_OK)));
2853 ret = FinalDecideLinkType("test", &linkList, listNum, &recommendList);
2854 EXPECT_EQ(ret, SOFTBUS_OK);
2855 }
2856
2857 /*
2858 * @tc.name: LNN_LANE_SELECT_RULE_04
2859 * @tc.desc: SelectLaneRule
2860 * @tc.type: FUNC
2861 * @tc.require:
2862 */
2863 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_04, TestSize.Level1)
2864 {
2865 LaneSelectParam request;
2866 LanePreferredLinkList recommendList;
2867 int32_t ret = DecideAvailableLane("test", nullptr, &recommendList);
2868 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2869
2870 ret = DecideAvailableLane("test", &request, nullptr);
2871 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2872
2873 ret = DecideAvailableLane("test", nullptr, nullptr);
2874 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2875 }
2876
2877 /*
2878 * @tc.name: LNN_LANE_SELECT_RULE_05
2879 * @tc.desc: SelectLaneRule
2880 * @tc.type: FUNC
2881 * @tc.require:
2882 */
2883 HWTEST_F(LNNLaneMockTest, LNN_LANE_SELECT_RULE_05, TestSize.Level1)
2884 {
2885 NiceMock<LaneDepsInterfaceMock> linkMock;
2886
2887 LnnWifiAdpterInterfaceMock wifiMock;
2888 LaneSelectParam request;
2889 LanePreferredLinkList recommendList;
2890
2891 request.qosRequire.minLaneLatency = 0;
2892 EXPECT_CALL(linkMock, LnnGetRemoteNodeInfoById)
2893 .WillRepeatedly(Return(SOFTBUS_OK));
2894 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
2895 .WillRepeatedly(Return(SOFTBUS_ERR));
2896 EXPECT_CALL(wifiMock, SoftBusGetWifiState)
2897 .WillRepeatedly(Return(SOFTBUS_WIFI_STATE_INACTIVE));
2898 int32_t ret = DecideAvailableLane("test", &request, &recommendList);
2899 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2900
2901 request.transType = LANE_T_FILE;
2902 request.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
2903 request.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
2904 request.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
2905
2906 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo)
2907 .WillRepeatedly(Return(SOFTBUS_ERR));
2908 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
2909 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2910
2911 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
2912 .WillRepeatedly(Return(SOFTBUS_ERR));
2913 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
2914 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2915
2916 int32_t osType = OH_OS_TYPE;
2917 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
2918 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
2919 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
2920 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2921
2922 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
2923 .WillRepeatedly(Return(SOFTBUS_ERR));
2924 EXPECT_CALL(linkMock, LnnGetOsTypeByNetworkId)
2925 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
2926 ret = DecideAvailableLane(NODE_NETWORK_ID, &request, &recommendList);
2927 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2928 }
2929
2930 /*
2931 * @tc.name: LNN_LANE_03
2932 * @tc.desc: SelectLaneRule
2933 * @tc.type: FUNC
2934 * @tc.require:
2935 */
2936 HWTEST_F(LNNLaneMockTest, LNN_LANE_03, TestSize.Level1)
2937 {
2938 uint32_t laneReqId = 0;
2939 LaneRequestOption request;
2940 ILaneListener listener;
2941 ILaneIdStateListener laneListener;
2942
2943 RegisterLaneIdListener(nullptr);
2944 laneListener.OnLaneIdEnabled = nullptr;
2945 laneListener.OnLaneIdDisabled = nullptr;
2946 RegisterLaneIdListener(&laneListener);
2947 UnregisterLaneIdListener(nullptr);
2948 FreeLaneReqId(laneReqId);
2949 laneReqId = 0xfffffff;
2950 FreeLaneReqId(laneReqId);
2951 request.type = LANE_TYPE_BUTT;
2952 int32_t ret = LnnRequestLane(0, &request, &listener);
2953 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2954
2955 request.type = (LaneType)-1;
2956 ret = LnnRequestLane(0, &request, &listener);
2957 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2958 }
2959
2960 /*
2961 * @tc.name: LNN_LANE_04
2962 * @tc.desc: SelectLaneRule
2963 * @tc.type: FUNC
2964 * @tc.require:
2965 */
2966 HWTEST_F(LNNLaneMockTest, LNN_LANE_04, TestSize.Level1)
2967 {
2968 RawLaneAllocInfo allocInfo;
2969 LaneAllocListener listener;
2970
2971 const LnnLaneManager *laneManager = GetLaneManager();
2972 LaneType laneType = LANE_TYPE_TRANS;
2973 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2974 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2975
2976 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, nullptr, &listener);
2977 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2978 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, nullptr);
2979 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2980 ret = laneManager->lnnAllocRawLane(laneHandle, nullptr, nullptr);
2981 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2982
2983 allocInfo.type = LANE_TYPE_BUTT;
2984 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2985 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2986
2987 allocInfo.type = (LaneType)-1;
2988 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2989 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2990 }
2991
2992 /*
2993 * @tc.name: LNN_LANE_05
2994 * @tc.desc: SelectLaneRule
2995 * @tc.type: FUNC
2996 * @tc.require:
2997 */
2998 HWTEST_F(LNNLaneMockTest, LNN_LANE_05, TestSize.Level1)
2999 {
3000 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3001 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3002 const LnnLaneManager *laneManager = GetLaneManager();
3003 LaneType laneType = LANE_TYPE_TRANS;
3004 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3005 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3006
3007 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
3008 RawLaneAllocInfo allocInfo;
3009 allocInfo.type = LANE_TYPE_HDLC;
3010 LaneAllocListener listener;
3011 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
3012 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3013
3014 ret = laneManager->lnnFreeLane(laneHandle);
3015 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
3016 std::this_thread::sleep_for(std::chrono::milliseconds(100));
3017 }
3018
3019 /*
3020 * @tc.name: LNN_LANE_06
3021 * @tc.desc: SelectLaneRule
3022 * @tc.type: FUNC
3023 * @tc.require:
3024 */
3025 HWTEST_F(LNNLaneMockTest, LNN_LANE_06, TestSize.Level1)
3026 {
3027 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3028 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3029 const LnnLaneManager *laneManager = GetLaneManager();
3030 LaneType laneType = LANE_TYPE_TRANS;
3031 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3032 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3033
3034 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
3035 RawLaneAllocInfo allocInfo;
3036 allocInfo.type = LANE_TYPE_TRANS;
3037 LaneAllocListener listener;
3038 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
3039 EXPECT_EQ(ret, SOFTBUS_OK);
3040
3041 ret = laneManager->lnnFreeLane(laneHandle);
3042 EXPECT_EQ(ret, SOFTBUS_OK);
3043 std::this_thread::sleep_for(std::chrono::milliseconds(100));
3044 }
3045
3046 /*
3047 * @tc.name: LNN_LANE_07
3048 * @tc.desc: SelectLaneRule
3049 * @tc.type: FUNC
3050 * @tc.require:
3051 */
3052 HWTEST_F(LNNLaneMockTest, LNN_LANE_07, TestSize.Level1)
3053 {
3054 LaneAllocInfoExt allocInfo;
3055 LaneAllocListener listener;
3056 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3057
3058 const LnnLaneManager *laneManager = GetLaneManager();
3059 LaneType laneType = LANE_TYPE_TRANS;
3060 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3061 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3062
3063 int32_t ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, nullptr);
3064 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3065 ret = laneManager->lnnAllocTargetLane(laneHandle, nullptr, &listener);
3066 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3067 ret = laneManager->lnnAllocTargetLane(laneHandle, nullptr, nullptr);
3068 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3069 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, nullptr, nullptr);
3070 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3071 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, nullptr, &listener);
3072 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3073 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, &allocInfo, &listener);
3074 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3075 allocInfo.type = LANE_TYPE_BUTT;
3076 ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &listener);
3077 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3078 allocInfo.type = LANE_TYPE_TRANS;
3079 allocInfo.linkList.linkTypeNum = LANE_LINK_TYPE_BUTT;
3080 ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &listener);
3081 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3082 std::this_thread::sleep_for(std::chrono::milliseconds(100));
3083 }
3084
3085 /*
3086 * @tc.name: LNN_LANE_08
3087 * @tc.desc: SelectLaneRule
3088 * @tc.type: FUNC
3089 * @tc.require:
3090 */
3091 HWTEST_F(LNNLaneMockTest, LNN_LANE_08, TestSize.Level1)
3092 {
3093 LaneAllocInfoExt allocInfo;
3094 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3095 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3096 const LnnLaneManager *laneManager = GetLaneManager();
3097 LaneType laneType = LANE_TYPE_TRANS;
3098 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
3099 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
3100
3101 EXPECT_CALL(laneDepMock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
3102 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
3103 laneDepMock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3104 laneDepMock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 8, 8);
3105 wifiMock.SetDefaultResult();
3106 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneHandle, NotNull()))
3107 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
3108 EXPECT_CALL(laneDepMock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
3109
3110 allocInfo.linkList.linkTypeNum = LANE_LINK_TYPE_BUTT - 1;
3111 allocInfo.type = LANE_TYPE_TRANS;
3112 int32_t ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &g_listenerCbForP2p2);
3113 EXPECT_EQ(ret, SOFTBUS_OK);
3114
3115 ret = laneManager->lnnFreeLane(laneHandle);
3116 EXPECT_EQ(ret, SOFTBUS_OK);
3117 std::this_thread::sleep_for(std::chrono::milliseconds(100));
3118 }
3119
3120 /*
3121 * @tc.name: LNN_LANE_09
3122 * @tc.desc: SelectLaneRule
3123 * @tc.type: FUNC
3124 * @tc.require:
3125 */
3126 HWTEST_F(LNNLaneMockTest, LNN_LANE_09, TestSize.Level1)
3127 {
3128 LnnMacInfo macInfo;
3129 LaneLinkInfo linkInfo;
3130 linkInfo.type = LANE_P2P;
3131 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3132
3133 EXPECT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.localIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
3134 EXPECT_EQ(strcpy_s(macInfo.localMac, MAX_MAC_LEN, LOCAL_MAC), EOK);
3135 EXPECT_EQ(strcpy_s(macInfo.remoteMac, MAX_MAC_LEN, PEER_MAC), EOK);
3136 int32_t ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
3137 EXPECT_EQ(ret, SOFTBUS_OK);
3138 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3139 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3140
3141 linkInfo.type = LANE_P2P_REUSE;
3142 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
3143 EXPECT_EQ(ret, SOFTBUS_OK);
3144 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3145 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3146
3147 linkInfo.type = LANE_HML;
3148 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
3149 EXPECT_EQ(ret, SOFTBUS_OK);
3150 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3151 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3152
3153 linkInfo.type = LANE_ETH;
3154 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
3155 EXPECT_EQ(ret, SOFTBUS_OK);
3156 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
3157 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3158 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3159 }
3160
3161 /*
3162 * @tc.name: LNN_LANE_11
3163 * @tc.desc: SelectLaneRule
3164 * @tc.type: FUNC
3165 * @tc.require:
3166 */
3167 HWTEST_F(LNNLaneMockTest, LNN_LANE_11, TestSize.Level1)
3168 {
3169 LaneLinkInfo linkInfo;
3170 NiceMock<LaneDepsInterfaceMock> laneDepMock;
3171 LnnMacInfo macInfo;
3172 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
3173 linkInfo.type = LANE_P2P;
3174 ASSERT_EQ(strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)), EOK);
3175 ASSERT_EQ(strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)), EOK);
3176 uint64_t laneId = LANE_ID_BASE;
3177 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
3178 uint32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
3179 EXPECT_EQ(ret, SOFTBUS_OK);
3180 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
3181 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
3182 EXPECT_EQ(ret, SOFTBUS_OK);
3183 }
3184
3185 /*
3186 * @tc.name: LNN_LANE_13
3187 * @tc.desc: SelectLaneRule
3188 * @tc.type: FUNC
3189 * @tc.require:
3190 */
3191 HWTEST_F(LNNLaneMockTest, LNN_LANE_13, TestSize.Level1)
3192 {
3193 LaneType laneType = LANE_TYPE_TRANS;
3194 uint32_t laneReqId = ApplyLaneReqId(laneType);
3195 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
3196 NiceMock<LaneDepsInterfaceMock> mock;
3197 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(DoAll(SetArgPointee<1>(NET_CAP), Return(SOFTBUS_OK)));
3198 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(DoAll(SetArgPointee<2>(NET_CAP), Return(SOFTBUS_OK)));
3199 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
3200 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3201 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
3202
3203 LaneRequestOption requestOption = {};
3204 requestOption.type = laneType;
3205 EXPECT_EQ(strncpy_s(requestOption.requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
3206 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
3207 requestOption.requestInfo.trans.transType = LANE_T_COMMON_VIDEO;
3208 requestOption.requestInfo.trans.expectedBw = 0;
3209 requestOption.requestInfo.trans.pid = 0;
3210 requestOption.requestInfo.trans.expectedLink.linkTypeNum = 1;
3211 requestOption.requestInfo.trans.expectedLink.linkType[0] = LANE_WLAN_5G;
3212
3213 int32_t ret = LnnRequestLane(laneReqId, &requestOption, &g_listener2);
3214 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
3215 }
3216
3217 /*
3218 * @tc.name: LNN_LANE_14
3219 * @tc.desc: SelectLaneRule
3220 * @tc.type: FUNC
3221 * @tc.require:
3222 */
3223 HWTEST_F(LNNLaneMockTest, LNN_LANE_14, TestSize.Level1)
3224 {
3225 NiceMock<LaneDepsInterfaceMock> mock;
3226 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3227 LaneSelectParam selectParam = {};
3228 LanePreferredLinkList linkList = {};
3229 selectParam.transType = LANE_T_RAW_STREAM;
3230 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
3231 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
3232 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
3233
3234 wifiMock.SetDefaultResult();
3235 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_24G));
3236 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3237 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3238 EXPECT_CALL(mock, LnnGetLocalNumInfo)
3239 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
3240 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
3241 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
3242 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
3243
3244 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
3245 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_BAND_ERR);
3246 }
3247
3248 /*
3249 * @tc.name: LNN_LANE_15
3250 * @tc.desc: SelectLaneRule
3251 * @tc.type: FUNC
3252 * @tc.require:
3253 */
3254 HWTEST_F(LNNLaneMockTest, LNN_LANE_15, TestSize.Level1)
3255 {
3256 NiceMock<LaneDepsInterfaceMock> mock;
3257 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3258 LaneSelectParam selectParam = {};
3259 LanePreferredLinkList linkList = {};
3260 selectParam.transType = LANE_T_RAW_STREAM;
3261 selectParam.qosRequire.minBW = DEFAULT_QOSINFO_MIN_BW;
3262 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
3263 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
3264
3265 wifiMock.SetDefaultResult();
3266 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
3267 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3268 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3269 EXPECT_CALL(mock, LnnGetLocalNumInfo)
3270 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
3271 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
3272 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
3273 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
3274 EXPECT_CALL(mock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_ERR));
3275 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
3276 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
3277 }
3278
3279 /*
3280 * @tc.name: LNN_LANE_16
3281 * @tc.desc: SelectLaneRule
3282 * @tc.type: FUNC
3283 * @tc.require:
3284 */
3285 HWTEST_F(LNNLaneMockTest, LNN_LANE_16, TestSize.Level1)
3286 {
3287 NiceMock<LaneDepsInterfaceMock> mock;
3288 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3289 LaneSelectParam selectParam = {};
3290 LanePreferredLinkList linkList = {};
3291 selectParam.transType = LANE_T_RAW_STREAM;
3292 selectParam.qosRequire.minBW = HIGH_BW;
3293 selectParam.qosRequire.maxLaneLatency = DEFAULT_QOSINFO_MAX_LATENCY;
3294 selectParam.qosRequire.minLaneLatency = DEFAULT_QOSINFO_MIN_LATENCY;
3295
3296 wifiMock.SetDefaultResult();
3297 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
3298 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3299 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3300 EXPECT_CALL(mock, LnnGetLocalNumInfo)
3301 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
3302 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
3303 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
3304 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
3305 EXPECT_CALL(mock, LnnGetLocalNumU32Info).WillRepeatedly(Return(SOFTBUS_ERR));
3306 int32_t ret = DecideAvailableLane(NODE_NETWORK_ID, &selectParam, &linkList);
3307 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
3308 }
3309
3310 /*
3311 * @tc.name: LNN_LANE_17
3312 * @tc.desc: SelectLaneRule
3313 * @tc.type: FUNC
3314 * @tc.require:
3315 */
3316 HWTEST_F(LNNLaneMockTest, LNN_LANE_17, TestSize.Level1)
3317 {
3318 NiceMock<LaneDepsInterfaceMock> mock;
3319 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3320 uint32_t listNum = 0;
3321 LanePreferredLinkList linkList = {};
3322 LaneSelectParam selectParam = {};
3323 selectParam.transType = LANE_T_FILE;
3324 selectParam.expectedBw = 0;
3325 selectParam.list.linkTypeNum = 2;
3326 selectParam.list.linkType[0] = LANE_WLAN_2P4G;
3327 selectParam.list.linkType[1] = LANE_COC_DIRECT;
3328 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3329 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
3330 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
3331 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
3332 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
3333 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3334 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3335 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3336 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3337 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
3338 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
3339 wifiMock.SetDefaultResult();
3340 SoftBusWifiLinkedInfo wlanInfo;
3341 wlanInfo.frequency = 1;
3342 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3343 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
3344 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
3345 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
3346 EXPECT_EQ(ret, SOFTBUS_OK);
3347 }
3348
3349 /*
3350 * @tc.name: LNN_LANE_18
3351 * @tc.desc: SelectLaneRule
3352 * @tc.type: FUNC
3353 * @tc.require:
3354 */
3355 HWTEST_F(LNNLaneMockTest, LNN_LANE_18, TestSize.Level1)
3356 {
3357 NiceMock<LaneDepsInterfaceMock> mock;
3358 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3359 uint32_t listNum = 0;
3360 LanePreferredLinkList linkList = {};
3361 LaneSelectParam selectParam = {};
3362 selectParam.transType = LANE_T_FILE;
3363 selectParam.expectedBw = 0;
3364 selectParam.list.linkTypeNum = 2;
3365 selectParam.list.linkType[0] = LANE_WLAN_2P4G;
3366 selectParam.list.linkType[1] = LANE_COC_DIRECT;
3367 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
3368 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
3369 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
3370 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
3371 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
3372 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3373 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3374 EXPECT_CALL(mock, LnnGetLocalNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3375 EXPECT_CALL(mock, LnnGetRemoteNumU64Info).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
3376 EXPECT_CALL(mock, LnnHasDiscoveryType).WillRepeatedly(Return(true));
3377 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_OK));
3378 wifiMock.SetDefaultResult();
3379 SoftBusWifiLinkedInfo wlanInfo;
3380 wlanInfo.frequency = FREQUENCY_2G_FIRST + 1;
3381 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
3382 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
3383 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3384 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
3385 EXPECT_EQ(ret, SOFTBUS_OK);
3386 }
3387
3388 /*
3389 * @tc.name: LNN_LANE_19
3390 * @tc.desc: SelectLaneRule
3391 * @tc.type: FUNC
3392 * @tc.require:
3393 */
3394 HWTEST_F(LNNLaneMockTest, LNN_LANE_19, TestSize.Level1)
3395 {
3396 LaneLinkType linkType = LANE_COC_DIRECT;
3397 NiceMock<LaneDepsInterfaceMock> linkMock;
3398 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
3399 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(1), Return(SOFTBUS_OK)));
3400 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
3401 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(1), Return(SOFTBUS_OK)));
3402 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
3403 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM), Return(SOFTBUS_OK)))
3404 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(LOCAL_NUM), Return(SOFTBUS_OK)));
3405 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
3406 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM), Return(SOFTBUS_OK)))
3407 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(LOCAL_NUM), Return(SOFTBUS_OK)));
3408 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3409 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_COC_CAP);
3410 }
3411
3412 /*
3413 * @tc.name: LNN_LANE_20
3414 * @tc.desc: SelectLaneRule
3415 * @tc.type: FUNC
3416 * @tc.require:
3417 */
3418 HWTEST_F(LNNLaneMockTest, LNN_LANE_20, TestSize.Level1)
3419 {
3420 LaneLinkType linkType = LANE_P2P_REUSE;
3421 NiceMock<LaneDepsInterfaceMock> linkMock;
3422 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3423 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
3424 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
3425 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
3426 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
3427 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_DEACTIVATING));
3428 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3429 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_WIFI_DIRECT_CAP);
3430 }
3431
3432 /*
3433 * @tc.name: LNN_LANE_21
3434 * @tc.desc: SelectLaneRule
3435 * @tc.type: FUNC
3436 * @tc.require:
3437 */
3438 HWTEST_F(LNNLaneMockTest, LNN_LANE_21, TestSize.Level1)
3439 {
3440 LaneLinkType linkType = LANE_P2P_REUSE;
3441 NiceMock<LaneDepsInterfaceMock> linkMock;
3442 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
3443 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
3444 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
3445 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
3446 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
3447 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_SEMIACTIVATING));
3448 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3449 EXPECT_EQ(ret, SOFTBUS_LANE_REMOTE_NO_WIFI_DIRECT_CAP);
3450 }
3451
3452 /*
3453 * @tc.name: LNN_LANE_22
3454 * @tc.desc: SelectLaneRule
3455 * @tc.type: FUNC
3456 * @tc.require:
3457 */
3458 HWTEST_F(LNNLaneMockTest, LNN_LANE_22, TestSize.Level1)
3459 {
3460 LaneLinkType linkType = LANE_P2P_REUSE;
3461 NiceMock<LaneDepsInterfaceMock> linkMock;
3462 EXPECT_CALL(linkMock, LnnGetLocalNumU32Info)
3463 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM), Return(SOFTBUS_OK)));
3464 EXPECT_CALL(linkMock, LnnGetRemoteNumU32Info)
3465 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM), Return(SOFTBUS_OK)));
3466 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
3467 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(0), Return(SOFTBUS_OK)));
3468 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
3469 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(0), Return(SOFTBUS_OK)));
3470 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3471 EXPECT_EQ(ret, SOFTBUS_LANE_LOCAL_NO_WIFI_DIRECT_CAP);
3472
3473 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
3474 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(ROM_NUM2), Return(SOFTBUS_OK)));
3475 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
3476 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(ROM_NUM2), Return(SOFTBUS_OK)));
3477 ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3478 EXPECT_EQ(ret, SOFTBUS_OK);
3479 }
3480
3481 /*
3482 * @tc.name: LNN_LANE_23
3483 * @tc.desc: SelectLaneRule
3484 * @tc.type: FUNC
3485 * @tc.require:
3486 */
3487 HWTEST_F(LNNLaneMockTest, LNN_LANE_23, TestSize.Level1)
3488 {
3489 NiceMock<LaneDepsInterfaceMock> mock;
3490 LanePreferredLinkList linkList = {};
3491 uint32_t listNum = 0;
3492 LaneSelectParam selectParam = {};
3493 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
3494 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, &listNum);
3495 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
3496
3497 ret = SelectLane(nullptr, &selectParam, &linkList, &listNum);
3498 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3499 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &linkList, nullptr);
3500 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3501 }
3502
3503 /*
3504 * @tc.name: LNN_LANE_24
3505 * @tc.desc: SelectLaneRule
3506 * @tc.type: FUNC
3507 * @tc.require:
3508 */
3509 HWTEST_F(LNNLaneMockTest, LNN_LANE_24, TestSize.Level1)
3510 {
3511 LanePreferredLinkList recommendList = {};
3512 LaneSelectParam selectParam = {};
3513 int32_t ret = SelectExpectLanesByQos(nullptr, &selectParam, &recommendList);
3514 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3515 ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &selectParam, nullptr);
3516 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3517 }
3518
3519 /*
3520 * @tc.name: LNN_LANE_25
3521 * @tc.desc: SelectLaneRule
3522 * @tc.type: FUNC
3523 * @tc.require:
3524 */
3525 HWTEST_F(LNNLaneMockTest, LNN_LANE_25, TestSize.Level1)
3526 {
3527 LaneLinkType linkType = LANE_ETH;
3528 int32_t ret = LaneCapCheck(NODE_NETWORK_ID, linkType);
3529 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
3530 }
3531 } // namespace OHOS
3532