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 12345
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: TransClientSessionManagerTest07
296 * @tc.desc: Transmission sdk session manager add session with existed session.
297 * @tc.type: FUNC
298 * @tc.require:
299 */
300 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest07, TestSize.Level1)
301 {
302 int32_t sessionId = 0;
303 bool isEnabled = false;
304 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
305 EXPECT_TRUE(sessionParam != NULL);
306 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
307 GenerateCommParam(sessionParam);
308 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
309 EXPECT_EQ(ret, SOFTBUS_OK);
310 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
311 EXPECT_EQ(ret, SOFTBUS_OK);
312 EXPECT_GT(sessionId, 0);
313 int32_t newSessionId = 0;
314 ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
315 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_REPEATED);
316 EXPECT_EQ(sessionId, newSessionId);
317 ret = ClientDeleteSession(sessionId);
318 EXPECT_EQ(ret, SOFTBUS_OK);
319 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
320 EXPECT_EQ(ret, SOFTBUS_OK);
321 SoftBusFree(sessionParam);
322 }
323
324 /**
325 * @tc.name: TransClientSessionManagerTest08
326 * @tc.desc: Transmission sdk session manager add session with wrong session.
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest08, TestSize.Level1)
331 {
332 int32_t sessionId = 0;
333 bool isEnabled = false;
334 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
335 EXPECT_TRUE(sessionParam != NULL);
336 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
337 GenerateCommParam(sessionParam);
338 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF"};
339 sessionParam->peerDeviceId = deviceId;
340 int32_t ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
341 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_CREATE_FAILED);
342 SoftBusFree(sessionParam);
343 }
344
345 /**
346 * @tc.name: TransClientSessionManagerTest09
347 * @tc.desc: Transmission sdk session manager delete session.
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest09, TestSize.Level1)
352 {
353 int32_t sessionId = 0;
354 bool isEnabled = false;
355 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
356 EXPECT_TRUE(sessionParam != NULL);
357 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
358 GenerateCommParam(sessionParam);
359 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
360 EXPECT_EQ(ret, SOFTBUS_OK);
361 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
362 EXPECT_EQ(ret, SOFTBUS_OK);
363 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
364 char groupId[] = {"TEST_GROUP_ID1"};
365 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
366 SessionAttribute sessionAttr = {
367 .dataType = TYPE_FILE,
368 };
369 SessionParam *newSessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
370 EXPECT_TRUE(newSessionParam != NULL);
371 memset_s(newSessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
372 newSessionParam->attr = &sessionAttr;
373 newSessionParam->groupId = groupId;
374 newSessionParam->peerDeviceId = deviceId;
375 newSessionParam->peerSessionName = sessionName;
376 newSessionParam->sessionName = g_sessionName;
377 int32_t newSessionId = 0;
378 ret = ClientAddSession(newSessionParam, &newSessionId, &isEnabled);
379 EXPECT_EQ(ret, SOFTBUS_OK);
380 ret = ClientDeleteSession(newSessionId);
381 EXPECT_EQ(ret, SOFTBUS_OK);
382 ret = ClientDeleteSession(sessionId);
383 EXPECT_EQ(ret, SOFTBUS_OK);
384 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
385 EXPECT_EQ(ret, SOFTBUS_OK);
386 SoftBusFree(sessionParam);
387 SoftBusFree(newSessionParam);
388 }
389
390 /**
391 * @tc.name: TransClientSessionManagerTest10
392 * @tc.desc: Transmission sdk session manager get session data by session id with invalid and valid parameters.
393 * @tc.type: FUNC
394 * @tc.require:
395 */
396 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest10, TestSize.Level1)
397 {
398 char data[SESSION_NAME_SIZE_MAX] = {0};
399 int32_t ret = ClientGetSessionDataById(TRANS_TEST_INVALID_SESSION_ID, data,
400 SESSION_NAME_SIZE_MAX, KEY_SESSION_NAME);
401 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
402 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
403 EXPECT_EQ(ret, SOFTBUS_OK);
404 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
405 EXPECT_TRUE(sessionParam != NULL);
406 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
407 GenerateCommParam(sessionParam);
408 int32_t sessionId = 0;
409 bool isEnabled = false;
410 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
411 EXPECT_EQ(ret, SOFTBUS_OK);
412 memset_s(data, sizeof(data), 0, sizeof(data));
413 ret = ClientGetSessionDataById(sessionId, data, SESSION_NAME_SIZE_MAX, KEY_PEER_SESSION_NAME);
414 EXPECT_EQ(ret, SOFTBUS_OK);
415 memset_s(data, sizeof(data), 0, sizeof(data));
416 ret = ClientGetSessionDataById(sessionId, data, DEVICE_ID_SIZE_MAX, KEY_PEER_DEVICE_ID);
417 EXPECT_EQ(ret, SOFTBUS_OK);
418 memset_s(data, sizeof(data), 0, sizeof(data));
419 ret = ClientGetSessionDataById(sessionId, data, PKG_NAME_SIZE_MAX, KEY_PKG_NAME);
420 EXPECT_EQ(ret, SOFTBUS_OK);
421 ret = ClientGetSessionDataById(sessionId, data, PKG_NAME_SIZE_MAX, KEY_PEER_PID);
422 EXPECT_EQ(ret, SOFTBUS_ERR);
423 ret = ClientDeleteSession(sessionId);
424 EXPECT_EQ(ret, SOFTBUS_OK);
425 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
426 EXPECT_EQ(ret, SOFTBUS_OK);
427 SoftBusFree(sessionParam);
428 }
429
430 /**
431 * @tc.name: TransClientSessionManagerTest11
432 * @tc.desc: Transmission sdk session manager get session Integer data by session id with invalid parameters.
433 * @tc.type: FUNC
434 * @tc.require:
435 */
436 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest11, TestSize.Level1)
437 {
438 int data = 0;
439 int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
440 EXPECT_EQ(ret, SOFTBUS_ERR);
441 }
442
443 /**
444 * @tc.name: TransClientSessionManagerTest12
445 * @tc.desc: Transmission sdk session manager get session Integer data by session id.
446 * @tc.type: FUNC
447 * @tc.require:
448 */
449 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest12, TestSize.Level1)
450 {
451 int data = 0;
452 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
453 EXPECT_EQ(ret, SOFTBUS_OK);
454 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
455 EXPECT_TRUE(sessionParam != NULL);
456 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
457 GenerateCommParam(sessionParam);
458 int32_t sessionId = 0;
459 bool isEnabled = false;
460 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
461 EXPECT_EQ(ret, SOFTBUS_OK);
462 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PEER_PID);
463 EXPECT_EQ(ret, SOFTBUS_OK);
464 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_IS_SERVER);
465 EXPECT_EQ(ret, SOFTBUS_OK);
466 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PEER_UID);
467 EXPECT_EQ(ret, SOFTBUS_OK);
468 ret = ClientGetSessionIntegerDataById(sessionId, &data, KEY_PKG_NAME);
469 EXPECT_EQ(ret, SOFTBUS_ERR);
470 ret = ClientDeleteSession(sessionId);
471 EXPECT_EQ(ret, SOFTBUS_OK);
472 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
473 EXPECT_EQ(ret, SOFTBUS_OK);
474 SoftBusFree(sessionParam);
475 }
476
477 /**
478 * @tc.name: TransClientSessionManagerTest13
479 * @tc.desc: Transmission sdk session manager get channel id by session id with invalid parameters.
480 * @tc.type: FUNC
481 * @tc.require:
482 */
483 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest13, TestSize.Level1)
484 {
485 int32_t channelId = 0;
486 int32_t type = 0;
487 bool isEnable = false;
488 int32_t ret = ClientGetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, &channelId, &type, &isEnable);
489 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
490 }
491
492 /**
493 * @tc.name: TransClientSessionManagerTest14
494 * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters.
495 * @tc.type: FUNC
496 * @tc.require:
497 */
498 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest14, TestSize.Level1)
499 {
500 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
501 EXPECT_TRUE(transInfo != NULL);
502 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
503 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
504 transInfo->channelType = CHANNEL_TYPE_UDP;
505 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
506 EXPECT_EQ(ret, SOFTBUS_OK);
507 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
508 EXPECT_EQ(ret, SOFTBUS_ERR);
509 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
510 EXPECT_EQ(ret, SOFTBUS_OK);
511 SoftBusFree(transInfo);
512 }
513
514 /**
515 * @tc.name: TransClientSessionManagerTest15
516 * @tc.desc: Transmission sdk session manager set channel id by session id.
517 * @tc.type: FUNC
518 * @tc.require:
519 */
520 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest15, TestSize.Level1)
521 {
522 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
523 EXPECT_TRUE(transInfo != NULL);
524 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
525 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
526 transInfo->channelType = CHANNEL_TYPE_UDP;
527 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
528 EXPECT_EQ(ret, SOFTBUS_OK);
529 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
530 EXPECT_TRUE(sessionParam != NULL);
531 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
532 GenerateCommParam(sessionParam);
533 int32_t sessionId = 0;
534 bool isEnabled = false;
535 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
536 EXPECT_EQ(ret, SOFTBUS_OK);
537 ret = ClientSetChannelBySessionId(sessionId, transInfo);
538 EXPECT_EQ(ret, SOFTBUS_OK);
539 ret = ClientDeleteSession(sessionId);
540 EXPECT_EQ(ret, SOFTBUS_OK);
541 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
542 EXPECT_EQ(ret, SOFTBUS_OK);
543 SoftBusFree(transInfo);
544 SoftBusFree(sessionParam);
545 }
546
547 /**
548 * @tc.name: TransClientSessionManagerTest16
549 * @tc.desc: Transmission sdk session manager get channel business type by session id with invalid parameters.
550 * @tc.type: FUNC
551 * @tc.require:
552 */
553 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest16, TestSize.Level1)
554 {
555 int32_t businessType = 0;
556 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
557 EXPECT_EQ(ret, SOFTBUS_OK);
558 ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
559 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
560 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
561 EXPECT_EQ(ret, SOFTBUS_OK);
562 }
563
564 /**
565 * @tc.name: TransClientSessionManagerTest17
566 * @tc.desc: Transmission sdk session manager get encrypt by channel id.
567 * @tc.type: FUNC
568 * @tc.require:
569 */
570 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest17, TestSize.Level1)
571 {
572 int data = 0;
573 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
574 EXPECT_EQ(ret, SOFTBUS_OK);
575 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
576 EXPECT_EQ(ret, SOFTBUS_ERR);
577 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
578 EXPECT_TRUE(sessionParam != NULL);
579 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
580 GenerateCommParam(sessionParam);
581 SessionInfo *session = GenerateSession(sessionParam);
582 session->channelId = TRANS_TEST_CHANNEL_ID;
583 session->channelType = CHANNEL_TYPE_UDP;
584 ret = ClientAddNewSession(g_sessionName, session);
585 EXPECT_EQ(ret, SOFTBUS_OK);
586 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
587 EXPECT_EQ(ret, SOFTBUS_OK);
588 EXPECT_TRUE(data);
589 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_BUTT, &data);
590 EXPECT_EQ(ret, SOFTBUS_ERR);
591 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
592 EXPECT_EQ(ret, SOFTBUS_OK);
593 SoftBusFree(sessionParam);
594 }
595
596 /**
597 * @tc.name: TransClientSessionManagerTest18
598 * @tc.desc: Transmission sdk session manager get session id by channel id.
599 * @tc.type: FUNC
600 * @tc.require:
601 */
602 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest18, TestSize.Level1)
603 {
604 int32_t sessionId = 0;
605 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
606 EXPECT_EQ(ret, SOFTBUS_OK);
607 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
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 = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
619 EXPECT_EQ(ret, SOFTBUS_OK);
620 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
621 EXPECT_EQ(ret, SOFTBUS_OK);
622 SoftBusFree(sessionParam);
623 }
624
625 /**
626 * @tc.name: TransClientSessionManagerTest19
627 * @tc.desc: Transmission sdk session manager get enable session id by channel id.
628 * @tc.type: FUNC
629 * @tc.require:
630 */
631 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest19, TestSize.Level1)
632 {
633 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
634 EXPECT_TRUE(channel != NULL);
635 memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
636 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
637 EXPECT_EQ(ret, SOFTBUS_OK);
638 int32_t sessionId = 0;
639 ret = ClientEnableSessionByChannelId(channel, &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 channel->channelId = 0;
646 channel->channelType = CHANNEL_TYPE_AUTH;
647 ret = ClientAddAuthSession(g_sessionName, &sessionId);
648 EXPECT_EQ(ret, SOFTBUS_OK);
649 int32_t newSessionId = 0;
650 ret = ClientEnableSessionByChannelId(channel, &newSessionId);
651 EXPECT_EQ(ret, SOFTBUS_MEM_ERR);
652 char deviceId[DEVICE_ID_SIZE_MAX] = {0};
653 ret = strcpy_s(deviceId, DEVICE_ID_SIZE_MAX, g_deviceId);
654 EXPECT_EQ(ret, EOK);
655 channel->peerDeviceId = deviceId;
656 ret = ClientEnableSessionByChannelId(channel, &newSessionId);
657 EXPECT_EQ(ret, SOFTBUS_OK);
658 EXPECT_EQ(sessionId, newSessionId);
659 ret = ClientDeleteSession(sessionId);
660 EXPECT_EQ(ret, SOFTBUS_OK);
661 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
662 EXPECT_EQ(ret, SOFTBUS_OK);
663 SoftBusFree(channel);
664 SoftBusFree(sessionParam);
665 }
666
667 /**
668 * @tc.name: TransClientSessionManagerTest20
669 * @tc.desc: Transmission sdk session manager get enable session callback by session id.
670 * @tc.type: FUNC
671 * @tc.require:
672 */
673 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest20, TestSize.Level1)
674 {
675 ISessionListener sessionlistener = {0};
676 int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
677 EXPECT_EQ(ret, SOFTBUS_ERR);
678 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
679 EXPECT_TRUE(sessionParam != NULL);
680 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
681 GenerateCommParam(sessionParam);
682 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
683 EXPECT_EQ(ret, SOFTBUS_OK);
684 int32_t sessionId = 0;
685 bool isEnabled = false;
686 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
687 EXPECT_EQ(ret, SOFTBUS_OK);
688 ret = ClientGetSessionCallbackById(sessionId, &sessionlistener);
689 EXPECT_EQ(ret, SOFTBUS_OK);
690 EXPECT_EQ(sessionlistener.OnSessionOpened, OnSessionOpened);
691 EXPECT_EQ(sessionlistener.OnSessionClosed, OnSessionClosed);
692 EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
693 EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
694 ret = ClientDeleteSession(sessionId);
695 EXPECT_EQ(ret, SOFTBUS_OK);
696 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
697 EXPECT_EQ(ret, SOFTBUS_OK);
698 SoftBusFree(sessionParam);
699 }
700
701 /**
702 * @tc.name: TransClientSessionManagerTest21
703 * @tc.desc: Transmission sdk session manager get enable session callback by session name.
704 * @tc.type: FUNC
705 * @tc.require:
706 */
707 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest21, TestSize.Level1)
708 {
709 ISessionListener sessionlistener = {0};
710 int32_t ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
711 EXPECT_EQ(ret, SOFTBUS_ERR);
712 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
713 EXPECT_EQ(ret, SOFTBUS_OK);
714 char pkgName[] = {"dms1"};
715 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
716 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, pkgName, sessionName, &g_sessionlistener);
717 EXPECT_EQ(ret, SOFTBUS_OK);
718 ret = ClientGetSessionCallbackByName(sessionName, &sessionlistener);
719 EXPECT_EQ(ret, SOFTBUS_OK);
720 EXPECT_EQ(sessionlistener.OnSessionOpened, OnSessionOpened);
721 EXPECT_EQ(sessionlistener.OnSessionClosed, OnSessionClosed);
722 EXPECT_EQ(sessionlistener.OnMessageReceived, OnMessageReceived);
723 EXPECT_EQ(sessionlistener.OnBytesReceived, OnBytesReceived);
724 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
725 EXPECT_EQ(ret, SOFTBUS_OK);
726 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
727 EXPECT_EQ(ret, SOFTBUS_OK);
728 }
729
730 /**
731 * @tc.name: TransClientSessionManagerTest22
732 * @tc.desc: Transmission sdk session manager get session side by session id.
733 * @tc.type: FUNC
734 * @tc.require:
735 */
736 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest22, TestSize.Level1)
737 {
738 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
739 EXPECT_EQ(ret, SOFTBUS_ERR);
740 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
741 EXPECT_EQ(ret, SOFTBUS_OK);
742 int32_t sessionId = 0;
743 bool isEnabled = false;
744 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
745 EXPECT_TRUE(sessionParam != NULL);
746 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
747 GenerateCommParam(sessionParam);
748 ret = ClientAddSession(sessionParam, &sessionId, &isEnabled);
749 EXPECT_EQ(ret, SOFTBUS_OK);
750 char sessionName[] = {"ohos.distributedschedule.dms.test1"};
751 char groupId[] = {"TEST_GROUP_ID1"};
752 char deviceId[] = {"ABCDEF00ABCDEF00ABCDEF00A"};
753 sessionParam->groupId = groupId;
754 sessionParam->peerSessionName = sessionName;
755 sessionParam->peerDeviceId = deviceId;
756 int32_t newSessionId = 0;
757 ret = ClientAddSession(sessionParam, &newSessionId, &isEnabled);
758 EXPECT_EQ(ret, SOFTBUS_OK);
759 ret = ClientGetSessionSide(sessionId);
760 EXPECT_EQ(ret, IS_CLIENT);
761 ret = ClientGetSessionSide(newSessionId);
762 EXPECT_EQ(ret, IS_CLIENT);
763 ret = ClientDeleteSession(sessionId);
764 EXPECT_EQ(ret, SOFTBUS_OK);
765 ret = ClientDeleteSession(newSessionId);
766 EXPECT_EQ(ret, SOFTBUS_OK);
767 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
768 EXPECT_EQ(ret, SOFTBUS_OK);
769 SoftBusFree(sessionParam);
770 }
771
772 /**
773 * @tc.name: TransClientSessionManagerTest23
774 * @tc.desc: Transmission sdk session manager grant permission and remove permission with invalid parameters.
775 * @tc.type: FUNC
776 * @tc.require:
777 */
778 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest23, TestSize.Level1)
779 {
780 int32_t ret = ClientGrantPermission(TRANS_TEST_INVALID_UID, TRANS_TEST_PID, g_sessionName);
781 EXPECT_EQ(ret, SOFTBUS_ERR);
782 ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_INVALID_PID, g_sessionName);
783 EXPECT_EQ(ret, SOFTBUS_ERR);
784 ret = ClientGrantPermission(TRANS_TEST_UID, TRANS_TEST_PID, NULL);
785 EXPECT_EQ(ret, SOFTBUS_ERR);
786 ret = ClientRemovePermission(NULL);
787 EXPECT_EQ(ret, SOFTBUS_ERR);
788 }
789
790 /**
791 * @tc.name: TransClientSessionManagerTest24
792 * @tc.desc: Transmission sdk session manager get file config by session.
793 * @tc.type: FUNC
794 * @tc.require:
795 */
796 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest24, TestSize.Level1)
797 {
798 int32_t fileEncrypt = 0;
799 int32_t algorithm = 0;
800 int32_t crc = 0;
801 int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
802 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
803 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
804 EXPECT_EQ(ret, SOFTBUS_OK);
805 int32_t sessionId = 0;
806 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
807 EXPECT_TRUE(sessionParam != NULL);
808 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
809 GenerateCommParam(sessionParam);
810 SessionInfo *session = GenerateSession(sessionParam);
811 session->channelId = TRANS_TEST_CHANNEL_ID;
812 session->channelType = CHANNEL_TYPE_UDP;
813 ret = ClientAddNewSession(g_sessionName, session);
814 EXPECT_EQ(ret, SOFTBUS_OK);
815 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
816 EXPECT_EQ(ret, SOFTBUS_OK);
817 ret = ClientGetFileConfigInfoById(sessionId, &fileEncrypt, &algorithm, &crc);
818 EXPECT_EQ(ret, SOFTBUS_OK);
819 EXPECT_EQ(TRANS_TEST_FILE_ENCRYPT, fileEncrypt);
820 EXPECT_EQ(TRANS_TEST_ALGORITHM, algorithm);
821 EXPECT_EQ(TRANS_TEST_CRC, crc);
822 ret = ClientDeleteSession(sessionId);
823 EXPECT_EQ(ret, SOFTBUS_OK);
824 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
825 EXPECT_EQ(ret, SOFTBUS_OK);
826 SoftBusFree(sessionParam);
827 }
828
829 /**
830 * @tc.name: TransClientSessionManagerTest25
831 * @tc.desc: Transmission sdk session manager recreate session server to server.
832 * @tc.type: FUNC
833 * @tc.require:
834 */
835 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest25, TestSize.Level1)
836 {
837 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
838 EXPECT_EQ(ret, SOFTBUS_OK);
839 ret = ReCreateSessionServerToServer();
840 EXPECT_EQ(ret, SOFTBUS_OK);
841 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
842 EXPECT_EQ(ret, SOFTBUS_OK);
843 }
844
845 /**
846 * @tc.name: TransClientSessionManagerTest26
847 * @tc.desc: Transmission sdk session manager clear list on link down.
848 * @tc.type: FUNC
849 * @tc.require:
850 */
851 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest26, TestSize.Level1)
852 {
853 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
854 EXPECT_EQ(ret, SOFTBUS_OK);
855 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
856 EXPECT_TRUE(sessionParam != NULL);
857 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
858 GenerateCommParam(sessionParam);
859 SessionInfo *session = GenerateSession(sessionParam);
860 session->channelId = TRANS_TEST_CHANNEL_ID;
861 session->channelType = CHANNEL_TYPE_UDP;
862 ret = ClientAddNewSession(g_sessionName, session);
863 EXPECT_EQ(ret, SOFTBUS_OK);
864 ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
865 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
866 EXPECT_EQ(ret, SOFTBUS_OK);
867 }
868
869 /**
870 * @tc.name: TransClientSessionManagerTest27
871 * @tc.desc: Transmission sdk session manager clear all session when server death.
872 * @tc.type: FUNC
873 * @tc.require:
874 */
875 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest27, TestSize.Level1)
876 {
877 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
878 EXPECT_EQ(ret, SOFTBUS_OK);
879 ClientCleanAllSessionWhenServerDeath();
880 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
881 EXPECT_TRUE(sessionParam != NULL);
882 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
883 GenerateCommParam(sessionParam);
884 SessionInfo *session = GenerateSession(sessionParam);
885 session->channelId = TRANS_TEST_CHANNEL_ID;
886 session->channelType = CHANNEL_TYPE_UDP;
887 ret = ClientAddNewSession(g_sessionName, session);
888 EXPECT_EQ(ret, SOFTBUS_OK);
889 ClientCleanAllSessionWhenServerDeath();
890 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
891 EXPECT_EQ(ret, SOFTBUS_OK);
892 }
893
894 /**
895 * @tc.name: TransClientSessionManagerTest28
896 * @tc.desc: Transmission sdk session manager permission state change.
897 * @tc.type: FUNC
898 * @tc.require:
899 */
900 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest28, TestSize.Level1)
901 {
902 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
903 EXPECT_EQ(ret, SOFTBUS_OK);
904 PermissionStateChange(g_pkgName, TRANS_TEST_STATE);
905 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
906 EXPECT_EQ(ret, SOFTBUS_OK);
907 }
908
909 /**
910 * @tc.name: TransClientSessionDestoryTest01
911 * @tc.desc: Transmission sdk session manager destory session by network id.
912 * @tc.type: FUNC
913 * @tc.require:
914 */
915 HWTEST_F(TransClientSessionManagerTest, TransClientSessionDestoryTest01, TestSize.Level1)
916 {
917 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
918 ASSERT_EQ(ret, SOFTBUS_OK);
919 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
920 ASSERT_TRUE(sessionParam != NULL);
921 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
922 GenerateCommParam(sessionParam);
923 SessionInfo *session = GenerateSession(sessionParam);
924 ASSERT_TRUE(session != NULL);
925 session->channelId = TRANS_TEST_CHANNEL_ID;
926 session->channelType = CHANNEL_TYPE_UDP;
927 session->routeType = WIFI_STA;
928 ret = ClientAddNewSession(g_sessionName, session);
929 ASSERT_EQ(ret, SOFTBUS_OK);
930 sessionParam->peerDeviceId = g_networkId;
931 SessionInfo *newSession = GenerateSession(sessionParam);
932 ASSERT_TRUE(newSession != NULL);
933 newSession->channelId = TRANS_TEST_CHANNEL_ID + 1;
934 newSession->channelType = CHANNEL_TYPE_UDP;
935 newSession->routeType = WIFI_P2P;
936 ret = ClientAddNewSession(g_sessionName, newSession);
937 ASSERT_EQ(ret, SOFTBUS_OK);
938 ClientTransOnLinkDown(g_networkId, WIFI_STA);
939 int32_t sessionId = 0;
940 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId);
941 EXPECT_EQ(ret, SOFTBUS_OK);
942 EXPECT_GT(sessionId, 0);
943 ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
944 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID + 1, CHANNEL_TYPE_UDP, &sessionId);
945 EXPECT_EQ(ret, SOFTBUS_ERR);
946 ClientTransOnLinkDown(g_deviceId, ROUTE_TYPE_ALL);
947 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
948 EXPECT_EQ(ret, SOFTBUS_ERR);
949 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
950 EXPECT_EQ(ret, SOFTBUS_OK);
951 SoftBusFree(sessionParam);
952 }
953
954 /**
955 * @tc.name: TransClientSessionManagerTest29
956 * @tc.desc: Transmission sdk session manager add and delete server with invalid parameters no initialize.
957 * @tc.type: FUNC
958 * @tc.require:
959 */
960 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest29, TestSize.Level1)
961 {
962 TransClientDeinit();
963 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, NULL, g_sessionName, &g_sessionlistener);
964 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
965 ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, g_sessionName, &g_sessionlistener);
966 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
967 ret = ClientDeleteSessionServer(SEC_TYPE_UNKNOWN, g_sessionName);
968 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
969 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, g_sessionName);
970 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
971 ret = ClientDeleteSession(TRANS_TEST_INVALID_SESSION_ID);
972 EXPECT_EQ(ret, SOFTBUS_ERR);
973 ret = ClientDeleteSession(TRANS_TEST_SESSION_ID);
974 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
975 }
976
977
978 /**
979 * @tc.name: TransClientSessionManagerTest30
980 * @tc.desc: Transmission sdk session manager add new auth session with invalid parameters no initialize.
981 * @tc.type: FUNC
982 * @tc.require:
983 */
984 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest30, TestSize.Level1)
985 {
986 int32_t sessionId = 0;
987 int32_t ret = ClientAddAuthSession(NULL, &sessionId);
988 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
989 ret = ClientAddAuthSession(g_sessionName, &sessionId);
990 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
991 }
992
993 /**
994 * @tc.name: TransClientSessionManagerTest31
995 * @tc.desc: Transmission sdk session manager add new session no initialize.
996 * @tc.type: FUNC
997 * @tc.require:
998 */
999 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest31, TestSize.Level1)
1000 {
1001 SessionParam *sessionParam = (SessionParam*)SoftBusMalloc(sizeof(SessionParam));
1002 EXPECT_TRUE(sessionParam != NULL);
1003 memset_s(sessionParam, sizeof(SessionParam), 0, sizeof(SessionParam));
1004 GenerateCommParam(sessionParam);
1005 SessionInfo *session = GenerateSession(sessionParam);
1006 int32_t ret = ClientAddNewSession(g_sessionName, NULL);
1007 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1008 ret = ClientAddNewSession(g_sessionName, session);
1009 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1010 SoftBusFree(sessionParam);
1011 }
1012
1013 /**
1014 * @tc.name: TransClientSessionManagerTest32
1015 * @tc.desc: Transmission sdk session manager get session Integer data by session id no initialize.
1016 * @tc.type: FUNC
1017 * @tc.require:
1018 */
1019 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest32, TestSize.Level1)
1020 {
1021 int data = 0;
1022 int32_t ret = ClientGetSessionIntegerDataById(TRANS_TEST_INVALID_SESSION_ID, &data, KEY_PEER_PID);
1023 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1024 ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, NULL, KEY_PEER_PID);
1025 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1026 ret = ClientGetSessionIntegerDataById(TRANS_TEST_SESSION_ID, &data, KEY_PEER_PID);
1027 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1028 }
1029
1030 /**
1031 * @tc.name: TransClientSessionManagerTest33
1032 * @tc.desc: Transmission sdk session manager set channel id by session id with invalid parameters no initialize.
1033 * @tc.type: FUNC
1034 * @tc.require:
1035 */
1036 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest33, TestSize.Level1)
1037 {
1038 TransInfo *transInfo = (TransInfo*)SoftBusMalloc(sizeof(TransInfo));
1039 EXPECT_TRUE(transInfo != NULL);
1040 memset_s(transInfo, sizeof(TransInfo), 0, sizeof(TransInfo));
1041 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1042 transInfo->channelType = CHANNEL_TYPE_UDP;
1043 int32_t ret = ClientSetChannelBySessionId(TRANS_TEST_INVALID_SESSION_ID, transInfo);
1044 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1045 transInfo->channelId = TRANS_TEST_INVALID_CHANNEL_ID;
1046 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1047 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1048 transInfo->channelId = TRANS_TEST_CHANNEL_ID;
1049 ret = ClientSetChannelBySessionId(TRANS_TEST_SESSION_ID, transInfo);
1050 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1051 SoftBusFree(transInfo);
1052 }
1053
1054 /**
1055 * @tc.name: TransClientSessionManagerTest34
1056 * @tc.desc: Transmission sdk session manager get channel business type by session id no initialize.
1057 * @tc.type: FUNC
1058 * @tc.require:
1059 */
1060 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest34, TestSize.Level1)
1061 {
1062 int32_t businessType = 0;
1063 int32_t ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_INVALID_SESSION_ID, &businessType);
1064 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1065 ret = ClientGetChannelBusinessTypeBySessionId(TRANS_TEST_SESSION_ID, &businessType);
1066 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1067 }
1068
1069 /**
1070 * @tc.name: TransClientSessionManagerTest35
1071 * @tc.desc: Transmission sdk session manager get encrypt by channel id with invalid parameters.
1072 * @tc.type: FUNC
1073 * @tc.require:
1074 */
1075 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest35, TestSize.Level1)
1076 {
1077 int data = 0;
1078 int32_t ret = GetEncryptByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1079 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1080 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, NULL);
1081 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1082 ret = GetEncryptByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &data);
1083 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1084 }
1085
1086 /**
1087 * @tc.name: TransClientSessionManagerTest36
1088 * @tc.desc: Transmission sdk session manager get session id by channel id with invalid parameters.
1089 * @tc.type: FUNC
1090 * @tc.require:
1091 */
1092 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest36, TestSize.Level1)
1093 {
1094 int sessionId = 0;
1095 int32_t ret = ClientGetSessionIdByChannelId(TRANS_TEST_INVALID_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
1096 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1097 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, NULL);
1098 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1099 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, CHANNEL_TYPE_UDP, &sessionId);
1100 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1101 }
1102
1103 /**
1104 * @tc.name: TransClientSessionManagerTest37
1105 * @tc.desc: Transmission sdk session manager get enable session id by channel id with invalid parameters.
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
1109 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest37, TestSize.Level1)
1110 {
1111 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
1112 EXPECT_TRUE(channel != NULL);
1113 memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
1114 int32_t sessionId = 0;
1115 int32_t ret = ClientEnableSessionByChannelId(NULL, &sessionId);
1116 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1117 ret = ClientEnableSessionByChannelId(channel, NULL);
1118 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1119 ret = ClientEnableSessionByChannelId(channel, &sessionId);
1120 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1121 SoftBusFree(channel);
1122 }
1123
1124 /**
1125 * @tc.name: TransClientSessionManagerTest38
1126 * @tc.desc: Transmission sdk session manager get enable session callback by session id with invalid parameters.
1127 * @tc.type: FUNC
1128 * @tc.require:
1129 */
1130 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest38, TestSize.Level1)
1131 {
1132 ISessionListener sessionlistener = {0};
1133 int32_t ret = ClientGetSessionCallbackById(TRANS_TEST_INVALID_SESSION_ID, &sessionlistener);
1134 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1135 ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, NULL);
1136 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1137 ret = ClientGetSessionCallbackById(TRANS_TEST_SESSION_ID, &sessionlistener);
1138 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1139 }
1140
1141 /**
1142 * @tc.name: TransClientSessionManagerTest39
1143 * @tc.desc: Transmission sdk session manager get enable session callback by session name with invalid parameters.
1144 * @tc.type: FUNC
1145 * @tc.require:
1146 */
1147 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest39, TestSize.Level1)
1148 {
1149 ISessionListener sessionlistener = {0};
1150 int32_t ret = ClientGetSessionCallbackByName(NULL, &sessionlistener);
1151 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1152 ret = ClientGetSessionCallbackByName(g_sessionName, NULL);
1153 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1154 ret = ClientGetSessionCallbackByName(g_sessionName, &sessionlistener);
1155 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1156 }
1157
1158 /**
1159 * @tc.name: TransClientSessionManagerTest40
1160 * @tc.desc: Transmission sdk session manager get side by session id with invalid parameters.
1161 * @tc.type: FUNC
1162 * @tc.require:
1163 */
1164 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest40, TestSize.Level1)
1165 {
1166 int32_t ret = ClientGetSessionSide(TRANS_TEST_SESSION_ID);
1167 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_SERVER_NOINIT);
1168 }
1169
1170 /**
1171 * @tc.name: TransClientSessionManagerTest41
1172 * @tc.desc: Transmission sdk session manager get file config by session id with invalid parameters.
1173 * @tc.type: FUNC
1174 * @tc.require:
1175 */
1176 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest41, TestSize.Level1)
1177 {
1178 int32_t fileEncrypt = 0;
1179 int32_t algorithm = 0;
1180 int32_t crc = 0;
1181 int32_t ret = ClientGetFileConfigInfoById(TRANS_TEST_INVALID_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1182 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1183 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, NULL, &algorithm, &crc);
1184 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1185 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, NULL, &crc);
1186 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1187 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, NULL);
1188 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
1189 ret = ClientGetFileConfigInfoById(TRANS_TEST_SESSION_ID, &fileEncrypt, &algorithm, &crc);
1190 EXPECT_EQ(ret, SOFTBUS_ERR);
1191 }
1192
1193 /**
1194 * @tc.name: TransClientSessionManagerTest42
1195 * @tc.desc: Transmission sdk session manager operate no initialize.
1196 * @tc.type: FUNC
1197 * @tc.require:
1198 */
1199 HWTEST_F(TransClientSessionManagerTest, TransClientSessionManagerTest42, TestSize.Level1)
1200 {
1201 int32_t ret = ReCreateSessionServerToServer();
1202 EXPECT_EQ(ret, SOFTBUS_ERR);
1203 ClientTransOnLinkDown(NULL, ROUTE_TYPE_ALL);
1204 ClientTransOnLinkDown(g_networkId, ROUTE_TYPE_ALL);
1205 ClientCleanAllSessionWhenServerDeath();
1206 PermissionStateChange(g_pkgName, 0);
1207 }
1208 }