1 /*
2 * Copyright (c) 2022-2025 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 <cinttypes>
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <securec.h>
20 #include <sys/time.h>
21
22 #include "auth_connection.c"
23 #include "auth_connection.h"
24 #include "auth_device.c"
25 #include "auth_interface.c"
26 #include "auth_interface.h"
27 #include "auth_lane.c"
28 #include "auth_log.h"
29 #include "auth_manager.c"
30 #include "auth_manager.h"
31 #include "auth_session_fsm.c"
32 #include "auth_session_fsm.h"
33 #include "auth_session_key.c"
34 #include "auth_session_key.h"
35 #include "auth_tcp_connection_mock.h"
36 #include "auth_common_mock.h"
37 #include "lnn_ctrl_lane.h"
38 #include "lnn_lane_interface.h"
39 #include "lnn_lane_score.h"
40 #include "softbus_adapter_json.h"
41 #include "softbus_error_code.h"
42 #include "softbus_socket.h"
43
44 namespace OHOS {
45 using namespace testing::ext;
46 using namespace testing;
47 constexpr uint32_t TEST_DATA_LEN = 30;
48 constexpr uint32_t MSG_LEN = 50;
49 constexpr char NETWORK_ID[] = "testnetworkid123";
50
51 class AuthOtherTest : public testing::Test {
52 public:
53 static void SetUpTestCase();
54 static void TearDownTestCase();
55 void SetUp();
56 void TearDown();
57 };
58
SetUpTestCase()59 void AuthOtherTest::SetUpTestCase()
60 {
61 int32_t ret = AuthCommonInit();
62 EXPECT_TRUE(ret == SOFTBUS_OK);
63 }
64
TearDownTestCase()65 void AuthOtherTest::TearDownTestCase()
66 {
67 AuthCommonDeinit();
68 }
69
SetUp()70 void AuthOtherTest::SetUp() { }
71
TearDown()72 void AuthOtherTest::TearDown() { }
73
OnConnectResultTest(uint32_t requestId,uint64_t connId,int32_t result,const AuthConnInfo * connInfo)74 void OnConnectResultTest(uint32_t requestId, uint64_t connId, int32_t result, const AuthConnInfo *connInfo)
75 {
76 (void)requestId;
77 (void)connId;
78 (void)result;
79 (void)connInfo;
80 }
81
OnDisconnectedTest(uint64_t connId,const AuthConnInfo * connInfo)82 void OnDisconnectedTest(uint64_t connId, const AuthConnInfo *connInfo)
83 {
84 (void)connId;
85 (void)connInfo;
86 }
87
OnDataReceivedTest(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)88 void OnDataReceivedTest(
89 uint64_t connId, const AuthConnInfo *connInfo, bool fromServer, const AuthDataHead *head, const uint8_t *data)
90 {
91 (void)connId;
92 (void)connInfo;
93 (void)fromServer;
94 (void)head;
95 (void)data;
96 }
97
OnDeviceNotTrustedTest(const char * udid)98 void OnDeviceNotTrustedTest(const char *udid)
99 {
100 (void)udid;
101 }
102
OnDeviceVerifyPassTest(AuthHandle authHandle,const NodeInfo * info)103 void OnDeviceVerifyPassTest(AuthHandle authHandle, const NodeInfo *info)
104 {
105 (void)authHandle;
106 (void)info;
107 }
108
OnDeviceDisconnectTest(int64_t authId)109 void OnDeviceDisconnectTest(int64_t authId)
110 {
111 (void)authId;
112 }
113
OnGroupCreatedTest(const char * groupId,int32_t groupType)114 void OnGroupCreatedTest(const char *groupId, int32_t groupType)
115 {
116 (void)groupId;
117 (void)groupType;
118 }
119
OnGroupDeletedTest(const char * groupId)120 void OnGroupDeletedTest(const char *groupId)
121 {
122 (void)groupId;
123 }
124
125 /*
126 * @tc.name: ADD_CONN_REQUEST_TEST_001
127 * @tc.desc: add conn request test
128 * @tc.type: FUNC
129 * @tc.require:
130 */
131 HWTEST_F(AuthOtherTest, ADD_CONN_REQUEST_TEST_001, TestSize.Level1)
132 {
133 AuthConnInfo connInfo;
134 uint32_t requestId = 0;
135 int32_t fd = 0;
136
137 int32_t ret = AddConnRequest(&connInfo, requestId, fd);
138 EXPECT_TRUE(ret == SOFTBUS_OK);
139 ConnRequest *item = FindConnRequestByRequestId(requestId);
140 EXPECT_TRUE(item != nullptr);
141 DelConnRequest(nullptr);
142 DelConnRequest(item);
143 }
144
145 /*
146 * @tc.name: REMOVE_FUNC_TEST_001
147 * @tc.desc: remove func test
148 * @tc.type: FUNC
149 * @tc.require:
150 */
151 HWTEST_F(AuthOtherTest, REMOVE_FUNC_TEST_001, TestSize.Level1)
152 {
153 uint32_t obj = 1;
154 uint32_t param = 1;
155
156 int32_t ret = RemoveFunc(nullptr, static_cast<void *>(¶m));
157 EXPECT_NE(ret, SOFTBUS_OK);
158 ret = RemoveFunc(static_cast<void *>(&obj), nullptr);
159 EXPECT_NE(ret, SOFTBUS_OK);
160 ret = RemoveFunc(static_cast<void *>(&obj), static_cast<void *>(¶m));
161 EXPECT_TRUE(ret == SOFTBUS_OK);
162 }
163
164 /*
165 * @tc.name: CHECK_ACTIVE_AUTH_CONNECTION_TEST_001
166 * @tc.desc: check active auth connection test
167 * @tc.type: FUNC
168 * @tc.require:
169 */
170 HWTEST_F(AuthOtherTest, CHECK_ACTIVE_AUTH_CONNECTION_TEST_001, TestSize.Level1)
171 {
172 AuthConnInfo connInfo;
173
174 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
175 bool ret = CheckActiveAuthConnection(nullptr);
176 EXPECT_TRUE(ret == false);
177 ret = CheckActiveAuthConnection(&connInfo);
178 EXPECT_TRUE(ret == false);
179 }
180
181 /*
182 * @tc.name: AUTH_GET_META_TYPE_TEST_001
183 * @tc.desc: auth get meta type test
184 * @tc.type: FUNC
185 * @tc.require:
186 */
187 HWTEST_F(AuthOtherTest, AUTH_GET_META_TYPE_TEST_001, TestSize.Level1)
188 {
189 int64_t authId = 0;
190 bool isMetaAuth = false;
191
192 int32_t ret = AuthGetMetaType(authId, nullptr);
193 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
194 ret = AuthGetMetaType(authId, &isMetaAuth);
195 EXPECT_TRUE(ret == SOFTBUS_OK);
196 }
197
198 /*
199 * @tc.name: REMOVE_AUTH_MANAGER_BY_AUTH_ID_TEST_001
200 * @tc.desc: remove auth manager by auth id test
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(AuthOtherTest, REMOVE_AUTH_MANAGER_BY_AUTH_ID_TEST_001, TestSize.Level1)
205 {
206 int64_t authSeq = 0;
207 AuthSessionInfo info;
208 AuthConnInfo connInfo;
209 const char *udid = "000";
210 uint64_t connId = 0;
211 uint64_t errConnId = 1;
212 const char *ip = "192.168.12.1";
213
214 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
215 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
216 (void)strcpy_s(info.udid, UDID_BUF_LEN, udid);
217 (void)strcpy_s(info.uuid, UUID_BUF_LEN, udid);
218 info.connId = 0;
219 info.isServer = true;
220 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
221 ListInit(&g_authServerList);
222 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
223 AuthManager *auth = NewAuthManager(authSeq, &info);
224 EXPECT_TRUE(auth != nullptr);
225 int64_t ret = GetAuthIdByConnId(errConnId, true);
226 EXPECT_TRUE(ret == AUTH_INVALID_ID);
227 ret = GetAuthIdByConnId(connId, true);
228 EXPECT_TRUE(ret != AUTH_INVALID_ID);
229 connInfo.type = AUTH_LINK_TYPE_WIFI;
230 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
231 ret = GetActiveAuthIdByConnInfo(&connInfo, false);
232 EXPECT_TRUE(ret == AUTH_INVALID_ID);
233 AuthHandle authHandle = { .authId = authSeq, .type = AUTH_LINK_TYPE_WIFI };
234 RemoveAuthManagerByAuthId(authHandle);
235 RemoveAuthManagerByConnInfo(&connInfo, true);
236 RemoveNotPassedAuthManagerByUdid(udid);
237 }
238
239 /*
240 * @tc.name: NOTIFY_DEVICE_VERIFY_PASSED_TEST_001
241 * @tc.desc: notify device verify passed test
242 * @tc.type: FUNC
243 * @tc.require:
244 */
245 HWTEST_F(AuthOtherTest, NOTIFY_DEVICE_VERIFY_PASSED_TEST_001, TestSize.Level1)
246 {
247 int64_t authId = 0;
248 int64_t errAuthId = 1;
249 NodeInfo nodeInfo;
250 AuthSessionInfo info;
251
252 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
253 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
254 info.isServer = true;
255 info.connInfo.type = AUTH_LINK_TYPE_BLE;
256 AuthManager *auth = NewAuthManager(authId, &info);
257 EXPECT_TRUE(auth != nullptr);
258 AuthHandle errHandle = { .authId = errAuthId, .type = AUTH_LINK_TYPE_BLE };
259 AuthHandle authHandle = { .authId = authId, .type = AUTH_LINK_TYPE_BLE };
260 AuthNotifyDeviceVerifyPassed(errHandle, &nodeInfo);
261 g_verifyListener.onDeviceVerifyPass = nullptr;
262 AuthNotifyDeviceVerifyPassed(authHandle, &nodeInfo);
263 g_verifyListener.onDeviceVerifyPass = OnDeviceVerifyPassTest, AuthNotifyDeviceVerifyPassed(authHandle, &nodeInfo);
264 DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
265 }
266
267 /*
268 * @tc.name: AUTH_MANAGER_SET_AUTH_PASSED_TEST_001
269 * @tc.desc: auth manager set auth passed test
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273 HWTEST_F(AuthOtherTest, AUTH_MANAGER_SET_AUTH_PASSED_TEST_001, TestSize.Level1)
274 {
275 int64_t authSeq = 0;
276 int64_t errAuthId = 1;
277 AuthSessionInfo info;
278 int32_t reason = 0;
279
280 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
281 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
282 AuthManager *auth = NewAuthManager(authSeq, &info);
283 EXPECT_TRUE(auth != nullptr);
284 AuthManagerSetAuthPassed(authSeq, nullptr);
285 AuthManagerSetAuthPassed(errAuthId, &info);
286 AuthManagerSetAuthPassed(authSeq, &info);
287 AuthManagerSetAuthFailed(errAuthId, &info, reason);
288 AuthManagerSetAuthFailed(authSeq, &info, reason);
289 DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
290 }
291
292 /*
293 * @tc.name: HANDLE_CONNECTION_DATA_TEST_001
294 * @tc.desc: handle connection data test
295 * @tc.type: FUNC
296 * @tc.require:
297 */
298 HWTEST_F(AuthOtherTest, HANDLE_CONNECTION_DATA_TEST_001, TestSize.Level1)
299 {
300 uint64_t connId = 0;
301 int64_t authId = 0;
302 AuthConnInfo connInfo;
303 AuthDataHead head;
304 AuthSessionInfo info;
305 const uint8_t *data = nullptr;
306 bool fromServer = true;
307 const char *ip = "192.168.12.1";
308
309 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
310 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
311 (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
312 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
313 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
314 AuthManager *auth = NewAuthManager(authId, &info);
315 EXPECT_TRUE(auth != nullptr);
316 HandleConnectionData(connId, &connInfo, fromServer, &head, data);
317 connInfo.type = AUTH_LINK_TYPE_WIFI;
318 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
319 HandleConnectionData(connId, &connInfo, fromServer, &head, data);
320 DelAuthManager(auth, AUTH_LINK_TYPE_MAX);
321 }
322
OnConnOpenedTest(uint32_t requestId,AuthHandle authHandle)323 static void OnConnOpenedTest(uint32_t requestId, AuthHandle authHandle)
324 {
325 AUTH_LOGI(
326 AUTH_TEST, "OnConnOpenedTest: requestId=%{public}d, authId=%{public}" PRId64 ".", requestId, authHandle.authId);
327 }
328
OnConnOpenFailedTest(uint32_t requestId,int32_t reason)329 static void OnConnOpenFailedTest(uint32_t requestId, int32_t reason)
330 {
331 AUTH_LOGI(AUTH_TEST, "OnConnOpenFailedTest: requestId=%{public}d, reason=%{public}d.", requestId, reason);
332 }
333
334 /*
335 * @tc.name: AUTH_DEVICE_OPEN_CONN_TEST_001
336 * @tc.desc: auth device open conn test
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(AuthOtherTest, AUTH_DEVICE_OPEN_CONN_TEST_001, TestSize.Level1)
341 {
342 AuthSessionInfo info;
343 AuthConnInfo connInfo;
344 uint32_t requestId = 0;
345 int64_t authId = 0;
346 const char *ip = "192.168.12.1";
347 AuthConnCallback cb = {
348 .onConnOpened = OnConnOpenedTest,
349 .onConnOpenFailed = OnConnOpenFailedTest,
350 };
351
352 (void)memset_s(&info, sizeof(AuthSessionInfo), 0, sizeof(AuthSessionInfo));
353 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
354 info.connInfo.type = AUTH_LINK_TYPE_WIFI;
355 (void)strcpy_s(info.connInfo.info.ipInfo.ip, IP_LEN, ip);
356 AuthManager *auth = NewAuthManager(authId, &info);
357 EXPECT_TRUE(auth != nullptr);
358 connInfo.type = AUTH_LINK_TYPE_WIFI;
359 int32_t ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
360 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
361 (void)strcpy_s(connInfo.info.ipInfo.ip, IP_LEN, ip);
362 ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
363 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
364 connInfo.type = AUTH_LINK_TYPE_BR;
365 ret = AuthDeviceOpenConn(&connInfo, requestId, &cb);
366 EXPECT_TRUE(ret != SOFTBUS_OK);
367 }
368
369 /*
370 * @tc.name: UPDATE_AUTH_REQUEST_CONN_INFO_TEST_001
371 * @tc.desc: update auth request conn info test
372 * @tc.type: FUNC
373 * @tc.require:
374 */
375 HWTEST_F(AuthOtherTest, FIND_AUTH_REQUEST_BY_CONN_INFO_TEST_001, TestSize.Level1)
376 {
377 AuthConnInfo connInfo;
378 AuthRequest request;
379
380 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
381 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
382 int32_t ret = FindAuthRequestByConnInfo(&connInfo, &request);
383 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
384 uint32_t requestId = 1;
385 ret = GetAuthRequestNoLock(requestId, &request);
386 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
387 ret = FindAndDelAuthRequestByConnInfo(requestId, &connInfo);
388 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
389 int32_t result = 1;
390 int64_t authId = 10;
391 PerformAuthConnCallback(requestId, result, authId);
392 AuthConnCallback cb = {
393 .onConnOpened = OnConnOpenedTest,
394 .onConnOpenFailed = OnConnOpenFailedTest,
395 };
396 request.requestId = 1;
397 request.connInfo.type = AUTH_LINK_TYPE_BLE;
398 request.connCb = cb;
399 ret = AddAuthRequest(&request);
400 EXPECT_TRUE(ret != 0);
401 ret = FindAndDelAuthRequestByConnInfo(requestId, &connInfo);
402 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
403 PerformAuthConnCallback(request.requestId, SOFTBUS_OK, authId);
404 PerformAuthConnCallback(request.requestId, SOFTBUS_NOT_FIND, authId);
405 request.connInfo.type = AUTH_LINK_TYPE_WIFI;
406 ret = AddAuthRequest(&request);
407 EXPECT_TRUE(ret != 0);
408 DelAuthRequest(request.requestId);
409 }
410
411 /*
412 * @tc.name: UPDATE_AUTH_REQUEST_CONN_INFO_TEST_002
413 * @tc.desc: update auth request conn info test
414 * @tc.type: FUNC
415 * @tc.require:
416 */
417 HWTEST_F(AuthOtherTest, FIND_AUTH_REQUEST_BY_CONN_INFO_TEST_002, TestSize.Level1)
418 {
419 AuthConnInfo connInfo;
420 AuthRequest request;
421 int64_t authId = 10;
422 uint32_t requestId = 1;
423 AuthConnCallback connCb = {
424 .onConnOpened = nullptr,
425 .onConnOpenFailed = nullptr,
426 };
427
428 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
429 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
430 request.requestId = requestId;
431 request.connInfo.type = AUTH_LINK_TYPE_BLE;
432 request.connCb = connCb;
433 int32_t ret = AddAuthRequest(&request);
434 EXPECT_TRUE(ret != 0);
435 PerformAuthConnCallback(requestId, SOFTBUS_OK, authId);
436 connInfo.type = AUTH_LINK_TYPE_BLE;
437 request.requestId = 2;
438 ret = FindAndDelAuthRequestByConnInfo(request.requestId, &connInfo);
439 EXPECT_TRUE(ret == SOFTBUS_NOT_FIND);
440 ret = AddAuthRequest(&request);
441 EXPECT_TRUE(ret != 0);
442 DelAuthRequest(requestId);
443 DelAuthRequest(request.requestId);
444 }
445
446 /*
447 * @tc.name: RMOVE_UPDATE_SESSION_KEY_FUNC_TEST_001
448 * @tc.desc: rmove update session key func test
449 * @tc.type: FUNC
450 * @tc.require:
451 */
452 HWTEST_F(AuthOtherTest, RMOVE_UPDATE_SESSION_KEY_FUNC_TEST_001, TestSize.Level1)
453 {
454 int64_t authId = 1;
455 int64_t para = 0;
456 int32_t ret = RemoveUpdateSessionKeyFunc(nullptr, nullptr);
457 EXPECT_NE(ret, SOFTBUS_OK);
458 ret = RemoveUpdateSessionKeyFunc(&authId, nullptr);
459 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
460 ret = RemoveUpdateSessionKeyFunc(&authId, ¶);
461 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
462 ret = RemoveUpdateSessionKeyFunc(&authId, &authId);
463 EXPECT_TRUE(ret == SOFTBUS_OK);
464 }
465
466 /*
467 * @tc.name: POST_CLOSE_ACK_MESSAGE_TEST_001
468 * @tc.desc: post close ack message test
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(AuthOtherTest, POST_CLOSE_ACK_MESSAGE_TEST_001, TestSize.Level1)
473 {
474 int64_t authSeq = 0;
475 AuthSessionInfo info;
476 (void)memset_s(&info, sizeof(info), 0, sizeof(info));
477 int32_t ret = PostCloseAckMessage(authSeq, nullptr);
478 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
479 ret = PostCloseAckMessage(authSeq, &info);
480 EXPECT_TRUE(ret != SOFTBUS_OK);
481 }
482
483 /*
484 * @tc.name: PACK_AUTH_DATA_TEST_001
485 * @tc.desc: pack auth data test
486 * @tc.type: FUNC
487 * @tc.require:
488 */
489 HWTEST_F(AuthOtherTest, PACK_AUTH_DATA_TEST_001, TestSize.Level1)
490 {
491 AuthDataHead head;
492 uint8_t *buf = nullptr;
493 const uint8_t data[TEST_DATA_LEN] = { 0 };
494 uint32_t len = 32;
495
496 (void)memset_s(&head, sizeof(AuthDataHead), AUTH_CONN_DATA_HEAD_SIZE, sizeof(AuthDataHead));
497 int32_t ret = PackAuthData(&head, data, buf, len);
498 EXPECT_TRUE(ret != SOFTBUS_OK);
499 }
500
501 /*
502 * @tc.name: GET_CONN_SIDE_TYPE_TEST_001
503 * @tc.desc: get connside type test
504 * @tc.type: FUNC
505 * @tc.require:
506 */
507 HWTEST_F(AuthOtherTest, GET_CONN_SIDE_TYPE_TEST_001, TestSize.Level1)
508 {
509 AuthCommonInterfaceMock connMock;
510 EXPECT_CALL(connMock, ConnGetConnectionInfo).WillRepeatedly(Return(true));
511 uint64_t connId = 0;
512 connId = GetConnType(connId);
513 ConnSideType ret = GetConnSideType(connId);
514 EXPECT_EQ(ret, CONN_SIDE_ANY);
515 ret = GetConnSideType(0x1FFFFFFFF);
516 EXPECT_EQ(ret, CONN_SIDE_ANY);
517 ret = GetConnSideType(0x2FFFFFFFF);
518 EXPECT_EQ(ret, CONN_SIDE_ANY);
519 ret = GetConnSideType(0x3FFFFFFFF);
520 EXPECT_EQ(ret, CONN_SIDE_ANY);
521 ret = GetConnSideType(0x4FFFFFFFF);
522 EXPECT_EQ(ret, CONN_SIDE_ANY);
523 }
524
525 /*
526 * @tc.name: ON_COMM_DATA_RECEVIED_TEST_001
527 * @tc.desc: on comm data received test
528 * @tc.type: FUNC
529 * @tc.require:
530 */
531 HWTEST_F(AuthOtherTest, ON_COMM_DATA_RECEVIED_TEST_001, TestSize.Level1)
532 {
533 uint32_t connectionId = 0;
534 ConnModule moduleId = MODULE_DEVICE_AUTH;
535 int64_t seq = 0;
536 int32_t len = 0;
537 char *data = reinterpret_cast<char *>(malloc(1024));
538 ASSERT_NE(data, nullptr);
539 OnCommDataReceived(connectionId, moduleId, seq, data, len);
540
541 const int32_t SEND_DATA_SIZE_1KB = 1024;
542 const char *testData = "{\"data\":\"open session test!!!\"}";
543 len = 2;
544 moduleId = MODULE_CONNECTION;
545 int32_t ret = memcpy_s(data, SEND_DATA_SIZE_1KB, testData, strlen(testData));
546 EXPECT_EQ(ret, SOFTBUS_OK);
547 OnCommDataReceived(connectionId, moduleId, seq, nullptr, len);
548 OnCommDataReceived(connectionId, moduleId, seq, data, len);
549
550 free(data);
551 }
552
553 /*
554 * @tc.name: IS_FLUSH_DEVICE_PACKET_TEST_001
555 * @tc.desc: is flush device packet test
556 * @tc.type: FUNC
557 * @tc.require:
558 */
559 HWTEST_F(AuthOtherTest, IS_FLUSH_DEVICE_PACKET_TEST_001, TestSize.Level1)
560 {
561 const char *sessionKeyStr = "www.test.com";
562 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
563 if (connInfo == nullptr) {
564 return;
565 }
566 (void)memset_s(connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
567 connInfo->type = AUTH_LINK_TYPE_BLE;
568
569 AuthDataHead *head = (AuthDataHead *)SoftBusCalloc(sizeof(AuthDataHead));
570 if (head == nullptr) {
571 return;
572 }
573 (void)memset_s(head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
574 head->len = strlen(sessionKeyStr);
575 const uint8_t data = { 0 };
576 bool isServer = false;
577 DeviceMessageParse messageParse = { 0 };
578 bool ret = IsDeviceMessagePacket(connInfo, head, &data, isServer, &messageParse);
579 EXPECT_TRUE(ret == false);
580 connInfo->type = AUTH_LINK_TYPE_WIFI;
581 ret = IsDeviceMessagePacket(connInfo, head, &data, isServer, &messageParse);
582 EXPECT_TRUE(ret == false);
583 SoftBusFree(head);
584 SoftBusFree(connInfo);
585 }
586
587 /*
588 * @tc.name: FSM_MSG_TYPE_TO_STR_TEST_001
589 * @tc.desc: fsm msg type to str test
590 * @tc.type: FUNC
591 * @tc.require:
592 */
593 HWTEST_F(AuthOtherTest, FSM_MSG_TYPE_TO_STR_TEST_001, TestSize.Level1)
594 {
595 int32_t type = FSM_MSG_UNKNOWN;
596 const char *str = "UNKNOWN MSG!!";
597 char *ret = FsmMsgTypeToStr(type);
598 EXPECT_EQ(ret, str);
599 type = -1;
600 ret = FsmMsgTypeToStr(type);
601 EXPECT_EQ(ret, str);
602 type = FSM_MSG_RECV_DEVICE_ID;
603 ret = FsmMsgTypeToStr(type);
604 const char *str1 = "RECV_DEVICE_ID";
605 EXPECT_EQ(ret, str1);
606 }
607
608 /*
609 * @tc.name: AUTH_MANAGER_SET_SESSION_KEY_TEST_001
610 * @tc.desc: fsm msg type to str test
611 * @tc.type: FUNC
612 * @tc.require:
613 */
614 HWTEST_F(AuthOtherTest, AUTH_MANAGER_SET_SESSION_KEY_TEST_001, TestSize.Level1)
615 {
616 AuthCommonInterfaceMock connMock;
617 uint64_t localFeatureCap = (1 << BIT_BLE_DIRECT_ONLINE);
618 EXPECT_CALL(connMock, LnnGetLocalNumU64Info)
619 .WillOnce(DoAll(SetArgPointee<1>(localFeatureCap), Return(SOFTBUS_OK)));
620 int64_t authSeq = 0;
621 AuthSessionInfo *info = (AuthSessionInfo *)SoftBusCalloc(sizeof(AuthSessionInfo));
622 if (info == nullptr) {
623 return;
624 }
625 info->requestId = 1;
626 info->isServer = false;
627 info->connInfo.type = AUTH_LINK_TYPE_WIFI;
628 SessionKey *sessionKey = (SessionKey *)SoftBusCalloc(sizeof(SessionKey));
629 if (sessionKey == nullptr) {
630 return;
631 }
632 sessionKey->len = 0;
633 int32_t ret = AuthManagerSetSessionKey(authSeq, info, sessionKey, false, false);
634 EXPECT_TRUE(ret == SOFTBUS_OK);
635 ret = AuthManagerGetSessionKey(authSeq, info, sessionKey);
636 EXPECT_TRUE(ret != SOFTBUS_OK);
637 AuthManagerSetAuthPassed(authSeq, info);
638 AuthManagerSetAuthFinished(authSeq, info);
639 info->isServer = true;
640 info->connInfo.type = AUTH_LINK_TYPE_BLE;
641 AuthManagerSetAuthFinished(authSeq, info);
642 SoftBusFree(sessionKey);
643 SoftBusFree(info);
644 }
645
646 /*
647 * @tc.name: AUTH_DEVICE_CLOSE_CONN_TEST_001
648 * @tc.desc: fsm msg type to str test
649 * @tc.type: FUNC
650 * @tc.require:
651 */
652 HWTEST_F(AuthOtherTest, AUTH_DEVICE_CLOSE_CONN_TEST_001, TestSize.Level1)
653 {
654 AuthHandle authHandle = { .authId = 111, .type = AUTH_LINK_TYPE_WIFI };
655 AuthDeviceCloseConn(authHandle);
656 AuthTransData *dataInfo = (AuthTransData *)SoftBusCalloc(sizeof(AuthTransData));
657 if (dataInfo == nullptr) {
658 return;
659 }
660 int32_t ret = AuthDevicePostTransData(authHandle, nullptr);
661 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
662 dataInfo->module = 1;
663 dataInfo->seq = 2;
664 dataInfo->flag = 0;
665 ret = AuthDevicePostTransData(authHandle, dataInfo);
666 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
667 SoftBusFree(dataInfo);
668 }
669
670 /*
671 * @tc.name: AUTH_DEVICE_GET_PREFER_CONN_INFO_TEST_001
672 * @tc.desc: fsm msg type to str test
673 * @tc.type: FUNC
674 * @tc.require:
675 */
676 HWTEST_F(AuthOtherTest, AUTH_DEVICE_GET_PREFER_CONN_INFO_TEST_001, TestSize.Level1)
677 {
678 const char *uuid = "";
679 int32_t ret = AuthDeviceGetPreferConnInfo(uuid, nullptr);
680 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
681 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
682 if (connInfo == nullptr) {
683 return;
684 }
685 ret = AuthDeviceGetPreferConnInfo(nullptr, connInfo);
686 connInfo->type = AUTH_LINK_TYPE_BLE;
687 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
688 SoftBusFree(connInfo);
689 }
690
691 /*
692 * @tc.name: AUTH_DEVICE_CHECK_CONN_INFO_TEST_001
693 * @tc.desc: fsm msg type to str test
694 * @tc.type: FUNC
695 * @tc.require:
696 */
697 HWTEST_F(AuthOtherTest, AUTH_DEVICE_CHECK_CONN_INFO_TEST_001, TestSize.Level1)
698 {
699 const char *uuid = "test66";
700 AuthLinkType type = AUTH_LINK_TYPE_WIFI;
701 bool checkConnection = false;
702 bool ret = AuthDeviceCheckConnInfo(uuid, type, checkConnection);
703 EXPECT_TRUE(ret == false);
704 }
705
706 /*
707 * @tc.name: CONVERT_AUTH_LINK_TYPE_TO_HISYSEVENT_LINKTYPE_TEST_001
708 * @tc.desc: sync deviceInfo state process test
709 * @tc.type: FUNC
710 * @tc.require:
711 */
712 HWTEST_F(AuthOtherTest, CONVERT_AUTH_LINK_TYPE_TO_HISYSEVENT_LINKTYPE_TEST_001, TestSize.Level1)
713 {
714 AuthCommonInterfaceMock connMock;
715 EXPECT_CALL(connMock, LnnGetAllOnlineNodeNum).WillRepeatedly(Return(SOFTBUS_OK));
716 AuthFsm *authFsm = (AuthFsm *)SoftBusCalloc(sizeof(AuthFsm));
717 ASSERT_TRUE(authFsm != nullptr);
718 authFsm->info.connInfo.type = (AuthLinkType)(AUTH_LINK_TYPE_WIFI - 1);
719 ReportAuthResultEvt(authFsm, 0);
720
721 authFsm->info.connInfo.type = AUTH_LINK_TYPE_WIFI;
722 SoftBusLinkType ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_WIFI);
723 EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_WLAN);
724
725 authFsm->info.connInfo.type = AUTH_LINK_TYPE_BR;
726 ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_BR);
727 EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_BR);
728
729 authFsm->info.connInfo.type = AUTH_LINK_TYPE_BLE;
730 ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_BLE);
731 EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_BLE);
732
733 authFsm->info.connInfo.type = AUTH_LINK_TYPE_P2P;
734 ret = ConvertAuthLinkTypeToHisysEvtLinkType(AUTH_LINK_TYPE_P2P);
735 EXPECT_TRUE(ret == SOFTBUS_HISYSEVT_LINK_TYPE_P2P);
736
737 ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_SEND_FAIL);
738 ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_DEVICE_DISCONNECTED);
739 ReportAuthResultEvt(authFsm, SOFTBUS_AUTH_HICHAIN_PROCESS_FAIL);
740 ReportAuthResultEvt(authFsm, 11);
741 int32_t ret1 = RecoveryFastAuthKey(authFsm);
742 EXPECT_TRUE(ret1 != SOFTBUS_OK);
743 AuthSessionInfo authSessionInfo;
744 authSessionInfo.requestId = 11;
745 authSessionInfo.isServer = false;
746 authSessionInfo.connInfo.type = AUTH_LINK_TYPE_WIFI;
747 const char *udid = "1111";
748 (void)strcpy_s(authSessionInfo.udid, UDID_BUF_LEN, udid);
749 authFsm->info = authSessionInfo;
750 authFsm->authSeq = 512;
751 const uint8_t *data = reinterpret_cast<const uint8_t *>(malloc(sizeof(uint8_t)));
752 if (data == nullptr) {
753 SoftBusFree(authFsm);
754 return;
755 }
756 MessagePara *para = NewMessagePara(data, MSG_LEN);
757 HandleMsgRecvDeviceInfo(authFsm, para);
758 authSessionInfo.isServer = true;
759 HandleMsgRecvDeviceInfo(authFsm, para);
760 SoftBusFree(authFsm);
761 }
762
763 /*
764 * @tc.name: POST_MESSAGE_TO_AUTH_FSM_TEST_001
765 * @tc.desc: post message to auth fsm test
766 * @tc.type: FUNC
767 * @tc.require:
768 */
769 HWTEST_F(AuthOtherTest, POST_MESSAGE_TO_AUTH_FSM_TEST_001, TestSize.Level1)
770 {
771 int32_t msgType = 1;
772 int64_t authSeq = 0;
773 const uint8_t *data = reinterpret_cast<const uint8_t *>(malloc(sizeof(uint8_t)));
774 ASSERT_TRUE(data != nullptr);
775 uint32_t len = 0;
776 int32_t ret = PostMessageToAuthFsm(msgType, authSeq, data, len);
777 EXPECT_TRUE(ret != SOFTBUS_OK);
778 len = MSG_LEN;
779 ret = PostMessageToAuthFsm(msgType, authSeq, data, len);
780 EXPECT_TRUE(ret != SOFTBUS_OK);
781 }
782
783 /*
784 * @tc.name: AUTH_FSM_TEST_001
785 * @tc.desc: authSession handle device disconnected test
786 * @tc.type: FUNC
787 * @tc.require:
788 */
789 HWTEST_F(AuthOtherTest, AUTH_FSM_TEST_001, TestSize.Level1)
790 {
791 uint64_t connId = 111;
792 bool isServer = true;
793 AuthFsm *ret = GetAuthFsmByConnId(connId, isServer, false);
794 EXPECT_TRUE(ret == nullptr);
795 int32_t ret1 = AuthSessionHandleDeviceDisconnected(connId, true);
796 EXPECT_TRUE(ret1 == SOFTBUS_OK);
797 }
798
799 /*
800 * @tc.name: AUTH_RESTORE_MANAGER_TEST_001
801 * @tc.desc: authRestore authManager test
802 * @tc.type: FUNC
803 * @tc.require:
804 */
805 HWTEST_F(AuthOtherTest, AUTH_RESTORE_MANAGER_TEST_001, TestSize.Level1)
806 {
807 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
808 if (connInfo == nullptr) {
809 return;
810 }
811 connInfo->type = AUTH_LINK_TYPE_BLE;
812 uint32_t requestId = 1;
813 NodeInfo *nodeInfo = (NodeInfo *)SoftBusCalloc(sizeof(NodeInfo));
814 if (nodeInfo == nullptr) {
815 SoftBusFree(connInfo);
816 return;
817 }
818 int64_t *authId = reinterpret_cast<int64_t *>(malloc(sizeof(int64_t)));
819 int32_t ret = AuthRestoreAuthManager(nullptr, connInfo, requestId, nodeInfo, authId);
820 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
821 const char *udidHash = "1234uuid";
822 ret = AuthRestoreAuthManager(udidHash, nullptr, requestId, nodeInfo, authId);
823 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
824 ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, nullptr, authId);
825 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
826 ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, nodeInfo, nullptr);
827 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
828 ret = AuthRestoreAuthManager(udidHash, connInfo, requestId, nodeInfo, authId);
829 EXPECT_EQ(ret, SOFTBUS_AUTH_MANAGER_RESTORE_FAIL);
830 const char *udidHash1 = "testudidhashpass";
831 ret = AuthRestoreAuthManager(udidHash1, connInfo, requestId, nodeInfo, authId);
832 EXPECT_EQ(ret, SOFTBUS_AUTH_MANAGER_RESTORE_FAIL);
833 SoftBusFree(connInfo);
834 SoftBusFree(nodeInfo);
835 }
836
837 /*
838 * @tc.name: GET_PEER_UDID_BY_NETWORK_ID_TEST_001
839 * @tc.desc: get peer udid by networkId test
840 * @tc.type: FUNC
841 * @tc.require:
842 */
843 HWTEST_F(AuthOtherTest, GET_PEER_UDID_BY_NETWORK_ID_TEST_001, TestSize.Level1)
844 {
845 const char *networkId = "testudid";
846 int32_t ret = GetPeerUdidByNetworkId(networkId, nullptr, UDID_BUF_LEN);
847 char udid[UDID_BUF_LEN] = { 0 };
848 ret = GetPeerUdidByNetworkId(nullptr, udid, UDID_BUF_LEN);
849 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
850 ret = GetPeerUdidByNetworkId(networkId, udid, UDID_BUF_LEN);
851 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
852 }
853
854 /*
855 * @tc.name: GET_LATEST_ID_BY_CONNINFO_TEST_001
856 * @tc.desc: get latest id by connInfo test
857 * @tc.type: FUNC
858 * @tc.require:
859 */
860 HWTEST_F(AuthOtherTest, GET_LATEST_ID_BY_CONNINFO_TEST_001, TestSize.Level1)
861 {
862 int64_t ret = GetLatestIdByConnInfo(nullptr);
863 EXPECT_TRUE(ret == AUTH_INVALID_ID);
864 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
865 ASSERT_TRUE(connInfo != nullptr);
866 connInfo->type = AUTH_LINK_TYPE_WIFI;
867 const char *ip = "192.168.12.1";
868 (void)strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, ip);
869 ret = GetLatestIdByConnInfo(connInfo);
870 EXPECT_TRUE(ret == AUTH_INVALID_ID);
871 connInfo->type = AUTH_LINK_TYPE_BLE;
872 ret = GetLatestIdByConnInfo(connInfo);
873 EXPECT_TRUE(ret == AUTH_INVALID_ID);
874 SoftBusFree(connInfo);
875 }
876
877 /*
878 * @tc.name: START_RECONNECT_DEVICE_TEST_001
879 * @tc.desc: start reconnection device test
880 * @tc.type: FUNC
881 * @tc.require:
882 */
883 HWTEST_F(AuthOtherTest, START_RECONNECT_DEVICE_TEST_001, TestSize.Level1)
884 {
885 AuthConnInfo connInfo;
886 AuthConnCallback connCb;
887 AuthHandle authHandle = { .authId = 1, .type = AUTH_LINK_TYPE_WIFI };
888 int32_t ret = AuthStartReconnectDevice(authHandle, &connInfo, 1, &connCb);
889 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
890
891 NodeInfo nodeInfo;
892 ReportAuthRequestPassed(11, authHandle, &nodeInfo);
893 AuthRequest request;
894 uint64_t connId = 10;
895 int32_t result = 1;
896 HandleReconnectResult(&request, connId, result, 0);
897 request.authId = 10;
898 request.requestId = 11;
899 HandleReconnectResult(&request, connId, result, 0);
900 }
901
902 /*
903 * @tc.name: AUTH_GET_LATEST_AUTHSEQ_LIST_TEST_001
904 * @tc.desc: auth get latest authsed list test
905 * @tc.type: FUNC
906 * @tc.require:
907 */
908 HWTEST_F(AuthOtherTest, AUTH_GET_LATEST_AUTHSEQ_LIST_TEST_001, TestSize.Level1)
909 {
910 int64_t seqList = 1024;
911 uint32_t num = 1;
912 int32_t ret = AuthGetLatestAuthSeqList(nullptr, &seqList, num);
913 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
914 const char *udid = "";
915 ret = AuthGetLatestAuthSeqList(udid, &seqList, num);
916 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
917 const char *udid1 = "11";
918 ret = AuthGetLatestAuthSeqList(udid1, nullptr, num);
919 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
920 ret = AuthGetLatestAuthSeqList(udid1, &seqList, num);
921 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
922 num = DISCOVERY_TYPE_COUNT;
923 ret = AuthGetLatestAuthSeqList(udid1, &seqList, num);
924 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
925
926 AuthConnInfo connInfo;
927 AuthDataHead head;
928 uint8_t data = 1;
929 head.flag = 0;
930 connInfo.type = AUTH_LINK_TYPE_BLE;
931 uint64_t connId = 11;
932 HandleDeviceInfoData(connId, &connInfo, false, &head, &data);
933 head.flag = 1;
934 HandleDeviceInfoData(connId, &connInfo, false, &head, &data);
935 }
936
937 /*
938 * @tc.name: SYNC_DEVINFO_STATE_PROCESS_TEST_001
939 * @tc.desc: sync deviceInfo state process test
940 * @tc.type: FUNC
941 * @tc.require:
942 */
943 HWTEST_F(AuthOtherTest, SYNC_DEVINFO_STATE_PROCESS_TEST_001, TestSize.Level1)
944 {
945 FsmStateMachine *fsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
946 ASSERT_TRUE(fsm != nullptr);
947 int32_t msgType = 1;
948 bool ret = SyncDevInfoStateProcess(fsm, msgType, nullptr);
949 EXPECT_TRUE(ret == false);
950 SoftBusFree(fsm);
951 FsmStateMachine *testFsm = (FsmStateMachine *)SoftBusCalloc(sizeof(FsmStateMachine));
952 ASSERT_TRUE(testFsm != nullptr);
953 testFsm->flag = 1;
954
955 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
956 EXPECT_TRUE(ret == false);
957
958 msgType = FSM_MSG_AUTH_TIMEOUT;
959 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
960 msgType = FSM_MSG_RECV_DEVICE_INFO;
961 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
962 EXPECT_TRUE(ret == false);
963
964 msgType = FSM_MSG_RECV_CLOSE_ACK;
965 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
966 EXPECT_TRUE(ret == false);
967
968 msgType = FSM_MSG_RECV_AUTH_DATA;
969 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
970 EXPECT_TRUE(ret == false);
971
972 msgType = FSM_MSG_AUTH_FINISH;
973 ret = SyncDevInfoStateProcess(testFsm, msgType, nullptr);
974 EXPECT_TRUE(ret == false);
975 SoftBusFree(testFsm);
976 }
977
978 /*
979 * @tc.name: GET_AUTH_CONN_001
980 * @tc.desc: get auth conn test
981 * @tc.type: FUNC
982 * @tc.require:
983 */
984 HWTEST_F(AuthOtherTest, GET_AUTH_CONN_001, TestSize.Level1)
985 {
986 const char *uuid = "testuuid123";
987
988 AuthConnInfo *connInfo = (AuthConnInfo *)SoftBusCalloc(sizeof(AuthConnInfo));
989 ASSERT_TRUE(connInfo != nullptr);
990
991 int32_t ret = GetAuthConn(uuid, LANE_BR, nullptr);
992 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
993
994 ret = GetAuthConn(nullptr, LANE_BR, connInfo);
995 EXPECT_TRUE(ret == SOFTBUS_INVALID_PARAM);
996
997 connInfo->type = AUTH_LINK_TYPE_BR;
998 ret = GetAuthConn(uuid, LANE_BR, connInfo);
999 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1000
1001 connInfo->type = AUTH_LINK_TYPE_BLE;
1002 ret = GetAuthConn(uuid, LANE_BLE, connInfo);
1003 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1004
1005 connInfo->type = AUTH_LINK_TYPE_P2P;
1006 ret = GetAuthConn(uuid, LANE_P2P, connInfo);
1007 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1008
1009 ret = GetAuthConn(uuid, LANE_HML, connInfo);
1010 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1011
1012 ret = GetAuthConn(uuid, LANE_WLAN_2P4G, connInfo);
1013 EXPECT_TRUE(ret == SOFTBUS_AUTH_NOT_FOUND);
1014
1015 SoftBusFree(connInfo);
1016 }
1017
1018 /*
1019 * @tc.name: AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_001
1020 * @tc.desc: AuthGetAuthHandleByIndex test
1021 * @tc.type: FUNC
1022 * @tc.require:
1023 */
1024 HWTEST_F(AuthOtherTest, AUTH_GET_AUTH_HANDLE_BY_INDEX_TEST_001, TestSize.Level1)
1025 {
1026 AuthConnInfo connInfo = {
1027 .info.ipInfo.ip = "192.168.12.1",
1028 .type = AUTH_LINK_TYPE_WIFI,
1029 };
1030 AuthHandle authHandle;
1031 (void)memset_s(&authHandle, sizeof(AuthHandle), 0, sizeof(AuthHandle));
1032 EXPECT_TRUE(AuthGetAuthHandleByIndex(nullptr, true, 1, &authHandle) == SOFTBUS_INVALID_PARAM);
1033 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1034 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_LOCK_ERR);
1035 char UDID_TEST[UDID_BUF_LEN] = "123456789udidtest";
1036 connInfo.type = AUTH_LINK_TYPE_BLE;
1037 ASSERT_TRUE(memcpy_s(connInfo.info.bleInfo.deviceIdHash, UDID_HASH_LEN, UDID_TEST, strlen(UDID_TEST)) == EOK);
1038 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_NOT_FIND);
1039 char BR_MAC[BT_MAC_LEN] = "00:15:5d:de:d4:23";
1040 connInfo.type = AUTH_LINK_TYPE_BR;
1041 ASSERT_TRUE(memcpy_s(connInfo.info.brInfo.brMac, BT_MAC_LEN, BR_MAC, strlen(BR_MAC)) == EOK);
1042 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_LOCK_ERR);
1043 connInfo.type = AUTH_LINK_TYPE_MAX;
1044 EXPECT_TRUE(AuthGetAuthHandleByIndex(&connInfo, true, 1, &authHandle) == SOFTBUS_INVALID_PARAM);
1045 }
1046
1047 /*
1048 * @tc.name: AUTH_CHECK_SESSION_KEY_VALID_BY_CONN_INFO_TEST_001
1049 * @tc.desc: AuthCheckSessionKeyValidByConnInfo test
1050 * @tc.type: FUNC
1051 * @tc.require:
1052 */
1053 HWTEST_F(AuthOtherTest, AUTH_CHECK_SESSION_KEY_VALID_BY_CONN_INFO_TEST_001, TestSize.Level1)
1054 {
1055 const char *networkId = "123456456";
1056 AuthConnInfo connInfo;
1057 EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(nullptr, &connInfo) == SOFTBUS_INVALID_PARAM);
1058 EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(networkId, nullptr) == SOFTBUS_INVALID_PARAM);
1059 EXPECT_TRUE(AuthCheckSessionKeyValidByConnInfo(networkId, &connInfo) == SOFTBUS_NETWORK_GET_NODE_INFO_ERR);
1060 EXPECT_TRUE(AuthCheckSessionKeyValidByAuthHandle(nullptr) == SOFTBUS_INVALID_PARAM);
1061 AuthHandle authHandle = {
1062 .type = AUTH_LINK_TYPE_WIFI,
1063 .authId = 0,
1064 };
1065 EXPECT_TRUE(AuthCheckSessionKeyValidByAuthHandle(&authHandle) == SOFTBUS_AUTH_SESSION_KEY_INVALID);
1066 authHandle.type = -1;
1067 AuthTransData dataInfo;
1068 AuthCloseConn(authHandle);
1069 EXPECT_TRUE(AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_INVALID_PARAM);
1070 EXPECT_TRUE(AuthGetConnInfo(authHandle, &connInfo) == SOFTBUS_INVALID_PARAM);
1071 authHandle.type = AUTH_LINK_TYPE_MAX;
1072 AuthCloseConn(authHandle);
1073 EXPECT_TRUE(AuthPostTransData(authHandle, &dataInfo) == SOFTBUS_INVALID_PARAM);
1074 EXPECT_TRUE(AuthGetConnInfo(authHandle, &connInfo) == SOFTBUS_INVALID_PARAM);
1075 AuthFreeLane(nullptr);
1076 DelAuthReqInfoByAuthHandle(nullptr);
1077 AuthFreeLane(&authHandle);
1078 DelAuthReqInfoByAuthHandle(&authHandle);
1079 AuthConnCallback callback;
1080 EXPECT_TRUE(AuthAllocLane(nullptr, 1, &callback) == SOFTBUS_INVALID_PARAM);
1081 EXPECT_TRUE(AuthAllocLane(networkId, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1082 EXPECT_TRUE(AuthAllocLane(nullptr, 1, nullptr) == SOFTBUS_INVALID_PARAM);
1083 EXPECT_TRUE(AuthGetP2pConnInfo(nullptr, nullptr, true) == AUTH_INVALID_ID);
1084 EXPECT_TRUE(AuthGetHmlConnInfo(nullptr, nullptr, true) == AUTH_INVALID_ID);
1085 AuthGetLatestIdByUuid(nullptr, AUTH_LINK_TYPE_WIFI, true, nullptr);
1086 AuthGetLatestIdByUuid(nullptr, AUTH_LINK_TYPE_WIFI, true, &authHandle);
1087 }
1088
1089 /*
1090 * @tc.name: AUTH_DIRECT_ONLINE_PROCESS_SESSION_KEY_TEST_001
1091 * @tc.desc: AuthDirectOnlineProcessSessionKey test
1092 * @tc.type: FUNC
1093 * @tc.require:
1094 */
1095 HWTEST_F(AuthOtherTest, AUTH_DIRECT_ONLINE_PROCESS_SESSION_KEY_TEST_001, TestSize.Level1)
1096 {
1097 AuthDeviceKeyInfo keyInfo = {
1098 .keyLen = strlen("testKey"),
1099 .isOldKey = true,
1100 };
1101 ASSERT_TRUE(memcpy_s(keyInfo.deviceKey, SESSION_KEY_LENGTH, "testKey", strlen("testKey")) == EOK);
1102 AuthSessionInfo info = {
1103 .connInfo.type = AUTH_LINK_TYPE_BR,
1104 };
1105 int64_t authId;
1106 EXPECT_EQ(AuthDirectOnlineProcessSessionKey(&info, &keyInfo, &authId), SOFTBUS_AUTH_NOT_FOUND);
1107 EXPECT_EQ(AuthDirectOnlineWithoutSessionKey(&info, &keyInfo, &authId), SOFTBUS_AUTH_UNEXPECTED_CONN_TYPE);
1108 EXPECT_TRUE(AuthEncrypt(nullptr, nullptr, 0, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
1109 EXPECT_TRUE(AuthDecrypt(nullptr, nullptr, 0, nullptr, nullptr) == SOFTBUS_INVALID_PARAM);
1110 }
1111
1112 /*
1113 * @tc.name: IS_SAME_ACCOUNT_DEVICE_TEST_001
1114 * @tc.desc: IsSameAccountDevice test
1115 * @tc.type: FUNC
1116 * @tc.require:
1117 */
1118 HWTEST_F(AuthOtherTest, IS_SAME_ACCOUNT_DEVICE_TEST_001, TestSize.Level1)
1119 {
1120 EXPECT_TRUE(LnnInitLocalLedger() == SOFTBUS_OK);
1121 uint8_t accountHash[SHA_256_HASH_LEN] = "accounthashtest";
1122 EXPECT_TRUE(LnnSetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, accountHash, SHA_256_HASH_LEN) == SOFTBUS_OK);
1123 EXPECT_TRUE(AuthIsPotentialTrusted(nullptr) == false);
1124 DeviceInfo device = {
1125 .devId = "testId",
1126 .accountHash = "accounthashtest",
1127 };
1128 EXPECT_TRUE(AuthIsPotentialTrusted(&device) == true);
1129 EXPECT_TRUE(IsSameAccountDevice(nullptr) == false);
1130 EXPECT_TRUE(IsSameAccountDevice(&device) == true);
1131 EXPECT_TRUE(AuthHasSameAccountGroup() == false);
1132 }
1133
1134 /*
1135 * @tc.name: FILL_AUTH_SESSION_INFO_TEST_001
1136 * @tc.desc: FillAuthSessionInfo test
1137 * @tc.type: FUNC
1138 * @tc.require:
1139 */
1140 HWTEST_F(AuthOtherTest, FILL_AUTH_SESSION_INFO_TEST_001, TestSize.Level1)
1141 {
1142 AuthSessionInfo info = {
1143 .connInfo.info.bleInfo.deviceIdHash = "123456789udidhashtest",
1144 };
1145 NodeInfo nodeInfo = {
1146 .authCapacity = 127,
1147 .uuid = "123456789uuidhashtest",
1148 .deviceInfo.deviceUdid = "123456789udidtest",
1149 };
1150 AuthDeviceKeyInfo keyInfo;
1151 EXPECT_TRUE(FillAuthSessionInfo(&info, &nodeInfo, &keyInfo, true) == SOFTBUS_OK);
1152 EXPECT_TRUE(FillAuthSessionInfo(&info, &nodeInfo, &keyInfo, false) == SOFTBUS_OK);
1153 }
1154
1155 /*
1156 * @tc.name: DEL_AUTH_REQ_INFO_BY_AUTH_HANDLE_TEST_001
1157 * @tc.desc: DelAuthReqInfoByAuthHandle test
1158 * @tc.type: FUNC
1159 * @tc.require:
1160 */
1161 HWTEST_F(AuthOtherTest, DEL_AUTH_REQ_INFO_BY_AUTH_HANDLE_TEST_001, TestSize.Level1)
1162 {
1163 InitAuthReqInfo();
1164 AuthConnCallback authConnCb = {
1165 .onConnOpened = OnConnOpenedTest,
1166 .onConnOpenFailed = OnConnOpenFailedTest,
1167 };
1168 EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 1, 1, &authConnCb), SOFTBUS_OK);
1169 EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 2, 2, &authConnCb), SOFTBUS_OK);
1170 EXPECT_EQ(AddAuthReqNode(NETWORK_ID, 3, 3, &authConnCb), SOFTBUS_OK);
1171 OnAuthConnOpenedFail(1, -1);
1172 OnAuthConnOpenedFail(4, -1);
1173 AuthHandle authHandle = {
1174 .authId = 2,
1175 .type = 1,
1176 };
1177 AuthFreeLane(&authHandle);
1178 EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1179 authHandle.type = 0;
1180 AuthFreeLane(&authHandle);
1181 EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1182 authHandle.authId = 1;
1183 AuthFreeLane(&authHandle);
1184 EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1185 authHandle.authId = 2;
1186 AuthFreeLane(&authHandle);
1187 EXPECT_EQ(DelAuthReqInfoByAuthHandle(&authHandle), SOFTBUS_OK);
1188 DeInitAuthReqInfo();
1189 }
1190
1191 /*
1192 * @tc.name: IS_ENHANCE_P2P_MODULE_ID_Test_001
1193 * @tc.desc: IsEnhanceP2pModuleId test
1194 * @tc.type: FUNC
1195 * @tc.require:
1196 */
1197 HWTEST_F(AuthOtherTest, IS_ENHANCE_P2P_MODULE_ID_Test_001, TestSize.Level1)
1198 {
1199 EXPECT_EQ(IsEnhanceP2pModuleId(AUTH_ENHANCED_P2P_START), true);
1200 EXPECT_EQ(IsEnhanceP2pModuleId(DIRECT_CHANNEL_SERVER_P2P), false);
1201 EXPECT_EQ(IsEnhanceP2pModuleId(AUTH_P2P), false);
1202 }
1203
1204 /*
1205 * @tc.name: AUTH_START_LISTENING_FOR_WIFI_DIRECT_Test_001
1206 * @tc.desc: AuthStartListeningForWifiDirect test
1207 * @tc.type: FUNC
1208 * @tc.require:
1209 */
1210 HWTEST_F(AuthOtherTest, AUTH_START_LISTENING_FOR_WIFI_DIRECT_Test_001, TestSize.Level1)
1211 {
1212 AsyncCallDeviceIdReceived(nullptr);
1213 AuthCommonInterfaceMock connMock;
1214 EXPECT_CALL(connMock, ConnStopLocalListening).WillRepeatedly(Return(SOFTBUS_OK));
1215 EXPECT_CALL(connMock, ConnStartLocalListening).WillRepeatedly(Return(0));
1216 AuthStopListeningForWifiDirect(AUTH_LINK_TYPE_P2P, AUTH_ENHANCED_P2P_START);
1217 AuthDataHead head;
1218 const uint8_t data[TEST_DATA_LEN] = { 0 };
1219 (void)memset_s(&head, sizeof(AuthDataHead), 0, sizeof(AuthDataHead));
1220 OnWiFiDataReceived(PROXY, 0, &head, data);
1221 OnWiFiDataReceived(AUTH, 0, &head, data);
1222 OnWiFiDataReceived(AUTH_P2P, 0, &head, data);
1223 OnWiFiDataReceived(AUTH_RAW_P2P_SERVER, 0, &head, data);
1224 OnWiFiDataReceived(AUTH_ENHANCED_P2P_START, 0, &head, data);
1225 const char *ip = "192.138.33.33";
1226 ListenerModule moduleId;
1227 (void)memset_s(&moduleId, sizeof(ListenerModule), 0, sizeof(ListenerModule));
1228 EXPECT_NE(AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_P2P, ip, 37025, &moduleId), SOFTBUS_INVALID_PORT);
1229 EXPECT_NE(
1230 AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_ENHANCED_P2P, ip, 37025, &moduleId), SOFTBUS_INVALID_PORT);
1231 EXPECT_EQ(AuthStartListeningForWifiDirect(AUTH_LINK_TYPE_WIFI, ip, 37025, &moduleId), SOFTBUS_INVALID_PARAM);
1232 }
1233 } // namespace OHOS
1234