1 /*
2 * Copyright (c) 2022 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
20 #include "bus_center_info_key.h"
21 #include "lnn_lane_common.h"
22 #include "lnn_lane_deps_mock.h"
23 #include "lnn_lane_def.h"
24 #include "lnn_lane.h"
25 #include "lnn_lane_interface.h"
26 #include "lnn_lane_link.h"
27 #include "lnn_lane_link_proc.h"
28 #include "lnn_lane_model.h"
29 #include "lnn_lane_select.h"
30 #include "lnn_wifi_adpter_mock.h"
31 #include "message_handler.h"
32 #include "softbus_adapter_mem.h"
33 #include "softbus_adapter_thread.h"
34 #include "softbus_error_code.h"
35 #include "softbus_wifi_api_adapter.h"
36
37 namespace OHOS {
38 using namespace testing::ext;
39 using namespace testing;
40
41 constexpr char NODE_NETWORK_ID[] = "111122223333abcdef";
42 constexpr uint32_t DEFAULT_SELECT_NUM = 4;
43
44 static SoftBusCond g_cond = {0};
45 static SoftBusMutex g_lock = {0};
46
47 static void OnLaneRequestSuccess(uint32_t laneId, const LaneConnInfo *info);
48 static void OnLaneRequestFail(uint32_t laneId, LaneRequestFailReason reason);
49 static void OnLaneStateChange(uint32_t laneId, LaneState state);
50 static ILaneListener g_listener = {
51 .OnLaneRequestSuccess = OnLaneRequestSuccess,
52 .OnLaneRequestFail = OnLaneRequestFail,
53 .OnLaneStateChange = OnLaneStateChange,
54 };
55
56 class LNNLaneTestMock : public testing::Test {
57 public:
58 static void SetUpTestCase();
59 static void TearDownTestCase();
60 void SetUp();
61 void TearDown();
62 };
63
SetUpTestCase()64 void LNNLaneTestMock::SetUpTestCase()
65 {
66 int32_t ret = LooperInit();
67 EXPECT_TRUE(ret == SOFTBUS_OK);
68 ret = InitLane();
69 EXPECT_TRUE(ret == SOFTBUS_OK);
70 GTEST_LOG_(INFO) << "LNNLaneTestMock start";
71 }
72
TearDownTestCase()73 void LNNLaneTestMock::TearDownTestCase()
74 {
75 DeinitLane();
76 LooperDeinit();
77 GTEST_LOG_(INFO) << "LNNLaneTestMock end";
78 }
79
SetUp()80 void LNNLaneTestMock::SetUp()
81 {
82 (void)SoftBusMutexInit(&g_lock, nullptr);
83 (void)SoftBusCondInit(&g_cond);
84 }
85
TearDown()86 void LNNLaneTestMock::TearDown()
87 {
88 (void)SoftBusCondDestroy(&g_cond);
89 (void)SoftBusCondDestroy(&g_lock);
90 }
91
CondSignal(void)92 static void CondSignal(void)
93 {
94 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
95 return;
96 }
97 if (SoftBusCondSignal(&g_cond) != SOFTBUS_OK) {
98 (void)SoftBusMutexUnlock(&g_lock);
99 return;
100 }
101 (void)SoftBusMutexUnlock(&g_lock);
102 }
103
CondWait(void)104 static void CondWait(void)
105 {
106 if (SoftBusMutexLock(&g_lock) != SOFTBUS_OK) {
107 return;
108 }
109 if (SoftBusCondWait(&g_cond, &g_lock, nullptr) != SOFTBUS_OK) {
110 (void)SoftBusMutexUnlock(&g_lock);
111 return;
112 }
113 (void)SoftBusMutexUnlock(&g_lock);
114 }
115
OnLaneRequestSuccess(uint32_t laneId,const LaneConnInfo * info)116 static void OnLaneRequestSuccess(uint32_t laneId, const LaneConnInfo *info)
117 {
118 int32_t ret = LnnFreeLane(laneId);
119 EXPECT_TRUE(ret == SOFTBUS_OK);
120 CondSignal();
121 }
122
OnLaneRequestFail(uint32_t laneId,LaneRequestFailReason reason)123 static void OnLaneRequestFail(uint32_t laneId, LaneRequestFailReason reason)
124 {
125 int32_t ret = LnnFreeLane(laneId);
126 EXPECT_TRUE(ret == SOFTBUS_OK);
127 CondSignal();
128 }
129
OnLaneStateChange(uint32_t laneId,LaneState state)130 static void OnLaneStateChange(uint32_t laneId, LaneState state)
131 {
132 int32_t ret = LnnFreeLane(laneId);
133 EXPECT_TRUE(ret == SOFTBUS_OK);
134 CondSignal();
135 }
136
137 /*
138 * @tc.name: LANE_REQUEST_Test_001
139 * @tc.desc: lane request for Wlan2p4G MSG
140 * @tc.type: FUNC
141 * @tc.require:
142 */
143 HWTEST_F(LNNLaneTestMock, LANE_REQUEST_Test_001, TestSize.Level1)
144 {
145 LaneType laneType = LANE_TYPE_TRANS;
146 uint32_t laneId = ApplyLaneId(laneType);
147 EXPECT_TRUE(laneId != INVALID_LANE_ID);
148
149 LaneDepsInterfaceMock mock;
150 mock.SetDefaultResult();
151 EXPECT_CALL(mock, LnnGetLocalNumInfo)
152 .WillRepeatedly(DoAll(SetArgPointee<1>(16), Return(SOFTBUS_OK)));
153 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
154 .WillRepeatedly(DoAll(SetArgPointee<2>(16), Return(SOFTBUS_OK)));
155 LnnWifiAdpterInterfaceMock wifiMock;
156 wifiMock.SetDefaultResult();
157
158 LaneRequestOption requestOption;
159 (void)memset_s(&requestOption, sizeof(LaneRequestOption), 0, sizeof(LaneRequestOption));
160 requestOption.type = laneType;
161 (void)strncpy_s(requestOption.requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
162 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
163 requestOption.requestInfo.trans.transType = LANE_T_MSG;
164 requestOption.requestInfo.trans.expectedBw = 0;
165 int32_t ret = LnnRequestLane(laneId, &requestOption, &g_listener);
166 EXPECT_EQ(ret, SOFTBUS_OK);
167 CondWait();
168 }
169
170 /*
171 * @tc.name: LANE_REQUEST_Test_002
172 * @tc.desc: lane request for Wlan5G byte
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(LNNLaneTestMock, LANE_REQUEST_Test_002, TestSize.Level1)
177 {
178 LaneType laneType = LANE_TYPE_TRANS;
179 uint32_t laneId = ApplyLaneId(laneType);
180 EXPECT_TRUE(laneId != INVALID_LANE_ID);
181
182 LaneDepsInterfaceMock mock;
183 mock.SetDefaultResult();
184 EXPECT_CALL(mock, LnnGetLocalNumInfo)
185 .WillRepeatedly(DoAll(SetArgPointee<1>(32), Return(SOFTBUS_OK)));
186 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
187 .WillRepeatedly(DoAll(SetArgPointee<2>(32), Return(SOFTBUS_OK)));
188 LnnWifiAdpterInterfaceMock wifiMock;
189 wifiMock.SetDefaultResult();
190
191 LaneRequestOption requestOption;
192 (void)memset_s(&requestOption, sizeof(LaneRequestOption), 0, sizeof(LaneRequestOption));
193 requestOption.type = laneType;
194 (void)strncpy_s(requestOption.requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
195 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
196 requestOption.requestInfo.trans.transType = LANE_T_BYTE;
197 requestOption.requestInfo.trans.expectedBw = 0;
198 int32_t ret = LnnRequestLane(laneId, &requestOption, &g_listener);
199 EXPECT_EQ(ret, SOFTBUS_OK);
200 CondWait();
201 }
202
203 /*
204 * @tc.name: LANE_REQUEST_Test_003
205 * @tc.desc: lane request for Wlan5G RAW-STREAM
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(LNNLaneTestMock, LANE_REQUEST_Test_003, TestSize.Level1)
210 {
211 LaneType laneType = LANE_TYPE_TRANS;
212 uint32_t laneId = ApplyLaneId(laneType);
213 EXPECT_TRUE(laneId != INVALID_LANE_ID);
214
215 LaneDepsInterfaceMock mock;
216 mock.SetDefaultResult();
217 EXPECT_CALL(mock, LnnGetLocalNumInfo)
218 .WillRepeatedly(DoAll(SetArgPointee<1>(32), Return(SOFTBUS_OK)));
219 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
220 .WillRepeatedly(DoAll(SetArgPointee<2>(32), Return(SOFTBUS_OK)));
221 LnnWifiAdpterInterfaceMock wifiMock;
222 wifiMock.SetDefaultResult();
223
224 LaneRequestOption requestOption;
225 (void)memset_s(&requestOption, sizeof(LaneRequestOption), 0, sizeof(LaneRequestOption));
226 requestOption.type = laneType;
227 (void)strncpy_s(requestOption.requestInfo.trans.networkId, NETWORK_ID_BUF_LEN,
228 NODE_NETWORK_ID, strlen(NODE_NETWORK_ID));
229 requestOption.requestInfo.trans.transType = LANE_T_RAW_STREAM;
230 requestOption.requestInfo.trans.expectedBw = 0;
231 int32_t ret = LnnRequestLane(laneId, &requestOption, &g_listener);
232 EXPECT_EQ(ret, SOFTBUS_OK);
233 CondWait();
234 }
235
236 /*
237 * @tc.name: LANE_REQUEST_Test_004
238 * @tc.desc: lane request failue
239 * @tc.type: FAILUE
240 * @tc.require:
241 */
242 HWTEST_F(LNNLaneTestMock, LANE_REQUEST_Test_004, TestSize.Level1)
243 {
244 LaneType laneType = LANE_TYPE_TRANS;
245 uint32_t laneId = ApplyLaneId(laneType);
246 EXPECT_TRUE(laneId != INVALID_LANE_ID);
247 LaneRequestOption requestOption;
248 (void)memset_s(&requestOption, sizeof(LaneRequestOption), 0, sizeof(LaneRequestOption));
249 requestOption.type = LANE_TYPE_BUTT;
250 int32_t ret = LnnRequestLane(laneId, &requestOption, nullptr);
251 EXPECT_EQ(ret, SOFTBUS_ERR);
252 ret = LnnRequestLane(laneId, nullptr, &g_listener);
253 EXPECT_EQ(ret, SOFTBUS_ERR);
254 laneId = 0xFFFFFFFF;
255 ret = LnnRequestLane(laneId, &requestOption, &g_listener);
256 EXPECT_EQ(ret, SOFTBUS_ERR);
257 requestOption.type = LANE_TYPE_BUTT;
258 ret = LnnRequestLane(laneId, &requestOption, &g_listener);
259 EXPECT_EQ(ret, SOFTBUS_ERR);
260 }
261
262 /*
263 * @tc.name: LANE_FREE_001
264 * @tc.desc: lane free
265 * @tc.type: FUNC
266 * @tc.require:
267 */
268 HWTEST_F(LNNLaneTestMock, LANE_FREE_001, TestSize.Level1)
269 {
270 LaneType laneType = LANE_TYPE_BUTT;
271 uint32_t laneId = ApplyLaneId(laneType);
272 int32_t ret = LnnFreeLane(laneId);
273 EXPECT_EQ(ret, SOFTBUS_ERR);
274
275 laneType = LANE_TYPE_TRANS;
276 laneId = ApplyLaneId(laneType);
277 EXPECT_TRUE(laneId != INVALID_LANE_ID);
278 ret = LnnFreeLane(laneId);
279 EXPECT_EQ(ret, SOFTBUS_OK);
280 ret = LnnFreeLane(laneId);
281 EXPECT_EQ(ret, SOFTBUS_OK);
282 }
283
LaneIdEnabled(uint32_t laneId,uint32_t laneProfileId)284 static void LaneIdEnabled(uint32_t laneId, uint32_t laneProfileId)
285 {
286 return;
287 }
288
289 /*
290 * @tc.name: LANE_REGISTER_001
291 * @tc.desc: lane register
292 * @tc.type: FAILUE
293 * @tc.require:
294 */
295 HWTEST_F(LNNLaneTestMock, LANE_REGISTER_001, TestSize.Level1)
296 {
297 RegisterLaneIdListener(nullptr);
298
299 const ILaneIdStateListener cb = {
300 .OnLaneIdEnabled = LaneIdEnabled,
301 .OnLaneIdDisabled = nullptr,
302 };
303 RegisterLaneIdListener(&cb);
304
305 const ILaneIdStateListener listener = {
306 .OnLaneIdEnabled = nullptr,
307 .OnLaneIdDisabled = LaneIdEnabled,
308 };
309 RegisterLaneIdListener(&listener);
310
311 UnregisterLaneIdListener(nullptr);
312 }
313
314 /*
315 * @tc.name: LANE_INFO_001
316 * @tc.desc: LaneInfoProcess BR
317 * @tc.type: FUNC
318 * @tc.require:
319 */
320 HWTEST_F(LNNLaneTestMock, LANE_INFO_001, TestSize.Level1)
321 {
322 LaneLinkInfo info;
323 (void)memset_s(&info, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo));
324 info.type = LANE_BR;
325 LaneConnInfo connInfo;
326 (void)memset_s(&connInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
327 LaneProfile profile;
328 (void)memset_s(&profile, sizeof(LaneProfile), 0, sizeof(LaneProfile));
329 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
330 EXPECT_EQ(ret, SOFTBUS_OK);
331 }
332
333 /*
334 * @tc.name: LANE_INFO_002
335 * @tc.desc: LaneInfoProcess BLE
336 * @tc.type: FUNC
337 * @tc.require:
338 */
339 HWTEST_F(LNNLaneTestMock, LANE_INFO_002, TestSize.Level1)
340 {
341 LaneLinkInfo info;
342 (void)memset_s(&info, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo));
343 info.type = LANE_BLE;
344 LaneConnInfo connInfo;
345 (void)memset_s(&connInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
346 LaneProfile profile;
347 (void)memset_s(&profile, sizeof(LaneProfile), 0, sizeof(LaneProfile));
348 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
349 EXPECT_EQ(ret, SOFTBUS_OK);
350 }
351
352 /*
353 * @tc.name: LANE_INFO_003
354 * @tc.desc: LaneInfoProcess P2P
355 * @tc.type: FUNC
356 * @tc.require:
357 */
358 HWTEST_F(LNNLaneTestMock, LANE_INFO_003, TestSize.Level1)
359 {
360 LaneLinkInfo info;
361 (void)memset_s(&info, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo));
362 info.type = LANE_P2P;
363 LaneConnInfo connInfo;
364 (void)memset_s(&connInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
365 LaneProfile profile;
366 (void)memset_s(&profile, sizeof(LaneProfile), 0, sizeof(LaneProfile));
367 int32_t ret = LaneInfoProcess(&info, &connInfo, &profile);
368 EXPECT_EQ(ret, SOFTBUS_OK);
369 }
370
371 /*
372 * @tc.name: LANE_INFO_004
373 * @tc.desc: LaneInfoProcess fail
374 * @tc.type: FAILUE
375 * @tc.require:
376 */
377 HWTEST_F(LNNLaneTestMock, LANE_INFO_004, TestSize.Level1)
378 {
379 LaneLinkInfo info;
380 (void)memset_s(&info, sizeof(LaneLinkInfo), 0, sizeof(LaneLinkInfo));
381 info.type = LANE_LINK_TYPE_BUTT;
382 LaneConnInfo *connInfo = nullptr;
383 LaneProfile *profile = nullptr;
384 int32_t ret = LaneInfoProcess(nullptr, connInfo, profile);
385 EXPECT_EQ(ret, SOFTBUS_ERR);
386
387 ret = LaneInfoProcess(&info, nullptr, profile);
388 EXPECT_EQ(ret, SOFTBUS_ERR);
389
390 ret = LaneInfoProcess(&info, connInfo, nullptr);
391 EXPECT_EQ(ret, SOFTBUS_ERR);
392
393 ret = LaneInfoProcess(&info, connInfo, profile);
394 EXPECT_EQ(ret, SOFTBUS_ERR);
395 }
396
397 /*
398 * @tc.name: LNN_DATA_001
399 * @tc.desc: LnnCreateData
400 * @tc.type: FUNC
401 * @tc.require:
402 */
403 HWTEST_F(LNNLaneTestMock, LNN_DATA_001, TestSize.Level1)
404 {
405 int32_t ret = LnnCreateData(nullptr, 32, nullptr, 0);
406 EXPECT_EQ(ret, SOFTBUS_ERR);
407
408 LnnDeleteData(nullptr, 32);
409 }
410
411 /*
412 * @tc.name: LNN_GET_TIME_001
413 * @tc.desc: LnnGetSysTimeMs
414 * @tc.type: FUNC
415 * @tc.require:
416 */
417 HWTEST_F(LNNLaneTestMock, LNN_GET_TIME_001, TestSize.Level1)
418 {
419 LnnGetSysTimeMs();
420 }
421
422 /*
423 * @tc.name: LNN_LANE_PROFILE_001
424 * @tc.desc: BindLaneIdToProfile
425 * @tc.type: FUNC
426 * @tc.require:
427 */
428 HWTEST_F(LNNLaneTestMock, LNN_LANE_PROFILE_001, TestSize.Level1)
429 {
430 uint32_t laneId = 0x10000001;
431 int32_t ret = BindLaneIdToProfile(laneId, nullptr);
432 EXPECT_EQ(ret, SOFTBUS_ERR);
433
434 LaneProfile profile;
435 (void)memset_s(&profile, sizeof(LaneProfile), 0, sizeof(LaneProfile));
436 ret = BindLaneIdToProfile(laneId, &profile);
437 EXPECT_EQ(ret, SOFTBUS_OK);
438
439 profile.linkType = LANE_P2P;
440 profile.content = LANE_T_FILE;
441 profile.priority = LANE_PRI_LOW;
442 ret = BindLaneIdToProfile(laneId, &profile);
443 EXPECT_EQ(ret, SOFTBUS_OK);
444
445 LaneGenerateParam param;
446 (void)memset_s(¶m, sizeof(LaneGenerateParam), 0, sizeof(LaneGenerateParam));
447 param.linkType = LANE_P2P;
448 param.transType = LANE_T_FILE;
449 param.priority = LANE_PRI_LOW;
450 uint32_t profileId = GenerateLaneProfileId(¶m);
451
452 ret = GetLaneProfile(profileId, &profile);
453 EXPECT_EQ(ret, SOFTBUS_OK);
454
455 ret = GetLaneProfile(profileId, nullptr);
456 EXPECT_EQ(ret, SOFTBUS_ERR);
457
458 uint32_t *laneIdList = nullptr;
459 uint32_t listSize = 0;
460 ret = GetLaneIdList(profileId, &laneIdList, &listSize);
461 EXPECT_EQ(ret, SOFTBUS_OK);
462 SoftBusFree(laneIdList);
463
464 (void)GetActiveProfileNum();
465
466 (void)UnbindLaneIdFromProfile(laneId, profileId);
467
468 (void)UnbindLaneIdFromProfile(0, profileId);
469 }
470
471 /*
472 * @tc.name: LNN_SELECT_LANE_001
473 * @tc.desc: SelectLane
474 * @tc.type: FUNC
475 * @tc.require:
476 */
477 HWTEST_F(LNNLaneTestMock, LNN_SELECT_LANE_001, TestSize.Level1)
478 {
479 LaneLinkType *recommendList = nullptr;
480 uint32_t listNum = 0;
481 LaneSelectParam selectParam;
482 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
483 selectParam.transType = LANE_T_FILE;
484 selectParam.expectedBw = 0;
485 selectParam.list.linkTypeNum = 2;
486 selectParam.list.linkType[0] = LANE_WLAN_5G;
487 selectParam.list.linkType[1] = LANE_LINK_TYPE_BUTT;
488 int32_t ret = SelectLane(NODE_NETWORK_ID, nullptr, &recommendList, &listNum);
489 EXPECT_EQ(ret, SOFTBUS_ERR);
490
491 LaneDepsInterfaceMock mock;
492 mock.SetDefaultResult();
493 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_ERR));
494 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_ERR));
495 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(false));
496 LnnWifiAdpterInterfaceMock wifiMock;
497 wifiMock.SetDefaultResult();
498 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
499 EXPECT_EQ(ret, SOFTBUS_ERR);
500
501 EXPECT_CALL(mock, LnnGetLocalNumInfo)
502 .WillRepeatedly(DoAll(SetArgPointee<1>(0), Return(SOFTBUS_OK)));
503 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
504 .WillRepeatedly(DoAll(SetArgPointee<2>(0), Return(SOFTBUS_OK)));
505 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
506 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
507 EXPECT_EQ(ret, SOFTBUS_ERR);
508
509 selectParam.transType = LANE_T_MIX;
510 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
511 EXPECT_EQ(ret, SOFTBUS_ERR);
512 SoftBusFree(recommendList);
513 }
514
515 /*
516 * @tc.name: LNN_SELECT_LANE_002
517 * @tc.desc: SelectLane
518 * @tc.type: FUNC
519 * @tc.require:
520 */
521 HWTEST_F(LNNLaneTestMock, LNN_SELECT_LANE_002, TestSize.Level1)
522 {
523 LaneLinkType *recommendList = nullptr;
524 uint32_t listNum = 0;
525 LaneSelectParam selectParam;
526 (void)memset_s(&selectParam, sizeof(LaneSelectParam), 0, sizeof(LaneSelectParam));
527 selectParam.transType = LANE_T_FILE;
528 selectParam.expectedBw = 0;
529 selectParam.list.linkTypeNum = DEFAULT_SELECT_NUM;
530 selectParam.list.linkType[0] = LANE_BLE;
531 selectParam.list.linkType[1] = LANE_WLAN_2P4G;
532 selectParam.list.linkType[2] = LANE_WLAN_5G;
533 selectParam.list.linkType[3] = LANE_BR;
534
535 LaneDepsInterfaceMock mock;
536 mock.SetDefaultResult();
537 EXPECT_CALL(mock, LnnGetLocalNumInfo).WillRepeatedly(Return(SOFTBUS_ERR));
538 EXPECT_CALL(mock, LnnGetRemoteNumInfo).WillRepeatedly(Return(SOFTBUS_ERR));
539 LnnWifiAdpterInterfaceMock wifiMock;
540 wifiMock.SetDefaultResult();
541 int32_t ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
542 EXPECT_EQ(ret, SOFTBUS_ERR);
543
544 EXPECT_CALL(mock, LnnGetLocalNumInfo)
545 .WillRepeatedly(DoAll(SetArgPointee<1>(1), Return(SOFTBUS_OK)));
546 EXPECT_CALL(mock, LnnGetRemoteNumInfo)
547 .WillRepeatedly(DoAll(SetArgPointee<2>(1), Return(SOFTBUS_OK)));
548 ret = SelectLane(NODE_NETWORK_ID, &selectParam, &recommendList, &listNum);
549 EXPECT_EQ(ret, SOFTBUS_OK);
550 SoftBusFree(recommendList);
551 }
552 } // namespace OHOS