1 /*
2 * Copyright (c) 2022-2025 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.test.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 BusCenterServerDeinit();
105 TransServerDeinit();
106 }
107
OnSessionOpened(int32_t sessionId,int32_t result)108 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
109 {
110 TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
111 return SOFTBUS_OK;
112 }
113
OnSessionClosed(int32_t sessionId)114 static void OnSessionClosed(int32_t sessionId)
115 {
116 TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
117 }
118
OnBytesReceived(int32_t sessionId,const void * data,unsigned int len)119 static void OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)
120 {
121 TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
122 }
123
OnMessageReceived(int32_t sessionId,const void * data,unsigned int len)124 static void OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)
125 {
126 TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
127 }
128
OnStreamReceived(int32_t sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)129 static void OnStreamReceived(int32_t sessionId, const StreamData *data,
130 const StreamData *ext, const StreamFrameInfo *param)
131 {
132 TRANS_LOGI(TRANS_TEST, "session stream received, sessionId=%{public}d", sessionId);
133 }
134
OnQosEvent(int32_t sessionId,int32_t eventId,int32_t tvCount,const QosTv * tvList)135 static void OnQosEvent(int32_t sessionId, int32_t eventId, int32_t tvCount, const QosTv *tvList)
136 {
137 TRANS_LOGI(TRANS_TEST, "session Qos event emit, sessionId=%{public}d", sessionId);
138 }
139
OnSessionOpenedErr(int32_t sessionId,int32_t result)140 static int32_t OnSessionOpenedErr(int32_t sessionId, int32_t result)
141 {
142 TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
143 return SOFTBUS_NOT_FIND;
144 }
145
OnReceiveFileStarted(int32_t sessionId,const char * files,int32_t fileCnt)146 static int32_t OnReceiveFileStarted(int32_t sessionId, const char *files, int32_t fileCnt)
147 {
148 TRANS_LOGI(TRANS_TEST, "receive file start, sessionId=%{public}d", sessionId);
149 return SOFTBUS_OK;
150 }
151
OnReceiveFileProcess(int32_t sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)152 static int32_t OnReceiveFileProcess(int32_t sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
153 {
154 TRANS_LOGI(TRANS_TEST, "receive file process, sessionId=%{public}d", sessionId);
155 return SOFTBUS_OK;
156 }
157
OnReceiveFileFinished(int32_t sessionId,const char * files,int32_t fileCnt)158 static void OnReceiveFileFinished(int32_t sessionId, const char *files, int32_t fileCnt)
159 {
160 TRANS_LOGI(TRANS_TEST, "receive file finished, sessionId=%{public}d", sessionId);
161 }
162
OnFileTransError(int32_t sessionId)163 void OnFileTransError(int32_t sessionId)
164 {
165 TRANS_LOGI(TRANS_TEST, "file transmission error, sessionId=%{public}d", sessionId);
166 }
167
OnSendFileProcess(int32_t sessionId,uint64_t bytesUpload,uint64_t bytesTotal)168 int32_t OnSendFileProcess(int32_t sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
169 {
170 TRANS_LOGI(TRANS_TEST, "send file process, sessionId=%{public}d", sessionId);
171 return SOFTBUS_OK;
172 }
173
OnSendFileFinished(int32_t sessionId,const char * firstFile)174 int32_t OnSendFileFinished(int32_t sessionId, const char *firstFile)
175 {
176 TRANS_LOGI(TRANS_TEST, "send file finished, sessionId=%{public}d", sessionId);
177 return SOFTBUS_OK;
178 }
179
180 static ISessionListener g_sessionlistener = {
181 .OnSessionOpened = OnSessionOpened,
182 .OnSessionClosed = OnSessionClosed,
183 .OnBytesReceived = OnBytesReceived,
184 .OnMessageReceived = OnMessageReceived,
185 .OnStreamReceived = OnStreamReceived,
186 .OnQosEvent = OnQosEvent,
187 };
188
189 static IFileReceiveListener g_fileRecvListener = {
190 .OnReceiveFileStarted = OnReceiveFileStarted,
191 .OnReceiveFileProcess = OnReceiveFileProcess,
192 .OnReceiveFileFinished = OnReceiveFileFinished,
193 .OnFileTransError = OnFileTransError
194 };
195
196 static IFileSendListener g_fileSendListener = {
197 .OnSendFileProcess = OnSendFileProcess,
198 .OnSendFileFinished = OnSendFileFinished,
199 .OnFileTransError = OnFileTransError
200 };
201
TestGenerateCommParam(SessionParam * sessionParam)202 static void TestGenerateCommParam(SessionParam *sessionParam)
203 {
204 sessionParam->sessionName = g_sessionName;
205 sessionParam->peerSessionName = g_sessionName;
206 sessionParam->peerDeviceId = g_deviceId;
207 sessionParam->groupId = g_groupId;
208 sessionParam->attr = &g_sessionAttr;
209 }
210
TestGenerateSession(const SessionParam * param)211 static SessionInfo *TestGenerateSession(const SessionParam *param)
212 {
213 SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
214 if (session == nullptr) {
215 return nullptr;
216 }
217
218 if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
219 strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
220 strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
221 SoftBusFree(session);
222 return nullptr;
223 }
224
225 session->sessionId = TRANS_TEST_SESSION_ID;
226 session->channelId = TRANS_TEST_CHANNEL_ID;
227 session->channelType = CHANNEL_TYPE_BUTT;
228 session->isServer = false;
229 session->enableStatus = ENABLE_STATUS_INIT;
230 session->routeType = ROUTE_TYPE_ALL;
231 session->info.flag = TYPE_BYTES;
232 session->isEncrypt = true;
233 session->algorithm = TRANS_TEST_ALGORITHM;
234 session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
235 session->crc = TRANS_TEST_CRC;
236 session->lifecycle.sessionState = SESSION_STATE_INIT;
237 return session;
238 }
239
AddSessionServerAndSession(const char * sessionName,int32_t channelType,bool isServer)240 static int32_t AddSessionServerAndSession(const char *sessionName, int32_t channelType, bool isServer)
241 {
242 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
243 if (sessionParam == nullptr) {
244 return SOFTBUS_MALLOC_ERR;
245 }
246
247 TestGenerateCommParam(sessionParam);
248 sessionParam->sessionName = sessionName;
249 uint64_t timestamp = 0;
250 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, sessionName, &g_sessionlistener, ×tamp);
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 uint64_t timestamp = 0;
299 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener, ×tamp);
300 ASSERT_EQ(ret, SOFTBUS_OK);
301 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
302 ASSERT_TRUE(sessionParam != nullptr);
303 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
304 TestGenerateCommParam(sessionParam);
305 SessionInfo *session = TestGenerateSession(sessionParam);
306 ASSERT_TRUE(session != nullptr);
307 session->channelType = CHANNEL_TYPE_AUTH;
308 ret = ClientAddNewSession(g_sessionName, session);
309 ASSERT_EQ(ret, SOFTBUS_OK);
310 ret = OpenSessionWithExistSession(session->sessionId, isEnabled);
311 EXPECT_EQ(ret, session->sessionId);
312 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
313 EXPECT_EQ(ret, SOFTBUS_OK);
314 SoftBusFree(sessionParam);
315 }
316
317 /**
318 * @tc.name: TransClientSessionTest02
319 * @tc.desc: Transmission sdk session service open session with existed session callback error.
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(TransClientSessionTest, TransClientSessionTest02, TestSize.Level1)
324 {
325 bool isEnabled = false;
326 ISessionListener sessionlistener = {
327 .OnSessionOpened = OnSessionOpenedErr,
328 .OnSessionClosed = OnSessionClosed,
329 .OnBytesReceived = OnBytesReceived,
330 .OnMessageReceived = OnMessageReceived,
331 .OnStreamReceived = OnStreamReceived,
332 .OnQosEvent = OnQosEvent,
333 };
334 uint64_t timestamp = 0;
335 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &sessionlistener, ×tamp);
336 ASSERT_EQ(ret, SOFTBUS_OK);
337 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
338 ASSERT_TRUE(sessionParam != nullptr);
339 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
340 TestGenerateCommParam(sessionParam);
341 SessionInfo *session = TestGenerateSession(sessionParam);
342 ASSERT_TRUE(session != nullptr);
343 session->channelType = CHANNEL_TYPE_AUTH;
344 ret = ClientAddNewSession(g_sessionName, session);
345 ASSERT_EQ(ret, SOFTBUS_OK);
346 isEnabled = true;
347 ret = OpenSessionWithExistSession(session->sessionId, isEnabled);
348 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
349 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
350 EXPECT_EQ(ret, SOFTBUS_OK);
351 SoftBusFree(sessionParam);
352 }
353
354 /**
355 * @tc.name: TransClientSessionTest03
356 * @tc.desc: Transmission sdk session service creat session server with different parameters.
357 * @tc.type: FUNC
358 * @tc.require:
359 */
360 HWTEST_F(TransClientSessionTest, TransClientSessionTest03, TestSize.Level0)
361 {
362 const char *pkgName = "package.test";
363 int32_t ret = CreateSessionServer(pkgName, g_sessionName, &g_sessionlistener);
364 EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
365 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
366 EXPECT_EQ(ret, SOFTBUS_OK);
367 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
368 EXPECT_EQ(ret, SOFTBUS_OK);
369 ret = RemoveSessionServer(g_pkgName, g_sessionName);
370 EXPECT_EQ(ret, SOFTBUS_OK);
371 }
372
373 /**
374 * @tc.name: TransClientSessionTest04
375 * @tc.desc: Transmission sdk session service remove session server with different parameters.
376 * @tc.type: FUNC
377 * @tc.require:
378 */
379 HWTEST_F(TransClientSessionTest, TransClientSessionTest04, TestSize.Level0)
380 {
381 int32_t ret = RemoveSessionServer(g_pkgName, g_sessionName);
382 EXPECT_EQ(ret, SOFTBUS_TRANS_CHECK_PID_ERROR);
383 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
384 EXPECT_EQ(ret, SOFTBUS_OK);
385 ret = RemoveSessionServer(g_pkgName, g_sessionName);
386 EXPECT_EQ(ret, SOFTBUS_OK);
387 }
388
389 /**
390 * @tc.name: TransClientSessionTest05
391 * @tc.desc: Transmission sdk session service open session.
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(TransClientSessionTest, TransClientSessionTest05, TestSize.Level0)
396 {
397 int32_t sessionId = 0;
398 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
399 int32_t ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
400 ASSERT_EQ(ret, SOFTBUS_OK);
401 ret = OpenSession(g_sessionName, g_sessionName, g_networkId, g_groupId, &g_sessionAttr);
402 EXPECT_NE(ret, SOFTBUS_OK);
403 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
404 ASSERT_TRUE(sessionParam != nullptr);
405 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
406 TestGenerateCommParam(sessionParam);
407 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
408 ASSERT_EQ(ret, SOFTBUS_OK);
409 ret = OpenSession(g_sessionName, g_sessionName, g_networkId, g_groupId, &g_sessionAttr);
410 EXPECT_EQ(ret, sessionId);
411 ret = ClientDeleteSession(sessionId);
412 EXPECT_EQ(ret, SOFTBUS_OK);
413 ret = RemoveSessionServer(g_pkgName, g_sessionName);
414 EXPECT_EQ(ret, SOFTBUS_OK);
415 }
416
417 /**
418 * @tc.name: TransClientSessionTest06
419 * @tc.desc: Transmission sdk session service convert address string with different parameters.
420 * @tc.type: FUNC
421 * @tc.require:
422 */
423 HWTEST_F(TransClientSessionTest, TransClientSessionTest06, TestSize.Level1)
424 {
425 ConnectionAddr *addrInfo = (ConnectionAddr*)SoftBusMalloc(sizeof(ConnectionAddr));
426 ASSERT_TRUE(addrInfo != nullptr);
427 int32_t ret = ConvertAddrStr(TRANS_TEST_AUTH_DATA, addrInfo);
428 EXPECT_EQ(ret, SOFTBUS_PARSE_JSON_ERR);
429 cJSON *msg = cJSON_CreateObject();
430 bool res = AddStringToJsonObject(msg, "ETH_IP", TRANS_TEST_CONN_IP);
431 ASSERT_TRUE(res);
432 res = AddNumberToJsonObject(msg, "ETH_PORT", TRANS_TEST_AUTH_PORT);
433 ASSERT_TRUE(res);
434 char *data = cJSON_PrintUnformatted(msg);
435 ret = ConvertAddrStr(data, addrInfo);
436 EXPECT_EQ(ret, SOFTBUS_OK);
437 cJSON_free(data);
438 cJSON_Delete(msg);
439 msg = cJSON_CreateObject();
440 res = AddStringToJsonObject(msg, "WIFI_IP", TRANS_TEST_CONN_IP);
441 ASSERT_TRUE(res);
442 res = AddNumberToJsonObject(msg, "WIFI_PORT", TRANS_TEST_AUTH_PORT);
443 ASSERT_TRUE(res);
444 data = cJSON_PrintUnformatted(msg);
445 ret = ConvertAddrStr(data, addrInfo);
446 EXPECT_EQ(ret, SOFTBUS_OK);
447 cJSON_free(data);
448 cJSON_Delete(msg);
449 msg = cJSON_CreateObject();
450 res = AddStringToJsonObject(msg, "BR_MAC", TRANS_TEST_BR_MAC);
451 ASSERT_TRUE(res);
452 data = cJSON_PrintUnformatted(msg);
453 ret = ConvertAddrStr(data, addrInfo);
454 EXPECT_EQ(ret, SOFTBUS_OK);
455 cJSON_free(data);
456 cJSON_Delete(msg);
457 msg = cJSON_CreateObject();
458 res = AddStringToJsonObject(msg, "BLE_MAC", TRANS_TEST_BR_MAC);
459 ASSERT_TRUE(res);
460 data = cJSON_PrintUnformatted(msg);
461 ret = ConvertAddrStr(data, addrInfo);
462 EXPECT_EQ(ret, SOFTBUS_OK);
463 cJSON_free(data);
464 cJSON_Delete(msg);
465 SoftBusFree(addrInfo);
466 }
467
468 /**
469 * @tc.name: TransClientSessionTest07
470 * @tc.desc: Transmission sdk session service is valid addrInfo.
471 * @tc.type: FUNC
472 * @tc.require:
473 */
474 HWTEST_F(TransClientSessionTest, TransClientSessionTest07, TestSize.Level1)
475 {
476 ConnectionAddr addrInfoArr[TRANS_TEST_ADDR_INFO_NUM] = {
477 {.type = CONNECTION_ADDR_MAX},
478 {.type = CONNECTION_ADDR_MAX}
479 };
480 int32_t ret = IsValidAddrInfoArr(addrInfoArr, TRANS_TEST_ADDR_INFO_NUM);
481 EXPECT_EQ(ret, -1);
482 }
483
484 /**
485 * @tc.name: TransClientSessionTest08
486 * @tc.desc: Transmission sdk session service open auth session with different.
487 * @tc.type: FUNC
488 * @tc.require:
489 */
490 HWTEST_F(TransClientSessionTest, TransClientSessionTest08, TestSize.Level0)
491 {
492 ConnectionAddr addrInfoArr[TRANS_TEST_ADDR_INFO_NUM] = {
493 {.type = CONNECTION_ADDR_MAX},
494 {.type = CONNECTION_ADDR_MAX}
495 };
496 cJSON *msg = cJSON_CreateObject();
497 bool res = AddStringToJsonObject(msg, "BLE_MAC", TRANS_TEST_BR_MAC);
498 ASSERT_TRUE(res);
499 char *data = cJSON_PrintUnformatted(msg);
500 int32_t ret = OpenAuthSession(g_sessionName, addrInfoArr, TRANS_TEST_ADDR_INFO_NUM, data);
501 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
502 ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
503 ASSERT_EQ(ret, SOFTBUS_OK);
504 ret = CreateSessionServer(g_pkgName, NEW_SESSION_NAME, &g_sessionlistener);
505 ASSERT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
506 ret = OpenAuthSession(g_sessionName, addrInfoArr, TRANS_TEST_ADDR_INFO_NUM, data);
507 ret = ClientDeleteSession(ret);
508 EXPECT_EQ(ret, SOFTBUS_OK);
509 cJSON_free(data);
510 cJSON_Delete(msg);
511 msg = cJSON_CreateObject();
512 res = AddStringToJsonObject(msg, "WIFI_IP", TRANS_TEST_CONN_IP);
513 ASSERT_TRUE(res);
514 res = AddNumberToJsonObject(msg, "WIFI_PORT", TRANS_TEST_AUTH_PORT);
515 ASSERT_TRUE(res);
516 data = cJSON_PrintUnformatted(msg);
517 ret = OpenAuthSession(NEW_SESSION_NAME, addrInfoArr, TRANS_TEST_ADDR_INFO_NUM, data);
518 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
519 ret = ClientDeleteSession(ret);
520 EXPECT_EQ(ret, SOFTBUS_TRANS_INVALID_SESSION_ID);
521 ret = RemoveSessionServer(g_pkgName, g_sessionName);
522 EXPECT_EQ(ret, SOFTBUS_OK);
523 ret = RemoveSessionServer(g_pkgName, NEW_SESSION_NAME);
524 EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
525 cJSON_free(data);
526 cJSON_Delete(msg);
527 }
528
529 /**
530 * @tc.name: TransClientSessionTest09
531 * @tc.desc: Transmission sdk session service notify auth success with different parameters.
532 * @tc.type: FUNC
533 * @tc.require:
534 */
535 HWTEST_F(TransClientSessionTest, TransClientSessionTest09, TestSize.Level1)
536 {
537 int32_t sessionId = 0;
538 bool isClosing = false;
539 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
540 int32_t ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
541 ASSERT_EQ(ret, SOFTBUS_OK);
542 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
543 ASSERT_TRUE(sessionParam != nullptr);
544 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
545 TestGenerateCommParam(sessionParam);
546 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
547 ASSERT_EQ(ret, SOFTBUS_OK);
548 NotifyAuthSuccess(sessionId);
549 ret = ClientDeleteSession(sessionId);
550 ASSERT_EQ(ret, SOFTBUS_OK);
551 SessionInfo *session = TestGenerateSession(sessionParam);
552 ASSERT_TRUE(session != nullptr);
553 session->isServer = true;
554 ret = ClientAddNewSession(g_sessionName, session);
555 ASSERT_EQ(ret, SOFTBUS_OK);
556 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &sessionId, isClosing);
557 EXPECT_EQ(ret, SOFTBUS_OK);
558 NotifyAuthSuccess(sessionId);
559 ret = ClientDeleteSession(sessionId);
560 EXPECT_EQ(ret, SOFTBUS_OK);
561 ret = RemoveSessionServer(g_pkgName, g_sessionName);
562 EXPECT_EQ(ret, SOFTBUS_OK);
563 SoftBusFree(sessionParam);
564 }
565
566 /**
567 * @tc.name: TransClientSessionTest10
568 * @tc.desc: Transmission sdk session service check whether session is opened with different parameters.
569 * @tc.type: FUNC
570 * @tc.require:
571 */
572 HWTEST_F(TransClientSessionTest, TransClientSessionTest10, TestSize.Level1)
573 {
574 int32_t sessionId = 0;
575 bool isClosing = false;
576 int32_t ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
577 ASSERT_EQ(ret, SOFTBUS_OK);
578 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
579 ASSERT_TRUE(sessionParam != nullptr);
580 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
581 TestGenerateCommParam(sessionParam);
582 SessionInfo *session = TestGenerateSession(sessionParam);
583 ASSERT_TRUE(session != nullptr);
584 session->enableStatus = ENABLE_STATUS_SUCCESS;
585 ret = CheckSessionIsOpened(TRANS_TEST_CHANNEL_ID, false);
586 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED);
587 ret = ClientAddNewSession(g_sessionName, session);
588 ASSERT_EQ(ret, SOFTBUS_OK);
589 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &sessionId, isClosing);
590 EXPECT_EQ(ret, SOFTBUS_OK);
591 ret = CheckSessionIsOpened(sessionId, false);
592 EXPECT_EQ(ret, SOFTBUS_OK);
593 ret = ClientDeleteSession(sessionId);
594 EXPECT_EQ(ret, SOFTBUS_OK);
595 ret = RemoveSessionServer(g_pkgName, g_sessionName);
596 EXPECT_EQ(ret, SOFTBUS_OK);
597 SoftBusFree(sessionParam);
598 }
599
600 /**
601 * @tc.name: TransClientSessionTest11
602 * @tc.desc: Transmission sdk session service close session with different parameters.
603 * @tc.type: FUNC
604 * @tc.require:
605 */
606 HWTEST_F(TransClientSessionTest, TransClientSessionTest11, TestSize.Level1)
607 {
608 int32_t sessionId = 0;
609 bool isClosing = false;
610 int32_t ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
611 ASSERT_EQ(ret, SOFTBUS_OK);
612 CloseSession(TRANS_TEST_INVALID_SESSION_ID);
613 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
614 ASSERT_TRUE(sessionParam != nullptr);
615 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
616 TestGenerateCommParam(sessionParam);
617 SessionInfo *session = TestGenerateSession(sessionParam);
618 ASSERT_TRUE(session != nullptr);
619 session->channelType = CHANNEL_TYPE_UDP;
620 CloseSession(TRANS_TEST_SESSION_ID);
621 ret = ClientAddNewSession(g_sessionName, session);
622 ASSERT_EQ(ret, SOFTBUS_OK);
623 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId, isClosing);
624 EXPECT_EQ(ret, SOFTBUS_OK);
625 CloseSession(sessionId);
626 ret = ClientDeleteSession(sessionId);
627 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
628 session = TestGenerateSession(sessionParam);
629 ASSERT_TRUE(session != nullptr);
630 session->channelType = CHANNEL_TYPE_AUTH;
631 ret = ClientAddNewSession(g_sessionName, session);
632 ASSERT_EQ(ret, SOFTBUS_OK);
633 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_AUTH, &sessionId, isClosing);
634 EXPECT_EQ(ret, SOFTBUS_OK);
635 CloseSession(sessionId);
636 ret = ClientDeleteSession(sessionId);
637 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
638 ret = RemoveSessionServer(g_pkgName, g_sessionName);
639 EXPECT_EQ(ret, SOFTBUS_OK);
640 SoftBusFree(sessionParam);
641 }
642
643 /**
644 * @tc.name: TransClientSessionTest12
645 * @tc.desc: Transmission sdk session service get my session name with invalid parameters.
646 * @tc.type: FUNC
647 * @tc.require:
648 */
649 HWTEST_F(TransClientSessionTest, TransClientSessionTest12, TestSize.Level1)
650 {
651 char sessionName[SESSION_NAME_SIZE_MAX] = {0};
652 int32_t ret = GetMySessionName(TRANS_TEST_INVALID_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
653 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
654 ret = GetMySessionName(TRANS_TEST_SESSION_ID, nullptr, SESSION_NAME_SIZE_MAX);
655 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
656 ret = GetMySessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX + 1);
657 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
658 }
659
660 /**
661 * @tc.name: TransClientSessionTest13
662 * @tc.desc: Transmission sdk session service get peer session name with different parameters.
663 * @tc.type: FUNC
664 * @tc.require:
665 */
666 HWTEST_F(TransClientSessionTest, TransClientSessionTest13, TestSize.Level1)
667 {
668 char sessionName[SESSION_NAME_SIZE_MAX] = {0};
669 int32_t ret = GetPeerSessionName(TRANS_TEST_INVALID_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
670 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
671 ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, nullptr, SESSION_NAME_SIZE_MAX);
672 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
673 ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX + 1);
674 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
675 ret = GetPeerSessionName(TRANS_TEST_SESSION_ID, sessionName, SESSION_NAME_SIZE_MAX);
676 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
677 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
678 ASSERT_GT(sessionId, 0);
679 ret = GetPeerSessionName(sessionId, sessionName, SESSION_NAME_SIZE_MAX);
680 EXPECT_EQ(ret, SOFTBUS_OK);
681 ret = strcmp(g_sessionName, sessionName);
682 EXPECT_EQ(ret, EOK);
683 DeleteSessionServerAndSession(g_sessionName, sessionId);
684 }
685
686 /**
687 * @tc.name: TransClientSessionTest14
688 * @tc.desc: Transmission sdk session service get peer device Id with different parameters.
689 * @tc.type: FUNC
690 * @tc.require:
691 */
692 HWTEST_F(TransClientSessionTest, TransClientSessionTest14, TestSize.Level1)
693 {
694 char networkId[DEVICE_ID_SIZE_MAX] = {0};
695 int32_t ret = GetPeerDeviceId(TRANS_TEST_INVALID_SESSION_ID, networkId, DEVICE_ID_SIZE_MAX);
696 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
697 ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, nullptr, DEVICE_ID_SIZE_MAX);
698 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
699 ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, networkId, SESSION_NAME_SIZE_MAX + 1);
700 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
701 ret = GetPeerDeviceId(TRANS_TEST_SESSION_ID, networkId, DEVICE_ID_SIZE_MAX);
702 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
703 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
704 ASSERT_GT(sessionId, 0);
705 ret = GetPeerDeviceId(sessionId, networkId, DEVICE_ID_SIZE_MAX);
706 EXPECT_EQ(ret, SOFTBUS_OK);
707 ret = strcmp(g_deviceId, networkId);
708 EXPECT_EQ(ret, EOK);
709 DeleteSessionServerAndSession(g_sessionName, sessionId);
710 }
711
712 /**
713 * @tc.name: TransClientSessionTest15
714 * @tc.desc: Transmission sdk session service judge session server or client.
715 * @tc.type: FUNC
716 * @tc.require:
717 */
718 HWTEST_F(TransClientSessionTest, TransClientSessionTest15, TestSize.Level1)
719 {
720 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
721 EXPECT_EQ(ret, -1);
722 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
723 ASSERT_GT(sessionId, 0);
724 ret = GetSessionSide(sessionId);
725 EXPECT_EQ(ret, IS_CLIENT);
726 DeleteSessionServerAndSession(g_sessionName, sessionId);
727 sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, true);
728 ASSERT_GT(sessionId, 0);
729 ret = GetSessionSide(sessionId);
730 EXPECT_EQ(ret, IS_SERVER);
731 DeleteSessionServerAndSession(g_sessionName, sessionId);
732 }
733
734 /**
735 * @tc.name: TransClientSessionTest16
736 * @tc.desc: Transmission sdk session service set file receive listener with different parameters.
737 * @tc.type: FUNC
738 * @tc.require:
739 */
740 HWTEST_F(TransClientSessionTest, TransClientSessionTest16, TestSize.Level1)
741 {
742 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
743 memset_s(sessionName, SESSION_NAME_SIZE_MAX + 2, 'A', SESSION_NAME_SIZE_MAX + 1);
744 char pkgName[PKG_NAME_SIZE_MAX + 2] = {0};
745 memset_s(pkgName, PKG_NAME_SIZE_MAX + 2, 'B', PKG_NAME_SIZE_MAX + 1);
746 char rootDir[FILE_RECV_ROOT_DIR_SIZE_MAX + 2] = {0};
747 memset_s(rootDir, FILE_RECV_ROOT_DIR_SIZE_MAX + 2, 'C', FILE_RECV_ROOT_DIR_SIZE_MAX + 1);
748 int32_t ret = SetFileReceiveListener(pkgName, g_sessionName, &g_fileRecvListener, g_rootDir);
749 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
750 ret = SetFileReceiveListener(g_pkgName, sessionName, &g_fileRecvListener, g_rootDir);
751 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
752 ret = SetFileReceiveListener(g_pkgName, g_sessionName, nullptr, g_rootDir);
753 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
754 ret = SetFileReceiveListener(g_pkgName, g_sessionName, &g_fileRecvListener, nullptr);
755 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
756 ret = SetFileReceiveListener(g_pkgName, g_sessionName, &g_fileRecvListener, g_rootDir);
757 EXPECT_EQ(ret, SOFTBUS_OK);
758 }
759
760 /**
761 * @tc.name: TransClientSessionTest17
762 * @tc.desc: Transmission sdk session service set file send listener with different parameters.
763 * @tc.type: FUNC
764 * @tc.require:
765 */
766 HWTEST_F(TransClientSessionTest, TransClientSessionTest17, TestSize.Level1)
767 {
768 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
769 memset_s(sessionName, SESSION_NAME_SIZE_MAX + 2, 'A', SESSION_NAME_SIZE_MAX + 1);
770 char pkgName[PKG_NAME_SIZE_MAX + 2] = {0};
771 memset_s(pkgName, PKG_NAME_SIZE_MAX + 2, 'B', PKG_NAME_SIZE_MAX + 1);
772 char rootDir[FILE_RECV_ROOT_DIR_SIZE_MAX + 2] = {0};
773 memset_s(rootDir, FILE_RECV_ROOT_DIR_SIZE_MAX + 2, 'C', FILE_RECV_ROOT_DIR_SIZE_MAX + 1);
774 int32_t ret = SetFileSendListener(pkgName, g_sessionName, &g_fileSendListener);
775 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
776 ret = SetFileSendListener(g_pkgName, sessionName, &g_fileSendListener);
777 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
778 ret = SetFileSendListener(g_pkgName, g_sessionName, nullptr);
779 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
780 ret = SetFileSendListener(g_pkgName, g_sessionName, &g_fileSendListener);
781 EXPECT_EQ(ret, SOFTBUS_OK);
782 }
783
784 /**
785 * @tc.name: TransClientSessionTest18
786 * @tc.desc: Transmission sdk session service judge whether session is DFS with different parameters.
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(TransClientSessionTest, TransClientSessionTest18, TestSize.Level1)
791 {
792 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, false);
793 ASSERT_GT(sessionId, 0);
794 int32_t channelId = 0;
795 int32_t ret = IsValidDFSSession(sessionId, &channelId);
796 EXPECT_EQ(ret, SOFTBUS_TRANS_FUNC_NOT_SUPPORT);
797 DeleteSessionServerAndSession(g_sessionName, sessionId);
798 const char *dfsSessionName = "DistributedFileService";
799 sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_BUTT, false);
800 ASSERT_GT(sessionId, 0);
801 ret = IsValidDFSSession(sessionId, &channelId);
802 EXPECT_EQ(ret, SOFTBUS_TRANS_FUNC_NOT_SUPPORT);
803 EXPECT_EQ(channelId, TRANS_TEST_CHANNEL_ID);
804 DeleteSessionServerAndSession(dfsSessionName, sessionId);
805 sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_TCP_DIRECT, false);
806 ASSERT_GT(sessionId, 0);
807 ret = IsValidDFSSession(sessionId, &channelId);
808 EXPECT_EQ(ret, SOFTBUS_OK);
809 EXPECT_EQ(channelId, TRANS_TEST_CHANNEL_ID);
810 DeleteSessionServerAndSession(dfsSessionName, sessionId);
811 }
812
813 /**
814 * @tc.name: TransClientSessionTest19
815 * @tc.desc: Transmission sdk session service get session key with different parameters.
816 * @tc.type: FUNC
817 * @tc.require:
818 */
819 HWTEST_F(TransClientSessionTest, TransClientSessionTest19, TestSize.Level1)
820 {
821 const char *dfsSessionName = "DistributedFileService";
822 int32_t sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_TCP_DIRECT, false);
823 ASSERT_GT(sessionId, 0);
824 char sessionKey[SESSION_KEY_LEN] = {0};
825 int32_t ret = GetSessionKey(sessionId, sessionKey, SESSION_KEY_LEN);
826 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
827 DeleteSessionServerAndSession(dfsSessionName, sessionId);
828 }
829
830 /**
831 * @tc.name: TransClientSessionTest20
832 * @tc.desc: Transmission sdk session service get session handle.
833 * @tc.type: FUNC
834 * @tc.require:
835 */
836 HWTEST_F(TransClientSessionTest, TransClientSessionTest20, TestSize.Level1)
837 {
838 const char *dfsSessionName = "DistributedFileService";
839 int32_t sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_TCP_DIRECT, false);
840 ASSERT_GT(sessionId, 0);
841 int32_t handle = 0;
842 int32_t ret = GetSessionHandle(sessionId, &handle);
843 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
844 DeleteSessionServerAndSession(dfsSessionName, sessionId);
845 }
846
847 /**
848 * @tc.name: TransClientSessionTest21
849 * @tc.desc: Transmission sdk session service disable session listener.
850 * @tc.type: FUNC
851 * @tc.require:
852 */
853 HWTEST_F(TransClientSessionTest, TransClientSessionTest21, TestSize.Level1)
854 {
855 const char *dfsSessionName = "DistributedFileService";
856 int32_t sessionId = AddSessionServerAndSession(dfsSessionName, CHANNEL_TYPE_TCP_DIRECT, false);
857 ASSERT_GT(sessionId, 0);
858 int32_t ret = DisableSessionListener(sessionId);
859 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
860 DeleteSessionServerAndSession(dfsSessionName, sessionId);
861 }
862
863 /**
864 * @tc.name: TransClientSessionTest22
865 * @tc.desc: Transmission sdk session service read max send bytes size with different parameters.
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 HWTEST_F(TransClientSessionTest, TransClientSessionTest22, TestSize.Level1)
870 {
871 uint32_t value = 0;
872 int32_t ret = ReadMaxSendBytesSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT,
873 &value, TRANS_TEST_INVALID_VALUE_SIZE);
874 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
875 ret = ReadMaxSendBytesSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT, nullptr, TRANS_TEST_INVALID_VALUE_SIZE);
876 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
877 ret = ReadMaxSendBytesSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &value, sizeof(value));
878 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
879 }
880
881 /**
882 * @tc.name: TransClientSessionTest23
883 * @tc.desc: Transmission sdk session service read max send message size with different parameters.
884 * @tc.type: FUNC
885 * @tc.require:
886 */
887 HWTEST_F(TransClientSessionTest, TransClientSessionTest23, TestSize.Level1)
888 {
889 uint32_t value = 0;
890 int32_t ret = ReadMaxSendMessageSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_TCP_DIRECT,
891 &value, TRANS_TEST_INVALID_VALUE_SIZE);
892 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
893 ret = ReadMaxSendMessageSize(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &value, sizeof(value));
894 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
895 }
896
897 /**
898 * @tc.name: TransClientSessionTest24
899 * @tc.desc: Transmission sdk session service get session option with different parameters.
900 * @tc.type: FUNC
901 * @tc.require:
902 */
903 HWTEST_F(TransClientSessionTest, TransClientSessionTest24, TestSize.Level1)
904 {
905 uint32_t optionValue = 0;
906 int32_t ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_BUTT,
907 &optionValue, sizeof(optionValue));
908 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
909 ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
910 nullptr, sizeof(optionValue));
911 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
912 ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
913 &optionValue, 0);
914 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
915 ret = GetSessionOption(TRANS_TEST_SESSION_ID, SESSION_OPTION_MAX_SENDBYTES_SIZE,
916 &optionValue, sizeof(optionValue));
917 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_GET_CHANNEL_FAILED);
918 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
919 ASSERT_GT(sessionId, 0);
920 ret = GetSessionOption(sessionId, SESSION_OPTION_MAX_SENDBYTES_SIZE,
921 &optionValue, sizeof(optionValue));
922 EXPECT_EQ(ret, SOFTBUS_OK);
923 DeleteSessionServerAndSession(g_sessionName, sessionId);
924 }
925
926 /**
927 * @tc.name: TransClientSessionTest25
928 * @tc.desc: Transmission sdk session manager lnn offline process with different parameters.
929 * @tc.type: FUNC
930 * @tc.require:
931 */
932 HWTEST_F(TransClientSessionTest, TransClientSessionTest25, TestSize.Level1)
933 {
934 ClientTransLnnOfflineProc(nullptr);
935 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
936 ASSERT_GT(sessionId, 0);
937
938 NodeBasicInfo info;
939 memset_s(&info, sizeof(NodeBasicInfo), 0, sizeof(NodeBasicInfo));
940 int32_t ret = strcpy_s(info.networkId, sizeof(info.networkId), g_networkId);
941 ASSERT_EQ(ret, EOK);
942 ret = strcpy_s(info.deviceName, sizeof(info.deviceName), g_deviceName);
943 ASSERT_EQ(ret, EOK);
944 info.deviceTypeId = TRANS_TEST_DEVICE_TYPE_ID;
945 ClientTransLnnOfflineProc(&info);
946
947 DeleteSessionServerAndSession(g_sessionName, sessionId);
948 }
949
950 /**
951 * @tc.name: TransClientSessionTest26
952 * @tc.desc: Transmission sdk session manager judge session whether session is available.
953 * @tc.type: FUNC
954 * @tc.require:
955 */
956 HWTEST_F(TransClientSessionTest, TransClientSessionTest26, TestSize.Level1)
957 {
958 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
959 ASSERT_GT(sessionId, 0);
960 DestroyClientSessionServer(nullptr, nullptr);
961 bool res = SessionIdIsAvailable(sessionId);
962 EXPECT_FALSE(res);
963
964 DeleteSessionServerAndSession(g_sessionName, sessionId);
965 }
966
967 /**
968 * @tc.name: TransClientSessionTest27
969 * @tc.desc: Transmission sdk session manager get new session server with different parameters.
970 * @tc.type: FUNC
971 * @tc.require:
972 */
973 HWTEST_F(TransClientSessionTest, TransClientSessionTest27, TestSize.Level1)
974 {
975 ClientSessionServer *server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, g_pkgName, &g_sessionlistener);
976 ASSERT_TRUE(server != nullptr);
977 ListNode destroyList;
978 DestroyAllClientSession(nullptr, &destroyList);
979 DestroyAllClientSession(server, nullptr);
980 DestroyAllClientSession(server, &destroyList);
981 SoftBusFree(server);
982 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
983 memset_s(sessionName, sizeof(sessionName), 'A', SESSION_NAME_SIZE_MAX + 1);
984 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, sessionName, g_pkgName, &g_sessionlistener);
985 EXPECT_TRUE(server == nullptr);
986 char pkgName[PKG_NAME_SIZE_MAX + 2] = {0};
987 memset_s(pkgName, sizeof(pkgName), 'B', PKG_NAME_SIZE_MAX + 1);
988 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, pkgName, &g_sessionlistener);
989 EXPECT_TRUE(server == nullptr);
990 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, nullptr, pkgName, &g_sessionlistener);
991 EXPECT_TRUE(server == nullptr);
992 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, nullptr, &g_sessionlistener);
993 EXPECT_TRUE(server == nullptr);
994 server = GetNewSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName, pkgName, nullptr);
995 EXPECT_TRUE(server == nullptr);
996 }
997
998 /**
999 * @tc.name: TransClientSessionTest28
1000 * @tc.desc: Transmission sdk session manager judge whether parameter is valid with different parameters.
1001 * @tc.type: FUNC
1002 * @tc.require:
1003 */
1004 HWTEST_F(TransClientSessionTest, TransClientSessionTest28, TestSize.Level1)
1005 {
1006 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1007 ASSERT_TRUE(sessionParam != nullptr);
1008
1009 bool res = IsValidSessionParam(nullptr);
1010 EXPECT_FALSE(res);
1011 res = IsValidSessionParam(sessionParam);
1012 EXPECT_FALSE(res);
1013 sessionParam->sessionName = g_sessionName;
1014 res = IsValidSessionParam(sessionParam);
1015 EXPECT_FALSE(res);
1016 sessionParam->peerSessionName = g_sessionName;
1017 res = IsValidSessionParam(sessionParam);
1018 EXPECT_FALSE(res);
1019 sessionParam->peerDeviceId = g_deviceId;
1020 res = IsValidSessionParam(sessionParam);
1021 EXPECT_FALSE(res);
1022 sessionParam->groupId = g_groupId;
1023 res = IsValidSessionParam(sessionParam);
1024 EXPECT_FALSE(res);
1025 sessionParam->attr = (const SessionAttribute*)&g_sessionAttr;
1026 res = IsValidSessionParam(sessionParam);
1027 EXPECT_TRUE(res);
1028
1029 SoftBusFree(sessionParam);
1030 }
1031
1032 /**
1033 * @tc.name: TransClientSessionTest29
1034 * @tc.desc: Transmission sdk session manager create new session with different parameters.
1035 * @tc.type: FUNC
1036 * @tc.require:
1037 */
1038 HWTEST_F(TransClientSessionTest, TransClientSessionTest29, TestSize.Level1)
1039 {
1040 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1041 ASSERT_TRUE(sessionParam != nullptr);
1042
1043 TestGenerateCommParam(sessionParam);
1044 SessionInfo *session = CreateNewSession(sessionParam);
1045 EXPECT_TRUE(session != nullptr);
1046 SoftBusFree(session);
1047
1048 session = CreateNewSession(nullptr);
1049 EXPECT_TRUE(session == nullptr);
1050
1051 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
1052 memset_s(sessionName, sizeof(sessionName), 'A', SESSION_NAME_SIZE_MAX + 1);
1053 sessionParam->peerSessionName = (const char*)sessionName;
1054 session = CreateNewSession(sessionParam);
1055 EXPECT_TRUE(session == nullptr);
1056
1057 char deviceId[DEVICE_ID_SIZE_MAX + 2] = {0};
1058 memset_s(deviceId, sizeof(deviceId), 'B', DEVICE_ID_SIZE_MAX + 1);
1059 sessionParam->peerSessionName = g_sessionName;
1060 sessionParam->peerDeviceId = (const char*)deviceId;
1061 session = CreateNewSession(sessionParam);
1062 EXPECT_TRUE(session == nullptr);
1063
1064 char groupId[GROUP_ID_SIZE_MAX + 2] = {0};
1065 memset_s(groupId, sizeof(groupId), 'C', GROUP_ID_SIZE_MAX + 1);
1066 sessionParam->peerSessionName = g_sessionName;
1067 sessionParam->peerDeviceId = g_deviceId;
1068 sessionParam->groupId = (const char*)groupId;
1069 session = CreateNewSession(sessionParam);
1070 EXPECT_TRUE(session == nullptr);
1071
1072 SoftBusFree(sessionParam);
1073 }
1074
1075 /**
1076 * @tc.name: TransClientSessionTest30
1077 * @tc.desc: Transmission sdk session manager get exist session.
1078 * @tc.type: FUNC
1079 * @tc.require:
1080 */
1081 HWTEST_F(TransClientSessionTest, TransClientSessionTest30, TestSize.Level1)
1082 {
1083 int32_t sessionId = AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_TCP_DIRECT, false);
1084 ASSERT_GT(sessionId, 0);
1085
1086 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1087 ASSERT_TRUE(sessionParam != nullptr);
1088 TestGenerateCommParam(sessionParam);
1089
1090 SessionInfo *session = GetExistSession(sessionParam);
1091 ASSERT_TRUE(session != nullptr);
1092
1093 int32_t ret = strcmp(session->info.peerSessionName, sessionParam->peerSessionName);
1094 EXPECT_EQ(ret, EOK);
1095 ret = strcmp(session->info.peerDeviceId, sessionParam->peerDeviceId);
1096 EXPECT_EQ(ret, EOK);
1097 ret = strcmp(session->info.groupId, sessionParam->groupId);
1098 EXPECT_EQ(ret, EOK);
1099
1100 DeleteSessionServerAndSession(g_sessionName, sessionId);
1101 }
1102
1103 /**
1104 * @tc.name: TransClientSessionTest31
1105 * @tc.desc: Transmission sdk session manager get exist session.
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
1109 HWTEST_F(TransClientSessionTest, TransClientSessionTest31, TestSize.Level1)
1110 {
1111 SessionInfo *sessionNode = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
1112 ASSERT_TRUE(sessionNode != nullptr);
1113 ClientSessionServer *SessionServer = GetNewSessionServer(SEC_TYPE_PLAINTEXT,
1114 g_sessionName, g_pkgName, &g_sessionlistener);
1115 ASSERT_TRUE(SessionServer != nullptr);
1116 sessionNode->sessionId = TRANS_TEST_SESSION_ID;
1117 sessionNode->channelId = TRANS_TEST_CHANNEL_ID;
1118 sessionNode->channelType = CHANNEL_TYPE_BUTT;
1119 sessionNode->isAsync = true;
1120 sessionNode->lifecycle.condIsWaiting = true;
1121 SessionServer->listener.isSocketListener = true;
1122
1123 DestroySessionInfo *destroyInfo = CreateDestroySessionNode(nullptr, SessionServer);
1124 EXPECT_TRUE(destroyInfo == nullptr);
1125 destroyInfo = CreateDestroySessionNode(sessionNode, nullptr);
1126 EXPECT_TRUE(destroyInfo == nullptr);
1127 destroyInfo = CreateDestroySessionNode(sessionNode, SessionServer);
1128 ASSERT_TRUE(destroyInfo != nullptr);
1129 ClientDestroySession(nullptr, SHUTDOWN_REASON_USER_SWICTH);
1130 SoftBusFree(destroyInfo);
1131 SoftBusFree(sessionNode);
1132 SoftBusFree(SessionServer);
1133 }
1134
1135 /**
1136 * @tc.name: TransClientSessionTest32
1137 * @tc.desc: Transmission sdk session manager get exist session.
1138 * @tc.type: FUNC
1139 * @tc.require:
1140 */
1141 HWTEST_F(TransClientSessionTest, TransClientSessionTest32, TestSize.Level1)
1142 {
1143 SessionInfo *sessionNode = CreateNonEncryptSessionInfo(nullptr);
1144 EXPECT_TRUE(sessionNode == nullptr);
1145 char sessionName[SESSION_NAME_SIZE_MAX + TRANS_TEST_ADDR_INFO_NUM] = {0};
1146 memset_s(sessionName, sizeof(sessionName), 'A', SESSION_NAME_SIZE_MAX + 1);
1147 sessionNode = CreateNonEncryptSessionInfo(sessionName);
1148 EXPECT_TRUE(sessionNode == nullptr);
1149 }
1150
1151 /**
1152 * @tc.name: TransClientSessionTest33
1153 * @tc.desc: Transmission sdk session manager get exist session.
1154 * @tc.type: FUNC
1155 * @tc.require:
1156 */
1157 HWTEST_F(TransClientSessionTest, TransClientSessionTest33, TestSize.Level1)
1158 {
1159 int32_t channelId = TRANS_TEST_CHANNEL_ID;
1160 char myIp[IP_LEN] = {0};
1161 memcpy_s(myIp, IP_LEN, TRANS_TEST_CONN_IP, IP_LEN);
1162 int32_t ipLen = IP_LEN;
1163 int32_t ret = ClientTransGetTdcIp(channelId, myIp, ipLen);
1164 EXPECT_EQ(ret, SOFTBUS_TRANS_TDC_CHANNEL_NOT_FOUND);
1165 ret = ClientTransGetUdpIp(channelId, myIp, ipLen);
1166 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
1167 }
1168
1169 /**
1170 * @tc.name: TransClientSessionTest34
1171 * @tc.desc: Transmission sdk session manager get exist session.
1172 * @tc.type: FUNC
1173 * @tc.require:
1174 */
1175 HWTEST_F(TransClientSessionTest, TransClientSessionTest34, TestSize.Level1)
1176 {
1177 char myIp[IP_LEN] = {0};
1178 memcpy_s(myIp, IP_LEN, TRANS_TEST_CONN_IP, IP_LEN);
1179 bool ret = ClientTransCheckHmlIp(myIp);
1180 EXPECT_FALSE(ret);
1181 memcpy_s(myIp, IP_LEN, TRANS_TEST_BR_MAC, IP_LEN);
1182 ret = ClientTransCheckHmlIp(myIp);
1183 EXPECT_TRUE(ret);
1184 }
1185
1186 /**
1187 * @tc.name: TransClientSessionTest35
1188 * @tc.desc: Transmission sdk session manager get exist session.
1189 * @tc.type: FUNC
1190 * @tc.require:
1191 */
1192 HWTEST_F(TransClientSessionTest, TransClientSessionTest35, TestSize.Level1)
1193 {
1194 const char *sessionName = "ohos.distributedschedule.dms.test";
1195 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1196 ASSERT_TRUE(sessionParam != nullptr);
1197 TestGenerateCommParam(sessionParam);
1198 SessionInfo *info = TestGenerateSession(sessionParam);
1199 ASSERT_TRUE(info != nullptr);
1200 int32_t connType = TRANS_CONN_HML;
1201 int32_t routeType = WIFI_P2P_REUSE;
1202 bool ret = ClientTransCheckNeedDel(sessionName, info, routeType, connType);
1203 EXPECT_FALSE(ret);
1204 routeType = ROUTE_TYPE_ALL;
1205 info->channelType = CHANNEL_TYPE_UDP;
1206 ret = ClientTransCheckNeedDel(sessionName, info, routeType, connType);
1207 EXPECT_FALSE(ret);
1208 info->channelType = CHANNEL_TYPE_TCP_DIRECT;
1209 ret = ClientTransCheckNeedDel(sessionName, info, routeType, connType);
1210 EXPECT_FALSE(ret);
1211 info->channelType = CHANNEL_TYPE_AUTH;
1212 ret = ClientTransCheckNeedDel(sessionName, info, routeType, connType);
1213 EXPECT_TRUE(ret);
1214 info->channelType = CHANNEL_TYPE_BUTT;
1215 ret = ClientTransCheckNeedDel(sessionName, info, routeType, connType);
1216 EXPECT_FALSE(ret);
1217 SoftBusFree(sessionParam);
1218 SoftBusFree(info);
1219 }
1220
1221 /**
1222 * @tc.name: TransClientSessionTest36
1223 * @tc.desc: Transmission sdk session manager get exist session.
1224 * @tc.type: FUNC
1225 * @tc.require:
1226 */
1227 HWTEST_F(TransClientSessionTest, TransClientSessionTest36, TestSize.Level1)
1228 {
1229 ClientSessionServer server;
1230 char networkId[DEVICE_ID_SIZE_MAX] = {0};
1231 ASSERT_TRUE(networkId != NULL);
1232 int32_t type = 1;
1233 ListNode destroyList;
1234 DestroyClientSessionByNetworkId(nullptr, networkId, type, &destroyList);
1235 DestroyClientSessionByNetworkId(&server, nullptr, type, &destroyList);
1236 DestroyClientSessionByNetworkId(&server, networkId, type, nullptr);
1237 SessionServerInfo *info = CreateSessionServerInfoNode(nullptr);
1238 ASSERT_TRUE(info == nullptr);
1239 }
1240
1241 /**
1242 * @tc.name: TransClientSessionTest37
1243 * @tc.desc: Transmission sdk session manager get exist session.
1244 * @tc.type: FUNC
1245 * @tc.require:
1246 */
1247 HWTEST_F(TransClientSessionTest, TransClientSessionTest37, TestSize.Level1)
1248 {
1249 char pkgName[PKG_NAME_SIZE_MAX] = {0};
1250 char sessionName[SESSION_NAME_SIZE_MAX] = {0};
1251 memset_s(sessionName, SESSION_NAME_SIZE_MAX, 'A', SESSION_NAME_SIZE_MAX - 1);
1252 SoftBusSecType type = SEC_TYPE_PLAINTEXT;
1253 ClientSessionServer *server = GetNewSocketServer(type, nullptr, pkgName);
1254 ASSERT_TRUE(server == nullptr);
1255 server = GetNewSocketServer(type, sessionName, nullptr);
1256 ASSERT_TRUE(server == nullptr);
1257 bool ret = IsDistributedDataSession(nullptr);
1258 EXPECT_FALSE(ret);
1259 ret = IsDistributedDataSession(sessionName);
1260 EXPECT_FALSE(ret);
1261 }
1262
1263 /**
1264 * @tc.name: TransClientSessionTest38
1265 * @tc.desc: Transmission sdk session manager get exist session.
1266 * @tc.type: FUNC
1267 * @tc.require:
1268 */
1269 HWTEST_F(TransClientSessionTest, TransClientSessionTest38, TestSize.Level1)
1270 {
1271 SessionInfo sessionInfo;
1272 sessionInfo.info.flag = COMMON_VIDEO_STREAM;
1273 sessionInfo.isEncyptedRawStream = true;
1274 int dataType = RAW_STREAM;
1275 bool isEncyptedRawStream = true;
1276 bool ret = IsDifferentDataType(nullptr, dataType, isEncyptedRawStream);
1277 EXPECT_FALSE(ret);
1278 ret = IsDifferentDataType(&sessionInfo, dataType, isEncyptedRawStream);
1279 EXPECT_TRUE(ret);
1280 sessionInfo.info.flag = RAW_STREAM;
1281 ret = IsDifferentDataType(&sessionInfo, dataType, isEncyptedRawStream);
1282 EXPECT_FALSE(ret);
1283 dataType = COMMON_VIDEO_STREAM;
1284 sessionInfo.info.flag = COMMON_VIDEO_STREAM;
1285 ret = IsDifferentDataType(&sessionInfo, dataType, isEncyptedRawStream);
1286 EXPECT_FALSE(ret);
1287 }
1288
1289 /**
1290 * @tc.name: TransClientSessionTest39
1291 * @tc.desc: Transmission sdk session manager get exist session.
1292 * @tc.type: FUNC
1293 * @tc.require:
1294 */
1295 HWTEST_F(TransClientSessionTest, TransClientSessionTest39, TestSize.Level1)
1296 {
1297 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1298 ASSERT_TRUE(sessionParam != nullptr);
1299 TestGenerateCommParam(sessionParam);
1300 SessionInfo *info = CreateNewSocketSession(nullptr);
1301 ASSERT_TRUE(info == nullptr);
1302 info = CreateNewSocketSession(sessionParam);
1303 ASSERT_TRUE(info != nullptr);
1304 SoftBusFree(sessionParam);
1305 SoftBusFree(info);
1306 }
1307
1308 /**
1309 * @tc.name: TransClientSessionTest40
1310 * @tc.desc: Transmission sdk session manager get exist session.
1311 * @tc.type: FUNC
1312 * @tc.require:
1313 */
1314 HWTEST_F(TransClientSessionTest, TransClientSessionTest40, TestSize.Level1)
1315 {
1316 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1317 ASSERT_TRUE(sessionParam != nullptr);
1318 TestGenerateCommParam(sessionParam);
1319 SessionInfo *info = TestGenerateSession(sessionParam);
1320 ASSERT_TRUE(info != nullptr);
1321 ClientSessionServer serverNode;
1322 SessionAttribute tmpAttr;
1323 int32_t ret = CheckBindSocketInfo(nullptr);
1324 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1325 ret = CheckBindSocketInfo(info);
1326 EXPECT_EQ(ret, SOFTBUS_OK);
1327 info->info.flag = 0;
1328 ret = CheckBindSocketInfo(info);
1329 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1330 info->info.flag = TYPE_BUTT;
1331 ret = CheckBindSocketInfo(info);
1332 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1333 FillSessionParam(nullptr, &tmpAttr, &serverNode, info);
1334 FillSessionParam(sessionParam, nullptr, &serverNode, info);
1335 FillSessionParam(sessionParam, &tmpAttr, nullptr, info);
1336 FillSessionParam(sessionParam, &tmpAttr, &serverNode, nullptr);
1337 SoftBusFree(sessionParam);
1338 SoftBusFree(info);
1339 }
1340
1341 /**
1342 * @tc.name: TransClientSessionTest41
1343 * @tc.desc: Transmission sdk session manager get exist session.
1344 * @tc.type: FUNC
1345 * @tc.require:
1346 */
1347 HWTEST_F(TransClientSessionTest, TransClientSessionTest41, TestSize.Level1)
1348 {
1349 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1350 ASSERT_TRUE(sessionParam != nullptr);
1351 TestGenerateCommParam(sessionParam);
1352 SessionInfo *info = TestGenerateSession(sessionParam);
1353 ASSERT_TRUE(info != nullptr);
1354 ClientSessionServer serverNode;
1355 int32_t socket = 1;
1356 int32_t retOut = 0;
1357 int32_t socketId[5] = {0};
1358 uint32_t capacity = 1;
1359 uint32_t num = 1;
1360 ClientConvertRetVal(socket, &retOut);
1361 bool ret = CleanUpTimeoutAuthSession(socket);
1362 ASSERT_FALSE(ret);
1363 ClientCheckWaitTimeOut(nullptr, info, socketId, capacity, &num);
1364 ClientCheckWaitTimeOut(&serverNode, nullptr, socketId, capacity, &num);
1365 ClientCheckWaitTimeOut(&serverNode, info, nullptr, capacity, &num);
1366 ClientCheckWaitTimeOut(&serverNode, info, socketId, capacity, nullptr);
1367 ClientCheckWaitTimeOut(&serverNode, info, socketId, capacity, &num);
1368 ClientCleanUpWaitTimeoutSocket(nullptr, num);
1369 ClientCleanUpWaitTimeoutSocket(socketId, num);
1370 SoftBusFree(sessionParam);
1371 SoftBusFree(info);
1372 }
1373
1374 /**
1375 * @tc.name: TransClientSessionTest42
1376 * @tc.desc: Transmission sdk session manager get exist session.
1377 * @tc.type: FUNC
1378 * @tc.require:
1379 */
1380 HWTEST_F(TransClientSessionTest, TransClientSessionTest42, TestSize.Level1)
1381 {
1382 int32_t sessionId = 0;
1383 int32_t ret = ClientDeleteSocketSession(sessionId);
1384 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1385 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
1386 ASSERT_TRUE(sessionParam != nullptr);
1387 TestGenerateCommParam(sessionParam);
1388 SessionInfo *info = TestGenerateSession(sessionParam);
1389 ASSERT_TRUE(info != nullptr);
1390 ClientSessionServer serverNode;
1391 SessionAttribute tmpAttr;
1392 ListNode destroyList;
1393 FillDfsSocketParam(nullptr, &tmpAttr, &serverNode, info);
1394 FillDfsSocketParam(sessionParam, nullptr, &serverNode, info);
1395 FillDfsSocketParam(sessionParam, &tmpAttr, nullptr, info);
1396 FillDfsSocketParam(sessionParam, &tmpAttr, &serverNode, nullptr);
1397 FillDfsSocketParam(sessionParam, &tmpAttr, &serverNode, info);
1398 ClientUpdateIdleTimeout(nullptr, info, &destroyList);
1399 ClientUpdateIdleTimeout(&serverNode, nullptr, &destroyList);
1400 ClientUpdateIdleTimeout(&serverNode, info, nullptr);
1401 SoftBusFree(sessionParam);
1402 SoftBusFree(info);
1403 }
1404
1405 /**
1406 * @tc.name: TransClientSessionTest43
1407 * @tc.desc: Transmission sdk session manager get exist session.
1408 * @tc.type: FUNC
1409 * @tc.require:
1410 */
1411 HWTEST_F(TransClientSessionTest, TransClientSessionTest43, TestSize.Level1)
1412 {
1413 int32_t sessionId = 0;
1414 int32_t ret = ClientDeletePagingSession(sessionId);
1415 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1416 sessionId = 1;
1417 ret = ClientDeletePagingSession(sessionId);
1418 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1419 }
1420
1421 /**
1422 * @tc.name: TransClientSessionTest44
1423 * @tc.desc: Transmission sdk session manager get exist session.
1424 * @tc.type: FUNC
1425 * @tc.require:
1426 */
1427 HWTEST_F(TransClientSessionTest, TransClientSessionTest44, TestSize.Level1)
1428 {
1429 int32_t sessionId = 0;
1430 int32_t ret = ClientDeletePagingSession(sessionId);
1431 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1432 sessionId = 1;
1433 ret = ClientDeletePagingSession(sessionId);
1434 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
1435 }
1436 }