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_error_code.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 SetAccessTokenPermission("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 == nullptr) {
216 return nullptr;
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 nullptr;
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 == nullptr) {
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 == nullptr) {
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 */
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 != nullptr);
302 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
303 TestGenerateCommParam(sessionParam);
304 SessionInfo *session = TestGenerateSession(sessionParam);
305 ASSERT_TRUE(session != nullptr);
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 */
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 != nullptr);
337 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
338 TestGenerateCommParam(sessionParam);
339 SessionInfo *session = TestGenerateSession(sessionParam);
340 ASSERT_TRUE(session != nullptr);
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 */
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 */
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 */
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 != nullptr);
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 */
421 HWTEST_F(TransClientSessionTest, TransClientSessionTest06, TestSize.Level1)
422 {
423 ConnectionAddr *addrInfo = (ConnectionAddr*)SoftBusMalloc(sizeof(ConnectionAddr));
424 ASSERT_TRUE(addrInfo != nullptr);
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 */
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 */
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 */
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 != nullptr);
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 != nullptr);
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 */
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 != nullptr);
578 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
579 TestGenerateCommParam(sessionParam);
580 SessionInfo *session = TestGenerateSession(sessionParam);
581 ASSERT_TRUE(session != nullptr);
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 */
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 != nullptr);
613 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
614 TestGenerateCommParam(sessionParam);
615 SessionInfo *session = TestGenerateSession(sessionParam);
616 ASSERT_TRUE(session != nullptr);
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 != nullptr);
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 */
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, nullptr, 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 */
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, nullptr, 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 */
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, nullptr, 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 */
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 */
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, nullptr, g_rootDir);
751 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
752 ret = SetFileReceiveListener(g_pkgName, g_sessionName, &g_fileRecvListener, nullptr);
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 */
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, nullptr);
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 nullptr, 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 */
928 HWTEST_F(TransClientSessionTest, TransClientSessionTest25, TestSize.Level1)
929 {
930 ClientTransLnnOfflineProc(nullptr);
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 */
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(nullptr, nullptr);
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 */
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 != nullptr);
973 ListNode destroyList;
974 DestroyAllClientSession(nullptr, &destroyList);
975 DestroyAllClientSession(server, nullptr);
976 DestroyAllClientSession(server, &destroyList);
977 SoftBusFree(server);
978 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
979 memset_s(sessionName, sizeof(sessionName), 'A', SESSION_NAME_SIZE_MAX + 1);
980 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, sessionName, g_pkgName, &g_sessionlistener);
981 EXPECT_TRUE(server == nullptr);
982 char pkgName[PKG_NAME_SIZE_MAX + 2] = {0};
983 memset_s(pkgName, sizeof(pkgName), 'B', PKG_NAME_SIZE_MAX + 1);
984 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, pkgName, &g_sessionlistener);
985 EXPECT_TRUE(server == nullptr);
986 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, nullptr, pkgName, &g_sessionlistener);
987 EXPECT_TRUE(server == nullptr);
988 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, nullptr, &g_sessionlistener);
989 EXPECT_TRUE(server == nullptr);
990 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, pkgName, nullptr);
991 EXPECT_TRUE(server == nullptr);
992 }
993
994 /**
995 * @tc.name: TransClientSessionTest28
996 * @tc.desc: Transmission sdk session manager judge whether parameter is valid with different parameters.
997 * @tc.type: FUNC
998 * @tc.require:
999 */
1000 HWTEST_F(TransClientSessionTest, TransClientSessionTest28, TestSize.Level1)
1001 {
1002 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1003 ASSERT_TRUE(sessionParam != nullptr);
1004
1005 bool res = IsValidSessionParam(nullptr);
1006 EXPECT_FALSE(res);
1007 res = IsValidSessionParam(sessionParam);
1008 EXPECT_FALSE(res);
1009 sessionParam->sessionName = g_sessionName;
1010 res = IsValidSessionParam(sessionParam);
1011 EXPECT_FALSE(res);
1012 sessionParam->peerSessionName = g_sessionName;
1013 res = IsValidSessionParam(sessionParam);
1014 EXPECT_FALSE(res);
1015 sessionParam->peerDeviceId = g_deviceId;
1016 res = IsValidSessionParam(sessionParam);
1017 EXPECT_FALSE(res);
1018 sessionParam->groupId = g_groupId;
1019 res = IsValidSessionParam(sessionParam);
1020 EXPECT_FALSE(res);
1021 sessionParam->attr = (const SessionAttribute*)&g_sessionAttr;
1022 res = IsValidSessionParam(sessionParam);
1023 EXPECT_TRUE(res);
1024
1025 SoftBusFree(sessionParam);
1026 }
1027
1028 /**
1029 * @tc.name: TransClientSessionTest29
1030 * @tc.desc: Transmission sdk session manager create new session with different parameters.
1031 * @tc.type: FUNC
1032 * @tc.require:
1033 */
1034 HWTEST_F(TransClientSessionTest, TransClientSessionTest29, TestSize.Level1)
1035 {
1036 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1037 ASSERT_TRUE(sessionParam != nullptr);
1038
1039 TestGenerateCommParam(sessionParam);
1040 SessionInfo *session = CreateNewSession(sessionParam);
1041 EXPECT_TRUE(session != nullptr);
1042 SoftBusFree(session);
1043
1044 session = CreateNewSession(nullptr);
1045 EXPECT_TRUE(session == nullptr);
1046
1047 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
1048 memset_s(sessionName, sizeof(sessionName), 'A', SESSION_NAME_SIZE_MAX + 1);
1049 sessionParam->peerSessionName = (const char*)sessionName;
1050 session = CreateNewSession(sessionParam);
1051 EXPECT_TRUE(session == nullptr);
1052
1053 char deviceId[DEVICE_ID_SIZE_MAX + 2] = {0};
1054 memset_s(deviceId, sizeof(deviceId), 'B', DEVICE_ID_SIZE_MAX + 1);
1055 sessionParam->peerSessionName = g_sessionName;
1056 sessionParam->peerDeviceId = (const char*)deviceId;
1057 session = CreateNewSession(sessionParam);
1058 EXPECT_TRUE(session == nullptr);
1059
1060 char groupId[GROUP_ID_SIZE_MAX + 2] = {0};
1061 memset_s(groupId, sizeof(groupId), 'C', GROUP_ID_SIZE_MAX + 1);
1062 sessionParam->peerSessionName = g_sessionName;
1063 sessionParam->peerDeviceId = g_deviceId;
1064 sessionParam->groupId = (const char*)groupId;
1065 session = CreateNewSession(sessionParam);
1066 EXPECT_TRUE(session == nullptr);
1067
1068 SoftBusFree(sessionParam);
1069 }
1070
1071 /**
1072 * @tc.name: TransClientSessionTest30
1073 * @tc.desc: Transmission sdk session manager get exist session.
1074 * @tc.type: FUNC
1075 * @tc.require:
1076 */
1077 HWTEST_F(TransClientSessionTest, TransClientSessionTest30, TestSize.Level1)
1078 {
1079 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
1080 ASSERT_GT(sessionId, 0);
1081
1082 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1083 ASSERT_TRUE(sessionParam != nullptr);
1084 TestGenerateCommParam(sessionParam);
1085
1086 SessionInfo *session = GetExistSession(sessionParam);
1087 ASSERT_TRUE(session != nullptr);
1088
1089 int32_t ret = strcmp(session->info.peerSessionName, sessionParam->peerSessionName);
1090 EXPECT_EQ(ret, EOK);
1091 ret = strcmp(session->info.peerDeviceId, sessionParam->peerDeviceId);
1092 EXPECT_EQ(ret, EOK);
1093 ret = strcmp(session->info.groupId, sessionParam->groupId);
1094 EXPECT_EQ(ret, EOK);
1095
1096 DeleteSessionServerAndSession(g_sessionName, sessionId);
1097 }
1098
1099 /**
1100 * @tc.name: TransClientSessionTest31
1101 * @tc.desc: Transmission sdk session manager get exist session.
1102 * @tc.type: FUNC
1103 * @tc.require:
1104 */
1105 HWTEST_F(TransClientSessionTest, TransClientSessionTest31, TestSize.Level1)
1106 {
1107 SessionInfo *sessionNode = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
1108 ASSERT_TRUE(sessionNode != nullptr);
1109 ClientSessionServer *SessionServer = GetNewSessionServer(SEC_TYPE_PLAINTEXT,
1110 g_sessionName, g_pkgName, &g_sessionlistener);
1111 ASSERT_TRUE(SessionServer != nullptr);
1112 sessionNode->sessionId = TRANS_TEST_SESSION_ID;
1113 sessionNode->channelId = TRANS_TEST_CHANNEL_ID;
1114 sessionNode->channelType = CHANNEL_TYPE_BUTT;
1115 sessionNode->isAsync = true;
1116 sessionNode->lifecycle.condIsWaiting = true;
1117 SessionServer->listener.isSocketListener = true;
1118
1119 DestroySessionInfo *destroyInfo = CreateDestroySessionNode(nullptr, SessionServer);
1120 EXPECT_TRUE(destroyInfo == nullptr);
1121 destroyInfo = CreateDestroySessionNode(sessionNode, nullptr);
1122 EXPECT_TRUE(destroyInfo == nullptr);
1123 destroyInfo = CreateDestroySessionNode(sessionNode, SessionServer);
1124 ASSERT_TRUE(destroyInfo != nullptr);
1125 ClientDestroySession(nullptr, SHUTDOWN_REASON_USER_SWICTH);
1126 SoftBusFree(destroyInfo);
1127 SoftBusFree(sessionNode);
1128 SoftBusFree(SessionServer);
1129 }
1130
1131 /**
1132 * @tc.name: TransClientSessionTest32
1133 * @tc.desc: Transmission sdk session manager get exist session.
1134 * @tc.type: FUNC
1135 * @tc.require:
1136 */
1137 HWTEST_F(TransClientSessionTest, TransClientSessionTest32, TestSize.Level1)
1138 {
1139 SessionInfo *sessionNode = CreateNonEncryptSessionInfo(nullptr);
1140 EXPECT_TRUE(sessionNode == nullptr);
1141 char sessionName[SESSION_NAME_SIZE_MAX + TRANS_TEST_ADDR_INFO_NUM] = {0};
1142 memset_s(sessionName, sizeof(sessionName), 'A', SESSION_NAME_SIZE_MAX + 1);
1143 sessionNode = CreateNonEncryptSessionInfo(sessionName);
1144 EXPECT_TRUE(sessionNode == nullptr);
1145 }
1146
1147 /**
1148 * @tc.name: TransClientSessionTest33
1149 * @tc.desc: Transmission sdk session manager get exist session.
1150 * @tc.type: FUNC
1151 * @tc.require:
1152 */
1153 HWTEST_F(TransClientSessionTest, TransClientSessionTest33, TestSize.Level1)
1154 {
1155 int32_t channelId = TRANS_TEST_CHANNEL_ID;
1156 char myIp[IP_LEN] = {0};
1157 memcpy_s(myIp, IP_LEN, TRANS_TEST_CONN_IP, IP_LEN);
1158 int32_t ipLen = IP_LEN;
1159 int32_t ret = ClientTransGetTdcIp(channelId, myIp, ipLen);
1160 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
1161 ret = ClientTransGetUdpIp(channelId, myIp, ipLen);
1162 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
1163 }
1164
1165 /**
1166 * @tc.name: TransClientSessionTest34
1167 * @tc.desc: Transmission sdk session manager get exist session.
1168 * @tc.type: FUNC
1169 * @tc.require:
1170 */
1171 HWTEST_F(TransClientSessionTest, TransClientSessionTest34, TestSize.Level1)
1172 {
1173 char myIp[IP_LEN] = {0};
1174 memcpy_s(myIp, IP_LEN, TRANS_TEST_CONN_IP, IP_LEN);
1175 bool ret = ClientTransCheckHmlIp(myIp);
1176 EXPECT_FALSE(ret);
1177 memcpy_s(myIp, IP_LEN, TRANS_TEST_BR_MAC, IP_LEN);
1178 ret = ClientTransCheckHmlIp(myIp);
1179 EXPECT_TRUE(ret);
1180 }
1181
1182 /**
1183 * @tc.name: TransClientSessionTest35
1184 * @tc.desc: Transmission sdk session manager get exist session.
1185 * @tc.type: FUNC
1186 * @tc.require:
1187 */
1188 HWTEST_F(TransClientSessionTest, TransClientSessionTest35, TestSize.Level1)
1189 {
1190 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1191 ASSERT_TRUE(sessionParam != nullptr);
1192 TestGenerateCommParam(sessionParam);
1193 SessionInfo *info = TestGenerateSession(sessionParam);
1194 ASSERT_TRUE(info != nullptr);
1195 int32_t connType = TRANS_CONN_HML;
1196 int32_t routeType = WIFI_P2P_REUSE;
1197 bool ret = ClientTransCheckNeedDel(info, routeType, connType);
1198 EXPECT_FALSE(ret);
1199 routeType = ROUTE_TYPE_ALL;
1200 info->channelType = CHANNEL_TYPE_UDP;
1201 ret = ClientTransCheckNeedDel(info, routeType, connType);
1202 EXPECT_FALSE(ret);
1203 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
1204 ret = ClientTransCheckNeedDel(info, routeType, connType);
1205 EXPECT_FALSE(ret);
1206 info->channelType = CHANNEL_TYPE_AUTH;
1207 ret = ClientTransCheckNeedDel(info, routeType, connType);
1208 EXPECT_TRUE(ret);
1209 info->channelType = CHANNEL_TYPE_BUTT;
1210 ret = ClientTransCheckNeedDel(info, routeType, connType);
1211 EXPECT_FALSE(ret);
1212 SoftBusFree(sessionParam);
1213 SoftBusFree(info);
1214 }
1215
1216 /**
1217 * @tc.name: TransClientSessionTest36
1218 * @tc.desc: Transmission sdk session manager get exist session.
1219 * @tc.type: FUNC
1220 * @tc.require:
1221 */
1222 HWTEST_F(TransClientSessionTest, TransClientSessionTest36, TestSize.Level1)
1223 {
1224 ClientSessionServer server;
1225 char networkId[DEVICE_ID_SIZE_MAX] = {0};
1226 ASSERT_TRUE(networkId != NULL);
1227 int32_t type = 1;
1228 ListNode destroyList;
1229 DestroyClientSessionByNetworkId(nullptr, networkId, type, &destroyList);
1230 DestroyClientSessionByNetworkId(&server, nullptr, type, &destroyList);
1231 DestroyClientSessionByNetworkId(&server, networkId, type, nullptr);
1232 SessionServerInfo *info = CreateSessionServerInfoNode(nullptr);
1233 ASSERT_TRUE(info == nullptr);
1234 }
1235
1236 /**
1237 * @tc.name: TransClientSessionTest37
1238 * @tc.desc: Transmission sdk session manager get exist session.
1239 * @tc.type: FUNC
1240 * @tc.require:
1241 */
1242 HWTEST_F(TransClientSessionTest, TransClientSessionTest37, TestSize.Level1)
1243 {
1244 char pkgName[PKG_NAME_SIZE_MAX] = {0};
1245 char sessionName[SESSION_NAME_SIZE_MAX] = {0};
1246 memset_s(sessionName, SESSION_NAME_SIZE_MAX, 'A', SESSION_NAME_SIZE_MAX - 1);
1247 SoftBusSecType type = SEC_TYPE_PLAINTEXT;
1248 ClientSessionServer *server = GetNewSocketServer(type, nullptr, pkgName);
1249 ASSERT_TRUE(server == nullptr);
1250 server = GetNewSocketServer(type, sessionName, nullptr);
1251 ASSERT_TRUE(server == nullptr);
1252 bool ret = IsDistributedDataSession(nullptr);
1253 EXPECT_FALSE(ret);
1254 ret = IsDistributedDataSession(sessionName);
1255 EXPECT_FALSE(ret);
1256 }
1257
1258 /**
1259 * @tc.name: TransClientSessionTest38
1260 * @tc.desc: Transmission sdk session manager get exist session.
1261 * @tc.type: FUNC
1262 * @tc.require:
1263 */
1264 HWTEST_F(TransClientSessionTest, TransClientSessionTest38, TestSize.Level1)
1265 {
1266 SessionInfo sessionInfo;
1267 sessionInfo.info.flag = COMMON_VIDEO_STREAM;
1268 sessionInfo.isEncyptedRawStream = true;
1269 int dataType = RAW_STREAM;
1270 bool isEncyptedRawStream = true;
1271 bool ret = IsDifferentDataType(nullptr, dataType, isEncyptedRawStream);
1272 EXPECT_FALSE(ret);
1273 ret = IsDifferentDataType(&sessionInfo, dataType, isEncyptedRawStream);
1274 EXPECT_TRUE(ret);
1275 sessionInfo.info.flag = RAW_STREAM;
1276 ret = IsDifferentDataType(&sessionInfo, dataType, isEncyptedRawStream);
1277 EXPECT_FALSE(ret);
1278 dataType = COMMON_VIDEO_STREAM;
1279 sessionInfo.info.flag = COMMON_VIDEO_STREAM;
1280 ret = IsDifferentDataType(&sessionInfo, dataType, isEncyptedRawStream);
1281 EXPECT_FALSE(ret);
1282 }
1283
1284 /**
1285 * @tc.name: TransClientSessionTest39
1286 * @tc.desc: Transmission sdk session manager get exist session.
1287 * @tc.type: FUNC
1288 * @tc.require:
1289 */
1290 HWTEST_F(TransClientSessionTest, TransClientSessionTest39, TestSize.Level1)
1291 {
1292 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1293 ASSERT_TRUE(sessionParam != nullptr);
1294 TestGenerateCommParam(sessionParam);
1295 SessionInfo *info = CreateNewSocketSession(nullptr);
1296 ASSERT_TRUE(info == nullptr);
1297 info = CreateNewSocketSession(sessionParam);
1298 ASSERT_TRUE(info != nullptr);
1299 SoftBusFree(sessionParam);
1300 SoftBusFree(info);
1301 }
1302
1303 /**
1304 * @tc.name: TransClientSessionTest40
1305 * @tc.desc: Transmission sdk session manager get exist session.
1306 * @tc.type: FUNC
1307 * @tc.require:
1308 */
1309 HWTEST_F(TransClientSessionTest, TransClientSessionTest40, TestSize.Level1)
1310 {
1311 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1312 ASSERT_TRUE(sessionParam != nullptr);
1313 TestGenerateCommParam(sessionParam);
1314 SessionInfo *info = TestGenerateSession(sessionParam);
1315 ASSERT_TRUE(info != nullptr);
1316 ClientSessionServer serverNode;
1317 SessionAttribute tmpAttr;
1318 int32_t ret = CheckBindSocketInfo(nullptr);
1319 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1320 ret = CheckBindSocketInfo(info);
1321 EXPECT_EQ(ret, SOFTBUS_OK);
1322 info->info.flag = 0;
1323 ret = CheckBindSocketInfo(info);
1324 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1325 info->info.flag = TYPE_BUTT;
1326 ret = CheckBindSocketInfo(info);
1327 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1328 FillSessionParam(nullptr, &tmpAttr, &serverNode, info);
1329 FillSessionParam(sessionParam, nullptr, &serverNode, info);
1330 FillSessionParam(sessionParam, &tmpAttr, nullptr, info);
1331 FillSessionParam(sessionParam, &tmpAttr, &serverNode, nullptr);
1332 SoftBusFree(sessionParam);
1333 SoftBusFree(info);
1334 }
1335
1336 /**
1337 * @tc.name: TransClientSessionTest41
1338 * @tc.desc: Transmission sdk session manager get exist session.
1339 * @tc.type: FUNC
1340 * @tc.require:
1341 */
1342 HWTEST_F(TransClientSessionTest, TransClientSessionTest41, TestSize.Level1)
1343 {
1344 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1345 ASSERT_TRUE(sessionParam != nullptr);
1346 TestGenerateCommParam(sessionParam);
1347 SessionInfo *info = TestGenerateSession(sessionParam);
1348 ASSERT_TRUE(info != nullptr);
1349 ClientSessionServer serverNode;
1350 int32_t socket = 1;
1351 int32_t retOut = 0;
1352 int32_t socketId[5] = {0};
1353 uint32_t capacity = 1;
1354 uint32_t num = 1;
1355 ClientConvertRetVal(socket, &retOut);
1356 bool ret = CleanUpTimeoutAuthSession(socket);
1357 ASSERT_FALSE(ret);
1358 ClientCheckWaitTimeOut(nullptr, info, socketId, capacity, &num);
1359 ClientCheckWaitTimeOut(&serverNode, nullptr, socketId, capacity, &num);
1360 ClientCheckWaitTimeOut(&serverNode, info, nullptr, capacity, &num);
1361 ClientCheckWaitTimeOut(&serverNode, info, socketId, capacity, nullptr);
1362 ClientCheckWaitTimeOut(&serverNode, info, socketId, capacity, &num);
1363 ClientCleanUpWaitTimeoutSocket(nullptr, num);
1364 ClientCleanUpWaitTimeoutSocket(socketId, num);
1365 SoftBusFree(sessionParam);
1366 SoftBusFree(info);
1367 }
1368
1369 /**
1370 * @tc.name: TransClientSessionTest42
1371 * @tc.desc: Transmission sdk session manager get exist session.
1372 * @tc.type: FUNC
1373 * @tc.require:
1374 */
1375 HWTEST_F(TransClientSessionTest, TransClientSessionTest42, TestSize.Level1)
1376 {
1377 int32_t sessionId = 0;
1378 int32_t ret = ClientDeleteSocketSession(sessionId);
1379 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1380 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1381 ASSERT_TRUE(sessionParam != nullptr);
1382 TestGenerateCommParam(sessionParam);
1383 SessionInfo *info = TestGenerateSession(sessionParam);
1384 ASSERT_TRUE(info != nullptr);
1385 ClientSessionServer serverNode;
1386 SessionAttribute tmpAttr;
1387 ListNode destroyList;
1388 FillDfsSocketParam(nullptr, &tmpAttr, &serverNode, info);
1389 FillDfsSocketParam(sessionParam, nullptr, &serverNode, info);
1390 FillDfsSocketParam(sessionParam, &tmpAttr, nullptr, info);
1391 FillDfsSocketParam(sessionParam, &tmpAttr, &serverNode, nullptr);
1392 FillDfsSocketParam(sessionParam, &tmpAttr, &serverNode, info);
1393 ClientUpdateIdleTimeout(nullptr, info, &destroyList);
1394 ClientUpdateIdleTimeout(&serverNode, nullptr, &destroyList);
1395 ClientUpdateIdleTimeout(&serverNode, info, nullptr);
1396 SoftBusFree(sessionParam);
1397 SoftBusFree(info);
1398 }
1399 }
1400