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 #include <thread>
20
21 #include "lnn_feature_capability.h"
22 #include "lnn_lane_common.h"
23 #include "lnn_lane_deps_mock.h"
24 #include "lnn_lane_interface.h"
25 #include "lnn_lane_link_deps_mock.h"
26 #include "lnn_lane_link_p2p.h"
27 #include "lnn_select_rule.h"
28
29 namespace OHOS {
30 using namespace testing::ext;
31 using namespace testing;
32
33 constexpr char NODE_NETWORK_ID[] = "123456789";
34 constexpr char BRMAC[] = "testBrMac";
35 constexpr int32_t SYNCFAIL = 0;
36 constexpr int32_t SYNCSUCC = 1;
37 constexpr int32_t ASYNCFAIL = 2;
38 constexpr int32_t ASYNCSUCC = 3;
39 constexpr int32_t USEABLE_LANE_ID = 1234567;
40 constexpr char USEABLE_IP[] = "192.168.1.1";
41 constexpr uint64_t DEFAULT_LINK_LATENCY = 30000;
42 constexpr int32_t REQID = 2;
43 constexpr int32_t LANEREQID = 12;
44 constexpr int32_t LANEREQID15 = 15;
45 constexpr int32_t LANEVALUE = 3;
46 constexpr int32_t DB_MAGIC_NUMBER = 0x5A5A5A5A;
47 constexpr int32_t MESH_MAGIC_NUMBER = 0xA5A5A5A5;
48
49 int32_t g_laneLinkResult = SOFTBUS_INVALID_PARAM;
50
51 class LNNLaneLinkTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp();
56 void TearDown();
57 };
58
SetUpTestCase()59 void LNNLaneLinkTest::SetUpTestCase()
60 {
61 GTEST_LOG_(INFO) << "LNNLaneLinkTest start";
62 LnnInitLnnLooper();
63 }
64
TearDownTestCase()65 void LNNLaneLinkTest::TearDownTestCase()
66 {
67 LnnDeinitLnnLooper();
68 GTEST_LOG_(INFO) << "LNNLaneLinkTest end";
69 }
70
SetUp()71 void LNNLaneLinkTest::SetUp()
72 {
73 }
74
TearDown()75 void LNNLaneLinkTest::TearDown()
76 {
77 }
78
OnLaneLinkSuccess(uint32_t reqId,LaneLinkType linkType,const LaneLinkInfo * linkInfo)79 static void OnLaneLinkSuccess(uint32_t reqId, LaneLinkType linkType, const LaneLinkInfo *linkInfo)
80 {
81 (void)reqId;
82 (void)linkType;
83 (void)linkInfo;
84 g_laneLinkResult = SOFTBUS_OK;
85 return;
86 }
87
OnLaneLinkFail(uint32_t reqId,int32_t reason,LaneLinkType linkType)88 static void OnLaneLinkFail(uint32_t reqId, int32_t reason, LaneLinkType linkType)
89 {
90 (void)reqId;
91 (void)reason;
92 (void)linkType;
93 g_laneLinkResult = SOFTBUS_LANE_BUILD_LINK_FAIL;
94 return;
95 }
96
97 static LaneLinkCb g_linkCb = {
98 .onLaneLinkSuccess = OnLaneLinkSuccess,
99 .onLaneLinkFail = OnLaneLinkFail,
100 };
101
GetLocalAndRemoteMacByLocalIp(const char * localIp,char * localMac,size_t localMacSize,char * remoteMac,size_t remoteMacSize)102 static int32_t GetLocalAndRemoteMacByLocalIp(
103 const char *localIp, char *localMac, size_t localMacSize, char *remoteMac, size_t remoteMacSize)
104 {
105 (void)localIp;
106 (void)localMac;
107 (void)localMacSize;
108 (void)remoteMac;
109 (void)remoteMacSize;
110 return SOFTBUS_OK;
111 }
112
113 static struct WifiDirectManager manager = {
114 .getLocalAndRemoteMacByLocalIp = GetLocalAndRemoteMacByLocalIp,
115 };
116
IsNegotiateChannelNeeded(const char * remoteNetworkId,enum WifiDirectLinkType linkType)117 static bool IsNegotiateChannelNeeded(const char *remoteNetworkId, enum WifiDirectLinkType linkType)
118 {
119 return false;
120 }
121
GetRequestId(void)122 static uint32_t GetRequestId(void)
123 {
124 return 1;
125 }
126
GetRequestId2(void)127 static uint32_t GetRequestId2(void)
128 {
129 return REQID;
130 }
131
ConnectDevice(struct WifiDirectConnectInfo * info,struct WifiDirectConnectCallback * callback)132 static int32_t ConnectDevice(struct WifiDirectConnectInfo *info, struct WifiDirectConnectCallback *callback)
133 {
134 if (info->pid == SYNCFAIL) {
135 return SOFTBUS_INVALID_PARAM;
136 }
137 if (info->pid == SYNCSUCC) {
138 return SOFTBUS_OK;
139 }
140 if (info->pid == ASYNCFAIL) {
141 callback->onConnectFailure(info->requestId, ERROR_WIFI_DIRECT_WAIT_REUSE_RESPONSE_TIMEOUT);
142 return SOFTBUS_OK;
143 }
144 struct WifiDirectLink link = {
145 .linkId = 1,
146 .linkType = WIFI_DIRECT_LINK_TYPE_P2P,
147 };
148 callback->onConnectSuccess(info->requestId, &link);
149 return SOFTBUS_OK;
150 }
151
ConnectDeviceForCancel(struct WifiDirectConnectInfo * info,struct WifiDirectConnectCallback * callback)152 static int32_t ConnectDeviceForCancel(struct WifiDirectConnectInfo *info, struct WifiDirectConnectCallback *callback)
153 {
154 GTEST_LOG_(INFO) << "ConnectDeviceForCancel enter";
155 (void)info;
156 (void)callback;
157 return SOFTBUS_OK;
158 }
159
DisconnectDevice(struct WifiDirectDisconnectInfo * info,struct WifiDirectDisconnectCallback * callback)160 static int32_t DisconnectDevice(struct WifiDirectDisconnectInfo *info, struct WifiDirectDisconnectCallback *callback)
161 {
162 (void)info;
163 (void)callback;
164 return SOFTBUS_OK;
165 }
166
DisconnectDevice2(struct WifiDirectDisconnectInfo * info,struct WifiDirectDisconnectCallback * callback)167 static int32_t DisconnectDevice2(struct WifiDirectDisconnectInfo *info, struct WifiDirectDisconnectCallback *callback)
168 {
169 (void)info;
170 (void)callback;
171 return SOFTBUS_ERR;
172 }
173
CancelConnectDevice(const struct WifiDirectConnectInfo * info)174 static int32_t CancelConnectDevice(const struct WifiDirectConnectInfo *info)
175 {
176 GTEST_LOG_(INFO) << "CancelConnectDevice enter";
177 (void)info;
178 return SOFTBUS_OK;
179 }
180
CancelConnectDeviceFail(const struct WifiDirectConnectInfo * info)181 static int32_t CancelConnectDeviceFail(const struct WifiDirectConnectInfo *info)
182 {
183 GTEST_LOG_(INFO) << "CancelConnectDeviceFail enter";
184 (void)info;
185 return SOFTBUS_LANE_BUILD_LINK_FAIL;
186 }
187
SupportHmlTwo(void)188 static bool SupportHmlTwo(void)
189 {
190 return true;
191 }
192
193 static struct WifiDirectManager g_manager = {
194 .isNegotiateChannelNeeded= IsNegotiateChannelNeeded,
195 .getRequestId = GetRequestId,
196 .connectDevice = ConnectDevice,
197 .cancelConnectDevice = CancelConnectDevice,
198 .disconnectDevice = DisconnectDevice,
199 .supportHmlTwo = SupportHmlTwo,
200 };
201
202 static struct WifiDirectManager g_manager2 = {
203 .isNegotiateChannelNeeded= IsNegotiateChannelNeeded,
204 .getRequestId = GetRequestId2,
205 .connectDevice = ConnectDevice,
206 .cancelConnectDevice = CancelConnectDevice,
207 .disconnectDevice = DisconnectDevice,
208 .supportHmlTwo = SupportHmlTwo,
209 };
210
211 static struct WifiDirectManager g_manager3 = {
212 .isNegotiateChannelNeeded= IsNegotiateChannelNeeded,
213 .getRequestId = GetRequestId,
214 .connectDevice = ConnectDevice,
215 .cancelConnectDevice = CancelConnectDevice,
216 .disconnectDevice = DisconnectDevice2,
217 .supportHmlTwo = SupportHmlTwo,
218 };
219
IsNegotiateChannelNeeded2(const char * remoteNetworkId,enum WifiDirectLinkType linkType)220 static bool IsNegotiateChannelNeeded2(const char *remoteNetworkId, enum WifiDirectLinkType linkType)
221 {
222 (void)remoteNetworkId;
223 (void)linkType;
224 return true;
225 }
226
227 static struct WifiDirectManager g_manager5 = {
228 .isNegotiateChannelNeeded= IsNegotiateChannelNeeded2,
229 };
230
231 static struct WifiDirectManager g_manager6 = {
232 .isNegotiateChannelNeeded= IsNegotiateChannelNeeded,
233 };
234
235 /*
236 * @tc.name: GET_WLAN_LINKED_FREQUENCY_TEST_001
237 * @tc.desc: LnnQueryLaneResource test
238 * @tc.type: FUNC
239 * @tc.require:
240 */
241 HWTEST_F(LNNLaneLinkTest, GET_WLAN_LINKED_FREQUENCY_TEST_001, TestSize.Level1)
242 {
243 int32_t ret = GetWlanLinkedFrequency();
244 EXPECT_EQ(ret, SOFTBUS_LANE_SELECT_FAIL);
245 }
246
247 /*
248 * @tc.name: GET_WLAN_LINKED_FREQUENCY_TEST_002
249 * @tc.desc: LnnQueryLaneResource test
250 * @tc.type: FUNC
251 * @tc.require:
252 */
253 HWTEST_F(LNNLaneLinkTest, GET_WLAN_LINKED_FREQUENCY_TEST_002, TestSize.Level1)
254 {
255 using TestLinkType = enum {
256 TEST_BR = -1,
257 };
258 TestLinkType testLink = TEST_BR;
259 LaneLinkType linkType = (LaneLinkType)testLink;
260 LinkAttribute *ret = GetLinkAttrByLinkType(linkType);
261 EXPECT_TRUE(ret == nullptr);
262 linkType = LANE_LINK_TYPE_BUTT;
263 ret = GetLinkAttrByLinkType(linkType);
264 EXPECT_TRUE(ret == nullptr);
265 linkType = LANE_P2P;
266 ret = GetLinkAttrByLinkType(linkType);
267 EXPECT_TRUE(ret != nullptr);
268 }
269
270 /*
271 * @tc.name: LnnConnectP2p_001
272 * @tc.desc: test LnnConnectP2p, request == NULL && callback == NULL
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(LNNLaneLinkTest, LnnConnectP2p_001, TestSize.Level1)
277 {
278 LinkRequest request;
279 LaneLinkCb cb;
280 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
281 (void)memset_s(&cb, sizeof(LaneLinkCb), 0, sizeof(LaneLinkCb));
282 uint32_t laneReqId = 10;
283
284 int32_t ret = LnnConnectP2p(nullptr, laneReqId, &cb);
285 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
286
287 ret = LnnConnectP2p(&request, laneReqId, nullptr);
288 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
289 }
290
291 /*
292 * @tc.name: LnnConnectP2p_002
293 * @tc.desc: test LnnConnectP2p, isMetaAuth == true && OpenAuthToConnP2p call GetPreferAuth fail
294 * @tc.type: FUNC
295 * @tc.require:
296 */
297 HWTEST_F(LNNLaneLinkTest, LnnConnectP2p_002, TestSize.Level1)
298 {
299 LinkRequest request;
300 LaneLinkCb cb;
301 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
302 (void)memset_s(&cb, sizeof(LaneLinkCb), 0, sizeof(LaneLinkCb));
303 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
304 EXPECT_EQ(EOK, ret);
305 request.linkType = LANE_LINK_TYPE_BUTT;
306 uint32_t laneReqId = 10;
307 int32_t value = 2;
308
309 NiceMock<LaneDepsInterfaceMock> linkMock;
310 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
311 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
312 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_NOT_FIND));
313
314 ret = LnnConnectP2p(&request, laneReqId, &cb);
315 EXPECT_EQ(SOFTBUS_LANE_GET_LEDGER_INFO_ERR, ret);
316 LnnDestroyP2p();
317 }
318
319 /*
320 * @tc.name: LnnConnectP2p_003
321 * @tc.desc: test LnnConnectP2p, TryWifiDirectReuse call ConnectWifiDirectWithReuse success
322 * @tc.type: FUNC
323 * @tc.require:
324 */
325 HWTEST_F(LNNLaneLinkTest, LnnConnectP2p_003, TestSize.Level1)
326 {
327 LinkRequest request;
328 LaneLinkCb cb;
329 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
330 (void)memset_s(&cb, sizeof(LaneLinkCb), 0, sizeof(LaneLinkCb));
331 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, "123");
332 EXPECT_EQ(EOK, ret);
333 request.linkType = LANE_HML;
334 request.pid = SYNCSUCC;
335 uint32_t laneReqId = 10;
336 int32_t value = 3;
337
338 NiceMock<LaneDepsInterfaceMock> linkMock;
339 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
340 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
341 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
342 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
343 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_OK));
344 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
345 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
346
347 ret = LnnConnectP2p(&request, laneReqId, &cb);
348 EXPECT_EQ(SOFTBUS_OK, ret);
349 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
350 LnnDestroyP2p();
351 }
352
353 /*
354 * @tc.name: LnnConnectP2p_004
355 * @tc.desc: test LnnConnectP2p, GetGuideChannelInfo:linkType >= LANE_LINK_TYPE_BUTT
356 * @tc.type: FUNC
357 * @tc.require:
358 */
359 HWTEST_F(LNNLaneLinkTest, LnnConnectP2p_004, TestSize.Level1)
360 {
361 LinkRequest request;
362 LaneLinkCb cb;
363 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
364 (void)memset_s(&cb, sizeof(LaneLinkCb), 0, sizeof(LaneLinkCb));
365 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
366 EXPECT_EQ(EOK, ret);
367 request.linkType = LANE_LINK_TYPE_BUTT;
368 uint32_t laneReqId = 10;
369 int32_t value = 3;
370
371 NiceMock<LaneDepsInterfaceMock> linkMock;
372 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
373 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
374
375 ret = LnnConnectP2p(&request, laneReqId, &cb);
376 EXPECT_EQ(SOFTBUS_LANE_GUIDE_BUILD_FAIL, ret);
377 LnnDestroyP2p();
378 }
379
380 /*
381 * @tc.name: GuideChannelRetryOfSync_001
382 * @tc.desc: test GuideChannelRetryOfSync:
383 * LANE_ACTIVE_AUTH_NEGO(fail)->LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(fail)
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_001, TestSize.Level1)
388 {
389 LinkRequest request;
390 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
391 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
392 EXPECT_EQ(EOK, ret);
393 request.linkType = LANE_P2P;
394 request.triggerLinkTime = SoftBusGetSysTimeMs();
395 request.availableLinkTime = DEFAULT_LINK_LATENCY;
396 uint32_t laneReqId = 10;
397 int32_t value = 3;
398 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
399 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
400 uint32_t requestId = 1;
401
402 NiceMock<LaneDepsInterfaceMock> linkMock;
403 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
404 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
405 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
406 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
407 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
408 .WillRepeatedly(Return(SOFTBUS_OK));
409 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
410 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
411 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
412 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
413 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
414 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
415 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
416 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
417 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
418 EXPECT_CALL(linkMock, AuthOpenConn)
419 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL)).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
420 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
421 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
422 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
423
424 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
425 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
426 EXPECT_EQ(SOFTBUS_OK, ret);
427 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
428 LnnDestroyP2p();
429 }
430
431 /*
432 * @tc.name: GuideChannelRetryOfSync_002
433 * @tc.desc: test GuideChannelRetryOfSync:LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(pass)
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_002, TestSize.Level1)
438 {
439 LinkRequest request;
440 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
441 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
442 EXPECT_EQ(EOK, ret);
443 request.linkType = LANE_HML;
444 request.triggerLinkTime = SoftBusGetSysTimeMs();
445 request.availableLinkTime = DEFAULT_LINK_LATENCY;
446 uint32_t laneReqId = 10;
447 int32_t value = 3;
448 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
449 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
450 uint32_t requestId = 1;
451
452 NiceMock<LaneDepsInterfaceMock> linkMock;
453 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
454 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
455 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
456 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
457 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
458 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
459 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
460 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
461 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
462 .WillRepeatedly(Return(SOFTBUS_OK));
463 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
464 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
465 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
466 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
467 EXPECT_CALL(linkMock, AuthOpenConn)
468 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL)).WillRepeatedly(Return(SOFTBUS_OK));
469 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
470 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
471
472 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
473 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
474 EXPECT_EQ(SOFTBUS_OK, ret);
475 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
476 LnnDestroyP2p();
477 }
478
479 /*
480 * @tc.name: GuideChannelRetryOfSync_003
481 * @tc.desc: test GuideChannelRetryOfSync:LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(pass)->LANE_NEW_AUTH_NEGO
482 * @tc.type: FUNC
483 * @tc.require:
484 */
485 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_003, TestSize.Level1)
486 {
487 LinkRequest request;
488 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
489 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
490 EXPECT_EQ(EOK, ret);
491 request.linkType = LANE_HML;
492 request.triggerLinkTime = SoftBusGetSysTimeMs();
493 request.availableLinkTime = DEFAULT_LINK_LATENCY;
494 uint32_t laneReqId = 10;
495 int32_t value = 3;
496 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
497 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
498 uint32_t requestId = 1;
499
500 NiceMock<LaneDepsInterfaceMock> linkMock;
501 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
502 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
503 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
504 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
505 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
506 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
507 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
508 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
509 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
510 .WillRepeatedly(Return(SOFTBUS_OK));
511 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
512 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
513 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
514 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
515 EXPECT_CALL(linkMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
516 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
517 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel).WillRepeatedly(Return(SOFTBUS_OK));
518
519 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
520 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
521 EXPECT_EQ(SOFTBUS_OK, ret);
522 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
523 LnnDestroyP2p();
524 }
525
526 /*
527 * @tc.name: GuideChannelRetryOfSync_004
528 * @tc.desc: test GuideChannelRetryOfSync:LANE_NEW_AUTH_NEGO(fail)
529 * @tc.type: FUNC
530 * @tc.require:
531 */
532 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_004, TestSize.Level1)
533 {
534 LinkRequest request;
535 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
536 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
537 EXPECT_EQ(EOK, ret);
538 request.linkType = LANE_HML;
539 request.triggerLinkTime = SoftBusGetSysTimeMs();
540 request.availableLinkTime = DEFAULT_LINK_LATENCY;
541 uint32_t laneReqId = 10;
542 int32_t value = 3;
543 uint64_t local = 0;
544 uint64_t remote = 0;
545 uint32_t requestId = 1;
546
547 NiceMock<LaneDepsInterfaceMock> linkMock;
548 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
549 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
550 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
551 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
552 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
553 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
554 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
555 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
556 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillRepeatedly(Return(SOFTBUS_OK));
557 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
558 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
559 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
560 EXPECT_CALL(linkMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
561
562 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
563 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
564 EXPECT_EQ(SOFTBUS_OK, ret);
565 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
566 LnnDestroyP2p();
567 }
568
569 /*
570 * @tc.name: GuideChannelRetryOfSync_005
571 * @tc.desc: test GuideChannelRetryOfSync:LANE_NEW_AUTH_NEGO(pass)
572 * @tc.type: FUNC
573 * @tc.require:
574 */
575 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_005, TestSize.Level1)
576 {
577 LinkRequest request;
578 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
579 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
580 EXPECT_EQ(EOK, ret);
581 request.linkType = LANE_HML;
582 request.triggerLinkTime = SoftBusGetSysTimeMs();
583 request.availableLinkTime = DEFAULT_LINK_LATENCY;
584 uint32_t laneReqId = 10;
585 int32_t value = 3;
586 uint64_t local = 0;
587 uint64_t remote = 0;
588 uint32_t requestId = 1;
589
590 NiceMock<LaneDepsInterfaceMock> linkMock;
591 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
592 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
593 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
594 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
595 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
596 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
597 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
598 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
599 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillRepeatedly(Return(SOFTBUS_OK));
600 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
601 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
602 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
603 EXPECT_CALL(linkMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_OK));
604
605 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
606 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
607 EXPECT_EQ(SOFTBUS_OK, ret);
608 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
609 LnnDestroyP2p();
610 }
611
612 /*
613 * @tc.name: GuideChannelRetryOfSync_006
614 * @tc.desc: test GuideChannelRetryOfSync:
615 * LANE_ACTIVE_AUTH_TRIGGER(fail)->LANE_BLE_TRIGGER(fail)->LANE_NEW_AUTH_TRIGGER(fail)
616 * @tc.type: FUNC
617 * @tc.require:
618 */
619 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_006, TestSize.Level1)
620 {
621 LinkRequest request;
622 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
623 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
624 EXPECT_EQ(EOK, ret);
625 request.linkType = LANE_HML;
626 request.pid = SYNCFAIL;
627 request.triggerLinkTime = SoftBusGetSysTimeMs();
628 request.availableLinkTime = DEFAULT_LINK_LATENCY;
629 uint32_t laneReqId = 10;
630 int32_t value = 3;
631 uint64_t local = 1 << BIT_BLE_TRIGGER_CONNECTION;
632 uint64_t remote = 1 << BIT_BLE_TRIGGER_CONNECTION;
633 uint32_t requestId = 1;
634
635 NiceMock<LaneDepsInterfaceMock> linkMock;
636 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
637 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
638 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
639 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
640 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
641 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
642 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
643 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
644 .WillRepeatedly(Return(SOFTBUS_OK));
645 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillOnce(Return(false))
646 .WillRepeatedly(Return(true));
647 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
648 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
649 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
650 EXPECT_CALL(linkMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
651 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
652
653 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
654 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
655 EXPECT_EQ(SOFTBUS_OK, ret);
656 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
657 LnnDestroyP2p();
658 }
659
660 /*
661 * @tc.name: GuideChannelRetryOfSync_007
662 * @tc.desc: test GuideChannelRetryOfSync:
663 * LANE_ACTIVE_AUTH_TRIGGER(fail)->LANE_BLE_TRIGGER(fail)->LANE_NEW_AUTH_TRIGGER(pass)
664 * @tc.type: FUNC
665 * @tc.require:
666 */
667 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_007, TestSize.Level1)
668 {
669 LinkRequest request;
670 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
671 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
672 EXPECT_EQ(EOK, ret);
673 request.linkType = LANE_HML;
674 request.pid = SYNCFAIL;
675 request.triggerLinkTime = SoftBusGetSysTimeMs();
676 request.availableLinkTime = DEFAULT_LINK_LATENCY;
677 uint32_t laneReqId = 10;
678 int32_t value = 3;
679 uint64_t local = 1 << BIT_BLE_TRIGGER_CONNECTION;
680 uint64_t remote = 1 << BIT_BLE_TRIGGER_CONNECTION;
681 uint32_t requestId = 1;
682
683 NiceMock<LaneDepsInterfaceMock> linkMock;
684 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
685 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
686 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
687 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
688 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
689 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
690 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
691 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
692 .WillRepeatedly(Return(SOFTBUS_OK));
693 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillRepeatedly(Return(true));
694 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
695 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
696 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
697 EXPECT_CALL(linkMock, AuthOpenConn)
698 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL)).WillRepeatedly(Return(SOFTBUS_OK));
699 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
700
701 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
702 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
703 EXPECT_EQ(SOFTBUS_OK, ret);
704 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
705 LnnDestroyP2p();
706 }
707
708 /*
709 * @tc.name: GuideChannelRetryOfSync_008
710 * @tc.desc: test GuideChannelRetryOfSync:LANE_ACTIVE_AUTH_TRIGGER(fail)->LANE_BLE_TRIGGER(pass)->LANE_NEW_AUTH_TRIGGER
711 * @tc.type: FUNC
712 * @tc.require:
713 */
714 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_008, TestSize.Level1)
715 {
716 LinkRequest request;
717 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
718 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
719 EXPECT_EQ(EOK, ret);
720 request.linkType = LANE_HML;
721 request.pid = SYNCSUCC;
722 request.triggerLinkTime = SoftBusGetSysTimeMs();
723 request.availableLinkTime = DEFAULT_LINK_LATENCY;
724 uint32_t laneReqId = 10;
725 int32_t value = 3;
726 uint64_t local = 1 << BIT_BLE_TRIGGER_CONNECTION;
727 uint64_t remote = 1 << BIT_BLE_TRIGGER_CONNECTION;
728 uint32_t requestId = 1;
729
730 NiceMock<LaneDepsInterfaceMock> linkMock;
731 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
732 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
733 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
734 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
735 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
736 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
737 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
738 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
739 .WillRepeatedly(Return(SOFTBUS_OK));
740 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillRepeatedly(Return(true));
741 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
742 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
743 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
744 EXPECT_CALL(linkMock, AuthOpenConn).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
745 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
746
747 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
748 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
749 EXPECT_EQ(SOFTBUS_OK, ret);
750 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
751 LnnDestroyP2p();
752 }
753
754 /*
755 * @tc.name: GuideChannelRetryOfSync_009
756 * @tc.desc: test GuideChannelRetryOfSync:LANE_BLE_TRIGGER(pass)->LANE_NEW_AUTH_TRIGGER
757 * @tc.type: FUNC
758 * @tc.require:
759 */
760 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfSync_009, TestSize.Level1)
761 {
762 LinkRequest request;
763 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
764 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
765 EXPECT_EQ(EOK, ret);
766 request.linkType = LANE_HML;
767 request.pid = SYNCSUCC;
768 request.triggerLinkTime = SoftBusGetSysTimeMs();
769 request.availableLinkTime = DEFAULT_LINK_LATENCY;
770 uint32_t laneReqId = 10;
771 int32_t value = 3;
772 uint64_t local = 1 << BIT_BLE_TRIGGER_CONNECTION;
773 uint64_t remote = 1 << BIT_BLE_TRIGGER_CONNECTION;
774
775 NiceMock<LaneDepsInterfaceMock> linkMock;
776 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
777 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
778 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
779 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
780 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
781 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
782 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
783 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
784 .WillRepeatedly(Return(SOFTBUS_OK));
785 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
786 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
787 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
788
789 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
790 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
791 EXPECT_EQ(SOFTBUS_OK, ret);
792 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
793 LnnDestroyP2p();
794 }
795
796 /*
797 * @tc.name: GuideChannelRetryOfAsync_001
798 * @tc.desc: test GuideChannelRetryOfAsync:
799 * LANE_ACTIVE_AUTH_NEGO(fail)->LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(fail)
800 * @tc.type: FUNC
801 * @tc.require:
802 */
803 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_001, TestSize.Level1)
804 {
805 LinkRequest request;
806 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
807 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
808 EXPECT_EQ(EOK, ret);
809 request.linkType = LANE_P2P;
810 request.triggerLinkTime = SoftBusGetSysTimeMs();
811 request.availableLinkTime = DEFAULT_LINK_LATENCY;
812 uint32_t laneReqId = 10;
813 int32_t value = 3;
814 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
815 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
816 uint32_t requestId = 1;
817
818 NiceMock<LaneDepsInterfaceMock> linkMock;
819 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
820 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
821 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
822 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
823 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
824 .WillRepeatedly(Return(SOFTBUS_OK));
825 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillRepeatedly(Return(true));
826 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
827 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
828 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
829 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
830 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
831 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
832 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
833 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
834 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpenFailed);
835 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
836 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel(requestId, _, _, NotNull()))
837 .WillRepeatedly(laneLinkMock.ActionOfChannelOpenFailed);
838 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
839
840 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
841 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
842 EXPECT_EQ(SOFTBUS_OK, ret);
843 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
844 LnnDestroyP2p();
845 }
846
847 /*
848 * @tc.name: GuideChannelRetryOfAsync_002
849 * @tc.desc: test GuideChannelRetryOfAsync:
850 * LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(pass)
851 * @tc.type: FUNC
852 * @tc.require:
853 */
854 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_002, TestSize.Level1)
855 {
856 LinkRequest request = {};
857 EXPECT_EQ(strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID), EOK);
858 request.linkType = LANE_HML;
859 request.pid = ASYNCSUCC;
860 request.triggerLinkTime = SoftBusGetSysTimeMs();
861 request.availableLinkTime = DEFAULT_LINK_LATENCY;
862 AuthConnInfo connInfo = {.type = AUTH_LINK_TYPE_P2P};
863 uint32_t laneReqId = 10;
864 int32_t value = 3;
865 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
866 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
867 uint32_t requestId = 1;
868
869 NiceMock<LaneDepsInterfaceMock> linkMock;
870 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
871 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
872 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
873 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
874 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
875 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
876 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
877 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND))
878 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
879 .WillOnce(Return(SOFTBUS_OK))
880 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
881 .WillRepeatedly(Return(SOFTBUS_OK));
882 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
883 EXPECT_CALL(linkMock, AuthGetPreferConnInfo)
884 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(connInfo), Return(SOFTBUS_OK)));
885 EXPECT_CALL(linkMock, AuthGetConnInfoByType)
886 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(connInfo), Return(SOFTBUS_OK)));
887 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
888 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
889 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
890 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel(requestId, _, _, NotNull()))
891 .WillRepeatedly(laneLinkMock.ActionOfChannelOpenFailed);
892 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
893 EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
894 EXPECT_CALL(linkMock, AuthGetP2pConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
895
896 int32_t ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
897 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
898 EXPECT_EQ(SOFTBUS_OK, ret);
899 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
900 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
901 LnnDestroyP2p();
902 }
903
904 /*
905 * @tc.name: GuideChannelRetryOfAsync_003
906 * @tc.desc: test GuideChannelRetryOfAsync:LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(pass)->LANE_NEW_AUTH_NEGO
907 * @tc.type: FUNC
908 * @tc.require:
909 */
910 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_003, TestSize.Level1)
911 {
912 LinkRequest request;
913 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
914 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
915 EXPECT_EQ(EOK, ret);
916 request.linkType = LANE_HML;
917 request.pid = ASYNCSUCC;
918 request.triggerLinkTime = SoftBusGetSysTimeMs();
919 request.availableLinkTime = DEFAULT_LINK_LATENCY;
920 uint32_t laneReqId = 10;
921 int32_t value = 3;
922 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
923 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
924 uint32_t requestId = 1;
925
926 NiceMock<LaneDepsInterfaceMock> linkMock;
927 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
928 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
929 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
930 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
931 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
932 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
933 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
934 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND))
935 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
936 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
937 .WillRepeatedly(Return(SOFTBUS_OK));
938 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
939 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
940 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
941 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpenFailed);
942 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
943 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel(requestId, _, _, NotNull()))
944 .WillRepeatedly(laneLinkMock.ActionOfChannelOpened);
945 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
946 EXPECT_CALL(laneLinkMock, TransProxyPipelineCloseChannelDelay).WillRepeatedly(Return(SOFTBUS_OK));
947 EXPECT_CALL(linkMock, AuthGetP2pConnInfo).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
948
949 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
950 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
951 EXPECT_EQ(SOFTBUS_OK, ret);
952 EXPECT_EQ(SOFTBUS_OK, g_laneLinkResult);
953 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
954 LnnDestroyP2p();
955 }
956
957 /*
958 * @tc.name: GuideChannelRetryOfAsync_004
959 * @tc.desc: test GuideChannelRetryOfAsync:LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(pass)
960 * @tc.type: FUNC
961 * @tc.require:
962 */
963 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_004, TestSize.Level1)
964 {
965 LinkRequest request;
966 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
967 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
968 EXPECT_EQ(EOK, ret);
969 request.linkType = LANE_HML;
970 request.pid = ASYNCSUCC;
971 request.triggerLinkTime = SoftBusGetSysTimeMs();
972 request.availableLinkTime = DEFAULT_LINK_LATENCY;
973 AuthConnInfo connInfo = {.type = AUTH_LINK_TYPE_P2P};
974 uint32_t laneReqId = 10;
975 int32_t value = 3;
976 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
977 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
978 uint32_t requestId = 1;
979
980 NiceMock<LaneDepsInterfaceMock> linkMock;
981 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
982 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
983 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
984 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
985 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
986 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
987 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
988 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
989 .WillRepeatedly(Return(SOFTBUS_OK));
990 EXPECT_CALL(linkMock, AuthGetPreferConnInfo)
991 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(connInfo), Return(SOFTBUS_OK)));
992 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
993 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
994 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillOnce(linkMock.ActionOfConnOpened)
995 .WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
996 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
997 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel(requestId, _, _, NotNull()))
998 .WillRepeatedly(laneLinkMock.ActionOfChannelOpenFailed);
999 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1000 EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
1001 EXPECT_CALL(linkMock, AuthGetP2pConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1002
1003 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1004 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
1005 EXPECT_EQ(SOFTBUS_OK, ret);
1006 EXPECT_EQ(SOFTBUS_OK, g_laneLinkResult);
1007 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1008 LnnDestroyP2p();
1009 }
1010
1011 /*
1012 * @tc.name: GuideChannelRetryOfAsync_005
1013 * @tc.desc: test GuideChannelRetryOfAsync:
1014 * LANE_ACTIVE_AUTH_TRIGGER(fail)->LANE_BLE_TRIGGER(fail)->LANE_NEW_AUTH_TRIGGER(fail)
1015 * @tc.type: FUNC
1016 * @tc.require:
1017 */
1018 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_005, TestSize.Level1)
1019 {
1020 LinkRequest request;
1021 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
1022 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1023 EXPECT_EQ(EOK, ret);
1024 request.linkType = LANE_HML;
1025 request.pid = ASYNCFAIL;
1026 request.triggerLinkTime = SoftBusGetSysTimeMs();
1027 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1028 uint32_t laneReqId = 10;
1029 int32_t value = 3;
1030 uint64_t local = 1 << BIT_BLE_TRIGGER_CONNECTION;
1031 uint64_t remote = 1 << BIT_BLE_TRIGGER_CONNECTION;
1032 uint32_t requestId = 1;
1033
1034 NiceMock<LaneDepsInterfaceMock> linkMock;
1035 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1036 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1037 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1038 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1039 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
1040 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1041 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
1042 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1043 .WillRepeatedly(Return(SOFTBUS_OK));
1044 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillRepeatedly(Return(true));
1045 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1046 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1047 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1048 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpenFailed);
1049 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1050
1051 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1052 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
1053 EXPECT_EQ(SOFTBUS_OK, ret);
1054 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
1055 LnnDestroyP2p();
1056 }
1057
1058 /*
1059 * @tc.name: GuideChannelRetryOfAsync_006
1060 * @tc.desc: test GuideChannelRetryOfAsync:
1061 * LANE_ACTIVE_AUTH_TRIGGER(fail)->LANE_BLE_TRIGGER(fail)->LANE_NEW_AUTH_TRIGGER(opened-fail)
1062 * @tc.type: FUNC
1063 * @tc.require:
1064 */
1065 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_006, TestSize.Level1)
1066 {
1067 LinkRequest request;
1068 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
1069 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1070 EXPECT_EQ(EOK, ret);
1071 request.linkType = LANE_HML;
1072 request.pid = ASYNCFAIL;
1073 request.triggerLinkTime = SoftBusGetSysTimeMs();
1074 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1075 AuthConnInfo connInfo = {.type = AUTH_LINK_TYPE_P2P};
1076 uint32_t laneReqId = 10;
1077 int32_t value = 3;
1078 uint64_t local = 1 << BIT_BLE_TRIGGER_CONNECTION;
1079 uint64_t remote = 1 << BIT_BLE_TRIGGER_CONNECTION;
1080 uint32_t requestId = 1;
1081
1082 NiceMock<LaneDepsInterfaceMock> linkMock;
1083 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1084 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1085 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1086 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1087 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
1088 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1089 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
1090 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_NOT_FIND))
1091 .WillRepeatedly(Return(SOFTBUS_OK));
1092 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillRepeatedly(Return(true));
1093 EXPECT_CALL(linkMock, AuthGetPreferConnInfo)
1094 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(connInfo), Return(SOFTBUS_OK)));
1095 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1096 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1097 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillOnce(linkMock.ActionOfConnOpenFailed)
1098 .WillRepeatedly(linkMock.ActionOfConnOpened);
1099 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1100 EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
1101
1102 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1103 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
1104 EXPECT_EQ(SOFTBUS_OK, ret);
1105 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
1106 LnnDestroyP2p();
1107 }
1108
1109 /*
1110 * @tc.name: GuideChannelRetryOfAsync_007
1111 * @tc.desc: test GuideChannelRetryOfAsync:LANE_ACTIVE_AUTH_TRIGGER(fail)->LANE_BLE_TRIGGER(pass)->LANE_NEW_AUTH_TRIGGER
1112 * @tc.type: FUNC
1113 * @tc.require:
1114 */
1115 HWTEST_F(LNNLaneLinkTest, GuideChannelRetryOfAsync_007, TestSize.Level1)
1116 {
1117 LinkRequest request;
1118 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
1119 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1120 EXPECT_EQ(EOK, ret);
1121 request.linkType = LANE_HML;
1122 request.pid = ASYNCSUCC;
1123 request.triggerLinkTime = SoftBusGetSysTimeMs();
1124 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1125 uint32_t laneReqId = 10;
1126 int32_t value = 3;
1127 uint64_t local = 1 << BIT_BLE_TRIGGER_CONNECTION;
1128 uint64_t remote = 1 << BIT_BLE_TRIGGER_CONNECTION;
1129 uint32_t requestId = 1;
1130
1131 NiceMock<LaneDepsInterfaceMock> linkMock;
1132 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1133 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1134 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1135 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1136 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
1137 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1138 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
1139 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1140 .WillRepeatedly(Return(SOFTBUS_OK));
1141 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillRepeatedly(Return(true));
1142 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1143 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1144 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1145 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillOnce(linkMock.ActionOfConnOpenFailed)
1146 .WillRepeatedly(Return(SOFTBUS_OK));
1147 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1148 EXPECT_CALL(linkMock, AuthGetP2pConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1149
1150 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1151 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
1152 EXPECT_EQ(SOFTBUS_OK, ret);
1153 EXPECT_EQ(SOFTBUS_OK, g_laneLinkResult);
1154 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1155 LnnDestroyP2p();
1156 }
1157
1158 /*
1159 * @tc.name: GuideChannelRetry_001
1160 * @tc.desc: test GuideChannelRetry:fist async
1161 * LANE_ACTIVE_AUTH_NEGO(fail)->LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(fail)
1162 * @tc.type: FUNC
1163 * @tc.require:
1164 */
1165 HWTEST_F(LNNLaneLinkTest, GuideChannelRetry_001, TestSize.Level1)
1166 {
1167 LinkRequest request;
1168 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
1169 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1170 EXPECT_EQ(EOK, ret);
1171 request.linkType = LANE_P2P;
1172 request.triggerLinkTime = SoftBusGetSysTimeMs();
1173 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1174 uint32_t laneReqId = 10;
1175 int32_t value = 3;
1176 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1177 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1178 uint32_t requestId = 1;
1179
1180 NiceMock<LaneDepsInterfaceMock> linkMock;
1181 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1182 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1183 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1184 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1185 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
1186 .WillRepeatedly(Return(SOFTBUS_OK));
1187 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1188 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
1189 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1190 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
1191 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1192 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
1193 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1194 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1195 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1196 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillOnce(linkMock.ActionOfConnOpenFailed)
1197 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL))
1198 .WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
1199 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
1200 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel(requestId, _, _, NotNull()))
1201 .WillRepeatedly(laneLinkMock.ActionOfChannelOpenFailed);
1202 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1203
1204 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1205 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
1206 EXPECT_EQ(SOFTBUS_OK, ret);
1207 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
1208 LnnDestroyP2p();
1209 }
1210
1211 /*
1212 * @tc.name: GuideChannelRetry_002
1213 * @tc.desc: test GuideChannelRetry:fist sync
1214 * LANE_ACTIVE_AUTH_NEGO(fail)->LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(fail)
1215 * @tc.type: FUNC
1216 * @tc.require:
1217 */
1218 HWTEST_F(LNNLaneLinkTest, GuideChannelRetry_002, TestSize.Level1)
1219 {
1220 LinkRequest request;
1221 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
1222 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1223 EXPECT_EQ(EOK, ret);
1224 request.linkType = LANE_P2P;
1225 request.triggerLinkTime = SoftBusGetSysTimeMs();
1226 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1227 uint32_t laneReqId = 10;
1228 int32_t value = 3;
1229 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1230 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1231 uint32_t requestId = 1;
1232
1233 NiceMock<LaneDepsInterfaceMock> linkMock;
1234 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1235 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1236 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1237 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1238 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
1239 .WillRepeatedly(Return(SOFTBUS_OK));
1240 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1241 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
1242 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1243 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
1244 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1245 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
1246 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1247 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1248 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1249 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL))
1250 .WillOnce(linkMock.ActionOfConnOpenFailed)
1251 .WillRepeatedly(linkMock.ActionOfConnOpenFailed);
1252 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
1253 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
1254 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1255
1256 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1257 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
1258 EXPECT_EQ(SOFTBUS_OK, ret);
1259 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
1260 LnnDestroyP2p();
1261 }
1262
1263 /*
1264 * @tc.name: GuideChannelRetry_003
1265 * @tc.desc: test GuideChannelRetry:fist async
1266 * LANE_ACTIVE_AUTH_NEGO(fail)->LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(pass)
1267 * @tc.type: FUNC
1268 * @tc.require:
1269 */
1270 HWTEST_F(LNNLaneLinkTest, GuideChannelRetry_003, TestSize.Level1)
1271 {
1272 LinkRequest request;
1273 (void)memset_s(&request, sizeof(LinkRequest), 0, sizeof(LinkRequest));
1274 int32_t ret = strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID);
1275 EXPECT_EQ(EOK, ret);
1276 request.linkType = LANE_P2P;
1277 request.triggerLinkTime = SoftBusGetSysTimeMs();
1278 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1279 uint32_t laneReqId = 10;
1280 int32_t value = 3;
1281 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1282 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1283 uint32_t requestId = 1;
1284
1285 NiceMock<LaneDepsInterfaceMock> linkMock;
1286 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1287 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1288 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1289 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1290 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
1291 .WillRepeatedly(Return(SOFTBUS_OK));
1292 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1293 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
1294 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1295 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
1296 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1297 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
1298 EXPECT_CALL(linkMock, AuthGetPreferConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1299 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1300 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1301 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillOnce(linkMock.ActionOfConnOpenFailed)
1302 .WillOnce(Return(SOFTBUS_LANE_BUILD_LINK_FAIL))
1303 .WillRepeatedly(Return(SOFTBUS_OK));
1304 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
1305 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel(requestId, _, _, NotNull()))
1306 .WillRepeatedly(laneLinkMock.ActionOfChannelOpenFailed);
1307 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1308
1309 ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1310 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
1311 EXPECT_EQ(SOFTBUS_OK, ret);
1312 LnnDestroyP2p();
1313 }
1314
1315 /*
1316 * @tc.name: GuideChannelRetry_004
1317 * @tc.desc: test GuideChannelRetry:fist sync
1318 * LANE_ACTIVE_AUTH_NEGO(fail)->LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(pass)
1319 * @tc.type: FUNC
1320 * @tc.require:
1321 */
1322 HWTEST_F(LNNLaneLinkTest, GuideChannelRetry_004, TestSize.Level1)
1323 {
1324 LinkRequest request = {};
1325 EXPECT_EQ(strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID), EOK);
1326 request.linkType = LANE_P2P;
1327 request.pid = ASYNCSUCC;
1328 request.triggerLinkTime = SoftBusGetSysTimeMs();
1329 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1330 AuthConnInfo connInfo = {.type = AUTH_LINK_TYPE_P2P};
1331 uint32_t laneReqId = 10;
1332 int32_t value = 3;
1333 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1334 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1335 uint32_t requestId = 1;
1336
1337 NiceMock<LaneDepsInterfaceMock> linkMock;
1338 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1339 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1340 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1341 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND))
1342 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK)).WillOnce(Return(SOFTBUS_OK))
1343 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
1344 .WillRepeatedly(Return(SOFTBUS_OK));
1345 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1346 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
1347 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1348 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
1349 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1350 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
1351 EXPECT_CALL(linkMock, AuthGetPreferConnInfo)
1352 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(connInfo), Return(SOFTBUS_OK)));
1353 EXPECT_CALL(linkMock, AuthGetConnInfoByType)
1354 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(connInfo), Return(SOFTBUS_OK)));
1355 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1356 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1357 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
1358 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
1359 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1360 EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
1361 EXPECT_CALL(linkMock, AuthGetP2pConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1362
1363 int32_t ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1364 std::this_thread::sleep_for(std::chrono::milliseconds(500)); // delay 500ms for looper completion.
1365 EXPECT_EQ(SOFTBUS_OK, ret);
1366 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
1367 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1368 LnnDestroyP2p();
1369 }
1370
1371 /*
1372 * @tc.name: GuideChannelDetect_001
1373 * @tc.desc: test GuideChannelDetect:fist sync
1374 * LANE_ACTIVE_AUTH_NEGO(fail)->LANE_ACTIVE_BR_NEGO(fail)->LANE_PROXY_AUTH_NEGO(fail)->LANE_NEW_AUTH_NEGO(pass)
1375 * @tc.type: FUNC
1376 * @tc.require:
1377 */
1378 HWTEST_F(LNNLaneLinkTest, GuideChannelDetect_001, TestSize.Level1)
1379 {
1380 LinkRequest request = {};
1381 EXPECT_EQ(strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID), EOK);
1382 request.linkType = LANE_P2P;
1383 request.pid = ASYNCSUCC;
1384 request.triggerLinkTime = SoftBusGetSysTimeMs();
1385 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1386 AuthConnInfo connInfo = {.type = AUTH_LINK_TYPE_WIFI};
1387 uint32_t laneReqId = 11;
1388 int32_t value = 3;
1389 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1390 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1391 uint32_t requestId = 1;
1392
1393 NiceMock<LaneDepsInterfaceMock> linkMock;
1394 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1395 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1396 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1397 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND))
1398 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1399 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
1400 .WillRepeatedly(Return(SOFTBUS_OK));
1401 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1402 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(true));
1403 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1404 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_OK)));
1405 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1406 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_OK)));
1407 EXPECT_CALL(linkMock, AuthGetPreferConnInfo)
1408 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(connInfo), Return(SOFTBUS_OK)));
1409 EXPECT_CALL(linkMock, AuthGetConnInfoByType)
1410 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(connInfo), Return(SOFTBUS_OK)));
1411 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1412 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1413 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpened);
1414 EXPECT_CALL(laneLinkMock, TransProxyPipelineGenRequestId).WillRepeatedly(Return(requestId));
1415 EXPECT_CALL(laneLinkMock, TransProxyPipelineOpenChannel).WillRepeatedly(Return(SOFTBUS_LANE_BUILD_LINK_FAIL));
1416 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1417 EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
1418 EXPECT_CALL(linkMock, AuthGetP2pConnInfo).WillRepeatedly(Return(SOFTBUS_OK));
1419 EXPECT_CALL(laneLinkMock, LaneDetectReliability(laneReqId, _, _)).WillOnce(Return(SOFTBUS_LANE_DETECT_FAIL))
1420 .WillRepeatedly(laneLinkMock.ActionOfDetectSuccess);
1421
1422 int32_t ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1423 EXPECT_EQ(SOFTBUS_OK, ret);
1424 std::this_thread::sleep_for(std::chrono::milliseconds(200)); // delay 200ms for looper completion.
1425 EXPECT_EQ(SOFTBUS_OK, g_laneLinkResult);
1426 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1427 LnnDestroyP2p();
1428 }
1429
1430 /*
1431 * @tc.name: LnnCancelWifiDirect_001
1432 * @tc.desc: test cancel wifiDirect request fail
1433 * @tc.type: FUNC
1434 * @tc.require:
1435 */
1436 HWTEST_F(LNNLaneLinkTest, LnnCancelWifiDirect_001, TestSize.Level1)
1437 {
1438 LinkRequest request = {};
1439 EXPECT_EQ(strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID), EOK);
1440 request.linkType = LANE_P2P;
1441 request.pid = ASYNCSUCC;
1442 request.triggerLinkTime = SoftBusGetSysTimeMs();
1443 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1444 AuthConnInfo connInfo = {.type = AUTH_LINK_TYPE_P2P};
1445 uint32_t laneReqId = 12;
1446 int32_t value = 3;
1447 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1448 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1449 uint32_t requestId = 1;
1450
1451 NiceMock<LaneDepsInterfaceMock> linkMock;
1452 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1453 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1454 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1455 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND))
1456 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1457 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
1458 .WillRepeatedly(Return(SOFTBUS_OK));
1459 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1460 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(false));
1461 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1462 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR)));
1463 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1464 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR)));
1465 EXPECT_CALL(linkMock, AuthGetPreferConnInfo)
1466 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(connInfo), Return(SOFTBUS_OK)));
1467 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1468 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1469 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpened);
1470 EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
1471 EXPECT_CALL(laneLinkMock, TransProxyPipelineCloseChannelDelay).WillRepeatedly(Return(SOFTBUS_OK));
1472 g_laneLinkResult = SOFTBUS_INVALID_PARAM;
1473 g_manager.connectDevice = ConnectDeviceForCancel;
1474 g_manager.cancelConnectDevice = nullptr;
1475 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1476
1477 int32_t ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1478 EXPECT_EQ(SOFTBUS_OK, ret);
1479 LnnCancelWifiDirect(laneReqId);
1480 EXPECT_EQ(SOFTBUS_INVALID_PARAM, g_laneLinkResult);
1481 g_manager.cancelConnectDevice = CancelConnectDeviceFail;
1482 LnnCancelWifiDirect(laneReqId);
1483 EXPECT_EQ(SOFTBUS_INVALID_PARAM, g_laneLinkResult);
1484 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1485 LnnDestroyP2p();
1486 g_manager.connectDevice = ConnectDevice;
1487 }
1488
1489 /*
1490 * @tc.name: LnnCancelWifiDirect_002
1491 * @tc.desc: test cancel wifiDirect request for success
1492 * @tc.type: FUNC
1493 * @tc.require:
1494 */
1495 HWTEST_F(LNNLaneLinkTest, LnnCancelWifiDirect_002, TestSize.Level1)
1496 {
1497 LinkRequest request = {};
1498 EXPECT_EQ(strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID), EOK);
1499 request.linkType = LANE_P2P;
1500 request.pid = ASYNCSUCC;
1501 request.triggerLinkTime = SoftBusGetSysTimeMs();
1502 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1503 AuthConnInfo connInfo = {.type = AUTH_LINK_TYPE_P2P};
1504 uint32_t laneReqId = 12;
1505 int32_t value = 3;
1506 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1507 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1508 uint32_t requestId = 1;
1509
1510 NiceMock<LaneDepsInterfaceMock> linkMock;
1511 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1512 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1513 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1514 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND))
1515 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1516 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
1517 .WillRepeatedly(Return(SOFTBUS_OK));
1518 EXPECT_CALL(linkMock, AuthDeviceCheckConnInfo).WillOnce(Return(false)).WillRepeatedly(Return(true));
1519 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(false));
1520 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1521 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR)));
1522 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1523 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR)));
1524 EXPECT_CALL(linkMock, AuthGetPreferConnInfo)
1525 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(connInfo), Return(SOFTBUS_OK)));
1526 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1527 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1528 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpened);
1529 EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
1530 EXPECT_CALL(laneLinkMock, TransProxyPipelineCloseChannelDelay).WillRepeatedly(Return(SOFTBUS_OK));
1531 g_laneLinkResult = SOFTBUS_INVALID_PARAM;
1532 g_manager.connectDevice = ConnectDeviceForCancel;
1533 g_manager.cancelConnectDevice = CancelConnectDevice;
1534 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager));
1535
1536 int32_t ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1537 EXPECT_EQ(SOFTBUS_OK, ret);
1538 LnnCancelWifiDirect(laneReqId);
1539 EXPECT_EQ(SOFTBUS_LANE_BUILD_LINK_FAIL, g_laneLinkResult);
1540 LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1541 LnnDestroyP2p();
1542 g_manager.connectDevice = ConnectDevice;
1543 }
1544
SetCommonFunction(uint32_t laneReqId,LaneLinkType linkType,struct WifiDirectManager manager)1545 static void SetCommonFunction(uint32_t laneReqId, LaneLinkType linkType, struct WifiDirectManager manager)
1546 {
1547 LinkRequest request = {};
1548 EXPECT_EQ(strcpy_s(request.peerNetworkId, NETWORK_ID_BUF_LEN, NODE_NETWORK_ID), EOK);
1549 request.linkType = linkType;
1550 request.pid = ASYNCSUCC;
1551 request.triggerLinkTime = SoftBusGetSysTimeMs();
1552 request.availableLinkTime = DEFAULT_LINK_LATENCY;
1553 AuthConnInfo connInfo = {.type = AUTH_LINK_TYPE_P2P};
1554 int32_t value = LANEVALUE;
1555 uint64_t local = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1556 uint64_t remote = 1 << BIT_SUPPORT_NEGO_P2P_BY_CHANNEL_CAPABILITY;
1557 uint32_t requestId = 1;
1558
1559 NiceMock<LaneDepsInterfaceMock> linkMock;
1560 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1561 EXPECT_CALL(linkMock, LnnGetRemoteNumInfo)
1562 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(value), Return(SOFTBUS_OK)));
1563 EXPECT_CALL(linkMock, LnnGetRemoteStrInfo).WillOnce(Return(SOFTBUS_NOT_FIND))
1564 .WillOnce(Return(SOFTBUS_NOT_FIND)).WillOnce(Return(SOFTBUS_OK))
1565 .WillOnce(DoAll(SetArrayArgument<LANE_MOCK_PARAM3>(BRMAC, BRMAC + BT_MAC_LEN), Return(SOFTBUS_OK)))
1566 .WillRepeatedly(Return(SOFTBUS_OK));
1567 EXPECT_CALL(linkMock, CheckActiveConnection).WillRepeatedly(Return(false));
1568 EXPECT_CALL(linkMock, LnnGetLocalNumU64Info)
1569 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(local), Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR)));
1570 EXPECT_CALL(linkMock, LnnGetRemoteNumU64Info)
1571 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM3>(remote), Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR)));
1572 EXPECT_CALL(linkMock, AuthGetPreferConnInfo)
1573 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(connInfo), Return(SOFTBUS_OK)));
1574 EXPECT_CALL(laneLinkMock, GetTransReqInfoByLaneReqId).WillRepeatedly(Return(SOFTBUS_OK));
1575 EXPECT_CALL(linkMock, AuthGenRequestId).WillRepeatedly(Return(requestId));
1576 EXPECT_CALL(linkMock, AuthOpenConn(_, requestId, NotNull(), _)).WillRepeatedly(linkMock.ActionOfConnOpened);
1577 EXPECT_CALL(linkMock, AuthCloseConn).WillRepeatedly(Return());
1578 EXPECT_CALL(laneLinkMock, TransProxyPipelineCloseChannelDelay).WillRepeatedly(Return(SOFTBUS_OK));
1579 g_laneLinkResult = SOFTBUS_INVALID_PARAM;
1580 g_manager.connectDevice = ConnectDeviceForCancel;
1581 g_manager.cancelConnectDevice = CancelConnectDevice;
1582 EXPECT_CALL(linkMock, GetWifiDirectManager).WillRepeatedly(Return(&manager));
1583
1584 int32_t ret = LnnConnectP2p(&request, laneReqId, &g_linkCb);
1585 EXPECT_EQ(SOFTBUS_OK, ret);
1586 }
1587
1588 /*
1589 * @tc.name: LnnCancelWifiDirect_003
1590 * @tc.desc: test cancel wifiDirect request for success
1591 * @tc.type: FUNC
1592 * @tc.require:
1593 */
1594 HWTEST_F(LNNLaneLinkTest, LnnCancelWifiDirect_003, TestSize.Level1)
1595 {
1596 uint32_t laneReqId = LANEREQID;
1597 SetCommonFunction(laneReqId, LANE_HML_RAW, g_manager);
1598 laneReqId = LANEREQID + 1;
1599 LnnCancelWifiDirect(laneReqId);
1600 EXPECT_EQ(SOFTBUS_INVALID_PARAM, g_laneLinkResult);
1601 laneReqId = LANEREQID;
1602 LnnCancelWifiDirect(laneReqId);
1603 EXPECT_EQ(SOFTBUS_INVALID_PARAM, g_laneLinkResult);
1604 int32_t ret = LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1605 EXPECT_EQ(SOFTBUS_LANE_RESOURCE_NOT_FOUND, ret);
1606 LnnDestroyP2p();
1607 g_manager.connectDevice = ConnectDevice;
1608 }
1609
1610 /*
1611 * @tc.name: LnnCancelWifiDirect_004
1612 * @tc.desc: test cancel wifiDirect request for success
1613 * @tc.type: FUNC
1614 * @tc.require:
1615 */
1616 HWTEST_F(LNNLaneLinkTest, LnnCancelWifiDirect_004, TestSize.Level1)
1617 {
1618 uint32_t laneReqId = LANEREQID;
1619 SetCommonFunction(laneReqId, LANE_HML_RAW, g_manager3);
1620 LnnCancelWifiDirect(laneReqId);
1621 EXPECT_EQ(SOFTBUS_INVALID_PARAM, g_laneLinkResult);
1622 int32_t ret = LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1623 EXPECT_EQ(SOFTBUS_LANE_RESOURCE_NOT_FOUND, ret);
1624 LnnDestroyP2p();
1625 g_manager.connectDevice = ConnectDevice;
1626 }
1627
1628 /*
1629 * @tc.name: LnnCancelWifiDirect_005
1630 * @tc.desc: test cancel wifiDirect request for success
1631 * @tc.type: FUNC
1632 * @tc.require:
1633 */
1634 HWTEST_F(LNNLaneLinkTest, LnnCancelWifiDirect_005, TestSize.Level1)
1635 {
1636 uint32_t laneReqId = LANEREQID;
1637 SetCommonFunction(laneReqId, LANE_HML_RAW, g_manager2);
1638 LnnCancelWifiDirect(laneReqId);
1639 EXPECT_EQ(SOFTBUS_INVALID_PARAM, g_laneLinkResult);
1640 int32_t ret = LnnDisconnectP2p(NODE_NETWORK_ID, laneReqId);
1641 EXPECT_EQ(SOFTBUS_LANE_RESOURCE_NOT_FOUND, ret);
1642 LnnDestroyP2p();
1643 g_manager.connectDevice = ConnectDevice;
1644 }
1645
1646 /*
1647 * @tc.name: LnnCancelWifiDirect_006
1648 * @tc.desc: test cancel wifiDirect request for success
1649 * @tc.type: FUNC
1650 * @tc.require:
1651 */
1652 HWTEST_F(LNNLaneLinkTest, LnnCancelWifiDirect_006, TestSize.Level1)
1653 {
1654 uint32_t laneReqId = LANEREQID;
1655 SetCommonFunction(laneReqId, LANE_P2P, g_manager);
1656 LnnDisconnectP2pWithoutLnn(laneReqId);
1657 laneReqId = LANEREQID15;
1658 LnnDisconnectP2pWithoutLnn(laneReqId);
1659 }
1660
1661 /*
1662 * @tc.name: GET_MAC_INFO_BY_LANE_ID_TEST_001
1663 * @tc.desc: GetMacInfoByLaneId test
1664 * @tc.type: FUNC
1665 * @tc.require:
1666 */
1667 HWTEST_F(LNNLaneLinkTest, GET_MAC_INFO_BY_LANE_ID_TEST_001, TestSize.Level1)
1668 {
1669 uint64_t laneId = INVALID_LANE_ID;
1670 LnnMacInfo macInfo;
1671 memset_s(&macInfo, sizeof(LnnMacInfo), 0, sizeof(LnnMacInfo));
1672 int32_t ret = GetMacInfoByLaneId(laneId, &macInfo);
1673 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1674 ret = GetMacInfoByLaneId(USEABLE_LANE_ID, NULL);
1675 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
1676 }
1677
1678 /*
1679 * @tc.name: GET_MAC_INFO_BY_LANE_ID_MOCK_TEST_002
1680 * @tc.desc: GetMacInfoByLaneId test
1681 * @tc.type: FUNC
1682 * @tc.require:
1683 */
1684 HWTEST_F(LNNLaneLinkTest, GET_MAC_INFO_BY_LANE_ID_MOCK_TEST_002, TestSize.Level1)
1685 {
1686 NiceMock<LaneDepsInterfaceMock> laneMock;
1687 NiceMock<LaneLinkDepsInterfaceMock> laneDepMock;
1688 int32_t ret = InitLaneLink();
1689 EXPECT_TRUE(ret == SOFTBUS_OK);
1690 LnnMacInfo macInfo;
1691 LaneResource resource = {
1692 .laneId = USEABLE_LANE_ID,
1693 .link.type = LANE_HML,
1694 };
1695 EXPECT_EQ(strcpy_s(resource.link.linkInfo.wlan.connInfo.addr, MAX_SOCKET_ADDR_LEN, USEABLE_IP), EOK);
1696 memset_s(&macInfo, sizeof(LnnMacInfo), 0, sizeof(LnnMacInfo));
1697 EXPECT_CALL(laneMock, GetWifiDirectManager).WillOnce(Return(NULL)).WillRepeatedly(Return(&manager));
1698 EXPECT_CALL(laneDepMock, FindLaneResourceByLaneId).WillOnce(Return(SOFTBUS_LANE_RESOURCE_NOT_FOUND))
1699 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(resource), Return(SOFTBUS_OK)));
1700 EXPECT_CALL(laneDepMock, DelLaneResourceByLaneId).WillRepeatedly(Return(SOFTBUS_OK));
1701 ret = GetMacInfoByLaneId(USEABLE_LANE_ID, &macInfo);
1702 EXPECT_EQ(ret, SOFTBUS_LANE_RESOURCE_NOT_FOUND);
1703 ret = GetMacInfoByLaneId(USEABLE_LANE_ID, &macInfo);
1704 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1705
1706 ret = DelLaneResourceByLaneId(USEABLE_LANE_ID, false);
1707 EXPECT_EQ(ret, SOFTBUS_OK);
1708 }
1709
1710 /*
1711 * @tc.name: CHECK_IS_AUTH_SESSION_SERVER_TEST_002
1712 * @tc.desc: CheckIsAuthSessionServer test
1713 * @tc.type: FUNC
1714 * @tc.require:
1715 */
1716 HWTEST_F(LNNLaneLinkTest, CHECK_IS_AUTH_SESSION_SERVER_TEST_002, TestSize.Level1)
1717 {
1718 const char *peerIp = "192.168.33.33";
1719 bool isServer = true;
1720 LnnDisconnectP2pWithoutLnn(0);
1721 EXPECT_EQ(CheckIsAuthSessionServer(nullptr, &isServer), SOFTBUS_INVALID_PARAM);
1722 EXPECT_EQ(CheckIsAuthSessionServer(peerIp, nullptr), SOFTBUS_INVALID_PARAM);
1723 EXPECT_EQ(CheckIsAuthSessionServer(peerIp, &isServer), SOFTBUS_NOT_FIND);
1724 EXPECT_EQ(RemoveAuthSessionServer(nullptr), SOFTBUS_INVALID_PARAM);
1725 EXPECT_EQ(RemoveAuthSessionServer(peerIp), SOFTBUS_NOT_FIND);
1726 }
1727
1728 /*
1729 * @tc.name: LNN_LANE_LINK_P2P_TEST_001
1730 * @tc.desc: LnnLaneLinkP2P test
1731 * @tc.type: FUNC
1732 * @tc.require:
1733 */
1734 HWTEST_F(LNNLaneLinkTest, LNN_LANE_LINK_P2P_TEST_001, TestSize.Level1)
1735 {
1736 bool isServer;
1737 int32_t ret = CheckIsAuthSessionServer(nullptr, &isServer);
1738 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1739 ret = CheckIsAuthSessionServer("192.168.11.12", nullptr);
1740 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1741 ret = CheckIsAuthSessionServer(nullptr, nullptr);
1742 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1743 }
1744
1745 /*
1746 * @tc.name: LNN_LANE_LINK_P2P_TEST_002
1747 * @tc.desc: LnnLaneLinkP2P test
1748 * @tc.type: FUNC
1749 * @tc.require:
1750 */
1751 HWTEST_F(LNNLaneLinkTest, LNN_LANE_LINK_P2P_TEST_002, TestSize.Level1)
1752 {
1753 bool isServer;
1754 uint32_t laneReqId = LANEREQID;
1755 SetCommonFunction(laneReqId, LANE_P2P, g_manager);
1756 int32_t ret = CheckIsAuthSessionServer("192.168.11.12", &isServer);
1757 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
1758 }
1759
1760 /*
1761 * @tc.name: LNN_LANE_LINK_P2P_TEST_003
1762 * @tc.desc: LnnLaneLinkP2P test
1763 * @tc.type: FUNC
1764 * @tc.require:
1765 */
1766 HWTEST_F(LNNLaneLinkTest, LNN_LANE_LINK_P2P_TEST_003, TestSize.Level1)
1767 {
1768 int32_t ret = RemoveAuthSessionServer(nullptr);
1769 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1770 uint32_t laneReqId = LANEREQID;
1771 SetCommonFunction(laneReqId, LANE_P2P, g_manager);
1772 ret = RemoveAuthSessionServer("192.168.1.1");
1773 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
1774 }
1775
1776 /*
1777 * @tc.name: LNN_LANE_LINK_P2P_TEST_004
1778 * @tc.desc: LnnLaneLinkP2P test
1779 * @tc.type: FUNC
1780 * @tc.require:
1781 */
1782 HWTEST_F(LNNLaneLinkTest, LNN_LANE_LINK_P2P_TEST_004, TestSize.Level1)
1783 {
1784 LanePreferredLinkList recommendList = {};
1785 LanePreferredLinkList request = {};
1786 request.linkTypeNum = 1;
1787 request.linkType[0] = LANE_HML;
1788 NiceMock<LaneDepsInterfaceMock> mock;
1789 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1790
1791 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_LANE_GET_LEDGER_INFO_ERR));
1792 int32_t ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1793 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1794
1795 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1796 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_OK));
1797 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager6));
1798 ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1799 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1800
1801 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_ERR));
1802 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager6));
1803 ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1804 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1805
1806 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_OK));
1807 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager5));
1808 ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1809 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1810
1811 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_ERR));
1812 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager5));
1813 ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1814 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1815 }
1816
1817 /*
1818 * @tc.name: LNN_LANE_LINK_P2P_TEST_005
1819 * @tc.desc: LnnLaneLinkP2P test
1820 * @tc.type: FUNC
1821 * @tc.require:
1822 */
1823 HWTEST_F(LNNLaneLinkTest, LNN_LANE_LINK_P2P_TEST_005, TestSize.Level1)
1824 {
1825 NiceMock<LaneDepsInterfaceMock> mock;
1826 LanePreferredLinkList recommendList = {};
1827 LanePreferredLinkList request = {};
1828 request.linkTypeNum = 1;
1829 request.linkType[0] = LANE_P2P;
1830 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1831
1832 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1833 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_OK));
1834 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager6));
1835 int32_t ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1836 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1837
1838 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_OK));
1839 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager5));
1840 ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1841 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1842
1843 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_ERR));
1844 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager6));
1845 ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1846 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1847
1848 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_ERR));
1849 EXPECT_CALL(mock, GetWifiDirectManager).WillRepeatedly(Return(&g_manager5));
1850 ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1851 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1852 }
1853
1854 /*
1855 * @tc.name: LNN_LANE_LINK_P2P_TEST_006
1856 * @tc.desc: LnnLaneLinkP2P test
1857 * @tc.type: FUNC
1858 * @tc.require:
1859 */
1860 HWTEST_F(LNNLaneLinkTest, LNN_LANE_LINK_P2P_TEST_006, TestSize.Level1)
1861 {
1862 LanePreferredLinkList recommendList = {};
1863 LanePreferredLinkList request = {};
1864 request.linkTypeNum = 1;
1865 request.linkType[0] = LANE_ETH;
1866
1867 int32_t ret = SelectAuthLane(NODE_NETWORK_ID, &request, &recommendList);
1868 EXPECT_EQ(ret, SOFTBUS_LANE_NO_AVAILABLE_LINK);
1869 }
1870
1871 /*
1872 * @tc.name: LNN_LANE_SELECT_01
1873 * @tc.desc: lnn_lane_select test
1874 * @tc.type: FUNC
1875 * @tc.require:
1876 */
1877 HWTEST_F(LNNLaneLinkTest, LNN_LANE_SELECT_01, TestSize.Level1)
1878 {
1879 NiceMock<LaneDepsInterfaceMock> mock;
1880 LanePreferredLinkList recommendList = {};
1881 LaneSelectParam request = {};
1882 request.qosRequire.minBW = MESH_MAGIC_NUMBER;
1883 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1884 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &request, &recommendList);
1885 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_NOT_ONLINE);
1886 }
1887
1888 /*
1889 * @tc.name: LNN_LANE_SELECT_02
1890 * @tc.desc: lnn_lane_select test
1891 * @tc.type: FUNC
1892 * @tc.require:
1893 */
1894 HWTEST_F(LNNLaneLinkTest, LNN_LANE_SELECT_02, TestSize.Level1)
1895 {
1896 NiceMock<LaneDepsInterfaceMock> mock;
1897 LanePreferredLinkList recommendList = {};
1898 LaneSelectParam request = {};
1899 request.qosRequire.minBW = DB_MAGIC_NUMBER;
1900 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1901 EXPECT_CALL(mock, LnnGetOsTypeByNetworkId).WillRepeatedly(Return(SOFTBUS_ERR));
1902 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &request, &recommendList);
1903 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_NOT_ONLINE);
1904 }
1905
1906 /*
1907 * @tc.name: LNN_LANE_SELECT_03
1908 * @tc.desc: lnn_lane_select test
1909 * @tc.type: FUNC
1910 * @tc.require:
1911 */
1912 HWTEST_F(LNNLaneLinkTest, LNN_LANE_SELECT_03, TestSize.Level1)
1913 {
1914 NiceMock<LaneDepsInterfaceMock> mock;
1915 LanePreferredLinkList recommendList = {};
1916 LaneSelectParam request = {};
1917 request.qosRequire.minBW = DB_MAGIC_NUMBER;
1918 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1919 int32_t osType = OH_OS_TYPE;
1920 EXPECT_CALL(mock, LnnGetOsTypeByNetworkId)
1921 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
1922 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &request, &recommendList);
1923 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_NOT_ONLINE);
1924 }
1925
1926 /*
1927 * @tc.name: LNN_LANE_SELECT_04
1928 * @tc.desc: lnn_lane_select test
1929 * @tc.type: FUNC
1930 * @tc.require:
1931 */
1932 HWTEST_F(LNNLaneLinkTest, LNN_LANE_SELECT_04, TestSize.Level1)
1933 {
1934 NiceMock<LaneDepsInterfaceMock> mock;
1935 LanePreferredLinkList recommendList = {};
1936 LaneSelectParam request = {};
1937 request.qosRequire.minBW = DB_MAGIC_NUMBER;
1938 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1939 int32_t osType = OH_OS_TYPE + 1;
1940 EXPECT_CALL(mock, LnnGetOsTypeByNetworkId)
1941 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
1942 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_ERR));
1943 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &request, &recommendList);
1944 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_NOT_ONLINE);
1945 }
1946
1947 /*
1948 * @tc.name: LNN_LANE_SELECT_05
1949 * @tc.desc: lnn_lane_select test
1950 * @tc.type: FUNC
1951 * @tc.require:
1952 */
1953 HWTEST_F(LNNLaneLinkTest, LNN_LANE_SELECT_05, TestSize.Level1)
1954 {
1955 NiceMock<LaneDepsInterfaceMock> mock;
1956 NiceMock<LaneLinkDepsInterfaceMock> laneLinkMock;
1957 LanePreferredLinkList recommendList = {};
1958 LaneSelectParam request = {};
1959 request.qosRequire.minBW = DB_MAGIC_NUMBER;
1960 EXPECT_CALL(mock, LnnGetOnlineStateById).WillRepeatedly(Return(true));
1961 int32_t osType = OH_OS_TYPE + 1;
1962 EXPECT_CALL(mock, LnnGetOsTypeByNetworkId)
1963 .WillRepeatedly(DoAll(SetArgPointee<LANE_MOCK_PARAM2>(osType), Return(SOFTBUS_OK)));
1964 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
1965 EXPECT_CALL(laneLinkMock, FindLaneResourceByLinkType).WillRepeatedly(Return(SOFTBUS_OK));
1966 int32_t ret = SelectExpectLanesByQos(NODE_NETWORK_ID, &request, &recommendList);
1967 EXPECT_EQ(ret, SOFTBUS_LANE_WIFI_NOT_ONLINE);
1968 }
1969 } // namespace OHOS
1970