1 /*
2  * Copyright (c) 2022 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_json_utils.h"
23 #include "softbus_app_info.h"
24 #include "softbus_server_frame.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_config_type.h"
27 #include "client_trans_session_manager.h"
28 #include "client_trans_socket_manager.h"
29 #include "client_trans_session_service.h"
30 #include "client_trans_session_service.c"
31 #include "client_trans_session_manager.c"
32 #include "client_trans_socket_manager.c"
33 #include "softbus_access_token_test.h"
34 #include "softbus_common.h"
35 #include "token_setproc.h"
36 #include "trans_log.h"
37 #include "softbus_feature_config.h"
38 #include "softbus_conn_interface.h"
39 #include "auth_interface.h"
40 #include "bus_center_manager.h"
41 #include "trans_session_service.h"
42 
43 #define TRANS_TEST_SESSION_ID 10
44 #define TRANS_TEST_CHANNEL_ID 1000
45 #define TRANS_TEST_DEVICE_TYPE_ID 3
46 #define TRANS_TEST_FILE_ENCRYPT 10
47 #define TRANS_TEST_ALGORITHM 1
48 #define TRANS_TEST_CRC 1
49 #define TRANS_TEST_AUTH_DATA "test auth message data"
50 #define TRANS_TEST_CONN_IP "192.168.8.1"
51 #define TRANS_TEST_BR_MAC "11:22:33:44:55:66"
52 #define TRANS_TEST_AUTH_PORT 60000
53 #define TRANS_TEST_ADDR_INFO_NUM 2
54 #define TRANS_TEST_MAX_LENGTH 1024
55 #define TRANS_TEST_INVALID_SESSION_ID (-1)
56 #define TRANS_TEST_INVALID_VALUE_SIZE 8
57 #define HAP_TOKENID 123456
58 #define NATIVE_TOKENID 134341184
59 using namespace testing::ext;
60 
61 namespace OHOS {
62 
63 const char *g_pkgName = "dms";
64 const char *g_sessionName = "ohos.distributedschedule.dms.test";
65 const char *g_sessionKey = "www.huaweitest.com";
66 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
67 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
68 const char *g_groupId = "TEST_GROUP_ID";
69 const char *g_deviceName = "rk3568test";
70 const char *g_rootDir = "/data";
71 const char *NEW_SESSION_NAME = "ohos.test.distributedschedule.dms.test";
72 static SessionAttribute g_sessionAttr = {
73     .dataType = TYPE_BYTES,
74 };
75 class TransClientSessionTest : public testing::Test {
76 public:
TransClientSessionTest()77     TransClientSessionTest()
78     {}
~TransClientSessionTest()79     ~TransClientSessionTest()
80     {}
81     static void SetUpTestCase(void);
82     static void TearDownTestCase(void);
SetUp()83     void SetUp() override
84     {}
TearDown()85     void TearDown() override
86     {}
87 };
88 
SetUpTestCase(void)89 void TransClientSessionTest::SetUpTestCase(void)
90 {
91     SoftbusConfigInit();
92     ConnServerInit();
93     AuthInit();
94     BusCenterServerInit();
95     TransServerInit();
96     SetAceessTokenPermission("dsoftbusTransTest");
97     int32_t ret = TransClientInit();
98     ASSERT_EQ(ret,  SOFTBUS_OK);
99 }
100 
TearDownTestCase(void)101 void TransClientSessionTest::TearDownTestCase(void)
102 {
103     ConnServerDeinit();
104     AuthDeinit();
105     BusCenterServerDeinit();
106     TransServerDeinit();
107 }
108 
OnSessionOpened(int sessionId,int result)109 static int OnSessionOpened(int sessionId, int result)
110 {
111     TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
112     return SOFTBUS_OK;
113 }
114 
OnSessionClosed(int sessionId)115 static void OnSessionClosed(int sessionId)
116 {
117     TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
118 }
119 
OnBytesReceived(int sessionId,const void * data,unsigned int len)120 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
121 {
122     TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
123 }
124 
OnMessageReceived(int sessionId,const void * data,unsigned int len)125 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
126 {
127     TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
128 }
129 
OnStreamReceived(int sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)130 static void OnStreamReceived(int sessionId, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
131 {
132     TRANS_LOGI(TRANS_TEST, "session stream received, sessionId=%{public}d", sessionId);
133 }
134 
OnQosEvent(int sessionId,int eventId,int tvCount,const QosTv * tvList)135 static void OnQosEvent(int sessionId, int eventId, int tvCount, const QosTv *tvList)
136 {
137     TRANS_LOGI(TRANS_TEST, "session Qos event emit, sessionId=%{public}d", sessionId);
138 }
139 
OnSessionOpenedErr(int sessionId,int result)140 static int OnSessionOpenedErr(int sessionId, int result)
141 {
142     TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
143     return SOFTBUS_NOT_FIND;
144 }
145 
OnReceiveFileStarted(int sessionId,const char * files,int fileCnt)146 static int OnReceiveFileStarted(int sessionId, const char *files, int fileCnt)
147 {
148     TRANS_LOGI(TRANS_TEST, "receive file start, sessionId=%{public}d", sessionId);
149     return SOFTBUS_OK;
150 }
151 
OnReceiveFileProcess(int sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)152 static int OnReceiveFileProcess(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
153 {
154     TRANS_LOGI(TRANS_TEST, "receive file process, sessionId=%{public}d", sessionId);
155     return SOFTBUS_OK;
156 }
157 
OnReceiveFileFinished(int sessionId,const char * files,int fileCnt)158 static void OnReceiveFileFinished(int sessionId, const char *files, int fileCnt)
159 {
160     TRANS_LOGI(TRANS_TEST, "receive file finished, sessionId=%{public}d", sessionId);
161 }
162 
OnFileTransError(int sessionId)163 void OnFileTransError(int sessionId)
164 {
165     TRANS_LOGI(TRANS_TEST, "file transmission error, sessionId=%{public}d", sessionId);
166 }
167 
OnSendFileProcess(int sessionId,uint64_t bytesUpload,uint64_t bytesTotal)168 int OnSendFileProcess(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
169 {
170     TRANS_LOGI(TRANS_TEST, "send file process, sessionId=%{public}d", sessionId);
171     return SOFTBUS_OK;
172 }
173 
OnSendFileFinished(int sessionId,const char * firstFile)174 int OnSendFileFinished(int sessionId, const char *firstFile)
175 {
176     TRANS_LOGI(TRANS_TEST, "send file finished, sessionId=%{public}d", sessionId);
177     return SOFTBUS_OK;
178 }
179 
180 static ISessionListener g_sessionlistener = {
181     .OnSessionOpened = OnSessionOpened,
182     .OnSessionClosed = OnSessionClosed,
183     .OnBytesReceived = OnBytesReceived,
184     .OnMessageReceived = OnMessageReceived,
185     .OnStreamReceived = OnStreamReceived,
186     .OnQosEvent = OnQosEvent,
187 };
188 
189 static IFileReceiveListener g_fileRecvListener = {
190     .OnReceiveFileStarted = OnReceiveFileStarted,
191     .OnReceiveFileProcess = OnReceiveFileProcess,
192     .OnReceiveFileFinished = OnReceiveFileFinished,
193     .OnFileTransError = OnFileTransError
194 };
195 
196 static IFileSendListener g_fileSendListener = {
197     .OnSendFileProcess = OnSendFileProcess,
198     .OnSendFileFinished = OnSendFileFinished,
199     .OnFileTransError = OnFileTransError
200 };
201 
TestGenerateCommParam(SessionParam * sessionParam)202 static void TestGenerateCommParam(SessionParam *sessionParam)
203 {
204     sessionParam->sessionName = g_sessionName;
205     sessionParam->peerSessionName = g_sessionName;
206     sessionParam->peerDeviceId = g_deviceId;
207     sessionParam->groupId = g_groupId;
208     sessionParam->attr = &g_sessionAttr;
209 }
210 
TestGenerateSession(const SessionParam * param)211 static SessionInfo *TestGenerateSession(const SessionParam *param)
212 {
213     SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
214     if (session == NULL) {
215         return NULL;
216     }
217 
218     if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
219         strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
220         strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
221         SoftBusFree(session);
222         return NULL;
223     }
224 
225     session->sessionId = TRANS_TEST_SESSION_ID;
226     session->channelId = TRANS_TEST_CHANNEL_ID;
227     session->channelType = CHANNEL_TYPE_BUTT;
228     session->isServer = false;
229     session->enableStatus = ENABLE_STATUS_INIT;
230     session->routeType = ROUTE_TYPE_ALL;
231     session->info.flag = TYPE_BYTES;
232     session->isEncrypt = true;
233     session->algorithm = TRANS_TEST_ALGORITHM;
234     session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
235     session->crc = TRANS_TEST_CRC;
236     session->lifecycle.sessionState = SESSION_STATE_INIT;
237     return session;
238 }
239 
AddSessionServerAndSession(const char * sessionName,int32_t channelType,bool isServer)240 static int32_t AddSessionServerAndSession(const char *sessionName, int32_t channelType, bool isServer)
241 {
242     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
243     if (sessionParam == NULL) {
244         return SOFTBUS_MALLOC_ERR;
245     }
246 
247     TestGenerateCommParam(sessionParam);
248     sessionParam->sessionName = sessionName;
249     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, sessionName, &g_sessionlistener);
250     if (ret != SOFTBUS_OK) {
251         return ret;
252     }
253 
254     SessionInfo *session = TestGenerateSession(sessionParam);
255     if (session == NULL) {
256         return SOFTBUS_MALLOC_ERR;
257     }
258 
259     session->channelType = (ChannelType)channelType;
260     session->isServer = isServer;
261     ret = ClientAddNewSession(sessionName, session);
262     if (ret != SOFTBUS_OK) {
263         return ret;
264     }
265 
266     int32_t sessionId = 0;
267     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, channelType, &sessionId);
268     if (ret != SOFTBUS_OK) {
269         return ret;
270     }
271 
272     SoftBusFree(sessionParam);
273     return sessionId;
274 }
275 
DeleteSessionServerAndSession(const char * sessionName,int32_t sessionId)276 static void DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)
277 {
278     (void)ClientDeleteSession(sessionId);
279     (void)ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
280 }
281 
282 /**
283  * @tc.name: TransClientSessionTest01
284  * @tc.desc: Transmission sdk session service open session with existed session callback success.
285  * @tc.type: FUNC
286  * @tc.require:
287  */
288 HWTEST_F(TransClientSessionTest, TransClientSessionTest01, TestSize.Level1)
289 {
290     bool isEnabled = false;
291     int32_t ret = OpenSessionWithExistSession(TRANS_TEST_SESSION_ID, isEnabled);
292     EXPECT_EQ(ret, TRANS_TEST_SESSION_ID);
293     isEnabled = true;
294     ret = OpenSessionWithExistSession(TRANS_TEST_SESSION_ID, isEnabled);
295     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
296     ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
297     ASSERT_EQ(ret, SOFTBUS_OK);
298     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
299     ASSERT_TRUE(sessionParam != NULL);
300     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
301     TestGenerateCommParam(sessionParam);
302     SessionInfo *session = TestGenerateSession(sessionParam);
303     ASSERT_TRUE(session != NULL);
304     session->channelType = CHANNEL_TYPE_AUTH;
305     ret = ClientAddNewSession(g_sessionName, session);
306     ASSERT_EQ(ret, SOFTBUS_OK);
307     ret = OpenSessionWithExistSession(session->sessionId, isEnabled);
308     EXPECT_EQ(ret, session->sessionId);
309     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
310     EXPECT_EQ(ret, SOFTBUS_OK);
311     SoftBusFree(sessionParam);
312 }
313 
314 /**
315  * @tc.name: TransClientSessionTest02
316  * @tc.desc: Transmission sdk session service open session with existed session callback error.
317  * @tc.type: FUNC
318  * @tc.require:
319  */
320 HWTEST_F(TransClientSessionTest, TransClientSessionTest02, TestSize.Level1)
321 {
322     bool isEnabled = false;
323     ISessionListener sessionlistener = {
324         .OnSessionOpened = OnSessionOpenedErr,
325         .OnSessionClosed = OnSessionClosed,
326         .OnBytesReceived = OnBytesReceived,
327         .OnMessageReceived = OnMessageReceived,
328         .OnStreamReceived = OnStreamReceived,
329         .OnQosEvent = OnQosEvent,
330     };
331     int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &sessionlistener);
332     ASSERT_EQ(ret, SOFTBUS_OK);
333     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
334     ASSERT_TRUE(sessionParam != NULL);
335     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
336     TestGenerateCommParam(sessionParam);
337     SessionInfo *session = TestGenerateSession(sessionParam);
338     ASSERT_TRUE(session != NULL);
339     session->channelType = CHANNEL_TYPE_AUTH;
340     ret = ClientAddNewSession(g_sessionName, session);
341     ASSERT_EQ(ret, SOFTBUS_OK);
342     isEnabled = true;
343     ret = OpenSessionWithExistSession(session->sessionId, isEnabled);
344     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
345     ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
346     EXPECT_EQ(ret, SOFTBUS_OK);
347     SoftBusFree(sessionParam);
348 }
349 
350 /**
351  * @tc.name: TransClientSessionTest03
352  * @tc.desc: Transmission sdk session service creat session server with different parameters.
353  * @tc.type: FUNC
354  * @tc.require:
355  */
356 HWTEST_F(TransClientSessionTest, TransClientSessionTest03, TestSize.Level1)
357 {
358     const char *pkgName = "package.test";
359     int ret = CreateSessionServer(pkgName, g_sessionName, &g_sessionlistener);
360     EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
361     ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
362     EXPECT_EQ(ret, SOFTBUS_OK);
363     ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
364     EXPECT_EQ(ret, SOFTBUS_OK);
365     ret = RemoveSessionServer(g_pkgName, g_sessionName);
366     EXPECT_EQ(ret, SOFTBUS_OK);
367 }
368 
369 /**
370  * @tc.name: TransClientSessionTest04
371  * @tc.desc: Transmission sdk session service remove session server with different parameters.
372  * @tc.type: FUNC
373  * @tc.require:
374  */
375 HWTEST_F(TransClientSessionTest, TransClientSessionTest04, TestSize.Level1)
376 {
377     int ret = RemoveSessionServer(g_pkgName, g_sessionName);
378     EXPECT_EQ(ret, SOFTBUS_TRANS_CHECK_PID_ERROR);
379     ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
380     EXPECT_EQ(ret, SOFTBUS_OK);
381     ret = RemoveSessionServer(g_pkgName, g_sessionName);
382     EXPECT_EQ(ret, SOFTBUS_OK);
383 }
384 
385 /**
386  * @tc.name: TransClientSessionTest05
387  * @tc.desc: Transmission sdk session service open session.
388  * @tc.type: FUNC
389  * @tc.require:
390  */
391 HWTEST_F(TransClientSessionTest, TransClientSessionTest05, TestSize.Level1)
392 {
393     int32_t sessionId = 0;
394     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
395     int ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
396     ASSERT_EQ(ret, SOFTBUS_OK);
397     ret = OpenSession(g_sessionName, g_sessionName, g_networkId, g_groupId, &g_sessionAttr);
398     EXPECT_NE(ret, SOFTBUS_OK);
399     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
400     ASSERT_TRUE(sessionParam != NULL);
401     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
402     TestGenerateCommParam(sessionParam);
403     ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
404     ASSERT_EQ(ret, SOFTBUS_OK);
405     ret = OpenSession(g_sessionName, g_sessionName, g_networkId, g_groupId, &g_sessionAttr);
406     EXPECT_EQ(ret, sessionId);
407     ret = ClientDeleteSession(sessionId);
408     EXPECT_EQ(ret, SOFTBUS_OK);
409     ret = RemoveSessionServer(g_pkgName, g_sessionName);
410     EXPECT_EQ(ret, SOFTBUS_OK);
411 }
412 
413 /**
414  * @tc.name: TransClientSessionTest06
415  * @tc.desc: Transmission sdk session service convert address string with different parameters.
416  * @tc.type: FUNC
417  * @tc.require:
418  */
419 HWTEST_F(TransClientSessionTest, TransClientSessionTest06, TestSize.Level1)
420 {
421     ConnectionAddr *addrInfo = (ConnectionAddr*)SoftBusMalloc(sizeof(ConnectionAddr));
422     ASSERT_TRUE(addrInfo != NULL);
423     int32_t ret = ConvertAddrStr(TRANS_TEST_AUTH_DATA, addrInfo);
424     EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
425     cJSON *msg = cJSON_CreateObject();
426     bool res = AddStringToJsonObject(msg, "ETH_IP", TRANS_TEST_CONN_IP);
427     ASSERT_TRUE(res);
428     res = AddNumberToJsonObject(msg, "ETH_PORT", TRANS_TEST_AUTH_PORT);
429     ASSERT_TRUE(res);
430     char *data = cJSON_PrintUnformatted(msg);
431     ret = ConvertAddrStr(data, addrInfo);
432     EXPECT_EQ(ret, SOFTBUS_OK);
433     cJSON_free(data);
434     cJSON_Delete(msg);
435     msg = cJSON_CreateObject();
436     res = AddStringToJsonObject(msg, "WIFI_IP", TRANS_TEST_CONN_IP);
437     ASSERT_TRUE(res);
438     res = AddNumberToJsonObject(msg, "WIFI_PORT", TRANS_TEST_AUTH_PORT);
439     ASSERT_TRUE(res);
440     data = cJSON_PrintUnformatted(msg);
441     ret = ConvertAddrStr(data, addrInfo);
442     EXPECT_EQ(ret, SOFTBUS_OK);
443     cJSON_free(data);
444     cJSON_Delete(msg);
445     msg = cJSON_CreateObject();
446     res = AddStringToJsonObject(msg, "BR_MAC", TRANS_TEST_BR_MAC);
447     ASSERT_TRUE(res);
448     data = cJSON_PrintUnformatted(msg);
449     ret = ConvertAddrStr(data, addrInfo);
450     EXPECT_EQ(ret, SOFTBUS_OK);
451     cJSON_free(data);
452     cJSON_Delete(msg);
453     msg = cJSON_CreateObject();
454     res = AddStringToJsonObject(msg, "BLE_MAC", TRANS_TEST_BR_MAC);
455     ASSERT_TRUE(res);
456     data = cJSON_PrintUnformatted(msg);
457     ret = ConvertAddrStr(data, addrInfo);
458     EXPECT_EQ(ret, SOFTBUS_OK);
459     cJSON_free(data);
460     cJSON_Delete(msg);
461     SoftBusFree(addrInfo);
462 }
463 
464 /**
465  * @tc.name: TransClientSessionTest07
466  * @tc.desc: Transmission sdk session service is valid addrInfo.
467  * @tc.type: FUNC
468  * @tc.require:
469  */
470 HWTEST_F(TransClientSessionTest, TransClientSessionTest07, TestSize.Level1)
471 {
472     ConnectionAddr addrInfoArr[TRANS_TEST_ADDR_INFO_NUM] = {
473         {.type = CONNECTION_ADDR_MAX},
474         {.type = CONNECTION_ADDR_MAX}
475     };
476     int ret = IsValidAddrInfoArr(addrInfoArr, TRANS_TEST_ADDR_INFO_NUM);
477     EXPECT_EQ(ret, -1);
478 }
479 
480 /**
481  * @tc.name: TransClientSessionTest08
482  * @tc.desc: Transmission sdk session service open auth session with different.
483  * @tc.type: FUNC
484  * @tc.require:
485  */
486 HWTEST_F(TransClientSessionTest, TransClientSessionTest08, TestSize.Level1)
487 {
488     ConnectionAddr addrInfoArr[TRANS_TEST_ADDR_INFO_NUM] = {
489         {.type = CONNECTION_ADDR_MAX},
490         {.type = CONNECTION_ADDR_MAX}
491     };
492     cJSON *msg = cJSON_CreateObject();
493     bool res = AddStringToJsonObject(msg, "BLE_MAC", TRANS_TEST_BR_MAC);
494     ASSERT_TRUE(res);
495     char *data = cJSON_PrintUnformatted(msg);
496     int ret = OpenAuthSession(g_sessionName, addrInfoArr, TRANS_TEST_ADDR_INFO_NUM, data);
497     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
498     ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
499     ASSERT_EQ(ret, SOFTBUS_OK);
500     ret = CreateSessionServer(g_pkgName, NEW_SESSION_NAME, &g_sessionlistener);
501     ASSERT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
502     ret = OpenAuthSession(g_sessionName, addrInfoArr, TRANS_TEST_ADDR_INFO_NUM, data);
503     ret = ClientDeleteSession(ret);
504     EXPECT_EQ(ret, SOFTBUS_OK);
505     cJSON_free(data);
506     cJSON_Delete(msg);
507     msg = cJSON_CreateObject();
508     res = AddStringToJsonObject(msg, "WIFI_IP", TRANS_TEST_CONN_IP);
509     ASSERT_TRUE(res);
510     res = AddNumberToJsonObject(msg, "WIFI_PORT", TRANS_TEST_AUTH_PORT);
511     ASSERT_TRUE(res);
512     data = cJSON_PrintUnformatted(msg);
513     ret = OpenAuthSession(NEW_SESSION_NAME, addrInfoArr, TRANS_TEST_ADDR_INFO_NUM, data);
514     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
515     ret = ClientDeleteSession(ret);
516     EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
517     ret = RemoveSessionServer(g_pkgName, g_sessionName);
518     EXPECT_EQ(ret, SOFTBUS_OK);
519     ret = RemoveSessionServer(g_pkgName, NEW_SESSION_NAME);
520     EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
521     cJSON_free(data);
522     cJSON_Delete(msg);
523 }
524 
525 /**
526  * @tc.name: TransClientSessionTest09
527  * @tc.desc: Transmission sdk session service notify auth success with different parameters.
528  * @tc.type: FUNC
529  * @tc.require:
530  */
531 HWTEST_F(TransClientSessionTest, TransClientSessionTest09, TestSize.Level1)
532 {
533     int32_t sessionId = 0;
534     SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
535     int ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
536     ASSERT_EQ(ret, SOFTBUS_OK);
537     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
538     ASSERT_TRUE(sessionParam != NULL);
539     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
540     TestGenerateCommParam(sessionParam);
541     ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
542     ASSERT_EQ(ret, SOFTBUS_OK);
543     NotifyAuthSuccess(sessionId);
544     ret = ClientDeleteSession(sessionId);
545     ASSERT_EQ(ret, SOFTBUS_OK);
546     SessionInfo *session = TestGenerateSession(sessionParam);
547     ASSERT_TRUE(session != NULL);
548     session->isServer = true;
549     ret = ClientAddNewSession(g_sessionName, session);
550     ASSERT_EQ(ret, SOFTBUS_OK);
551     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &sessionId);
552     EXPECT_EQ(ret, SOFTBUS_OK);
553     NotifyAuthSuccess(sessionId);
554     ret = ClientDeleteSession(sessionId);
555     EXPECT_EQ(ret, SOFTBUS_OK);
556     ret = RemoveSessionServer(g_pkgName, g_sessionName);
557     EXPECT_EQ(ret, SOFTBUS_OK);
558     SoftBusFree(sessionParam);
559 }
560 
561 /**
562  * @tc.name: TransClientSessionTest10
563  * @tc.desc: Transmission sdk session service check whether session is opened with different parameters.
564  * @tc.type: FUNC
565  * @tc.require:
566  */
567 HWTEST_F(TransClientSessionTest, TransClientSessionTest10, TestSize.Level1)
568 {
569     int32_t sessionId = 0;
570     int ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
571     ASSERT_EQ(ret, SOFTBUS_OK);
572     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
573     ASSERT_TRUE(sessionParam != NULL);
574     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
575     TestGenerateCommParam(sessionParam);
576     SessionInfo *session = TestGenerateSession(sessionParam);
577     ASSERT_TRUE(session != NULL);
578     session->enableStatus = ENABLE_STATUS_SUCCESS;
579     ret = CheckSessionIsOpened(TRANS_TEST_CHANNEL_ID, false);
580     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED);
581     ret = ClientAddNewSession(g_sessionName, session);
582     ASSERT_EQ(ret, SOFTBUS_OK);
583     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &sessionId);
584     EXPECT_EQ(ret, SOFTBUS_OK);
585     ret = CheckSessionIsOpened(sessionId, false);
586     EXPECT_EQ(ret, SOFTBUS_OK);
587     ret = ClientDeleteSession(sessionId);
588     EXPECT_EQ(ret, SOFTBUS_OK);
589     ret = RemoveSessionServer(g_pkgName, g_sessionName);
590     EXPECT_EQ(ret, SOFTBUS_OK);
591     SoftBusFree(sessionParam);
592 }
593 
594 /**
595  * @tc.name: TransClientSessionTest11
596  * @tc.desc: Transmission sdk session service close session with different parameters.
597  * @tc.type: FUNC
598  * @tc.require:
599  */
600 HWTEST_F(TransClientSessionTest, TransClientSessionTest11, TestSize.Level1)
601 {
602     int32_t sessionId = 0;
603     int ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
604     ASSERT_EQ(ret, SOFTBUS_OK);
605     CloseSession(TRANS_TEST_INVALID_SESSION_ID);
606     SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
607     ASSERT_TRUE(sessionParam != NULL);
608     memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
609     TestGenerateCommParam(sessionParam);
610     SessionInfo *session = TestGenerateSession(sessionParam);
611     ASSERT_TRUE(session != NULL);
612     session->channelType = CHANNEL_TYPE_UDP;
613     CloseSession(TRANS_TEST_SESSION_ID);
614     ret = ClientAddNewSession(g_sessionName, session);
615     ASSERT_EQ(ret, SOFTBUS_OK);
616     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
617     EXPECT_EQ(ret, SOFTBUS_OK);
618     CloseSession(sessionId);
619     ret = ClientDeleteSession(sessionId);
620     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
621     session = TestGenerateSession(sessionParam);
622     ASSERT_TRUE(session != NULL);
623     session->channelType = CHANNEL_TYPE_AUTH;
624     ret = ClientAddNewSession(g_sessionName, session);
625     ASSERT_EQ(ret, SOFTBUS_OK);
626     ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_AUTH, &sessionId);
627     EXPECT_EQ(ret, SOFTBUS_OK);
628     CloseSession(sessionId);
629     ret = ClientDeleteSession(sessionId);
630     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
631     ret = RemoveSessionServer(g_pkgName, g_sessionName);
632     EXPECT_EQ(ret, SOFTBUS_OK);
633     SoftBusFree(sessionParam);
634 }
635 
636 /**
637  * @tc.name: TransClientSessionTest12
638  * @tc.desc: Transmission sdk session service get my session name with invalid parameters.
639  * @tc.type: FUNC
640  * @tc.require:
641  */
642 HWTEST_F(TransClientSessionTest, TransClientSessionTest12, TestSize.Level1)
643 {
644     char sessionName[SESSION_NAME_SIZE_MAX] = {0};
645     int ret = GetMySessionName(TRANS_TEST_INVALID_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
646     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
647     ret = GetMySessionName(TRANS_TEST_SESSION_ID, NULL, SESSION_NAME_SIZE_MAX);
648     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
649     ret = GetMySessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX + 1);
650     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
651 }
652 
653 /**
654  * @tc.name: TransClientSessionTest13
655  * @tc.desc: Transmission sdk session service get peer session name with different parameters.
656  * @tc.type: FUNC
657  * @tc.require:
658  */
659 HWTEST_F(TransClientSessionTest, TransClientSessionTest13, TestSize.Level1)
660 {
661     char sessionName[SESSION_NAME_SIZE_MAX] = {0};
662     int ret = GetPeerSessionName(TRANS_TEST_INVALID_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
663     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
664     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, NULL, SESSION_NAME_SIZE_MAX);
665     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
666     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX + 1);
667     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
668     ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
669     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
670     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
671     ASSERT_GT(sessionId, 0);
672     ret = GetPeerSessionName(sessionId, sessionName, SESSION_NAME_SIZE_MAX);
673     EXPECT_EQ(ret, SOFTBUS_OK);
674     ret = strcmp(g_sessionName, sessionName);
675     EXPECT_EQ(ret, EOK);
676     DeleteSessionServerAndSession(g_sessionName, sessionId);
677 }
678 
679 /**
680  * @tc.name: TransClientSessionTest14
681  * @tc.desc: Transmission sdk session service get peer device Id with different parameters.
682  * @tc.type: FUNC
683  * @tc.require:
684  */
685 HWTEST_F(TransClientSessionTest, TransClientSessionTest14, TestSize.Level1)
686 {
687     char networkId[DEVICE_ID_SIZE_MAX] = {0};
688     int ret = GetPeerDeviceId(TRANS_TEST_INVALID_SESSION_ID, networkId, DEVICE_ID_SIZE_MAX);
689     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
690     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, NULL, DEVICE_ID_SIZE_MAX);
691     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
692     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, networkId, SESSION_NAME_SIZE_MAX + 1);
693     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
694     ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, networkId, DEVICE_ID_SIZE_MAX);
695     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
696     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
697     ASSERT_GT(sessionId, 0);
698     ret = GetPeerDeviceId(sessionId, networkId, DEVICE_ID_SIZE_MAX);
699     EXPECT_EQ(ret, SOFTBUS_OK);
700     ret = strcmp(g_deviceId, networkId);
701     EXPECT_EQ(ret, EOK);
702     DeleteSessionServerAndSession(g_sessionName, sessionId);
703 }
704 
705 /**
706  * @tc.name: TransClientSessionTest15
707  * @tc.desc: Transmission sdk session service judge session server or client.
708  * @tc.type: FUNC
709  * @tc.require:
710  */
711 HWTEST_F(TransClientSessionTest, TransClientSessionTest15, TestSize.Level1)
712 {
713     int32_t ret =  ClientGetSessionSide(TRANS_TEST_SESSION_ID);
714     EXPECT_EQ(ret, -1);
715     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
716     ASSERT_GT(sessionId, 0);
717     ret =  GetSessionSide(sessionId);
718     EXPECT_EQ(ret, IS_CLIENT);
719     DeleteSessionServerAndSession(g_sessionName, sessionId);
720     sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, true);
721     ASSERT_GT(sessionId, 0);
722     ret =  GetSessionSide(sessionId);
723     EXPECT_EQ(ret, IS_SERVER);
724     DeleteSessionServerAndSession(g_sessionName, sessionId);
725 }
726 
727 /**
728  * @tc.name: TransClientSessionTest16
729  * @tc.desc: Transmission sdk session service set file receive listener with different parameters.
730  * @tc.type: FUNC
731  * @tc.require:
732  */
733 HWTEST_F(TransClientSessionTest, TransClientSessionTest16, TestSize.Level1)
734 {
735     char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
736     memset_s(sessionName, SESSION_NAME_SIZE_MAX + 2, 'A', SESSION_NAME_SIZE_MAX + 1);
737     char pkgName[PKG_NAME_SIZE_MAX + 2] = {0};
738     memset_s(pkgName, PKG_NAME_SIZE_MAX + 2, 'B', PKG_NAME_SIZE_MAX + 1);
739     char rootDir[FILE_RECV_ROOT_DIR_SIZE_MAX + 2] = {0};
740     memset_s(rootDir, FILE_RECV_ROOT_DIR_SIZE_MAX + 2, 'C', FILE_RECV_ROOT_DIR_SIZE_MAX + 1);
741     int ret = SetFileReceiveListener(pkgName, g_sessionName, &g_fileRecvListener, g_rootDir);
742     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
743     ret = SetFileReceiveListener(g_pkgName, sessionName, &g_fileRecvListener, g_rootDir);
744     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
745     ret = SetFileReceiveListener(g_pkgName, g_sessionName, NULL, g_rootDir);
746     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
747     ret = SetFileReceiveListener(g_pkgName, g_sessionName, &g_fileRecvListener, NULL);
748     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
749     ret = SetFileReceiveListener(g_pkgName, g_sessionName, &g_fileRecvListener, g_rootDir);
750     EXPECT_EQ(ret, SOFTBUS_OK);
751 }
752 
753 /**
754  * @tc.name: TransClientSessionTest17
755  * @tc.desc: Transmission sdk session service set file send listener with different parameters.
756  * @tc.type: FUNC
757  * @tc.require:
758  */
759 HWTEST_F(TransClientSessionTest, TransClientSessionTest17, TestSize.Level1)
760 {
761     char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
762     memset_s(sessionName, SESSION_NAME_SIZE_MAX + 2, 'A', SESSION_NAME_SIZE_MAX + 1);
763     char pkgName[PKG_NAME_SIZE_MAX + 2] = {0};
764     memset_s(pkgName, PKG_NAME_SIZE_MAX + 2, 'B', PKG_NAME_SIZE_MAX + 1);
765     char rootDir[FILE_RECV_ROOT_DIR_SIZE_MAX + 2] = {0};
766     memset_s(rootDir, FILE_RECV_ROOT_DIR_SIZE_MAX + 2, 'C', FILE_RECV_ROOT_DIR_SIZE_MAX + 1);
767     int ret = SetFileSendListener(pkgName, g_sessionName, &g_fileSendListener);
768     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
769     ret = SetFileSendListener(g_pkgName, sessionName, &g_fileSendListener);
770     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
771     ret = SetFileSendListener(g_pkgName, g_sessionName, NULL);
772     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
773     ret = SetFileSendListener(g_pkgName, g_sessionName, &g_fileSendListener);
774     EXPECT_EQ(ret, SOFTBUS_OK);
775 }
776 
777 /**
778  * @tc.name: TransClientSessionTest18
779  * @tc.desc: Transmission sdk session service judge whether session is DFS with different parameters.
780  * @tc.type: FUNC
781  * @tc.require:
782  */
783 HWTEST_F(TransClientSessionTest, TransClientSessionTest18, TestSize.Level1)
784 {
785     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
786     ASSERT_GT(sessionId, 0);
787     int32_t channelId = 0;
788     int32_t ret = IsValidDFSSession(sessionId, &channelId);
789     EXPECT_EQ(ret, SOFTBUS_TRANS_FUNC_NOT_SUPPORT);
790     DeleteSessionServerAndSession(g_sessionName, sessionId);
791     const char *dfsSessionName = "DistributedFileService";
792     sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_BUTT, false);
793     ASSERT_GT(sessionId, 0);
794     ret = IsValidDFSSession(sessionId, &channelId);
795     EXPECT_EQ(ret, SOFTBUS_TRANS_FUNC_NOT_SUPPORT);
796     EXPECT_EQ(channelId, TRANS_TEST_CHANNEL_ID);
797     DeleteSessionServerAndSession(dfsSessionName, sessionId);
798     sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_TCP_DIRECT, false);
799     ASSERT_GT(sessionId, 0);
800     ret = IsValidDFSSession(sessionId, &channelId);
801     EXPECT_EQ(ret, SOFTBUS_OK);
802     EXPECT_EQ(channelId, TRANS_TEST_CHANNEL_ID);
803     DeleteSessionServerAndSession(dfsSessionName, sessionId);
804 }
805 
806 /**
807  * @tc.name: TransClientSessionTest19
808  * @tc.desc: Transmission sdk session service get session key with different parameters.
809  * @tc.type: FUNC
810  * @tc.require:
811  */
812 HWTEST_F(TransClientSessionTest, TransClientSessionTest19, TestSize.Level1)
813 {
814     const char *dfsSessionName = "DistributedFileService";
815     int32_t sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_TCP_DIRECT, false);
816     ASSERT_GT(sessionId, 0);
817     char sessionKey[SESSION_KEY_LEN] = {0};
818     int32_t ret = GetSessionKey(sessionId, sessionKey, SESSION_KEY_LEN);
819     EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
820     DeleteSessionServerAndSession(dfsSessionName, sessionId);
821 }
822 
823 /**
824  * @tc.name: TransClientSessionTest20
825  * @tc.desc: Transmission sdk session service get session handle.
826  * @tc.type: FUNC
827  * @tc.require:
828  */
829 HWTEST_F(TransClientSessionTest, TransClientSessionTest20, TestSize.Level1)
830 {
831     const char *dfsSessionName = "DistributedFileService";
832     int32_t sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_TCP_DIRECT, false);
833     ASSERT_GT(sessionId, 0);
834     int handle = 0;
835     int32_t ret = GetSessionHandle(sessionId, &handle);
836     EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
837     DeleteSessionServerAndSession(dfsSessionName, sessionId);
838 }
839 
840 /**
841  * @tc.name: TransClientSessionTest21
842  * @tc.desc: Transmission sdk session service disable session listener.
843  * @tc.type: FUNC
844  * @tc.require:
845  */
846 HWTEST_F(TransClientSessionTest, TransClientSessionTest21, TestSize.Level1)
847 {
848     const char *dfsSessionName = "DistributedFileService";
849     int32_t sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_TCP_DIRECT, false);
850     ASSERT_GT(sessionId, 0);
851     int32_t ret = DisableSessionListener(sessionId);
852     EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
853     DeleteSessionServerAndSession(dfsSessionName, sessionId);
854 }
855 
856 /**
857  * @tc.name: TransClientSessionTest22
858  * @tc.desc: Transmission sdk session service read max send bytes size with different parameters.
859  * @tc.type: FUNC
860  * @tc.require:
861  */
862 HWTEST_F(TransClientSessionTest, TransClientSessionTest22, TestSize.Level1)
863 {
864     uint32_t value = 0;
865     int ret = ReadMaxSendBytesSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT,
866                                    &value, TRANS_TEST_INVALID_VALUE_SIZE);
867     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
868     ret = ReadMaxSendBytesSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &value, sizeof(value));
869     EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
870 }
871 
872 /**
873  * @tc.name: TransClientSessionTest23
874  * @tc.desc: Transmission sdk session service read max send message size with different parameters.
875  * @tc.type: FUNC
876  * @tc.require:
877  */
878 HWTEST_F(TransClientSessionTest, TransClientSessionTest23, TestSize.Level1)
879 {
880     uint32_t value = 0;
881     int ret = ReadMaxSendMessageSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT,
882                                      &value, TRANS_TEST_INVALID_VALUE_SIZE);
883     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
884     ret = ReadMaxSendMessageSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &value, sizeof(value));
885     EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
886 }
887 
888 /**
889  * @tc.name: TransClientSessionTest24
890  * @tc.desc: Transmission sdk session service get session option with different parameters.
891  * @tc.type: FUNC
892  * @tc.require:
893  */
894 HWTEST_F(TransClientSessionTest, TransClientSessionTest24, TestSize.Level1)
895 {
896     uint32_t optionValue = 0;
897     int ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_BUTT,
898                                &optionValue, sizeof(optionValue));
899     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
900     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
901                            NULL, sizeof(optionValue));
902     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
903     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
904                            &optionValue, 0);
905     EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
906     ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
907                            &optionValue, sizeof(optionValue));
908     EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED);
909     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
910     ASSERT_GT(sessionId, 0);
911     ret = GetSessionOption(sessionId, SESSION_OPTION_MAX_SENDBYTES_SIZE,
912                            &optionValue, sizeof(optionValue));
913     EXPECT_EQ(ret, SOFTBUS_OK);
914     DeleteSessionServerAndSession(g_sessionName, sessionId);
915 }
916 
917 /**
918  * @tc.name: TransClientSessionTest25
919  * @tc.desc: Transmission sdk session manager lnn offline process with different parameters.
920  * @tc.type: FUNC
921  * @tc.require:
922  */
923 HWTEST_F(TransClientSessionTest, TransClientSessionTest25, TestSize.Level1)
924 {
925     ClientTransLnnOfflineProc(NULL);
926     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
927     ASSERT_GT(sessionId, 0);
928 
929     NodeBasicInfo info;
930     memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
931     int ret = strcpy_s(info.networkId, sizeof(info.networkId), g_networkId);
932     ASSERT_EQ(ret, EOK);
933     ret = strcpy_s(info.deviceName, sizeof(info.deviceName), g_deviceName);
934     ASSERT_EQ(ret, EOK);
935     info.deviceTypeId = TRANS_TEST_DEVICE_TYPE_ID;
936     ClientTransLnnOfflineProc(&info);
937 
938     DeleteSessionServerAndSession(g_sessionName, sessionId);
939 }
940 
941 /**
942  * @tc.name: TransClientSessionTest26
943  * @tc.desc: Transmission sdk session manager judge session whether session is available.
944  * @tc.type: FUNC
945  * @tc.require:
946  */
947 HWTEST_F(TransClientSessionTest, TransClientSessionTest26, TestSize.Level1)
948 {
949     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
950     ASSERT_GT(sessionId, 0);
951     DestroyClientSessionServer(NULL, NULL);
952     bool res = SessionIdIsAvailable(sessionId);
953     EXPECT_FALSE(res);
954 
955     DeleteSessionServerAndSession(g_sessionName, sessionId);
956 }
957 
958 /**
959  * @tc.name: TransClientSessionTest27
960  * @tc.desc: Transmission sdk session manager get new session server with different parameters.
961  * @tc.type: FUNC
962  * @tc.require:
963  */
964 HWTEST_F(TransClientSessionTest, TransClientSessionTest27, TestSize.Level1)
965 {
966     ClientSessionServer *server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, g_pkgName, &g_sessionlistener);
967     ASSERT_TRUE(server != NULL);
968     SoftBusFree(server);
969     char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
970     memset_s(sessionName, sizeof(sessionName), 'A', SESSION_NAME_SIZE_MAX + 1);
971     server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, sessionName, g_pkgName, &g_sessionlistener);
972     EXPECT_TRUE(server == NULL);
973     char pkgName[PKG_NAME_SIZE_MAX + 2] = {0};
974     memset_s(pkgName, sizeof(pkgName), 'B', PKG_NAME_SIZE_MAX + 1);
975     server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, pkgName, &g_sessionlistener);
976     EXPECT_TRUE(server == NULL);
977 }
978 
979 /**
980  * @tc.name: TransClientSessionTest28
981  * @tc.desc: Transmission sdk session manager judge whether parameter is valid with different parameters.
982  * @tc.type: FUNC
983  * @tc.require:
984  */
985 HWTEST_F(TransClientSessionTest, TransClientSessionTest28, TestSize.Level1)
986 {
987     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
988     ASSERT_TRUE(sessionParam != NULL);
989 
990     bool res = IsValidSessionParam(NULL);
991     EXPECT_FALSE(res);
992     res = IsValidSessionParam(sessionParam);
993     EXPECT_FALSE(res);
994     sessionParam->sessionName = g_sessionName;
995     res = IsValidSessionParam(sessionParam);
996     EXPECT_FALSE(res);
997     sessionParam->peerSessionName = g_sessionName;
998     res = IsValidSessionParam(sessionParam);
999     EXPECT_FALSE(res);
1000     sessionParam->peerDeviceId = g_deviceId;
1001     res = IsValidSessionParam(sessionParam);
1002     EXPECT_FALSE(res);
1003     sessionParam->groupId = g_groupId;
1004     res = IsValidSessionParam(sessionParam);
1005     EXPECT_FALSE(res);
1006     sessionParam->attr = (const SessionAttribute*)&g_sessionAttr;
1007     res = IsValidSessionParam(sessionParam);
1008     EXPECT_TRUE(res);
1009 
1010     SoftBusFree(sessionParam);
1011 }
1012 
1013 /**
1014  * @tc.name: TransClientSessionTest29
1015  * @tc.desc: Transmission sdk session manager create new session with different parameters.
1016  * @tc.type: FUNC
1017  * @tc.require:
1018  */
1019 HWTEST_F(TransClientSessionTest, TransClientSessionTest29, TestSize.Level1)
1020 {
1021     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1022     ASSERT_TRUE(sessionParam != NULL);
1023 
1024     TestGenerateCommParam(sessionParam);
1025     SessionInfo *session = CreateNewSession(sessionParam);
1026     EXPECT_TRUE(session != NULL);
1027     SoftBusFree(session);
1028 
1029     char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
1030     memset_s(sessionName, sizeof(sessionName), 'A', SESSION_NAME_SIZE_MAX + 1);
1031     sessionParam->peerSessionName = (const char*)sessionName;
1032     session = CreateNewSession(sessionParam);
1033     EXPECT_TRUE(session == NULL);
1034 
1035     char deviceId[DEVICE_ID_SIZE_MAX + 2] = {0};
1036     memset_s(deviceId, sizeof(deviceId), 'B', DEVICE_ID_SIZE_MAX + 1);
1037     sessionParam->peerSessionName = g_sessionName;
1038     sessionParam->peerDeviceId = (const char*)deviceId;
1039     session = CreateNewSession(sessionParam);
1040     EXPECT_TRUE(session == NULL);
1041 
1042     char groupId[GROUP_ID_SIZE_MAX + 2] = {0};
1043     memset_s(groupId, sizeof(groupId), 'C', GROUP_ID_SIZE_MAX + 1);
1044     sessionParam->peerSessionName = g_sessionName;
1045     sessionParam->peerDeviceId = g_deviceId;
1046     sessionParam->groupId = (const char*)groupId;
1047     session = CreateNewSession(sessionParam);
1048     EXPECT_TRUE(session == NULL);
1049 
1050     SoftBusFree(sessionParam);
1051 }
1052 
1053 /**
1054  * @tc.name: TransClientSessionTest30
1055  * @tc.desc: Transmission sdk session manager get exist session.
1056  * @tc.type: FUNC
1057  * @tc.require:
1058  */
1059 HWTEST_F(TransClientSessionTest, TransClientSessionTest30, TestSize.Level1)
1060 {
1061     int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
1062     ASSERT_GT(sessionId, 0);
1063 
1064     SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1065     ASSERT_TRUE(sessionParam != NULL);
1066     TestGenerateCommParam(sessionParam);
1067 
1068     SessionInfo *session = GetExistSession(sessionParam);
1069     ASSERT_TRUE(session != NULL);
1070 
1071     int ret = strcmp(session->info.peerSessionName, sessionParam->peerSessionName);
1072     EXPECT_EQ(ret, EOK);
1073     ret = strcmp(session->info.peerDeviceId, sessionParam->peerDeviceId);
1074     EXPECT_EQ(ret, EOK);
1075     ret = strcmp(session->info.groupId, sessionParam->groupId);
1076     EXPECT_EQ(ret, EOK);
1077 
1078     DeleteSessionServerAndSession(g_sessionName, sessionId);
1079 }
1080 }