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 uint64_t timestamp = 0;
212 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, nullptr);
213 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
214 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
215 EXPECT_EQ(ret, SOFTBUS_OK);
216 ret = ClientAddNewSession(g_sessionName, session);
217 EXPECT_EQ(ret, SOFTBUS_OK);
218 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
219 EXPECT_EQ(ret, SOFTBUS_OK);
220 SoftBusFree(sessionParam);
221 }
222
223 /**
224 * @tc.name: TransClientSessionManagerTest03
225 * @tc.desc: Transmission sdk session manager add new auth session with invalid and valid parameters.
226 * @tc.type: FUNC
227 * @tc.require:
228 */
229 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest03, TestSize.Level1)
230 {
231 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
232 EXPECT_TRUE(sessionParam != nullptr);
233 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
234 GenerateCommParam(sessionParam);
235 int32_t sessionId = 0;
236 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
237 memset_s(sessionName, SESSION_NAME_SIZE_MAX + 2, 'A', SESSION_NAME_SIZE_MAX + 1);
238 int32_t ret = ClientAddAuthSession(g_sessionName, &sessionId);
239 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
240 uint64_t timestamp = 0;
241 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
242 EXPECT_EQ(ret, SOFTBUS_OK);
243 ret = ClientAddAuthSession(g_sessionName, &sessionId);
244 EXPECT_EQ(ret, SOFTBUS_OK);
245 EXPECT_GT(sessionId, 0);
246 ret = ClientDeleteSession(sessionId);
247 EXPECT_EQ(ret, SOFTBUS_OK);
248 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
249 EXPECT_EQ(ret, SOFTBUS_OK);
250 SoftBusFree(sessionParam);
251 }
252
253 /**
254 * @tc.name: TransClientSessionManagerTest04
255 * @tc.desc: Transmission sdk session manager delete session with invalid parameters.
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest04, TestSize.Level1)
260 {
261 uint64_t timestamp = 0;
262 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
263 EXPECT_EQ(ret, SOFTBUS_OK);
264 ret = ClientDeleteSession(TRANS_TEST_SESSION_ID);
265 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
266 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
267 EXPECT_EQ(ret, SOFTBUS_OK);
268 }
269
270 /**
271 * @tc.name: TransClientSessionManagerTest05
272 * @tc.desc: Transmission sdk session manager add session.
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest05, TestSize.Level1)
277 {
278 int32_t sessionId = 0;
279 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
280 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
281 EXPECT_TRUE(sessionParam != nullptr);
282 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
283 GenerateCommParam(sessionParam);
284 uint64_t timestamp = 0;
285 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
286 EXPECT_EQ(ret, SOFTBUS_OK);
287 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
288 EXPECT_EQ(ret, SOFTBUS_OK);
289 EXPECT_GT(sessionId, 0);
290 ret = ClientDeleteSession(sessionId);
291 EXPECT_EQ(ret, SOFTBUS_OK);
292 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
293 EXPECT_EQ(ret, SOFTBUS_OK);
294 SoftBusFree(sessionParam);
295 }
296
297 /**
298 * @tc.name: TransClientSessionManagerTest06
299 * @tc.desc: Transmission sdk session manager add session server out of range.
300 * @tc.type: FUNC
301 * @tc.require:
302 */
303 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest06, TestSize.Level1)
304 {
305 int32_t ret = 0;
306 uint64_t timestamp = 0;
307 for (int32_t i = 0; i < MAX_SESSION_SERVER_NUMBER; ++i) {
308 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
309 char pkgName[PKG_NAME_SIZE_MAX] = {0};
310 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
311 EXPECT_GT(ret, 0);
312 ret = sprintf_s(pkgName, PKG_NAME_SIZE_MAX, "%s%d", g_pkgName, i);
313 EXPECT_GT(ret, 0);
314 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, pkgName, sessionNme, &g_sessionlistener, ×tamp);
315 EXPECT_EQ(ret, SOFTBUS_OK);
316 }
317 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
318 EXPECT_EQ(ret, SOFTBUS_INVALID_NUM);
319 for (int32_t i = 0; i < MAX_SESSION_SERVER_NUMBER; ++i) {
320 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
321 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
322 EXPECT_GT(ret, 0);
323 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionNme);
324 EXPECT_EQ(ret, SOFTBUS_OK);
325 }
326 }
327
328 /**
329 * @tc.name: GetMaxIdleTimeBySocket01
330 * @tc.desc: Transmission sdk session manager get opt.
331 * @tc.type: FUNC
332 * @tc.require:
333 */
334 HWTEST_F(TransClientSessionManagerTest, GetMaxIdleTimeBySocket01, TestSize.Level1)
335 {
336 int32_t sessionId = 0;
337 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
338 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
339 EXPECT_TRUE(sessionParam != nullptr);
340 uint64_t timestamp = 0;
341 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
342 GenerateCommParam(sessionParam);
343 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
344 EXPECT_EQ(ret, SOFTBUS_OK);
345 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
346 EXPECT_EQ(ret, SOFTBUS_OK);
347 EXPECT_GT(sessionId, 0);
348 uint32_t optValueValid = 10000;
349 ret = SetMaxIdleTimeBySocket(sessionId, optValueValid);
350 ASSERT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
351 uint32_t getValue = 0;
352 ret = GetMaxIdleTimeBySocket(sessionId, &getValue);
353 ASSERT_EQ(ret, SOFTBUS_NOT_IMPLEMENT);
354 ret = ClientDeleteSession(sessionId);
355 EXPECT_EQ(ret, SOFTBUS_OK);
356 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
357 EXPECT_EQ(ret, SOFTBUS_OK);
358 SoftBusFree(sessionParam);
359 }
360
361 /**
362 * @tc.name: TransClientAddSessionOutOfMaxTest01
363 * @tc.desc: Transmission sdk session manager add session out of maxmum.
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(TransClientSessionManagerTest, TransClientAddSessionOutOfMaxTest01, TestSize.Level1)
368 {
369 int32_t sessionId = 0;
370 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
371 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
372 ASSERT_TRUE(sessionParam != nullptr);
373 GenerateCommParam(sessionParam);
374 uint64_t timestamp = 0;
375 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
376 ASSERT_EQ(ret, SOFTBUS_OK);
377
378 for (int32_t i = 0; i < MAX_SESSION_ID; ++i) {
379 char sessionName[SESSION_NAME_SIZE_MAX] = {0};
380 ret = sprintf_s(sessionName, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
381 ASSERT_GT(ret, 0);
382 sessionParam->peerSessionName = (const char*)sessionName;
383 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
384 EXPECT_EQ(ret, SOFTBUS_OK);
385 }
386
387 sessionParam->peerSessionName = g_sessionName;
388 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
389 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_CNT_EXCEEDS_LIMIT);
390 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
391 EXPECT_EQ(ret, SOFTBUS_OK);
392 }
393
394 /**
395 * @tc.name: TransClientSessionManagerTest07
396 * @tc.desc: Transmission sdk session manager add session with existed session.
397 * @tc.type: FUNC
398 * @tc.require:
399 */
400 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest07, TestSize.Level1)
401 {
402 int32_t sessionId = 0;
403 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
404 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
405 EXPECT_TRUE(sessionParam != nullptr);
406 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
407 GenerateCommParam(sessionParam);
408 uint64_t timestamp = 0;
409 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
410 EXPECT_EQ(ret, SOFTBUS_OK);
411 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
412 EXPECT_EQ(ret, SOFTBUS_OK);
413 EXPECT_GT(sessionId, 0);
414 int32_t newSessionId = 0;
415 ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
416 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_REPEATED);
417 EXPECT_EQ(sessionId, newSessionId);
418 ret = ClientDeleteSession(sessionId);
419 EXPECT_EQ(ret, SOFTBUS_OK);
420 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
421 EXPECT_EQ(ret, SOFTBUS_OK);
422 SoftBusFree(sessionParam);
423 }
424
425 /**
426 * @tc.name: TransClientSessionManagerTest08
427 * @tc.desc: Transmission sdk session manager add session with wrong session.
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest08, TestSize.Level1)
432 {
433 int32_t sessionId = 0;
434 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
435 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
436 EXPECT_TRUE(sessionParam != nullptr);
437 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
438 GenerateCommParam(sessionParam);
439 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF"};
440 sessionParam->peerDeviceId = deviceId;
441 int32_t ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
442 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_CREATE_FAILED);
443 SoftBusFree(sessionParam);
444 }
445
446 /**
447 * @tc.name: TransClientSessionManagerTest09
448 * @tc.desc: Transmission sdk session manager delete session.
449 * @tc.type: FUNC
450 * @tc.require:
451 */
452 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest09, TestSize.Level1)
453 {
454 int32_t sessionId = 0;
455 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
456 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
457 EXPECT_TRUE(sessionParam != nullptr);
458 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
459 GenerateCommParam(sessionParam);
460 uint64_t timestamp = 0;
461 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
462 EXPECT_EQ(ret, SOFTBUS_OK);
463 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
464 EXPECT_EQ(ret, SOFTBUS_OK);
465 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
466 char groupId[] = {"TEST_GROUP_ID1"};
467 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
468 SessionAttribute sessionAttr = {
469 .dataType = TYPE_FILE,
470 };
471 SessionParam *newSessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
472 EXPECT_TRUE(newSessionParam != nullptr);
473 memset_s(newSessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
474 newSessionParam->attr = &sessionAttr;
475 newSessionParam->groupId = groupId;
476 newSessionParam->peerDeviceId = deviceId;
477 newSessionParam->peerSessionName = sessionName;
478 newSessionParam->sessionName = g_sessionName;
479 int32_t newSessionId = 0;
480 ret = ClientAddSession(newSessionParam, &newSessionId, &isEnabled);
481 EXPECT_EQ(ret, SOFTBUS_OK);
482 ret = ClientDeleteSession(newSessionId);
483 EXPECT_EQ(ret, SOFTBUS_OK);
484 ret = ClientDeleteSession(sessionId);
485 EXPECT_EQ(ret, SOFTBUS_OK);
486 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
487 EXPECT_EQ(ret, SOFTBUS_OK);
488 SoftBusFree(sessionParam);
489 SoftBusFree(newSessionParam);
490 }
491
492 /**
493 * @tc.name: TransClientSessionManagerTest10
494 * @tc.desc: Transmission sdk session manager get session data by session id with invalid and valid parameters.
495 * @tc.type: FUNC
496 * @tc.require:
497 */
498 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest10, TestSize.Level1)
499 {
500 char data[SESSION_NAME_SIZE_MAX] = {0};
501 int32_t ret = ClientGetSessionDataById(TRANS_TEST_INVALID_SESSION_ID, data,
502 SESSION_NAME_SIZE_MAX, KEY_SESSION_NAME);
503 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
504 uint64_t timestamp = 0;
505 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
506 EXPECT_EQ(ret, SOFTBUS_OK);
507 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
508 EXPECT_TRUE(sessionParam != nullptr);
509 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
510 GenerateCommParam(sessionParam);
511 int32_t sessionId = 0;
512 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
513 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
514 EXPECT_EQ(ret, SOFTBUS_OK);
515 memset_s(data, sizeof(data), 0, sizeof(data));
516 ret = ClientGetSessionDataById(sessionId, data, SESSION_NAME_SIZE_MAX, KEY_PEER_SESSION_NAME);
517 EXPECT_EQ(ret, SOFTBUS_OK);
518 memset_s(data, sizeof(data), 0, sizeof(data));
519 ret = ClientGetSessionDataById(sessionId, data, DEVICE_ID_SIZE_MAX, KEY_PEER_DEVICE_ID);
520 EXPECT_EQ(ret, SOFTBUS_OK);
521 memset_s(data, sizeof(data), 0, sizeof(data));
522 ret = ClientGetSessionDataById(sessionId, data, PKG_NAME_SIZE_MAX, KEY_PKG_NAME);
523 EXPECT_EQ(ret, SOFTBUS_OK);
524 ret = ClientGetSessionDataById(sessionId, data, PKG_NAME_SIZE_MAX, KEY_PEER_PID);
525 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
526 ret = ClientDeleteSession(sessionId);
527 EXPECT_EQ(ret, SOFTBUS_OK);
528 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
529 EXPECT_EQ(ret, SOFTBUS_OK);
530 SoftBusFree(sessionParam);
531 }
532
533 /**
534 * @tc.name: TransClientSessionManagerTest11
535 * @tc.desc: Transmission sdk session manager get session Integer data by session id with invalid parameters.
536 * @tc.type: FUNC
537 * @tc.require:
538 */
539 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest11, TestSize.Level1)
540 {
541 int32_t data = 0;
542 int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
543 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
544 }
545
546 /**
547 * @tc.name: TransClientSessionManagerTest12
548 * @tc.desc: Transmission sdk session manager get session Integer data by session id.
549 * @tc.type: FUNC
550 * @tc.require:
551 */
552 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest12, TestSize.Level1)
553 {
554 int32_t data = 0;
555 uint64_t timestamp = 0;
556 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
557 EXPECT_EQ(ret, SOFTBUS_OK);
558 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
559 EXPECT_TRUE(sessionParam != nullptr);
560 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
561 GenerateCommParam(sessionParam);
562 int32_t sessionId = 0;
563 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
564 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
565 EXPECT_EQ(ret, SOFTBUS_OK);
566 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PEER_PID);
567 EXPECT_EQ(ret, SOFTBUS_OK);
568 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_IS_SERVER);
569 EXPECT_EQ(ret, SOFTBUS_OK);
570 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PEER_UID);
571 EXPECT_EQ(ret, SOFTBUS_OK);
572 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PKG_NAME);
573 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
574 ret = ClientDeleteSession(sessionId);
575 EXPECT_EQ(ret, SOFTBUS_OK);
576 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
577 EXPECT_EQ(ret, SOFTBUS_OK);
578 SoftBusFree(sessionParam);
579 }
580
581 /**
582 * @tc.name: TransClientSessionManagerTest13
583 * @tc.desc: Transmission sdk session manager get channel id by session id with invalid parameters.
584 * @tc.type: FUNC
585 * @tc.require:
586 */
587 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest13, TestSize.Level1)
588 {
589 int32_t channelId = 0;
590 int32_t type = 0;
591 SessionEnableStatus enableStatus = ENABLE_STATUS_INIT;
592 int32_t ret = ClientGetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, &channelId, &type, &enableStatus);
593 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
594 }
595
596 /**
597 * @tc.name: TransClientSessionManagerTest14
598 * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters.
599 * @tc.type: FUNC
600 * @tc.require:
601 */
602 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest14, TestSize.Level1)
603 {
604 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
605 EXPECT_TRUE(transInfo != nullptr);
606 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
607 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
608 transInfo->channelType = CHANNEL_TYPE_UDP;
609 uint64_t timestamp = 0;
610 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
611 EXPECT_EQ(ret, SOFTBUS_OK);
612 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
613 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
614 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
615 EXPECT_EQ(ret, SOFTBUS_OK);
616 SoftBusFree(transInfo);
617 }
618
619 /**
620 * @tc.name: TransClientSessionManagerTest15
621 * @tc.desc: Transmission sdk session manager set channel id by session id.
622 * @tc.type: FUNC
623 * @tc.require:
624 */
625 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest15, TestSize.Level1)
626 {
627 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
628 EXPECT_TRUE(transInfo != nullptr);
629 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
630 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
631 transInfo->channelType = CHANNEL_TYPE_UDP;
632 uint64_t timestamp = 0;
633 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
634 EXPECT_EQ(ret, SOFTBUS_OK);
635 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
636 EXPECT_TRUE(sessionParam != nullptr);
637 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
638 GenerateCommParam(sessionParam);
639 int32_t sessionId = 0;
640 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
641 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
642 EXPECT_EQ(ret, SOFTBUS_OK);
643 ret = ClientSetChannelBySessionId(sessionId, transInfo);
644 EXPECT_EQ(ret, SOFTBUS_OK);
645 ret = ClientDeleteSession(sessionId);
646 EXPECT_EQ(ret, SOFTBUS_OK);
647 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
648 EXPECT_EQ(ret, SOFTBUS_OK);
649 SoftBusFree(transInfo);
650 SoftBusFree(sessionParam);
651 }
652
653 /**
654 * @tc.name: TransClientSessionManagerTest16
655 * @tc.desc: Transmission sdk session manager get channel business type by session id with invalid parameters.
656 * @tc.type: FUNC
657 * @tc.require:
658 */
659 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest16, TestSize.Level1)
660 {
661 int32_t businessType = 0;
662 uint64_t timestamp = 0;
663 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
664 EXPECT_EQ(ret, SOFTBUS_OK);
665 ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
666 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
667 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
668 EXPECT_EQ(ret, SOFTBUS_OK);
669 }
670
671 /**
672 * @tc.name: TransClientSessionManagerTest17
673 * @tc.desc: Transmission sdk session manager get encrypt by channel id.
674 * @tc.type: FUNC
675 * @tc.require:
676 */
677 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest17, TestSize.Level1)
678 {
679 int32_t data = 0;
680 uint64_t timestamp = 0;
681 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
682 EXPECT_EQ(ret, SOFTBUS_OK);
683 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
684 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
685 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
686 EXPECT_TRUE(sessionParam != nullptr);
687 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
688 GenerateCommParam(sessionParam);
689 SessionInfo *session = GenerateSession(sessionParam);
690 session->channelId = TRANS_TEST_CHANNEL_ID;
691 session->channelType = CHANNEL_TYPE_UDP;
692 ret = ClientAddNewSession(g_sessionName, session);
693 EXPECT_EQ(ret, SOFTBUS_OK);
694 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
695 EXPECT_EQ(ret, SOFTBUS_OK);
696 EXPECT_TRUE(data);
697 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &data);
698 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
699 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
700 EXPECT_EQ(ret, SOFTBUS_OK);
701 SoftBusFree(sessionParam);
702 }
703
704 /**
705 * @tc.name: TransClientSessionManagerTest18
706 * @tc.desc: Transmission sdk session manager get session id by channel id.
707 * @tc.type: FUNC
708 * @tc.require:
709 */
710 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest18, TestSize.Level1)
711 {
712 int32_t sessionId = 0;
713 bool isClosing = false;
714 uint64_t timestamp = 0;
715 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
716 EXPECT_EQ(ret, SOFTBUS_OK);
717 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
718 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
719 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
720 EXPECT_TRUE(sessionParam != nullptr);
721 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
722 GenerateCommParam(sessionParam);
723 SessionInfo *session = GenerateSession(sessionParam);
724 session->channelId = TRANS_TEST_CHANNEL_ID;
725 session->channelType = CHANNEL_TYPE_UDP;
726 ret = ClientAddNewSession(g_sessionName, session);
727 EXPECT_EQ(ret, SOFTBUS_OK);
728 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
729 EXPECT_EQ(ret, SOFTBUS_OK);
730 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
731 EXPECT_EQ(ret, SOFTBUS_OK);
732 SoftBusFree(sessionParam);
733 }
734
735 /**
736 * @tc.name: TransClientSessionManagerTest19
737 * @tc.desc: Transmission sdk session manager get enable session id by channel id.
738 * @tc.type: FUNC
739 * @tc.require:
740 */
741 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest19, TestSize.Level1)
742 {
743 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
744 EXPECT_TRUE(channel != nullptr);
745 memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
746 uint64_t timestamp = 0;
747 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
748 EXPECT_EQ(ret, SOFTBUS_OK);
749 int32_t sessionId = 0;
750 ret = ClientEnableSessionByChannelId(channel, &sessionId);
751 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
752 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
753 EXPECT_TRUE(sessionParam != nullptr);
754 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
755 GenerateCommParam(sessionParam);
756 channel->channelId = 0;
757 channel->channelType = CHANNEL_TYPE_AUTH;
758 ret = ClientAddAuthSession(g_sessionName, &sessionId);
759 EXPECT_EQ(ret, SOFTBUS_OK);
760 int32_t newSessionId = 0;
761 ret = ClientEnableSessionByChannelId(channel, &newSessionId);
762 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
763 char deviceId[DEVICE_ID_SIZE_MAX] = {0};
764 ret = strcpy_s(deviceId, DEVICE_ID_SIZE_MAX, g_deviceId);
765 EXPECT_EQ(ret, EOK);
766 channel->peerDeviceId = deviceId;
767 ret = ClientEnableSessionByChannelId(channel, &newSessionId);
768 EXPECT_EQ(ret, SOFTBUS_OK);
769 EXPECT_EQ(sessionId, newSessionId);
770 ret = ClientDeleteSession(sessionId);
771 EXPECT_EQ(ret, SOFTBUS_OK);
772 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
773 EXPECT_EQ(ret, SOFTBUS_OK);
774 SoftBusFree(channel);
775 SoftBusFree(sessionParam);
776 }
777
778 /**
779 * @tc.name: TransClientSessionManagerTest20
780 * @tc.desc: Transmission sdk session manager get enable session callback by session id.
781 * @tc.type: FUNC
782 * @tc.require:
783 */
784 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest20, TestSize.Level1)
785 {
786 ISessionListener sessionlistener = {0};
787 int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
788 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
789 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
790 EXPECT_TRUE(sessionParam != nullptr);
791 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
792 GenerateCommParam(sessionParam);
793 uint64_t timestamp = 0;
794 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
795 EXPECT_EQ(ret, SOFTBUS_OK);
796 int32_t sessionId = 0;
797 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
798 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
799 EXPECT_EQ(ret, SOFTBUS_OK);
800 ret = ClientGetSessionCallbackById(sessionId, &sessionlistener);
801 EXPECT_EQ(ret, SOFTBUS_OK);
802 EXPECT_EQ(sessionlistener.OnSessionOpened, OnSessionOpened);
803 EXPECT_EQ(sessionlistener.OnSessionClosed, OnSessionClosed);
804 EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
805 EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
806 ret = ClientDeleteSession(sessionId);
807 EXPECT_EQ(ret, SOFTBUS_OK);
808 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
809 EXPECT_EQ(ret, SOFTBUS_OK);
810 SoftBusFree(sessionParam);
811 }
812
813 /**
814 * @tc.name: TransClientSessionManagerTest21
815 * @tc.desc: Transmission sdk session manager get enable session callback by session name.
816 * @tc.type: FUNC
817 * @tc.require:
818 */
819 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest21, TestSize.Level1)
820 {
821 ISessionListener sessionlistener = {0};
822 int32_t ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
823 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
824 uint64_t timestamp = 0;
825 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
826 EXPECT_EQ(ret, SOFTBUS_OK);
827 char pkgName[] = {"dms1"};
828 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
829 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, pkgName, sessionName, &g_sessionlistener, ×tamp);
830 EXPECT_EQ(ret, SOFTBUS_OK);
831 ret = ClientGetSessionCallbackByName(sessionName, &sessionlistener);
832 EXPECT_EQ(ret, SOFTBUS_OK);
833 EXPECT_EQ(sessionlistener.OnSessionOpened, OnSessionOpened);
834 EXPECT_EQ(sessionlistener.OnSessionClosed, OnSessionClosed);
835 EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
836 EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
837 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
838 EXPECT_EQ(ret, SOFTBUS_OK);
839 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
840 EXPECT_EQ(ret, SOFTBUS_OK);
841 }
842
843 /**
844 * @tc.name: TransClientSessionManagerTest22
845 * @tc.desc: Transmission sdk session manager get session side by session id.
846 * @tc.type: FUNC
847 * @tc.require:
848 */
849 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest22, TestSize.Level1)
850 {
851 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
852 EXPECT_NE(ret, SOFTBUS_OK);
853 uint64_t timestamp = 0;
854 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
855 EXPECT_EQ(ret, SOFTBUS_OK);
856 int32_t sessionId = 0;
857 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
858 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
859 EXPECT_TRUE(sessionParam != nullptr);
860 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
861 GenerateCommParam(sessionParam);
862 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
863 EXPECT_EQ(ret, SOFTBUS_OK);
864 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
865 char groupId[] = {"TEST_GROUP_ID1"};
866 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
867 sessionParam->groupId = groupId;
868 sessionParam->peerSessionName = sessionName;
869 sessionParam->peerDeviceId = deviceId;
870 int32_t newSessionId = 0;
871 ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
872 EXPECT_EQ(ret, SOFTBUS_OK);
873 ret = ClientGetSessionSide(sessionId);
874 EXPECT_EQ(ret, IS_CLIENT);
875 ret = ClientGetSessionSide(newSessionId);
876 EXPECT_EQ(ret, IS_CLIENT);
877 ret = ClientDeleteSession(sessionId);
878 EXPECT_EQ(ret, SOFTBUS_OK);
879 ret = ClientDeleteSession(newSessionId);
880 EXPECT_EQ(ret, SOFTBUS_OK);
881 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
882 EXPECT_EQ(ret, SOFTBUS_OK);
883 SoftBusFree(sessionParam);
884 }
885
886 /**
887 * @tc.name: TransClientSessionManagerTest23
888 * @tc.desc: Transmission sdk session manager grant permission and remove permission with invalid parameters.
889 * @tc.type: FUNC
890 * @tc.require:
891 */
892 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest23, TestSize.Level1)
893 {
894 int32_t ret = ClientGrantPermission(TRANS_TEST_INVALID_UID, TRANS_TEST_PID, g_sessionName);
895 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
896 ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_INVALID_PID, g_sessionName);
897 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
898 ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_PID, nullptr);
899 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
900 ret = ClientRemovePermission(nullptr);
901 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
902 }
903
904 /**
905 * @tc.name: TransClientSessionManagerTest24
906 * @tc.desc: Transmission sdk session manager get file config by session.
907 * @tc.type: FUNC
908 * @tc.require:
909 */
910 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest24, TestSize.Level1)
911 {
912 int32_t fileEncrypt = 0;
913 int32_t algorithm = 0;
914 int32_t crc = 0;
915 bool isClosing = false;
916 uint64_t timestamp = 0;
917 int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
918 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
919 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
920 EXPECT_EQ(ret, SOFTBUS_OK);
921 int32_t sessionId = 0;
922 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
923 EXPECT_TRUE(sessionParam != nullptr);
924 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
925 GenerateCommParam(sessionParam);
926 SessionInfo *session = GenerateSession(sessionParam);
927 session->channelId = TRANS_TEST_CHANNEL_ID;
928 session->channelType = CHANNEL_TYPE_UDP;
929 ret = ClientAddNewSession(g_sessionName, session);
930 EXPECT_EQ(ret, SOFTBUS_OK);
931 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
932 EXPECT_EQ(ret, SOFTBUS_OK);
933 ret = ClientGetFileConfigInfoById(sessionId, &fileEncrypt, &algorithm, &crc);
934 EXPECT_EQ(ret, SOFTBUS_OK);
935 EXPECT_EQ(TRANS_TEST_FILE_ENCRYPT, fileEncrypt);
936 EXPECT_EQ(TRANS_TEST_ALGORITHM, algorithm);
937 EXPECT_EQ(TRANS_TEST_CRC, crc);
938 ret = ClientDeleteSession(sessionId);
939 EXPECT_EQ(ret, SOFTBUS_OK);
940 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
941 EXPECT_EQ(ret, SOFTBUS_OK);
942 SoftBusFree(sessionParam);
943 }
944
945 /**
946 * @tc.name: TransClientSessionManagerTest25
947 * @tc.desc: Transmission sdk session manager recreate session server to server.
948 * @tc.type: FUNC
949 * @tc.require:
950 */
951 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest25, TestSize.Level1)
952 {
953 uint64_t timestamp = 0;
954 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
955 EXPECT_EQ(ret, SOFTBUS_OK);
956
957 ret = ReCreateSessionServerToServer(nullptr);
958 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
959
960 ListNode sessionServerList;
961 ListInit(&sessionServerList);
962 ret = ReCreateSessionServerToServer(&sessionServerList);
963 EXPECT_EQ(ret, SOFTBUS_OK);
964
965 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
966 EXPECT_EQ(ret, SOFTBUS_OK);
967
968 SessionServerInfo *infoNode = nullptr;
969 SessionServerInfo *infoNodeNext = nullptr;
970 LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
971 ListDelete(&infoNode->node);
972 SoftBusFree(infoNode);
973 }
974 }
975
976 /**
977 * @tc.name: TransClientSessionManagerTest26
978 * @tc.desc: Transmission sdk session manager clear list on link down.
979 * @tc.type: FUNC
980 * @tc.require:
981 */
982 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest26, TestSize.Level1)
983 {
984 uint64_t timestamp = 0;
985 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
986 EXPECT_EQ(ret, SOFTBUS_OK);
987 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
988 EXPECT_TRUE(sessionParam != nullptr);
989 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
990 GenerateCommParam(sessionParam);
991 SessionInfo *session = GenerateSession(sessionParam);
992 session->channelId = TRANS_TEST_CHANNEL_ID;
993 session->channelType = CHANNEL_TYPE_UDP;
994 ret = ClientAddNewSession(g_sessionName, session);
995 EXPECT_EQ(ret, SOFTBUS_OK);
996 ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
997 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
998 EXPECT_EQ(ret, SOFTBUS_OK);
999 }
1000
1001 /**
1002 * @tc.name: TransClientSessionManagerTest27
1003 * @tc.desc: Transmission sdk session manager clear all session when server death.
1004 * @tc.type: FUNC
1005 * @tc.require:
1006 */
1007 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest27, TestSize.Level1)
1008 {
1009 uint64_t timestamp = 0;
1010 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1011 EXPECT_EQ(ret, SOFTBUS_OK);
1012
1013 ListNode sessionServerList;
1014 ListInit(&sessionServerList);
1015 ClientCleanAllSessionWhenServerDeath(&sessionServerList);
1016 SessionServerInfo *infoNode = nullptr;
1017 SessionServerInfo *infoNodeNext = nullptr;
1018 LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
1019 ListDelete(&infoNode->node);
1020 SoftBusFree(infoNode);
1021 }
1022
1023 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1024 EXPECT_TRUE(sessionParam != nullptr);
1025 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1026 GenerateCommParam(sessionParam);
1027 SessionInfo *session = GenerateSession(sessionParam);
1028 session->channelId = TRANS_TEST_CHANNEL_ID;
1029 session->channelType = CHANNEL_TYPE_UDP;
1030 ret = ClientAddNewSession(g_sessionName, session);
1031 EXPECT_EQ(ret, SOFTBUS_OK);
1032
1033 ClientCleanAllSessionWhenServerDeath(&sessionServerList);
1034 infoNode = nullptr;
1035 infoNodeNext = nullptr;
1036 LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
1037 ListDelete(&infoNode->node);
1038 SoftBusFree(infoNode);
1039 }
1040
1041 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1042 EXPECT_EQ(ret, SOFTBUS_OK);
1043 }
1044
1045 /**
1046 * @tc.name: TransClientSessionManagerTest28
1047 * @tc.desc: Transmission sdk session manager permission state change.
1048 * @tc.type: FUNC
1049 * @tc.require:
1050 */
1051 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest28, TestSize.Level1)
1052 {
1053 uint64_t timestamp = 0;
1054 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1055 EXPECT_EQ(ret, SOFTBUS_OK);
1056 PermissionStateChange(g_pkgName, TRANS_TEST_STATE);
1057 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1058 EXPECT_EQ(ret, SOFTBUS_OK);
1059 }
1060
1061 /**
1062 * @tc.name: TransClientSessionDestroyTest01
1063 * @tc.desc: Transmission sdk session manager destroy session by network id.
1064 * @tc.type: FUNC
1065 * @tc.require:
1066 */
1067 HWTEST_F(TransClientSessionManagerTest, TransClientSessionDestroyTest01, TestSize.Level1)
1068 {
1069 uint64_t timestamp = 0;
1070 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1071 ASSERT_EQ(ret, SOFTBUS_OK);
1072 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1073 ASSERT_TRUE(sessionParam != nullptr);
1074 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1075 GenerateCommParam(sessionParam);
1076 SessionInfo *session = GenerateSession(sessionParam);
1077 ASSERT_TRUE(session != nullptr);
1078 session->channelId = TRANS_TEST_CHANNEL_ID;
1079 session->channelType = CHANNEL_TYPE_UDP;
1080 session->routeType = WIFI_STA;
1081 ret = ClientAddNewSession(g_sessionName, session);
1082 ASSERT_EQ(ret, SOFTBUS_OK);
1083 sessionParam->peerDeviceId = g_networkId;
1084 SessionInfo *newSession = GenerateSession(sessionParam);
1085 ASSERT_TRUE(newSession != nullptr);
1086 newSession->channelId = TRANS_TEST_CHANNEL_ID + 1;
1087 newSession->channelType = CHANNEL_TYPE_UDP;
1088 newSession->routeType = WIFI_P2P;
1089 ret = ClientAddNewSession(g_sessionName, newSession);
1090 ASSERT_EQ(ret, SOFTBUS_OK);
1091 ClientTransOnLinkDown(g_networkId, WIFI_STA);
1092 int32_t sessionId = 0;
1093 bool isClosing = false;
1094 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1095 EXPECT_EQ(ret, SOFTBUS_OK);
1096 EXPECT_GT(sessionId, 0);
1097 ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
1098 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1099 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1100 ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
1101 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1102 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1103 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1104 EXPECT_EQ(ret, SOFTBUS_OK);
1105 SoftBusFree(sessionParam);
1106 }
1107
1108 /**
1109 * @tc.name: TransClientSessionIsAsyncTest01
1110 * @tc.desc: Session IsAsync param tests.
1111 * @tc.type: FUNC
1112 * @tc.require:
1113 */
1114 HWTEST_F(TransClientSessionManagerTest, TransClientSessionIsAsyncTest01, TestSize.Level1)
1115 {
1116 uint64_t timestamp = 0;
1117 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1118 ASSERT_EQ(ret, SOFTBUS_OK);
1119 SessionParam *sessionParam = (SessionParam *)SoftBusMalloc(sizeof(SessionParam));
1120 ASSERT_TRUE(sessionParam != nullptr);
1121 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1122 GenerateCommParam(sessionParam);
1123 SessionInfo *session = GenerateSession(sessionParam);
1124 ASSERT_TRUE(session != nullptr);
1125 ret = ClientAddNewSession(g_sessionName, session);
1126 session->sessionId = 1;
1127 ASSERT_EQ(ret, SOFTBUS_OK);
1128 sessionParam->isAsync = true;
1129 SessionInfo *newSession = GenerateSession(sessionParam);
1130 ret = ClientAddNewSession(g_sessionName, newSession);
1131 ASSERT_EQ(ret, SOFTBUS_OK);
1132 newSession->sessionId = 2;
1133 bool isAsync = false;
1134 ClientGetSessionIsAsyncBySessionId(2, &isAsync);
1135 ASSERT_EQ(isAsync, true);
1136 ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1137 ASSERT_EQ(isAsync, false);
1138 SetSessionIsAsyncById(1, true);
1139 ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1140 ASSERT_EQ(isAsync, true);
1141 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1142 EXPECT_EQ(ret, SOFTBUS_OK);
1143 SoftBusFree(sessionParam);
1144 }
1145
1146 /**
1147 * @tc.name: ClientTransSetChannelInfoTest01
1148 * @tc.desc: Session IsAsync param tests.
1149 * @tc.type: FUNC
1150 * @tc.require:
1151 */
1152 HWTEST_F(TransClientSessionManagerTest, ClientTransSetChannelInfoTest01, TestSize.Level1)
1153 {
1154 uint64_t timestamp = 0;
1155 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1156 ASSERT_EQ(ret, SOFTBUS_OK);
1157 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1158 ASSERT_TRUE(sessionParam != nullptr);
1159 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1160 GenerateCommParam(sessionParam);
1161 SessionInfo *session = GenerateSession(sessionParam);
1162 ASSERT_TRUE(session != nullptr);
1163 session->channelId = TRANS_TEST_CHANNEL_ID;
1164 session->channelType = CHANNEL_TYPE_PROXY;
1165 session->routeType = WIFI_STA;
1166 ret = ClientAddNewSession(g_sessionName, session);
1167 session->sessionId = 1;
1168 ASSERT_EQ(ret, SOFTBUS_OK);
1169 ret = ClientTransSetChannelInfo(g_sessionName, 1, 11, CHANNEL_TYPE_TCP_DIRECT);
1170 ASSERT_EQ(ret, SOFTBUS_OK);
1171 int32_t channelId = INVALID_CHANNEL_ID;
1172 int32_t ChannelType = CHANNEL_TYPE_BUTT;
1173 ClientGetChannelBySessionId(1, &channelId, &ChannelType, nullptr);
1174 ASSERT_EQ(channelId, 11);
1175 ASSERT_EQ(ChannelType, CHANNEL_TYPE_TCP_DIRECT);
1176 char sessionName[SESSION_NAME_SIZE_MAX];
1177 SocketLifecycleData lifecycle;
1178 ret = GetSocketLifecycleAndSessionNameBySessionId(1, sessionName, &lifecycle);
1179 ASSERT_EQ(ret, SOFTBUS_OK);
1180 ASSERT_EQ(lifecycle.sessionState, SESSION_STATE_OPENED);
1181 ret = SetSessionStateBySessionId(1, SESSION_STATE_CANCELLING, 0);
1182 ASSERT_EQ(ret, SOFTBUS_OK);
1183 ret = GetSocketLifecycleAndSessionNameBySessionId(1, sessionName, &lifecycle);
1184 ASSERT_EQ(ret, SOFTBUS_OK);
1185 ASSERT_EQ(lifecycle.sessionState, SESSION_STATE_CANCELLING);
1186 int32_t osType;
1187 ret = ClientGetChannelOsTypeBySessionId(1, &osType);
1188 EXPECT_EQ(SOFTBUS_OK, ret);
1189 (void)ClientTransOnPrivilegeClose(g_networkId);
1190 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1191 EXPECT_EQ(ret, SOFTBUS_OK);
1192 SoftBusFree(sessionParam);
1193 }
1194
1195 /**
1196 * @tc.name: TransClientSessionManagerTest29
1197 * @tc.desc: Transmission sdk session manager add and delete server with invalid parameters no initialize.
1198 * @tc.type: FUNC
1199 * @tc.require:
1200 */
1201 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest29, TestSize.Level1)
1202 {
1203 TransClientDeinit();
1204 uint64_t timestamp = 0;
1205 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, nullptr, g_sessionName, &g_sessionlistener, ×tamp);
1206 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1207 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1208 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1209 ret = ClientDeleteSessionServer(SEC_TYPE_UNKNOWN, g_sessionName);
1210 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1211 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1212 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1213 ret = ClientDeleteSession(TRANS_TEST_INVALID_SESSION_ID);
1214 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1215 ret = ClientDeleteSession(TRANS_TEST_SESSION_ID);
1216 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1217 }
1218
1219
1220 /**
1221 * @tc.name: TransClientSessionManagerTest30
1222 * @tc.desc: Transmission sdk session manager add new auth session with invalid parameters no initialize.
1223 * @tc.type: FUNC
1224 * @tc.require:
1225 */
1226 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest30, TestSize.Level1)
1227 {
1228 int32_t sessionId = 0;
1229 int32_t ret = ClientAddAuthSession(nullptr, &sessionId);
1230 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1231 ret = ClientAddAuthSession(g_sessionName, &sessionId);
1232 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1233 }
1234
1235 /**
1236 * @tc.name: TransClientSessionManagerTest31
1237 * @tc.desc: Transmission sdk session manager add new session no initialize.
1238 * @tc.type: FUNC
1239 * @tc.require:
1240 */
1241 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest31, TestSize.Level1)
1242 {
1243 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1244 EXPECT_TRUE(sessionParam != nullptr);
1245 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1246 GenerateCommParam(sessionParam);
1247 SessionInfo *session = GenerateSession(sessionParam);
1248 int32_t ret = ClientAddNewSession(g_sessionName, nullptr);
1249 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1250 ret = ClientAddNewSession(g_sessionName, session);
1251 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1252 SoftBusFree(sessionParam);
1253 }
1254
1255 /**
1256 * @tc.name: TransClientSessionManagerTest32
1257 * @tc.desc: Transmission sdk session manager get session Integer data by session id no initialize.
1258 * @tc.type: FUNC
1259 * @tc.require:
1260 */
1261 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest32, TestSize.Level1)
1262 {
1263 int32_t data = 0;
1264 int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_INVALID_SESSION_ID, &data, KEY_PEER_PID);
1265 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1266 ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, nullptr, KEY_PEER_PID);
1267 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1268 ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
1269 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1270 }
1271
1272 /**
1273 * @tc.name: TransClientSessionManagerTest33
1274 * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters no initialize.
1275 * @tc.type: FUNC
1276 * @tc.require:
1277 */
1278 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest33, TestSize.Level1)
1279 {
1280 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
1281 EXPECT_TRUE(transInfo != nullptr);
1282 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
1283 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1284 transInfo->channelType = CHANNEL_TYPE_UDP;
1285 int32_t ret = ClientSetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, transInfo);
1286 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1287 transInfo->channelId = TRANS_TEST_INVALID_CHANNEL_ID;
1288 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1289 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1290 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1291 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1292 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1293 SoftBusFree(transInfo);
1294 }
1295
1296 /**
1297 * @tc.name: TransClientSessionManagerTest34
1298 * @tc.desc: Transmission sdk session manager get channel business type by session id no initialize.
1299 * @tc.type: FUNC
1300 * @tc.require:
1301 */
1302 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest34, TestSize.Level1)
1303 {
1304 int32_t businessType = 0;
1305 int32_t ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_INVALID_SESSION_ID, &businessType);
1306 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1307 ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
1308 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1309 }
1310
1311 /**
1312 * @tc.name: TransClientSessionManagerTest35
1313 * @tc.desc: Transmission sdk session manager get encrypt by channel id with invalid parameters.
1314 * @tc.type: FUNC
1315 * @tc.require:
1316 */
1317 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest35, TestSize.Level1)
1318 {
1319 int32_t data = 0;
1320 int32_t ret = GetEncryptByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1321 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1322 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, nullptr);
1323 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1324 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1325 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1326 }
1327
1328 /**
1329 * @tc.name: TransClientSessionManagerTest36
1330 * @tc.desc: Transmission sdk session manager get session id by channel id with invalid parameters.
1331 * @tc.type: FUNC
1332 * @tc.require:
1333 */
1334 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest36, TestSize.Level1)
1335 {
1336 int32_t sessionId = 0;
1337 bool isClosing = false;
1338 int32_t ret = ClientGetSessionIdByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1339 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1340 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, nullptr, isClosing);
1341 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1342 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1343 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1344 char data[SESSION_NAME_SIZE_MAX] = {0};
1345 ret = ClientGetSessionDataById(TRANS_TEST_SESSION_ID, data, SESSION_NAME_SIZE_MAX, KEY_PEER_SESSION_NAME);
1346 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1347 }
1348
1349 /**
1350 * @tc.name: TransClientSessionManagerTest37
1351 * @tc.desc: Transmission sdk session manager get enable session id by channel id with invalid parameters.
1352 * @tc.type: FUNC
1353 * @tc.require:
1354 */
1355 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest37, TestSize.Level1)
1356 {
1357 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
1358 EXPECT_TRUE(channel != nullptr);
1359 memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
1360 int32_t sessionId = 0;
1361 int32_t ret = ClientEnableSessionByChannelId(nullptr, &sessionId);
1362 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1363 ret = ClientEnableSessionByChannelId(channel, nullptr);
1364 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1365 ret = ClientEnableSessionByChannelId(channel, &sessionId);
1366 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1367 SoftBusFree(channel);
1368 }
1369
1370 /**
1371 * @tc.name: TransClientSessionManagerTest38
1372 * @tc.desc: Transmission sdk session manager get enable session callback by session id with invalid parameters.
1373 * @tc.type: FUNC
1374 * @tc.require:
1375 */
1376 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest38, TestSize.Level1)
1377 {
1378 ISessionListener sessionlistener = {0};
1379 int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_INVALID_SESSION_ID, &sessionlistener);
1380 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1381 ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, nullptr);
1382 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1383 ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
1384 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1385 }
1386
1387 /**
1388 * @tc.name: TransClientSessionManagerTest39
1389 * @tc.desc: Transmission sdk session manager get enable session callback by session name with invalid parameters.
1390 * @tc.type: FUNC
1391 * @tc.require:
1392 */
1393 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest39, TestSize.Level1)
1394 {
1395 ISessionListener sessionlistener = {0};
1396 int32_t ret = ClientGetSessionCallbackByName(nullptr, &sessionlistener);
1397 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1398 ret = ClientGetSessionCallbackByName(g_sessionName, nullptr);
1399 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1400 ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
1401 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1402 }
1403
1404 /**
1405 * @tc.name: TransClientSessionManagerTest40
1406 * @tc.desc: Transmission sdk session manager get side by session id with invalid parameters.
1407 * @tc.type: FUNC
1408 * @tc.require:
1409 */
1410 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest40, TestSize.Level1)
1411 {
1412 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
1413 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1414 }
1415
1416 /**
1417 * @tc.name: TransClientSessionManagerTest41
1418 * @tc.desc: Transmission sdk session manager get file config by session id with invalid parameters.
1419 * @tc.type: FUNC
1420 * @tc.require:
1421 */
1422 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest41, TestSize.Level1)
1423 {
1424 int32_t fileEncrypt = 0;
1425 int32_t algorithm = 0;
1426 int32_t crc = 0;
1427 int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_INVALID_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1428 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1429 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, nullptr, &algorithm, &crc);
1430 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1431 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, nullptr, &crc);
1432 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1433 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, nullptr);
1434 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1435 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1436 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1437 ret = CheckPermissionState(TRANS_TEST_SESSION_ID);
1438 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1439 }
1440
1441 /**
1442 * @tc.name: TransClientSessionManagerTest42
1443 * @tc.desc: Transmission sdk session manager operate no initialize.
1444 * @tc.type: FUNC
1445 * @tc.require:
1446 */
1447 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest42, TestSize.Level1)
1448 {
1449 ListNode sessionServerList;
1450 ListInit(&sessionServerList);
1451 int32_t ret = ReCreateSessionServerToServer(&sessionServerList);
1452 EXPECT_EQ(ret, SOFTBUS_OK);
1453 ClientTransOnLinkDown(nullptr, ROUTE_TYPE_ALL);
1454 ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
1455
1456 ClientCleanAllSessionWhenServerDeath(&sessionServerList);
1457 SessionServerInfo *infoNode = nullptr;
1458 SessionServerInfo *infoNodeNext = nullptr;
1459 LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
1460 ListDelete(&infoNode->node);
1461 SoftBusFree(infoNode);
1462 }
1463
1464 PermissionStateChange(g_pkgName, 0);
1465 }
1466
1467 /**
1468 * @tc.name: TransClientSessionManagerTest43
1469 * @tc.desc: Transmission sdk session manager get encrypt option by session name.
1470 * @tc.type: FUNC
1471 * @tc.require:
1472 */
1473 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest43, TestSize.Level1)
1474 {
1475 int32_t ret = ClientRawStreamEncryptDefOptGet(nullptr, nullptr);
1476 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1477
1478 ret = ClientRawStreamEncryptDefOptGet(g_sessionName, nullptr);
1479 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1480
1481 bool isEncrypt = false;
1482 ret = ClientRawStreamEncryptDefOptGet(nullptr, &isEncrypt);
1483 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1484
1485 ret = ClientRawStreamEncryptDefOptGet(g_sessionName, &isEncrypt);
1486 ASSERT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1487 }
1488
1489 /**
1490 * @tc.name: TransClientSessionManagerTest44
1491 * @tc.desc: Transmission sdk session manager get encrypt option by channelId.
1492 * @tc.type: FUNC
1493 * @tc.require:
1494 */
1495 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest44, TestSize.Level1)
1496 {
1497 bool isEncrypt = false;
1498 int32_t ret = ClientRawStreamEncryptOptGet(TRANS_TEST_SESSION_ID,
1499 TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &isEncrypt);
1500 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1501
1502 ret = ClientRawStreamEncryptOptGet(TRANS_TEST_SESSION_ID, TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, nullptr);
1503 ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1504
1505 ret = ClientRawStreamEncryptOptGet(TRANS_TEST_SESSION_ID, TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &isEncrypt);
1506 ASSERT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1507 }
1508
1509 /**
1510 * @tc.name: TransClientSessionManagerTest45
1511 * @tc.desc: Call isAsync functions when g_clientSessionServerList no initialize.
1512 * @tc.type: FUNC
1513 * @tc.require:
1514 */
1515 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest45, TestSize.Level1)
1516 {
1517 int32_t ret = SetSessionIsAsyncById(1, true);
1518 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1519 ret = SetSessionIsAsyncById(-1, true);
1520 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1521 ret = ClientTransSetChannelInfo(g_sessionName, 1, 1, CHANNEL_TYPE_AUTH);
1522 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1523 ret = ClientTransSetChannelInfo(nullptr, 1, 1, 1);
1524 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1525 bool isAsync = false;
1526 ret = ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1527 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1528 ret = ClientGetSessionIsAsyncBySessionId(-1, &isAsync);
1529 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1530 }
1531
1532 /**
1533 * @tc.name: TransClientSessionManagerTest46
1534 * @tc.desc: Call ClientHandleBindWaitTimer for invalid param.
1535 * @tc.type: FUNC
1536 * @tc.require:
1537 */
1538 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest46, TestSize.Level1)
1539 {
1540 int32_t ret = ClientHandleBindWaitTimer(-1, 0, TIMER_ACTION_STOP);
1541 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1542
1543 ret = ClientHandleBindWaitTimer(1, 0, TIMER_ACTION_STOP);
1544 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1545 }
1546
1547 /**
1548 * @tc.name: TransClientSessionManagerTest47
1549 * @tc.desc: Call GetQosValue SUCCESS.
1550 * @tc.type: FUNC
1551 * @tc.require:
1552 */
1553 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest47, TestSize.Level1)
1554 {
1555 QosTV qos[] = {
1556 {.qos = QOS_TYPE_MAX_WAIT_TIMEOUT, .value = TRANS_TEST_MAX_WAIT_TIMEOUT},
1557 {.qos = QOS_TYPE_MAX_IDLE_TIMEOUT, .value = 0},
1558 };
1559 int32_t maxWaitTimeout = 0;
1560 int32_t ret = GetQosValue(
1561 qos, sizeof(qos) / sizeof(qos[0]), QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1562 EXPECT_EQ(ret, SOFTBUS_OK);
1563 EXPECT_EQ(maxWaitTimeout, TRANS_TEST_MAX_WAIT_TIMEOUT);
1564 }
1565
1566 /**
1567 * @tc.name: TransClientSessionManagerTest48
1568 * @tc.desc: Call GetQosValue default value.
1569 * @tc.type: FUNC
1570 * @tc.require:
1571 */
1572 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest48, TestSize.Level1)
1573 {
1574 QosTV qos[] = {
1575 { .qos = QOS_TYPE_MAX_IDLE_TIMEOUT, .value = 0 },
1576 };
1577 int32_t maxWaitTimeout = 0;
1578 int32_t ret = GetQosValue(
1579 qos, sizeof(qos) / sizeof(qos[0]), QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1580 EXPECT_EQ(ret, SOFTBUS_OK);
1581 EXPECT_EQ(maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1582
1583 ret = GetQosValue(
1584 nullptr, 0, QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1585 EXPECT_EQ(ret, SOFTBUS_OK);
1586 EXPECT_EQ(maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1587 }
1588
1589 /**
1590 * @tc.name: TransClientSessionManagerTest49
1591 * @tc.desc: Call GetQosValue FAIL.
1592 * @tc.type: FUNC
1593 * @tc.require:
1594 */
1595 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest49, TestSize.Level1)
1596 {
1597 int32_t maxWaitTimeout = 0;
1598 int32_t ret = GetQosValue(
1599 nullptr, 1, QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1600 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1601 }
1602
1603 /**
1604 * @tc.name: TransClientSessionManagerTest50
1605 * @tc.desc: Call ClientWaitSyncBind for invalid param..
1606 * @tc.type: FUNC
1607 * @tc.require:
1608 */
1609 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest50, TestSize.Level1)
1610 {
1611 int32_t ret = ClientWaitSyncBind(-1);
1612 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1613
1614 ret = ClientWaitSyncBind(1);
1615 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1616 }
1617
1618 /**
1619 * @tc.name: TransClientSessionManagerTest51
1620 * @tc.desc: Call ClientWaitSyncBind for invalid param..
1621 * @tc.type: FUNC
1622 * @tc.require:
1623 */
1624 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest51, TestSize.Level1)
1625 {
1626 int32_t ret = ClientSignalSyncBind(-1, 0);
1627 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1628
1629 ret = ClientSignalSyncBind(1, 0);
1630 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1631 ClientTransOnUserSwitch();
1632 TransServerDeinit();
1633 ClientTransOnUserSwitch();
1634 }
1635
1636 /*
1637 * @tc.name: TransClientSessionManagerTest52
1638 * @tc.desc: Call RelationChecker for invalid param..
1639 * @tc.type: FUNC
1640 * @tc.require:
1641 */
1642 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest52, TestSize.Level1)
1643 {
1644 CollabInfo sourceInfo;
1645 (void)memset_s(&sourceInfo, sizeof(CollabInfo), 0, sizeof(CollabInfo));
1646 CollabInfo sinkInfo;
1647 (void)memset_s(&sinkInfo, sizeof(CollabInfo), 0, sizeof(CollabInfo));
1648 const int32_t channelId = 1;
1649 const int32_t channelType = 1;
1650 int32_t ret = ClientRegisterRelationChecker(nullptr);
1651 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1652
1653 ret = ClientTransCheckCollabRelation(&sourceInfo, &sinkInfo, channelId, channelType);
1654 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
1655
1656 ret = ClientRegisterRelationChecker(&g_relationChecker);
1657 EXPECT_EQ(SOFTBUS_OK, ret);
1658
1659 ret = ClientTransCheckCollabRelation(&sourceInfo, &sinkInfo, channelId, channelType);
1660 EXPECT_EQ(SOFTBUS_OK, ret);
1661
1662 EXPECT_NO_FATAL_FAILURE(DestroyRelationChecker());
1663 }
1664
1665 /**
1666 * @tc.name: TransClientSessionManagerTest53
1667 * @tc.desc: DataSeqInfoListAddItem
1668 * @tc.type: FUNC
1669 * @tc.require:
1670 */
1671 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest53, TestSize.Level1)
1672 {
1673 TransDataSeqInfoListInit();
1674 int32_t channelId = 1;
1675 uint32_t dataSeq = 1;
1676 int32_t socketId = 1;
1677 int32_t ret = DataSeqInfoListAddItem(dataSeq, channelId, socketId, 0);
1678 EXPECT_EQ(ret, SOFTBUS_OK);
1679 TransDataSeqInfoListDeinit();
1680 }
1681
1682 /**
1683 * @tc.name: TransClientSessionManagerTest54
1684 * @tc.desc: DeleteDataSeqInfoList
1685 * @tc.type: FUNC
1686 * @tc.require:
1687 */
1688 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest54, TestSize.Level1)
1689 {
1690 TransDataSeqInfoListInit();
1691 int32_t channelId = 1;
1692 uint32_t dataSeq = 1;
1693 int32_t socketId = 1;
1694 DataSeqInfoListAddItem(dataSeq, channelId, socketId, 0);
1695 int32_t ret = DeleteDataSeqInfoList(dataSeq, channelId);
1696 EXPECT_EQ(ret, SOFTBUS_OK);
1697 TransDataSeqInfoListDeinit();
1698 }
1699
1700 /**
1701 * @tc.name: TransClientSessionManagerTest55
1702 * @tc.desc: TryDeleteEmptySessionServer
1703 * @tc.type: FUNC
1704 * @tc.require:
1705 */
1706 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest55, TestSize.Level1)
1707 {
1708 int32_t ret = TryDeleteEmptySessionServer(nullptr, g_sessionName);
1709 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1710 ret = TryDeleteEmptySessionServer(g_pkgName, nullptr);
1711 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1712 ret = TryDeleteEmptySessionServer(nullptr, nullptr);
1713 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1714 }
1715
1716 /**
1717 * @tc.name: TransClientSessionManagerTest56
1718 * @tc.desc: SocketServerStateUpdate
1719 * @tc.type: FUNC
1720 * @tc.require:
1721 */
1722 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest56, TestSize.Level1)
1723 {
1724 int32_t ret = TransClientInit();
1725 EXPECT_EQ(ret, SOFTBUS_OK);
1726 SocketServerStateUpdate(nullptr);
1727 SocketServerStateUpdate(g_sessionName);
1728 uint64_t timestamp = 0;
1729 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1730 EXPECT_EQ(ret, SOFTBUS_OK);
1731 SocketServerStateUpdate(g_sessionName);
1732 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1733 EXPECT_EQ(ret, SOFTBUS_OK);
1734 }
1735
1736 /**
1737 * @tc.name: TransClientSessionManagerTestTest57
1738 * @tc.desc: ClientSetStatusClosingBySocket
1739 * @tc.type: FUNC
1740 * @tc.require:
1741 */
1742 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTestTest57, TestSize.Level1)
1743 {
1744 uint64_t timestamp = 0;
1745 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1746 EXPECT_EQ(ret, SOFTBUS_OK);
1747 int32_t socketId = SOFTBUS_TRANS_INVALID_SESSION_ID;
1748 ret = ClientSetStatusClosingBySocket(socketId, true);
1749 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1750 ret = ClientSetStatusClosingBySocket(TRANS_TEST_SESSION_ID, true);
1751 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1752 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1753 EXPECT_EQ(ret, SOFTBUS_OK);
1754 }
1755
1756 /**
1757 * @tc.name: TransClientSessionManagerTest58
1758 * @tc.desc: GetSupportTlvAndNeedAckById
1759 * @tc.type: FUNC
1760 * @tc.require:
1761 */
1762 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest58, TestSize.Level1)
1763 {
1764 int32_t channelId = 0;
1765 int32_t ret = GetSupportTlvAndNeedAckById(channelId, CHANNEL_TYPE_UDP, nullptr, nullptr);
1766 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1767 ret = GetSupportTlvAndNeedAckById(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, nullptr, nullptr);
1768 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1769 }
1770
1771 /**
1772 * @tc.name: TransClientSessionManagerTest59
1773 * @tc.desc: ClientGetSessionStateByChannelId
1774 * @tc.type: FUNC
1775 * @tc.require:
1776 */
1777 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest59, TestSize.Level1)
1778 {
1779 int32_t channelId = TRANS_TEST_INVALID_CHANNEL_ID;
1780 int32_t channelType = CHANNEL_TYPE_TCP_DIRECT;
1781 SessionState sessionState;
1782 uint64_t timestamp = 0;
1783 int32_t ret = ClientGetSessionStateByChannelId(channelId, channelType, nullptr);
1784 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1785 channelId = TRANS_TEST_CHANNEL_ID;
1786 ret = ClientGetSessionStateByChannelId(channelId, channelType, &sessionState);
1787 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1788 channelType = CHANNEL_TYPE_BUTT;
1789 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1790 EXPECT_TRUE(sessionParam != nullptr);
1791 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1792 GenerateCommParam(sessionParam);
1793 SessionInfo *session = GenerateSession(sessionParam);
1794 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1795 EXPECT_EQ(ret, SOFTBUS_OK);
1796 session->channelId = TRANS_TEST_CHANNEL_ID;
1797 session->sessionId = TRANS_TEST_SESSION_ID;
1798 ret = ClientAddNewSession(g_sessionName, session);
1799 EXPECT_EQ(ret, SOFTBUS_OK);
1800 ret = ClientGetSessionStateByChannelId(channelId, channelType, &sessionState);
1801 EXPECT_EQ(ret, SOFTBUS_OK);
1802 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1803 EXPECT_EQ(ret, SOFTBUS_OK);
1804 SoftBusFree(sessionParam);
1805 }
1806
1807 /**
1808 * @tc.name: TransClientSessionManagerTest60
1809 * @tc.desc: ClientGetRouteTypeByChannelId
1810 * @tc.type: FUNC
1811 * @tc.require:
1812 */
1813 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest60, TestSize.Level1)
1814 {
1815 int32_t channelId = TRANS_TEST_INVALID_CHANNEL_ID;
1816 int32_t channelType = CHANNEL_TYPE_TCP_DIRECT;
1817 int32_t routeType = 0;
1818 uint64_t timestamp = 0;
1819 int32_t ret = ClientGetRouteTypeByChannelId(channelId, channelType, nullptr);
1820 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1821 channelId = TRANS_TEST_CHANNEL_ID;
1822 ret = ClientGetRouteTypeByChannelId(channelId, channelType, nullptr);
1823 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1824 ret = ClientGetRouteTypeByChannelId(channelId, channelType, &routeType);
1825 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1826 channelType = CHANNEL_TYPE_BUTT;
1827 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1828 EXPECT_TRUE(sessionParam != nullptr);
1829 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1830 GenerateCommParam(sessionParam);
1831 SessionInfo *session = GenerateSession(sessionParam);
1832 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1833 EXPECT_EQ(ret, SOFTBUS_OK);
1834 session->channelId = TRANS_TEST_CHANNEL_ID;
1835 session->sessionId = TRANS_TEST_SESSION_ID;
1836 ret = ClientAddNewSession(g_sessionName, session);
1837 EXPECT_EQ(ret, SOFTBUS_OK);
1838 ret = ClientGetRouteTypeByChannelId(channelId, channelType, &routeType);
1839 EXPECT_EQ(ret, SOFTBUS_OK);
1840 ClientTransOnUserSwitch();
1841 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1842 ClientCleanAllSessionWhenServerDeath(nullptr);
1843 EXPECT_EQ(ret, SOFTBUS_OK);
1844 SoftBusFree(sessionParam);
1845 }
1846
1847 /**
1848 * @tc.name: TransClientSessionManagerTest61
1849 * @tc.desc: ClientIpcOpenSession
1850 * @tc.type: FUNC
1851 * @tc.require:
1852 */
1853 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest61, TestSize.Level1)
1854 {
1855 int32_t sessionId = 0;
1856 uint32_t qosCount = 0;
1857 uint32_t maxWaitTime = 0;
1858 uint64_t timestamp = 0;
1859 int32_t ret = ClientAddSocketServer(SEC_TYPE_PLAINTEXT, nullptr, g_sessionName, ×tamp);
1860 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1861 ret = ClientAddSocketServer(SEC_TYPE_PLAINTEXT, g_pkgName, nullptr, ×tamp);
1862 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1863 ret = ClientAddSocketServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, nullptr);
1864 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1865 ret = ClientAddSocketSession(nullptr, true, &sessionId, nullptr);
1866 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1867 ret = ClientIpcOpenSession(sessionId, nullptr, qosCount, nullptr, true);
1868 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1869 sessionId = TRANS_TEST_INVALID_SESSION_ID;
1870 ret = ClientIpcOpenSession(sessionId, nullptr, qosCount, nullptr, true);
1871 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1872 ret = ClientHandleBindWaitTimer(TRANS_TEST_SESSION_ID, maxWaitTime, TIMER_ACTION_BUTT);
1873 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1874 }
1875
1876 /**
1877 * @tc.name: TransClientSessionManagerTest62
1878 * @tc.desc: ClientDfsIpcOpenSession
1879 * @tc.type: FUNC
1880 * @tc.require:
1881 */
1882 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest62, TestSize.Level1)
1883 {
1884 uint32_t maxIdleTimeout = 0;
1885 TransInfo transInfo;
1886 uint64_t timestamp = 0;
1887 int32_t ret = ClientSetSocketState(TRANS_TEST_INVALID_SESSION_ID, maxIdleTimeout, SESSION_ROLE_CLIENT);
1888 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1889 ret = ClientSetSocketState(TRANS_TEST_SESSION_ID, maxIdleTimeout, SESSION_ROLE_CLIENT);
1890 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1891 ret = ClientDfsIpcOpenSession(TRANS_TEST_INVALID_SESSION_ID, &transInfo);
1892 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1893 ret = ClientDfsIpcOpenSession(TRANS_TEST_SESSION_ID, nullptr);
1894 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1895 ret = ClientDfsIpcOpenSession(TRANS_TEST_SESSION_ID, &transInfo);
1896 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1897 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1898 EXPECT_TRUE(sessionParam != nullptr);
1899 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1900 GenerateCommParam(sessionParam);
1901 SessionInfo *session = GenerateSession(sessionParam);
1902 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1903 EXPECT_EQ(ret, SOFTBUS_OK);
1904 session->channelId = TRANS_TEST_CHANNEL_ID;
1905 session->sessionId = TRANS_TEST_SESSION_ID;
1906 ret = ClientAddNewSession(g_sessionName, session);
1907 EXPECT_EQ(ret, SOFTBUS_OK);
1908 ret = ClientDfsIpcOpenSession(TRANS_TEST_SESSION_ID, &transInfo);
1909 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1910 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1911 EXPECT_EQ(ret, SOFTBUS_OK);
1912 SessionListenerAdapter callbackAdapter;
1913 ret = ClientGetSessionCallbackAdapterByName(nullptr, &callbackAdapter);
1914 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1915 ret = ClientGetSessionCallbackAdapterByName(g_sessionName, nullptr);
1916 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1917 SoftBusFree(sessionParam);
1918 }
1919
1920 /**
1921 * @tc.name: TransClientSessionManagerTest63
1922 * @tc.desc: ClientGetPeerSocketInfoById
1923 * @tc.type: FUNC
1924 * @tc.require:
1925 */
1926 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest63, TestSize.Level1)
1927 {
1928 bool isServer = true;
1929 SessionListenerAdapter callbackAdapter;
1930 PeerSocketInfo peerSocketInfo;
1931 uint64_t timestamp = 0;
1932 int32_t ret = ClientGetSessionCallbackAdapterById(TRANS_TEST_INVALID_SESSION_ID, &callbackAdapter, &isServer);
1933 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1934 ret = ClientGetSessionCallbackAdapterById(TRANS_TEST_SESSION_ID, nullptr, &isServer);
1935 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1936 ret = ClientGetSessionCallbackAdapterById(TRANS_TEST_SESSION_ID, &callbackAdapter, &isServer);
1937 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1938 ret = ClientGetPeerSocketInfoById(TRANS_TEST_INVALID_SESSION_ID, &peerSocketInfo);
1939 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1940 ret = ClientGetPeerSocketInfoById(TRANS_TEST_SESSION_ID, nullptr);
1941 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1942 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1943 EXPECT_TRUE(sessionParam != nullptr);
1944 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1945 GenerateCommParam(sessionParam);
1946 SessionInfo *session = GenerateSession(sessionParam);
1947 session->channelId = TRANS_TEST_CHANNEL_ID;
1948 session->sessionId = TRANS_TEST_SESSION_ID;
1949 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1950 EXPECT_EQ(ret, SOFTBUS_OK);
1951 ret = ClientAddNewSession(g_sessionName, session);
1952 EXPECT_EQ(ret, SOFTBUS_OK);
1953 ret = ClientGetPeerSocketInfoById(TRANS_TEST_SESSION_ID, &peerSocketInfo);
1954 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1955 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1956 EXPECT_EQ(ret, SOFTBUS_OK);
1957 SoftBusFree(sessionParam);
1958 }
1959
1960 /**
1961 * @tc.name: TransClientSessionManagerTest64
1962 * @tc.desc: ClientDfsIpcOpenSession
1963 * @tc.type: FUNC
1964 * @tc.require:
1965 */
1966 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest64, TestSize.Level1)
1967 {
1968 int32_t len = sizeof(g_sessionName);
1969 char sessionName[] = {"ohos.distributedschedule.dms.test"};
1970 uint64_t timestamp = 0;
1971 int32_t ret = ClientResetIdleTimeoutById(TRANS_TEST_INVALID_SESSION_ID);
1972 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1973 ret = ClientResetIdleTimeoutById(TRANS_TEST_SESSION_ID);
1974 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1975 ret = ClientGetSessionNameByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT, sessionName, len);
1976 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1977 ret = ClientGetSessionNameByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT, nullptr, len);
1978 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1979 ret = ClientGetSessionNameByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT, sessionName, 0);
1980 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1981 ret = ClientGetSessionNameByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT, sessionName, len);
1982 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1983 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1984 EXPECT_TRUE(sessionParam != nullptr);
1985 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1986 GenerateCommParam(sessionParam);
1987 SessionInfo *session = GenerateSession(sessionParam);
1988 session->channelId = TRANS_TEST_CHANNEL_ID;
1989 session->sessionId = TRANS_TEST_SESSION_ID;
1990 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
1991 EXPECT_EQ(ret, SOFTBUS_OK);
1992 ret = ClientAddNewSession(g_sessionName, session);
1993 EXPECT_EQ(ret, SOFTBUS_OK);
1994 ret = ClientGetSessionNameByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, sessionName, len);
1995 EXPECT_EQ(ret, SOFTBUS_OK);
1996 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1997 EXPECT_EQ(ret, SOFTBUS_OK);
1998 SoftBusFree(sessionParam);
1999 }
2000
2001 /**
2002 * @tc.name: ClientSetLowLatencyBySocketTest65
2003 * @tc.desc: ClientSetLowLatencyBySocket
2004 * @tc.type: FUNC
2005 * @tc.require:
2006 */
2007 HWTEST_F(TransClientSessionManagerTest, ClientSetLowLatencyBySocketTest65, TestSize.Level1)
2008 {
2009 TransClientInit();
2010 uint64_t timestamp = 0;
2011 int32_t ret = ClientSetLowLatencyBySocket(0);
2012 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2013 ret = ClientSetLowLatencyBySocket(1);
2014 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
2015
2016 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
2017 EXPECT_EQ(ret, SOFTBUS_OK);
2018 SessionParam *sessionParam = (SessionParam *)SoftBusMalloc(sizeof(SessionParam));
2019 EXPECT_TRUE(sessionParam != nullptr);
2020 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
2021 GenerateCommParam(sessionParam);
2022 int32_t sessionId = 1;
2023 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
2024 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
2025 EXPECT_EQ(ret, SOFTBUS_OK);
2026 ret = ClientSetLowLatencyBySocket(sessionId);
2027 EXPECT_EQ(ret, SOFTBUS_OK);
2028
2029 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
2030 EXPECT_EQ(ret, SOFTBUS_OK);
2031 SoftBusFree(sessionParam);
2032 TransClientDeinit();
2033 }
2034
2035 /**
2036 * @tc.name: TransClientSessionManagerTest66
2037 * @tc.desc: Transmission sdk session manager get business type by channel id.
2038 * @tc.type: FUNC
2039 * @tc.require:
2040 */
2041 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest66, TestSize.Level1)
2042 {
2043 int32_t businessType = 0;
2044 int32_t ret = ClientGetChannelBusinessTypeByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, &businessType);
2045 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2046
2047 ret = ClientGetChannelBusinessTypeByChannelId(TRANS_TEST_CHANNEL_ID, nullptr);
2048 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
2049
2050 ret = ClientGetChannelBusinessTypeByChannelId(TRANS_TEST_CHANNEL_ID, &businessType);
2051 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
2052 }
2053 }