1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "auth_connection.c"
20 #include "auth_connection_mock.h"
21
22 namespace OHOS {
23 using namespace testing;
24 using namespace testing::ext;
25 const uint32_t TEST_REQUEST_ID = 111;
26 const uint32_t TEST_SIZE = 32;
27 const uint32_t TEST_HEAD_LEN = 10;
28 const uint32_t TEST_DATA_LEN = 20;
29 const int32_t TEST_FD = 888;
30 const int32_t TEST_PORT = 1234;
31 const char TEST_IP[] = "192.168.1.134";
32 uint64_t g_connId = 0;
33
34 class AuthConnectionTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp();
39 void TearDown();
40 static void OnConnectResult(uint32_t requestId, uint64_t connId, int32_t result, const AuthConnInfo *connInfo);
41 static void OnDisconnected(uint64_t connId, const AuthConnInfo *connInfo);
42 static void OnDataReceived(uint64_t connId, const AuthConnInfo *connInfo, bool fromServer,
43 const AuthDataHead *head, const uint8_t *data);
44 static bool isOnConnectResultSuccess;
45 static bool isOnDisconnectedSuccess;
46 static bool isOnDataReceivedSuccess;
47 };
48
49 bool AuthConnectionTest::isOnConnectResultSuccess = false;
50 bool AuthConnectionTest::isOnDisconnectedSuccess = false;
51 bool AuthConnectionTest::isOnDataReceivedSuccess = false;
52
SetUpTestCase()53 void AuthConnectionTest::SetUpTestCase() { }
54
TearDownTestCase()55 void AuthConnectionTest::TearDownTestCase() { }
56
SetUp()57 void AuthConnectionTest::SetUp() { }
58
TearDown()59 void AuthConnectionTest::TearDown() { }
60
OnConnectResult(uint32_t requestId,uint64_t connId,int32_t result,const AuthConnInfo * connInfo)61 void AuthConnectionTest::OnConnectResult(uint32_t requestId, uint64_t connId, int32_t result,
62 const AuthConnInfo *connInfo)
63 {
64 (void)requestId;
65 (void)connInfo;
66 g_connId = connId;
67 isOnConnectResultSuccess = true;
68 AUTH_LOGI(AUTH_TEST, "result = %{public}d", result);
69 }
70
OnDisconnected(uint64_t connId,const AuthConnInfo * connInfo)71 void AuthConnectionTest::OnDisconnected(uint64_t connId, const AuthConnInfo *connInfo)
72 {
73 (void)connId;
74 (void)connInfo;
75 isOnDisconnectedSuccess = true;
76 AUTH_LOGI(AUTH_TEST, "Auth Connection Disconnected.");
77 }
78
OnDataReceived(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)79 void AuthConnectionTest::OnDataReceived(uint64_t connId, const AuthConnInfo *connInfo, bool fromServer,
80 const AuthDataHead *head, const uint8_t *data)
81 {
82 (void)connId;
83 (void)connInfo;
84 (void)fromServer;
85 (void)head;
86 (void)data;
87 isOnDataReceivedSuccess = true;
88 AUTH_LOGI(AUTH_TEST, "Receive data.");
89 }
90
91 /*
92 * @tc.name: IS_ENHANCE_P2P_MODULE_ID_TEST_001
93 * @tc.desc: is enhance P2p moduleId test.
94 * @tc.type: FUNC
95 * @tc.require:
96 */
97 HWTEST_F(AuthConnectionTest, IS_ENHANCE_P2P_MODULE_ID_TEST_001, TestSize.Level1)
98 {
99 ListenerModule moduleId = ListenerModule::AUTH_SESSION_KEY;
100 bool ret = IsEnhanceP2pModuleId(moduleId);
101 EXPECT_FALSE(ret);
102
103 moduleId = ListenerModule::AUTH_P2P;
104 ret = IsEnhanceP2pModuleId(moduleId);
105 EXPECT_FALSE(ret);
106
107 moduleId = ListenerModule::AUTH_ENHANCED_P2P_START;
108 ret = IsEnhanceP2pModuleId(moduleId);
109 EXPECT_TRUE(ret);
110 }
111
112 /*
113 * @tc.name: CEN_CONN_ID_TEST_001
114 * @tc.desc: generate conn ID test.
115 * @tc.type: FUNC
116 * @tc.require:
117 */
118 HWTEST_F(AuthConnectionTest, CEN_CONN_ID_TEST_001, TestSize.Level1)
119 {
120 int32_t connType = 1;
121 int32_t id = 1;
122 uint64_t ret = GenConnId(connType, id);
123 EXPECT_EQ(ret, 0x100000001);
124 }
125
126 /*
127 * @tc.name: CET_CONN_TYPE_TEST_001
128 * @tc.desc: get conn type test.
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(AuthConnectionTest, CET_CONN_TYPE_TEST_001, TestSize.Level1)
133 {
134 uint64_t connId = 0x100000001;
135 int32_t ret = GetConnType(connId);
136 EXPECT_EQ(ret, 1);
137 }
138
139
140 /*
141 * @tc.name: CET_CONN_TYPE_TEST_001
142 * @tc.desc: get conn type str test.
143 * @tc.type: FUNC
144 * @tc.require:
145 */
146 HWTEST_F(AuthConnectionTest, CET_CONN_TYPE_STR_TEST_001, TestSize.Level1)
147 {
148 uint64_t connId = 0x100000000;
149 const char *str = GetConnTypeStr(connId);
150 EXPECT_STREQ(str, "wifi/eth");
151
152 connId = 0x200000000;
153 str = GetConnTypeStr(connId);
154 EXPECT_STREQ(str, "br");
155
156 connId = 0x300000000;
157 str = GetConnTypeStr(connId);
158 EXPECT_STREQ(str, "ble");
159
160 connId = 0x400000000;
161 str = GetConnTypeStr(connId);
162 EXPECT_STREQ(str, "p2p");
163
164 connId = 0x500000000;
165 str = GetConnTypeStr(connId);
166 EXPECT_STREQ(str, "enhanced_p2p");
167
168 connId = 0x800000000;
169 str = GetConnTypeStr(connId);
170 EXPECT_STREQ(str, "session");
171
172 connId = 0x900000000;
173 str = GetConnTypeStr(connId);
174 EXPECT_STREQ(str, "session");
175
176 connId = 0xA00000000;
177 str = GetConnTypeStr(connId);
178 EXPECT_STREQ(str, "sle");
179
180 connId = 0xB00000000;
181 str = GetConnTypeStr(connId);
182 EXPECT_STREQ(str, "usb");
183
184 connId = 0xC00000000;
185 str = GetConnTypeStr(connId);
186 EXPECT_STREQ(str, "unknown");
187 }
188
189 /*
190 * @tc.name: CET_CONN_TYPE_TEST_001
191 * @tc.desc: get conn id test.
192 * @tc.type: FUNC
193 * @tc.require:
194 */
195 HWTEST_F(AuthConnectionTest, CET_CONN_ID_TEST_001, TestSize.Level1)
196 {
197 uint64_t connId = 13579;
198 int32_t ret = GetConnId(connId);
199 EXPECT_EQ(ret, 13579);
200 }
201
202 /*
203 * @tc.name: CET_CONN_TYPE_TEST_001
204 * @tc.desc: get fd test.
205 * @tc.type: FUNC
206 * @tc.require:
207 */
208 HWTEST_F(AuthConnectionTest, CET_FD_TEST_001, TestSize.Level1)
209 {
210 uint64_t connId = 13579;
211 int32_t ret = GetFd(connId);
212 EXPECT_EQ(ret, 13579);
213 }
214
215 /*
216 * @tc.name: FIND_CONN_REQUEST_BY_FD_TEST_001
217 * @tc.desc: Test finding connection request by unused fd.
218 * @tc.type: FUNC
219 * @tc.require:
220 */
221 HWTEST_F(AuthConnectionTest, FIND_CONN_REQUEST_BY_FD_TEST_001, TestSize.Level1)
222 {
223 ConnRequest *connRequest = FindConnRequestByFd(TEST_FD);
224 EXPECT_EQ(connRequest, nullptr);
225 }
226
227 /*
228 * @tc.name: FIND_CONN_REQUEST_BY_FD_TEST_002
229 * @tc.desc: Test findind connection request by added fd.
230 * @tc.type: FUNC
231 * @tc.require:
232 */
233 HWTEST_F(AuthConnectionTest, FIND_CONN_REQUEST_BY_FD_TEST_002, TestSize.Level1)
234 {
235 AuthConnInfo connInfo = {
236 .type = AUTH_LINK_TYPE_WIFI,
237 };
238
239 int32_t ret = AddConnRequest(&connInfo, TEST_REQUEST_ID, TEST_FD);
240 EXPECT_EQ(ret, SOFTBUS_OK);
241 ConnRequest *connRequest = FindConnRequestByFd(TEST_FD);
242 EXPECT_NE(connRequest, nullptr);
243 ClearConnRequest();
244 }
245
246 /*
247 * @tc.name: FIND_CONN_REQUEST_BY_REQUEST_ID_TEST_001
248 * @tc.desc: Test finding connection request by nonexisted request id.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(AuthConnectionTest, FIND_CONN_REQUEST_BY_REQUEST_ID_TEST_001, TestSize.Level1)
253 {
254 ConnRequest *connRequest = FindConnRequestByRequestId(TEST_REQUEST_ID);
255 EXPECT_EQ(connRequest, nullptr);
256 }
257
258 /*
259 * @tc.name: FIND_CONN_REQUEST_BY_REQUEST_ID_TEST_001
260 * @tc.desc: Notify client connected.
261 * @tc.type: FUNC
262 * @tc.require:
263 */
264 HWTEST_F(AuthConnectionTest, NOTIFY_CLIENT_CONNECTED_TEST_001, TestSize.Level1)
265 {
266 uint32_t requestId = 1;
267 uint64_t connId = 2;
268 int32_t result = 3;
269 AuthConnInfo connInfo = {
270 .type = AUTH_LINK_TYPE_WIFI,
271 };
272 isOnConnectResultSuccess = false;
273 NotifyClientConnected(requestId, connId, result, &connInfo);
274 EXPECT_FALSE(isOnConnectResultSuccess);
275
276 ConnServerInit();
277 AuthConnListener connListener = {
278 .onConnectResult = OnConnectResult,
279 .onDisconnected = OnDisconnected,
280 .onDataReceived = OnDataReceived,
281 };
282 int32_t ret = AuthConnInit(&connListener);
283 EXPECT_EQ(ret, SOFTBUS_OK);
284 NotifyClientConnected(requestId, connId, result, &connInfo);
285 EXPECT_TRUE(isOnConnectResultSuccess);
286 AuthConnDeinit();
287 ConnServerDeinit();
288 }
289
290 /*
291 * @tc.name: NOTIFY_CLIENT_DISCONNECTED_TEST_001
292 * @tc.desc: Notify client disconnected.
293 * @tc.type: FUNC
294 * @tc.require:
295 */
296 HWTEST_F(AuthConnectionTest, NOTIFY_CLIENT_DISCONNECTED_TEST_001, TestSize.Level1)
297 {
298 uint64_t connId = 2;
299 AuthConnInfo connInfo = {
300 .type = AUTH_LINK_TYPE_WIFI,
301 };
302 isOnDisconnectedSuccess = false;
303 NotifyDisconnected(connId, &connInfo);
304 EXPECT_FALSE(isOnDisconnectedSuccess);
305
306 ConnServerInit();
307 AuthConnListener connListener = {
308 .onConnectResult = OnConnectResult,
309 .onDisconnected = OnDisconnected,
310 .onDataReceived = OnDataReceived,
311 };
312 int32_t ret = AuthConnInit(&connListener);
313 EXPECT_EQ(ret, SOFTBUS_OK);
314 NotifyDisconnected(connId, &connInfo);
315 EXPECT_TRUE(isOnDisconnectedSuccess);
316 AuthConnDeinit();
317 ConnServerDeinit();
318 }
319
320 /*
321 * @tc.name: NOTIFY_DATE_RECEIVED_TEST_001
322 * @tc.desc: Notify data received.
323 * @tc.type: FUNC
324 * @tc.require:
325 */
326 HWTEST_F(AuthConnectionTest, NOTIFY_DATE_RECEIVED_TEST_001, TestSize.Level1)
327 {
328 uint64_t connId = 2;
329 AuthConnInfo connInfo = {
330 .type = AUTH_LINK_TYPE_WIFI,
331 };
332 AuthDataHead head = {
333 .dataType = DATA_TYPE_AUTH,
334 .len = TEST_HEAD_LEN,
335 };
336 uint8_t data = 3;
337 isOnDataReceivedSuccess = false;
338 NotifyDataReceived(connId, &connInfo, true, &head, &data);
339 EXPECT_FALSE(isOnDataReceivedSuccess);
340
341 ConnServerInit();
342 AuthConnListener connListener = {
343 .onConnectResult = OnConnectResult,
344 .onDisconnected = OnDisconnected,
345 .onDataReceived = OnDataReceived,
346 };
347 int32_t ret = AuthConnInit(&connListener);
348 EXPECT_EQ(ret, SOFTBUS_OK);
349 NotifyDataReceived(connId, &connInfo, true, &head, &data);
350 EXPECT_TRUE(isOnDataReceivedSuccess);
351 AuthConnDeinit();
352 ConnServerDeinit();
353 }
354
355 /*
356 * @tc.name: GET_AUTH_DATA_SIZE_TEST_001
357 * @tc.desc: Get auth data size.
358 * @tc.type: FUNC
359 * @tc.require:
360 */
361 HWTEST_F(AuthConnectionTest, GET_AUTH_DATA_SIZE_TEST_001, TestSize.Level1)
362 {
363 uint32_t len = 10;
364 uint32_t ret = GetAuthDataSize(len);
365 EXPECT_EQ(ret, 34);
366 }
367
368 /*
369 * @tc.name: PACK_AUTH_DATA_TEST_001
370 * @tc.desc: Test buffer is not enough while packing auth data.
371 * @tc.type: FUNC
372 * @tc.require:
373 */
374 HWTEST_F(AuthConnectionTest, PACK_AUTH_DATA_TEST_001, TestSize.Level1)
375 {
376 AuthDataHead head = {
377 .len = TEST_HEAD_LEN,
378 };
379 uint8_t data[TEST_SIZE] = { 0 };
380 uint8_t buf[TEST_SIZE] = { 0 };
381 int32_t ret = PackAuthData(nullptr, data, buf, TEST_SIZE);
382 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
383
384 ret = PackAuthData(&head, nullptr, buf, TEST_SIZE);
385 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
386
387 ret = PackAuthData(&head, data, nullptr, TEST_SIZE);
388 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
389
390 ret = PackAuthData(&head, data, buf, TEST_SIZE);
391 EXPECT_EQ(ret, SOFTBUS_NO_ENOUGH_DATA);
392
393 uint32_t size = 36;
394 ret = PackAuthData(&head, data, buf, size);
395 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
396 }
397
398 /*
399 * @tc.name: UNPACK_AUTH_DATA_TEST_001
400 * @tc.desc: Test the data length is shorter than head length.
401 * @tc.type: FUNC
402 * @tc.require:
403 */
404 HWTEST_F(AuthConnectionTest, UNPACK_AUTH_DATA_TEST_001, TestSize.Level1)
405 {
406 uint8_t data[TEST_DATA_LEN] = { 0 };
407 AuthDataHead head;
408 (void)memset_s(&head, sizeof(head), 0, sizeof(head));
409 const uint8_t *buf = UnpackAuthData(data, TEST_DATA_LEN, &head);
410 EXPECT_EQ(buf, nullptr);
411
412 uint32_t size = 36;
413 buf = UnpackAuthData(data, size, &head);
414 EXPECT_EQ(buf, nullptr);
415
416 head.len = TEST_HEAD_LEN;
417 buf = UnpackAuthData(data, size, &head);
418 EXPECT_EQ(buf, nullptr);
419 }
420
421 /*
422 * @tc.name: GET_AUTH_TIMEOUT_ERR_CODE_TEST_001
423 * @tc.desc: Test GetAuthTimeoutErrCode return the exact error code according to auth link type.
424 * @tc.type: FUNC
425 * @tc.require:
426 */
427 HWTEST_F(AuthConnectionTest, GET_AUTH_TIMEOUT_ERR_CODE_TEST_001, TestSize.Level1)
428 {
429 int32_t ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_USB);
430 EXPECT_EQ(ret, SOFTBUS_AUTH_USB_CONN_TIMEOUT);
431 ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_WIFI);
432 EXPECT_EQ(ret, SOFTBUS_AUTH_WIFI_CONN_TIMEOUT);
433 ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_BR);
434 EXPECT_EQ(ret, SOFTBUS_AUTH_BR_CONN_TIMEOUT);
435 ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_BLE);
436 EXPECT_EQ(ret, SOFTBUS_AUTH_BLE_CONN_TIMEOUT);
437 ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_P2P);
438 EXPECT_EQ(ret, SOFTBUS_AUTH_P2P_CONN_TIMEOUT);
439 ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_ENHANCED_P2P);
440 EXPECT_EQ(ret, SOFTBUS_AUTH_ENHANCEP2P_CONN_TIMEOUT);
441 ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_SESSION_KEY);
442 EXPECT_EQ(ret, SOFTBUS_AUTH_SESSION_KEY_CONN_TIMEOUT);
443 ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_SLE);
444 EXPECT_EQ(ret, SOFTBUS_AUTH_SLE_CONN_TIMEOUT);
445 ret = GetAuthTimeoutErrCode(AUTH_LINK_TYPE_MAX);
446 EXPECT_EQ(ret, SOFTBUS_AUTH_CONN_TIMEOUT);
447 }
448
449 /*
450 * @tc.name: IS_SESSION_AUTH_TEST_001
451 * @tc.desc: Is session auth.
452 * @tc.type: FUNC
453 * @tc.require:
454 */
455 HWTEST_F(AuthConnectionTest, IS_SESSION_AUTH_TEST_001, TestSize.Level1)
456 {
457 int32_t module = MODULE_SESSION_KEY_AUTH;
458 bool ret = IsSessionAuth(module);
459 EXPECT_FALSE(ret);
460
461 module = MODULE_SESSION_AUTH;
462 ret = IsSessionAuth(module);
463 EXPECT_TRUE(ret);
464 }
465
466 /*
467 * @tc.name: IS_SESSION_AUTH_TEST_001
468 * @tc.desc: Is session key auth.
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 HWTEST_F(AuthConnectionTest, IS_SESSION_KEY_AUTH_TEST_001, TestSize.Level1)
473 {
474 int32_t module = MODULE_SESSION_KEY_AUTH;
475 bool ret = IsSessionKeyAuth(module);
476 EXPECT_TRUE(ret);
477
478 module = MODULE_SESSION_AUTH;
479 ret = IsSessionKeyAuth(module);
480 EXPECT_FALSE(ret);
481 }
482
483 /*
484 * @tc.name: IS_SESSION_AUTH_TEST_001
485 * @tc.desc: Init WiFi conn.
486 * @tc.type: FUNC
487 * @tc.require:
488 */
489 HWTEST_F(AuthConnectionTest, INIT_WIFI_CONN_TEST_001, TestSize.Level1)
490 {
491 int32_t ret = InitWiFiConn();
492 EXPECT_EQ(ret, SOFTBUS_OK);
493 }
494
495 /*
496 * @tc.name: ON_COMM_DISCONNECTED_TEST_001
497 * @tc.desc: notify comm disconnected.
498 * @tc.type: FUNC
499 * @tc.require:
500 */
501 HWTEST_F(AuthConnectionTest, ON_COMM_DISCONNECTED_TEST_001, TestSize.Level1)
502 {
503 uint32_t connectionId = 1;
504 ConnectionInfo info = {
505 .isAvailable = 1,
506 .isServer = 1,
507 .type = CONNECT_BR,
508 .brInfo.brMac = "11:22:33:44:55:66",
509 };
510 AuthConnListener connListener = {
511 .onConnectResult = OnConnectResult,
512 .onDisconnected = OnDisconnected,
513 .onDataReceived = OnDataReceived,
514 };
515 isOnDisconnectedSuccess = false;
516 ConnServerInit();
517 int32_t ret = AuthConnInit(&connListener);
518 EXPECT_EQ(ret, SOFTBUS_OK);
519 OnCommDisconnected(connectionId, nullptr);
520 EXPECT_FALSE(isOnDisconnectedSuccess);
521
522 OnCommDisconnected(connectionId, &info);
523 EXPECT_TRUE(isOnDisconnectedSuccess);
524 AuthConnDeinit();
525 ConnServerDeinit();
526 }
527
528 /*
529 * @tc.name: GET_CONN_INFO_BY_CONNECTION_ID_TEST_001
530 * @tc.desc: get connInfo by connection id.
531 * @tc.type: FUNC
532 * @tc.require:
533 */
534 HWTEST_F(AuthConnectionTest, GET_CONN_INFO_BY_CONNECTION_ID_TEST_001, TestSize.Level1)
535 {
536 uint32_t connectionId = 1;
537 AuthConnInfo connInfo = {
538 .type = AUTH_LINK_TYPE_WIFI,
539 };
540 int32_t ret = GetConnInfoByConnectionId(connectionId, &connInfo);
541 EXPECT_NE(ret, SOFTBUS_OK);
542 }
543
544 /*
545 * @tc.name: INIT_COMM_CONN_TEST_001
546 * @tc.desc: init comm conn.
547 * @tc.type: FUNC
548 * @tc.require:
549 */
550 HWTEST_F(AuthConnectionTest, INIT_COMM_CONN_TEST_001, TestSize.Level1)
551 {
552 int32_t ret = InitCommConn();
553 EXPECT_EQ(ret, SOFTBUS_OK);
554 AuthConnDeinit();
555 }
556
557 /*
558 * @tc.name: SESSION_CONNECT_SUCC_TEST_001
559 * @tc.desc: session connect succ.
560 * @tc.type: FUNC
561 * @tc.require:
562 */
563 HWTEST_F(AuthConnectionTest, SESSION_CONNECT_SUCC_TEST_001, TestSize.Level1)
564 {
565 uint32_t requestId = 1;
566 AuthConnInfo connInfo = {
567 .type = AUTH_LINK_TYPE_WIFI,
568 };
569 isOnConnectResultSuccess = false;
570 AuthConnListener connListener = {
571 .onConnectResult = OnConnectResult,
572 .onDisconnected = OnDisconnected,
573 .onDataReceived = OnDataReceived,
574 };
575 ConnServerInit();
576 int32_t ret = AuthConnInit(&connListener);
577 EXPECT_EQ(ret, SOFTBUS_OK);
578 SessionConnectSucc(requestId, &connInfo);
579 EXPECT_TRUE(isOnConnectResultSuccess);
580 AuthConnDeinit();
581 ConnServerDeinit();
582 }
583
584 /*
585 * @tc.name: CONNECT_AUT_DEVICE_TEST_001
586 * @tc.desc: Mock ble is not enable
587 * @tc.type: FUNC
588 * @tc.require:
589 */
590 HWTEST_F(AuthConnectionTest, CONNECT_AUT_DEVICE_TEST_001, TestSize.Level1)
591 {
592 AuthConnInfo connInfo = {
593 .type = AUTH_LINK_TYPE_WIFI,
594 };
595 connInfo.type = AUTH_LINK_TYPE_BR;
596 AuthConnectionInterfaceMock mock;
597 EXPECT_CALL(mock, SoftBusGetBtState).WillOnce(Return(BLE_DISABLE));
598 EXPECT_CALL(mock, PostAuthEvent).WillOnce(Return(SOFTBUS_OK));
599 int32_t ret = ConnectAuthDevice(1, &connInfo, CONN_SIDE_CLIENT);
600 EXPECT_EQ(ret, SOFTBUS_AUTH_CONN_FAIL);
601 }
602
603 /*
604 * @tc.name: CONNECT_AUT_DEVICE_TEST_002
605 * @tc.desc: ConnectAuthDevice success, auth link type is AUTH_LINK_TYPE_SESSION.
606 * @tc.type: FUNC
607 * @tc.require:
608 */
609 HWTEST_F(AuthConnectionTest, CONNECT_AUT_DEVICE_TEST_002, TestSize.Level1)
610 {
611 AuthConnInfo connInfo = {
612 .type = AUTH_LINK_TYPE_WIFI,
613 };
614 connInfo.type = AUTH_LINK_TYPE_SESSION;
615 AuthConnectionInterfaceMock mock;
616 EXPECT_CALL(mock, PostAuthEvent).WillOnce(Return(SOFTBUS_OK));
617 int32_t ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
618 EXPECT_EQ(ret, SOFTBUS_OK);
619 DisconnectAuthDevice(nullptr);
620 DisconnectAuthDevice(&g_connId);
621 }
622
623 /*
624 * @tc.name: CONNECT_AUT_DEVICE_TEST_003
625 * @tc.desc: ConnectAuthDevice success, auth link type is AUTH_LINK_TYPE_SESSION_KEY.
626 * @tc.type: FUNC
627 * @tc.require:
628 */
629 HWTEST_F(AuthConnectionTest, CONNECT_AUT_DEVICE_TEST_003, TestSize.Level1)
630 {
631 AuthConnInfo connInfo = {
632 .type = AUTH_LINK_TYPE_WIFI,
633 };
634 connInfo.type = AUTH_LINK_TYPE_SESSION_KEY;
635 AuthConnectionInterfaceMock mock;
636 EXPECT_CALL(mock, PostAuthEvent).WillRepeatedly(Return(SOFTBUS_OK));
637 int32_t ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
638 EXPECT_EQ(ret, SOFTBUS_OK);
639 }
640
641 /*
642 * @tc.name: CONNECT_AUT_DEVICE_TEST_004
643 * @tc.desc: ConnectAuthDevice success, auth link type is AUTH_LINK_TYPE_MAX.
644 * @tc.type: FUNC
645 * @tc.require:
646 */
647 HWTEST_F(AuthConnectionTest, CONNECT_AUT_DEVICE_TEST_004, TestSize.Level1)
648 {
649 AuthConnInfo connInfo = {
650 .type = AUTH_LINK_TYPE_WIFI,
651 };
652 connInfo.type = AUTH_LINK_TYPE_MAX;
653 AuthConnectionInterfaceMock mock;
654 EXPECT_CALL(mock, PostAuthEvent).WillOnce(Return(SOFTBUS_OK));
655 int32_t ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
656 EXPECT_EQ(ret, SOFTBUS_OK);
657 }
658
659 /*
660 * @tc.name: CONNECT_AUT_DEVICE_TEST_005
661 * @tc.desc: ConnectAuthDevice success, auth link type is AUTH_LINK_TYPE_WIFI or AUTH_LINK_TYPE_USB.
662 * @tc.type: FUNC
663 * @tc.require:
664 */
665 HWTEST_F(AuthConnectionTest, CONNECT_AUT_DEVICE_TEST_005, TestSize.Level1)
666 {
667 AuthConnInfo connInfo = {
668 .type = AUTH_LINK_TYPE_WIFI,
669 };
670 connInfo.type = AUTH_LINK_TYPE_WIFI;
671 AuthConnectionInterfaceMock mock;
672 EXPECT_CALL(mock, PostAuthEvent).WillRepeatedly(Return(SOFTBUS_OK));
673 int32_t ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
674 EXPECT_EQ(ret, SOFTBUS_OK);
675
676 connInfo.type = AUTH_LINK_TYPE_USB;
677 ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
678 EXPECT_EQ(ret, SOFTBUS_OK);
679 }
680
681 /*
682 * @tc.name: CONNECT_AUT_DEVICE_TEST_006
683 * @tc.desc: ConnectAuthDevice fail, auth link type is AUTH_LINK_TYPE_BLE or AUTH_LINK_TYPE_SLE.
684 * @tc.type: FUNC
685 * @tc.require:
686 */
687 HWTEST_F(AuthConnectionTest, CONNECT_AUT_DEVICE_TEST_006, TestSize.Level1)
688 {
689 AuthConnInfo connInfo = {
690 .type = AUTH_LINK_TYPE_WIFI,
691 };
692 connInfo.type = AUTH_LINK_TYPE_BLE;
693 AuthConnectionInterfaceMock mock;
694 EXPECT_CALL(mock, PostAuthEvent).WillRepeatedly(Return(SOFTBUS_OK));
695 int32_t ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
696 EXPECT_EQ(ret, SOFTBUS_AUTH_CONN_FAIL);
697
698 connInfo.type = AUTH_LINK_TYPE_SLE;
699 ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
700 EXPECT_EQ(ret, SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT);
701 }
702
703 /*
704 * @tc.name: CONNECT_AUT_DEVICE_TEST_007
705 * @tc.desc: ConnectAuthDevice fail, auth link type is AUTH_LINK_TYPE_P2P or AUTH_LINK_TYPE_ENHANCED_P2P.
706 * @tc.type: FUNC
707 * @tc.require:
708 */
709 HWTEST_F(AuthConnectionTest, CONNECT_AUT_DEVICE_TEST_007, TestSize.Level1)
710 {
711 AuthConnInfo connInfo = {
712 .type = AUTH_LINK_TYPE_WIFI,
713 };
714 connInfo.type = AUTH_LINK_TYPE_P2P;
715 AuthConnectionInterfaceMock mock;
716 EXPECT_CALL(mock, PostAuthEvent).WillRepeatedly(Return(SOFTBUS_OK));
717 int32_t ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
718 EXPECT_EQ(ret, SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT);
719
720 connInfo.type = AUTH_LINK_TYPE_ENHANCED_P2P;
721 ret = ConnectAuthDevice(TEST_REQUEST_ID, &connInfo, CONN_SIDE_CLIENT);
722 EXPECT_EQ(ret, SOFTBUS_CONN_MANAGER_TYPE_NOT_SUPPORT);
723 }
724
725 /*
726 * @tc.name: POST_BY_TEST_FOR_SESSION_TEST_001
727 * @tc.desc: PostBytesForSession test, data is nullptr.
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 HWTEST_F(AuthConnectionTest, POST_BY_TEST_FOR_SESSION_TEST_001, TestSize.Level1)
732 {
733 AuthDataHead head;
734 (void)memset_s(&head, sizeof(head), 0, sizeof(head));
735 int32_t ret = PostBytesForSession(TEST_FD, &head, nullptr);
736 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
737 }
738
739 /*
740 * @tc.name: POST_BY_TEST_FOR_SESSION_TEST_002
741 * @tc.desc: Mock SocketPostBytes fail.
742 * @tc.type: FUNC
743 * @tc.require:
744 */
745 HWTEST_F(AuthConnectionTest, POST_BY_TEST_FOR_SESSION_TEST_002, TestSize.Level1)
746 {
747 AuthDataHead head;
748 uint8_t data[TEST_DATA_LEN] = {0};
749 (void)memset_s(&head, sizeof(head), 0, sizeof(head));
750 AuthConnectionInterfaceMock mock;
751 int32_t ret = PostBytesForSession(TEST_FD, &head, data);
752 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
753 head.len = TEST_DATA_LEN;
754 EXPECT_CALL(mock, SocketPostBytes).WillOnce(Return(SOFTBUS_AUTH_PACK_SOCKET_PKT_FAIL));
755 ret = PostBytesForSession(TEST_FD, &head, data);
756 EXPECT_EQ(ret, SOFTBUS_AUTH_PACK_SOCKET_PKT_FAIL);
757 }
758
759 /*
760 * @tc.name: POST_BY_TEST_FOR_SESSION_TEST_003
761 * @tc.desc: PostBytesForSession success.
762 * @tc.type: FUNC
763 * @tc.require:
764 */
765 HWTEST_F(AuthConnectionTest, POST_BY_TEST_FOR_SESSION_TEST_003, TestSize.Level1)
766 {
767 AuthDataHead head;
768 uint8_t data[TEST_DATA_LEN] = {0};
769 (void)memset_s(&head, sizeof(head), 0, sizeof(head));
770 head.len = TEST_DATA_LEN;
771 AuthConnectionInterfaceMock mock;
772 EXPECT_CALL(mock, SocketPostBytes).WillOnce(Return(SOFTBUS_OK));
773 int32_t ret = PostBytesForSession(TEST_FD, &head, data);
774 EXPECT_EQ(ret, SOFTBUS_OK);
775 }
776
777 /*
778 * @tc.name: IS_AUTH_SESSION_KEY_MODULE_TEST_001
779 * @tc.desc: is auth session key module.
780 * @tc.type: FUNC
781 * @tc.require:
782 */
783 HWTEST_F(AuthConnectionTest, IS_AUTH_SESSION_KEY_MODULE_TEST_001, TestSize.Level1)
784 {
785 AuthDataHead head;
786 head.dataType = DATA_TYPE_AUTH;
787 bool ret = IsAuthSessionKeyModule(&head);
788 EXPECT_TRUE(ret);
789
790 head.dataType = DATA_TYPE_DEVICE_INFO;
791 ret = IsAuthSessionKeyModule(&head);
792 EXPECT_TRUE(ret);
793
794 head.dataType = DATA_TYPE_DEVICE_ID;
795 ret = IsAuthSessionKeyModule(&head);
796 EXPECT_TRUE(ret);
797
798 head.dataType = DATA_TYPE_CLOSE_ACK;
799 ret = IsAuthSessionKeyModule(&head);
800 EXPECT_TRUE(ret);
801
802 head.dataType = DATA_TYPE_APPLY_KEY_CONNECTION;
803 ret = IsAuthSessionKeyModule(&head);
804 EXPECT_FALSE(ret);
805 }
806
807 /*
808 * @tc.name: POST_BYTES_FOR_SESSION_KEY_TEST_001
809 * @tc.desc: post bytes for sessionKey.
810 * @tc.type: FUNC
811 * @tc.require:
812 */
813 HWTEST_F(AuthConnectionTest, POST_BYTES_FOR_SESSION_KEY_TEST_001, TestSize.Level1)
814 {
815 AuthConnectionInterfaceMock mock;
816 EXPECT_CALL(mock, SocketPostBytes).WillRepeatedly(Return(SOFTBUS_OK));
817
818 AuthDataHead head = {
819 .dataType = DATA_TYPE_AUTH,
820 .len = TEST_HEAD_LEN,
821 };
822 int32_t fd = 1;
823 uint8_t data = 2;
824 int32_t ret = PostBytesForSessionKey(fd, &head, &data);
825 EXPECT_EQ(ret, SOFTBUS_OK);
826
827 head.dataType = DATA_TYPE_APPLY_KEY_CONNECTION;
828 ret = IsAuthSessionKeyModule(&head);
829 EXPECT_EQ(ret, SOFTBUS_OK);
830 }
831
832 /*
833 * @tc.name: POST_AUTH_DATA_TEST_001
834 * @tc.desc: Post auth data.
835 * @tc.type: FUNC
836 * @tc.require:
837 */
838 HWTEST_F(AuthConnectionTest, POST_AUTH_DATA_TEST_001, TestSize.Level1)
839 {
840 AuthConnectionInterfaceMock mock;
841 EXPECT_CALL(mock, SocketPostBytes).WillRepeatedly(Return(SOFTBUS_OK));
842
843 uint64_t connId = 0x100000000;
844 bool toServer = true;
845 AuthDataHead head = {
846 .dataType = DATA_TYPE_AUTH,
847 .len = TEST_HEAD_LEN,
848 };
849 uint8_t data = 2;
850 int32_t ret = PostAuthData(connId, toServer, nullptr, &data);
851 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
852
853 ret = PostAuthData(connId, toServer, &head, nullptr);
854 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
855
856 ret = PostAuthData(connId, toServer, &head, &data);
857 EXPECT_EQ(ret, SOFTBUS_OK);
858
859 connId = 0xB00000000;
860 ret = PostAuthData(connId, toServer, &head, &data);
861 EXPECT_EQ(ret, SOFTBUS_OK);
862
863 connId = 0x200000000;
864 ret = PostAuthData(connId, toServer, &head, &data);
865 EXPECT_NE(ret, SOFTBUS_OK);
866
867 connId = 0x300000000;
868 ret = PostAuthData(connId, toServer, &head, &data);
869 EXPECT_NE(ret, SOFTBUS_OK);
870
871 connId = 0xA00000000;
872 ret = PostAuthData(connId, toServer, &head, &data);
873 EXPECT_NE(ret, SOFTBUS_OK);
874 }
875
876 /*
877 * @tc.name: POST_AUTH_DATA_TEST_002
878 * @tc.desc: Post auth data.
879 * @tc.type: FUNC
880 * @tc.require:
881 */
882 HWTEST_F(AuthConnectionTest, POST_AUTH_DATA_TEST_002, TestSize.Level1)
883 {
884 AuthConnectionInterfaceMock mock;
885 EXPECT_CALL(mock, SocketPostBytes).WillRepeatedly(Return(SOFTBUS_OK));
886
887 uint64_t connId = 0x900000000;
888 bool toServer = true;
889 AuthDataHead head = {
890 .dataType = DATA_TYPE_AUTH,
891 .len = TEST_HEAD_LEN,
892 };
893 uint8_t data = 2;
894 int32_t ret = PostAuthData(connId, toServer, &head, &data);
895 EXPECT_EQ(ret, SOFTBUS_OK);
896
897 connId = 0xC00000000;
898 ret = PostAuthData(connId, toServer, &head, &data);
899 EXPECT_NE(ret, SOFTBUS_OK);
900
901 connId = 0x400000000;
902 ret = PostAuthData(connId, toServer, &head, &data);
903 EXPECT_NE(ret, SOFTBUS_OK);
904
905 connId = 0x500000000;
906 ret = PostAuthData(connId, toServer, &head, &data);
907 EXPECT_NE(ret, SOFTBUS_OK);
908
909 connId = 0x800000000;
910 ret = PostAuthData(connId, toServer, &head, &data);
911 EXPECT_EQ(ret, SOFTBUS_OK);
912 }
913
914 /*
915 * @tc.name: GET_CONN_SIDE_TYPE_TEST_001
916 * @tc.desc: get conn side type.
917 * @tc.type: FUNC
918 * @tc.require:
919 */
920 HWTEST_F(AuthConnectionTest, GET_CONN_SIDE_TYPE_TEST_001, TestSize.Level1)
921 {
922 uint64_t connId = 0x100000000;
923 ConnSideType ret = GetConnSideType(connId);
924 EXPECT_EQ(ret, CONN_SIDE_ANY);
925
926 connId = 0xB00000000;
927 ret = GetConnSideType(connId);
928 EXPECT_EQ(ret, CONN_SIDE_ANY);
929
930 connId = 0x200000000;
931 ret = GetConnSideType(connId);
932 EXPECT_EQ(ret, CONN_SIDE_ANY);
933 }
934
935 /*
936 * @tc.name: CHECK_ACTIVE_AUTH_CONNECTION_TEST_001
937 * @tc.desc: check active auth connection.
938 * @tc.type: FUNC
939 * @tc.require:
940 */
941 HWTEST_F(AuthConnectionTest, CHECK_ACTIVE_AUTH_CONNECTION_TEST_001, TestSize.Level1)
942 {
943 bool ret = CheckActiveAuthConnection(nullptr);
944 EXPECT_FALSE(ret);
945 AuthConnInfo connInfo = {
946 .type = AUTH_LINK_TYPE_WIFI,
947 };
948 connInfo.type = AUTH_LINK_TYPE_BLE;
949 ret = CheckActiveAuthConnection(nullptr);
950 EXPECT_FALSE(ret);
951 }
952
953 /*
954 * @tc.name: AUTH_START_LISTENING_TEST_001
955 * @tc.desc: Auth start wifi listening success.
956 * @tc.type: FUNC
957 * @tc.require:
958 */
959 HWTEST_F(AuthConnectionTest, AUTH_START_LISTENING_TEST_001, TestSize.Level1)
960 {
961 AuthConnectionInterfaceMock mock;
962 EXPECT_CALL(mock, StartSocketListening).WillOnce(Return(SOFTBUS_OK));
963 int32_t ret = AuthStartListening(AUTH_LINK_TYPE_WIFI, TEST_IP, TEST_PORT);
964 EXPECT_EQ(ret, SOFTBUS_OK);
965 AuthStopListening(AUTH_LINK_TYPE_WIFI);
966 }
967
968 /*
969 * @tc.name: AUTH_START_LISTENING_TEST_002
970 * @tc.desc: Auth start enhanced p2p listening success.
971 * @tc.type: FUNC
972 * @tc.require:
973 */
974 HWTEST_F(AuthConnectionTest, AUTH_START_LISTENING_TEST_002, TestSize.Level1)
975 {
976 AuthConnectionInterfaceMock mock;
977 EXPECT_CALL(mock, StartSocketListening).WillOnce(Return(SOFTBUS_OK));
978 int32_t ret = AuthStartListening(AUTH_LINK_TYPE_RAW_ENHANCED_P2P, TEST_IP, TEST_PORT);
979 EXPECT_EQ(ret, SOFTBUS_OK);
980 AuthStopListening(AUTH_LINK_TYPE_RAW_ENHANCED_P2P);
981 }
982
983 /*
984 * @tc.name: AUTH_START_LISTENING_TEST_003
985 * @tc.desc: Unsupported link type.
986 * @tc.type: FUNC
987 * @tc.require:
988 */
989 HWTEST_F(AuthConnectionTest, AUTH_START_LISTENING_TEST_003, TestSize.Level1)
990 {
991 int32_t ret = AuthStartListening(AUTH_LINK_TYPE_ENHANCED_P2P, TEST_IP, TEST_PORT);
992 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
993 AuthStopListening(AUTH_LINK_TYPE_ENHANCED_P2P);
994 }
995
996 /*
997 * @tc.name: AUTH_START_LISTENING_TEST_004
998 * @tc.desc: Auth start usb listening success.
999 * @tc.type: FUNC
1000 * @tc.require:
1001 */
1002 HWTEST_F(AuthConnectionTest, AUTH_START_LISTENING_TEST_004, TestSize.Level1)
1003 {
1004 AuthConnectionInterfaceMock mock;
1005 EXPECT_CALL(mock, StartSocketListening).WillOnce(Return(SOFTBUS_OK));
1006 int32_t ret = AuthStartListening(AUTH_LINK_TYPE_USB, TEST_IP, TEST_PORT);
1007 EXPECT_EQ(ret, SOFTBUS_OK);
1008 AuthStopListening(AUTH_LINK_TYPE_USB);
1009 }
1010
1011 /*
1012 * @tc.name: AUTH_START_LISTENING_FOR_WIFI_DIRECT_TEST_001
1013 * @tc.desc: Auth start AUTH_LINK_TYPE_P2P listening.
1014 * @tc.type: FUNC
1015 * @tc.require:
1016 */
1017 HWTEST_F(AuthConnectionTest, AUTH_START_LISTENING_FOR_WIFI_DIRECT_TEST_001, TestSize.Level1)
1018 {
1019 AuthLinkType type = AUTH_LINK_TYPE_P2P;
1020 const char *addr = "192.168.11.44";
1021 int32_t port = 37025;
1022 ListenerModule moduleId = ListenerModule::AUTH_P2P;
1023
1024 int32_t ret = AuthStartListeningForWifiDirect(type, nullptr, port, &moduleId);
1025 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1026
1027 ret = AuthStartListeningForWifiDirect(type, addr, port, nullptr);
1028 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1029
1030 ret = AuthStartListeningForWifiDirect(type, addr, port, &moduleId);
1031 EXPECT_NE(ret, SOFTBUS_OK);
1032
1033 type = AUTH_LINK_TYPE_ENHANCED_P2P;
1034 ret = AuthStartListeningForWifiDirect(type, addr, port, &moduleId);
1035 EXPECT_NE(ret, SOFTBUS_OK);
1036
1037 type = AUTH_LINK_TYPE_WIFI;
1038 ret = AuthStartListeningForWifiDirect(type, addr, port, &moduleId);
1039 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1040 }
1041 }
1042