1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #include <thread>
20
21 #include "auth_device.c"
22 #include "auth_interface.c"
23 #include "auth_interface.h"
24 #include "auth_lane.c"
25 #include "auth_lane_mock.h"
26 #include "auth_log.h"
27 #include "auth_manager.c"
28 #include "auth_manager.h"
29 #include "lnn_lane_common.h"
30 #include "lnn_trans_lane.h"
31
32 using namespace testing::ext;
33 using namespace testing;
34
35 namespace OHOS {
36
37 const uint64_t CONN_ID = 10 | ((uint64_t)AUTH_LINK_TYPE_WIFI << INT32_BIT_NUM);
38 constexpr char NETWORK_ID[] = "testnetworkid123";
39 constexpr char UUID_TEST[UUID_BUF_LEN] = "testId123";
40 constexpr char UDID_TEST[UDID_BUF_LEN] = "testId123";
41 constexpr char IP_TEST[IP_LEN] = "192.168.51.170";
42 constexpr char BR_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
43 constexpr char BLE_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
44 constexpr uint8_t DEVICE_ID_HASH[UDID_HASH_LEN] = "123456789";
45 constexpr int64_t AUTH_SEQ = 1;
46 constexpr int32_t DEVICE_ID_HASH_LEN = 9;
47 constexpr int32_t PORT = 1;
48
OnConnOpenedTest(uint32_t requestId,AuthHandle authHandle)49 static void OnConnOpenedTest(uint32_t requestId, AuthHandle authHandle)
50 {
51 (void)requestId;
52 (void)authHandle;
53 AUTH_LOGI(
54 AUTH_TEST, "OnConnOpenedTest: requestId=%{public}d, authId=%{public}" PRId64 "", requestId, authHandle.authId);
55 }
56
OnConnOpenFailedTest(uint32_t requestId,int32_t reason)57 static void OnConnOpenFailedTest(uint32_t requestId, int32_t reason)
58 {
59 (void)requestId;
60 (void)reason;
61 AUTH_LOGI(AUTH_TEST, "OnConnOpenFailedTest: requestId=%{public}d, reason=%{public}d.", requestId, reason);
62 }
63
64 static AuthConnCallback authConnCb = {
65 .onConnOpened = OnConnOpenedTest,
66 .onConnOpenFailed = OnConnOpenFailedTest,
67 };
68
69 class AuthLaneTest : public testing::Test {
70 public:
AuthLaneTest()71 AuthLaneTest() { }
~AuthLaneTest()72 ~AuthLaneTest() { }
73 static void SetUpTestCase(void);
74 static void TearDownTestCase(void);
SetUp()75 void SetUp() override { }
TearDown()76 void TearDown() override { }
77 };
78
SetUpTestCase()79 void AuthLaneTest::SetUpTestCase()
80 {
81 int32_t ret = LooperInit();
82 EXPECT_TRUE(ret == SOFTBUS_OK);
83 ret = LnnInitDistributedLedger();
84 EXPECT_TRUE(ret == SOFTBUS_OK);
85 ret = LnnInitLocalLedger();
86 EXPECT_TRUE(ret == SOFTBUS_OK);
87 ret = LnnInitLnnLooper();
88 EXPECT_EQ(ret, SOFTBUS_OK);
89 ret = InitLane();
90 EXPECT_TRUE(ret == SOFTBUS_OK);
91 GTEST_LOG_(INFO) << "AuthLaneTest start";
92 }
93
TearDownTestCase()94 void AuthLaneTest::TearDownTestCase()
95 {
96 DeinitLane();
97 LnnDeinitLocalLedger();
98 LnnDeinitDistributedLedger();
99 LooperDeinit();
100 GTEST_LOG_(INFO) << "AuthLaneTest end";
101 }
102
SetAuthSessionInfo(AuthSessionInfo * info,uint64_t connId,bool isServer,AuthLinkType type)103 static void SetAuthSessionInfo(AuthSessionInfo *info, uint64_t connId, bool isServer, AuthLinkType type)
104 {
105 (void)memset_s(info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
106 info->connId = connId;
107 info->isServer = isServer;
108 info->connInfo.type = type;
109 info->version = SOFTBUS_NEW_V2;
110 ASSERT_TRUE(memcpy_s(info->udid, UDID_BUF_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
111 ASSERT_TRUE(memcpy_s(info->uuid, UUID_BUF_LEN, UUID_TEST, strlen(UUID_TEST)) == EOK);
112 switch (type) {
113 case AUTH_LINK_TYPE_WIFI:
114 ASSERT_TRUE(memcpy_s(info->connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
115 break;
116 case AUTH_LINK_TYPE_BLE:
117 ASSERT_TRUE(memcpy_s(info->connInfo.info.bleInfo.bleMac, BT_MAC_LEN, BLE_MAC, strlen(BLE_MAC)) == EOK);
118 ASSERT_TRUE(memcpy_s(info->connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN,
119 DEVICE_ID_HASH, DEVICE_ID_HASH_LEN) == EOK);
120 break;
121 case AUTH_LINK_TYPE_BR:
122 ASSERT_TRUE(memcpy_s(info->connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
123 break;
124 case AUTH_LINK_TYPE_P2P:
125 case AUTH_LINK_TYPE_ENHANCED_P2P:
126 ASSERT_TRUE(memcpy_s(info->connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
127 info->connInfo.info.ipInfo.port = PORT;
128 break;
129 default:
130 break;
131 }
132 }
133
134 /*
135 * @tc.name: ADD_AUTH_REQUEST_NODE_TEST_001
136 * @tc.desc: add auth request node test
137 * @tc.type: FUNC
138 * @tc.require:
139 */
140 HWTEST_F(AuthLaneTest, ADD_AUTH_REQUEST_NODE_TEST_001, TestSize.Level1)
141 {
142 uint32_t laneReqId = 1;
143 uint32_t authRequestId = 1;
144
145 InitAuthReqInfo();
146 ListInit(&g_authClientList);
147 ListInit(&g_authServerList);
148 AuthCommonInit();
149 AuthLaneInterfaceMock mock;
150 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
151 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
152 int32_t ret = AddAuthReqNode(nullptr, laneReqId, authRequestId, &authConnCb);
153 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
154
155 ret = AddAuthReqNode(NETWORK_ID, INVALID_LANE_REQ_ID, authRequestId, &authConnCb);
156 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
157
158 ret = AddAuthReqNode(NETWORK_ID, laneReqId, authRequestId, nullptr);
159 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
160
161 ret = AddAuthReqNode(NETWORK_ID, laneReqId, authRequestId, &authConnCb);
162 EXPECT_TRUE(ret == SOFTBUS_OK);
163
164 LaneConnInfo info;
165 (void)memset_s(&info, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
166 AuthOnLaneAllocSuccess(laneReqId, &info);
167
168 AuthHandle authHandle;
169 (void)memset_s(&info, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
170 authHandle.authId = 1;
171 authHandle.type = AUTH_LINK_TYPE_WIFI;
172 OnAuthConnOpenedSucc(authRequestId, authHandle);
173
174 ret = DelAuthReqInfoByAuthHandle(&authHandle);
175 EXPECT_TRUE(ret == SOFTBUS_OK);
176 DestroyAuthManagerList();
177 AuthCommonDeinit();
178 DeInitAuthReqInfo();
179 }
180
181 /*
182 * @tc.name: AUTH_GET_REQUEST_OPTION_TEST_001
183 * @tc.desc: auth get request option test test
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(AuthLaneTest, AUTH_GET_REQUEST_OPTION_TEST_001, TestSize.Level1)
188 {
189 AuthLaneInterfaceMock mock;
190 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
191 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
192 LaneAllocInfo allocInfo;
193 (void)memset_s(&allocInfo, sizeof(LaneAllocInfo), 0, sizeof(LaneAllocInfo));
194
195 int32_t ret = AuthGetLaneAllocInfo(nullptr, &allocInfo);
196 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
197
198 ret = AuthGetLaneAllocInfo(NETWORK_ID, nullptr);
199 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
200
201 ret = AuthGetLaneAllocInfo(NETWORK_ID, &allocInfo);
202 EXPECT_TRUE(ret == SOFTBUS_OK);
203 }
204
205 /*
206 * @tc.name: GET_AUTH_LINK_TYPE_LIST_TEST_001
207 * @tc.desc: get auth link type list test
208 * @tc.type: FUNC
209 * @tc.require:
210 */
211 HWTEST_F(AuthLaneTest, GET_AUTH_LINK_TYPE_LIST_TEST_001, TestSize.Level1)
212 {
213 AuthLinkTypeList linkTypeList;
214 (void)memset_s(&linkTypeList, sizeof(AuthLinkTypeList), 0, sizeof(AuthLinkTypeList));
215
216 AuthLaneInterfaceMock mock;
217 EXPECT_CALL(mock, LnnGetRemoteStrInfo).WillRepeatedly(Return(SOFTBUS_OK));
218
219 int32_t ret = GetAuthLinkTypeList(nullptr, &linkTypeList);
220 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
221
222 ret = GetAuthLinkTypeList(NETWORK_ID, nullptr);
223 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
224
225 ret = GetAuthLinkTypeList(NETWORK_ID, &linkTypeList);
226 EXPECT_NE(ret, SOFTBUS_OK);
227 }
228
229 /*
230 * @tc.name: AUTH_ALLOC_LANE_001
231 * @tc.desc: auth alloc lane test
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_001, TestSize.Level1)
236 {
237 InitAuthReqInfo();
238 ListInit(&g_authClientList);
239 ListInit(&g_authServerList);
240 AuthCommonInit();
241 uint32_t authRequestId = 0;
242
243 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, nullptr);
244 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
245
246 ret = AuthAllocLane(nullptr, authRequestId, &authConnCb);
247 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
248
249 AuthLaneInterfaceMock mock;
250 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
251 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
252 ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
253 EXPECT_NE(ret, SOFTBUS_OK);
254 DestroyAuthManagerList();
255 AuthCommonDeinit();
256 DeInitAuthReqInfo();
257 }
258
259 /*
260 * @tc.name: AUTH_ALLOC_LANE_WLAN_001
261 * @tc.desc: auth alloc lane wlan test
262 * @tc.type: FUNC
263 * @tc.require:
264 */
265 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_WLAN_001, TestSize.Level1)
266 {
267 InitAuthReqInfo();
268 ListInit(&g_authClientList);
269 ListInit(&g_authServerList);
270 AuthCommonInit();
271 AuthLaneInterfaceMock mock;
272 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
273 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
274
275 AuthSessionInfo info;
276 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_WIFI);
277 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
278 AuthConnInfo connInfo;
279 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
280 connInfo.type = AUTH_LINK_TYPE_WIFI;
281 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
282 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
283 EXPECT_TRUE(auth != nullptr);
284 auth->hasAuthPassed[AUTH_LINK_TYPE_WIFI] = true;
285 auth->authId = 1;
286 auth->lastVerifyTime = 1;
287
288 uint32_t authRequestId = AuthGenRequestId();
289 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
290 EXPECT_NE(ret, SOFTBUS_OK);
291
292 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
293 LaneConnInfo laneConnInfo;
294 (void)memset_s(&laneConnInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
295 laneConnInfo.laneId = 1;
296 laneConnInfo.type = LANE_WLAN_5G;
297 AuthOnLaneAllocSuccess(laneReqId, &laneConnInfo);
298
299 DelAuthManager(auth, connInfo.type);
300 DestroyAuthManagerList();
301 AuthCommonDeinit();
302 DeInitAuthReqInfo();
303 }
304
305 /*
306 * @tc.name: AUTH_ALLOC_LANE_WLAN_002
307 * @tc.desc: AuthDeviceOpenConn return SOFTBUS_AUTH_NOT_FOUND
308 * @tc.type: FUNC
309 * @tc.require:
310 */
311 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_WLAN_002, TestSize.Level1)
312 {
313 InitAuthReqInfo();
314 ListInit(&g_authClientList);
315 ListInit(&g_authServerList);
316 AuthCommonInit();
317 AuthLaneInterfaceMock mock;
318 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
319 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
320
321 AuthSessionInfo info;
322 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_WIFI);
323 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
324 AuthConnInfo connInfo;
325 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
326 connInfo.type = AUTH_LINK_TYPE_WIFI;
327 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
328 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
329 EXPECT_TRUE(auth != nullptr);
330 auth->hasAuthPassed[AUTH_LINK_TYPE_WIFI] = true;
331
332 uint32_t authRequestId = AuthGenRequestId();
333 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
334 EXPECT_NE(ret, SOFTBUS_OK);
335
336 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
337 LaneConnInfo laneConnInfo;
338 (void)memset_s(&laneConnInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
339 laneConnInfo.laneId = 1;
340 laneConnInfo.type = LANE_WLAN_5G;
341 AuthOnLaneAllocSuccess(laneReqId, &laneConnInfo);
342
343 DelAuthManager(auth, connInfo.type);
344 DestroyAuthManagerList();
345 AuthCommonDeinit();
346 DeInitAuthReqInfo();
347 }
348
349 /*
350 * @tc.name: AUTH_ALLOC_LANE_WLAN_003
351 * @tc.desc: AuthOnLaneAllocFail
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_WLAN_003, TestSize.Level1)
356 {
357 InitAuthReqInfo();
358 ListInit(&g_authClientList);
359 ListInit(&g_authServerList);
360 AuthCommonInit();
361 AuthLaneInterfaceMock mock;
362 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
363 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
364
365 AuthSessionInfo info;
366 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_WIFI);
367 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
368 AuthConnInfo connInfo;
369 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
370 connInfo.type = AUTH_LINK_TYPE_WIFI;
371 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
372 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
373 EXPECT_TRUE(auth != nullptr);
374 auth->hasAuthPassed[AUTH_LINK_TYPE_WIFI] = true;
375
376 uint32_t authRequestId = AuthGenRequestId();
377 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
378 EXPECT_NE(ret, SOFTBUS_OK);
379
380 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
381 AuthOnLaneAllocFail(laneReqId, SOFTBUS_INVALID_PARAM);
382
383 DelAuthManager(auth, connInfo.type);
384 DestroyAuthManagerList();
385 AuthCommonDeinit();
386 DeInitAuthReqInfo();
387 }
388
389 /*
390 * @tc.name: AUTH_ALLOC_LANE_BLE_001
391 * @tc.desc: auth alloc lane ble test
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_BLE_001, TestSize.Level1)
396 {
397 InitAuthReqInfo();
398 ListInit(&g_authClientList);
399 ListInit(&g_authServerList);
400 AuthCommonInit();
401 AuthLaneInterfaceMock mock;
402 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
403 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
404
405 AuthSessionInfo info;
406 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_BLE);
407 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
408 AuthConnInfo connInfo;
409 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
410 connInfo.type = AUTH_LINK_TYPE_BLE;
411 ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.bleMac, BT_MAC_LEN, BLE_MAC, strlen(BLE_MAC)) == EOK);
412 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
413 EXPECT_TRUE(auth != nullptr);
414 auth->hasAuthPassed[AUTH_LINK_TYPE_BLE] = true;
415 auth->authId = 1;
416 auth->lastVerifyTime = 1;
417
418 uint32_t authRequestId = AuthGenRequestId();
419 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
420 EXPECT_NE(ret, SOFTBUS_OK);
421
422 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
423 LaneConnInfo laneConnInfo;
424 (void)memset_s(&laneConnInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
425 laneConnInfo.laneId = 1;
426 laneConnInfo.type = LANE_BLE;
427 AuthOnLaneAllocSuccess(laneReqId, &laneConnInfo);
428
429 DelAuthManager(auth, connInfo.type);
430 DestroyAuthManagerList();
431 AuthCommonDeinit();
432 DeInitAuthReqInfo();
433 }
434
435 /*
436 * @tc.name: AUTH_ALLOC_LANE_BR_001
437 * @tc.desc: auth alloc lane br test
438 * @tc.type: FUNC
439 * @tc.require:
440 */
441 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_BR_001, TestSize.Level1)
442 {
443 InitAuthReqInfo();
444 ListInit(&g_authClientList);
445 ListInit(&g_authServerList);
446 AuthCommonInit();
447 AuthLaneInterfaceMock mock;
448 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
449 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
450
451 AuthSessionInfo info;
452 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_BR);
453 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
454 AuthConnInfo connInfo;
455 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
456 connInfo.type = AUTH_LINK_TYPE_BR;
457 ASSERT_TRUE(memcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
458 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
459 EXPECT_TRUE(auth != nullptr);
460 auth->hasAuthPassed[AUTH_LINK_TYPE_BR] = true;
461 auth->authId = 1;
462 auth->lastVerifyTime = 1;
463
464 uint32_t authRequestId = AuthGenRequestId();
465 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
466 EXPECT_NE(ret, SOFTBUS_OK);
467
468 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
469 LaneConnInfo laneConnInfo;
470 (void)memset_s(&laneConnInfo, sizeof(LaneConnInfo), 0, sizeof(LaneConnInfo));
471 laneConnInfo.laneId = 1;
472 laneConnInfo.type = LANE_BR;
473 AuthOnLaneAllocSuccess(laneReqId, &laneConnInfo);
474
475 DelAuthManager(auth, connInfo.type);
476 DestroyAuthManagerList();
477 AuthCommonDeinit();
478 DeInitAuthReqInfo();
479 }
480
481 /*
482 * @tc.name: AUTH_ALLOC_LANE_P2P_001
483 * @tc.desc: IsReuseP2p return false
484 * @tc.type: FUNC
485 * @tc.require:
486 */
487 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_P2P_001, TestSize.Level1)
488 {
489 InitAuthReqInfo();
490 ListInit(&g_authClientList);
491 ListInit(&g_authServerList);
492 AuthCommonInit();
493 AuthLaneInterfaceMock mock;
494 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
495 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
496
497 AuthSessionInfo info;
498 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_P2P);
499 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
500 AuthConnInfo connInfo;
501 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
502 connInfo.type = AUTH_LINK_TYPE_P2P;
503 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
504 connInfo.info.ipInfo.port = PORT;
505 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
506 EXPECT_TRUE(auth != nullptr);
507 auth->hasAuthPassed[AUTH_LINK_TYPE_P2P] = true;
508 auth->authId = 1;
509 auth->lastVerifyTime = 1;
510
511 uint32_t authRequestId = AuthGenRequestId();
512 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
513 EXPECT_NE(ret, SOFTBUS_OK);
514
515 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
516 AuthOnLaneAllocFail(laneReqId, SOFTBUS_INVALID_PARAM);
517
518 DelAuthManager(auth, connInfo.type);
519 DestroyAuthManagerList();
520 AuthCommonDeinit();
521 DeInitAuthReqInfo();
522 }
523
524 /*
525 * @tc.name: AUTH_ALLOC_LANE_ENHANCED_P2P_001
526 * @tc.desc: IsReuseP2p return false
527 * @tc.type: FUNC
528 * @tc.require:
529 */
530 HWTEST_F(AuthLaneTest, AUTH_ALLOC_LANE_ENHANCED_P2P_001, TestSize.Level1)
531 {
532 InitAuthReqInfo();
533 ListInit(&g_authClientList);
534 ListInit(&g_authServerList);
535 AuthCommonInit();
536 AuthLaneInterfaceMock mock;
537 EXPECT_CALL(mock, LnnGetRemoteStrInfo)
538 .WillRepeatedly(DoAll(SetArrayArgument<2>(UUID_TEST, UUID_TEST + UUID_BUF_LEN), Return(SOFTBUS_OK)));
539
540 AuthSessionInfo info;
541 SetAuthSessionInfo(&info, CONN_ID, false, AUTH_LINK_TYPE_ENHANCED_P2P);
542 EXPECT_TRUE(NewAuthManager(AUTH_SEQ, &info) != nullptr);
543 AuthConnInfo connInfo;
544 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
545 connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
546 ASSERT_TRUE(memcpy_s(connInfo.info.ipInfo.ip, IP_LEN, IP_TEST, strlen(IP_TEST)) == EOK);
547 connInfo.info.ipInfo.port = PORT;
548 AuthManager *auth = FindAuthManagerByConnInfo(&connInfo, false);
549 EXPECT_TRUE(auth != nullptr);
550 auth->hasAuthPassed[AUTH_LINK_TYPE_ENHANCED_P2P] = true;
551 auth->authId = 1;
552 auth->lastVerifyTime = 1;
553
554 uint32_t authRequestId = AuthGenRequestId();
555 int32_t ret = AuthAllocLane(NETWORK_ID, authRequestId, &authConnCb);
556 EXPECT_NE(ret, SOFTBUS_OK);
557
558 uint32_t laneReqId = GetLaneManager()->lnnGetLaneHandle(LANE_TYPE_CTRL);
559 AuthOnLaneAllocFail(laneReqId, SOFTBUS_INVALID_PARAM);
560
561 DelAuthManager(auth, connInfo.type);
562 DestroyAuthManagerList();
563 AuthCommonDeinit();
564 DeInitAuthReqInfo();
565 }
566 } // namespace OHOS