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