1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <securec.h>
17
18 #include <gtest/gtest.h>
19 #include "softbus_def.h"
20 #include "softbus_errcode.h"
21 #include "softbus_log.h"
22 #include "softbus_trans_def.h"
23 #include "softbus_app_info.h"
24 #include "softbus_server_frame.h"
25 #include "softbus_adapter_mem.h"
26 #include "client_trans_session_manager.h"
27
28 #define TRANS_TEST_SESSION_ID 10
29 #define TRANS_TEST_PID 0
30 #define TRANS_TEST_UID 0
31 #define TRANS_TEST_INVALID_PID (-1)
32 #define TRANS_TEST_INVALID_UID (-1)
33 #define TRANS_TEST_CHANNEL_ID 1000
34 #define TRANS_TEST_INVALID_CHANNEL_ID (-1)
35 #define TRANS_TEST_INVALID_SESSION_ID (-1)
36 #define TRANS_TEST_FILE_ENCRYPT 10
37 #define TRANS_TEST_ALGORITHM 1
38 #define TRANS_TEST_CRC 1
39 #define TRANS_TEST_STATE 1
40
41 #define MAX_SESSION_SERVER_NUM 32
42
43 using namespace testing::ext;
44
45 namespace OHOS {
46
47 const char *g_pkgName = "dms";
48 const char *g_sessionName = "ohos.distributedschedule.dms.test";
49 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
50 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00";
51 const char *g_groupid = "TEST_GROUP_ID";
52 static SessionAttribute g_sessionAttr = {
53 .dataType = TYPE_BYTES,
54 };
55 class TransClientSessionManagerTest : public testing::Test {
56 public:
TransClientSessionManagerTest()57 TransClientSessionManagerTest()
58 {}
~TransClientSessionManagerTest()59 ~TransClientSessionManagerTest()
60 {}
61 static void SetUpTestCase(void);
62 static void TearDownTestCase(void);
SetUp()63 void SetUp() override
64 {}
TearDown()65 void TearDown() override
66 {}
67 };
68
SetUpTestCase(void)69 void TransClientSessionManagerTest::SetUpTestCase(void)
70 {
71 InitSoftBusServer();
72 }
73
TearDownTestCase(void)74 void TransClientSessionManagerTest::TearDownTestCase(void)
75 {
76 }
77
OnSessionOpened(int sessionId,int result)78 static int OnSessionOpened(int sessionId, int result)
79 {
80 LOG_INFO("session opened,sesison id = %d\r\n", sessionId);
81 return SOFTBUS_OK;
82 }
83
OnSessionClosed(int sessionId)84 static void OnSessionClosed(int sessionId)
85 {
86 LOG_INFO("session closed, session id = %d\r\n", sessionId);
87 }
88
OnBytesReceived(int sessionId,const void * data,unsigned int len)89 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
90 {
91 LOG_INFO("session bytes received, session id = %d\r\n", sessionId);
92 }
93
OnMessageReceived(int sessionId,const void * data,unsigned int len)94 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
95 {
96 LOG_INFO("session msg received, session id = %d\r\n", sessionId);
97 }
98
GenerateSession(const SessionParam * param)99 static SessionInfo *GenerateSession(const SessionParam *param)
100 {
101 SessionInfo *session = (SessionInfo*)SoftBusMalloc(sizeof(SessionInfo));
102 EXPECT_TRUE(session != NULL);
103 memset_s(session, sizeof(SessionInfo), 0, sizeof(SessionInfo));
104
105 int ret = strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName);
106 EXPECT_EQ(ret, EOK);
107
108 ret = strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId);
109 EXPECT_EQ(ret, EOK);
110
111 ret = strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId);
112 EXPECT_EQ(ret, EOK);
113
114 session->sessionId = INVALID_SESSION_ID;
115 session->channelId = INVALID_CHANNEL_ID;
116 session->channelType = CHANNEL_TYPE_BUTT;
117 session->isServer = false;
118 session->isEnable = false;
119 session->routeType = ROUTE_TYPE_ALL;
120 session->info.flag = TYPE_BYTES;
121 session->isEncrypt = true;
122 session->algorithm = TRANS_TEST_ALGORITHM;
123 session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
124 session->crc = TRANS_TEST_CRC;
125
126 return session;
127 }
GenerateCommParam(SessionParam * sessionParam)128 static void GenerateCommParam(SessionParam *sessionParam)
129 {
130 sessionParam->sessionName = g_sessionName;
131 sessionParam->peerSessionName = g_sessionName;
132 sessionParam->peerDeviceId = g_deviceId;
133 sessionParam->groupId = g_groupid;
134 sessionParam->attr = &g_sessionAttr;
135 }
136
137 static ISessionListener g_sessionlistener = {
138 .OnSessionOpened = OnSessionOpened,
139 .OnSessionClosed = OnSessionClosed,
140 .OnBytesReceived = OnBytesReceived,
141 .OnMessageReceived = OnMessageReceived,
142 };
143
144 /**
145 * @tc.name: TransClientSessionManagerTest01
146 * @tc.desc: Transmission sdk session manager add session with invalid parameters.
147 * @tc.type: FUNC
148 * @tc.require:
149 */
150 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest01, TestSize.Level1)
151 {
152 int32_t ret = TransClientInit();
153 EXPECT_EQ(ret, SOFTBUS_OK);
154 int32_t sessionId = 0;
155 bool isEnabled = false;
156 ret = ClientAddSession(NULL, &sessionId, &isEnabled);
157 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
158 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
159 EXPECT_TRUE(sessionParam != NULL);
160 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
161 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
162 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
163 GenerateCommParam(sessionParam);
164 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
165 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
166 SoftBusFree(sessionParam);
167 }
168
169 /**
170 * @tc.name: TransClientSessionManagerTest02
171 * @tc.desc: Transmission sdk session manager add new session.
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest02, TestSize.Level1)
176 {
177 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
178 EXPECT_TRUE(sessionParam != NULL);
179 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
180 GenerateCommParam(sessionParam);
181 SessionInfo *session = GenerateSession(sessionParam);
182 int32_t ret = ClientAddNewSession(g_sessionName, session);
183 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
184 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
185 EXPECT_EQ(ret, SOFTBUS_OK);
186 ret = ClientAddNewSession(g_sessionName, session);
187 EXPECT_EQ(ret, SOFTBUS_OK);
188 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
189 EXPECT_EQ(ret, SOFTBUS_OK);
190 SoftBusFree(sessionParam);
191 }
192
193 /**
194 * @tc.name: TransClientSessionManagerTest03
195 * @tc.desc: Transmission sdk session manager add new auth session with invalid and valid parameters.
196 * @tc.type: FUNC
197 * @tc.require:
198 */
199 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest03, TestSize.Level1)
200 {
201 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
202 EXPECT_TRUE(sessionParam != NULL);
203 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
204 GenerateCommParam(sessionParam);
205 int32_t sessionId = 0;
206 char sessionName[SESSION_NAME_SIZE_MAX + 2] = {0};
207 memset_s(sessionName, SESSION_NAME_SIZE_MAX + 2, 'A', SESSION_NAME_SIZE_MAX + 1);
208 int32_t ret = ClientAddAuthSession(g_sessionName, &sessionId);
209 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED);
210 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
211 EXPECT_EQ(ret, SOFTBUS_OK);
212 ret = ClientAddAuthSession(g_sessionName, &sessionId);
213 EXPECT_EQ(ret, SOFTBUS_OK);
214 EXPECT_GT(sessionId, 0);
215 ret = ClientDeleteSession(sessionId);
216 EXPECT_EQ(ret, SOFTBUS_OK);
217 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
218 EXPECT_EQ(ret, SOFTBUS_OK);
219 SoftBusFree(sessionParam);
220 }
221
222 /**
223 * @tc.name: TransClientSessionManagerTest04
224 * @tc.desc: Transmission sdk session manager delete session with invalid parameters.
225 * @tc.type: FUNC
226 * @tc.require:
227 */
228 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest04, TestSize.Level1)
229 {
230 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
231 EXPECT_EQ(ret, SOFTBUS_OK);
232 ret = ClientDeleteSession(TRANS_TEST_SESSION_ID);
233 EXPECT_EQ(ret, SOFTBUS_ERR);
234 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
235 EXPECT_EQ(ret, SOFTBUS_OK);
236 }
237
238 /**
239 * @tc.name: TransClientSessionManagerTest05
240 * @tc.desc: Transmission sdk session manager add session.
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest05, TestSize.Level1)
245 {
246 int32_t sessionId = 0;
247 bool isEnabled = false;
248 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
249 EXPECT_TRUE(sessionParam != NULL);
250 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
251 GenerateCommParam(sessionParam);
252 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
253 EXPECT_EQ(ret, SOFTBUS_OK);
254 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
255 EXPECT_EQ(ret, SOFTBUS_OK);
256 EXPECT_GT(sessionId, 0);
257 ret = ClientDeleteSession(sessionId);
258 EXPECT_EQ(ret, SOFTBUS_OK);
259 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
260 EXPECT_EQ(ret, SOFTBUS_OK);
261 SoftBusFree(sessionParam);
262 }
263
264 /**
265 * @tc.name: TransClientSessionManagerTest06
266 * @tc.desc: Transmission sdk session manager add session server out of range.
267 * @tc.type: FUNC
268 * @tc.require:
269 */
270 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest06, TestSize.Level1)
271 {
272 int32_t ret = 0;
273 for (int i = 0; i < MAX_SESSION_SERVER_NUMBER; ++i) {
274 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
275 char pkgName[PKG_NAME_SIZE_MAX] = {0};
276 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
277 EXPECT_GT(ret, 0);
278 ret = sprintf_s(pkgName, PKG_NAME_SIZE_MAX, "%s%d", g_pkgName, i);
279 EXPECT_GT(ret, 0);
280 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, pkgName, sessionNme, &g_sessionlistener);
281 EXPECT_EQ(ret, SOFTBUS_OK);
282 }
283 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
284 EXPECT_EQ(ret, SOFTBUS_INVALID_NUM);
285 for (int i = 0; i < MAX_SESSION_SERVER_NUMBER; ++i) {
286 char sessionNme[SESSION_NAME_SIZE_MAX] = {0};
287 ret = sprintf_s(sessionNme, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
288 EXPECT_GT(ret, 0);
289 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionNme);
290 EXPECT_EQ(ret, SOFTBUS_OK);
291 }
292 }
293
294 /**
295 * @tc.name: TransClientAddSessionOutOfMaxTest01
296 * @tc.desc: Transmission sdk session manager add session out of maxmum.
297 * @tc.type: FUNC
298 * @tc.require:
299 */
300 HWTEST_F(TransClientSessionManagerTest, TransClientAddSessionOutOfMaxTest01, TestSize.Level1)
301 {
302 int32_t sessionId = 0;
303 bool isEnabled = false;
304 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
305 ASSERT_TRUE(sessionParam != NULL);
306 GenerateCommParam(sessionParam);
307 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
308 ASSERT_EQ(ret, SOFTBUS_OK);
309
310 for (int i = 0; i < MAX_SESSION_ID; ++i) {
311 char sessionName[SESSION_NAME_SIZE_MAX] = {0};
312 ret = sprintf_s(sessionName, SESSION_NAME_SIZE_MAX, "%s%d", g_sessionName, i);
313 ASSERT_GT(ret, 0);
314 sessionParam->peerSessionName = (const char*)sessionName;
315 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
316 EXPECT_EQ(ret, SOFTBUS_OK);
317 }
318
319 sessionParam->peerSessionName = g_sessionName;
320 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
321 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_CNT_EXCEEDS_LIMIT);
322 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
323 EXPECT_EQ(ret, SOFTBUS_OK);
324 }
325
326 /**
327 * @tc.name: TransClientSessionManagerTest07
328 * @tc.desc: Transmission sdk session manager add session with existed session.
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest07, TestSize.Level1)
333 {
334 int32_t sessionId = 0;
335 bool isEnabled = false;
336 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
337 EXPECT_TRUE(sessionParam != NULL);
338 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
339 GenerateCommParam(sessionParam);
340 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
341 EXPECT_EQ(ret, SOFTBUS_OK);
342 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
343 EXPECT_EQ(ret, SOFTBUS_OK);
344 EXPECT_GT(sessionId, 0);
345 int32_t newSessionId = 0;
346 ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
347 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_REPEATED);
348 EXPECT_EQ(sessionId, newSessionId);
349 ret = ClientDeleteSession(sessionId);
350 EXPECT_EQ(ret, SOFTBUS_OK);
351 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
352 EXPECT_EQ(ret, SOFTBUS_OK);
353 SoftBusFree(sessionParam);
354 }
355
356 /**
357 * @tc.name: TransClientSessionManagerTest08
358 * @tc.desc: Transmission sdk session manager add session with wrong session.
359 * @tc.type: FUNC
360 * @tc.require:
361 */
362 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest08, TestSize.Level1)
363 {
364 int32_t sessionId = 0;
365 bool isEnabled = false;
366 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
367 EXPECT_TRUE(sessionParam != NULL);
368 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
369 GenerateCommParam(sessionParam);
370 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF"};
371 sessionParam->peerDeviceId = deviceId;
372 int32_t ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
373 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_CREATE_FAILED);
374 SoftBusFree(sessionParam);
375 }
376
377 /**
378 * @tc.name: TransClientSessionManagerTest09
379 * @tc.desc: Transmission sdk session manager delete session.
380 * @tc.type: FUNC
381 * @tc.require:
382 */
383 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest09, TestSize.Level1)
384 {
385 int32_t sessionId = 0;
386 bool isEnabled = false;
387 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
388 EXPECT_TRUE(sessionParam != NULL);
389 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
390 GenerateCommParam(sessionParam);
391 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
392 EXPECT_EQ(ret, SOFTBUS_OK);
393 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
394 EXPECT_EQ(ret, SOFTBUS_OK);
395 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
396 char groupId[] = {"TEST_GROUP_ID1"};
397 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
398 SessionAttribute sessionAttr = {
399 .dataType = TYPE_FILE,
400 };
401 SessionParam *newSessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
402 EXPECT_TRUE(newSessionParam != NULL);
403 memset_s(newSessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
404 newSessionParam->attr = &sessionAttr;
405 newSessionParam->groupId = groupId;
406 newSessionParam->peerDeviceId = deviceId;
407 newSessionParam->peerSessionName = sessionName;
408 newSessionParam->sessionName = g_sessionName;
409 int32_t newSessionId = 0;
410 ret = ClientAddSession(newSessionParam, &newSessionId, &isEnabled);
411 EXPECT_EQ(ret, SOFTBUS_OK);
412 ret = ClientDeleteSession(newSessionId);
413 EXPECT_EQ(ret, SOFTBUS_OK);
414 ret = ClientDeleteSession(sessionId);
415 EXPECT_EQ(ret, SOFTBUS_OK);
416 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
417 EXPECT_EQ(ret, SOFTBUS_OK);
418 SoftBusFree(sessionParam);
419 SoftBusFree(newSessionParam);
420 }
421
422 /**
423 * @tc.name: TransClientSessionManagerTest10
424 * @tc.desc: Transmission sdk session manager get session data by session id with invalid and valid parameters.
425 * @tc.type: FUNC
426 * @tc.require:
427 */
428 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest10, TestSize.Level1)
429 {
430 char data[SESSION_NAME_SIZE_MAX] = {0};
431 int32_t ret = ClientGetSessionDataById(TRANS_TEST_INVALID_SESSION_ID, data,
432 SESSION_NAME_SIZE_MAX, KEY_SESSION_NAME);
433 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
434 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
435 EXPECT_EQ(ret, SOFTBUS_OK);
436 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
437 EXPECT_TRUE(sessionParam != NULL);
438 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
439 GenerateCommParam(sessionParam);
440 int32_t sessionId = 0;
441 bool isEnabled = false;
442 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
443 EXPECT_EQ(ret, SOFTBUS_OK);
444 memset_s(data, sizeof(data), 0, sizeof(data));
445 ret = ClientGetSessionDataById(sessionId, data, SESSION_NAME_SIZE_MAX, KEY_PEER_SESSION_NAME);
446 EXPECT_EQ(ret, SOFTBUS_OK);
447 memset_s(data, sizeof(data), 0, sizeof(data));
448 ret = ClientGetSessionDataById(sessionId, data, DEVICE_ID_SIZE_MAX, KEY_PEER_DEVICE_ID);
449 EXPECT_EQ(ret, SOFTBUS_OK);
450 memset_s(data, sizeof(data), 0, sizeof(data));
451 ret = ClientGetSessionDataById(sessionId, data, PKG_NAME_SIZE_MAX, KEY_PKG_NAME);
452 EXPECT_EQ(ret, SOFTBUS_OK);
453 ret = ClientGetSessionDataById(sessionId, data, PKG_NAME_SIZE_MAX, KEY_PEER_PID);
454 EXPECT_EQ(ret, SOFTBUS_ERR);
455 ret = ClientDeleteSession(sessionId);
456 EXPECT_EQ(ret, SOFTBUS_OK);
457 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
458 EXPECT_EQ(ret, SOFTBUS_OK);
459 SoftBusFree(sessionParam);
460 }
461
462 /**
463 * @tc.name: TransClientSessionManagerTest11
464 * @tc.desc: Transmission sdk session manager get session Integer data by session id with invalid parameters.
465 * @tc.type: FUNC
466 * @tc.require:
467 */
468 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest11, TestSize.Level1)
469 {
470 int data = 0;
471 int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
472 EXPECT_EQ(ret, SOFTBUS_ERR);
473 }
474
475 /**
476 * @tc.name: TransClientSessionManagerTest12
477 * @tc.desc: Transmission sdk session manager get session Integer data by session id.
478 * @tc.type: FUNC
479 * @tc.require:
480 */
481 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest12, TestSize.Level1)
482 {
483 int data = 0;
484 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
485 EXPECT_EQ(ret, SOFTBUS_OK);
486 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
487 EXPECT_TRUE(sessionParam != NULL);
488 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
489 GenerateCommParam(sessionParam);
490 int32_t sessionId = 0;
491 bool isEnabled = false;
492 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
493 EXPECT_EQ(ret, SOFTBUS_OK);
494 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PEER_PID);
495 EXPECT_EQ(ret, SOFTBUS_OK);
496 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_IS_SERVER);
497 EXPECT_EQ(ret, SOFTBUS_OK);
498 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PEER_UID);
499 EXPECT_EQ(ret, SOFTBUS_OK);
500 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PKG_NAME);
501 EXPECT_EQ(ret, SOFTBUS_ERR);
502 ret = ClientDeleteSession(sessionId);
503 EXPECT_EQ(ret, SOFTBUS_OK);
504 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
505 EXPECT_EQ(ret, SOFTBUS_OK);
506 SoftBusFree(sessionParam);
507 }
508
509 /**
510 * @tc.name: TransClientSessionManagerTest13
511 * @tc.desc: Transmission sdk session manager get channel id by session id with invalid parameters.
512 * @tc.type: FUNC
513 * @tc.require:
514 */
515 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest13, TestSize.Level1)
516 {
517 int32_t channelId = 0;
518 int32_t type = 0;
519 bool isEnable = false;
520 int32_t ret = ClientGetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, &channelId, &type, &isEnable);
521 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
522 }
523
524 /**
525 * @tc.name: TransClientSessionManagerTest14
526 * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters.
527 * @tc.type: FUNC
528 * @tc.require:
529 */
530 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest14, TestSize.Level1)
531 {
532 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
533 EXPECT_TRUE(transInfo != NULL);
534 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
535 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
536 transInfo->channelType = CHANNEL_TYPE_UDP;
537 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
538 EXPECT_EQ(ret, SOFTBUS_OK);
539 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
540 EXPECT_EQ(ret, SOFTBUS_ERR);
541 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
542 EXPECT_EQ(ret, SOFTBUS_OK);
543 SoftBusFree(transInfo);
544 }
545
546 /**
547 * @tc.name: TransClientSessionManagerTest15
548 * @tc.desc: Transmission sdk session manager set channel id by session id.
549 * @tc.type: FUNC
550 * @tc.require:
551 */
552 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest15, TestSize.Level1)
553 {
554 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
555 EXPECT_TRUE(transInfo != NULL);
556 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
557 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
558 transInfo->channelType = CHANNEL_TYPE_UDP;
559 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
560 EXPECT_EQ(ret, SOFTBUS_OK);
561 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
562 EXPECT_TRUE(sessionParam != NULL);
563 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
564 GenerateCommParam(sessionParam);
565 int32_t sessionId = 0;
566 bool isEnabled = false;
567 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
568 EXPECT_EQ(ret, SOFTBUS_OK);
569 ret = ClientSetChannelBySessionId(sessionId, transInfo);
570 EXPECT_EQ(ret, SOFTBUS_OK);
571 ret = ClientDeleteSession(sessionId);
572 EXPECT_EQ(ret, SOFTBUS_OK);
573 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
574 EXPECT_EQ(ret, SOFTBUS_OK);
575 SoftBusFree(transInfo);
576 SoftBusFree(sessionParam);
577 }
578
579 /**
580 * @tc.name: TransClientSessionManagerTest16
581 * @tc.desc: Transmission sdk session manager get channel business type by session id with invalid parameters.
582 * @tc.type: FUNC
583 * @tc.require:
584 */
585 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest16, TestSize.Level1)
586 {
587 int32_t businessType = 0;
588 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
589 EXPECT_EQ(ret, SOFTBUS_OK);
590 ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
591 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
592 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
593 EXPECT_EQ(ret, SOFTBUS_OK);
594 }
595
596 /**
597 * @tc.name: TransClientSessionManagerTest17
598 * @tc.desc: Transmission sdk session manager get encrypt by channel id.
599 * @tc.type: FUNC
600 * @tc.require:
601 */
602 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest17, TestSize.Level1)
603 {
604 int data = 0;
605 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
606 EXPECT_EQ(ret, SOFTBUS_OK);
607 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
608 EXPECT_EQ(ret, SOFTBUS_ERR);
609 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
610 EXPECT_TRUE(sessionParam != NULL);
611 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
612 GenerateCommParam(sessionParam);
613 SessionInfo *session = GenerateSession(sessionParam);
614 session->channelId = TRANS_TEST_CHANNEL_ID;
615 session->channelType = CHANNEL_TYPE_UDP;
616 ret = ClientAddNewSession(g_sessionName, session);
617 EXPECT_EQ(ret, SOFTBUS_OK);
618 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
619 EXPECT_EQ(ret, SOFTBUS_OK);
620 EXPECT_TRUE(data);
621 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &data);
622 EXPECT_EQ(ret, SOFTBUS_ERR);
623 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
624 EXPECT_EQ(ret, SOFTBUS_OK);
625 SoftBusFree(sessionParam);
626 }
627
628 /**
629 * @tc.name: TransClientSessionManagerTest18
630 * @tc.desc: Transmission sdk session manager get session id by channel id.
631 * @tc.type: FUNC
632 * @tc.require:
633 */
634 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest18, TestSize.Level1)
635 {
636 int32_t sessionId = 0;
637 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
638 EXPECT_EQ(ret, SOFTBUS_OK);
639 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
640 EXPECT_EQ(ret, SOFTBUS_ERR);
641 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
642 EXPECT_TRUE(sessionParam != NULL);
643 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
644 GenerateCommParam(sessionParam);
645 SessionInfo *session = GenerateSession(sessionParam);
646 session->channelId = TRANS_TEST_CHANNEL_ID;
647 session->channelType = CHANNEL_TYPE_UDP;
648 ret = ClientAddNewSession(g_sessionName, session);
649 EXPECT_EQ(ret, SOFTBUS_OK);
650 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
651 EXPECT_EQ(ret, SOFTBUS_OK);
652 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
653 EXPECT_EQ(ret, SOFTBUS_OK);
654 SoftBusFree(sessionParam);
655 }
656
657 /**
658 * @tc.name: TransClientSessionManagerTest19
659 * @tc.desc: Transmission sdk session manager get enable session id by channel id.
660 * @tc.type: FUNC
661 * @tc.require:
662 */
663 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest19, TestSize.Level1)
664 {
665 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
666 EXPECT_TRUE(channel != NULL);
667 memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
668 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
669 EXPECT_EQ(ret, SOFTBUS_OK);
670 int32_t sessionId = 0;
671 ret = ClientEnableSessionByChannelId(channel, &sessionId);
672 EXPECT_EQ(ret, SOFTBUS_ERR);
673 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
674 EXPECT_TRUE(sessionParam != NULL);
675 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
676 GenerateCommParam(sessionParam);
677 channel->channelId = 0;
678 channel->channelType = CHANNEL_TYPE_AUTH;
679 ret = ClientAddAuthSession(g_sessionName, &sessionId);
680 EXPECT_EQ(ret, SOFTBUS_OK);
681 int32_t newSessionId = 0;
682 ret = ClientEnableSessionByChannelId(channel, &newSessionId);
683 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
684 char deviceId[DEVICE_ID_SIZE_MAX] = {0};
685 ret = strcpy_s(deviceId, DEVICE_ID_SIZE_MAX, g_deviceId);
686 EXPECT_EQ(ret, EOK);
687 channel->peerDeviceId = deviceId;
688 ret = ClientEnableSessionByChannelId(channel, &newSessionId);
689 EXPECT_EQ(ret, SOFTBUS_OK);
690 EXPECT_EQ(sessionId, newSessionId);
691 ret = ClientDeleteSession(sessionId);
692 EXPECT_EQ(ret, SOFTBUS_OK);
693 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
694 EXPECT_EQ(ret, SOFTBUS_OK);
695 SoftBusFree(channel);
696 SoftBusFree(sessionParam);
697 }
698
699 /**
700 * @tc.name: TransClientSessionManagerTest20
701 * @tc.desc: Transmission sdk session manager get enable session callback by session id.
702 * @tc.type: FUNC
703 * @tc.require:
704 */
705 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest20, TestSize.Level1)
706 {
707 ISessionListener sessionlistener = {0};
708 int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
709 EXPECT_EQ(ret, SOFTBUS_ERR);
710 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
711 EXPECT_TRUE(sessionParam != NULL);
712 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
713 GenerateCommParam(sessionParam);
714 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
715 EXPECT_EQ(ret, SOFTBUS_OK);
716 int32_t sessionId = 0;
717 bool isEnabled = false;
718 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
719 EXPECT_EQ(ret, SOFTBUS_OK);
720 ret = ClientGetSessionCallbackById(sessionId, &sessionlistener);
721 EXPECT_EQ(ret, SOFTBUS_OK);
722 EXPECT_EQ(sessionlistener.OnSessionOpened, OnSessionOpened);
723 EXPECT_EQ(sessionlistener.OnSessionClosed, OnSessionClosed);
724 EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
725 EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
726 ret = ClientDeleteSession(sessionId);
727 EXPECT_EQ(ret, SOFTBUS_OK);
728 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
729 EXPECT_EQ(ret, SOFTBUS_OK);
730 SoftBusFree(sessionParam);
731 }
732
733 /**
734 * @tc.name: TransClientSessionManagerTest21
735 * @tc.desc: Transmission sdk session manager get enable session callback by session name.
736 * @tc.type: FUNC
737 * @tc.require:
738 */
739 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest21, TestSize.Level1)
740 {
741 ISessionListener sessionlistener = {0};
742 int32_t ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
743 EXPECT_EQ(ret, SOFTBUS_ERR);
744 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
745 EXPECT_EQ(ret, SOFTBUS_OK);
746 char pkgName[] = {"dms1"};
747 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
748 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, pkgName, sessionName, &g_sessionlistener);
749 EXPECT_EQ(ret, SOFTBUS_OK);
750 ret = ClientGetSessionCallbackByName(sessionName, &sessionlistener);
751 EXPECT_EQ(ret, SOFTBUS_OK);
752 EXPECT_EQ(sessionlistener.OnSessionOpened, OnSessionOpened);
753 EXPECT_EQ(sessionlistener.OnSessionClosed, OnSessionClosed);
754 EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
755 EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
756 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
757 EXPECT_EQ(ret, SOFTBUS_OK);
758 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
759 EXPECT_EQ(ret, SOFTBUS_OK);
760 }
761
762 /**
763 * @tc.name: TransClientSessionManagerTest22
764 * @tc.desc: Transmission sdk session manager get session side by session id.
765 * @tc.type: FUNC
766 * @tc.require:
767 */
768 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest22, TestSize.Level1)
769 {
770 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
771 EXPECT_EQ(ret, SOFTBUS_ERR);
772 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
773 EXPECT_EQ(ret, SOFTBUS_OK);
774 int32_t sessionId = 0;
775 bool isEnabled = false;
776 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
777 EXPECT_TRUE(sessionParam != NULL);
778 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
779 GenerateCommParam(sessionParam);
780 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
781 EXPECT_EQ(ret, SOFTBUS_OK);
782 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
783 char groupId[] = {"TEST_GROUP_ID1"};
784 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
785 sessionParam->groupId = groupId;
786 sessionParam->peerSessionName = sessionName;
787 sessionParam->peerDeviceId = deviceId;
788 int32_t newSessionId = 0;
789 ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
790 EXPECT_EQ(ret, SOFTBUS_OK);
791 ret = ClientGetSessionSide(sessionId);
792 EXPECT_EQ(ret, IS_CLIENT);
793 ret = ClientGetSessionSide(newSessionId);
794 EXPECT_EQ(ret, IS_CLIENT);
795 ret = ClientDeleteSession(sessionId);
796 EXPECT_EQ(ret, SOFTBUS_OK);
797 ret = ClientDeleteSession(newSessionId);
798 EXPECT_EQ(ret, SOFTBUS_OK);
799 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
800 EXPECT_EQ(ret, SOFTBUS_OK);
801 SoftBusFree(sessionParam);
802 }
803
804 /**
805 * @tc.name: TransClientSessionManagerTest23
806 * @tc.desc: Transmission sdk session manager grant permission and remove permission with invalid parameters.
807 * @tc.type: FUNC
808 * @tc.require:
809 */
810 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest23, TestSize.Level1)
811 {
812 int32_t ret = ClientGrantPermission(TRANS_TEST_INVALID_UID, TRANS_TEST_PID, g_sessionName);
813 EXPECT_EQ(ret, SOFTBUS_ERR);
814 ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_INVALID_PID, g_sessionName);
815 EXPECT_EQ(ret, SOFTBUS_ERR);
816 ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_PID, NULL);
817 EXPECT_EQ(ret, SOFTBUS_ERR);
818 ret = ClientRemovePermission(NULL);
819 EXPECT_EQ(ret, SOFTBUS_ERR);
820 }
821
822 /**
823 * @tc.name: TransClientSessionManagerTest24
824 * @tc.desc: Transmission sdk session manager get file config by session.
825 * @tc.type: FUNC
826 * @tc.require:
827 */
828 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest24, TestSize.Level1)
829 {
830 int32_t fileEncrypt = 0;
831 int32_t algorithm = 0;
832 int32_t crc = 0;
833 int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
834 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
835 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
836 EXPECT_EQ(ret, SOFTBUS_OK);
837 int32_t sessionId = 0;
838 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
839 EXPECT_TRUE(sessionParam != NULL);
840 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
841 GenerateCommParam(sessionParam);
842 SessionInfo *session = GenerateSession(sessionParam);
843 session->channelId = TRANS_TEST_CHANNEL_ID;
844 session->channelType = CHANNEL_TYPE_UDP;
845 ret = ClientAddNewSession(g_sessionName, session);
846 EXPECT_EQ(ret, SOFTBUS_OK);
847 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
848 EXPECT_EQ(ret, SOFTBUS_OK);
849 ret = ClientGetFileConfigInfoById(sessionId, &fileEncrypt, &algorithm, &crc);
850 EXPECT_EQ(ret, SOFTBUS_OK);
851 EXPECT_EQ(TRANS_TEST_FILE_ENCRYPT, fileEncrypt);
852 EXPECT_EQ(TRANS_TEST_ALGORITHM, algorithm);
853 EXPECT_EQ(TRANS_TEST_CRC, crc);
854 ret = ClientDeleteSession(sessionId);
855 EXPECT_EQ(ret, SOFTBUS_OK);
856 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
857 EXPECT_EQ(ret, SOFTBUS_OK);
858 SoftBusFree(sessionParam);
859 }
860
861 /**
862 * @tc.name: TransClientSessionManagerTest25
863 * @tc.desc: Transmission sdk session manager recreate session server to server.
864 * @tc.type: FUNC
865 * @tc.require:
866 */
867 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest25, TestSize.Level1)
868 {
869 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
870 EXPECT_EQ(ret, SOFTBUS_OK);
871 ret = ReCreateSessionServerToServer();
872 EXPECT_EQ(ret, SOFTBUS_OK);
873 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
874 EXPECT_EQ(ret, SOFTBUS_OK);
875 }
876
877 /**
878 * @tc.name: TransClientSessionManagerTest26
879 * @tc.desc: Transmission sdk session manager clear list on link down.
880 * @tc.type: FUNC
881 * @tc.require:
882 */
883 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest26, TestSize.Level1)
884 {
885 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
886 EXPECT_EQ(ret, SOFTBUS_OK);
887 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
888 EXPECT_TRUE(sessionParam != NULL);
889 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
890 GenerateCommParam(sessionParam);
891 SessionInfo *session = GenerateSession(sessionParam);
892 session->channelId = TRANS_TEST_CHANNEL_ID;
893 session->channelType = CHANNEL_TYPE_UDP;
894 ret = ClientAddNewSession(g_sessionName, session);
895 EXPECT_EQ(ret, SOFTBUS_OK);
896 ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
897 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
898 EXPECT_EQ(ret, SOFTBUS_OK);
899 }
900
901 /**
902 * @tc.name: TransClientSessionManagerTest27
903 * @tc.desc: Transmission sdk session manager clear all session when server death.
904 * @tc.type: FUNC
905 * @tc.require:
906 */
907 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest27, TestSize.Level1)
908 {
909 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
910 EXPECT_EQ(ret, SOFTBUS_OK);
911 ClientCleanAllSessionWhenServerDeath();
912 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
913 EXPECT_TRUE(sessionParam != NULL);
914 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
915 GenerateCommParam(sessionParam);
916 SessionInfo *session = GenerateSession(sessionParam);
917 session->channelId = TRANS_TEST_CHANNEL_ID;
918 session->channelType = CHANNEL_TYPE_UDP;
919 ret = ClientAddNewSession(g_sessionName, session);
920 EXPECT_EQ(ret, SOFTBUS_OK);
921 ClientCleanAllSessionWhenServerDeath();
922 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
923 EXPECT_EQ(ret, SOFTBUS_OK);
924 }
925
926 /**
927 * @tc.name: TransClientSessionManagerTest28
928 * @tc.desc: Transmission sdk session manager permission state change.
929 * @tc.type: FUNC
930 * @tc.require:
931 */
932 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest28, TestSize.Level1)
933 {
934 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
935 EXPECT_EQ(ret, SOFTBUS_OK);
936 PermissionStateChange(g_pkgName, TRANS_TEST_STATE);
937 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
938 EXPECT_EQ(ret, SOFTBUS_OK);
939 }
940
941 /**
942 * @tc.name: TransClientSessionDestroyTest01
943 * @tc.desc: Transmission sdk session manager destroy session by network id.
944 * @tc.type: FUNC
945 * @tc.require:
946 */
947 HWTEST_F(TransClientSessionManagerTest, TransClientSessionDestroyTest01, TestSize.Level1)
948 {
949 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
950 ASSERT_EQ(ret, SOFTBUS_OK);
951 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
952 ASSERT_TRUE(sessionParam != NULL);
953 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
954 GenerateCommParam(sessionParam);
955 SessionInfo *session = GenerateSession(sessionParam);
956 ASSERT_TRUE(session != NULL);
957 session->channelId = TRANS_TEST_CHANNEL_ID;
958 session->channelType = CHANNEL_TYPE_UDP;
959 session->routeType = WIFI_STA;
960 ret = ClientAddNewSession(g_sessionName, session);
961 ASSERT_EQ(ret, SOFTBUS_OK);
962 sessionParam->peerDeviceId = g_networkId;
963 SessionInfo *newSession = GenerateSession(sessionParam);
964 ASSERT_TRUE(newSession != NULL);
965 newSession->channelId = TRANS_TEST_CHANNEL_ID + 1;
966 newSession->channelType = CHANNEL_TYPE_UDP;
967 newSession->routeType = WIFI_P2P;
968 ret = ClientAddNewSession(g_sessionName, newSession);
969 ASSERT_EQ(ret, SOFTBUS_OK);
970 ClientTransOnLinkDown(g_networkId, WIFI_STA);
971 int32_t sessionId = 0;
972 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId);
973 EXPECT_EQ(ret, SOFTBUS_OK);
974 EXPECT_GT(sessionId, 0);
975 ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
976 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId);
977 EXPECT_EQ(ret, SOFTBUS_ERR);
978 ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
979 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
980 EXPECT_EQ(ret, SOFTBUS_ERR);
981 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
982 EXPECT_EQ(ret, SOFTBUS_OK);
983 SoftBusFree(sessionParam);
984 }
985
986 /**
987 * @tc.name: TransClientSessionManagerTest29
988 * @tc.desc: Transmission sdk session manager add and delete server with invalid parameters no initialize.
989 * @tc.type: FUNC
990 * @tc.require:
991 */
992 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest29, TestSize.Level1)
993 {
994 TransClientDeinit();
995 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, NULL, g_sessionName, &g_sessionlistener);
996 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
997 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
998 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
999 ret = ClientDeleteSessionServer(SEC_TYPE_UNKNOWN, g_sessionName);
1000 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1001 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
1002 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1003 ret = ClientDeleteSession(TRANS_TEST_INVALID_SESSION_ID);
1004 EXPECT_EQ(ret, SOFTBUS_ERR);
1005 ret = ClientDeleteSession(TRANS_TEST_SESSION_ID);
1006 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1007 }
1008
1009
1010 /**
1011 * @tc.name: TransClientSessionManagerTest30
1012 * @tc.desc: Transmission sdk session manager add new auth session with invalid parameters no initialize.
1013 * @tc.type: FUNC
1014 * @tc.require:
1015 */
1016 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest30, TestSize.Level1)
1017 {
1018 int32_t sessionId = 0;
1019 int32_t ret = ClientAddAuthSession(NULL, &sessionId);
1020 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1021 ret = ClientAddAuthSession(g_sessionName, &sessionId);
1022 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1023 }
1024
1025 /**
1026 * @tc.name: TransClientSessionManagerTest31
1027 * @tc.desc: Transmission sdk session manager add new session no initialize.
1028 * @tc.type: FUNC
1029 * @tc.require:
1030 */
1031 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest31, TestSize.Level1)
1032 {
1033 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1034 EXPECT_TRUE(sessionParam != NULL);
1035 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1036 GenerateCommParam(sessionParam);
1037 SessionInfo *session = GenerateSession(sessionParam);
1038 int32_t ret = ClientAddNewSession(g_sessionName, NULL);
1039 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1040 ret = ClientAddNewSession(g_sessionName, session);
1041 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1042 SoftBusFree(sessionParam);
1043 }
1044
1045 /**
1046 * @tc.name: TransClientSessionManagerTest32
1047 * @tc.desc: Transmission sdk session manager get session Integer data by session id no initialize.
1048 * @tc.type: FUNC
1049 * @tc.require:
1050 */
1051 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest32, TestSize.Level1)
1052 {
1053 int data = 0;
1054 int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_INVALID_SESSION_ID, &data, KEY_PEER_PID);
1055 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1056 ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, NULL, KEY_PEER_PID);
1057 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1058 ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
1059 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1060 }
1061
1062 /**
1063 * @tc.name: TransClientSessionManagerTest33
1064 * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters no initialize.
1065 * @tc.type: FUNC
1066 * @tc.require:
1067 */
1068 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest33, TestSize.Level1)
1069 {
1070 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
1071 EXPECT_TRUE(transInfo != NULL);
1072 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
1073 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1074 transInfo->channelType = CHANNEL_TYPE_UDP;
1075 int32_t ret = ClientSetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, transInfo);
1076 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1077 transInfo->channelId = TRANS_TEST_INVALID_CHANNEL_ID;
1078 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1079 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1080 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1081 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1082 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1083 SoftBusFree(transInfo);
1084 }
1085
1086 /**
1087 * @tc.name: TransClientSessionManagerTest34
1088 * @tc.desc: Transmission sdk session manager get channel business type by session id no initialize.
1089 * @tc.type: FUNC
1090 * @tc.require:
1091 */
1092 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest34, TestSize.Level1)
1093 {
1094 int32_t businessType = 0;
1095 int32_t ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_INVALID_SESSION_ID, &businessType);
1096 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1097 ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
1098 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1099 }
1100
1101 /**
1102 * @tc.name: TransClientSessionManagerTest35
1103 * @tc.desc: Transmission sdk session manager get encrypt by channel id with invalid parameters.
1104 * @tc.type: FUNC
1105 * @tc.require:
1106 */
1107 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest35, TestSize.Level1)
1108 {
1109 int data = 0;
1110 int32_t ret = GetEncryptByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1111 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1112 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, NULL);
1113 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1114 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1115 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1116 }
1117
1118 /**
1119 * @tc.name: TransClientSessionManagerTest36
1120 * @tc.desc: Transmission sdk session manager get session id by channel id with invalid parameters.
1121 * @tc.type: FUNC
1122 * @tc.require:
1123 */
1124 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest36, TestSize.Level1)
1125 {
1126 int sessionId = 0;
1127 int32_t ret = ClientGetSessionIdByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
1128 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1129 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, NULL);
1130 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1131 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
1132 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1133 char data[SESSION_NAME_SIZE_MAX] = {0};
1134 ret = ClientGetSessionDataById(TRANS_TEST_SESSION_ID, data, SESSION_NAME_SIZE_MAX, KEY_PEER_SESSION_NAME);
1135 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1136 }
1137
1138 /**
1139 * @tc.name: TransClientSessionManagerTest37
1140 * @tc.desc: Transmission sdk session manager get enable session id by channel id with invalid parameters.
1141 * @tc.type: FUNC
1142 * @tc.require:
1143 */
1144 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest37, TestSize.Level1)
1145 {
1146 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
1147 EXPECT_TRUE(channel != NULL);
1148 memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
1149 int32_t sessionId = 0;
1150 int32_t ret = ClientEnableSessionByChannelId(NULL, &sessionId);
1151 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1152 ret = ClientEnableSessionByChannelId(channel, NULL);
1153 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1154 ret = ClientEnableSessionByChannelId(channel, &sessionId);
1155 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1156 SoftBusFree(channel);
1157 }
1158
1159 /**
1160 * @tc.name: TransClientSessionManagerTest38
1161 * @tc.desc: Transmission sdk session manager get enable session callback by session id with invalid parameters.
1162 * @tc.type: FUNC
1163 * @tc.require:
1164 */
1165 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest38, TestSize.Level1)
1166 {
1167 ISessionListener sessionlistener = {0};
1168 int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_INVALID_SESSION_ID, &sessionlistener);
1169 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1170 ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, NULL);
1171 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1172 ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
1173 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1174 }
1175
1176 /**
1177 * @tc.name: TransClientSessionManagerTest39
1178 * @tc.desc: Transmission sdk session manager get enable session callback by session name with invalid parameters.
1179 * @tc.type: FUNC
1180 * @tc.require:
1181 */
1182 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest39, TestSize.Level1)
1183 {
1184 ISessionListener sessionlistener = {0};
1185 int32_t ret = ClientGetSessionCallbackByName(NULL, &sessionlistener);
1186 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1187 ret = ClientGetSessionCallbackByName(g_sessionName, NULL);
1188 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1189 ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
1190 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1191 }
1192
1193 /**
1194 * @tc.name: TransClientSessionManagerTest40
1195 * @tc.desc: Transmission sdk session manager get side by session id with invalid parameters.
1196 * @tc.type: FUNC
1197 * @tc.require:
1198 */
1199 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest40, TestSize.Level1)
1200 {
1201 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
1202 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1203 }
1204
1205 /**
1206 * @tc.name: TransClientSessionManagerTest41
1207 * @tc.desc: Transmission sdk session manager get file config by session id with invalid parameters.
1208 * @tc.type: FUNC
1209 * @tc.require:
1210 */
1211 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest41, TestSize.Level1)
1212 {
1213 int32_t fileEncrypt = 0;
1214 int32_t algorithm = 0;
1215 int32_t crc = 0;
1216 int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_INVALID_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1217 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1218 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, NULL, &algorithm, &crc);
1219 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1220 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, NULL, &crc);
1221 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1222 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, NULL);
1223 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1224 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1225 EXPECT_EQ(ret, SOFTBUS_ERR);
1226 ret = CheckPermissionState(TRANS_TEST_SESSION_ID);
1227 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1228 }
1229
1230 /**
1231 * @tc.name: TransClientSessionManagerTest42
1232 * @tc.desc: Transmission sdk session manager operate no initialize.
1233 * @tc.type: FUNC
1234 * @tc.require:
1235 */
1236 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest42, TestSize.Level1)
1237 {
1238 int32_t ret = ReCreateSessionServerToServer();
1239 EXPECT_EQ(ret, SOFTBUS_ERR);
1240 ClientTransOnLinkDown(NULL, ROUTE_TYPE_ALL);
1241 ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
1242 ClientCleanAllSessionWhenServerDeath();
1243 PermissionStateChange(g_pkgName, 0);
1244 }
1245 }