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 <gtest/gtest.h>
17
18 #include "auth_interface.h"
19 #include "bus_center_manager.h"
20 #include "softbus_adapter_mem.h"
21 #include "softbus_app_info.h"
22 #include "softbus_conn_interface.h"
23 #include "softbus_feature_config.h"
24 #include "trans_session_account_adapter.h"
25 #include "trans_session_ipc_adapter.h"
26 #include "trans_session_manager.c"
27 #include "trans_session_manager.h"
28 #include "trans_session_service.h"
29
30 #define TRANS_TEST_INVALID_PID (-1)
31 #define TRANS_TEST_INVALID_UID (-1)
32
33 #define MAX_SESSION_SERVER_NUM 100
34 #define TEST_UID 488
35 #define TEST_PID 1335
36
37 using namespace testing::ext;
38
39 namespace OHOS {
40
41 const char *g_pkgName = "dms";
42 const char *g_sessionName = "ohos.distributedschedule.dms.test";
43 const char *g_networkid = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
44 class TransSessionManagerTest : public testing::Test {
45 public:
TransSessionManagerTest()46 TransSessionManagerTest()
47 {}
~TransSessionManagerTest()48 ~TransSessionManagerTest()
49 {}
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
SetUp()52 void SetUp() override
53 {}
TearDown()54 void TearDown() override
55 {}
56 };
57
SetUpTestCase(void)58 void TransSessionManagerTest::SetUpTestCase(void)
59 {
60 SoftbusConfigInit();
61 ConnServerInit();
62 AuthInit();
63 BusCenterServerInit();
64 TransServerInit();
65 }
66
TearDownTestCase(void)67 void TransSessionManagerTest::TearDownTestCase(void)
68 {
69 ConnServerDeinit();
70 AuthDeinit();
71 BusCenterServerDeinit();
72 TransServerDeinit();
73 }
74
BuildSessionServer()75 static SessionServer *BuildSessionServer()
76 {
77 SessionServer *sessionServer = (SessionServer*)SoftBusCalloc(sizeof(SessionServer));
78 if (sessionServer == nullptr) {
79 return nullptr;
80 }
81 int32_t ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
82 if (ret != EOK) {
83 SoftBusFree(sessionServer);
84 return nullptr;
85 }
86 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
87 if (ret != EOK) {
88 SoftBusFree(sessionServer);
89 return nullptr;
90 }
91 return sessionServer;
92 }
93
94 /**
95 * @tc.name: TransSessionManagerTest01
96 * @tc.desc: Transmission session manager initialize.
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest01, TestSize.Level1)
101 {
102 int32_t ret = TransSessionMgrInit();
103 EXPECT_EQ(ret, SOFTBUS_OK);
104 TransSessionMgrDeinit();
105 ret = TransSessionMgrInit();
106 EXPECT_EQ(ret, SOFTBUS_OK);
107 TransSessionMgrDeinit();
108 }
109
110 /**
111 * @tc.name: TransSessionManagerTest02
112 * @tc.desc: Transmission session manager judge whether session exists with invalid parameters.
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest02, TestSize.Level1)
117 {
118 bool res = TransSessionServerIsExist(nullptr);
119 EXPECT_FALSE(res);
120 res = TransSessionServerIsExist(g_sessionName);
121 EXPECT_FALSE(res);
122 }
123
124 /**
125 * @tc.name: TransSessionManagerTest03
126 * @tc.desc: Transmission session manager add item with invalid parameters.
127 * @tc.type: FUNC
128 * @tc.require:
129 */
130 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest03, TestSize.Level1)
131 {
132 int32_t ret = TransSessionServerAddItem(nullptr);
133 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
134 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
135 ASSERT_TRUE(sessionServer != nullptr);
136 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
137 ret = TransSessionServerAddItem(sessionServer);
138 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
139 }
140
141 /**
142 * @tc.name: TransSessionManagerTest04
143 * @tc.desc: Transmission session manager del item with invalid parameters.
144 * @tc.type: FUNC
145 * @tc.require:
146 */
147 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest04, TestSize.Level1)
148 {
149 int32_t ret = TransSessionServerDelItem(nullptr);
150 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
151 ret = TransSessionServerDelItem(g_sessionName);
152 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
153
154 ret = TransGetCallingFullTokenId(nullptr);
155 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
156
157 ret = TransGetUserIdFromUid(TEST_UID);
158 EXPECT_NE(ret, INVALID_USER_ID);
159
160 int32_t UID_1 = 30001000; // test value
161 ret = TransGetUserIdFromUid(UID_1);
162 EXPECT_NE(ret, INVALID_USER_ID);
163 }
164
165 /**
166 * @tc.name: TransSessionManagerTest05
167 * @tc.desc: Transmission session manager del item with not existed item.
168 * @tc.type: FUNC
169 * @tc.require:
170 */
171 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest05, TestSize.Level1)
172 {
173 int32_t ret = TransSessionMgrInit();
174 EXPECT_EQ(ret, SOFTBUS_OK);
175 TransSessionServerDelItem(g_sessionName);
176 TransSessionMgrDeinit();
177 }
178
179 /**
180 * @tc.name: TransSessionManagerTest06
181 * @tc.desc: Transmission session manager get package name by session name with invalid parameters.
182 * @tc.type: FUNC
183 * @tc.require:
184 */
185 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest06, TestSize.Level1)
186 {
187 int32_t ret = TransSessionMgrInit();
188 EXPECT_EQ(ret, SOFTBUS_OK);
189 char pkgName[PKG_NAME_SIZE_MAX] = {0};
190 ret = TransGetPkgNameBySessionName(nullptr, pkgName, PKG_NAME_SIZE_MAX);
191 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
192 ret = TransGetPkgNameBySessionName(g_sessionName, nullptr, PKG_NAME_SIZE_MAX);
193 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
194 ret = TransGetPkgNameBySessionName(g_sessionName, pkgName, 0);
195 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
196 TransSessionMgrDeinit();
197 }
198
199 /**
200 * @tc.name: TransSessionManagerTest07
201 * @tc.desc: Transmission session manager delete item by package name with invalid parameters.
202 * @tc.type: FUNC
203 * @tc.require:
204 */
205 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest07, TestSize.Level1)
206 {
207 int32_t ret = TransSessionMgrInit();
208 EXPECT_EQ(ret, SOFTBUS_OK);
209 SessionServer *sessionServer = BuildSessionServer();
210 EXPECT_TRUE(sessionServer != nullptr);
211 sessionServer->pid = TRANS_TEST_INVALID_PID;
212 ret = TransSessionServerAddItem(sessionServer);
213 EXPECT_EQ(ret, SOFTBUS_OK);
214 bool res = TransSessionServerIsExist(g_sessionName);
215 EXPECT_TRUE(res);
216 TransDelItemByPackageName(nullptr, TRANS_TEST_INVALID_PID);
217 res = TransSessionServerIsExist(g_sessionName);
218 EXPECT_TRUE(res);
219 TransSessionMgrDeinit();
220 TransDelItemByPackageName(g_pkgName, TRANS_TEST_INVALID_PID);
221 }
222
223 /**
224 * @tc.name: TransSessionManagerTest08
225 * @tc.desc: Transmission session manager get uid and pid by session name with invalid parameters.
226 * @tc.type: FUNC
227 * @tc.require:
228 */
229 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest08, TestSize.Level1)
230 {
231 int32_t pid = 0;
232 int32_t uid = 0;
233 int32_t ret = TransGetUidAndPid(nullptr, &uid, &pid);
234 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
235 ret = TransGetUidAndPid(g_sessionName, nullptr, &pid);
236 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
237 ret = TransGetUidAndPid(g_sessionName, &uid, nullptr);
238 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
239 ret = TransGetUidAndPid(g_sessionName, &uid, &pid);
240 EXPECT_NE(ret, SOFTBUS_OK);
241 }
242
243 /**
244 * @tc.name: TransSessionManagerTest09
245 * @tc.desc: Transmission session manager get package name by session name.
246 * @tc.type: FUNC
247 * @tc.require:
248 */
249 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest09, TestSize.Level1)
250 {
251 int32_t ret = TransSessionMgrInit();
252 EXPECT_EQ(ret, SOFTBUS_OK);
253 SessionServer *sessionServer = BuildSessionServer();
254 EXPECT_TRUE(sessionServer != nullptr);
255 ret = TransSessionServerAddItem(sessionServer);
256 EXPECT_EQ(ret, SOFTBUS_OK);
257 char pkgName[PKG_NAME_SIZE_MAX] = {0};
258 ret = TransGetPkgNameBySessionName(g_sessionName, pkgName, PKG_NAME_SIZE_MAX);
259 EXPECT_EQ(ret, SOFTBUS_OK);
260 ret = strncmp(pkgName, g_pkgName, strlen(g_pkgName));
261 EXPECT_EQ(ret, EOK);
262 ret = TransSessionServerDelItem(g_sessionName);
263 EXPECT_EQ(ret, SOFTBUS_OK);
264 TransSessionMgrDeinit();
265 }
266
267 /**
268 * @tc.name: TransSessionManagerTest10
269 * @tc.desc: Transmission session manager delete item by package name.
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest10, TestSize.Level1)
274 {
275 int32_t ret = TransSessionMgrInit();
276 EXPECT_EQ(ret, SOFTBUS_OK);
277 SessionServer *sessionServer = BuildSessionServer();
278 EXPECT_TRUE(sessionServer != nullptr);
279 sessionServer->pid = TRANS_TEST_INVALID_PID;
280 ret = TransSessionServerAddItem(sessionServer);
281 EXPECT_EQ(ret, SOFTBUS_OK);
282 TransDelItemByPackageName(g_pkgName, TRANS_TEST_INVALID_PID);
283 bool res = TransSessionServerIsExist(g_sessionName);
284 EXPECT_FALSE(res);
285 TransSessionMgrDeinit();
286 }
287
288 /**
289 * @tc.name: TransSessionManagerTest11
290 * @tc.desc: Transmission session manager judge whether session exists.
291 * @tc.type: FUNC
292 * @tc.require:
293 */
294 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest11, TestSize.Level1)
295 {
296 int32_t ret = TransSessionMgrInit();
297 EXPECT_EQ(ret, SOFTBUS_OK);
298 SessionServer *sessionServer = BuildSessionServer();
299 EXPECT_TRUE(sessionServer != nullptr);
300 sessionServer->pid = TRANS_TEST_INVALID_PID;
301 ret = TransSessionServerAddItem(sessionServer);
302 EXPECT_EQ(ret, SOFTBUS_OK);
303 bool res = TransSessionServerIsExist(g_sessionName);
304 EXPECT_TRUE(res);
305 SessionServer *newSessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
306 EXPECT_TRUE(newSessionServer != nullptr);
307 memset_s(newSessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
308 ret = strcpy_s(newSessionServer->sessionName, sizeof(newSessionServer->sessionName), g_sessionName);
309 EXPECT_EQ(ret, EOK);
310 ret = strcpy_s(newSessionServer->pkgName, sizeof(newSessionServer->pkgName), g_pkgName);
311 EXPECT_EQ(ret, EOK);
312 newSessionServer->pid = TRANS_TEST_INVALID_PID;
313 ret = TransSessionServerAddItem(newSessionServer);
314 EXPECT_EQ(ret, SOFTBUS_SERVER_NAME_REPEATED);
315 ret = TransSessionServerDelItem(g_sessionName);
316 EXPECT_EQ(ret, SOFTBUS_OK);
317 SoftBusFree(newSessionServer);
318 TransSessionMgrDeinit();
319 }
320 /**
321 * @tc.name: TransSessionManagerTest12
322 * @tc.desc: Transmission session manager get pid and uid by session name.
323 * @tc.type: FUNC
324 * @tc.require:
325 */
326 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest12, TestSize.Level1)
327 {
328 int32_t ret = TransSessionMgrInit();
329 EXPECT_EQ(ret, SOFTBUS_OK);
330 SessionServer *sessionServer = BuildSessionServer();
331 EXPECT_TRUE(sessionServer != nullptr);
332 sessionServer->pid = TRANS_TEST_INVALID_PID;
333 sessionServer->uid = TRANS_TEST_INVALID_UID;
334 ret = TransSessionServerAddItem(sessionServer);
335 EXPECT_EQ(ret, SOFTBUS_OK);
336 int32_t pid = 0;
337 int32_t uid = 0;
338 ret = TransGetUidAndPid(g_sessionName, &uid, &pid);
339 EXPECT_EQ(uid, TRANS_TEST_INVALID_UID);
340 EXPECT_EQ(pid, TRANS_TEST_INVALID_PID);
341 ret = TransSessionServerDelItem(g_sessionName);
342 EXPECT_EQ(ret, SOFTBUS_OK);
343 TransSessionMgrDeinit();
344 }
345
346 /**
347 * @tc.name: TransSessionManagerTest13
348 * @tc.desc: Transmission session manager onLink down with invalid parameters.
349 * @tc.type: FUNC
350 * @tc.require:
351 */
352 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest13, TestSize.Level1)
353 {
354 int32_t ret = TransSessionMgrInit();
355 EXPECT_EQ(ret, SOFTBUS_OK);
356 TransOnLinkDown(nullptr, nullptr, nullptr, nullptr, WIFI_P2P);
357 TransSessionMgrDeinit();
358 TransOnLinkDown(g_networkid, nullptr, nullptr, nullptr, WIFI_P2P);
359 }
360
361 /**
362 * @tc.name: TransSessionManagerTest14
363 * @tc.desc: Transmission session manager onLink down with wrong parameters.
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest14, TestSize.Level1)
368 {
369 int32_t ret = TransSessionMgrInit();
370 EXPECT_EQ(ret, SOFTBUS_OK);
371 SessionServer *sessionServer = BuildSessionServer();
372 EXPECT_TRUE(sessionServer != nullptr);
373 sessionServer->pid = TRANS_TEST_INVALID_PID;
374 sessionServer->uid = TRANS_TEST_INVALID_UID;
375 ret = TransSessionServerAddItem(sessionServer);
376 EXPECT_EQ(ret, SOFTBUS_OK);
377 TransOnLinkDown(g_networkid, nullptr, nullptr, nullptr, WIFI_P2P);
378 }
379
380 /**
381 * @tc.name: TransSessionManagerTest15
382 * @tc.desc: Transmission session manager add item to maxmun.
383 * @tc.type: FUNC
384 * @tc.require:
385 */
386 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest15, TestSize.Level1)
387 {
388 int32_t ret = TransSessionMgrInit();
389 EXPECT_EQ(ret, SOFTBUS_OK);
390 for (int32_t i = 0; i < MAX_SESSION_SERVER_NUM - 1; ++i) {
391 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
392 char pkgName[PKG_NAME_SIZE_MAX] = {0};
393 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
394 EXPECT_GT(ret, 0);
395 ret = sprintf_s(pkgName, PKG_NAME_SIZE_MAX, "%s%d", g_pkgName, i);
396 EXPECT_GT(ret, 0);
397 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
398 EXPECT_TRUE(sessionServer != nullptr);
399 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
400 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), sessionNme);
401 EXPECT_EQ(ret, EOK);
402 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), pkgName);
403 EXPECT_EQ(ret, EOK);
404 ret = TransSessionServerAddItem(sessionServer);
405 EXPECT_EQ(ret, SOFTBUS_OK);
406 }
407
408 SessionServer *sessionServer = (SessionServer*)SoftBusMalloc(sizeof(SessionServer));
409 EXPECT_TRUE(sessionServer != nullptr);
410 memset_s(sessionServer, sizeof(SessionServer), 0, sizeof(SessionServer));
411 ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
412 EXPECT_EQ(ret, EOK);
413 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
414 EXPECT_EQ(ret, EOK);
415 ret = TransSessionServerAddItem(sessionServer);
416 EXPECT_EQ(ret, SOFTBUS_INVALID_NUM);
417 SoftBusFree(sessionServer);
418
419 for (int32_t i = 0; i < MAX_SESSION_SERVER_NUM - 1; ++i) {
420 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
421 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
422 EXPECT_GT(ret, 0);
423 ret = TransSessionServerDelItem(sessionNme);
424 EXPECT_EQ(ret, SOFTBUS_OK);
425 }
426 TransSessionMgrDeinit();
427 }
428
429 /**
430 * @tc.name: TransSessionManagerTest16
431 * @tc.desc: Transmission session manager test .
432 * @tc.type: FUNC
433 * @tc.require:
434 */
435 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest16, TestSize.Level1)
436 {
437 int32_t ret = TransSessionMgrInit();
438 EXPECT_EQ(ret, SOFTBUS_OK);
439 SessionServer *sessionServer = BuildSessionServer();
440 EXPECT_TRUE(sessionServer != nullptr);
441 sessionServer->pid = TRANS_TEST_INVALID_PID;
442 sessionServer->uid = 0;
443 ret = TransSessionServerAddItem(sessionServer);
444 EXPECT_EQ(ret, SOFTBUS_OK);
445
446 int32_t pid = 0;
447 char pkgName[PKG_NAME_SIZE_MAX] = { 0 };
448 ret = TransGetPidAndPkgName(g_sessionName, 0, &pid, pkgName, PKG_NAME_SIZE_MAX);
449 EXPECT_EQ(SOFTBUS_OK, ret);
450 char sessionNme0[SESSION_NAME_SIZE_MAX] = {0};
451 ret = sprintf_s(sessionNme0, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, 0);
452 EXPECT_GT(ret, 0);
453 ret = TransGetPidAndPkgName(sessionNme0, 0, &pid, pkgName, PKG_NAME_SIZE_MAX);
454 EXPECT_EQ(SOFTBUS_TRANS_GET_PID_FAILED, ret);
455
456 uint64_t tokenId = 0;
457 ret = TransGetTokenIdBySessionName(g_sessionName, &tokenId);
458 EXPECT_EQ(SOFTBUS_OK, ret);
459 ret = TransGetTokenIdBySessionName(sessionNme0, &tokenId);
460 EXPECT_EQ(SOFTBUS_TRANS_SESSION_NAME_NO_EXIST, ret);
461
462 ret = TransSessionServerDelItem(g_sessionName);
463 EXPECT_EQ(SOFTBUS_OK, ret);
464 TransSessionMgrDeinit();
465 }
466
GenerateSessionServer()467 static SessionServer *GenerateSessionServer()
468 {
469 SessionServer *sessionServer = static_cast<SessionServer *>(SoftBusCalloc(sizeof(SessionServer)));
470 EXPECT_NE(nullptr, sessionServer);
471
472 int32_t ret = strcpy_s(sessionServer->sessionName, sizeof(sessionServer->sessionName), g_sessionName);
473 if (ret != EOK) {
474 SoftBusFree(sessionServer);
475 return nullptr;
476 }
477
478 ret = strcpy_s(sessionServer->pkgName, sizeof(sessionServer->pkgName), g_pkgName);
479 if (ret != EOK) {
480 SoftBusFree(sessionServer);
481 return nullptr;
482 }
483
484 return sessionServer;
485 }
486
487 /**
488 * @tc.name: TransSessionManagerTest17
489 * @tc.desc: Transmission session manager test .
490 * @tc.type: FUNC
491 * @tc.require:
492 */
493 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest17, TestSize.Level1)
494 {
495 int32_t ret = TransGetUserIdFromSessionName(nullptr);
496 EXPECT_EQ(INVALID_USER_ID, ret);
497
498 ret = TransSessionMgrInit();
499 EXPECT_EQ(SOFTBUS_OK, ret);
500
501 SessionServer *sessionServer = GenerateSessionServer();
502 EXPECT_NE(nullptr, sessionServer);
503
504 ret = TransSessionServerAddItem(sessionServer);
505 EXPECT_EQ(SOFTBUS_OK, ret);
506
507 ret = TransGetUserIdFromSessionName(g_sessionName);
508 EXPECT_EQ(SOFTBUS_OK, ret);
509
510 TransSessionMgrDeinit();
511 }
512
513 /**
514 * @tc.name: TransSessionManagerTest20
515 * @tc.desc: test AddAccessInfoBySessionName invalid value.
516 * @tc.type: FUNC
517 * @tc.require:
518 */
519 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest20, TestSize.Level1)
520 {
521 char *sessionName = NULL;
522 AccessInfo accessInfo;
523 memset_s(&accessInfo, sizeof(AccessInfo), 0, sizeof(AccessInfo));
524 pid_t callingPid = (pid_t)TEST_PID;
525 int32_t ret = AddAccessInfoBySessionName(nullptr, &accessInfo, callingPid);
526 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
527 ret = AddAccessInfoBySessionName(sessionName, nullptr, callingPid);
528 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
529 }
530
531 /**
532 * @tc.name: TransSessionManagerTest21
533 * @tc.desc: test AddAccessInfoBySessionName not init.
534 * @tc.type: FUNC
535 * @tc.require:
536 */
537 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest21, TestSize.Level1)
538 {
539 char sessionName[] = "testSessionName";
540 AccessInfo accessInfo;
541 pid_t callingPid = (pid_t)TEST_PID;
542 memset_s(&accessInfo, sizeof(AccessInfo), 0, sizeof(AccessInfo));
543 int32_t ret = AddAccessInfoBySessionName(sessionName, &accessInfo, callingPid);
544 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
545 }
546
547 /**
548 * @tc.name: TransSessionManagerTest22
549 * @tc.desc: test AddAccessInfoBySessionName already init.
550 * @tc.type: FUNC
551 * @tc.require:
552 */
553 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest22, TestSize.Level1)
554 {
555 char sessionName[] = "testSessionName";
556 AccessInfo accessInfo;
557 memset_s(&accessInfo, sizeof(AccessInfo), 0, sizeof(AccessInfo));
558 pid_t callingPid = (pid_t)TEST_PID;
559 int32_t ret = TransSessionMgrInit();
560 EXPECT_EQ(SOFTBUS_OK, ret);
561 ret = AddAccessInfoBySessionName(sessionName, &accessInfo, callingPid);
562 EXPECT_EQ(SOFTBUS_TRANS_SESSION_NAME_NO_EXIST, ret);
563 TransSessionMgrDeinit();
564 }
565
566 /**
567 * @tc.name: TransSessionManagerTest23
568 * @tc.desc: test AddAccessInfoBySessionName success.
569 * @tc.type: FUNC
570 * @tc.require:
571 */
572 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest23, TestSize.Level1)
573 {
574 AccessInfo accessInfo;
575 memset_s(&accessInfo, sizeof(AccessInfo), 0, sizeof(AccessInfo));
576 accessInfo.extraAccessInfo = (char *)SoftBusCalloc(EXTRA_ACCESS_INFO_LEN_MAX);
577 ASSERT_TRUE(accessInfo.extraAccessInfo != nullptr);
578 memset_s(accessInfo.extraAccessInfo, EXTRA_ACCESS_INFO_LEN_MAX - 1, 'm', EXTRA_ACCESS_INFO_LEN_MAX - 1);
579 pid_t callingPid = (pid_t)TEST_PID;
580 int32_t userId = TEST_PID;
581 uint64_t tokenId = TEST_PID;
582 char businessAccountId[] = "testBusinessAccountId";
583 char extraAccessInfo[] = "testExtraAccessInfo";
584
585 SessionServer *newNode = (SessionServer *)SoftBusCalloc(sizeof(SessionServer));
586 ASSERT_TRUE(newNode != nullptr);
587 char sessionName[] = "testSessionNametest";
588 strcpy_s(newNode->sessionName, sizeof(sessionName), sessionName);
589 newNode->pid = (pid_t)TEST_PID;
590 int32_t ret = GetAccessInfoBySessionName(sessionName, &userId, &tokenId, businessAccountId, extraAccessInfo);
591 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
592
593 ret = TransSessionMgrInit();
594 EXPECT_EQ(SOFTBUS_OK, ret);
595
596 ret = TransSessionServerAddItem(newNode);
597 EXPECT_EQ(SOFTBUS_OK, ret);
598
599 ret = AddAccessInfoBySessionName(sessionName, &accessInfo, callingPid);
600 EXPECT_EQ(SOFTBUS_OK, ret);
601 ret = GetAccessInfoBySessionName(nullptr, &userId, &tokenId, businessAccountId, extraAccessInfo);
602 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
603 ret = GetAccessInfoBySessionName(sessionName, nullptr, &tokenId, businessAccountId, extraAccessInfo);
604 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
605 ret = GetAccessInfoBySessionName(sessionName, &userId, nullptr, businessAccountId, extraAccessInfo);
606 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
607 ret = GetAccessInfoBySessionName(sessionName, &userId, &tokenId, businessAccountId, nullptr);
608 EXPECT_EQ(SOFTBUS_OK, ret);
609
610 ret = TransSessionServerDelItem(sessionName);
611 EXPECT_EQ(SOFTBUS_OK, ret);
612 TransSessionMgrDeinit();
613 SoftBusFree(accessInfo.extraAccessInfo);
614 }
615
616 /**
617 * @tc.name: TransSessionManagerTest24
618 * @tc.desc: test AddAccessInfoBySessionName extraAccessInfo is null.
619 * @tc.type: FUNC
620 * @tc.require:
621 */
622 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest24, TestSize.Level1)
623 {
624 char sessionName[] = "testSessionName1";
625 AccessInfo accessInfo;
626 memset_s(&accessInfo, sizeof(AccessInfo), 0, sizeof(AccessInfo));
627 SessionServer *newNode = (SessionServer *)SoftBusCalloc(sizeof(SessionServer));
628 ASSERT_TRUE(newNode != nullptr);
629 strcpy_s(newNode->sessionName, strlen(sessionName), sessionName);
630 newNode->pid = (pid_t)TEST_PID;
631 pid_t callingPid = (pid_t)TEST_PID;
632
633 int32_t ret = TransSessionMgrInit();
634 EXPECT_EQ(SOFTBUS_OK, ret);
635
636 ret = TransSessionServerAddItem(newNode);
637 EXPECT_EQ(SOFTBUS_OK, ret);
638
639 ret = AddAccessInfoBySessionName(sessionName, &accessInfo, callingPid);
640 EXPECT_NE(SOFTBUS_NO_INIT, ret);
641 ret = AddAccessInfoBySessionName(sessionName, &accessInfo, 0);
642 EXPECT_NE(SOFTBUS_NO_INIT, ret);
643
644 ret = TransSessionServerDelItem(sessionName);
645 EXPECT_EQ(SOFTBUS_OK, ret);
646 TransSessionMgrDeinit();
647 }
648
649 /**
650 * @tc.name: TransSessionManagerTest25
651 * @tc.desc: test AddAccessInfoBySessionName extraAccessInfo is null.
652 * @tc.type: FUNC
653 * @tc.require:
654 */
655 HWTEST_F(TransSessionManagerTest, TransSessionManagerTest25, TestSize.Level1)
656 {
657 char sessionName[] = "testSessionName1";
658 SessionServer *newNode = reinterpret_cast<SessionServer *>(SoftBusCalloc(sizeof(SessionServer)));
659 ASSERT_TRUE(newNode != nullptr);
660 (void)strcpy_s(newNode->sessionName, strlen(sessionName), sessionName);
661 newNode->pid = (pid_t)TEST_PID;
662 uint64_t time = 1;
663 int32_t ret = CheckAndUpdateTimeBySessionName(nullptr, time);
664 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
665 ret = CheckAndUpdateTimeBySessionName(sessionName, time);
666 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
667
668 ret = TransSessionMgrInit();
669 EXPECT_EQ(SOFTBUS_OK, ret);
670 ret = CheckAndUpdateTimeBySessionName(sessionName, time);
671 EXPECT_EQ(SOFTBUS_TRANS_SESSION_NAME_NO_EXIST, ret);
672
673 ret = TransSessionServerAddItem(newNode);
674 EXPECT_EQ(SOFTBUS_OK, ret);
675 ret = CheckAndUpdateTimeBySessionName(sessionName, time);
676 EXPECT_NE(SOFTBUS_NO_INIT, ret);
677 ret = CheckAndUpdateTimeBySessionName(sessionName, time);
678 EXPECT_NE(SOFTBUS_NO_INIT, ret);
679
680 ret = TransSessionServerDelItem(sessionName);
681 EXPECT_EQ(SOFTBUS_OK, ret);
682 TransSessionMgrDeinit();
683 }
684 }
685