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