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 "dsoftbus_enhance_interface.h"
23 #include "g_enhance_lnn_func.h"
24 #include "g_enhance_lnn_func_pack.h"
25 #include "lnn_lane.h"
26 #include "lnn_lane_common.h"
27 #include "lnn_lane_def.h"
28 #include "lnn_lane_deps_mock.h"
29 #include "lnn_lane_interface.h"
30 #include "lnn_lane_link.h"
31 #include "lnn_lane_link_ledger.h"
32 #include "lnn_lane_model.h"
33 #include "lnn_lane_power_ctrl_deps_mock.h"
34 #include "lnn_lane_reliability.c"
35 #include "lnn_lane_select.h"
36 #include "lnn_select_rule.h"
37 #include "lnn_wifi_adpter_mock.h"
38 #include "message_handler.h"
39 #include "softbus_adapter_mem.h"
40 #include "softbus_error_code.h"
41 #include "softbus_wifi_api_adapter.h"
42 #include "wifi_direct_error_code.h"
43
44 namespace OHOS {
45 using namespace testing::ext;
46 using namespace testing;
47
48 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
49 constexpr char PEER_IP_HML[] = "172.30.0.1";
50 constexpr char PEER_WLAN_ADDR[] = "172.30.0.1";
51 constexpr char PEER_MAC[] = "a1:b2:c3:d4:e5:f6";
52 constexpr char LOCAL_MAC[] = "a2:b2:c3:d4:e5:f6";
53 constexpr char PEER_UDID[] = "111122223333abcdef";
54 constexpr char LOCAL_UDID[] = "444455556666abcdef";
55 constexpr uint64_t LANE_ID_BASE = 1122334455667788;
56 constexpr uint16_t PRI = 1;
57
58 static NodeInfo g_NodeInfo = {
59 .p2pInfo.p2pRole = 1,
60 .p2pInfo.p2pMac = "abc",
61 .p2pInfo.goMac = "abc",
62 };
63
64 class LNNLaneExtMockTest : public testing::Test {
65 public:
66 static void SetUpTestCase();
67 static void TearDownTestCase();
68 void SetUp();
69 void TearDown();
70 };
71
SetUpTestCase()72 void LNNLaneExtMockTest::SetUpTestCase()
73 {
74 int32_t ret = LnnInitLnnLooper();
75 EXPECT_EQ(ret, SOFTBUS_OK);
76 ret = LooperInit();
77 EXPECT_EQ(ret, SOFTBUS_OK);
78 NiceMock<LaneDepsInterfaceMock> mock;
79 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(nullptr));
80 ret = InitLane();
81 EXPECT_EQ(ret, SOFTBUS_OK);
82 GTEST_LOG_(INFO) << "LNNLaneExtMockTest start";
83 }
84
TearDownTestCase()85 void LNNLaneExtMockTest::TearDownTestCase()
86 {
87 NiceMock<LnnWifiAdpterInterfaceMock> wifiMock;
88 EXPECT_CALL(wifiMock, LnnDestroyP2p).WillRepeatedly(Return());
89 DeinitLane();
90 LooperDeinit();
91 LnnDeinitLnnLooper();
92 GTEST_LOG_(INFO) << "LNNLaneExtMockTest end";
93 }
94
SetUp()95 void LNNLaneExtMockTest::SetUp()
96 {
97 }
98
TearDown()99 void LNNLaneExtMockTest::TearDown()
100 {
101 }
102
PrejudgeAvailability(const char * remoteNetworkId,enum WifiDirectLinkType connectType)103 static int32_t PrejudgeAvailability(const char *remoteNetworkId, enum WifiDirectLinkType connectType)
104 {
105 (void)remoteNetworkId;
106 (void)connectType;
107 GTEST_LOG_(INFO) << "PrejudgeAvailability Enter";
108 return SOFTBUS_OK;
109 }
110
GetLocalAndRemoteMacByLocalIp(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)111 static int32_t GetLocalAndRemoteMacByLocalIp(const char *localIp, char *localMac, size_t localMacSize,
112 char *remoteMac, size_t remoteMacSize)
113 {
114 (void)localIp;
115 (void)localMac;
116 (void)localMacSize;
117 (void)remoteMac;
118 (void)remoteMacSize;
119 return SOFTBUS_OK;
120 }
121
GetLocalAndRemoteMacByLocalIpError(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)122 static int32_t GetLocalAndRemoteMacByLocalIpError(const char *localIp, char *localMac, size_t localMacSize,
123 char *remoteMac, size_t remoteMacSize)
124 {
125 (void)localIp;
126 (void)localMac;
127 (void)localMacSize;
128 (void)remoteMac;
129 (void)remoteMacSize;
130 return SOFTBUS_INVALID_PARAM;
131 }
132
133 static struct WifiDirectManager g_manager = {
134 .prejudgeAvailability = PrejudgeAvailability,
135 .getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIp,
136 };
137
OnLaneLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)138 static void OnLaneLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
139 {
140 (void)reqId;
141 (void)reason;
142 (void)linkType;
143 return;
144 }
145
OnLaneLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)146 static void OnLaneLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
147 {
148 (void)reqId;
149 (void)linkType;
150 (void)linkInfo;
151 return;
152 }
153
154 /*
155 * @tc.name: LANE_INFO_001
156 * @tc.desc: LaneInfoProcess BR
157 * @tc.type: FUNC
158 * @tc.require:
159 */
160 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_001, TestSize.Level1)
161 {
162 LaneLinkInfo info = {};
163 info.type = LANE_BR;
164 LaneConnInfo connInfo = {};
165 LaneProfile profile = {};
166 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
167 EXPECT_EQ(ret, SOFTBUS_OK);
168 }
169
170 /*
171 * @tc.name: LANE_INFO_002
172 * @tc.desc: LaneInfoProcess BLE
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_002, TestSize.Level1)
177 {
178 LaneLinkInfo info = {};
179 info.type = LANE_BLE;
180 LaneConnInfo connInfo = {};
181 LaneProfile profile = {};
182 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
183 EXPECT_EQ(ret, SOFTBUS_OK);
184 }
185
186 /*
187 * @tc.name: LANE_INFO_003
188 * @tc.desc: LaneInfoProcess P2P
189 * @tc.type: FUNC
190 * @tc.require:
191 */
192 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_003, TestSize.Level1)
193 {
194 LaneLinkInfo info = {};
195 info.type = LANE_P2P;
196 LaneConnInfo connInfo;
197 LaneProfile profile = {};
198 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
199 EXPECT_EQ(ret, SOFTBUS_OK);
200 }
201
202 /*
203 * @tc.name: LANE_INFO_004
204 * @tc.desc: LaneInfoProcess fail
205 * @tc.type: FAILUE
206 * @tc.require:
207 */
208 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_004, TestSize.Level1)
209 {
210 LaneLinkInfo info = {};
211 info.type = LANE_USB;
212 LaneConnInfo connInfo = {};
213 LaneProfile profile = {};
214 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
215 EXPECT_EQ(ret, SOFTBUS_OK);
216
217 ret = LaneInfoProcess(nullptr, &connInfo, &profile);
218 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
219
220 ret = LaneInfoProcess(&info, nullptr, &profile);
221 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
222
223 ret = LaneInfoProcess(&info, &connInfo, nullptr);
224 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
225 }
226
227 /*
228 * @tc.name: LANE_INFO_005
229 * @tc.desc: LaneInfoProcess 2.4G
230 * @tc.type: FUNC
231 * @tc.require:
232 */
233 HWTEST_F(LNNLaneExtMockTest, LANE_INFO_005, TestSize.Level1)
234 {
235 LaneLinkInfo info = {};
236 LaneConnInfo connInfo = {};
237 LaneProfile profile = {};
238
239 info.type = LANE_WLAN_2P4G;
240 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
241 EXPECT_EQ(ret, SOFTBUS_OK);
242
243 info.type = LANE_WLAN_5G;
244 ret = LaneInfoProcess(&info, &connInfo, &profile);
245 EXPECT_EQ(ret, SOFTBUS_OK);
246
247 info.type = LANE_P2P_REUSE;
248 ret = LaneInfoProcess(&info, &connInfo, &profile);
249 EXPECT_EQ(ret, SOFTBUS_OK);
250
251 info.type = LANE_BLE_DIRECT;
252 ret = LaneInfoProcess(&info, &connInfo, &profile);
253 EXPECT_EQ(ret, SOFTBUS_OK);
254
255 info.type = LANE_COC;
256 ret = LaneInfoProcess(&info, &connInfo, &profile);
257 EXPECT_EQ(ret, SOFTBUS_OK);
258
259 info.type = LANE_HML_RAW;
260 ret = LaneInfoProcess(&info, &connInfo, &profile);
261 EXPECT_EQ(ret, SOFTBUS_OK);
262
263 info.type = LANE_LINK_TYPE_BUTT;
264 ret = LaneInfoProcess(&info, &connInfo, &profile);
265 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
266 }
267
268 /*
269 * @tc.name: LNN_DATA_001
270 * @tc.desc: LnnCreateData
271 * @tc.type: FUNC
272 * @tc.require:
273 */
274 HWTEST_F(LNNLaneExtMockTest, LNN_DATA_001, TestSize.Level1)
275 {
276 int32_t ret = LnnCreateData(nullptr, 32, nullptr, 0);
277 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
278 LnnDeleteData(nullptr, 32);
279 }
280
281 /*
282 * @tc.name: LNN_LANE_PROFILE_001
283 * @tc.desc: BindLaneIdToProfile
284 * @tc.type: FUNC
285 * @tc.require:
286 */
287 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_PROFILE_001, TestSize.Level1)
288 {
289 uint64_t laneId = 0x1000000000000001;
290 int32_t ret = BindLaneIdToProfile(laneId, nullptr);
291 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
292
293 LaneProfile profile = {};
294 ret = BindLaneIdToProfile(laneId, &profile);
295 EXPECT_EQ(ret, SOFTBUS_OK);
296
297 profile.linkType = LANE_P2P;
298 profile.content = LANE_T_FILE;
299 profile.priority = LANE_PRI_LOW;
300 ret = BindLaneIdToProfile(laneId, &profile);
301 EXPECT_EQ(ret, SOFTBUS_OK);
302
303 LaneGenerateParam param = {};
304 param.linkType = LANE_P2P;
305 param.transType = LANE_T_FILE;
306 param.priority = LANE_PRI_LOW;
307 uint32_t profileId = GenerateLaneProfileId(¶m);
308
309 ret = GetLaneProfile(profileId, &profile);
310 EXPECT_EQ(ret, SOFTBUS_OK);
311
312 ret = GetLaneProfile(profileId, nullptr);
313 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
314
315 uint64_t *laneReqIdList = nullptr;
316 uint32_t listSize = 0;
317 ret = GetLaneIdList(profileId, &laneReqIdList, &listSize);
318 EXPECT_EQ(ret, SOFTBUS_OK);
319 SoftBusFree(laneReqIdList);
320 (void)GetActiveProfileNum();
321 (void)UnbindLaneIdFromProfile(laneId, profileId);
322 (void)UnbindLaneIdFromProfile(0, profileId);
323 }
324
325 /*
326 * @tc.name: LNN_LANE_PROFILE_002
327 * @tc.desc: BindLaneIdToProfile
328 * @tc.type: FUNC
329 * @tc.require:
330 */
331 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_PROFILE_002, TestSize.Level1)
332 {
333 uint64_t laneId = 0x1000000000000002;
334 uint32_t profileId = 111111;
335 LaneProfile profile = {};
336 int32_t ret = GetLaneProfile(profileId, &profile);
337 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
338
339 uint64_t *laneReqIdList = nullptr;
340 uint32_t listSize = 0;
341 ret = GetLaneIdList(profileId, &laneReqIdList, &listSize);
342 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
343
344 profile.linkType = LANE_P2P;
345 profile.content = LANE_T_FILE;
346 profile.priority = LANE_PRI_LOW;
347 ret = BindLaneIdToProfile(laneId, &profile);
348 EXPECT_EQ(ret, SOFTBUS_OK);
349
350 ret = BindLaneIdToProfile(laneId, &profile);
351 EXPECT_EQ(ret, SOFTBUS_OK);
352 SoftBusFree(laneReqIdList);
353 (void)UnbindLaneIdFromProfile(laneId, profileId);
354 }
355
356 /*
357 * @tc.name: LANE_FIND_LANERESOURCE_BY_LINKADDR_001
358 * @tc.desc: LANE FIND LANERESOURCE BY LINK ADDR TEST
359 * @tc.type: FUNC
360 * @tc.require:
361 */
362 HWTEST_F(LNNLaneExtMockTest, LANE_FIND_LANERESOURCE_BY_LINKADDR_001, TestSize.Level1)
363 {
364 NiceMock<LaneDepsInterfaceMock> mock;
365 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
366 LaneLinkInfo linkInfo;
367 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
368 linkInfo.type = LANE_HML;
369 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
370 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
371
372 LaneResource laneResourse;
373 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
374 int32_t ret = FindLaneResourceByLinkAddr(nullptr, &laneResourse);
375 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
376
377 ret = FindLaneResourceByLinkAddr(&linkInfo, nullptr);
378 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
379
380 ret = FindLaneResourceByLinkAddr(&linkInfo, &laneResourse);
381 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
382
383 uint64_t laneId = LANE_ID_BASE;
384 uint32_t clientRef = 0;
385 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
386 EXPECT_EQ(ret, SOFTBUS_OK);
387 clientRef++;
388
389 LaneLinkInfo linkInfoFind;
390 ASSERT_EQ(memset_s(&linkInfoFind, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
391 linkInfoFind.type = LANE_HML;
392 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
393 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
394
395 ASSERT_EQ(strcpy_s(linkInfoFind.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
396 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
397 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
398
399 ASSERT_EQ(strcpy_s(linkInfoFind.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
400 ret = FindLaneResourceByLinkAddr(&linkInfoFind, &laneResourse);
401 EXPECT_EQ(ret, SOFTBUS_OK);
402 EXPECT_FALSE(laneResourse.isServerSide);
403 EXPECT_EQ(laneResourse.clientRef, clientRef);
404 EXPECT_EQ(laneResourse.link.type, LANE_HML);
405 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
406 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
407 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
408
409 ret = DelLaneResourceByLaneId(laneId, false);
410 EXPECT_EQ(ret, SOFTBUS_OK);
411 }
412
413 /*
414 * @tc.name: LANE_FIND_LANERESOURCE_BY_LINKTYPE_001
415 * @tc.desc: LANE FIND LANERESOURCE BY LINK TYPE TEST
416 * @tc.type: FUNC
417 * @tc.require:
418 */
419 HWTEST_F(LNNLaneExtMockTest, LANE_FIND_LANERESOURCE_BY_LINKTYPE_001, TestSize.Level1)
420 {
421 NiceMock<LaneDepsInterfaceMock> mock;
422 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
423 LaneLinkInfo linkInfo;
424 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
425 linkInfo.type = LANE_HML;
426 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
427 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
428
429 LaneResource laneResourse;
430 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
431 int32_t ret = FindLaneResourceByLinkType(nullptr, LANE_HML, &laneResourse);
432 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
433
434 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_LINK_TYPE_BUTT, &laneResourse);
435 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
436
437 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, nullptr);
438 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
439
440 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, &laneResourse);
441 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
442
443 uint64_t laneId = LANE_ID_BASE;
444 uint32_t clientRef = 0;
445 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
446 EXPECT_EQ(ret, SOFTBUS_OK);
447 clientRef++;
448
449 ret = FindLaneResourceByLinkType(LOCAL_UDID, LANE_HML, &laneResourse);
450 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
451
452 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_P2P, &laneResourse);
453 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
454
455 ret = FindLaneResourceByLinkType(PEER_UDID, LANE_HML, &laneResourse);
456 EXPECT_EQ(ret, SOFTBUS_OK);
457 EXPECT_FALSE(laneResourse.isServerSide);
458 EXPECT_EQ(laneResourse.clientRef, clientRef);
459 EXPECT_EQ(laneResourse.link.type, LANE_HML);
460 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
461 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
462 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
463
464 ret = DelLaneResourceByLaneId(laneId, false);
465 EXPECT_EQ(ret, SOFTBUS_OK);
466 }
467
468 /*
469 * @tc.name: LANE_FIND_LANERESOURCE_BY_LANEID_001
470 * @tc.desc: LANE FIND LANERESOURCE BY LANEID TEST
471 * @tc.type: FUNC
472 * @tc.require:
473 */
474 HWTEST_F(LNNLaneExtMockTest, LANE_FIND_LANERESOURCE_BY_LANEID_001, TestSize.Level1)
475 {
476 NiceMock<LaneDepsInterfaceMock> mock;
477 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
478 LaneLinkInfo linkInfo;
479 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
480 linkInfo.type = LANE_HML;
481 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
482 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
483
484 LaneResource laneResourse;
485 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
486 uint64_t laneId = INVALID_LANE_ID;
487 int32_t ret = FindLaneResourceByLaneId(laneId, nullptr);
488 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
489
490 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
491 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
492
493 laneId = LANE_ID_BASE;
494 uint32_t clientRef = 0;
495 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
496 EXPECT_EQ(ret, SOFTBUS_OK);
497 clientRef++;
498
499 ret = FindLaneResourceByLaneId(INVALID_LANE_ID, &laneResourse);
500 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
501
502 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
503 EXPECT_EQ(ret, SOFTBUS_OK);
504 EXPECT_FALSE(laneResourse.isServerSide);
505 EXPECT_EQ(laneResourse.clientRef, clientRef);
506 EXPECT_EQ(laneResourse.link.type, LANE_HML);
507 EXPECT_EQ(laneResourse.laneId, LANE_ID_BASE);
508 EXPECT_STREQ(laneResourse.link.linkInfo.p2p.connInfo.peerIp, PEER_IP_HML);
509 EXPECT_STREQ(laneResourse.link.peerUdid, PEER_UDID);
510
511 ret = DelLaneResourceByLaneId(laneId, false);
512 EXPECT_EQ(ret, SOFTBUS_OK);
513 }
514
515 /*
516 * @tc.name: LANE_DEL_AND_ADD_LANERESOURCEITEM_001
517 * @tc.desc: LANE_DEL AND ADD LANERESOURCEITEM CLIENT
518 * @tc.type: FUNC
519 * @tc.require:
520 */
521 HWTEST_F(LNNLaneExtMockTest, LANE_DEL_AND_ADD_LANERESOURCEITEM_001, TestSize.Level1)
522 {
523 NiceMock<LaneDepsInterfaceMock> mock;
524 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
525 LaneLinkInfo linkInfo;
526 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
527 linkInfo.type = LANE_HML;
528 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
529 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
530
531 uint64_t laneId = INVALID_LANE_ID;
532 int32_t ret = AddLaneResourceToPool(nullptr, laneId, false);
533 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
534 ret = AddLaneResourceToPool(&linkInfo, INVALID_LANE_ID, false);
535 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
536
537 laneId = LANE_ID_BASE;
538 uint32_t clientRef = 0;
539 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
540 EXPECT_EQ(ret, SOFTBUS_OK);
541 clientRef++;
542 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
543 EXPECT_EQ(ret, SOFTBUS_OK);
544 clientRef++;
545
546 LaneResource laneResourse;
547 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
548 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
549 EXPECT_EQ(ret, SOFTBUS_OK);
550 EXPECT_FALSE(laneResourse.isServerSide);
551 EXPECT_EQ(laneResourse.clientRef, clientRef);
552
553 ret = DelLaneResourceByLaneId(INVALID_LANE_ID, false);
554 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
555 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
556 EXPECT_EQ(laneResourse.clientRef, clientRef);
557
558 ret = DelLaneResourceByLaneId(laneId, false);
559 EXPECT_EQ(ret, SOFTBUS_OK);
560 clientRef--;
561 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
562 EXPECT_EQ(laneResourse.clientRef, clientRef);
563
564 ret = DelLaneResourceByLaneId(laneId, false);
565 EXPECT_EQ(ret, SOFTBUS_OK);
566 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
567 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
568 }
569
570 /*
571 * @tc.name: LANE_DEL_AND_ADD_LANERESOURCEITEM_002
572 * @tc.desc: LANE_DEL AND ADD LANERESOURCEITEM SERVER
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(LNNLaneExtMockTest, LANE_DEL_AND_ADD_LANERESOURCEITEM_002, TestSize.Level1)
577 {
578 NiceMock<LaneDepsInterfaceMock> mock;
579 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
580 LaneLinkInfo linkInfo;
581 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
582 linkInfo.type = LANE_HML;
583 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
584 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
585
586 uint64_t laneId = INVALID_LANE_ID;
587 int32_t ret = AddLaneResourceToPool(nullptr, laneId, true);
588 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
589
590 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
591 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
592
593 laneId = LANE_ID_BASE;
594 uint32_t serverRef = 0;
595 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
596 EXPECT_EQ(ret, SOFTBUS_OK);
597
598 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
599 EXPECT_EQ(ret, SOFTBUS_LANE_TRIGGER_LINK_FAIL);
600
601 LaneResource laneResourse;
602 ASSERT_EQ(memset_s(&laneResourse, sizeof(LaneResource), 0, sizeof(LaneResource)), EOK);
603 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
604 EXPECT_EQ(ret, SOFTBUS_OK);
605 EXPECT_TRUE(laneResourse.isServerSide);
606 EXPECT_EQ(laneResourse.clientRef, serverRef);
607
608 ret = DelLaneResourceByLaneId(laneId, false);
609 EXPECT_EQ(ret, SOFTBUS_OK);
610
611 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
612 EXPECT_EQ(ret, SOFTBUS_OK);
613
614 ret = DelLaneResourceByLaneId(laneId, true);
615 EXPECT_EQ(ret, SOFTBUS_OK);
616 }
617
618 /*
619 * @tc.name: LANE_GENERATE_LANE_ID_001
620 * @tc.desc: LANE GENERATE LANE ID
621 * @tc.type: FUNC
622 * @tc.require:
623 */
624 HWTEST_F(LNNLaneExtMockTest, LANE_GENERATE_LANE_ID_001, TestSize.Level1)
625 {
626 NiceMock<LaneDepsInterfaceMock> laneMock;
627 EXPECT_CALL(laneMock, SoftBusGenerateStrHash)
628 .WillOnce(Return(SOFTBUS_ENCRYPT_ERR))
629 .WillRepeatedly(LaneDepsInterfaceMock::ActionOfGenerateStrHash);
630
631 uint64_t laneId = GenerateLaneId(LOCAL_UDID, PEER_UDID, LANE_HML);
632 EXPECT_EQ(laneId, INVALID_LANE_ID);
633
634 laneId = GenerateLaneId(LOCAL_UDID, PEER_UDID, LANE_HML);
635 EXPECT_NE(laneId, INVALID_LANE_ID);
636 }
637
638 /*
639 * @tc.name: LANE_CLEAR_LANE_RESOURCE_BYLANEID_001
640 * @tc.desc: ClearLaneResourceByLaneId
641 * @tc.type: FUNC
642 * @tc.require:
643 */
644 HWTEST_F(LNNLaneExtMockTest, LANE_CLEAR_LANE_RESOURCE_BYLANEID_001, TestSize.Level1)
645 {
646 NiceMock<LaneDepsInterfaceMock> mock;
647 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
648
649 uint64_t laneId = LANE_ID_BASE;
650 int32_t ret = ClearLaneResourceByLaneId(laneId);
651 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
652
653 LaneLinkInfo linkInfo = {};
654 linkInfo.type = LANE_HML;
655 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
656 EXPECT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
657 uint32_t clientRef = 0;
658 ret = AddLaneResourceToPool(&linkInfo, laneId, true);
659 EXPECT_EQ(ret, SOFTBUS_OK);
660
661 LaneResource laneResourse = {};
662 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
663 EXPECT_EQ(ret, SOFTBUS_OK);
664 EXPECT_TRUE(laneResourse.isServerSide);
665 EXPECT_EQ(laneResourse.clientRef, clientRef);
666
667 ret = ClearLaneResourceByLaneId(laneId);
668 EXPECT_EQ(ret, SOFTBUS_OK);
669
670 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
671 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
672 }
673
674 /*
675 * @tc.name: LANE_PPOCESS_VAP_INFO_001
676 * @tc.desc: ProcessVapInfo hml
677 * @tc.type: FUNC
678 * @tc.require:
679 */
680 HWTEST_F(LNNLaneExtMockTest, LANE_PPOCESS_VAP_INFO_001, TestSize.Level1)
681 {
682 NiceMock<LaneDepsInterfaceMock> mock;
683 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
684 LaneLinkInfo linkInfo = {};
685 linkInfo.type = LANE_P2P;
686 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
687 EXPECT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
688 uint64_t laneId = LANE_ID_BASE;
689 uint64_t laneIdExt = LANE_ID_BASE + 1;
690 uint32_t clientRef = 0;
691 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, true);
692 EXPECT_EQ(ret, SOFTBUS_OK);
693
694 linkInfo.type = LANE_HML;
695 ret = AddLaneResourceToPool(&linkInfo, laneIdExt, false);
696 EXPECT_EQ(ret, SOFTBUS_OK);
697 clientRef++;
698
699 ret = ClearLaneResourceByLaneId(laneId);
700 EXPECT_EQ(ret, SOFTBUS_OK);
701
702 LaneResource laneResourse = {};
703 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
704 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
705
706 ret = FindLaneResourceByLaneId(laneIdExt, &laneResourse);
707 EXPECT_EQ(ret, SOFTBUS_OK);
708 EXPECT_TRUE(!laneResourse.isServerSide);
709 EXPECT_EQ(laneResourse.clientRef, clientRef);
710
711 ret = DelLaneResourceByLaneId(laneIdExt, false);
712 EXPECT_EQ(ret, SOFTBUS_OK);
713 }
714
715 /*
716 * @tc.name: LANE_PPOCESS_VAP_INFO_002
717 * @tc.desc: ProcessVapInfo p2p
718 * @tc.type: FUNC
719 * @tc.require:
720 */
721 HWTEST_F(LNNLaneExtMockTest, LANE_PPOCESS_VAP_INFO_002, TestSize.Level1)
722 {
723 NiceMock<LaneDepsInterfaceMock> mock;
724 mock.SetDefaultResult(reinterpret_cast<NodeInfo *>(&g_NodeInfo));
725 LaneLinkInfo linkInfo = {};
726 linkInfo.type = LANE_HML;
727 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
728 EXPECT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
729 uint64_t laneId = LANE_ID_BASE;
730 uint64_t laneIdExt = LANE_ID_BASE + 1;
731 uint32_t clientRef = 0;
732 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, true);
733 EXPECT_EQ(ret, SOFTBUS_OK);
734
735 linkInfo.type = LANE_P2P;
736 ret = AddLaneResourceToPool(&linkInfo, laneIdExt, false);
737 EXPECT_EQ(ret, SOFTBUS_OK);
738 clientRef++;
739
740 ret = ClearLaneResourceByLaneId(laneId);
741 EXPECT_EQ(ret, SOFTBUS_OK);
742
743 LaneResource laneResourse = {};
744 ret = FindLaneResourceByLaneId(laneId, &laneResourse);
745 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
746
747 ret = FindLaneResourceByLaneId(laneIdExt, &laneResourse);
748 EXPECT_EQ(ret, SOFTBUS_OK);
749 EXPECT_TRUE(!laneResourse.isServerSide);
750 EXPECT_EQ(laneResourse.clientRef, clientRef);
751
752 ret = DelLaneResourceByLaneId(laneIdExt, false);
753 EXPECT_EQ(ret, SOFTBUS_OK);
754 }
755
756 /*
757 * @tc.name: LNN_LANE_MAC_INFO_TEST_01
758 * @tc.desc: GetMacInfoByLaneId
759 * @tc.type: FUNC
760 * @tc.require:
761 */
762 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_MAC_INFO_TEST_01, TestSize.Level1)
763 {
764 LnnMacInfo macInfo;
765 LaneLinkInfo linkInfo;
766 linkInfo.type = LANE_P2P;
767 NiceMock<LaneDepsInterfaceMock> laneDepMock;
768 EXPECT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.localIp, IP_LEN, PEER_IP_HML), EOK);
769 EXPECT_EQ(strcpy_s(macInfo.localMac, MAX_MAC_LEN, LOCAL_MAC), EOK);
770 EXPECT_EQ(strcpy_s(macInfo.remoteMac, MAX_MAC_LEN, PEER_MAC), EOK);
771 int32_t ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
772 EXPECT_EQ(ret, SOFTBUS_OK);
773 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
774 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
775 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
776 EXPECT_EQ(ret, SOFTBUS_OK);
777
778 linkInfo.type = LANE_P2P_REUSE;
779 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
780 EXPECT_EQ(ret, SOFTBUS_OK);
781 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
782 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
783 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
784 EXPECT_EQ(ret, SOFTBUS_OK);
785
786 linkInfo.type = LANE_HML;
787 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
788 EXPECT_EQ(ret, SOFTBUS_OK);
789 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
790 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
791 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
792 EXPECT_EQ(ret, SOFTBUS_OK);
793
794 linkInfo.type = LANE_ETH;
795 ret = AddLaneResourceToPool(&linkInfo, LANE_ID_BASE, false);
796 EXPECT_EQ(ret, SOFTBUS_OK);
797 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
798 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
799 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
800 ret = DelLaneResourceByLaneId(LANE_ID_BASE, false);
801 EXPECT_EQ(ret, SOFTBUS_OK);
802 }
803
804 /*
805 * @tc.name: LNN_LANE_MAC_INFO_TEST_02
806 * @tc.desc: GetMacInfoByLaneId
807 * @tc.type: FUNC
808 * @tc.require:
809 */
810 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_MAC_INFO_TEST_02, TestSize.Level1)
811 {
812 LaneLinkInfo linkInfo;
813 NiceMock<LaneDepsInterfaceMock> laneDepMock;
814 LnnMacInfo macInfo;
815 ASSERT_EQ(memset_s(&linkInfo, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo)), EOK);
816 linkInfo.type = LANE_P2P;
817 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
818 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
819 uint64_t laneId = LANE_ID_BASE;
820 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
821 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
822 EXPECT_EQ(ret, SOFTBUS_OK);
823 EXPECT_CALL(laneDepMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
824 ret = GetMacInfoByLaneId(LANE_ID_BASE, &macInfo);
825 EXPECT_EQ(ret, SOFTBUS_OK);
826 ret = DelLaneResourceByLaneId(laneId, false);
827 EXPECT_EQ(ret, SOFTBUS_OK);
828 }
829
830 /*
831 * @tc.name: LNN_LANE_UPDATE_LANE_ID_001
832 * @tc.desc: test UpdateLaneResourceLaneId
833 * @tc.type: FUNC
834 * @tc.require:
835 */
836 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_UPDATE_LANE_ID_001, TestSize.Level1)
837 {
838 LaneLinkInfo linkInfo = {};
839 linkInfo.type = LANE_HML;
840 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
841 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
842
843 NiceMock<LaneDepsInterfaceMock> laneDepMock;
844 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
845 uint64_t laneId = LANE_ID_BASE;
846 uint64_t laneIdNew = LANE_ID_BASE + 1;
847 int32_t ret = UpdateLaneResourceLaneId(INVALID_LANE_ID, laneIdNew, PEER_UDID);
848 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
849 ret = UpdateLaneResourceLaneId(laneId, INVALID_LANE_ID, PEER_UDID);
850 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
851 ret = UpdateLaneResourceLaneId(laneId, laneIdNew, nullptr);
852 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
853 ret = UpdateLaneResourceLaneId(laneId, laneIdNew, PEER_UDID);
854 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
855 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
856 EXPECT_EQ(ret, SOFTBUS_OK);
857 ret = UpdateLaneResourceLaneId(laneId, laneIdNew, PEER_UDID);
858 EXPECT_EQ(ret, SOFTBUS_OK);
859 ret = DelLaneResourceByLaneId(laneIdNew, false);
860 EXPECT_EQ(ret, SOFTBUS_OK);
861 }
862
863 /*
864 * @tc.name: LNN_LANE_DETECT_WIFI_DIRECT_APPLY_001
865 * @tc.desc: test DetectEnableWifiDirectApply & DetectDisableWifiDirectApply
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 HWTEST_F(LNNLaneExtMockTest, LNN_LANE_DETECT_WIFI_DIRECT_APPLY_001, TestSize.Level1)
870 {
871 LnnEnhanceFuncList *pfnLnnEnhanceFuncList = LnnEnhanceFuncListGet();
872 pfnLnnEnhanceFuncList->enablePowerControl = EnablePowerControl;
873 LaneLinkInfo linkInfo = {};
874 linkInfo.type = LANE_HML;
875 linkInfo.linkInfo.p2p.bw = LANE_BW_160M;
876 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
877 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
878 NiceMock<LaneDepsInterfaceMock> laneDepMock;
879 NiceMock<LanePowerCtrlDepsInterfaceMock> powerCtrlMock;
880 struct WifiDirectManager manager = g_manager;
881 manager.getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIpError;
882 EXPECT_CALL(laneDepMock, GetWifiDirectManager)
883 .WillOnce(Return(nullptr))
884 .WillOnce(Return(&manager))
885 .WillRepeatedly(Return(&g_manager));
886 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
887 EXPECT_CALL(powerCtrlMock, IsPowerControlEnabled).WillRepeatedly(Return(true));
888 EXPECT_CALL(powerCtrlMock, EnablePowerControl)
889 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
890 .WillRepeatedly(Return(SOFTBUS_OK));
891
892 uint64_t laneId = LANE_ID_BASE;
893 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
894 EXPECT_EQ(ret, SOFTBUS_OK);
895 DetectEnableWifiDirectApply();
896 DetectDisableWifiDirectApply();
897 DetectEnableWifiDirectApply();
898 DetectDisableWifiDirectApply();
899 ret = DelLaneResourceByLaneId(laneId, false);
900 EXPECT_EQ(ret, SOFTBUS_OK);
901
902 linkInfo.linkInfo.p2p.bw = LANE_BW_80P80M;
903 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
904 EXPECT_EQ(ret, SOFTBUS_OK);
905 DetectEnableWifiDirectApply();
906 DetectDisableWifiDirectApply();
907 uint64_t laneIdRaw = LANE_ID_BASE + 1;
908 linkInfo.type = LANE_HML_RAW;
909 ret = AddLaneResourceToPool(&linkInfo, laneIdRaw, false);
910 EXPECT_EQ(ret, SOFTBUS_OK);
911 DetectEnableWifiDirectApply();
912 ret = DelLaneResourceByLaneId(laneIdRaw, false);
913 EXPECT_EQ(ret, SOFTBUS_OK);
914 ret = DelLaneResourceByLaneId(laneId, false);
915 EXPECT_EQ(ret, SOFTBUS_OK);
916 }
917
918 /*
919 * @tc.name: LNN_CHECK_LANE_RESOURCE_NUM_001
920 * @tc.desc: test CheckLaneResourceNumByLinkType
921 * @tc.type: FUNC
922 * @tc.require:
923 */
924 HWTEST_F(LNNLaneExtMockTest, LNN_CHECK_LANE_RESOURCE_NUM_001, TestSize.Level1)
925 {
926 LaneLinkInfo linkInfo = {};
927 linkInfo.type = LANE_HML;
928 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
929 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
930 NiceMock<LaneDepsInterfaceMock> laneDepMock;
931 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
932
933 int32_t laneNum = 0;
934 int32_t ret = CheckLaneResourceNumByLinkType(nullptr, LANE_HML, &laneNum);
935 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
936 ret = CheckLaneResourceNumByLinkType(nullptr, LANE_LINK_TYPE_BUTT, &laneNum);
937 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
938 ret = CheckLaneResourceNumByLinkType(PEER_UDID, LANE_HML, &laneNum);
939 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
940 uint64_t laneId = LANE_ID_BASE;
941 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
942 EXPECT_EQ(ret, SOFTBUS_OK);
943 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
944 EXPECT_EQ(ret, SOFTBUS_OK);
945 ret = CheckLaneResourceNumByLinkType(PEER_UDID, LANE_HML, &laneNum);
946 EXPECT_EQ(ret, SOFTBUS_OK);
947 ret = DelLaneResourceByLaneId(laneId, false);
948 EXPECT_EQ(ret, SOFTBUS_OK);
949 ret = DelLaneResourceByLaneId(laneId, false);
950 EXPECT_EQ(ret, SOFTBUS_OK);
951 }
952
953 /*
954 * @tc.name: LNN_ADD_LANE_IS_VALID_LINK_ADDR_001
955 * @tc.desc: test IsValidLinkAddr(hml/br/ble)
956 * @tc.type: FUNC
957 * @tc.require:
958 */
959 HWTEST_F(LNNLaneExtMockTest, LNN_ADD_LANE_IS_VALID_LINK_ADDR_001, TestSize.Level1)
960 {
961 NiceMock<LaneDepsInterfaceMock> laneDepMock;
962 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
963
964 LaneLinkInfo linkInfo = {};
965 linkInfo.type = LANE_HML;
966 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
967 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.br.brMac, BT_MAC_LEN, PEER_MAC), EOK);
968 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.ble.bleMac, BT_MAC_LEN, PEER_MAC), EOK);
969 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
970 uint64_t laneId = LANE_ID_BASE;
971 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
972 EXPECT_EQ(ret, SOFTBUS_OK);
973 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
974 EXPECT_EQ(ret, SOFTBUS_OK);
975 ret = DelLaneResourceByLaneId(laneId, false);
976 EXPECT_EQ(ret, SOFTBUS_OK);
977 ret = DelLaneResourceByLaneId(laneId, false);
978 EXPECT_EQ(ret, SOFTBUS_OK);
979
980 linkInfo.type = LANE_BR;
981 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
982 EXPECT_EQ(ret, SOFTBUS_OK);
983 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
984 EXPECT_EQ(ret, SOFTBUS_OK);
985 ret = DelLaneResourceByLaneId(laneId, false);
986 EXPECT_EQ(ret, SOFTBUS_OK);
987 ret = DelLaneResourceByLaneId(laneId, false);
988 EXPECT_EQ(ret, SOFTBUS_OK);
989
990 linkInfo.type = LANE_BLE;
991 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
992 EXPECT_EQ(ret, SOFTBUS_OK);
993 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
994 EXPECT_EQ(ret, SOFTBUS_OK);
995 ret = DelLaneResourceByLaneId(laneId, false);
996 EXPECT_EQ(ret, SOFTBUS_OK);
997 ret = DelLaneResourceByLaneId(laneId, false);
998 EXPECT_EQ(ret, SOFTBUS_OK);
999 }
1000
1001 /*
1002 * @tc.name: LNN_ADD_LANE_IS_VALID_LINK_ADDR_002
1003 * @tc.desc: test IsValidLinkAddr(coc_direct/wlan)
1004 * @tc.type: FUNC
1005 * @tc.require:
1006 */
1007 HWTEST_F(LNNLaneExtMockTest, LNN_ADD_LANE_IS_VALID_LINK_ADDR_002, TestSize.Level1)
1008 {
1009 NiceMock<LaneDepsInterfaceMock> laneDepMock;
1010 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1011
1012 LaneLinkInfo linkInfo = {};
1013 linkInfo.type = LANE_COC_DIRECT;
1014 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, PEER_WLAN_ADDR), EOK);
1015 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.bleDirect.networkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID), EOK);
1016 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1017 uint64_t laneId = LANE_ID_BASE;
1018 int32_t ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1019 EXPECT_EQ(ret, SOFTBUS_OK);
1020 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1021 EXPECT_EQ(ret, SOFTBUS_OK);
1022 ret = DelLaneResourceByLaneId(laneId, false);
1023 EXPECT_EQ(ret, SOFTBUS_OK);
1024 ret = DelLaneResourceByLaneId(laneId, false);
1025 EXPECT_EQ(ret, SOFTBUS_OK);
1026
1027 linkInfo.type = LANE_WLAN_5G;
1028 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1029 EXPECT_EQ(ret, SOFTBUS_OK);
1030 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1031 EXPECT_EQ(ret, SOFTBUS_OK);
1032 ret = DelLaneResourceByLaneId(laneId, false);
1033 EXPECT_EQ(ret, SOFTBUS_OK);
1034 ret = DelLaneResourceByLaneId(laneId, false);
1035 EXPECT_EQ(ret, SOFTBUS_OK);
1036
1037 linkInfo.type = LANE_LINK_TYPE_BUTT;
1038 ret = AddLaneResourceToPool(&linkInfo, laneId, false);
1039 EXPECT_EQ(ret, SOFTBUS_OK);
1040 ret = DelLaneResourceByLaneId(laneId, false);
1041 EXPECT_EQ(ret, SOFTBUS_OK);
1042 }
1043
1044 /*
1045 * @tc.name: CHECK_LANE_LINK_EXIST_BY_TYPE_001
1046 * @tc.desc: test CheckLaneLinkExistByType
1047 * @tc.type: FUNC
1048 * @tc.require:
1049 */
1050 HWTEST_F(LNNLaneExtMockTest, CHECK_LANE_LINK_EXIST_BY_TYPE_001, TestSize.Level1)
1051 {
1052 EXPECT_FALSE(CheckLaneLinkExistByType(LANE_LINK_TYPE_BUTT));
1053 EXPECT_FALSE(CheckLaneLinkExistByType(LANE_HML));
1054
1055 NiceMock<LaneDepsInterfaceMock> laneDepMock;
1056 EXPECT_CALL(laneDepMock, LnnGetLocalStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1057 LaneLinkInfo linkInfo = { .type = LANE_HML };
1058 ASSERT_EQ(strcpy_s(linkInfo.linkInfo.p2p.connInfo.peerIp, IP_LEN, PEER_IP_HML), EOK);
1059 ASSERT_EQ(strcpy_s(linkInfo.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1060 uint64_t laneId = LANE_ID_BASE;
1061 EXPECT_EQ(SOFTBUS_OK, AddLaneResourceToPool(&linkInfo, laneId, false));
1062 EXPECT_TRUE(CheckLaneLinkExistByType(LANE_HML));
1063 EXPECT_EQ(SOFTBUS_OK, DelLaneResourceByLaneId(laneId, false));
1064 }
1065
1066 struct SelectProtocolReq {
1067 LnnNetIfType localIfType;
1068 ProtocolType selectedProtocol;
1069 ProtocolType remoteSupporttedProtocol;
1070 uint8_t currPri;
1071 };
1072
MockLnnVisitPhysicalSubnet(LnnVisitPhysicalSubnetCallback callback,void * data)1073 static bool MockLnnVisitPhysicalSubnet(LnnVisitPhysicalSubnetCallback callback, void *data)
1074 {
1075 if (callback == nullptr || data == nullptr) {
1076 return false;
1077 }
1078 LnnProtocolManager protocol = {
1079 .supportedNetif = LNN_NETIF_TYPE_USB,
1080 .pri = PRI,
1081 .id = LNN_PROTOCOL_ALL,
1082 };
1083 LnnPhysicalSubnet subnet = {
1084 .protocol = &protocol,
1085 .status = LNN_SUBNET_RUNNING,
1086 };
1087 struct SelectProtocolReq *req = (struct SelectProtocolReq *)data;
1088 req->selectedProtocol = LNN_PROTOCOL_USB;
1089 req->remoteSupporttedProtocol = LNN_PROTOCOL_USB;
1090 if (callback(nullptr, data) != CHOICE_FINISH_VISITING) {
1091 return false;
1092 }
1093 if (callback(&subnet, nullptr) != CHOICE_FINISH_VISITING) {
1094 return false;
1095 }
1096 if (callback(&subnet, data) != CHOICE_VISIT_NEXT) {
1097 return false;
1098 }
1099 req->selectedProtocol = LNN_PROTOCOL_USB;
1100 return true;
1101 }
1102
1103 /*
1104 * @tc.name: BUILD_LINK_TEST_001
1105 * @tc.desc: BuildLink test linkType is LANE_USB
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
1109 HWTEST_F(LNNLaneExtMockTest, BUILD_LINK_TEST_001, TestSize.Level1)
1110 {
1111 NiceMock<LaneDepsInterfaceMock> mock;
1112 LinkRequest reqInfo = {
1113 .linkType = LANE_USB,
1114 .transType = LANE_T_FILE,
1115 };
1116 LaneLinkCb cb = {
1117 .onLaneLinkSuccess = OnLaneLinkSuccess,
1118 .onLaneLinkFail = OnLaneLinkFail,
1119 };
1120 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_OK)).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
1121 int32_t ret = BuildLink(&reqInfo, 0, &cb);
1122 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1123
1124 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_INVALID_PARAM)).WillRepeatedly(Return(SOFTBUS_OK));
1125 reqInfo.transType = LANE_T_BYTE;
1126 ret = BuildLink(&reqInfo, 0, &cb);
1127 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1128 reqInfo.transType = LANE_T_MSG;
1129 reqInfo.isInnerCalled = true;
1130 ret = BuildLink(&reqInfo, 0, &cb);
1131 EXPECT_EQ(ret, SOFTBUS_OK);
1132
1133 EXPECT_CALL(mock, LnnVisitPhysicalSubnet).WillRepeatedly(Invoke(MockLnnVisitPhysicalSubnet));
1134 reqInfo.isInnerCalled = false;
1135 ret = BuildLink(&reqInfo, 0, &cb);
1136 EXPECT_EQ(ret, SOFTBUS_OK);
1137
1138 EXPECT_CALL(mock, LnnGetRemoteNumInfoByIfnameIdx)
1139 .WillOnce(Return(SOFTBUS_INVALID_PARAM))
1140 .WillRepeatedly(Return(SOFTBUS_OK));
1141 ret = BuildLink(&reqInfo, 0, &cb);
1142 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1143
1144 EXPECT_CALL(mock, LnnGetLocalNodeInfo).WillOnce(Return(nullptr)).WillRepeatedly(Return(&g_NodeInfo));
1145 ret = BuildLink(&reqInfo, 0, &cb);
1146 EXPECT_EQ(ret, SOFTBUS_OK);
1147 ret = BuildLink(&reqInfo, 0, &cb);
1148 EXPECT_EQ(ret, SOFTBUS_LANE_GET_LEDGER_INFO_ERR);
1149 }
1150
1151 /*
1152 * @tc.name: GET_ALL_LINK_WITH_DEVID_TEST_001
1153 * @tc.desc: GetAllLinkWithDevId test
1154 * @tc.type: FUNC
1155 * @tc.require:
1156 */
1157 HWTEST_F(LNNLaneExtMockTest, GET_ALL_LINK_WITH_DEVID_TEST_001, TestSize.Level1)
1158 {
1159 LaneLinkType *linkList = nullptr;
1160 uint8_t linkCnt = 0;
1161 int32_t ret = GetAllLinkWithDevId(nullptr, &linkList, &linkCnt);
1162 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1163 ret = GetAllLinkWithDevId(PEER_UDID, nullptr, &linkCnt);
1164 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1165 ret = GetAllLinkWithDevId(PEER_UDID, &linkList, nullptr);
1166 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1167 ret = GetAllLinkWithDevId(PEER_UDID, &linkList, &linkCnt);
1168 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
1169
1170 LaneLinkInfo info = {};
1171 ASSERT_EQ(strcpy_s(info.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1172 uint64_t laneId = 1;
1173 info.type = LANE_USB;
1174 NiceMock<LaneDepsInterfaceMock> mock;
1175 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1176 ret = AddLaneResourceToPool(&info, laneId, false);
1177 EXPECT_EQ(ret, SOFTBUS_OK);
1178
1179 ret = GetAllLinkWithDevId(PEER_UDID, &linkList, &linkCnt);
1180 ASSERT_NE(linkList, nullptr);
1181 EXPECT_EQ(ret, SOFTBUS_OK);
1182 SoftBusFree(linkList);
1183
1184 ret = ClearLaneResourceByLaneId(laneId);
1185 EXPECT_EQ(ret, SOFTBUS_OK);
1186 }
1187
1188 /*
1189 * @tc.name: GET_ALL_LINK_WITH_LINK_TYPE_TEST_001
1190 * @tc.desc: GetAllDevIdWithLinkType test
1191 * @tc.type: FUNC
1192 * @tc.require:
1193 */
1194 HWTEST_F(LNNLaneExtMockTest, GET_ALL_LINK_WITH_LINK_TYPE_TEST_001, TestSize.Level1)
1195 {
1196 char *linkList = nullptr;
1197 uint8_t linkCnt = 0;
1198 int32_t ret = GetAllDevIdWithLinkType(LANE_LINK_TYPE_BUTT, &linkList, &linkCnt);
1199 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1200 ret = GetAllDevIdWithLinkType(LANE_HML, nullptr, &linkCnt);
1201 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1202 ret = GetAllDevIdWithLinkType(LANE_HML, &linkList, nullptr);
1203 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1204 ret = GetAllDevIdWithLinkType(LANE_HML, &linkList, &linkCnt);
1205 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
1206
1207 LaneLinkInfo info = {};
1208 ASSERT_EQ(strcpy_s(info.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1209 uint64_t laneId = 1;
1210 info.type = LANE_HML;
1211 NiceMock<LaneDepsInterfaceMock> mock;
1212 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1213 ret = AddLaneResourceToPool(&info, laneId, false);
1214 EXPECT_EQ(ret, SOFTBUS_OK);
1215
1216 ret = GetAllDevIdWithLinkType(LANE_HML, &linkList, &linkCnt);
1217 ASSERT_NE(linkList, nullptr);
1218 EXPECT_EQ(ret, SOFTBUS_OK);
1219 SoftBusFree(linkList);
1220
1221 ret = ClearLaneResourceByLaneId(laneId);
1222 EXPECT_EQ(ret, SOFTBUS_OK);
1223 }
1224
1225 /*
1226 * @tc.name: GET_VALID_LANE_RESOURCE_TEST_001
1227 * @tc.desc: GetValidLaneResource test
1228 * @tc.type: FUNC
1229 * @tc.require:
1230 */
1231 HWTEST_F(LNNLaneExtMockTest, GET_VALID_LANE_RESOURCE_TEST_001, TestSize.Level1)
1232 {
1233 LaneLinkInfo info = {};
1234 ASSERT_EQ(strcpy_s(info.peerUdid, UDID_BUF_LEN, PEER_UDID), EOK);
1235 uint64_t laneId = 1;
1236 info.type = LANE_USB;
1237 NiceMock<LaneDepsInterfaceMock> mock;
1238 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1239 int32_t ret = AddLaneResourceToPool(&info, laneId, false);
1240 EXPECT_EQ(ret, SOFTBUS_OK);
1241 LaneResource resource = {0};
1242 ret = FindLaneResourceByLinkAddr(&info, &resource);
1243 EXPECT_EQ(ret, SOFTBUS_OK);
1244 ret = ClearLaneResourceByLaneId(laneId);
1245 EXPECT_EQ(ret, SOFTBUS_OK);
1246
1247 info.type = LANE_BLE_REUSE;
1248 ret = AddLaneResourceToPool(&info, laneId, false);
1249 EXPECT_EQ(ret, SOFTBUS_OK);
1250 ret = FindLaneResourceByLinkAddr(&info, &resource);
1251 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
1252 ret = ClearLaneResourceByLaneId(laneId);
1253 EXPECT_EQ(ret, SOFTBUS_OK);
1254
1255 info.type = LANE_SLE;
1256 ret = AddLaneResourceToPool(&info, laneId, false);
1257 EXPECT_EQ(ret, SOFTBUS_OK);
1258 ret = FindLaneResourceByLinkAddr(&info, &resource);
1259 EXPECT_EQ(ret, SOFTBUS_OK);
1260 ret = ClearLaneResourceByLaneId(laneId);
1261 EXPECT_EQ(ret, SOFTBUS_OK);
1262
1263 info.type = LANE_SLE_DIRECT;
1264 ret = AddLaneResourceToPool(&info, laneId, false);
1265 EXPECT_EQ(ret, SOFTBUS_OK);
1266 ret = FindLaneResourceByLinkAddr(&info, &resource);
1267 EXPECT_EQ(ret, SOFTBUS_OK);
1268 ret = ClearLaneResourceByLaneId(laneId);
1269 EXPECT_EQ(ret, SOFTBUS_OK);
1270 }
1271 } // namespace OHOS