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);
71     void SetUp() override
72     {}
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(int32_t sessionId, int32_t result)94 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
95 {
96     TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
97     return SOFTBUS_OK;
98 }
99 
OnSessionClosed(int32_t sessionId)100 static void OnSessionClosed(int32_t sessionId)
101 {
102     TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
103 }
104 
OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)105 static void OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)
106 {
107     TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
108 }
109 
OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)110 static void OnMessageReceived(int32_t 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     int32_t 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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest01, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest02, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest03, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest04, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest05, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest06, TestSize.Level1)288 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest06, TestSize.Level1)
289 {
290     int32_t ret = 0;
291     for (int32_t 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 (int32_t 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  */
HWTEST_F(TransClientSessionManagerTest, TransClientAddSessionOutOfMaxTest01, TestSize.Level1)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 (int32_t 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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest07, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest08, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest09, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest10, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest11, TestSize.Level1)486 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest11, TestSize.Level1)
487 {
488     int32_t 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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest12, TestSize.Level1)499 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest12, TestSize.Level1)
500 {
501     int32_t 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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest13, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest14, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest15, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest16, TestSize.Level1)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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest17, TestSize.Level1)620 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest17, TestSize.Level1)
621 {
622     int32_t 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  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest18, TestSize.Level1)652 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest18, TestSize.Level1)
653 {
654     int32_t sessionId = 0;
655     bool isClosing = false;
656     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
657     EXPECT_EQ(ret,  SOFTBUS_OK);
658     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
659     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
660     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
661     EXPECT_TRUE(sessionParam != NULL);
662     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
663     GenerateCommParam(sessionParam);
664     SessionInfo *session = GenerateSession(sessionParam);
665     session->channelId = TRANS_TEST_CHANNEL_ID;
666     session->channelType = CHANNEL_TYPE_UDP;
667     ret = ClientAddNewSession(g_sessionName, session);
668     EXPECT_EQ(ret,  SOFTBUS_OK);
669     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
670     EXPECT_EQ(ret,  SOFTBUS_OK);
671     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
672     EXPECT_EQ(ret,  SOFTBUS_OK);
673     SoftBusFree(sessionParam);
674 }
675 
676 /**
677  * @tc.name: TransClientSessionManagerTest19
678  * @tc.desc: Transmission sdk session manager get enable session id by channel id.
679  * @tc.type: FUNC
680  * @tc.require:
681  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest19, TestSize.Level1)682 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest19, TestSize.Level1)
683 {
684     ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
685     EXPECT_TRUE(channel != NULL);
686     memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
687     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
688     EXPECT_EQ(ret,  SOFTBUS_OK);
689     int32_t sessionId = 0;
690     ret = ClientEnableSessionByChannelId(channel, &sessionId);
691     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
692     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
693     EXPECT_TRUE(sessionParam != NULL);
694     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
695     GenerateCommParam(sessionParam);
696     channel->channelId = 0;
697     channel->channelType = CHANNEL_TYPE_AUTH;
698     ret = ClientAddAuthSession(g_sessionName, &sessionId);
699     EXPECT_EQ(ret,  SOFTBUS_OK);
700     int32_t newSessionId = 0;
701     ret = ClientEnableSessionByChannelId(channel, &newSessionId);
702     EXPECT_EQ(ret,  SOFTBUS_MEM_ERR);
703     char deviceId[DEVICE_ID_SIZE_MAX] = {0};
704     ret = strcpy_s(deviceId, DEVICE_ID_SIZE_MAX, g_deviceId);
705     EXPECT_EQ(ret,  EOK);
706     channel->peerDeviceId = deviceId;
707     ret = ClientEnableSessionByChannelId(channel, &newSessionId);
708     EXPECT_EQ(ret,  SOFTBUS_OK);
709     EXPECT_EQ(sessionId,  newSessionId);
710     ret = ClientDeleteSession(sessionId);
711     EXPECT_EQ(ret, SOFTBUS_OK);
712     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
713     EXPECT_EQ(ret,  SOFTBUS_OK);
714     SoftBusFree(channel);
715     SoftBusFree(sessionParam);
716 }
717 
718 /**
719  * @tc.name: TransClientSessionManagerTest20
720  * @tc.desc: Transmission sdk session manager get enable session callback by session id.
721  * @tc.type: FUNC
722  * @tc.require:
723  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest20, TestSize.Level1)724 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest20, TestSize.Level1)
725 {
726     ISessionListener sessionlistener = {0};
727     int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
728     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
729     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
730     EXPECT_TRUE(sessionParam != NULL);
731     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
732     GenerateCommParam(sessionParam);
733     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
734     EXPECT_EQ(ret,  SOFTBUS_OK);
735     int32_t sessionId = 0;
736     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
737     ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
738     EXPECT_EQ(ret,  SOFTBUS_OK);
739     ret = ClientGetSessionCallbackById(sessionId, &sessionlistener);
740     EXPECT_EQ(ret,  SOFTBUS_OK);
741     EXPECT_EQ(sessionlistener.OnSessionOpened,  OnSessionOpened);
742     EXPECT_EQ(sessionlistener.OnSessionClosed,  OnSessionClosed);
743     EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
744     EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
745     ret = ClientDeleteSession(sessionId);
746     EXPECT_EQ(ret, SOFTBUS_OK);
747     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
748     EXPECT_EQ(ret,  SOFTBUS_OK);
749     SoftBusFree(sessionParam);
750 }
751 
752 /**
753  * @tc.name: TransClientSessionManagerTest21
754  * @tc.desc: Transmission sdk session manager get enable session callback by session name.
755  * @tc.type: FUNC
756  * @tc.require:
757  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest21, TestSize.Level1)758 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest21, TestSize.Level1)
759 {
760     ISessionListener sessionlistener = {0};
761     int32_t ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
762     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
763     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
764     EXPECT_EQ(ret,  SOFTBUS_OK);
765     char pkgName[] = {"dms1"};
766     char sessionName[] = {"ohos.distributedschedule.dms.test1"};
767     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, pkgName, sessionName, &g_sessionlistener);
768     EXPECT_EQ(ret,  SOFTBUS_OK);
769     ret = ClientGetSessionCallbackByName(sessionName, &sessionlistener);
770     EXPECT_EQ(ret,  SOFTBUS_OK);
771     EXPECT_EQ(sessionlistener.OnSessionOpened,  OnSessionOpened);
772     EXPECT_EQ(sessionlistener.OnSessionClosed,  OnSessionClosed);
773     EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
774     EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
775     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
776     EXPECT_EQ(ret,  SOFTBUS_OK);
777     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
778     EXPECT_EQ(ret,  SOFTBUS_OK);
779 }
780 
781 /**
782  * @tc.name: TransClientSessionManagerTest22
783  * @tc.desc: Transmission sdk session manager get session side by session id.
784  * @tc.type: FUNC
785  * @tc.require:
786  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest22, TestSize.Level1)787 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest22, TestSize.Level1)
788 {
789     int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
790     EXPECT_NE(ret,  SOFTBUS_OK);
791     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
792     EXPECT_EQ(ret,  SOFTBUS_OK);
793     int32_t sessionId = 0;
794     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
795     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
796     EXPECT_TRUE(sessionParam != NULL);
797     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
798     GenerateCommParam(sessionParam);
799     ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
800     EXPECT_EQ(ret,  SOFTBUS_OK);
801     char sessionName[] = {"ohos.distributedschedule.dms.test1"};
802     char groupId[] = {"TEST_GROUP_ID1"};
803     char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
804     sessionParam->groupId = groupId;
805     sessionParam->peerSessionName = sessionName;
806     sessionParam->peerDeviceId = deviceId;
807     int32_t newSessionId = 0;
808     ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
809     EXPECT_EQ(ret,  SOFTBUS_OK);
810     ret = ClientGetSessionSide(sessionId);
811     EXPECT_EQ(ret,  IS_CLIENT);
812     ret = ClientGetSessionSide(newSessionId);
813     EXPECT_EQ(ret,  IS_CLIENT);
814     ret = ClientDeleteSession(sessionId);
815     EXPECT_EQ(ret, SOFTBUS_OK);
816     ret = ClientDeleteSession(newSessionId);
817     EXPECT_EQ(ret, SOFTBUS_OK);
818     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
819     EXPECT_EQ(ret,  SOFTBUS_OK);
820     SoftBusFree(sessionParam);
821 }
822 
823 /**
824  * @tc.name: TransClientSessionManagerTest23
825  * @tc.desc: Transmission sdk session manager grant permission and remove permission with invalid parameters.
826  * @tc.type: FUNC
827  * @tc.require:
828  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest23, TestSize.Level1)829 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest23, TestSize.Level1)
830 {
831     int32_t ret = ClientGrantPermission(TRANS_TEST_INVALID_UID, TRANS_TEST_PID, g_sessionName);
832     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
833     ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_INVALID_PID, g_sessionName);
834     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
835     ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_PID, NULL);
836     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
837     ret = ClientRemovePermission(NULL);
838     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
839 }
840 
841 /**
842  * @tc.name: TransClientSessionManagerTest24
843  * @tc.desc: Transmission sdk session manager get file config by session.
844  * @tc.type: FUNC
845  * @tc.require:
846  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest24, TestSize.Level1)847 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest24, TestSize.Level1)
848 {
849     int32_t fileEncrypt = 0;
850     int32_t algorithm = 0;
851     int32_t crc = 0;
852     bool isClosing = false;
853     int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
854     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
855     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
856     EXPECT_EQ(ret,  SOFTBUS_OK);
857     int32_t sessionId = 0;
858     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
859     EXPECT_TRUE(sessionParam != NULL);
860     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
861     GenerateCommParam(sessionParam);
862     SessionInfo *session = GenerateSession(sessionParam);
863     session->channelId = TRANS_TEST_CHANNEL_ID;
864     session->channelType = CHANNEL_TYPE_UDP;
865     ret = ClientAddNewSession(g_sessionName, session);
866     EXPECT_EQ(ret,  SOFTBUS_OK);
867     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
868     EXPECT_EQ(ret,  SOFTBUS_OK);
869     ret = ClientGetFileConfigInfoById(sessionId, &fileEncrypt, &algorithm, &crc);
870     EXPECT_EQ(ret,  SOFTBUS_OK);
871     EXPECT_EQ(TRANS_TEST_FILE_ENCRYPT, fileEncrypt);
872     EXPECT_EQ(TRANS_TEST_ALGORITHM, algorithm);
873     EXPECT_EQ(TRANS_TEST_CRC, crc);
874     ret = ClientDeleteSession(sessionId);
875     EXPECT_EQ(ret, SOFTBUS_OK);
876     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
877     EXPECT_EQ(ret,  SOFTBUS_OK);
878     SoftBusFree(sessionParam);
879 }
880 
881 /**
882  * @tc.name: TransClientSessionManagerTest25
883  * @tc.desc: Transmission sdk session manager recreate session server to server.
884  * @tc.type: FUNC
885  * @tc.require:
886  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest25, TestSize.Level1)887 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest25, TestSize.Level1)
888 {
889     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
890     EXPECT_EQ(ret,  SOFTBUS_OK);
891 
892     ret = ReCreateSessionServerToServer(NULL);
893     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
894 
895     ListNode sessionServerList;
896     ListInit(&sessionServerList);
897     ret = ReCreateSessionServerToServer(&sessionServerList);
898     EXPECT_EQ(ret,  SOFTBUS_OK);
899 
900     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
901     EXPECT_EQ(ret,  SOFTBUS_OK);
902 
903     SessionServerInfo *infoNode = NULL;
904     SessionServerInfo *infoNodeNext = NULL;
905     LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
906         ListDelete(&infoNode->node);
907         SoftBusFree(infoNode);
908     }
909 }
910 
911 /**
912  * @tc.name: TransClientSessionManagerTest26
913  * @tc.desc: Transmission sdk session manager clear list on link down.
914  * @tc.type: FUNC
915  * @tc.require:
916  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest26, TestSize.Level1)917 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest26, TestSize.Level1)
918 {
919     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
920     EXPECT_EQ(ret,  SOFTBUS_OK);
921     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
922     EXPECT_TRUE(sessionParam != NULL);
923     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
924     GenerateCommParam(sessionParam);
925     SessionInfo *session = GenerateSession(sessionParam);
926     session->channelId = TRANS_TEST_CHANNEL_ID;
927     session->channelType = CHANNEL_TYPE_UDP;
928     ret = ClientAddNewSession(g_sessionName, session);
929     EXPECT_EQ(ret,  SOFTBUS_OK);
930     ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
931     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
932     EXPECT_EQ(ret,  SOFTBUS_OK);
933 }
934 
935 /**
936  * @tc.name: TransClientSessionManagerTest27
937  * @tc.desc: Transmission sdk session manager clear all session when server death.
938  * @tc.type: FUNC
939  * @tc.require:
940  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest27, TestSize.Level1)941 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest27, TestSize.Level1)
942 {
943     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
944     EXPECT_EQ(ret,  SOFTBUS_OK);
945 
946     ListNode sessionServerList;
947     ListInit(&sessionServerList);
948     ClientCleanAllSessionWhenServerDeath(&sessionServerList);
949     SessionServerInfo *infoNode = NULL;
950     SessionServerInfo *infoNodeNext = NULL;
951     LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
952         ListDelete(&infoNode->node);
953         SoftBusFree(infoNode);
954     }
955 
956     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
957     EXPECT_TRUE(sessionParam != NULL);
958     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
959     GenerateCommParam(sessionParam);
960     SessionInfo *session = GenerateSession(sessionParam);
961     session->channelId = TRANS_TEST_CHANNEL_ID;
962     session->channelType = CHANNEL_TYPE_UDP;
963     ret = ClientAddNewSession(g_sessionName, session);
964     EXPECT_EQ(ret,  SOFTBUS_OK);
965 
966     ClientCleanAllSessionWhenServerDeath(&sessionServerList);
967     infoNode = NULL;
968     infoNodeNext = NULL;
969     LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
970         ListDelete(&infoNode->node);
971         SoftBusFree(infoNode);
972     }
973 
974     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
975     EXPECT_EQ(ret,  SOFTBUS_OK);
976 }
977 
978 /**
979  * @tc.name: TransClientSessionManagerTest28
980  * @tc.desc: Transmission sdk session manager permission state change.
981  * @tc.type: FUNC
982  * @tc.require:
983  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest28, TestSize.Level1)984 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest28, TestSize.Level1)
985 {
986     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
987     EXPECT_EQ(ret,  SOFTBUS_OK);
988     PermissionStateChange(g_pkgName, TRANS_TEST_STATE);
989     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
990     EXPECT_EQ(ret,  SOFTBUS_OK);
991 }
992 
993 /**
994  * @tc.name: TransClientSessionDestroyTest01
995  * @tc.desc: Transmission sdk session manager destroy session by network id.
996  * @tc.type: FUNC
997  * @tc.require:
998  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionDestroyTest01, TestSize.Level1)999 HWTEST_F(TransClientSessionManagerTest, TransClientSessionDestroyTest01, TestSize.Level1)
1000 {
1001     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1002     ASSERT_EQ(ret, SOFTBUS_OK);
1003     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1004     ASSERT_TRUE(sessionParam != NULL);
1005     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1006     GenerateCommParam(sessionParam);
1007     SessionInfo *session = GenerateSession(sessionParam);
1008     ASSERT_TRUE(session != NULL);
1009     session->channelId = TRANS_TEST_CHANNEL_ID;
1010     session->channelType = CHANNEL_TYPE_UDP;
1011     session->routeType = WIFI_STA;
1012     ret = ClientAddNewSession(g_sessionName, session);
1013     ASSERT_EQ(ret, SOFTBUS_OK);
1014     sessionParam->peerDeviceId = g_networkId;
1015     SessionInfo *newSession = GenerateSession(sessionParam);
1016     ASSERT_TRUE(newSession != NULL);
1017     newSession->channelId = TRANS_TEST_CHANNEL_ID + 1;
1018     newSession->channelType = CHANNEL_TYPE_UDP;
1019     newSession->routeType = WIFI_P2P;
1020     ret = ClientAddNewSession(g_sessionName, newSession);
1021     ASSERT_EQ(ret, SOFTBUS_OK);
1022     ClientTransOnLinkDown(g_networkId, WIFI_STA);
1023     int32_t sessionId = 0;
1024     bool isClosing = false;
1025     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1026     EXPECT_EQ(ret, SOFTBUS_OK);
1027     EXPECT_GT(sessionId, 0);
1028     ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
1029     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1030     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1031     ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
1032     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1033     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1034     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1035     EXPECT_EQ(ret, SOFTBUS_OK);
1036     SoftBusFree(sessionParam);
1037 }
1038 
1039 /**
1040  * @tc.name: TransClientSessionIsAsyncTest01
1041  * @tc.desc: Session IsAsync param tests.
1042  * @tc.type: FUNC
1043  * @tc.require:
1044  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionIsAsyncTest01, TestSize.Level1)1045 HWTEST_F(TransClientSessionManagerTest, TransClientSessionIsAsyncTest01, TestSize.Level1)
1046 {
1047     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1048     ASSERT_EQ(ret, SOFTBUS_OK);
1049     SessionParam *sessionParam = (SessionParam *)SoftBusMalloc(sizeof(SessionParam));
1050     ASSERT_TRUE(sessionParam != NULL);
1051     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1052     GenerateCommParam(sessionParam);
1053     SessionInfo *session = GenerateSession(sessionParam);
1054     ASSERT_TRUE(session != NULL);
1055     ret = ClientAddNewSession(g_sessionName, session);
1056     session->sessionId = 1;
1057     ASSERT_EQ(ret, SOFTBUS_OK);
1058     sessionParam->isAsync = true;
1059     SessionInfo *newSession = GenerateSession(sessionParam);
1060     ret = ClientAddNewSession(g_sessionName, newSession);
1061     ASSERT_EQ(ret, SOFTBUS_OK);
1062     newSession->sessionId = 2;
1063     bool isAsync = false;
1064     ClientGetSessionIsAsyncBySessionId(2, &isAsync);
1065     ASSERT_EQ(isAsync, true);
1066     ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1067     ASSERT_EQ(isAsync, false);
1068     SetSessionIsAsyncById(1, true);
1069     ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1070     ASSERT_EQ(isAsync, true);
1071     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1072     EXPECT_EQ(ret, SOFTBUS_OK);
1073     SoftBusFree(sessionParam);
1074 }
1075 
1076 /**
1077  * @tc.name: ClientTransSetChannelInfoTest01
1078  * @tc.desc: Session IsAsync param tests.
1079  * @tc.type: FUNC
1080  * @tc.require:
1081  */
HWTEST_F(TransClientSessionManagerTest, ClientTransSetChannelInfoTest01, TestSize.Level1)1082 HWTEST_F(TransClientSessionManagerTest, ClientTransSetChannelInfoTest01, TestSize.Level1)
1083 {
1084     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1085     ASSERT_EQ(ret, SOFTBUS_OK);
1086     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1087     ASSERT_TRUE(sessionParam != NULL);
1088     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1089     GenerateCommParam(sessionParam);
1090     SessionInfo *session = GenerateSession(sessionParam);
1091     ASSERT_TRUE(session != NULL);
1092     session->channelId = TRANS_TEST_CHANNEL_ID;
1093     session->channelType = CHANNEL_TYPE_PROXY;
1094     session->routeType = WIFI_STA;
1095     ret = ClientAddNewSession(g_sessionName, session);
1096     session->sessionId = 1;
1097     ASSERT_EQ(ret, SOFTBUS_OK);
1098     ret = ClientTransSetChannelInfo(g_sessionName, 1, 11, CHANNEL_TYPE_TCP_DIRECT);
1099     ASSERT_EQ(ret, SOFTBUS_OK);
1100     int32_t channelId = INVALID_CHANNEL_ID;
1101     int32_t ChannelType = CHANNEL_TYPE_BUTT;
1102     ClientGetChannelBySessionId(1, &channelId, &ChannelType, NULL);
1103     ASSERT_EQ(channelId, 11);
1104     ASSERT_EQ(ChannelType, CHANNEL_TYPE_TCP_DIRECT);
1105     char sessionName[SESSION_NAME_SIZE_MAX];
1106     SocketLifecycleData lifecycle;
1107     ret = GetSocketLifecycleAndSessionNameBySessionId(1, sessionName, &lifecycle);
1108     ASSERT_EQ(ret, SOFTBUS_OK);
1109     ASSERT_EQ(lifecycle.sessionState, SESSION_STATE_OPENED);
1110     ret = SetSessionStateBySessionId(1, SESSION_STATE_CANCELLING, 0);
1111     ASSERT_EQ(ret, SOFTBUS_OK);
1112     ret = GetSocketLifecycleAndSessionNameBySessionId(1, sessionName, &lifecycle);
1113     ASSERT_EQ(ret, SOFTBUS_OK);
1114     ASSERT_EQ(lifecycle.sessionState, SESSION_STATE_CANCELLING);
1115     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1116     EXPECT_EQ(ret, SOFTBUS_OK);
1117     SoftBusFree(sessionParam);
1118 }
1119 
1120 /**
1121  * @tc.name: TransClientSessionManagerTest29
1122  * @tc.desc: Transmission sdk session manager add and delete server with invalid parameters no initialize.
1123  * @tc.type: FUNC
1124  * @tc.require:
1125  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest29, TestSize.Level1)1126 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest29, TestSize.Level1)
1127 {
1128     TransClientDeinit();
1129     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, NULL, g_sessionName, &g_sessionlistener);
1130     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1131     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
1132     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1133     ret = ClientDeleteSessionServer(SEC_TYPE_UNKNOWN, g_sessionName);
1134     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1135     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1136     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1137     ret = ClientDeleteSession(TRANS_TEST_INVALID_SESSION_ID);
1138     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1139     ret = ClientDeleteSession(TRANS_TEST_SESSION_ID);
1140     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1141 }
1142 
1143 
1144 /**
1145  * @tc.name: TransClientSessionManagerTest30
1146  * @tc.desc: Transmission sdk session manager add new auth session with invalid parameters no initialize.
1147  * @tc.type: FUNC
1148  * @tc.require:
1149  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest30, TestSize.Level1)1150 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest30, TestSize.Level1)
1151 {
1152     int32_t sessionId = 0;
1153     int32_t ret = ClientAddAuthSession(NULL, &sessionId);
1154     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1155     ret = ClientAddAuthSession(g_sessionName, &sessionId);
1156     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1157 }
1158 
1159 /**
1160  * @tc.name: TransClientSessionManagerTest31
1161  * @tc.desc: Transmission sdk session manager add new session no initialize.
1162  * @tc.type: FUNC
1163  * @tc.require:
1164  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest31, TestSize.Level1)1165 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest31, TestSize.Level1)
1166 {
1167     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1168     EXPECT_TRUE(sessionParam != NULL);
1169     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1170     GenerateCommParam(sessionParam);
1171     SessionInfo *session = GenerateSession(sessionParam);
1172     int32_t ret = ClientAddNewSession(g_sessionName, NULL);
1173     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1174     ret = ClientAddNewSession(g_sessionName, session);
1175     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1176     SoftBusFree(sessionParam);
1177 }
1178 
1179 /**
1180  * @tc.name: TransClientSessionManagerTest32
1181  * @tc.desc: Transmission sdk session manager get session Integer data by session id no initialize.
1182  * @tc.type: FUNC
1183  * @tc.require:
1184  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest32, TestSize.Level1)1185 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest32, TestSize.Level1)
1186 {
1187     int32_t data = 0;
1188     int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_INVALID_SESSION_ID, &data, KEY_PEER_PID);
1189     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1190     ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, NULL, KEY_PEER_PID);
1191     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1192     ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
1193     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1194 }
1195 
1196 /**
1197  * @tc.name: TransClientSessionManagerTest33
1198  * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters no initialize.
1199  * @tc.type: FUNC
1200  * @tc.require:
1201  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest33, TestSize.Level1)1202 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest33, TestSize.Level1)
1203 {
1204     TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
1205     EXPECT_TRUE(transInfo != NULL);
1206     memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
1207     transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1208     transInfo->channelType = CHANNEL_TYPE_UDP;
1209     int32_t ret = ClientSetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, transInfo);
1210     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1211     transInfo->channelId = TRANS_TEST_INVALID_CHANNEL_ID;
1212     ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1213     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1214     transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1215     ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1216     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1217     SoftBusFree(transInfo);
1218 }
1219 
1220 /**
1221  * @tc.name: TransClientSessionManagerTest34
1222  * @tc.desc: Transmission sdk session manager get channel business type by session id no initialize.
1223  * @tc.type: FUNC
1224  * @tc.require:
1225  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest34, TestSize.Level1)1226 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest34, TestSize.Level1)
1227 {
1228     int32_t businessType = 0;
1229     int32_t ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_INVALID_SESSION_ID, &businessType);
1230     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1231     ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
1232     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1233 }
1234 
1235 /**
1236  * @tc.name: TransClientSessionManagerTest35
1237  * @tc.desc: Transmission sdk session manager get encrypt by channel id with invalid parameters.
1238  * @tc.type: FUNC
1239  * @tc.require:
1240  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest35, TestSize.Level1)1241 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest35, TestSize.Level1)
1242 {
1243     int32_t data = 0;
1244     int32_t ret = GetEncryptByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1245     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1246     ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, NULL);
1247     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1248     ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1249     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1250 }
1251 
1252 /**
1253  * @tc.name: TransClientSessionManagerTest36
1254  * @tc.desc: Transmission sdk session manager get session id by channel id with invalid parameters.
1255  * @tc.type: FUNC
1256  * @tc.require:
1257  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest36, TestSize.Level1)1258 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest36, TestSize.Level1)
1259 {
1260     int32_t sessionId = 0;
1261     bool isClosing = false;
1262     int32_t ret = ClientGetSessionIdByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1263     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1264     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, NULL, isClosing);
1265     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1266     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
1267     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1268     char data[SESSION_NAME_SIZE_MAX] = {0};
1269     ret = ClientGetSessionDataById(TRANS_TEST_SESSION_ID, data, SESSION_NAME_SIZE_MAX, KEY_PEER_SESSION_NAME);
1270     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1271 }
1272 
1273 /**
1274  * @tc.name: TransClientSessionManagerTest37
1275  * @tc.desc: Transmission sdk session manager get enable session id by channel id with invalid parameters.
1276  * @tc.type: FUNC
1277  * @tc.require:
1278  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest37, TestSize.Level1)1279 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest37, TestSize.Level1)
1280 {
1281     ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
1282     EXPECT_TRUE(channel != NULL);
1283     memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
1284     int32_t sessionId = 0;
1285     int32_t ret = ClientEnableSessionByChannelId(NULL, &sessionId);
1286     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1287     ret = ClientEnableSessionByChannelId(channel, NULL);
1288     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1289     ret = ClientEnableSessionByChannelId(channel, &sessionId);
1290     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1291     SoftBusFree(channel);
1292 }
1293 
1294 /**
1295  * @tc.name: TransClientSessionManagerTest38
1296  * @tc.desc: Transmission sdk session manager get enable session callback by session id with invalid parameters.
1297  * @tc.type: FUNC
1298  * @tc.require:
1299  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest38, TestSize.Level1)1300 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest38, TestSize.Level1)
1301 {
1302     ISessionListener sessionlistener = {0};
1303     int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_INVALID_SESSION_ID, &sessionlistener);
1304     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1305     ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, NULL);
1306     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1307     ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
1308     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1309 }
1310 
1311 /**
1312  * @tc.name: TransClientSessionManagerTest39
1313  * @tc.desc: Transmission sdk session manager get enable session callback by session name with invalid parameters.
1314  * @tc.type: FUNC
1315  * @tc.require:
1316  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest39, TestSize.Level1)1317 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest39, TestSize.Level1)
1318 {
1319     ISessionListener sessionlistener = {0};
1320     int32_t ret = ClientGetSessionCallbackByName(NULL, &sessionlistener);
1321     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1322     ret = ClientGetSessionCallbackByName(g_sessionName, NULL);
1323     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1324     ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
1325     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1326 }
1327 
1328 /**
1329  * @tc.name: TransClientSessionManagerTest40
1330  * @tc.desc: Transmission sdk session manager get side by session id with invalid parameters.
1331  * @tc.type: FUNC
1332  * @tc.require:
1333  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest40, TestSize.Level1)1334 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest40, TestSize.Level1)
1335 {
1336     int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
1337     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1338 }
1339 
1340 /**
1341  * @tc.name: TransClientSessionManagerTest41
1342  * @tc.desc: Transmission sdk session manager get file config by session id with invalid parameters.
1343  * @tc.type: FUNC
1344  * @tc.require:
1345  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest41, TestSize.Level1)1346 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest41, TestSize.Level1)
1347 {
1348     int32_t fileEncrypt = 0;
1349     int32_t algorithm = 0;
1350     int32_t crc = 0;
1351     int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_INVALID_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1352     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1353     ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, NULL, &algorithm, &crc);
1354     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1355     ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, NULL, &crc);
1356     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1357     ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, NULL);
1358     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1359     ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1360     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1361     ret = CheckPermissionState(TRANS_TEST_SESSION_ID);
1362     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1363 }
1364 
1365 /**
1366  * @tc.name: TransClientSessionManagerTest42
1367  * @tc.desc: Transmission sdk session manager operate no initialize.
1368  * @tc.type: FUNC
1369  * @tc.require:
1370  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest42, TestSize.Level1)1371 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest42, TestSize.Level1)
1372 {
1373     ListNode sessionServerList;
1374     ListInit(&sessionServerList);
1375     int32_t ret = ReCreateSessionServerToServer(&sessionServerList);
1376     EXPECT_EQ(ret,  SOFTBUS_OK);
1377     ClientTransOnLinkDown(NULL, ROUTE_TYPE_ALL);
1378     ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
1379 
1380     ClientCleanAllSessionWhenServerDeath(&sessionServerList);
1381     SessionServerInfo *infoNode = NULL;
1382     SessionServerInfo *infoNodeNext = NULL;
1383     LIST_FOR_EACH_ENTRY_SAFE(infoNode, infoNodeNext, &(sessionServerList), SessionServerInfo, node) {
1384         ListDelete(&infoNode->node);
1385         SoftBusFree(infoNode);
1386     }
1387 
1388     PermissionStateChange(g_pkgName, 0);
1389 }
1390 
1391 /**
1392  * @tc.name: TransClientSessionManagerTest43
1393  * @tc.desc: Transmission sdk session manager get encrypt option by session name.
1394  * @tc.type: FUNC
1395  * @tc.require:
1396  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest43, TestSize.Level1)1397 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest43, TestSize.Level1)
1398 {
1399     int32_t ret = ClientRawStreamEncryptDefOptGet(nullptr, nullptr);
1400     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1401 
1402     ret = ClientRawStreamEncryptDefOptGet(g_sessionName, nullptr);
1403     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1404 
1405     bool isEncrypt = false;
1406     ret = ClientRawStreamEncryptDefOptGet(nullptr, &isEncrypt);
1407     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1408 
1409     ret = ClientRawStreamEncryptDefOptGet(g_sessionName, &isEncrypt);
1410     ASSERT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1411 }
1412 
1413 /**
1414  * @tc.name: TransClientSessionManagerTest44
1415  * @tc.desc: Transmission sdk session manager get encrypt option by channelId.
1416  * @tc.type: FUNC
1417  * @tc.require:
1418  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest44, TestSize.Level1)1419 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest44, TestSize.Level1)
1420 {
1421     bool isEncrypt = false;
1422     int32_t ret = ClientRawStreamEncryptOptGet(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &isEncrypt);
1423     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1424 
1425     ret = ClientRawStreamEncryptOptGet(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, nullptr);
1426     ASSERT_EQ(ret, SOFTBUS_INVALID_PARAM);
1427 
1428     ret = ClientRawStreamEncryptOptGet(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &isEncrypt);
1429     ASSERT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1430 }
1431 
1432 /**
1433  * @tc.name: TransClientSessionManagerTest45
1434  * @tc.desc: Call isAsync functions when g_clientSessionServerList no initialize.
1435  * @tc.type: FUNC
1436  * @tc.require:
1437  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest45, TestSize.Level1)1438 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest45, TestSize.Level1)
1439 {
1440     int32_t ret = SetSessionIsAsyncById(1, true);
1441     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1442     ret = SetSessionIsAsyncById(-1, true);
1443     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1444     ret = ClientTransSetChannelInfo(g_sessionName, 1, 1, CHANNEL_TYPE_AUTH);
1445     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1446     ret = ClientTransSetChannelInfo(NULL, 1, 1, 1);
1447     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1448     bool isAsync = false;
1449     ret = ClientGetSessionIsAsyncBySessionId(1, &isAsync);
1450     EXPECT_EQ(ret,  SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1451     ret = ClientGetSessionIsAsyncBySessionId(-1, &isAsync);
1452     EXPECT_EQ(ret,  SOFTBUS_INVALID_PARAM);
1453 }
1454 
1455 /**
1456  * @tc.name: TransClientSessionManagerTest46
1457  * @tc.desc: Call ClientHandleBindWaitTimer for invalid param.
1458  * @tc.type: FUNC
1459  * @tc.require:
1460  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest46, TestSize.Level1)1461 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest46, TestSize.Level1)
1462 {
1463     int32_t ret = ClientHandleBindWaitTimer(-1, 0, TIMER_ACTION_STOP);
1464     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1465 
1466     ret = ClientHandleBindWaitTimer(1, 0, TIMER_ACTION_STOP);
1467     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1468 }
1469 
1470 /**
1471  * @tc.name: TransClientSessionManagerTest47
1472  * @tc.desc: Call GetQosValue SUCCESS.
1473  * @tc.type: FUNC
1474  * @tc.require:
1475  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest47, TestSize.Level1)1476 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest47, TestSize.Level1)
1477 {
1478     QosTV qos[] = {
1479         {.qos = QOS_TYPE_MAX_WAIT_TIMEOUT, .value = TRANS_TEST_MAX_WAIT_TIMEOUT},
1480         {.qos = QOS_TYPE_MAX_IDLE_TIMEOUT, .value = 0},
1481     };
1482     int32_t maxWaitTimeout = 0;
1483     int32_t ret = GetQosValue(
1484         qos, sizeof(qos) / sizeof(qos[0]), QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1485     EXPECT_EQ(ret, SOFTBUS_OK);
1486     EXPECT_EQ(maxWaitTimeout, TRANS_TEST_MAX_WAIT_TIMEOUT);
1487 }
1488 
1489 /**
1490  * @tc.name: TransClientSessionManagerTest48
1491  * @tc.desc: Call GetQosValue default value.
1492  * @tc.type: FUNC
1493  * @tc.require:
1494  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest48, TestSize.Level1)1495 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest48, TestSize.Level1)
1496 {
1497     QosTV qos[] = {
1498         { .qos = QOS_TYPE_MAX_IDLE_TIMEOUT, .value = 0                          },
1499     };
1500     int32_t maxWaitTimeout = 0;
1501     int32_t ret = GetQosValue(
1502         qos, sizeof(qos) / sizeof(qos[0]), QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1503     EXPECT_EQ(ret, SOFTBUS_OK);
1504     EXPECT_EQ(maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1505 
1506     ret = GetQosValue(
1507         NULL, 0, QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1508     EXPECT_EQ(ret, SOFTBUS_OK);
1509     EXPECT_EQ(maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1510 }
1511 
1512 /**
1513  * @tc.name: TransClientSessionManagerTest49
1514  * @tc.desc: Call GetQosValue FAIL.
1515  * @tc.type: FUNC
1516  * @tc.require:
1517  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest49, TestSize.Level1)1518 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest49, TestSize.Level1)
1519 {
1520     int32_t maxWaitTimeout = 0;
1521     int32_t ret = GetQosValue(
1522         NULL, 1, QOS_TYPE_MAX_WAIT_TIMEOUT, &maxWaitTimeout, TRANS_TEST_DEF_WAIT_TIMEOUT);
1523     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1524 }
1525 
1526 /**
1527  * @tc.name: TransClientSessionManagerTest50
1528  * @tc.desc: Call ClientWaitSyncBind for invalid param..
1529  * @tc.type: FUNC
1530  * @tc.require:
1531  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest50, TestSize.Level1)1532 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest50, TestSize.Level1)
1533 {
1534     int32_t ret = ClientWaitSyncBind(-1);
1535     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1536 
1537     ret = ClientWaitSyncBind(1);
1538     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1539 }
1540 
1541 /**
1542  * @tc.name: TransClientSessionManagerTest51
1543  * @tc.desc: Call ClientWaitSyncBind for invalid param..
1544  * @tc.type: FUNC
1545  * @tc.require:
1546  */
HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest51, TestSize.Level1)1547 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest51, TestSize.Level1)
1548 {
1549     int32_t ret = ClientSignalSyncBind(-1, 0);
1550     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
1551 
1552     ret = ClientSignalSyncBind(1, 0);
1553     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1554 }
1555 }