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