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 <securec.h>
17
18 #include <gtest/gtest.h>
19 #include "softbus_def.h"
20 #include "softbus_error_code.h"
21 #include "softbus_trans_def.h"
22 #include "softbus_app_info.h"
23 #include "softbus_server_frame.h"
24 #include "softbus_adapter_mem.h"
25 #include "client_trans_session_manager.h"
26 #include "client_trans_socket_manager.h"
27 #include "trans_log.h"
28 #include "softbus_feature_config.h"
29 #include "softbus_conn_interface.h"
30 #include "auth_interface.h"
31 #include "bus_center_manager.h"
32 #include "trans_session_service.h"
33
34 #define TRANS_TEST_SESSION_ID 10
35 #define TRANS_TEST_PID 0
36 #define TRANS_TEST_UID 0
37 #define TRANS_TEST_INVALID_PID (-1)
38 #define TRANS_TEST_INVALID_UID (-1)
39 #define TRANS_TEST_CHANNEL_ID 1000
40 #define TRANS_TEST_INVALID_CHANNEL_ID (-1)
41 #define TRANS_TEST_INVALID_SESSION_ID (-1)
42 #define TRANS_TEST_FILE_ENCRYPT 10
43 #define TRANS_TEST_ALGORITHM 1
44 #define TRANS_TEST_CRC 1
45 #define TRANS_TEST_STATE 1
46 #define TRANS_TEST_MAX_WAIT_TIMEOUT 9000
47 #define TRANS_TEST_DEF_WAIT_TIMEOUT 30000
48
49 #define MAX_SESSION_SERVER_NUM 32
50
51 using namespace testing::ext;
52
53 namespace OHOS {
54
55 const char *g_pkgName = "dms";
56 const char *g_sessionName = "ohos.distributedschedule.dms.test";
57 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
58 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00";
59 const char *g_groupid = "TEST_GROUP_ID";
60 static SessionAttribute g_sessionAttr = {
61 .dataType = TYPE_BYTES,
62 };
63 class TransClientSessionManagerTest : public testing::Test {
64 public:
TransClientSessionManagerTest()65 TransClientSessionManagerTest()
66 {}
~TransClientSessionManagerTest()67 ~TransClientSessionManagerTest()
68 {}
69 static void SetUpTestCase(void);
70 static void TearDownTestCase(void);
SetUp()71 void SetUp() override
72 {}
TearDown()73 void TearDown() override
74 {}
75 };
76
SetUpTestCase(void)77 void TransClientSessionManagerTest::SetUpTestCase(void)
78 {
79 SoftbusConfigInit();
80 ConnServerInit();
81 AuthInit();
82 BusCenterServerInit();
83 TransServerInit();
84 }
85
TearDownTestCase(void)86 void TransClientSessionManagerTest::TearDownTestCase(void)
87 {
88 ConnServerDeinit();
89 AuthDeinit();
90 BusCenterServerDeinit();
91 }
92
OnSessionOpened(int32_t sessionId,int32_t result)93 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
94 {
95 TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
96 return SOFTBUS_OK;
97 }
98
OnSessionClosed(int32_t sessionId)99 static void OnSessionClosed(int32_t sessionId)
100 {
101 TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
102 }
103
OnBytesReceived(int32_t sessionId,const void * data,unsigned int len)104 static void OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)
105 {
106 TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
107 }
108
OnMessageReceived(int32_t sessionId,const void * data,unsigned int len)109 static void OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)
110 {
111 TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
112 }
113
CheckCollabRelation(const CollabInfo * sourceInfo,const CollabInfo * sinkInfo)114 static int32_t CheckCollabRelation(const CollabInfo *sourceInfo, const CollabInfo *sinkInfo)
115 {
116 TRANS_LOGI(TRANS_TEST, "call check collab relation func");
117 return SOFTBUS_OK;
118 }
119
GenerateSession(const SessionParam * param)120 static SessionInfo *GenerateSession(const SessionParam *param)
121 {
122 SessionInfo *session = (SessionInfo*)SoftBusMalloc(sizeof(SessionInfo));
123 EXPECT_TRUE(session != nullptr);
124 memset_s(session, sizeof(SessionInfo), 0, sizeof(SessionInfo));
125
126 int32_t ret = strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName);
127 EXPECT_EQ(ret, EOK);
128
129 ret = strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId);
130 EXPECT_EQ(ret, EOK);
131
132 ret = strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId);
133 EXPECT_EQ(ret, EOK);
134
135 session->sessionId = INVALID_SESSION_ID;
136 session->channelId = INVALID_CHANNEL_ID;
137 session->channelType = CHANNEL_TYPE_BUTT;
138 session->isServer = false;
139 session->enableStatus = ENABLE_STATUS_INIT;
140 session->routeType = ROUTE_TYPE_ALL;
141 session->info.flag = TYPE_BYTES;
142 session->isEncrypt = true;
143 session->algorithm = TRANS_TEST_ALGORITHM;
144 session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
145 session->crc = TRANS_TEST_CRC;
146 session->isAsync = param->isAsync;
147 session->lifecycle.sessionState = SESSION_STATE_INIT;
148 return session;
149 }
150
GenerateCommParam(SessionParam * sessionParam)151 static void GenerateCommParam(SessionParam *sessionParam)
152 {
153 sessionParam->sessionName = g_sessionName;
154 sessionParam->peerSessionName = g_sessionName;
155 sessionParam->peerDeviceId = g_deviceId;
156 sessionParam->groupId = g_groupid;
157 sessionParam->attr = &g_sessionAttr;
158 }
159
160 static ISessionListener g_sessionlistener = {
161 .OnSessionOpened = OnSessionOpened,
162 .OnSessionClosed = OnSessionClosed,
163 .OnBytesReceived = OnBytesReceived,
164 .OnMessageReceived = OnMessageReceived,
165 };
166
167 static IFeatureAbilityRelationChecker g_relationChecker = {
168 .CheckCollabRelation = CheckCollabRelation,
169 };
170
171 /**
172 * @tc.name: TransClientSessionManagerTest01
173 * @tc.desc: Transmission sdk session manager add session with invalid parameters.
174 * @tc.type: FUNC
175 * @tc.require:
176 */
177 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest01, TestSize.Level1)
178 {
179 int32_t ret = TransClientInit();
180 EXPECT_EQ(ret, SOFTBUS_OK);
181 int32_t sessionId = 0;
182 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
183 ret = ClientAddSession(nullptr, &sessionId, &isEnabled);
184 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
185 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
186 EXPECT_TRUE(sessionParam != nullptr);
187 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
188 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
189 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
190 GenerateCommParam(sessionParam);
191 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
192 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
193 SoftBusFree(sessionParam);
194 }
195
196 /**
197 * @tc.name: TransClientSessionManagerTest02
198 * @tc.desc: Transmission sdk session manager add new session.
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest02, TestSize.Level1)
203 {
204 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
205 EXPECT_TRUE(sessionParam != nullptr);
206 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
207 GenerateCommParam(sessionParam);
208 SessionInfo *session = GenerateSession(sessionParam);
209 int32_t ret = ClientAddNewSession(g_sessionName, session);
210 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
211 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
212 EXPECT_EQ(ret, SOFTBUS_OK);
213 ret = ClientAddNewSession(g_sessionName, session);
214 EXPECT_EQ(ret, SOFTBUS_OK);
215 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
216 EXPECT_EQ(ret, SOFTBUS_OK);
217 SoftBusFree(sessionParam);
218 }
219
220 /**
221 * @tc.name: TransClientSessionManagerTest03
222 * @tc.desc: Transmission sdk session manager add new auth session with invalid and valid parameters.
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest03, TestSize.Level1)
227 {
228 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
229 EXPECT_TRUE(sessionParam != nullptr);
230 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
231 GenerateCommParam(sessionParam);
232 int32_t sessionId = 0;
233 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
234 memset_s(sessionName, SESSION_NAME_SIZE_MAX + 2, 'A', SESSION_NAME_SIZE_MAX + 1);
235 int32_t ret = ClientAddAuthSession(g_sessionName, &sessionId);
236 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
237 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
238 EXPECT_EQ(ret, SOFTBUS_OK);
239 ret = ClientAddAuthSession(g_sessionName, &sessionId);
240 EXPECT_EQ(ret, SOFTBUS_OK);
241 EXPECT_GT(sessionId, 0);
242 ret = ClientDeleteSession(sessionId);
243 EXPECT_EQ(ret, SOFTBUS_OK);
244 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
245 EXPECT_EQ(ret, SOFTBUS_OK);
246 SoftBusFree(sessionParam);
247 }
248
249 /**
250 * @tc.name: TransClientSessionManagerTest04
251 * @tc.desc: Transmission sdk session manager delete session with invalid parameters.
252 * @tc.type: FUNC
253 * @tc.require:
254 */
255 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest04, TestSize.Level1)
256 {
257 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
258 EXPECT_EQ(ret, SOFTBUS_OK);
259 ret = ClientDeleteSession(TRANS_TEST_SESSION_ID);
260 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
261 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
262 EXPECT_EQ(ret, SOFTBUS_OK);
263 }
264
265 /**
266 * @tc.name: TransClientSessionManagerTest05
267 * @tc.desc: Transmission sdk session manager add session.
268 * @tc.type: FUNC
269 * @tc.require:
270 */
271 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest05, TestSize.Level1)
272 {
273 int32_t sessionId = 0;
274 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
275 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
276 EXPECT_TRUE(sessionParam != nullptr);
277 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
278 GenerateCommParam(sessionParam);
279 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
280 EXPECT_EQ(ret, SOFTBUS_OK);
281 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
282 EXPECT_EQ(ret, SOFTBUS_OK);
283 EXPECT_GT(sessionId, 0);
284 ret = ClientDeleteSession(sessionId);
285 EXPECT_EQ(ret, SOFTBUS_OK);
286 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
287 EXPECT_EQ(ret, SOFTBUS_OK);
288 SoftBusFree(sessionParam);
289 }
290
291 /**
292 * @tc.name: TransClientSessionManagerTest06
293 * @tc.desc: Transmission sdk session manager add session server out of range.
294 * @tc.type: FUNC
295 * @tc.require:
296 */
297 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest06, TestSize.Level1)
298 {
299 int32_t ret = 0;
300 for (int32_t i = 0; i < MAX_SESSION_SERVER_NUMBER; ++i) {
301 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
302 char pkgName[PKG_NAME_SIZE_MAX] = {0};
303 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
304 EXPECT_GT(ret, 0);
305 ret = sprintf_s(pkgName, PKG_NAME_SIZE_MAX, "%s%d", g_pkgName, i);
306 EXPECT_GT(ret, 0);
307 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, pkgName, sessionNme, &g_sessionlistener);
308 EXPECT_EQ(ret, SOFTBUS_OK);
309 }
310 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
311 EXPECT_EQ(ret, SOFTBUS_INVALID_NUM);
312 for (int32_t i = 0; i < MAX_SESSION_SERVER_NUMBER; ++i) {
313 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
314 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
315 EXPECT_GT(ret, 0);
316 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionNme);
317 EXPECT_EQ(ret, SOFTBUS_OK);
318 }
319 }
320
321 /**
322 * @tc.name: GetMaxIdleTimeBySocket01
323 * @tc.desc: Transmission sdk session manager get opt.
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(TransClientSessionManagerTest, GetMaxIdleTimeBySocket01, TestSize.Level1)
328 {
329 int32_t sessionId = 0;
330 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
331 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
332 EXPECT_TRUE(sessionParam != nullptr);
333 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
334 GenerateCommParam(sessionParam);
335 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
336 EXPECT_EQ(ret, SOFTBUS_OK);
337 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
338 EXPECT_EQ(ret, SOFTBUS_OK);
339 EXPECT_GT(sessionId, 0);
340 uint32_t optValueValid = 10000;
341 ret = SetMaxIdleTimeBySocket(sessionId, optValueValid);
342 ASSERT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
343 uint32_t getValue = 0;
344 ret = GetMaxIdleTimeBySocket(sessionId, &getValue);
345 ASSERT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
346 ret = ClientDeleteSession(sessionId);
347 EXPECT_EQ(ret, SOFTBUS_OK);
348 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
349 EXPECT_EQ(ret, SOFTBUS_OK);
350 SoftBusFree(sessionParam);
351 }
352
353 /**
354 * @tc.name: TransClientAddSessionOutOfMaxTest01
355 * @tc.desc: Transmission sdk session manager add session out of maxmum.
356 * @tc.type: FUNC
357 * @tc.require:
358 */
359 HWTEST_F(TransClientSessionManagerTest, TransClientAddSessionOutOfMaxTest01, TestSize.Level1)
360 {
361 int32_t sessionId = 0;
362 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
363 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
364 ASSERT_TRUE(sessionParam != nullptr);
365 GenerateCommParam(sessionParam);
366 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
367 ASSERT_EQ(ret, SOFTBUS_OK);
368
369 for (int32_t i = 0; i < MAX_SESSION_ID; ++i) {
370 char sessionName[SESSION_NAME_SIZE_MAX] = {0};
371 ret = sprintf_s(sessionName, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
372 ASSERT_GT(ret, 0);
373 sessionParam->peerSessionName = (const char*)sessionName;
374 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
375 EXPECT_EQ(ret, SOFTBUS_OK);
376 }
377
378 sessionParam->peerSessionName = g_sessionName;
379 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
380 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_CNT_EXCEEDS_LIMIT);
381 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
382 EXPECT_EQ(ret, SOFTBUS_OK);
383 }
384
385 /**
386 * @tc.name: TransClientSessionManagerTest07
387 * @tc.desc: Transmission sdk session manager add session with existed session.
388 * @tc.type: FUNC
389 * @tc.require:
390 */
391 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest07, TestSize.Level1)
392 {
393 int32_t sessionId = 0;
394 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
395 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
396 EXPECT_TRUE(sessionParam != nullptr);
397 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
398 GenerateCommParam(sessionParam);
399 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
400 EXPECT_EQ(ret, SOFTBUS_OK);
401 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
402 EXPECT_EQ(ret, SOFTBUS_OK);
403 EXPECT_GT(sessionId, 0);
404 int32_t newSessionId = 0;
405 ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
406 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_REPEATED);
407 EXPECT_EQ(sessionId, newSessionId);
408 ret = ClientDeleteSession(sessionId);
409 EXPECT_EQ(ret, SOFTBUS_OK);
410 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
411 EXPECT_EQ(ret, SOFTBUS_OK);
412 SoftBusFree(sessionParam);
413 }
414
415 /**
416 * @tc.name: TransClientSessionManagerTest08
417 * @tc.desc: Transmission sdk session manager add session with wrong session.
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest08, TestSize.Level1)
422 {
423 int32_t sessionId = 0;
424 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
425 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
426 EXPECT_TRUE(sessionParam != nullptr);
427 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
428 GenerateCommParam(sessionParam);
429 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF"};
430 sessionParam->peerDeviceId = deviceId;
431 int32_t ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
432 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_CREATE_FAILED);
433 SoftBusFree(sessionParam);
434 }
435
436 /**
437 * @tc.name: TransClientSessionManagerTest09
438 * @tc.desc: Transmission sdk session manager delete session.
439 * @tc.type: FUNC
440 * @tc.require:
441 */
442 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest09, TestSize.Level1)
443 {
444 int32_t sessionId = 0;
445 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
446 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
447 EXPECT_TRUE(sessionParam != nullptr);
448 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
449 GenerateCommParam(sessionParam);
450 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
451 EXPECT_EQ(ret, SOFTBUS_OK);
452 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
453 EXPECT_EQ(ret, SOFTBUS_OK);
454 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
455 char groupId[] = {"TEST_GROUP_ID1"};
456 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
457 SessionAttribute sessionAttr = {
458 .dataType = TYPE_FILE,
459 };
460 SessionParam *newSessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
461 EXPECT_TRUE(newSessionParam != nullptr);
462 memset_s(newSessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
463 newSessionParam->attr = &sessionAttr;
464 newSessionParam->groupId = groupId;
465 newSessionParam->peerDeviceId = deviceId;
466 newSessionParam->peerSessionName = sessionName;
467 newSessionParam->sessionName = g_sessionName;
468 int32_t newSessionId = 0;
469 ret = ClientAddSession(newSessionParam, &newSessionId, &isEnabled);
470 EXPECT_EQ(ret, SOFTBUS_OK);
471 ret = ClientDeleteSession(newSessionId);
472 EXPECT_EQ(ret, SOFTBUS_OK);
473 ret = ClientDeleteSession(sessionId);
474 EXPECT_EQ(ret, SOFTBUS_OK);
475 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
476 EXPECT_EQ(ret, SOFTBUS_OK);
477 SoftBusFree(sessionParam);
478 SoftBusFree(newSessionParam);
479 }
480
481 /**
482 * @tc.name: TransClientSessionManagerTest10
483 * @tc.desc: Transmission sdk session manager get session data by session id with invalid and valid parameters.
484 * @tc.type: FUNC
485 * @tc.require:
486 */
487 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest10, TestSize.Level1)
488 {
489 char data[SESSION_NAME_SIZE_MAX] = {0};
490 int32_t ret = ClientGetSessionDataById(TRANS_TEST_INVALID_SESSION_ID, data,
491 SESSION_NAME_SIZE_MAX, KEY_SESSION_NAME);
492 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
493 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
494 EXPECT_EQ(ret, SOFTBUS_OK);
495 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
496 EXPECT_TRUE(sessionParam != nullptr);
497 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
498 GenerateCommParam(sessionParam);
499 int32_t sessionId = 0;
500 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
501 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
502 EXPECT_EQ(ret, SOFTBUS_OK);
503 memset_s(data, sizeof(data), 0, sizeof(data));
504 ret = ClientGetSessionDataById(sessionId, data, SESSION_NAME_SIZE_MAX, KEY_PEER_SESSION_NAME);
505 EXPECT_EQ(ret, SOFTBUS_OK);
506 memset_s(data, sizeof(data), 0, sizeof(data));
507 ret = ClientGetSessionDataById(sessionId, data, DEVICE_ID_SIZE_MAX, KEY_PEER_DEVICE_ID);
508 EXPECT_EQ(ret, SOFTBUS_OK);
509 memset_s(data, sizeof(data), 0, sizeof(data));
510 ret = ClientGetSessionDataById(sessionId, data, PKG_NAME_SIZE_MAX, KEY_PKG_NAME);
511 EXPECT_EQ(ret, SOFTBUS_OK);
512 ret = ClientGetSessionDataById(sessionId, data, PKG_NAME_SIZE_MAX, KEY_PEER_PID);
513 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
514 ret = ClientDeleteSession(sessionId);
515 EXPECT_EQ(ret, SOFTBUS_OK);
516 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
517 EXPECT_EQ(ret, SOFTBUS_OK);
518 SoftBusFree(sessionParam);
519 }
520
521 /**
522 * @tc.name: TransClientSessionManagerTest11
523 * @tc.desc: Transmission sdk session manager get session Integer data by session id with invalid parameters.
524 * @tc.type: FUNC
525 * @tc.require:
526 */
527 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest11, TestSize.Level1)
528 {
529 int32_t data = 0;
530 int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
531 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
532 }
533
534 /**
535 * @tc.name: TransClientSessionManagerTest12
536 * @tc.desc: Transmission sdk session manager get session Integer data by session id.
537 * @tc.type: FUNC
538 * @tc.require:
539 */
540 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest12, TestSize.Level1)
541 {
542 int32_t data = 0;
543 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
544 EXPECT_EQ(ret, SOFTBUS_OK);
545 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
546 EXPECT_TRUE(sessionParam != nullptr);
547 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
548 GenerateCommParam(sessionParam);
549 int32_t sessionId = 0;
550 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
551 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
552 EXPECT_EQ(ret, SOFTBUS_OK);
553 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PEER_PID);
554 EXPECT_EQ(ret, SOFTBUS_OK);
555 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_IS_SERVER);
556 EXPECT_EQ(ret, SOFTBUS_OK);
557 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PEER_UID);
558 EXPECT_EQ(ret, SOFTBUS_OK);
559 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PKG_NAME);
560 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
561 ret = ClientDeleteSession(sessionId);
562 EXPECT_EQ(ret, SOFTBUS_OK);
563 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
564 EXPECT_EQ(ret, SOFTBUS_OK);
565 SoftBusFree(sessionParam);
566 }
567
568 /**
569 * @tc.name: TransClientSessionManagerTest13
570 * @tc.desc: Transmission sdk session manager get channel id by session id with invalid parameters.
571 * @tc.type: FUNC
572 * @tc.require:
573 */
574 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest13, TestSize.Level1)
575 {
576 int32_t channelId = 0;
577 int32_t type = 0;
578 SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
579 int32_t ret = ClientGetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, &channelId, &type, &enableStatus);
580 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
581 }
582
583 /**
584 * @tc.name: TransClientSessionManagerTest14
585 * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters.
586 * @tc.type: FUNC
587 * @tc.require:
588 */
589 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest14, TestSize.Level1)
590 {
591 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
592 EXPECT_TRUE(transInfo != nullptr);
593 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
594 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
595 transInfo->channelType = CHANNEL_TYPE_UDP;
596 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
597 EXPECT_EQ(ret, SOFTBUS_OK);
598 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
599 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
600 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
601 EXPECT_EQ(ret, SOFTBUS_OK);
602 SoftBusFree(transInfo);
603 }
604
605 /**
606 * @tc.name: TransClientSessionManagerTest15
607 * @tc.desc: Transmission sdk session manager set channel id by session id.
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest15, TestSize.Level1)
612 {
613 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
614 EXPECT_TRUE(transInfo != nullptr);
615 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
616 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
617 transInfo->channelType = CHANNEL_TYPE_UDP;
618 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
619 EXPECT_EQ(ret, SOFTBUS_OK);
620 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
621 EXPECT_TRUE(sessionParam != nullptr);
622 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
623 GenerateCommParam(sessionParam);
624 int32_t sessionId = 0;
625 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
626 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
627 EXPECT_EQ(ret, SOFTBUS_OK);
628 ret = ClientSetChannelBySessionId(sessionId, transInfo);
629 EXPECT_EQ(ret, SOFTBUS_OK);
630 ret = ClientDeleteSession(sessionId);
631 EXPECT_EQ(ret, SOFTBUS_OK);
632 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
633 EXPECT_EQ(ret, SOFTBUS_OK);
634 SoftBusFree(transInfo);
635 SoftBusFree(sessionParam);
636 }
637
638 /**
639 * @tc.name: TransClientSessionManagerTest16
640 * @tc.desc: Transmission sdk session manager get channel business type by session id with invalid parameters.
641 * @tc.type: FUNC
642 * @tc.require:
643 */
644 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest16, TestSize.Level1)
645 {
646 int32_t businessType = 0;
647 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
648 EXPECT_EQ(ret, SOFTBUS_OK);
649 ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
650 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
651 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
652 EXPECT_EQ(ret, SOFTBUS_OK);
653 }
654
655 /**
656 * @tc.name: TransClientSessionManagerTest17
657 * @tc.desc: Transmission sdk session manager get encrypt by channel id.
658 * @tc.type: FUNC
659 * @tc.require:
660 */
661 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest17, TestSize.Level1)
662 {
663 int32_t data = 0;
664 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
665 EXPECT_EQ(ret, SOFTBUS_OK);
666 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
667 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
668 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
669 EXPECT_TRUE(sessionParam != nullptr);
670 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
671 GenerateCommParam(sessionParam);
672 SessionInfo *session = GenerateSession(sessionParam);
673 session->channelId = TRANS_TEST_CHANNEL_ID;
674 session->channelType = CHANNEL_TYPE_UDP;
675 ret = ClientAddNewSession(g_sessionName, session);
676 EXPECT_EQ(ret, SOFTBUS_OK);
677 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
678 EXPECT_EQ(ret, SOFTBUS_OK);
679 EXPECT_TRUE(data);
680 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &data);
681 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
682 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
683 EXPECT_EQ(ret, SOFTBUS_OK);
684 SoftBusFree(sessionParam);
685 }
686
687 /**
688 * @tc.name: TransClientSessionManagerTest18
689 * @tc.desc: Transmission sdk session manager get session id by channel id.
690 * @tc.type: FUNC
691 * @tc.require:
692 */
693 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest18, TestSize.Level1)
694 {
695 int32_t sessionId = 0;
696 bool isClosing = false;
697 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
698 EXPECT_EQ(ret, SOFTBUS_OK);
699 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
700 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
701 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
702 EXPECT_TRUE(sessionParam != nullptr);
703 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
704 GenerateCommParam(sessionParam);
705 SessionInfo *session = GenerateSession(sessionParam);
706 session->channelId = TRANS_TEST_CHANNEL_ID;
707 session->channelType = CHANNEL_TYPE_UDP;
708 ret = ClientAddNewSession(g_sessionName, session);
709 EXPECT_EQ(ret, SOFTBUS_OK);
710 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
711 EXPECT_EQ(ret, SOFTBUS_OK);
712 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
713 EXPECT_EQ(ret, SOFTBUS_OK);
714 SoftBusFree(sessionParam);
715 }
716
717 /**
718 * @tc.name: TransClientSessionManagerTest19
719 * @tc.desc: Transmission sdk session manager get enable session id by channel id.
720 * @tc.type: FUNC
721 * @tc.require:
722 */
723 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest19, TestSize.Level1)
724 {
725 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
726 EXPECT_TRUE(channel != nullptr);
727 memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
728 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
729 EXPECT_EQ(ret, SOFTBUS_OK);
730 int32_t sessionId = 0;
731 ret = ClientEnableSessionByChannelId(channel, &sessionId);
732 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
733 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
734 EXPECT_TRUE(sessionParam != nullptr);
735 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
736 GenerateCommParam(sessionParam);
737 channel->channelId = 0;
738 channel->channelType = CHANNEL_TYPE_AUTH;
739 ret = ClientAddAuthSession(g_sessionName, &sessionId);
740 EXPECT_EQ(ret, SOFTBUS_OK);
741 int32_t newSessionId = 0;
742 ret = ClientEnableSessionByChannelId(channel, &newSessionId);
743 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
744 char deviceId[DEVICE_ID_SIZE_MAX] = {0};
745 ret = strcpy_s(deviceId, DEVICE_ID_SIZE_MAX, g_deviceId);
746 EXPECT_EQ(ret, EOK);
747 channel->peerDeviceId = deviceId;
748 ret = ClientEnableSessionByChannelId(channel, &newSessionId);
749 EXPECT_EQ(ret, SOFTBUS_OK);
750 EXPECT_EQ(sessionId, newSessionId);
751 ret = ClientDeleteSession(sessionId);
752 EXPECT_EQ(ret, SOFTBUS_OK);
753 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
754 EXPECT_EQ(ret, SOFTBUS_OK);
755 SoftBusFree(channel);
756 SoftBusFree(sessionParam);
757 }
758
759 /**
760 * @tc.name: TransClientSessionManagerTest20
761 * @tc.desc: Transmission sdk session manager get enable session callback by session id.
762 * @tc.type: FUNC
763 * @tc.require:
764 */
765 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest20, TestSize.Level1)
766 {
767 ISessionListener sessionlistener = {0};
768 int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
769 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
770 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
771 EXPECT_TRUE(sessionParam != nullptr);
772 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
773 GenerateCommParam(sessionParam);
774 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
775 EXPECT_EQ(ret, SOFTBUS_OK);
776 int32_t sessionId = 0;
777 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
778 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
779 EXPECT_EQ(ret, SOFTBUS_OK);
780 ret = ClientGetSessionCallbackById(sessionId, &sessionlistener);
781 EXPECT_EQ(ret, SOFTBUS_OK);
782 EXPECT_EQ(sessionlistener.OnSessionOpened, OnSessionOpened);
783 EXPECT_EQ(sessionlistener.OnSessionClosed, OnSessionClosed);
784 EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
785 EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
786 ret = ClientDeleteSession(sessionId);
787 EXPECT_EQ(ret, SOFTBUS_OK);
788 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
789 EXPECT_EQ(ret, SOFTBUS_OK);
790 SoftBusFree(sessionParam);
791 }
792
793 /**
794 * @tc.name: TransClientSessionManagerTest21
795 * @tc.desc: Transmission sdk session manager get enable session callback by session name.
796 * @tc.type: FUNC
797 * @tc.require:
798 */
799 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest21, TestSize.Level1)
800 {
801 ISessionListener sessionlistener = {0};
802 int32_t ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
803 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
804 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
805 EXPECT_EQ(ret, SOFTBUS_OK);
806 char pkgName[] = {"dms1"};
807 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
808 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, pkgName, sessionName, &g_sessionlistener);
809 EXPECT_EQ(ret, SOFTBUS_OK);
810 ret = ClientGetSessionCallbackByName(sessionName, &sessionlistener);
811 EXPECT_EQ(ret, SOFTBUS_OK);
812 EXPECT_EQ(sessionlistener.OnSessionOpened, OnSessionOpened);
813 EXPECT_EQ(sessionlistener.OnSessionClosed, OnSessionClosed);
814 EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
815 EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
816 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
817 EXPECT_EQ(ret, SOFTBUS_OK);
818 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
819 EXPECT_EQ(ret, SOFTBUS_OK);
820 }
821
822 /**
823 * @tc.name: TransClientSessionManagerTest22
824 * @tc.desc: Transmission sdk session manager get session side by session id.
825 * @tc.type: FUNC
826 * @tc.require:
827 */
828 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest22, TestSize.Level1)
829 {
830 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
831 EXPECT_NE(ret, SOFTBUS_OK);
832 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
833 EXPECT_EQ(ret, SOFTBUS_OK);
834 int32_t sessionId = 0;
835 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
836 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
837 EXPECT_TRUE(sessionParam != nullptr);
838 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
839 GenerateCommParam(sessionParam);
840 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
841 EXPECT_EQ(ret, SOFTBUS_OK);
842 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
843 char groupId[] = {"TEST_GROUP_ID1"};
844 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
845 sessionParam->groupId = groupId;
846 sessionParam->peerSessionName = sessionName;
847 sessionParam->peerDeviceId = deviceId;
848 int32_t newSessionId = 0;
849 ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
850 EXPECT_EQ(ret, SOFTBUS_OK);
851 ret = ClientGetSessionSide(sessionId);
852 EXPECT_EQ(ret, IS_CLIENT);
853 ret = ClientGetSessionSide(newSessionId);
854 EXPECT_EQ(ret, IS_CLIENT);
855 ret = ClientDeleteSession(sessionId);
856 EXPECT_EQ(ret, SOFTBUS_OK);
857 ret = ClientDeleteSession(newSessionId);
858 EXPECT_EQ(ret, SOFTBUS_OK);
859 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
860 EXPECT_EQ(ret, SOFTBUS_OK);
861 SoftBusFree(sessionParam);
862 }
863
864 /**
865 * @tc.name: TransClientSessionManagerTest23
866 * @tc.desc: Transmission sdk session manager grant permission and remove permission with invalid parameters.
867 * @tc.type: FUNC
868 * @tc.require:
869 */
870 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest23, TestSize.Level1)
871 {
872 int32_t ret = ClientGrantPermission(TRANS_TEST_INVALID_UID, TRANS_TEST_PID, g_sessionName);
873 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
874 ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_INVALID_PID, g_sessionName);
875 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
876 ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_PID, nullptr);
877 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
878 ret = ClientRemovePermission(nullptr);
879 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
880 }
881
882 /**
883 * @tc.name: TransClientSessionManagerTest24
884 * @tc.desc: Transmission sdk session manager get file config by session.
885 * @tc.type: FUNC
886 * @tc.require:
887 */
888 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest24, TestSize.Level1)
889 {
890 int32_t fileEncrypt = 0;
891 int32_t algorithm = 0;
892 int32_t crc = 0;
893 bool isClosing = false;
894 int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
895 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
896 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
897 EXPECT_EQ(ret, SOFTBUS_OK);
898 int32_t sessionId = 0;
899 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
900 EXPECT_TRUE(sessionParam != nullptr);
901 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
902 GenerateCommParam(sessionParam);
903 SessionInfo *session = GenerateSession(sessionParam);
904 session->channelId = TRANS_TEST_CHANNEL_ID;
905 session->channelType = CHANNEL_TYPE_UDP;
906 ret = ClientAddNewSession(g_sessionName, session);
907 EXPECT_EQ(ret, SOFTBUS_OK);
908 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
909 EXPECT_EQ(ret, SOFTBUS_OK);
910 ret = ClientGetFileConfigInfoById(sessionId, &fileEncrypt, &algorithm, &crc);
911 EXPECT_EQ(ret, SOFTBUS_OK);
912 EXPECT_EQ(TRANS_TEST_FILE_ENCRYPT, fileEncrypt);
913 EXPECT_EQ(TRANS_TEST_ALGORITHM, algorithm);
914 EXPECT_EQ(TRANS_TEST_CRC, crc);
915 ret = ClientDeleteSession(sessionId);
916 EXPECT_EQ(ret, SOFTBUS_OK);
917 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
918 EXPECT_EQ(ret, SOFTBUS_OK);
919 SoftBusFree(sessionParam);
920 }
921
922 /**
923 * @tc.name: TransClientSessionManagerTest25
924 * @tc.desc: Transmission sdk session manager recreate session server to server.
925 * @tc.type: FUNC
926 * @tc.require:
927 */
928 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest25, TestSize.Level1)
929 {
930 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
931 EXPECT_EQ(ret, SOFTBUS_OK);
932
933 ret = ReCreateSessionServerToServer(nullptr);
934 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
935
936 ListNode sessionServerList;
937 ListInit(&sessionServerList);
938 ret = ReCreateSessionServerToServer(&sessionServerList);
939 EXPECT_EQ(ret, SOFTBUS_OK);
940
941 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
942 EXPECT_EQ(ret, SOFTBUS_OK);
943
944 SessionServerInfo *infoNode = nullptr;
945 SessionServerInfo *infoNodeNext = nullptr;
946 LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
947 ListDelete(&infoNode->node);
948 SoftBusFree(infoNode);
949 }
950 }
951
952 /**
953 * @tc.name: TransClientSessionManagerTest26
954 * @tc.desc: Transmission sdk session manager clear list on link down.
955 * @tc.type: FUNC
956 * @tc.require:
957 */
958 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest26, TestSize.Level1)
959 {
960 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
961 EXPECT_EQ(ret, SOFTBUS_OK);
962 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
963 EXPECT_TRUE(sessionParam != nullptr);
964 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
965 GenerateCommParam(sessionParam);
966 SessionInfo *session = GenerateSession(sessionParam);
967 session->channelId = TRANS_TEST_CHANNEL_ID;
968 session->channelType = CHANNEL_TYPE_UDP;
969 ret = ClientAddNewSession(g_sessionName, session);
970 EXPECT_EQ(ret, SOFTBUS_OK);
971 ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
972 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
973 EXPECT_EQ(ret, SOFTBUS_OK);
974 }
975
976 /**
977 * @tc.name: TransClientSessionManagerTest27
978 * @tc.desc: Transmission sdk session manager clear all session when server death.
979 * @tc.type: FUNC
980 * @tc.require:
981 */
982 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest27, TestSize.Level1)
983 {
984 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
985 EXPECT_EQ(ret, SOFTBUS_OK);
986
987 ListNode sessionServerList;
988 ListInit(&sessionServerList);
989 ClientCleanAllSessionWhenServerDeath(&sessionServerList);
990 SessionServerInfo *infoNode = nullptr;
991 SessionServerInfo *infoNodeNext = nullptr;
992 LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
993 ListDelete(&infoNode->node);
994 SoftBusFree(infoNode);
995 }
996
997 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
998 EXPECT_TRUE(sessionParam != nullptr);
999 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1000 GenerateCommParam(sessionParam);
1001 SessionInfo *session = GenerateSession(sessionParam);
1002 session->channelId = TRANS_TEST_CHANNEL_ID;
1003 session->channelType = CHANNEL_TYPE_UDP;
1004 ret = ClientAddNewSession(g_sessionName, session);
1005 EXPECT_EQ(ret, SOFTBUS_OK);
1006
1007 ClientCleanAllSessionWhenServerDeath(&sessionServerList);
1008 infoNode = nullptr;
1009 infoNodeNext = nullptr;
1010 LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
1011 ListDelete(&infoNode->node);
1012 SoftBusFree(infoNode);
1013 }
1014
1015 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1016 EXPECT_EQ(ret, SOFTBUS_OK);
1017 }
1018
1019 /**
1020 * @tc.name: TransClientSessionManagerTest28
1021 * @tc.desc: Transmission sdk session manager permission state change.
1022 * @tc.type: FUNC
1023 * @tc.require:
1024 */
1025 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest28, TestSize.Level1)
1026 {
1027 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1028 EXPECT_EQ(ret, SOFTBUS_OK);
1029 PermissionStateChange(g_pkgName, TRANS_TEST_STATE);
1030 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1031 EXPECT_EQ(ret, SOFTBUS_OK);
1032 }
1033
1034 /**
1035 * @tc.name: TransClientSessionDestroyTest01
1036 * @tc.desc: Transmission sdk session manager destroy session by network id.
1037 * @tc.type: FUNC
1038 * @tc.require:
1039 */
1040 HWTEST_F(TransClientSessionManagerTest, TransClientSessionDestroyTest01, TestSize.Level1)
1041 {
1042 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1043 ASSERT_EQ(ret, SOFTBUS_OK);
1044 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1045 ASSERT_TRUE(sessionParam != nullptr);
1046 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1047 GenerateCommParam(sessionParam);
1048 SessionInfo *session = GenerateSession(sessionParam);
1049 ASSERT_TRUE(session != nullptr);
1050 session->channelId = TRANS_TEST_CHANNEL_ID;
1051 session->channelType = CHANNEL_TYPE_UDP;
1052 session->routeType = WIFI_STA;
1053 ret = ClientAddNewSession(g_sessionName, session);
1054 ASSERT_EQ(ret, SOFTBUS_OK);
1055 sessionParam->peerDeviceId = g_networkId;
1056 SessionInfo *newSession = GenerateSession(sessionParam);
1057 ASSERT_TRUE(newSession != nullptr);
1058 newSession->channelId = TRANS_TEST_CHANNEL_ID + 1;
1059 newSession->channelType = CHANNEL_TYPE_UDP;
1060 newSession->routeType = WIFI_P2P;
1061 ret = ClientAddNewSession(g_sessionName, newSession);
1062 ASSERT_EQ(ret, SOFTBUS_OK);
1063 ClientTransOnLinkDown(g_networkId, WIFI_STA);
1064 int32_t sessionId = 0;
1065 bool isClosing = false;
1066 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1067 EXPECT_EQ(ret, SOFTBUS_OK);
1068 EXPECT_GT(sessionId, 0);
1069 ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
1070 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1071 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1072 ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
1073 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1074 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1075 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1076 EXPECT_EQ(ret, SOFTBUS_OK);
1077 SoftBusFree(sessionParam);
1078 }
1079
1080 /**
1081 * @tc.name: TransClientSessionIsAsyncTest01
1082 * @tc.desc: Session IsAsync param tests.
1083 * @tc.type: FUNC
1084 * @tc.require:
1085 */
1086 HWTEST_F(TransClientSessionManagerTest, TransClientSessionIsAsyncTest01, TestSize.Level1)
1087 {
1088 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1089 ASSERT_EQ(ret, SOFTBUS_OK);
1090 SessionParam *sessionParam = (SessionParam *)SoftBusMalloc(sizeof(SessionParam));
1091 ASSERT_TRUE(sessionParam != nullptr);
1092 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1093 GenerateCommParam(sessionParam);
1094 SessionInfo *session = GenerateSession(sessionParam);
1095 ASSERT_TRUE(session != nullptr);
1096 ret = ClientAddNewSession(g_sessionName, session);
1097 session->sessionId = 1;
1098 ASSERT_EQ(ret, SOFTBUS_OK);
1099 sessionParam->isAsync = true;
1100 SessionInfo *newSession = GenerateSession(sessionParam);
1101 ret = ClientAddNewSession(g_sessionName, newSession);
1102 ASSERT_EQ(ret, SOFTBUS_OK);
1103 newSession->sessionId = 2;
1104 bool isAsync = false;
1105 ClientGetSessionIsAsyncBySessionId(2, &isAsync);
1106 ASSERT_EQ(isAsync, true);
1107 ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1108 ASSERT_EQ(isAsync, false);
1109 SetSessionIsAsyncById(1, true);
1110 ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1111 ASSERT_EQ(isAsync, true);
1112 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1113 EXPECT_EQ(ret, SOFTBUS_OK);
1114 SoftBusFree(sessionParam);
1115 }
1116
1117 /**
1118 * @tc.name: ClientTransSetChannelInfoTest01
1119 * @tc.desc: Session IsAsync param tests.
1120 * @tc.type: FUNC
1121 * @tc.require:
1122 */
1123 HWTEST_F(TransClientSessionManagerTest, ClientTransSetChannelInfoTest01, TestSize.Level1)
1124 {
1125 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1126 ASSERT_EQ(ret, SOFTBUS_OK);
1127 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1128 ASSERT_TRUE(sessionParam != nullptr);
1129 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1130 GenerateCommParam(sessionParam);
1131 SessionInfo *session = GenerateSession(sessionParam);
1132 ASSERT_TRUE(session != nullptr);
1133 session->channelId = TRANS_TEST_CHANNEL_ID;
1134 session->channelType = CHANNEL_TYPE_PROXY;
1135 session->routeType = WIFI_STA;
1136 ret = ClientAddNewSession(g_sessionName, session);
1137 session->sessionId = 1;
1138 ASSERT_EQ(ret, SOFTBUS_OK);
1139 ret = ClientTransSetChannelInfo(g_sessionName, 1, 11, CHANNEL_TYPE_TCP_DIRECT);
1140 ASSERT_EQ(ret, SOFTBUS_OK);
1141 int32_t channelId = INVALID_CHANNEL_ID;
1142 int32_t ChannelType = CHANNEL_TYPE_BUTT;
1143 ClientGetChannelBySessionId(1, &channelId, &ChannelType, nullptr);
1144 ASSERT_EQ(channelId, 11);
1145 ASSERT_EQ(ChannelType, CHANNEL_TYPE_TCP_DIRECT);
1146 char sessionName[SESSION_NAME_SIZE_MAX];
1147 SocketLifecycleData lifecycle;
1148 ret = GetSocketLifecycleAndSessionNameBySessionId(1, sessionName, &lifecycle);
1149 ASSERT_EQ(ret, SOFTBUS_OK);
1150 ASSERT_EQ(lifecycle.sessionState, SESSION_STATE_OPENED);
1151 ret = SetSessionStateBySessionId(1, SESSION_STATE_CANCELLING, 0);
1152 ASSERT_EQ(ret, SOFTBUS_OK);
1153 ret = GetSocketLifecycleAndSessionNameBySessionId(1, sessionName, &lifecycle);
1154 ASSERT_EQ(ret, SOFTBUS_OK);
1155 ASSERT_EQ(lifecycle.sessionState, SESSION_STATE_CANCELLING);
1156 int32_t osType;
1157 ret = ClientGetChannelOsTypeBySessionId(1, &osType);
1158 EXPECT_EQ(SOFTBUS_OK, ret);
1159 (void)ClientTransOnPrivilegeClose(g_networkId);
1160 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1161 EXPECT_EQ(ret, SOFTBUS_OK);
1162 SoftBusFree(sessionParam);
1163 }
1164
1165 /**
1166 * @tc.name: TransClientSessionManagerTest29
1167 * @tc.desc: Transmission sdk session manager add and delete server with invalid parameters no initialize.
1168 * @tc.type: FUNC
1169 * @tc.require:
1170 */
1171 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest29, TestSize.Level1)
1172 {
1173 TransClientDeinit();
1174 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, nullptr, g_sessionName, &g_sessionlistener);
1175 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1176 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1177 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1178 ret = ClientDeleteSessionServer(SEC_TYPE_UNKNOWN, g_sessionName);
1179 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1180 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1181 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1182 ret = ClientDeleteSession(TRANS_TEST_INVALID_SESSION_ID);
1183 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1184 ret = ClientDeleteSession(TRANS_TEST_SESSION_ID);
1185 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1186 }
1187
1188
1189 /**
1190 * @tc.name: TransClientSessionManagerTest30
1191 * @tc.desc: Transmission sdk session manager add new auth session with invalid parameters no initialize.
1192 * @tc.type: FUNC
1193 * @tc.require:
1194 */
1195 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest30, TestSize.Level1)
1196 {
1197 int32_t sessionId = 0;
1198 int32_t ret = ClientAddAuthSession(nullptr, &sessionId);
1199 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1200 ret = ClientAddAuthSession(g_sessionName, &sessionId);
1201 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1202 }
1203
1204 /**
1205 * @tc.name: TransClientSessionManagerTest31
1206 * @tc.desc: Transmission sdk session manager add new session no initialize.
1207 * @tc.type: FUNC
1208 * @tc.require:
1209 */
1210 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest31, TestSize.Level1)
1211 {
1212 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1213 EXPECT_TRUE(sessionParam != nullptr);
1214 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1215 GenerateCommParam(sessionParam);
1216 SessionInfo *session = GenerateSession(sessionParam);
1217 int32_t ret = ClientAddNewSession(g_sessionName, nullptr);
1218 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1219 ret = ClientAddNewSession(g_sessionName, session);
1220 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1221 SoftBusFree(sessionParam);
1222 }
1223
1224 /**
1225 * @tc.name: TransClientSessionManagerTest32
1226 * @tc.desc: Transmission sdk session manager get session Integer data by session id no initialize.
1227 * @tc.type: FUNC
1228 * @tc.require:
1229 */
1230 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest32, TestSize.Level1)
1231 {
1232 int32_t data = 0;
1233 int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_INVALID_SESSION_ID, &data, KEY_PEER_PID);
1234 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1235 ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, nullptr, KEY_PEER_PID);
1236 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1237 ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
1238 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1239 }
1240
1241 /**
1242 * @tc.name: TransClientSessionManagerTest33
1243 * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters no initialize.
1244 * @tc.type: FUNC
1245 * @tc.require:
1246 */
1247 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest33, TestSize.Level1)
1248 {
1249 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
1250 EXPECT_TRUE(transInfo != nullptr);
1251 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
1252 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1253 transInfo->channelType = CHANNEL_TYPE_UDP;
1254 int32_t ret = ClientSetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, transInfo);
1255 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1256 transInfo->channelId = TRANS_TEST_INVALID_CHANNEL_ID;
1257 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1258 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1259 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1260 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1261 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1262 SoftBusFree(transInfo);
1263 }
1264
1265 /**
1266 * @tc.name: TransClientSessionManagerTest34
1267 * @tc.desc: Transmission sdk session manager get channel business type by session id no initialize.
1268 * @tc.type: FUNC
1269 * @tc.require:
1270 */
1271 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest34, TestSize.Level1)
1272 {
1273 int32_t businessType = 0;
1274 int32_t ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_INVALID_SESSION_ID, &businessType);
1275 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1276 ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
1277 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1278 }
1279
1280 /**
1281 * @tc.name: TransClientSessionManagerTest35
1282 * @tc.desc: Transmission sdk session manager get encrypt by channel id with invalid parameters.
1283 * @tc.type: FUNC
1284 * @tc.require:
1285 */
1286 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest35, TestSize.Level1)
1287 {
1288 int32_t data = 0;
1289 int32_t ret = GetEncryptByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1290 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1291 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, nullptr);
1292 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1293 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1294 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1295 }
1296
1297 /**
1298 * @tc.name: TransClientSessionManagerTest36
1299 * @tc.desc: Transmission sdk session manager get session id by channel id with invalid parameters.
1300 * @tc.type: FUNC
1301 * @tc.require:
1302 */
1303 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest36, TestSize.Level1)
1304 {
1305 int32_t sessionId = 0;
1306 bool isClosing = false;
1307 int32_t ret = ClientGetSessionIdByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1308 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1309 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, nullptr, isClosing);
1310 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1311 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1312 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1313 char data[SESSION_NAME_SIZE_MAX] = {0};
1314 ret = ClientGetSessionDataById(TRANS_TEST_SESSION_ID, data, SESSION_NAME_SIZE_MAX, KEY_PEER_SESSION_NAME);
1315 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1316 }
1317
1318 /**
1319 * @tc.name: TransClientSessionManagerTest37
1320 * @tc.desc: Transmission sdk session manager get enable session id by channel id with invalid parameters.
1321 * @tc.type: FUNC
1322 * @tc.require:
1323 */
1324 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest37, TestSize.Level1)
1325 {
1326 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
1327 EXPECT_TRUE(channel != nullptr);
1328 memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
1329 int32_t sessionId = 0;
1330 int32_t ret = ClientEnableSessionByChannelId(nullptr, &sessionId);
1331 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1332 ret = ClientEnableSessionByChannelId(channel, nullptr);
1333 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1334 ret = ClientEnableSessionByChannelId(channel, &sessionId);
1335 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1336 SoftBusFree(channel);
1337 }
1338
1339 /**
1340 * @tc.name: TransClientSessionManagerTest38
1341 * @tc.desc: Transmission sdk session manager get enable session callback by session id with invalid parameters.
1342 * @tc.type: FUNC
1343 * @tc.require:
1344 */
1345 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest38, TestSize.Level1)
1346 {
1347 ISessionListener sessionlistener = {0};
1348 int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_INVALID_SESSION_ID, &sessionlistener);
1349 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1350 ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, nullptr);
1351 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1352 ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
1353 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1354 }
1355
1356 /**
1357 * @tc.name: TransClientSessionManagerTest39
1358 * @tc.desc: Transmission sdk session manager get enable session callback by session name with invalid parameters.
1359 * @tc.type: FUNC
1360 * @tc.require:
1361 */
1362 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest39, TestSize.Level1)
1363 {
1364 ISessionListener sessionlistener = {0};
1365 int32_t ret = ClientGetSessionCallbackByName(nullptr, &sessionlistener);
1366 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1367 ret = ClientGetSessionCallbackByName(g_sessionName, nullptr);
1368 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1369 ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
1370 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1371 }
1372
1373 /**
1374 * @tc.name: TransClientSessionManagerTest40
1375 * @tc.desc: Transmission sdk session manager get side by session id with invalid parameters.
1376 * @tc.type: FUNC
1377 * @tc.require:
1378 */
1379 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest40, TestSize.Level1)
1380 {
1381 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
1382 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1383 }
1384
1385 /**
1386 * @tc.name: TransClientSessionManagerTest41
1387 * @tc.desc: Transmission sdk session manager get file config by session id with invalid parameters.
1388 * @tc.type: FUNC
1389 * @tc.require:
1390 */
1391 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest41, TestSize.Level1)
1392 {
1393 int32_t fileEncrypt = 0;
1394 int32_t algorithm = 0;
1395 int32_t crc = 0;
1396 int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_INVALID_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1397 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1398 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, nullptr, &algorithm, &crc);
1399 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1400 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, nullptr, &crc);
1401 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1402 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, nullptr);
1403 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1404 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1405 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1406 ret = CheckPermissionState(TRANS_TEST_SESSION_ID);
1407 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1408 }
1409
1410 /**
1411 * @tc.name: TransClientSessionManagerTest42
1412 * @tc.desc: Transmission sdk session manager operate no initialize.
1413 * @tc.type: FUNC
1414 * @tc.require:
1415 */
1416 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest42, TestSize.Level1)
1417 {
1418 ListNode sessionServerList;
1419 ListInit(&sessionServerList);
1420 int32_t ret = ReCreateSessionServerToServer(&sessionServerList);
1421 EXPECT_EQ(ret, SOFTBUS_OK);
1422 ClientTransOnLinkDown(nullptr, ROUTE_TYPE_ALL);
1423 ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
1424
1425 ClientCleanAllSessionWhenServerDeath(&sessionServerList);
1426 SessionServerInfo *infoNode = nullptr;
1427 SessionServerInfo *infoNodeNext = nullptr;
1428 LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
1429 ListDelete(&infoNode->node);
1430 SoftBusFree(infoNode);
1431 }
1432
1433 PermissionStateChange(g_pkgName, 0);
1434 }
1435
1436 /**
1437 * @tc.name: TransClientSessionManagerTest43
1438 * @tc.desc: Transmission sdk session manager get encrypt option by session name.
1439 * @tc.type: FUNC
1440 * @tc.require:
1441 */
1442 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest43, TestSize.Level1)
1443 {
1444 int32_t ret = ClientRawStreamEncryptDefOptGet(nullptr, nullptr);
1445 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1446
1447 ret = ClientRawStreamEncryptDefOptGet(g_sessionName, nullptr);
1448 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1449
1450 bool isEncrypt = false;
1451 ret = ClientRawStreamEncryptDefOptGet(nullptr, &isEncrypt);
1452 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1453
1454 ret = ClientRawStreamEncryptDefOptGet(g_sessionName, &isEncrypt);
1455 ASSERT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1456 }
1457
1458 /**
1459 * @tc.name: TransClientSessionManagerTest44
1460 * @tc.desc: Transmission sdk session manager get encrypt option by channelId.
1461 * @tc.type: FUNC
1462 * @tc.require:
1463 */
1464 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest44, TestSize.Level1)
1465 {
1466 bool isEncrypt = false;
1467 int32_t ret = ClientRawStreamEncryptOptGet(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &isEncrypt);
1468 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1469
1470 ret = ClientRawStreamEncryptOptGet(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, nullptr);
1471 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1472
1473 ret = ClientRawStreamEncryptOptGet(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &isEncrypt);
1474 ASSERT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1475 }
1476
1477 /**
1478 * @tc.name: TransClientSessionManagerTest45
1479 * @tc.desc: Call isAsync functions when g_clientSessionServerList no initialize.
1480 * @tc.type: FUNC
1481 * @tc.require:
1482 */
1483 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest45, TestSize.Level1)
1484 {
1485 int32_t ret = SetSessionIsAsyncById(1, true);
1486 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1487 ret = SetSessionIsAsyncById(-1, true);
1488 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1489 ret = ClientTransSetChannelInfo(g_sessionName, 1, 1, CHANNEL_TYPE_AUTH);
1490 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1491 ret = ClientTransSetChannelInfo(nullptr, 1, 1, 1);
1492 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1493 bool isAsync = false;
1494 ret = ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1495 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1496 ret = ClientGetSessionIsAsyncBySessionId(-1, &isAsync);
1497 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1498 }
1499
1500 /**
1501 * @tc.name: TransClientSessionManagerTest46
1502 * @tc.desc: Call ClientHandleBindWaitTimer for invalid param.
1503 * @tc.type: FUNC
1504 * @tc.require:
1505 */
1506 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest46, TestSize.Level1)
1507 {
1508 int32_t ret = ClientHandleBindWaitTimer(-1, 0, TIMER_ACTION_STOP);
1509 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1510
1511 ret = ClientHandleBindWaitTimer(1, 0, TIMER_ACTION_STOP);
1512 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1513 }
1514
1515 /**
1516 * @tc.name: TransClientSessionManagerTest47
1517 * @tc.desc: Call GetQosValue SUCCESS.
1518 * @tc.type: FUNC
1519 * @tc.require:
1520 */
1521 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest47, TestSize.Level1)
1522 {
1523 QosTV qos[] = {
1524 {.qos = QOS_TYPE_MAX_WAIT_TIMEOUT, .value = TRANS_TEST_MAX_WAIT_TIMEOUT},
1525 {.qos = QOS_TYPE_MAX_IDLE_TIMEOUT, .value = 0},
1526 };
1527 int32_t maxWaitTimeout = 0;
1528 int32_t ret = GetQosValue(
1529 qos, sizeof(qos) / sizeof(qos[0]), QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1530 EXPECT_EQ(ret, SOFTBUS_OK);
1531 EXPECT_EQ(maxWaitTimeout, TRANS_TEST_MAX_WAIT_TIMEOUT);
1532 }
1533
1534 /**
1535 * @tc.name: TransClientSessionManagerTest48
1536 * @tc.desc: Call GetQosValue default value.
1537 * @tc.type: FUNC
1538 * @tc.require:
1539 */
1540 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest48, TestSize.Level1)
1541 {
1542 QosTV qos[] = {
1543 { .qos = QOS_TYPE_MAX_IDLE_TIMEOUT, .value = 0 },
1544 };
1545 int32_t maxWaitTimeout = 0;
1546 int32_t ret = GetQosValue(
1547 qos, sizeof(qos) / sizeof(qos[0]), QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1548 EXPECT_EQ(ret, SOFTBUS_OK);
1549 EXPECT_EQ(maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1550
1551 ret = GetQosValue(
1552 nullptr, 0, QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1553 EXPECT_EQ(ret, SOFTBUS_OK);
1554 EXPECT_EQ(maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1555 }
1556
1557 /**
1558 * @tc.name: TransClientSessionManagerTest49
1559 * @tc.desc: Call GetQosValue FAIL.
1560 * @tc.type: FUNC
1561 * @tc.require:
1562 */
1563 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest49, TestSize.Level1)
1564 {
1565 int32_t maxWaitTimeout = 0;
1566 int32_t ret = GetQosValue(
1567 nullptr, 1, QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1568 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1569 }
1570
1571 /**
1572 * @tc.name: TransClientSessionManagerTest50
1573 * @tc.desc: Call ClientWaitSyncBind for invalid param..
1574 * @tc.type: FUNC
1575 * @tc.require:
1576 */
1577 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest50, TestSize.Level1)
1578 {
1579 int32_t ret = ClientWaitSyncBind(-1);
1580 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1581
1582 ret = ClientWaitSyncBind(1);
1583 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1584 }
1585
1586 /**
1587 * @tc.name: TransClientSessionManagerTest51
1588 * @tc.desc: Call ClientWaitSyncBind for invalid param..
1589 * @tc.type: FUNC
1590 * @tc.require:
1591 */
1592 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest51, TestSize.Level1)
1593 {
1594 int32_t ret = ClientSignalSyncBind(-1, 0);
1595 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1596
1597 ret = ClientSignalSyncBind(1, 0);
1598 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1599 ClientTransOnUserSwitch();
1600 TransServerDeinit();
1601 ClientTransOnUserSwitch();
1602 }
1603
1604 /*
1605 * @tc.name: TransClientSessionManagerTest52
1606 * @tc.desc: Call RelationChecker for invalid param..
1607 * @tc.type: FUNC
1608 * @tc.require:
1609 */
1610 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest52, TestSize.Level1)
1611 {
1612 CollabInfo sourceInfo;
1613 (void)memset_s(&sourceInfo, sizeof(CollabInfo), 0, sizeof(CollabInfo));
1614 CollabInfo sinkInfo;
1615 (void)memset_s(&sinkInfo, sizeof(CollabInfo), 0, sizeof(CollabInfo));
1616 const int32_t channelId = 1;
1617 const int32_t channelType = 1;
1618 int32_t ret = ClientRegisterRelationChecker(nullptr);
1619 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1620
1621 ret = ClientTransCheckCollabRelation(&sourceInfo, &sinkInfo, channelId, channelType);
1622 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
1623
1624 ret = ClientRegisterRelationChecker(&g_relationChecker);
1625 EXPECT_EQ(SOFTBUS_OK, ret);
1626
1627 ret = ClientTransCheckCollabRelation(&sourceInfo, &sinkInfo, channelId, channelType);
1628 EXPECT_EQ(SOFTBUS_OK, ret);
1629
1630 EXPECT_NO_FATAL_FAILURE(DestroyRelationChecker());
1631 }
1632
1633 /**
1634 * @tc.name: TransClientSessionManagerTest53
1635 * @tc.desc: DataSeqInfoListAddItem
1636 * @tc.type: FUNC
1637 * @tc.require:
1638 */
1639 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest53, TestSize.Level1)
1640 {
1641 TransDataSeqInfoListInit();
1642 int32_t channelId = 1;
1643 uint32_t dataSeq = 1;
1644 int32_t socketId = 1;
1645 int32_t ret = DataSeqInfoListAddItem(dataSeq, channelId, socketId, 0);
1646 EXPECT_EQ(ret, SOFTBUS_OK);
1647 TransDataSeqInfoListDeinit();
1648 }
1649
1650 /**
1651 * @tc.name: TransClientSessionManagerTest55
1652 * @tc.desc: DeleteDataSeqInfoList
1653 * @tc.type: FUNC
1654 * @tc.require:
1655 */
1656 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest55, TestSize.Level1)
1657 {
1658 TransDataSeqInfoListInit();
1659 int32_t channelId = 1;
1660 uint32_t dataSeq = 1;
1661 int32_t socketId = 1;
1662 DataSeqInfoListAddItem(dataSeq, channelId, socketId, 0);
1663 int32_t ret = DeleteDataSeqInfoList(dataSeq, channelId);
1664 EXPECT_EQ(ret, SOFTBUS_OK);
1665 TransDataSeqInfoListDeinit();
1666 }
1667 }