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 PEER_UDID[] = "111122223333abcdef";
51 constexpr uint64_t LANE_ID_BASE = 1122334455667788;
52 constexpr uint32_t DEFAULT_QOSINFO_MIN_BW = 10;
53 constexpr uint32_t DEFAULT_QOSINFO_MAX_LATENCY = 10000;
54 constexpr uint32_t DEFAULT_QOSINFO_MIN_LATENCY = 2500;
55 constexpr uint32_t DEFAULT_LANE_RESOURCE_LANE_REF = 0;
56 constexpr uint32_t LOW_BW = 384 * 1024;
57 constexpr uint32_t MID_BW = 30 * 1024 * 1024;
58 constexpr uint32_t HIGH_BW = 160 * 1024 * 1024;
59 constexpr uint32_t PORT_A = 22;
60 constexpr uint32_t PORT_B = 25;
61 constexpr uint32_t FD = 888;
62 constexpr uint32_t SLEEP_FOR_LOOP_COMPLETION_MS = 50;
63 constexpr uint32_t NET_CAP = 63;
64
65 static SoftBusCond g_cond = {0};
66 static SoftBusMutex g_lock = {0};
67 static int32_t g_errCode = 0;
68 static bool g_isNeedCondWait = true;
69
70 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info);
71 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode);
72 static void OnLaneFreeSuccess(uint32_t laneHandle);
73 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode);
74
75 static LaneAllocListener g_listener = {
76 .onLaneAllocSuccess = OnLaneAllocSuccess,
77 .onLaneAllocFail = OnLaneAllocFail,
78 .onLaneFreeSuccess = OnLaneFreeSuccess,
79 .onLaneFreeFail = OnLaneFreeFail,
80 };
81
OnLaneRequestSuccess(uint32_t laneId,const LaneConnInfo * info)82 static void OnLaneRequestSuccess(uint32_t laneId, const LaneConnInfo *info)
83 {
84 GTEST_LOG_(INFO) << "OnLaneRequestSuccess";
85 }
86
OnLaneRequestFail(uint32_t laneId,int32_t reason)87 static void OnLaneRequestFail(uint32_t laneId, int32_t reason)
88 {
89 GTEST_LOG_(INFO) << "OnLaneRequestFail";
90 }
91
92 static ILaneListener g_listener2 = {
93 .onLaneRequestSuccess = OnLaneRequestSuccess,
94 .onLaneRequestFail = OnLaneRequestFail,
95 };
96
97 static NodeInfo g_NodeInfo = {
98 .p2pInfo.p2pRole = 1,
99 .p2pInfo.p2pMac = "abc",
100 .p2pInfo.goMac = "abc",
101 };
102
103 class LNNLaneMockTest : public testing::Test {
104 public:
105 static void SetUpTestCase();
106 static void TearDownTestCase();
107 void SetUp();
108 void TearDown();
109 };
110
SetUpTestCase()111 void LNNLaneMockTest::SetUpTestCase()
112 {
113 (void)SoftBusMutexInit(&g_lock, nullptr);
114 (void)SoftBusCondInit(&g_cond);
115 int32_t ret = LnnInitLnnLooper();
116 EXPECT_TRUE(ret == SOFTBUS_OK);
117 ret = LooperInit();
118 NiceMock<LaneDepsInterfaceMock> mock;
119 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(LaneDepsInterfaceMock::ActionOfStartBaseClient);
120 ret = InitLane();
121 EXPECT_TRUE(ret == SOFTBUS_OK);
122 GTEST_LOG_(INFO) << "LNNLaneMockTest start";
123 }
124
TearDownTestCase()125 void LNNLaneMockTest::TearDownTestCase()
126 {
127 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
128 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
129 DeinitLane();
130 LooperDeinit();
131 LnnDeinitLnnLooper();
132 (void)SoftBusCondDestroy(&g_cond);
133 (void)SoftBusMutexDestroy(&g_lock);
134 GTEST_LOG_(INFO) << "LNNLaneMockTest end";
135 }
136
SetUp()137 void LNNLaneMockTest::SetUp()
138 {
139 }
140
TearDown()141 void LNNLaneMockTest::TearDown()
142 {
143 }
144
CondSignal(void)145 static void CondSignal(void)
146 {
147 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
148 GTEST_LOG_(INFO) << "CondSignal SoftBusMutexLock failed";
149 return;
150 }
151 if (SoftBusCondSignal(&g_cond) != SOFTBUS_OK) {
152 GTEST_LOG_(INFO) << "CondSignal SoftBusCondSignal failed";
153 (void)SoftBusMutexUnlock(&g_lock);
154 return;
155 }
156 g_isNeedCondWait = false;
157 (void)SoftBusMutexUnlock(&g_lock);
158 }
159
ComputeWaitForceDownTime(uint32_t waitMillis,SoftBusSysTime * outtime)160 static void ComputeWaitForceDownTime(uint32_t waitMillis, SoftBusSysTime *outtime)
161 {
162 #define USECTONSEC 1000
163 SoftBusSysTime now;
164 (void)SoftBusGetTime(&now);
165 int64_t time = now.sec * USECTONSEC * USECTONSEC + now.usec + (int64_t)waitMillis * USECTONSEC;
166 outtime->sec = time / USECTONSEC / USECTONSEC;
167 outtime->usec = time % (USECTONSEC * USECTONSEC);
168 }
169
CondWait(void)170 static void CondWait(void)
171 {
172 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
173 GTEST_LOG_(INFO) << "CondWait SoftBusMutexLock failed";
174 return;
175 }
176 if (!g_isNeedCondWait) {
177 GTEST_LOG_(INFO) << "Doesn't need CondWait, g_isNeedCondWait = " << g_isNeedCondWait;
178 (void)SoftBusMutexUnlock(&g_lock);
179 return;
180 }
181 SoftBusSysTime waitTime = {0};
182 uint32_t condWaitTimeout = 3000;
183 ComputeWaitForceDownTime(condWaitTimeout, &waitTime);
184 if (SoftBusCondWait(&g_cond, &g_lock, &waitTime) != SOFTBUS_OK) {
185 GTEST_LOG_(INFO) << "CondWait Timeout end";
186 (void)SoftBusMutexUnlock(&g_lock);
187 return;
188 }
189 (void)SoftBusMutexUnlock(&g_lock);
190 }
191
SetIsNeedCondWait(void)192 static void SetIsNeedCondWait(void)
193 {
194 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
195 GTEST_LOG_(INFO) << "SetIsNeedCondWait SoftBusMutexLock failed";
196 return;
197 }
198 g_isNeedCondWait = true;
199 (void)SoftBusMutexUnlock(&g_lock);
200 }
201
OnLaneAllocSuccess(uint32_t laneHandle,const LaneConnInfo * info)202 static void OnLaneAllocSuccess(uint32_t laneHandle, const LaneConnInfo *info)
203 {
204 ASSERT_NE(info, nullptr) << "invalid info";
205 GTEST_LOG_(INFO) << "alloc lane successful, laneReqId=" << laneHandle << ", linkType=" << info->type;
206 const LnnLaneManager *laneManager = GetLaneManager();
207 int32_t ret = laneManager->lnnFreeLane(laneHandle);
208 EXPECT_TRUE(ret == SOFTBUS_OK);
209 CondSignal();
210 }
211
OnLaneAllocFail(uint32_t laneHandle,int32_t errCode)212 static void OnLaneAllocFail(uint32_t laneHandle, int32_t errCode)
213 {
214 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
215 EXPECT_NE(errCode, SOFTBUS_OK);
216 g_errCode = errCode;
217 const LnnLaneManager *laneManager = GetLaneManager();
218 int32_t ret = laneManager->lnnFreeLane(laneHandle);
219 EXPECT_TRUE(ret == SOFTBUS_OK);
220 CondSignal();
221 }
222
OnLaneFreeSuccess(uint32_t laneHandle)223 static void OnLaneFreeSuccess(uint32_t laneHandle)
224 {
225 GTEST_LOG_(INFO) << "free lane success, laneReqId=" << laneHandle;
226 CondSignal();
227 }
228
OnLaneFreeFail(uint32_t laneHandle,int32_t errCode)229 static void OnLaneFreeFail(uint32_t laneHandle, int32_t errCode)
230 {
231 GTEST_LOG_(INFO) << "free lane failed, laneReqId=" << laneHandle << ", errCode=" << errCode;
232 CondSignal();
233 }
234
OnLaneLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)235 static void OnLaneLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
236 {
237 (void)reqId;
238 (void)reason;
239 (void)linkType;
240 return;
241 }
242
OnLaneLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)243 static void OnLaneLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
244 {
245 (void)reqId;
246 (void)linkType;
247 (void)linkInfo;
248 return;
249 }
250
OnLaneLinkSuccessForDetect(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)251 static void OnLaneLinkSuccessForDetect(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
252 {
253 (void)reqId;
254 (void)linkInfo;
255 GTEST_LOG_(INFO) << "on laneLink success for detect";
256 EXPECT_EQ(linkType, LANE_WLAN_5G);
257 }
258
OnLaneLinkFailForDetect(uint32_t reqId,int32_t reason,LaneLinkType linkType)259 static void OnLaneLinkFailForDetect(uint32_t reqId, int32_t reason, LaneLinkType linkType)
260 {
261 (void)reqId;
262 (void)linkType;
263 GTEST_LOG_(INFO) << "on laneLink fail for detect";
264 EXPECT_EQ(reason, SOFTBUS_LANE_DETECT_TIMEOUT);
265 CondSignal();
266 }
267
OnLaneAllocSuccessForHml(uint32_t laneHandle,const LaneConnInfo * info)268 static void OnLaneAllocSuccessForHml(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_HML);
274 CondSignal();
275 }
276
OnLaneAllocSuccessForP2p(uint32_t laneHandle,const LaneConnInfo * info)277 static void OnLaneAllocSuccessForP2p(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_P2P);
283 CondSignal();
284 }
285
OnLaneAllocSuccessForBr(uint32_t laneHandle,const LaneConnInfo * info)286 static void OnLaneAllocSuccessForBr(uint32_t laneHandle, const LaneConnInfo *info)
287 {
288 (void)laneHandle;
289 ASSERT_NE(info, nullptr) << "invalid connInfo";
290 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
291 EXPECT_EQ(info->type, LANE_BR);
292 CondSignal();
293 }
294
OnLaneAllocSuccessForWlan5g(uint32_t laneHandle,const LaneConnInfo * info)295 static void OnLaneAllocSuccessForWlan5g(uint32_t laneHandle, const LaneConnInfo *info)
296 {
297 (void)laneHandle;
298 ASSERT_NE(info, nullptr) << "invalid connInfo";
299 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
300 EXPECT_EQ(info->type, LANE_WLAN_5G);
301 CondSignal();
302 }
303
OnLaneAllocSuccessForBle(uint32_t laneHandle,const LaneConnInfo * info)304 static void OnLaneAllocSuccessForBle(uint32_t laneHandle, const LaneConnInfo *info)
305 {
306 (void)laneHandle;
307 ASSERT_NE(info, nullptr) << "invalid connInfo";
308 GTEST_LOG_(INFO) << "alloc lane successful, linkType=" << info->type;
309 EXPECT_EQ(info->type, LANE_BLE);
310 CondSignal();
311 }
312
OnLaneAllocFailNoExcept(uint32_t laneHandle,int32_t errCode)313 static void OnLaneAllocFailNoExcept(uint32_t laneHandle, int32_t errCode)
314 {
315 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle;
316 EXPECT_EQ(errCode, SOFTBUS_LANE_SUCC_AFTER_CANCELED);
317 CondSignal();
318 }
319
OnLaneAllocFailNoExcept2(uint32_t laneHandle,int32_t errCode)320 static void OnLaneAllocFailNoExcept2(uint32_t laneHandle, int32_t errCode)
321 {
322 GTEST_LOG_(INFO) << "alloc lane failed, laneReqId=" << laneHandle;
323 EXPECT_EQ(errCode, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
324 CondSignal();
325 }
326
327 static LaneAllocListener g_listenerCbForHml = {
328 .onLaneAllocSuccess = OnLaneAllocSuccessForHml,
329 .onLaneAllocFail = OnLaneAllocFailNoExcept,
330 .onLaneFreeSuccess = OnLaneFreeSuccess,
331 .onLaneFreeFail = OnLaneFreeFail,
332 };
333
334 static LaneAllocListener g_listenerCbForP2p = {
335 .onLaneAllocSuccess = OnLaneAllocSuccessForP2p,
336 .onLaneAllocFail = OnLaneAllocFailNoExcept,
337 .onLaneFreeSuccess = OnLaneFreeSuccess,
338 .onLaneFreeFail = OnLaneFreeFail,
339 };
340
341 static LaneAllocListener g_listenerCbForBr2 = {
342 .onLaneAllocSuccess = OnLaneAllocSuccessForBr,
343 .onLaneAllocFail = OnLaneAllocFailNoExcept2,
344 .onLaneFreeSuccess = OnLaneFreeSuccess,
345 .onLaneFreeFail = OnLaneFreeFail,
346 };
347
348 static LaneAllocListener g_listenerCbForBr = {
349 .onLaneAllocSuccess = OnLaneAllocSuccessForBr,
350 .onLaneAllocFail = OnLaneAllocFailNoExcept,
351 .onLaneFreeSuccess = OnLaneFreeSuccess,
352 .onLaneFreeFail = OnLaneFreeFail,
353 };
354
355 static LaneAllocListener g_listenerCbForWlan5g = {
356 .onLaneAllocSuccess = OnLaneAllocSuccessForWlan5g,
357 .onLaneAllocFail = OnLaneAllocFailNoExcept,
358 .onLaneFreeSuccess = OnLaneFreeSuccess,
359 .onLaneFreeFail = OnLaneFreeFail,
360 };
361
362 static LaneAllocListener g_listenerCbForBle = {
363 .onLaneAllocSuccess = OnLaneAllocSuccessForBle,
364 .onLaneAllocFail = OnLaneAllocFailNoExcept,
365 .onLaneFreeSuccess = OnLaneFreeSuccess,
366 .onLaneFreeFail = OnLaneFreeFail,
367 };
368
AddLaneResourceForAllocTest(LaneLinkType linkType)369 static int32_t AddLaneResourceForAllocTest(LaneLinkType linkType)
370 {
371 LaneLinkInfo linkInfo = {};
372 linkInfo.type = linkType;
373 if (strncpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML, strlen(PEER_IP_HML)) != EOK) {
374 return SOFTBUS_STRCPY_ERR;
375 }
376 if (strncpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID, strlen(PEER_UDID)) != EOK) {
377 return SOFTBUS_STRCPY_ERR;
378 }
379 return AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
380 }
381
CreateAllocInfoForAllocTest(LaneTransType transType,uint32_t minBW,uint32_t maxLaneLatency,uint32_t minLaneLatency,LaneAllocInfo * allocInfo)382 static void CreateAllocInfoForAllocTest(LaneTransType transType, uint32_t minBW, uint32_t maxLaneLatency,
383 uint32_t minLaneLatency, LaneAllocInfo *allocInfo)
384 {
385 ASSERT_NE(allocInfo, nullptr) << "invalid allocInfo";
386 allocInfo->type = LANE_TYPE_TRANS;
387 ASSERT_EQ(strncpy_s(allocInfo->networkId, NETWORK_ID_BUF_LEN,
388 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
389 allocInfo->transType = transType;
390 allocInfo->qosRequire.minBW = minBW;
391 allocInfo->qosRequire.maxLaneLatency = maxLaneLatency;
392 allocInfo->qosRequire.minLaneLatency = minLaneLatency;
393 }
394
PrejudgeAvailability(const char * remoteNetworkId,enum WifiDirectLinkType connectType)395 static int32_t PrejudgeAvailability(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
396 {
397 (void)remoteNetworkId;
398 (void)connectType;
399 GTEST_LOG_(INFO) << "PrejudgeAvailability Enter";
400 return SOFTBUS_OK;
401 }
402
GetLocalAndRemoteMacByLocalIp(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)403 static int32_t GetLocalAndRemoteMacByLocalIp(const char *localIp, char *localMac, size_t localMacSize,
404 char *remoteMac, size_t remoteMacSize)
405 {
406 (void)localIp;
407 (void)localMac;
408 (void)localMacSize;
409 (void)remoteMac;
410 (void)remoteMacSize;
411 return SOFTBUS_OK;
412 }
413
414 static struct WifiDirectManager g_manager = {
415 .prejudgeAvailability = PrejudgeAvailability,
416 .getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIp,
417 };
418 /*
419 * @tc.name: LANE_ALLOC_ErrTest_001
420 * @tc.desc: lane errcode test
421 * @tc.type: FUNC
422 * @tc.require:
423 */
424 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_ERRTEST_001, TestSize.Level1)
425 {
426 const LnnLaneManager *laneManager = GetLaneManager();
427 LaneType laneType = LANE_TYPE_TRANS;
428 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
429 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
430
431 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
432 wifiMock.SetDefaultResult();
433 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
434 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfOnConnectP2pFail);
435 NiceMock<LaneDepsInterfaceMock> mock;
436 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
437 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
438 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_CONN_FAIL));
439 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
440
441 LaneAllocInfo allocInfo = {};
442 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
443 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
444 SetIsNeedCondWait();
445 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listener);
446 EXPECT_EQ(ret, SOFTBUS_OK);
447 CondWait();
448 EXPECT_EQ(g_errCode, ERROR_WIFI_OFF);
449
450 (void)laneManager->lnnFreeLane(laneReqId);
451 }
452
453 /*
454 * @tc.name: LANE_ALLOC_Test_001
455 * @tc.desc: lane alloc by select default link for T_MSG (build wlan5g)
456 * @tc.type: FUNC
457 * @tc.require:
458 */
459 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_001, TestSize.Level1)
460 {
461 const LnnLaneManager *laneManager = GetLaneManager();
462 LaneType laneType = LANE_TYPE_TRANS;
463 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
464 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
465
466 NiceMock<LaneDepsInterfaceMock> mock;
467 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
468 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
469 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
470 char buf[] = "lanedetect";
471 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
472 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
473 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
474 wifiMock.SetDefaultResult();
475 SoftBusWifiLinkedInfo wlanInfo;
476 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
477 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
478 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
479
480 LaneAllocInfo allocInfo = {};
481 CreateAllocInfoForAllocTest(LANE_T_MSG, 0, 0, 0, &allocInfo);
482 SetIsNeedCondWait();
483 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
484 EXPECT_EQ(ret, SOFTBUS_OK);
485 CondWait();
486 SetIsNeedCondWait();
487 ret = laneManager->lnnFreeLane(laneReqId);
488 EXPECT_EQ(ret, SOFTBUS_OK);
489 CondWait();
490 }
491
492 /*
493 * @tc.name: LANE_ALLOC_Test_002
494 * @tc.desc: lane alloc by select default link for T_BYTE (not enable wlan and br, build ble)
495 * @tc.type: FUNC
496 * @tc.require:
497 */
498 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_002, TestSize.Level1)
499 {
500 const LnnLaneManager *laneManager = GetLaneManager();
501 LaneType laneType = LANE_TYPE_TRANS;
502 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
503 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
504
505 NiceMock<LaneDepsInterfaceMock> mock;
506 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
507 mock.SetDefaultResultForAlloc(1 << BIT_BLE, 1 << BIT_BLE, 0, 0);
508 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
509 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
510 wifiMock.SetDefaultResult();
511 LaneAllocInfo allocInfo = {};
512 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
513 PEER_MAC, strlen(PEER_MAC)), EOK);
514 CreateAllocInfoForAllocTest(LANE_T_BYTE, 0, 0, 0, &allocInfo);
515 SetIsNeedCondWait();
516 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBle);
517 EXPECT_EQ(ret, SOFTBUS_OK);
518 CondWait();
519 SetIsNeedCondWait();
520 ret = laneManager->lnnFreeLane(laneReqId);
521 EXPECT_EQ(ret, SOFTBUS_OK);
522 CondWait();
523 }
524
525 /*
526 * @tc.name: LANE_ALLOC_Test_003
527 * @tc.desc: lane alloc by select default link for T_FILE (not enable wlan and hml, build p2p)
528 * @tc.type: FUNC
529 * @tc.require:
530 */
531 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_003, TestSize.Level1)
532 {
533 const LnnLaneManager *laneManager = GetLaneManager();
534 LaneType laneType = LANE_TYPE_TRANS;
535 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
536 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
537
538 NiceMock<LaneDepsInterfaceMock> mock;
539 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
540 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
541 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
542 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_ACTIVED));
543 wifiMock.SetDefaultResult();
544 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
545 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
546
547 LaneAllocInfo allocInfo = {};
548 CreateAllocInfoForAllocTest(LANE_T_FILE, 0, 0, 0, &allocInfo);
549 SetIsNeedCondWait();
550 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
551 EXPECT_EQ(ret, SOFTBUS_OK);
552 CondWait();
553 SetIsNeedCondWait();
554 ret = laneManager->lnnFreeLane(laneReqId);
555 EXPECT_EQ(ret, SOFTBUS_OK);
556 CondWait();
557 }
558
559 /*
560 * @tc.name: LANE_ALLOC_Test_004
561 * @tc.desc: lane alloc by select default link for T_RAW_STREAM (not enable wlan, build p2p)
562 * @tc.type: FUNC
563 * @tc.require:
564 */
565 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_004, TestSize.Level1)
566 {
567 const LnnLaneManager *laneManager = GetLaneManager();
568 LaneType laneType = LANE_TYPE_TRANS;
569 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
570 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
571
572 NiceMock<LaneDepsInterfaceMock> mock;
573 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
574 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
575 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
576 wifiMock.SetDefaultResult();
577 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
578 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
579
580 LaneAllocInfo allocInfo = {};
581 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, 0, 0, 0, &allocInfo);
582 SetIsNeedCondWait();
583 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
584 EXPECT_EQ(ret, SOFTBUS_OK);
585 CondWait();
586 SetIsNeedCondWait();
587 ret = laneManager->lnnFreeLane(laneReqId);
588 EXPECT_EQ(ret, SOFTBUS_OK);
589 CondWait();
590 }
591
592 /*
593 * @tc.name: LANE_ALLOC_Test_005
594 * @tc.desc: lane alloc by mesh link (not enable wlan, build br)
595 * @tc.type: FUNC
596 * @tc.require:
597 */
598 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_005, TestSize.Level1)
599 {
600 const LnnLaneManager *laneManager = GetLaneManager();
601 LaneType laneType = LANE_TYPE_TRANS;
602 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
603 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
604
605 NiceMock<LaneDepsInterfaceMock> mock;
606 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
607 mock.SetDefaultResultForAlloc(1 << BIT_BR, 1 << BIT_BR, 0, 0);
608 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
609 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
610 wifiMock.SetDefaultResult();
611
612 LaneAllocInfo allocInfo = {};
613 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, MESH_MAGIC_NUMBER, 0, 0, &allocInfo);
614 SetIsNeedCondWait();
615 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
616 EXPECT_EQ(ret, SOFTBUS_OK);
617 CondWait();
618 SetIsNeedCondWait();
619 ret = laneManager->lnnFreeLane(laneReqId);
620 EXPECT_EQ(ret, SOFTBUS_OK);
621 CondWait();
622 }
623
624 /*
625 * @tc.name: LANE_ALLOC_Test_006
626 * @tc.desc: lane alloc by RTT link (not enable hml, build p2p)
627 * @tc.type: FUNC
628 * @tc.require:
629 */
630 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_006, TestSize.Level1)
631 {
632 const LnnLaneManager *laneManager = GetLaneManager();
633 LaneType laneType = LANE_TYPE_TRANS;
634 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
635 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
636
637 NiceMock<LaneDepsInterfaceMock> mock;
638 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
639 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 0, 0);
640 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
641 wifiMock.SetDefaultResult();
642 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
643 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
644
645 LaneAllocInfo allocInfo = {};
646 allocInfo.qosRequire.rttLevel = LANE_RTT_LEVEL_LOW;
647 CreateAllocInfoForAllocTest(LANE_T_RAW_STREAM, DEFAULT_QOSINFO_MIN_BW, 0, 0, &allocInfo);
648 SetIsNeedCondWait();
649 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
650 EXPECT_EQ(ret, SOFTBUS_OK);
651 CondWait();
652 SetIsNeedCondWait();
653 ret = laneManager->lnnFreeLane(laneReqId);
654 EXPECT_EQ(ret, SOFTBUS_OK);
655 CondWait();
656 }
657
658 /*
659 * @tc.name: LANE_ALLOC_Test_007
660 * @tc.desc: lane alloc by qos require (HIGH_BW, build hml)
661 * @tc.type: FUNC
662 * @tc.require:
663 */
664 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_007, TestSize.Level1)
665 {
666 const LnnLaneManager *laneManager = GetLaneManager();
667 LaneType laneType = LANE_TYPE_TRANS;
668 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
669 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
670
671 NiceMock<LaneDepsInterfaceMock> mock;
672 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
673 mock.SetDefaultResultForAlloc(NET_CAP, NET_CAP, 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY,
674 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY);
675 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
676 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
677 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_ACTIVED));
678 wifiMock.SetDefaultResult();
679 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
680 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
681
682 LaneAllocInfo allocInfo = {};
683 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
684 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
685 SetIsNeedCondWait();
686 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForHml);
687 EXPECT_EQ(ret, SOFTBUS_OK);
688 CondWait();
689 SetIsNeedCondWait();
690 ret = laneManager->lnnFreeLane(laneReqId);
691 EXPECT_EQ(ret, SOFTBUS_OK);
692 CondWait();
693 }
694
695 /*
696 * @tc.name: LANE_ALLOC_Test_008
697 * @tc.desc: lane alloc by qos require (MID_HIGH_BW, not enable hml, build wlan5g)
698 * @tc.type: FUNC
699 * @tc.require:
700 */
701 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_008, TestSize.Level1)
702 {
703 const LnnLaneManager *laneManager = GetLaneManager();
704 LaneType laneType = LANE_TYPE_TRANS;
705 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
706 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
707
708 NiceMock<LaneDepsInterfaceMock> mock;
709 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
710 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
711 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
712 char buf[] = "lanedetect";
713 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
714 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
715 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
716 wifiMock.SetDefaultResult();
717 SoftBusWifiLinkedInfo wlanInfo;
718 wlanInfo.band = 0;
719 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
720 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
721 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
722
723 LaneAllocInfo allocInfo = {};
724 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + MID_BW, DEFAULT_QOSINFO_MAX_LATENCY,
725 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
726 SetIsNeedCondWait();
727 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
728 EXPECT_EQ(ret, SOFTBUS_OK);
729 CondWait();
730 SetIsNeedCondWait();
731 ret = laneManager->lnnFreeLane(laneReqId);
732 EXPECT_EQ(ret, SOFTBUS_OK);
733 CondWait();
734 }
735
736 /*
737 * @tc.name: LANE_ALLOC_Test_009
738 * @tc.desc: lane alloc by qos require (MID_LOW_BW, not enable wlan5g and hml, build wlan24g)
739 * @tc.type: FUNC
740 * @tc.require:
741 */
742 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_009, TestSize.Level1)
743 {
744 const LnnLaneManager *laneManager = GetLaneManager();
745 LaneType laneType = LANE_TYPE_TRANS;
746 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
747 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
748
749 NiceMock<LaneDepsInterfaceMock> mock;
750 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
751 mock.SetDefaultResultForAlloc(1 << BIT_WIFI_5G, 1 << BIT_WIFI_5G, 0, 0);
752 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
753 char buf[] = "lanedetect";
754 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
755 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
756 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
757 wifiMock.SetDefaultResult();
758 SoftBusWifiLinkedInfo wlanInfo;
759 wlanInfo.band = 1;
760 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
761 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
762 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
763
764 LaneAllocInfo allocInfo = {};
765 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
766 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
767 SetIsNeedCondWait();
768 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForWlan5g);
769 EXPECT_EQ(ret, SOFTBUS_OK);
770 CondWait();
771 SetIsNeedCondWait();
772 ret = laneManager->lnnFreeLane(laneReqId);
773 EXPECT_EQ(ret, SOFTBUS_OK);
774 CondWait();
775 }
776
777 /*
778 * @tc.name: LANE_ALLOC_Test_010
779 * @tc.desc: lane alloc by qos require (LOW_BW, not enable wlan5g\hml\br\p2p\coc_direct, build ble)
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_010, TestSize.Level1)
784 {
785 const LnnLaneManager *laneManager = GetLaneManager();
786 LaneType laneType = LANE_TYPE_TRANS;
787 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
788 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
789
790 NiceMock<LaneDepsInterfaceMock> mock;
791 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
792 mock.SetDefaultResultForAlloc(1 << BIT_BLE, 1 << BIT_BLE, 0, 0);
793 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
794 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
795 wifiMock.SetDefaultResult();
796
797 LaneAllocInfo allocInfo = {};
798 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
799 PEER_MAC, strlen(PEER_MAC)), EOK);
800 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
801 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
802 SetIsNeedCondWait();
803 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBle);
804 EXPECT_EQ(ret, SOFTBUS_OK);
805 CondWait();
806 SetIsNeedCondWait();
807 ret = laneManager->lnnFreeLane(laneReqId);
808 EXPECT_EQ(ret, SOFTBUS_OK);
809 CondWait();
810 }
811
812 /*
813 * @tc.name: LANE_ALLOC_Test_011
814 * @tc.desc: lane alloc for exception deal before select link
815 * @tc.type: FAILUE
816 * @tc.require:
817 */
818 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_011, TestSize.Level1)
819 {
820 const LnnLaneManager *laneManager = GetLaneManager();
821 LaneType laneType = LANE_TYPE_TRANS;
822 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
823 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
824
825 NiceMock<LaneDepsInterfaceMock> mock;
826 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
827
828 LaneAllocInfo allocInfo = {};
829 int32_t ret = laneManager->lnnAllocLane(laneReqId, nullptr, &g_listenerCbForP2p);
830 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
831
832 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, nullptr);
833 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
834
835 allocInfo.type = LANE_TYPE_BUTT;
836 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
837 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
838
839 allocInfo.type = (LaneType)-1;
840 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
841 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
842
843 ret = laneManager->lnnAllocLane(INVALID_LANE_REQ_ID, &allocInfo, &g_listenerCbForP2p);
844 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
845
846 allocInfo.type = LANE_TYPE_HDLC;
847 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
848 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
849
850 allocInfo.type = laneType;
851 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
852 EXPECT_EQ(ret, SOFTBUS_NETWORK_NODE_OFFLINE);
853
854 ret = laneManager->lnnFreeLane(laneReqId);
855 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
856 }
857
858 /*
859 * @tc.name: LANE_ALLOC_Test_012
860 * @tc.desc: lane alloc for continuous task(local is watch)
861 * @tc.type: FUNC
862 * @tc.require:
863 */
864 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_012, TestSize.Level1)
865 {
866 const LnnLaneManager *laneManager = GetLaneManager();
867 LaneType laneType = LANE_TYPE_TRANS;
868 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
869 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
870
871 NiceMock<LaneDepsInterfaceMock> mock;
872 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
873 mock.SetDefaultResultForAlloc(11, 11, 0x2400, 0x2400);
874 EXPECT_CALL(mock, LnnGetLocalNumInfo)
875 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(TYPE_WATCH_ID), Return(SOFTBUS_OK)))
876 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
877 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
878 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
879 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
880 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
881 wifiMock.SetDefaultResult();
882
883 LaneAllocInfo allocInfo = {};
884 CreateAllocInfoForAllocTest(LANE_T_BYTE, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
885 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
886 allocInfo.qosRequire.continuousTask = true;
887 SetIsNeedCondWait();
888 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
889 EXPECT_EQ(ret, SOFTBUS_OK);
890 CondWait();
891 SetIsNeedCondWait();
892 ret = laneManager->lnnFreeLane(laneReqId);
893 EXPECT_EQ(ret, SOFTBUS_OK);
894 CondWait();
895 }
896
897 /*
898 * @tc.name: LANE_ALLOC_Test_013
899 * @tc.desc: lane alloc for continuous task(remote is watch)
900 * @tc.type: FUNC
901 * @tc.require:
902 */
903 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_013, TestSize.Level1)
904 {
905 const LnnLaneManager *laneManager = GetLaneManager();
906 LaneType laneType = LANE_TYPE_TRANS;
907 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
908 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
909
910 NiceMock<LaneDepsInterfaceMock> mock;
911 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
912 mock.SetDefaultResultForAlloc(11, 11, 0x2400, 0x2400);
913 EXPECT_CALL(mock, LnnGetLocalNumInfo)
914 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(TYPE_PHONE_ID), Return(SOFTBUS_OK)))
915 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
916 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
917 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(TYPE_WATCH_ID), Return(SOFTBUS_OK)))
918 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
919 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
920 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
921 wifiMock.SetDefaultResult();
922
923 LaneAllocInfo allocInfo = {};
924 CreateAllocInfoForAllocTest(LANE_T_BYTE, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
925 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
926 allocInfo.qosRequire.continuousTask = true;
927 SetIsNeedCondWait();
928 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
929 EXPECT_EQ(ret, SOFTBUS_OK);
930 CondWait();
931 SetIsNeedCondWait();
932 ret = laneManager->lnnFreeLane(laneReqId);
933 EXPECT_EQ(ret, SOFTBUS_OK);
934 CondWait();
935 }
936
937 /*
938 * @tc.name: LANE_ALLOC_Test_014
939 * @tc.desc: lane alloc for MIDDLE_LOW_BW¬ continuous task(local is watch)
940 * @tc.type: FUNC
941 * @tc.require:
942 */
943 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_014, TestSize.Level1)
944 {
945 const LnnLaneManager *laneManager = GetLaneManager();
946 LaneType laneType = LANE_TYPE_TRANS;
947 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
948 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
949
950 NiceMock<LaneDepsInterfaceMock> mock;
951 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
952 mock.SetDefaultResultForAlloc(15, 15, 0x3137A, 0x3FFEA);
953 EXPECT_CALL(mock, LnnGetLocalNumInfo)
954 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(TYPE_WATCH_ID), Return(SOFTBUS_OK)))
955 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
956 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
957 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
958 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
959 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
960 wifiMock.SetDefaultResult();
961 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
962 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
963
964 LaneAllocInfo allocInfo = {};
965 CreateAllocInfoForAllocTest(LANE_T_BYTE, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
966 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
967 SetIsNeedCondWait();
968 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
969 EXPECT_EQ(ret, SOFTBUS_OK);
970 CondWait();
971 SetIsNeedCondWait();
972 ret = laneManager->lnnFreeLane(laneReqId);
973 EXPECT_EQ(ret, SOFTBUS_OK);
974 CondWait();
975 }
976
977 /*
978 * @tc.name: LANE_ALLOC_Test_015
979 * @tc.desc: lane alloc for MIDDLE_HIGH_BW¬ continuous task(remote is watch)
980 * @tc.type: FUNC
981 * @tc.require:
982 */
983 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_015, TestSize.Level1)
984 {
985 const LnnLaneManager *laneManager = GetLaneManager();
986 LaneType laneType = LANE_TYPE_TRANS;
987 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
988 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
989
990 NiceMock<LaneDepsInterfaceMock> mock;
991 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
992 mock.SetDefaultResultForAlloc(15, 15, 0x3FFEA, 0x3137A);
993 EXPECT_CALL(mock, LnnGetLocalNumInfo)
994 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(TYPE_PHONE_ID), Return(SOFTBUS_OK)))
995 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(11), Return(SOFTBUS_OK)));
996 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
997 .WillOnce(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(TYPE_WATCH_ID), Return(SOFTBUS_OK)))
998 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(11), Return(SOFTBUS_OK)));
999 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1000 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1001 wifiMock.SetDefaultResult();
1002 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1003 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1004
1005 LaneAllocInfo allocInfo = {};
1006 CreateAllocInfoForAllocTest(LANE_T_BYTE, HIGH_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1007 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1008 SetIsNeedCondWait();
1009 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1010 EXPECT_EQ(ret, SOFTBUS_OK);
1011 CondWait();
1012 SetIsNeedCondWait();
1013 ret = laneManager->lnnFreeLane(laneReqId);
1014 EXPECT_EQ(ret, SOFTBUS_OK);
1015 CondWait();
1016 }
1017
1018 /*
1019 * @tc.name: LANE_ALLOC_Test_016
1020 * @tc.desc: lane alloc for continuous task(lowBw and remote is hoos, expect link is br)
1021 * @tc.type: FUNC
1022 * @tc.require:
1023 */
1024 HWTEST_F(LNNLaneMockTest, LANE_ALLOC_Test_016, TestSize.Level1)
1025 {
1026 const LnnLaneManager *laneManager = GetLaneManager();
1027 LaneType laneType = LANE_TYPE_TRANS;
1028 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1029 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1030
1031 NiceMock<LaneDepsInterfaceMock> mock;
1032 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1033 mock.SetDefaultResultForAlloc(15, 15, 0x3F7EA, 0x3F7EA);
1034 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1035 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1036 wifiMock.SetDefaultResult();
1037
1038 LaneAllocInfo allocInfo = {};
1039 ASSERT_EQ(strncpy_s(allocInfo.extendInfo.peerBleMac, MAX_MAC_LEN,
1040 PEER_MAC, strlen(PEER_MAC)), EOK);
1041 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1042 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1043 allocInfo.qosRequire.continuousTask = true;
1044 SetIsNeedCondWait();
1045 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForBr);
1046 EXPECT_EQ(ret, SOFTBUS_OK);
1047 CondWait();
1048 SetIsNeedCondWait();
1049 ret = laneManager->lnnFreeLane(laneReqId);
1050 EXPECT_EQ(ret, SOFTBUS_OK);
1051 CondWait();
1052 }
1053
1054 /*
1055 * @tc.name: LANE_RE_ALLOC_Test_001
1056 * @tc.desc: lane re alloc for invalid param
1057 * @tc.type: FUNC
1058 * @tc.require:
1059 */
1060 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_001, TestSize.Level1)
1061 {
1062 const LnnLaneManager *laneManager = GetLaneManager();
1063 LaneType laneType = LANE_TYPE_TRANS;
1064 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1065 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1066
1067 int32_t ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, nullptr, &g_listenerCbForP2p);
1068 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1069
1070 LaneAllocInfo allocInfo;
1071 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1072 allocInfo.type = LANE_TYPE_BUTT;
1073
1074 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, nullptr);
1075 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1076
1077 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
1078 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1079
1080 ret = laneManager->lnnReAllocLane(INVALID_LANE_REQ_ID, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
1081 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1082
1083 ret = laneManager->lnnReAllocLane(laneReqId, INVALID_LANE_ID, &allocInfo, &g_listenerCbForP2p);
1084 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1085
1086 allocInfo.type = LANE_TYPE_HDLC;
1087 ret = laneManager->lnnReAllocLane(laneReqId, INVALID_LANE_ID, &allocInfo, &g_listenerCbForP2p);
1088 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1089 }
1090
1091 /*
1092 * @tc.name: LANE_RE_ALLOC_Test_002
1093 * @tc.desc: lane re alloc for MSG HIGH_BW
1094 * @tc.type: FUNC
1095 * @tc.require:
1096 */
1097 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_002, TestSize.Level1)
1098 {
1099 const LnnLaneManager *laneManager = GetLaneManager();
1100 LaneType laneType = LANE_TYPE_TRANS;
1101 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1102 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1103
1104 NiceMock<LaneDepsInterfaceMock> mock;
1105 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1106 mock.SetDefaultResultForAlloc(63, 63, 8, 8);
1107 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1108 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1109 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
1110 EXPECT_EQ(ret, SOFTBUS_OK);
1111
1112 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1113 wifiMock.SetDefaultResult();
1114 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1115 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1116
1117 LaneAllocInfo allocInfo;
1118 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1119 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1120 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1121 SetIsNeedCondWait();
1122 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForP2p);
1123 EXPECT_EQ(ret, SOFTBUS_OK);
1124 CondWait();
1125 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1126 EXPECT_EQ(ret, SOFTBUS_OK);
1127 SetIsNeedCondWait();
1128 ret = laneManager->lnnFreeLane(laneReqId);
1129 EXPECT_TRUE(ret == SOFTBUS_OK);
1130 CondWait();
1131 }
1132
1133 /*
1134 * @tc.name: LANE_RE_ALLOC_Test_003
1135 * @tc.desc: lane re alloc for MSG MID_HIGH_BW
1136 * @tc.type: FUNC
1137 * @tc.require:
1138 */
1139 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_003, TestSize.Level1)
1140 {
1141 const LnnLaneManager *laneManager = GetLaneManager();
1142 LaneType laneType = LANE_TYPE_TRANS;
1143 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1144 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1145
1146 NiceMock<LaneDepsInterfaceMock> mock;
1147 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1148 mock.SetDefaultResultForAlloc(63, 63, 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY,
1149 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY);
1150 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
1151 char buf[] = "lanedetect";
1152 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
1153 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1154 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1155 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
1156 EXPECT_EQ(ret, SOFTBUS_OK);
1157
1158 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1159 wifiMock.SetDefaultResult();
1160 SoftBusWifiLinkedInfo wlanInfo;
1161 wlanInfo.band = 0;
1162 wlanInfo.connState = SOFTBUS_API_WIFI_CONNECTED;
1163 EXPECT_CALL(wifiMock, SoftBusGetLinkedInfo)
1164 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM1>(wlanInfo), Return(SOFTBUS_OK)));
1165 LaneAllocInfo allocInfo;
1166 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1167 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + MID_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1168 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1169 SetIsNeedCondWait();
1170 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForWlan5g);
1171 EXPECT_EQ(ret, SOFTBUS_OK);
1172 CondWait();
1173 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1174 EXPECT_EQ(ret, SOFTBUS_OK);
1175 SetIsNeedCondWait();
1176 ret = laneManager->lnnFreeLane(laneReqId);
1177 EXPECT_TRUE(ret == SOFTBUS_OK);
1178 CondWait();
1179 }
1180
1181 /*
1182 * @tc.name: LANE_RE_ALLOC_Test_004
1183 * @tc.desc: lane re alloc for MSG MID_LOW_BW
1184 * @tc.type: FUNC
1185 * @tc.require:
1186 */
1187 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_004, TestSize.Level1)
1188 {
1189 const LnnLaneManager *laneManager = GetLaneManager();
1190 LaneType laneType = LANE_TYPE_TRANS;
1191 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1192 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1193
1194 NiceMock<LaneDepsInterfaceMock> mock;
1195 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1196 mock.SetDefaultResultForAlloc(NET_CAP, NET_CAP, 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY,
1197 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY);
1198 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1199 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1200 int32_t ret = AddLaneResourceForAllocTest(LANE_WLAN_5G);
1201 EXPECT_EQ(ret, SOFTBUS_OK);
1202
1203 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1204 EXPECT_CALL(wifiMock, SoftBusGetWifiState).WillRepeatedly(Return(SOFTBUS_WIFI_STATE_ACTIVED));
1205 wifiMock.SetDefaultResult();
1206 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1207 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1208 LaneAllocInfo allocInfo;
1209 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1210 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + LOW_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1211 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1212 SetIsNeedCondWait();
1213 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForHml);
1214 EXPECT_EQ(ret, SOFTBUS_OK);
1215 CondWait();
1216 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1217 EXPECT_EQ(ret, SOFTBUS_OK);
1218 SetIsNeedCondWait();
1219 ret = laneManager->lnnFreeLane(laneReqId);
1220 EXPECT_TRUE(ret == SOFTBUS_OK);
1221 CondWait();
1222 }
1223
1224 /*
1225 * @tc.name: LANE_RE_ALLOC_Test_005
1226 * @tc.desc: lane re alloc for MSG LOW_BW
1227 * @tc.type: FUNC
1228 * @tc.require:
1229 */
1230 HWTEST_F(LNNLaneMockTest, LANE_RE_ALLOC_Test_005, TestSize.Level1)
1231 {
1232 const LnnLaneManager *laneManager = GetLaneManager();
1233 LaneType laneType = LANE_TYPE_TRANS;
1234 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1235 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1236
1237 NiceMock<LaneDepsInterfaceMock> mock;
1238 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1239 mock.SetDefaultResultForAlloc(15, 15, 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY,
1240 1 << BIT_WIFI_DIRECT_ENHANCE_CAPABILITY);
1241 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
1242 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1243 int32_t ret = AddLaneResourceForAllocTest(LANE_HML);
1244 EXPECT_EQ(ret, SOFTBUS_OK);
1245
1246 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1247 wifiMock.SetDefaultResult();
1248 LaneAllocInfo allocInfo;
1249 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1250 CreateAllocInfoForAllocTest(LANE_T_MSG, LOW_BW - DEFAULT_QOSINFO_MIN_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1251 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1252 SetIsNeedCondWait();
1253 ret = laneManager->lnnReAllocLane(laneReqId, LANE_ID_BASE, &allocInfo, &g_listenerCbForBr);
1254 EXPECT_EQ(ret, SOFTBUS_OK);
1255 CondWait();
1256 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
1257 EXPECT_EQ(ret, SOFTBUS_OK);
1258 SetIsNeedCondWait();
1259 ret = laneManager->lnnFreeLane(laneReqId);
1260 EXPECT_TRUE(ret == SOFTBUS_OK);
1261 CondWait();
1262 }
1263
1264 /*
1265 * @tc.name: LANE_CANCEL_Test_001
1266 * @tc.desc: lane cancel after notify
1267 * @tc.type: FUNC
1268 * @tc.require:
1269 */
1270 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_001, TestSize.Level1)
1271 {
1272 const LnnLaneManager *laneManager = GetLaneManager();
1273 LaneType laneType = LANE_TYPE_TRANS;
1274 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1275 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1276
1277 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1278 wifiMock.SetDefaultResult();
1279 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1280 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1281 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1282 NiceMock<LaneDepsInterfaceMock> mock;
1283 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1284 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1285
1286 LaneAllocInfo allocInfo;
1287 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1288 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1289 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1290 SetIsNeedCondWait();
1291 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1292 EXPECT_EQ(ret, SOFTBUS_OK);
1293 CondWait();
1294 ret = laneManager->lnnCancelLane(laneReqId);
1295 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1296 SetIsNeedCondWait();
1297 ret = laneManager->lnnFreeLane(laneReqId);
1298 EXPECT_TRUE(ret == SOFTBUS_OK);
1299 CondWait();
1300 }
1301
1302 /*
1303 * @tc.name: LANE_CANCEL_Test_002
1304 * @tc.desc: lane cancel before notify
1305 * @tc.type: FUNC
1306 * @tc.require:
1307 */
1308 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_002, TestSize.Level1)
1309 {
1310 const LnnLaneManager *laneManager = GetLaneManager();
1311 LaneType laneType = LANE_TYPE_TRANS;
1312 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1313 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1314
1315 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1316 LnnWifiAdpterInterfaceMock::delayNotifyLinkSuccess = true;
1317 wifiMock.SetDefaultResult();
1318 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1319 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1320 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1321 NiceMock<LaneDepsInterfaceMock> mock;
1322 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1323 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1324
1325 LaneAllocInfo allocInfo;
1326 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1327 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1328 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1329 SetIsNeedCondWait();
1330 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1331 EXPECT_EQ(ret, SOFTBUS_OK);
1332 ret = laneManager->lnnCancelLane(laneReqId);
1333 EXPECT_EQ(ret, SOFTBUS_OK);
1334 CondWait();
1335 LnnWifiAdpterInterfaceMock::delayNotifyLinkSuccess = false;
1336 std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_FOR_LOOP_COMPLETION_MS));
1337 }
1338
1339 /*
1340 * @tc.name: LANE_CANCEL_Test_003
1341 * @tc.desc: lane cancel after free
1342 * @tc.type: FUNC
1343 * @tc.require:
1344 */
1345 HWTEST_F(LNNLaneMockTest, LANE_CANCEL_Test_003, TestSize.Level1)
1346 {
1347 const LnnLaneManager *laneManager = GetLaneManager();
1348 LaneType laneType = LANE_TYPE_TRANS;
1349 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1350 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1351
1352 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1353 wifiMock.SetDefaultResult();
1354 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
1355 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
1356 EXPECT_CALL(wifiMock, LnnCancelWifiDirect).WillRepeatedly(Return());
1357 NiceMock<LaneDepsInterfaceMock> mock;
1358 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
1359 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
1360
1361 LaneAllocInfo allocInfo;
1362 ASSERT_EQ(memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo)), EOK);
1363 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
1364 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
1365 SetIsNeedCondWait();
1366 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listenerCbForP2p);
1367 EXPECT_EQ(ret, SOFTBUS_OK);
1368 CondWait();
1369 SetIsNeedCondWait();
1370 ret = laneManager->lnnFreeLane(laneReqId);
1371 EXPECT_EQ(ret, SOFTBUS_OK);
1372 CondWait();
1373 ret = laneManager->lnnCancelLane(laneReqId);
1374 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1375 }
1376
1377 /*
1378 * @tc.name: LANE_FREE_001
1379 * @tc.desc: lane free
1380 * @tc.type: FUNC
1381 * @tc.require:
1382 */
1383 HWTEST_F(LNNLaneMockTest, LANE_FREE_001, TestSize.Level1)
1384 {
1385 const LnnLaneManager *laneManager = GetLaneManager();
1386 LaneType laneType = LANE_TYPE_BUTT;
1387 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1388 int32_t ret = laneManager->lnnFreeLane(laneReqId);
1389 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1390
1391 laneType = LANE_TYPE_TRANS;
1392 laneReqId = laneManager->lnnGetLaneHandle(laneType);
1393 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1394 ret = laneManager->lnnFreeLane(laneReqId);
1395 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1396 ret = laneManager->lnnFreeLane(laneReqId);
1397 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1398 }
1399
1400 /*
1401 * @tc.name: LNN_BUILD_LINK_001
1402 * @tc.desc: BUILDLINK
1403 * @tc.type: FUNC
1404 * @tc.require:
1405 */
1406 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_001, TestSize.Level1)
1407 {
1408 LinkRequest reqInfo = {};
1409 reqInfo.linkType = LANE_P2P;
1410 LaneLinkCb cb = {
1411 .onLaneLinkSuccess = OnLaneLinkSuccess,
1412 .onLaneLinkFail = OnLaneLinkFail,
1413 };
1414 int32_t ret;
1415 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1416 EXPECT_CALL(wifiMock, LnnDisconnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
1417 EXPECT_CALL(wifiMock, LnnConnectP2p)
1418 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL))
1419 .WillRepeatedly(Return(SOFTBUS_OK));
1420 ret = BuildLink(&reqInfo, 0, &cb);
1421 EXPECT_EQ(ret, SOFTBUS_LANE_BUILD_LINK_FAIL);
1422
1423 ret = BuildLink(&reqInfo, 0, &cb);
1424 EXPECT_TRUE(ret == SOFTBUS_OK);
1425
1426 cb.onLaneLinkFail = nullptr;
1427 ret = BuildLink(&reqInfo, 0, &cb);
1428 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1429
1430 cb.onLaneLinkSuccess = nullptr;
1431 ret = BuildLink(&reqInfo, 0, &cb);
1432 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1433
1434 ret = BuildLink(&reqInfo, 0, nullptr);
1435 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1436
1437 reqInfo.linkType = LANE_BLE;
1438 ret = BuildLink(&reqInfo, 0, nullptr);
1439 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1440
1441 reqInfo.linkType = LANE_LINK_TYPE_BUTT;
1442 ret = BuildLink(&reqInfo, 0, &cb);
1443 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1444
1445 ret = BuildLink(nullptr, 0, nullptr);
1446 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1447
1448 ret = DestroyLink(NODE_NETWORK_ID, 0, LANE_BLE);
1449 EXPECT_TRUE(ret == SOFTBUS_OK);
1450
1451 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
1452 ret = DestroyLink(NODE_NETWORK_ID, 0, LANE_P2P);
1453 EXPECT_TRUE(ret == SOFTBUS_OK);
1454 ret = DestroyLink(nullptr, 0, LANE_P2P);
1455 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1456 }
1457
1458 /*
1459 * @tc.name: LNN_BUILD_LINK_002
1460 * @tc.desc: BUILDLINK
1461 * @tc.type: FUNC
1462 * @tc.require:
1463 */
1464 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_002, TestSize.Level1)
1465 {
1466 NiceMock<LaneDepsInterfaceMock> mock;
1467 LinkRequest reqInfo = {};
1468 reqInfo.linkType = LANE_P2P;
1469 LaneLinkCb cb = {
1470 .onLaneLinkSuccess = OnLaneLinkSuccess,
1471 .onLaneLinkFail = OnLaneLinkFail,
1472 };
1473 int32_t ret;
1474 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1475 const char *udid = "testuuid";
1476 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1477 ret = BuildLink(&reqInfo, 0, &cb);
1478 EXPECT_TRUE(ret == SOFTBUS_OK);
1479 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1480 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1481 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1482 ON_CALL(wifiMock, LnnConnectP2p).WillByDefault(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
1483 ret = BuildLink(&reqInfo, 0, &cb);
1484 EXPECT_EQ(ret, SOFTBUS_LANE_BUILD_LINK_FAIL);
1485 }
1486
1487 /*
1488 * @tc.name: LNN_BUILD_LINK_003
1489 * @tc.desc: BUILDLINK
1490 * @tc.type: FUNC
1491 * @tc.require:
1492 */
1493 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_003, TestSize.Level1)
1494 {
1495 NiceMock<LaneDepsInterfaceMock> mock;
1496 LinkRequest reqInfo = {};
1497 reqInfo.linkType = LANE_P2P;
1498 LaneLinkCb cb = {
1499 .onLaneLinkSuccess = OnLaneLinkSuccess,
1500 .onLaneLinkFail = OnLaneLinkFail,
1501 };
1502 int32_t ret;
1503 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1504
1505 ConnBleConnection *connection = (ConnBleConnection*)SoftBusCalloc(sizeof(ConnBleConnection));
1506 if (connection == nullptr) {
1507 return;
1508 }
1509 const char *udid = "testuuid";
1510 NodeInfo *nodeInfo = (NodeInfo*)SoftBusCalloc(sizeof(NodeInfo));
1511 if (nodeInfo == nullptr) {
1512 return;
1513 }
1514 connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
1515 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1516 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(connection));
1517 EXPECT_CALL(mock, LnnGetRemoteNodeInfoById).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1518 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
1519 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
1520 ret = BuildLink(&reqInfo, 0, &cb);
1521 EXPECT_TRUE(ret == SOFTBUS_OK);
1522 SoftBusFree(connection);
1523 SoftBusFree(nodeInfo);
1524 }
1525
1526 /*
1527 * @tc.name: LNN_BUILD_LINK_004
1528 * @tc.desc: BUILDLINK
1529 * @tc.type: FUNC
1530 * @tc.require:
1531 */
1532 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_004, TestSize.Level1)
1533 {
1534 NiceMock<LaneDepsInterfaceMock> mock;
1535 LinkRequest reqInfo = {};
1536 int32_t ret;
1537 const char *udid = "testuuid";
1538 LaneLinkCb cb = {
1539 .onLaneLinkSuccess = OnLaneLinkSuccess,
1540 .onLaneLinkFail = OnLaneLinkFail,
1541 };
1542
1543 reqInfo.linkType = LANE_BLE;
1544 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1545 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1546 ON_CALL(mock, LnnGetRemoteStrInfo).WillByDefault(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1547 ret = BuildLink(&reqInfo, 0, &cb);
1548 EXPECT_NE(ret, SOFTBUS_OK);
1549
1550 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1551 ON_CALL(mock, SoftBusGenerateStrHash).WillByDefault(Return(SOFTBUS_ENCRYPT_ERR));
1552 ret = BuildLink(&reqInfo, 0, &cb);
1553 EXPECT_NE(ret, SOFTBUS_OK);
1554 ret = BuildLink(&reqInfo, 0, &cb);
1555 EXPECT_NE(ret, SOFTBUS_OK);
1556 }
1557
1558 /*
1559 * @tc.name: LNN_BUILD_LINK_005
1560 * @tc.desc: BUILDLINK
1561 * @tc.type: FUNC
1562 * @tc.require:
1563 */
1564 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_005, TestSize.Level1)
1565 {
1566 NiceMock<LaneDepsInterfaceMock> mock;
1567 LinkRequest reqInfo = {};
1568 int32_t ret;
1569 const char *udid = "testuuid";
1570 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
1571 LaneLinkCb cb = {
1572 .onLaneLinkSuccess = OnLaneLinkSuccess,
1573 .onLaneLinkFail = OnLaneLinkFail,
1574 };
1575
1576 reqInfo.linkType = LANE_BLE;
1577 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
1578 if (connection == nullptr) {
1579 return;
1580 }
1581 connection->state = BLE_CONNECTION_STATE_INVALID;
1582 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1583 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(connection));
1584 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1585 ON_CALL(mock, LnnGetRemoteNodeInfoById).WillByDefault(Return(SOFTBUS_OK));
1586 ret = BuildLink(&reqInfo, 0, &cb);
1587 EXPECT_TRUE(ret == SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1588 SoftBusFree(connection);
1589 }
1590
1591 /*
1592 * @tc.name: LNN_BUILD_LINK_006
1593 * @tc.desc: BUILDLINK
1594 * @tc.type: FUNC
1595 * @tc.require:
1596 */
1597 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_006, TestSize.Level1)
1598 {
1599 uint32_t reqId = 0;
1600 const char *networkId = "testnetworkid123";
1601 const char *networkIdNotFound = "testnetworkid133";
1602 const char *ipAddr = "127.0.0.1";
1603 const char *ipAddrDiff = "127.0.0.2";
1604 uint16_t portA = 22;
1605 uint16_t portB = 33;
1606 LaneLinkCb cb = {
1607 .onLaneLinkSuccess = OnLaneLinkSuccess,
1608 .onLaneLinkFail = OnLaneLinkFail,
1609 };
1610 NiceMock<LaneDepsInterfaceMock> mock;
1611 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1612 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1613 if (request == nullptr) {
1614 return;
1615 }
1616 LaneAddP2pAddress(networkId, ipAddr, portA);
1617 LaneAddP2pAddress(networkId, ipAddr, portB);
1618 LaneAddP2pAddressByIp(ipAddr, portB);
1619 LaneAddP2pAddressByIp(ipAddrDiff, portB);
1620 request->linkType = LANE_P2P_REUSE;
1621 (void)strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkId);
1622 int32_t ret = BuildLink(request, reqId, &cb);
1623 EXPECT_TRUE(ret == SOFTBUS_OK);
1624
1625 (void)strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkIdNotFound);
1626 ret = BuildLink(request, reqId, &cb);
1627 EXPECT_TRUE(ret == SOFTBUS_LANE_NOT_FOUND);
1628 SoftBusFree(request);
1629 LaneDeleteP2pAddress(networkId, true);
1630 }
1631
1632 /*
1633 * @tc.name: LNN_BUILD_LINK_007
1634 * @tc.desc: BUILDLINK
1635 * @tc.type: FUNC
1636 * @tc.require:
1637 */
1638 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_007, TestSize.Level1)
1639 {
1640 NiceMock<LaneDepsInterfaceMock> mock;
1641 uint32_t reqId = 0;
1642 LaneLinkCb cb = {
1643 .onLaneLinkSuccess = OnLaneLinkSuccess,
1644 .onLaneLinkFail = OnLaneLinkFail,
1645 };
1646 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1647 if (request == nullptr) {
1648 return;
1649 }
1650 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
1651 if (nodeInfo == nullptr) {
1652 SoftBusFree(request);
1653 return;
1654 }
1655 request->linkType = LANE_BLE_DIRECT;
1656 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1657 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillRepeatedly(Return(nodeInfo));
1658
1659 int32_t ret = BuildLink(request, reqId, &cb);
1660 ret = BuildLink(request, reqId, &cb);
1661 EXPECT_TRUE(ret == SOFTBUS_OK);
1662 SoftBusFree(request);
1663 SoftBusFree(nodeInfo);
1664 }
1665
1666 /*
1667 * @tc.name: LNN_BUILD_LINK_008
1668 * @tc.desc: BUILDLINK
1669 * @tc.type: FUNC
1670 * @tc.require:
1671 */
1672 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_008, TestSize.Level1)
1673 {
1674 NiceMock<LaneDepsInterfaceMock> mock;
1675 LinkRequest reqInfo = {};
1676 int32_t ret;
1677 const char *udid = "testuuid";
1678 const char *bleMac = "127.1.1.1";
1679 LaneLinkCb cb = {
1680 .onLaneLinkSuccess = OnLaneLinkSuccess,
1681 .onLaneLinkFail = OnLaneLinkFail,
1682 };
1683
1684 reqInfo.linkType = LANE_COC;
1685 if (strcpy_s(reqInfo.peerBleMac, MAX_MAC_LEN, bleMac) != EOK) {
1686 return;
1687 }
1688 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1689 EXPECT_CALL(mock, ConnBleGetClientConnectionByUdid).WillRepeatedly(Return(nullptr));
1690 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1691 ret = BuildLink(&reqInfo, 0, &cb);
1692 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1693
1694 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1695 EXPECT_CALL(mock, SoftBusGenerateStrHash)
1696 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
1697 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfGenerateStrHash);
1698 ret = BuildLink(&reqInfo, 0, &cb);
1699 EXPECT_EQ(ret, SOFTBUS_ENCRYPT_ERR);
1700 ret = BuildLink(&reqInfo, 0, &cb);
1701 EXPECT_TRUE(ret == SOFTBUS_OK);
1702 }
1703
1704 /*
1705 * @tc.name: LNN_BUILD_LINK_009
1706 * @tc.desc: BUILDLINK
1707 * @tc.type: FUNC
1708 * @tc.require:
1709 */
1710 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_009, TestSize.Level1)
1711 {
1712 uint32_t reqId = 0;
1713 const char *networkId = "testnetworkid123";
1714 const char *networkIdNotFound = "testnetworkid133";
1715 LaneLinkCb cb = {
1716 .onLaneLinkSuccess = OnLaneLinkSuccess,
1717 .onLaneLinkFail = OnLaneLinkFail,
1718 };
1719 NiceMock<LaneDepsInterfaceMock> mock;
1720 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1721 LinkRequest *request = (LinkRequest *)SoftBusCalloc(sizeof(LinkRequest));
1722 if (request == nullptr) {
1723 return;
1724 }
1725 request->linkType = LANE_COC_DIRECT;
1726 if (strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkId) != EOK) {
1727 return;
1728 }
1729 int32_t ret = BuildLink(request, reqId, &cb);
1730 EXPECT_TRUE(ret == SOFTBUS_OK);
1731
1732 if (strcpy_s(request->peerNetworkId, NETWORK_ID_BUF_LEN, networkIdNotFound) != EOK) {
1733 return;
1734 }
1735 ret = BuildLink(request, reqId, &cb);
1736 EXPECT_TRUE(ret == SOFTBUS_OK);
1737 SoftBusFree(request);
1738 LaneDeleteP2pAddress(networkId, true);
1739 }
1740
1741 /*
1742 * @tc.name: LNN_BUILD_LINK_010
1743 * @tc.desc: BUILDLINK
1744 * @tc.type: FUNC
1745 * @tc.require:
1746 */
1747 HWTEST_F(LNNLaneMockTest, LNN_BUILD_LINK_010, TestSize.Level1)
1748 {
1749 const char *networkId = "testnetworkid123";
1750 const char *ipAddr = "127.0.0.1";
1751 uint16_t port = 1022;
1752 NiceMock<LaneDepsInterfaceMock> mock;
1753 LinkRequest reqInfo = {};
1754 int32_t ret;
1755 const char *udid = "testuuid";
1756 const char *bleMac = "127.1.1.1";
1757 LaneLinkCb cb = {
1758 .onLaneLinkSuccess = OnLaneLinkSuccess,
1759 .onLaneLinkFail = OnLaneLinkFail,
1760 };
1761 ConnBleConnection *connection = (ConnBleConnection *)SoftBusCalloc(sizeof(ConnBleConnection));
1762 if (connection == nullptr) {
1763 return;
1764 }
1765 connection->state = BLE_CONNECTION_STATE_EXCHANGED_BASIC_INFO;
1766 reqInfo.linkType = LANE_BLE_REUSE;
1767 if (strcpy_s(reqInfo.peerBleMac, MAX_MAC_LEN, bleMac) != EOK) {
1768 return;
1769 }
1770 LaneAddP2pAddress(networkId, ipAddr, port);
1771 LaneAddP2pAddressByIp(ipAddr, port);
1772 LaneUpdateP2pAddressByIp(ipAddr, networkId);
1773 ON_CALL(mock, ConnBleGetConnectionByUdid).WillByDefault(Return(connection));
1774 ON_CALL(mock, ConnBleReturnConnection).WillByDefault(Return());
1775 EXPECT_CALL(mock, LnnConvertDLidToUdid).WillRepeatedly(Return(udid));
1776 EXPECT_CALL(mock, SoftBusGenerateStrHash).WillRepeatedly(Return(SOFTBUS_OK));
1777 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1778 ret = BuildLink(&reqInfo, 0, &cb);
1779 EXPECT_TRUE(ret == SOFTBUS_OK);
1780
1781 EXPECT_CALL(mock, ConnBleGetConnectionByUdid).WillRepeatedly(Return(connection));
1782 ret = BuildLink(&reqInfo, 0, &cb);
1783 EXPECT_TRUE(ret == SOFTBUS_OK);
1784 SoftBusFree(connection);
1785 }
1786
1787 /*
1788 * @tc.name: LANE_FLOAD_EXPLORE_001
1789 * @tc.desc: LANE FLOAD EXPLORE TEST
1790 * @tc.type: FUNC
1791 * @tc.require:
1792 */
1793 HWTEST_F(LNNLaneMockTest, LANE_FLOAD_EXPLORE_001, TestSize.Level1)
1794 {
1795 LaneResource resourceItem = {};
1796 resourceItem.clientRef = DEFAULT_LANE_RESOURCE_LANE_REF;
1797 int32_t ret = LaneDetectFload(&resourceItem);
1798 EXPECT_EQ(ret, SOFTBUS_OK);
1799 }
1800
1801 /*
1802 * @tc.name: LANE_DETECT_RELIABILITY_001
1803 * @tc.desc: LANE DETECT RELIABILITY TEST
1804 * @tc.type: FUNC
1805 * @tc.require:
1806 */
1807 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_001, TestSize.Level1)
1808 {
1809 LaneLinkCb cb = {
1810 .onLaneLinkSuccess = OnLaneLinkSuccess,
1811 .onLaneLinkFail = OnLaneLinkFail,
1812 };
1813
1814 NiceMock<LaneDepsInterfaceMock> mock;
1815 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
1816 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
1817
1818 LaneLinkInfo linkInfo;
1819 linkInfo.type = LANE_WLAN_2P4G;
1820 const LnnLaneManager *laneManager = GetLaneManager();
1821 LaneType laneType = LANE_TYPE_TRANS;
1822 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1823 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1824
1825 uint64_t laneId = LANE_ID_BASE;
1826 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1827 EXPECT_EQ(ret, SOFTBUS_OK);
1828
1829 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1830 EXPECT_EQ(ret, SOFTBUS_OK);
1831
1832 DelLaneResourceByLaneId(laneId, false);
1833 EXPECT_EQ(ret, SOFTBUS_OK);
1834 }
1835
1836 /*
1837 * @tc.name: LANE_DETECT_RELIABILITY_002
1838 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
1839 * @tc.type: FUNC
1840 * @tc.require:
1841 */
1842 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_002, TestSize.Level1)
1843 {
1844 NiceMock<LaneDepsInterfaceMock> mock;
1845 int32_t events = 0;
1846 ListenerModule module = LANE;
1847 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
1848 LaneLinkCb cb = {
1849 .onLaneLinkSuccess = OnLaneLinkSuccess,
1850 .onLaneLinkFail = OnLaneLinkFail,
1851 };
1852
1853 LaneLinkInfo linkInfo;
1854 linkInfo.type = LANE_WLAN_5G;
1855 const LnnLaneManager *laneManager = GetLaneManager();
1856 LaneType laneType = LANE_TYPE_TRANS;
1857 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1858 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1859
1860 uint64_t laneId = LANE_ID_BASE;
1861 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1862 EXPECT_EQ(ret, SOFTBUS_OK);
1863
1864 ret = LaneDetectOnDataEvent(module, events, FD);
1865 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
1866 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
1867 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
1868
1869 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1870 EXPECT_EQ(ret, SOFTBUS_OK);
1871
1872 LaneDetectInfo requestItem = {};
1873 if (GetLaneDetectInfoByWlanFd(SOFTBUS_OK, &requestItem) != SOFTBUS_OK) {
1874 return;
1875 }
1876 bool isSendSuc = true;
1877 ret = NotifyWlanDetectResult(&requestItem, isSendSuc);
1878 EXPECT_EQ(ret, SOFTBUS_OK);
1879
1880 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1881 EXPECT_EQ(ret, SOFTBUS_OK);
1882 ret = LaneDetectOnDataEvent(module, events, SOFTBUS_OK);
1883 EXPECT_EQ(ret, SOFTBUS_OK);
1884 ret = LaneDetectReliability(INVALID_LANE_REQ_ID, &linkInfo, &cb);
1885 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1886
1887 ret = DelLaneResourceByLaneId(laneId, false);
1888 EXPECT_EQ(ret, SOFTBUS_OK);
1889 }
1890
1891 /*
1892 * @tc.name: LANE_DETECT_RELIABILITY_003
1893 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
1894 * @tc.type: FUNC
1895 * @tc.require:
1896 */
1897 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_003, TestSize.Level1)
1898 {
1899 const char *ipAddr = "127.0.0.1";
1900 NiceMock<LaneDepsInterfaceMock> mock;
1901 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
1902 LaneLinkCb cb = {
1903 .onLaneLinkSuccess = OnLaneLinkSuccess,
1904 .onLaneLinkFail = OnLaneLinkFail,
1905 };
1906
1907 LaneLinkInfo linkInfo;
1908 linkInfo.type = LANE_WLAN_5G;
1909 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
1910 if (strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr) != EOK) {
1911 return;
1912 }
1913 const LnnLaneManager *laneManager = GetLaneManager();
1914 LaneType laneType = LANE_TYPE_TRANS;
1915 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1916 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1917
1918 uint64_t laneId = LANE_ID_BASE;
1919 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1920 EXPECT_EQ(ret, SOFTBUS_OK);
1921
1922 EXPECT_CALL(mock, ConnOpenClientSocket)
1923 .WillOnce(Return(SOFTBUS_TCPCONNECTION_SOCKET_ERR))
1924 .WillRepeatedly(Return(SOFTBUS_OK));
1925 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_LANE_DETECT_FAIL));
1926
1927 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1928 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
1929 linkInfo.linkInfo.wlan.connInfo.port = PORT_B;
1930
1931 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1932 EXPECT_EQ(ret, SOFTBUS_LANE_DETECT_FAIL);
1933 ret = DelLaneResourceByLaneId(laneId, false);
1934 EXPECT_EQ(ret, SOFTBUS_OK);
1935 }
1936
1937 /*
1938 * @tc.name: LANE_DETECT_RELIABILITY_004
1939 * @tc.desc: WLAN LANE DETECT RELIABILITY TEST
1940 * @tc.type: FUNC
1941 * @tc.require:
1942 */
1943 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_004, TestSize.Level1)
1944 {
1945 const char *ipAddr = "127.0.0.1";
1946 LaneLinkCb cb = {
1947 .onLaneLinkSuccess = OnLaneLinkSuccessForDetect,
1948 .onLaneLinkFail = OnLaneLinkFailForDetect,
1949 };
1950
1951 LaneLinkInfo linkInfo;
1952 linkInfo.type = LANE_WLAN_5G;
1953 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
1954 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr), EOK);
1955 const LnnLaneManager *laneManager = GetLaneManager();
1956 LaneType laneType = LANE_TYPE_TRANS;
1957 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
1958 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
1959
1960 NiceMock<LaneDepsInterfaceMock> mock;
1961 EXPECT_CALL(mock, ConnOpenClientSocket)
1962 .WillOnce(Return(SOFTBUS_TCPCONNECTION_SOCKET_ERR))
1963 .WillRepeatedly(Return(SOFTBUS_OK));
1964 EXPECT_CALL(mock, AddTrigger).WillOnce(Return(SOFTBUS_CONN_FAIL))
1965 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
1966 char buf[] = "lanedetect";
1967 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
1968
1969 int32_t ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1970 EXPECT_EQ(ret, SOFTBUS_TCPCONNECTION_SOCKET_ERR);
1971
1972 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1973 EXPECT_EQ(ret, SOFTBUS_CONN_FAIL);
1974
1975 ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
1976 EXPECT_EQ(ret, SOFTBUS_OK);
1977 }
1978
1979 /*
1980 * @tc.name: LANE_DETECT_RELIABILITY_005
1981 * @tc.desc: WLAN LANE DETECT RELIABILITY, SOFTBUS_SOCKET_EXCEPTION
1982 * @tc.type: FUNC
1983 * @tc.require:
1984 */
1985 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_005, TestSize.Level1)
1986 {
1987 const char *ipAddr = "127.0.0.1";
1988 LaneLinkCb cb = {
1989 .onLaneLinkSuccess = OnLaneLinkSuccessForDetect,
1990 .onLaneLinkFail = OnLaneLinkFailForDetect,
1991 };
1992
1993 LaneLinkInfo linkInfo;
1994 linkInfo.type = LANE_WLAN_5G;
1995 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
1996 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr), EOK);
1997 const LnnLaneManager *laneManager = GetLaneManager();
1998 LaneType laneType = LANE_TYPE_TRANS;
1999 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2000 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2001 LaneDepsInterfaceMock::socketEvent = SOFTBUS_SOCKET_EXCEPTION;
2002 NiceMock<LaneDepsInterfaceMock> mock;
2003 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
2004 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(LaneDepsInterfaceMock::ActionOfAddTrigger);
2005 char buf[] = "lanedetect";
2006 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
2007
2008 int32_t ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2009 EXPECT_EQ(ret, SOFTBUS_OK);
2010 }
2011
2012 /*
2013 * @tc.name: LANE_DETECT_RELIABILITY_006
2014 * @tc.desc: WLAN LANE DETECT RELIABILITY TIMEOUT
2015 * @tc.type: FUNC
2016 * @tc.require:
2017 */
2018 HWTEST_F(LNNLaneMockTest, LANE_DETECT_RELIABILITY_006, TestSize.Level1)
2019 {
2020 const char *ipAddr = "127.0.0.1";
2021 LaneLinkCb cb = {
2022 .onLaneLinkSuccess = OnLaneLinkSuccessForDetect,
2023 .onLaneLinkFail = OnLaneLinkFailForDetect,
2024 };
2025
2026 LaneLinkInfo linkInfo;
2027 linkInfo.type = LANE_WLAN_5G;
2028 linkInfo.linkInfo.wlan.connInfo.port = PORT_A;
2029 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, ipAddr), EOK);
2030 const LnnLaneManager *laneManager = GetLaneManager();
2031 LaneType laneType = LANE_TYPE_TRANS;
2032 int32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2033 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2034
2035 NiceMock<LaneDepsInterfaceMock> mock;
2036 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_OK));
2037 EXPECT_CALL(mock, AddTrigger).WillRepeatedly(Return(SOFTBUS_OK));
2038 char buf[] = "lanedetect";
2039 EXPECT_CALL(mock, ConnSendSocketData).WillRepeatedly(Return(sizeof(buf)));
2040 SetIsNeedCondWait();
2041 int32_t ret = LaneDetectReliability(laneReqId, &linkInfo, &cb);
2042 EXPECT_EQ(ret, SOFTBUS_OK);
2043 CondWait();
2044 }
2045
2046 /*
2047 * @tc.name: LANE_INIT_RELIABLITY_001
2048 * @tc.desc: LANE INIT RELIABLITY TEST
2049 * @tc.type: FUNC
2050 * @tc.require:
2051 */
2052 HWTEST_F(LNNLaneMockTest, LANE_INIT_RELIABLITY_001, TestSize.Level1)
2053 {
2054 NiceMock<LaneDepsInterfaceMock> mock;
2055 EXPECT_CALL(mock, StartBaseClient).WillRepeatedly(Return(SOFTBUS_OK));
2056 int32_t ret = InitLaneReliability();
2057 EXPECT_EQ(ret, SOFTBUS_OK);
2058 }
2059
2060 /*
2061 * @tc.name: LNN_AUTH_ALLOC_TEST_001
2062 * @tc.desc: AuthAlloc
2063 * @tc.type: FUNC
2064 * @tc.require:
2065 */
2066 HWTEST_F(LNNLaneMockTest, LNN_AUTH_ALLOC_TEST_001, TestSize.Level1)
2067 {
2068 const LnnLaneManager *laneManager = GetLaneManager();
2069 LaneType laneType = LANE_TYPE_CTRL;
2070 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2071 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2072
2073 NiceMock<LaneDepsInterfaceMock> mock;
2074 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2075 EXPECT_CALL(mock, LnnGetLocalNumInfo)
2076 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
2077 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
2078 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
2079 EXPECT_CALL(mock, LnnGetLocalNumU32Info)
2080 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(16), Return(SOFTBUS_OK)));
2081 EXPECT_CALL(mock, LnnGetRemoteNumU32Info)
2082 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(16), Return(SOFTBUS_OK)));
2083
2084 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2085 wifiMock.SetDefaultResult();
2086
2087 LaneAllocInfo allocInfo = {};
2088 allocInfo.type = laneType;
2089 (void)strncpy_s(allocInfo.networkId, NETWORK_ID_BUF_LEN,
2090 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
2091 allocInfo.transType = LANE_T_BYTE;
2092 allocInfo.qosRequire.minBW = 0;
2093 allocInfo.qosRequire.maxLaneLatency = 0;
2094 allocInfo.qosRequire.minLaneLatency = 0;
2095
2096 int32_t ret = laneManager->lnnAllocLane(laneReqId, nullptr, &g_listener);
2097 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2098
2099 ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, nullptr);
2100 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2101
2102 ret = laneManager->lnnAllocLane(INVALID_LANE_REQ_ID, &allocInfo, &g_listener);
2103 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2104 }
2105
2106 /*
2107 * @tc.name: LNN_LANE_03
2108 * @tc.desc: SelectLaneRule
2109 * @tc.type: FUNC
2110 * @tc.require:
2111 */
2112 HWTEST_F(LNNLaneMockTest, LNN_LANE_03, TestSize.Level1)
2113 {
2114 uint32_t laneReqId = 0;
2115 LaneRequestOption request;
2116 ILaneListener listener;
2117 ILaneIdStateListener laneListener;
2118
2119 RegisterLaneIdListener(nullptr);
2120 laneListener.OnLaneIdEnabled = nullptr;
2121 laneListener.OnLaneIdDisabled = nullptr;
2122 RegisterLaneIdListener(&laneListener);
2123 UnregisterLaneIdListener(nullptr);
2124 FreeLaneReqId(laneReqId);
2125 laneReqId = 0xfffffff;
2126 FreeLaneReqId(laneReqId);
2127 request.type = LANE_TYPE_BUTT;
2128 int32_t ret = LnnRequestLane(0, &request, &listener);
2129 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2130
2131 request.type = (LaneType)-1;
2132 ret = LnnRequestLane(0, &request, &listener);
2133 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2134 }
2135
2136 /*
2137 * @tc.name: LNN_LANE_04
2138 * @tc.desc: SelectLaneRule
2139 * @tc.type: FUNC
2140 * @tc.require:
2141 */
2142 HWTEST_F(LNNLaneMockTest, LNN_LANE_04, TestSize.Level1)
2143 {
2144 RawLaneAllocInfo allocInfo;
2145 LaneAllocListener listener;
2146
2147 const LnnLaneManager *laneManager = GetLaneManager();
2148 LaneType laneType = LANE_TYPE_TRANS;
2149 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2150 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2151
2152 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, nullptr, &listener);
2153 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2154 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, nullptr);
2155 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2156 ret = laneManager->lnnAllocRawLane(laneHandle, nullptr, nullptr);
2157 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2158
2159 allocInfo.type = LANE_TYPE_BUTT;
2160 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2161 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2162
2163 allocInfo.type = (LaneType)-1;
2164 ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2165 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2166 }
2167
2168 /*
2169 * @tc.name: LNN_LANE_05
2170 * @tc.desc: SelectLaneRule
2171 * @tc.type: FUNC
2172 * @tc.require:
2173 */
2174 HWTEST_F(LNNLaneMockTest, LNN_LANE_05, TestSize.Level1)
2175 {
2176 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2177 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2178 const LnnLaneManager *laneManager = GetLaneManager();
2179 LaneType laneType = LANE_TYPE_TRANS;
2180 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2181 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2182
2183 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
2184 RawLaneAllocInfo allocInfo;
2185 allocInfo.type = LANE_TYPE_HDLC;
2186 LaneAllocListener listener;
2187 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2188 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2189
2190 ret = laneManager->lnnFreeLane(laneHandle);
2191 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
2192 }
2193
2194 /*
2195 * @tc.name: LNN_LANE_06
2196 * @tc.desc: SelectLaneRule
2197 * @tc.type: FUNC
2198 * @tc.require:
2199 */
2200 HWTEST_F(LNNLaneMockTest, LNN_LANE_06, TestSize.Level1)
2201 {
2202 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2203 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2204 const LnnLaneManager *laneManager = GetLaneManager();
2205 LaneType laneType = LANE_TYPE_TRANS;
2206 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2207 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2208
2209 EXPECT_CALL(wifiMock, LnnConnectP2p).WillRepeatedly(Return(SOFTBUS_OK));
2210 RawLaneAllocInfo allocInfo;
2211 allocInfo.type = LANE_TYPE_TRANS;
2212 LaneAllocListener listener = {
2213 .onLaneFreeSuccess = OnLaneFreeSuccess,
2214 .onLaneFreeFail = OnLaneFreeFail,
2215 };
2216 SetIsNeedCondWait();
2217 int32_t ret = laneManager->lnnAllocRawLane(laneHandle, &allocInfo, &listener);
2218 EXPECT_EQ(ret, SOFTBUS_OK);
2219 CondWait();
2220 SetIsNeedCondWait();
2221 ret = laneManager->lnnFreeLane(laneHandle);
2222 EXPECT_EQ(ret, SOFTBUS_OK);
2223 CondWait();
2224 }
2225
2226 /*
2227 * @tc.name: LNN_LANE_07
2228 * @tc.desc: SelectLaneRule
2229 * @tc.type: FUNC
2230 * @tc.require:
2231 */
2232 HWTEST_F(LNNLaneMockTest, LNN_LANE_07, TestSize.Level1)
2233 {
2234 LaneAllocInfoExt allocInfo;
2235 LaneAllocListener listener;
2236 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2237
2238 const LnnLaneManager *laneManager = GetLaneManager();
2239 LaneType laneType = LANE_TYPE_TRANS;
2240 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2241 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2242
2243 int32_t ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, nullptr);
2244 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2245 ret = laneManager->lnnAllocTargetLane(laneHandle, nullptr, &listener);
2246 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2247 ret = laneManager->lnnAllocTargetLane(laneHandle, nullptr, nullptr);
2248 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2249 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, nullptr, nullptr);
2250 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2251 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, nullptr, &listener);
2252 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2253 ret = laneManager->lnnAllocTargetLane(INVALID_LANE_REQ_ID, &allocInfo, &listener);
2254 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2255 allocInfo.type = LANE_TYPE_BUTT;
2256 ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &listener);
2257 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2258 allocInfo.type = LANE_TYPE_TRANS;
2259 allocInfo.linkList.linkTypeNum = LANE_LINK_TYPE_BUTT;
2260 ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &listener);
2261 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2262 }
2263
2264 /*
2265 * @tc.name: LNN_LANE_08
2266 * @tc.desc: SelectLaneRule
2267 * @tc.type: FUNC
2268 * @tc.require:
2269 */
2270 HWTEST_F(LNNLaneMockTest, LNN_LANE_08, TestSize.Level1)
2271 {
2272 LaneAllocInfoExt allocInfo;
2273 NiceMock<LaneDepsInterfaceMock> laneDepMock;
2274 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2275 const LnnLaneManager *laneManager = GetLaneManager();
2276 LaneType laneType = LANE_TYPE_TRANS;
2277 uint32_t laneHandle = laneManager->lnnGetLaneHandle(laneType);
2278 EXPECT_TRUE(laneHandle != INVALID_LANE_REQ_ID);
2279
2280 EXPECT_CALL(laneDepMock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
2281 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
2282 laneDepMock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2283 laneDepMock.SetDefaultResultForAlloc(1 << BIT_WIFI_P2P, 1 << BIT_WIFI_P2P, 8, 8);
2284 wifiMock.SetDefaultResult();
2285 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneHandle, NotNull()))
2286 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfLnnConnectP2p);
2287
2288 allocInfo.linkList.linkTypeNum = LANE_LINK_TYPE_BUTT - 1;
2289 allocInfo.type = LANE_TYPE_TRANS;
2290 SetIsNeedCondWait();
2291 int32_t ret = laneManager->lnnAllocTargetLane(laneHandle, &allocInfo, &g_listenerCbForBr2);
2292 EXPECT_EQ(ret, SOFTBUS_OK);
2293 CondWait();
2294 SetIsNeedCondWait();
2295 ret = laneManager->lnnFreeLane(laneHandle);
2296 EXPECT_EQ(ret, SOFTBUS_OK);
2297 CondWait();
2298 }
2299
2300 /*
2301 * @tc.name: LNN_LANE_12
2302 * @tc.desc: SelectLaneRule
2303 * @tc.type: FUNC
2304 * @tc.require:
2305 */
2306 HWTEST_F(LNNLaneMockTest, LNN_LANE_12, TestSize.Level1)
2307 {
2308 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2309 const LnnLaneManager *laneManager = GetLaneManager();
2310 LaneType laneType = LANE_TYPE_TRANS;
2311 uint32_t laneReqId = laneManager->lnnGetLaneHandle(laneType);
2312 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2313
2314 wifiMock.SetDefaultResult();
2315 EXPECT_CALL(wifiMock, LnnConnectP2p(NotNull(), laneReqId, NotNull()))
2316 .WillRepeatedly(LnnWifiAdpterInterfaceMock::ActionOfOnConnectP2pFail);
2317 NiceMock<LaneDepsInterfaceMock> mock;
2318 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
2319 mock.SetDefaultResultForAlloc(63, 63, 0, 0);
2320 EXPECT_CALL(mock, ConnOpenClientSocket).WillRepeatedly(Return(SOFTBUS_CONN_FAIL));
2321 EXPECT_CALL(mock, DeleteNetworkResourceByLaneId).WillRepeatedly(Return());
2322 LaneAllocInfo allocInfo = {};
2323 CreateAllocInfoForAllocTest(LANE_T_MSG, DEFAULT_QOSINFO_MIN_BW + HIGH_BW, DEFAULT_QOSINFO_MAX_LATENCY,
2324 DEFAULT_QOSINFO_MIN_LATENCY, &allocInfo);
2325 SetIsNeedCondWait();
2326 int32_t ret = laneManager->lnnAllocLane(laneReqId, &allocInfo, &g_listener);
2327 EXPECT_EQ(ret, SOFTBUS_OK);
2328 CondWait();
2329 }
2330
2331 /*
2332 * @tc.name: LNN_LANE_13
2333 * @tc.desc: SelectLaneRule
2334 * @tc.type: FUNC
2335 * @tc.require:
2336 */
2337 HWTEST_F(LNNLaneMockTest, LNN_LANE_13, TestSize.Level1)
2338 {
2339 LaneType laneType = LANE_TYPE_TRANS;
2340 uint32_t laneReqId = ApplyLaneReqId(laneType);
2341 EXPECT_TRUE(laneReqId != INVALID_LANE_REQ_ID);
2342 NiceMock<LaneDepsInterfaceMock> mock;
2343 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(DoAll(SetArgPointee<1>(NET_CAP), Return(SOFTBUS_OK)));
2344 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(DoAll(SetArgPointee<2>(NET_CAP), Return(SOFTBUS_OK)));
2345 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
2346 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
2347 EXPECT_CALL(wifiMock, SoftBusGetLinkBand).WillRepeatedly(Return(BAND_5G));
2348
2349 LaneRequestOption requestOption = {};
2350 requestOption.type = laneType;
2351 EXPECT_EQ(strncpy_s(requestOption.requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
2352 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID)), EOK);
2353 requestOption.requestInfo.trans.transType = LANE_T_COMMON_VIDEO;
2354 requestOption.requestInfo.trans.expectedBw = 0;
2355 requestOption.requestInfo.trans.pid = 0;
2356 requestOption.requestInfo.trans.expectedLink.linkTypeNum = 1;
2357 requestOption.requestInfo.trans.expectedLink.linkType[0] = LANE_WLAN_5G;
2358
2359 int32_t ret = LnnRequestLane(laneReqId, &requestOption, &g_listener2);
2360 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_OFF);
2361 ret = LnnFreeLane(laneReqId);
2362 EXPECT_EQ(ret, SOFTBUS_LANE_NOT_FOUND);
2363 }
2364 } // namespace OHOS
2365