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