1 /*
2 * Copyright (c) 2022-2024 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 "gtest/gtest.h"
17 #include <securec.h>
18
19 #include "auth_common.h"
20 #include "bus_center_event.h"
21 #include "softbus_adapter_mem.h"
22 #include "trans_udp_channel_manager.c"
23 #include "trans_udp_negotiation.h"
24
25 using namespace testing::ext;
26
27 namespace OHOS {
28
29 #define TEST_CHANNEL_ID 1000
30 #define TEST_LEN 64
31 #define TEST_AUTH_PORT (6000)
32 #define INVALID_CHANNEL_SEQ (22579)
33 #define INVALID_CHAN_ID (-1)
34 #define INVALID_CHANNEL_REQUETID (23456)
35 #define INVALID_CHANNEL_NETWORK (1111)
36 static int64_t g_channelId = 0;
37
38 class TransUdpManagerTest : public testing::Test {
39 public:
TransUdpManagerTest()40 TransUdpManagerTest()
41 {}
~TransUdpManagerTest()42 ~TransUdpManagerTest()
43 {}
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
SetUp()46 void SetUp() override
47 {}
TearDown()48 void TearDown() override
49 {}
50 };
51
SetUpTestCase(void)52 void TransUdpManagerTest::SetUpTestCase(void)
53 {
54 int32_t ret = LnnInitBusCenterEvent();
55 EXPECT_EQ(ret, SOFTBUS_OK);
56 ret = AuthCommonInit();
57 EXPECT_EQ(ret, SOFTBUS_OK);
58
59 IServerChannelCallBack *cb = TransServerGetChannelCb();
60 ret = TransUdpChannelInit(cb);
61 EXPECT_EQ(ret, SOFTBUS_OK);
62 }
63
TearDownTestCase(void)64 void TransUdpManagerTest::TearDownTestCase(void)
65 {
66 AuthCommonDeinit();
67 TransUdpChannelDeinit();
68 LnnDeinitBusCenterEvent();
69 }
70
TestGetChannelId()71 int64_t TestGetChannelId()
72 {
73 g_channelId++;
74 return g_channelId;
75 }
76
GetPackTest()77 UdpChannelInfo* GetPackTest()
78 {
79 UdpChannelInfo *Channel = (UdpChannelInfo*)SoftBusCalloc(sizeof(UdpChannelInfo));
80 if (Channel == nullptr) {
81 return nullptr;
82 }
83 Channel->info.myData.channelId = TestGetChannelId();
84 Channel->info.appType = APP_TYPE_NORMAL;
85 Channel->info.myData.apiVersion = API_V2;
86 Channel->info.businessType = BUSINESS_TYPE_MESSAGE;
87 Channel->info.peerData.apiVersion = API_V2;
88 Channel->info.encrypt = APP_INFO_FILE_FEATURES_SUPPORT;
89 Channel->info.algorithm = APP_INFO_ALGORITHM_AES_GCM_256;
90 Channel->info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
91 (void)memcpy_s(Channel->info.groupId, GROUP_ID_SIZE_MAX, "123",
92 (strlen("123")+1));
93 (void)memcpy_s(Channel->info.myData.sessionName, SESSION_NAME_SIZE_MAX,
94 "com.test.trans.session", (strlen("com.test.trans.session")+1));
95 (void)memcpy_s(Channel->info.peerNetWorkId, DEVICE_ID_SIZE_MAX,
96 "1234567789", (strlen("1234567789")+1));
97 (void)memcpy_s(Channel->info.peerData.sessionName, SESSION_NAME_SIZE_MAX,
98 "com.test.trans.session.sendfile", (strlen("com.test.trans.session.sendfile")+1));
99 (void)memcpy_s(Channel->info.sessionKey, SESSION_KEY_LENGTH,
100 "auth session key", (strlen("auth session key")+1));
101 (void)memcpy_s(Channel->info.myData.pkgName, PKG_NAME_SIZE_MAX,
102 "normal pakName", (strlen("normal pakName")+1));
103 (void)memcpy_s(Channel->info.myData.sessionName, SESSION_NAME_SIZE_MAX,
104 "normal sessionName", (strlen("normal sessionName")+1));
105 return Channel;
106 }
107
108 /**
109 * @tc.name: TransUdpManagerTest001
110 * @tc.desc: get lock and relsease lock.
111 * @tc.type: FUNC
112 * @tc.require:
113 */
114 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest001, TestSize.Level1)
115 {
116 int32_t ret = TransUdpChannelMgrInit();
117 EXPECT_EQ(ret, SOFTBUS_OK);
118 ret = GetUdpChannelLock();
119 EXPECT_EQ(ret, SOFTBUS_OK);
120 ReleaseUdpChannelLock();
121 TransUdpChannelMgrDeinit();
122 ret = GetUdpChannelLock();
123 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
124 }
125
126 /**
127 * @tc.name: TransUdpManagerTest002
128 * @tc.desc: udp channel init and deinit.
129 * @tc.type: FUNC
130 * @tc.require:
131 */
132 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest002, TestSize.Level1)
133 {
134 int32_t ret = TransUdpChannelMgrInit();
135 EXPECT_EQ(ret, SOFTBUS_OK);
136 UdpChannelInfo *newchannel = nullptr;
137 ret = TransAddUdpChannel(newchannel);
138 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
139 TransUdpChannelMgrDeinit();
140 UdpChannelInfo *Channel = GetPackTest();
141 ASSERT_TRUE(Channel != nullptr);
142 ret = TransAddUdpChannel(Channel);
143 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
144 }
145
146 /**
147 * @tc.name: TransUdpManagerTest003
148 * @tc.desc: add udp channel and del udp channel.
149 * @tc.type: FUNC
150 * @tc.require:
151 */
152 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest003, TestSize.Level1)
153 {
154 int32_t invalidId = -1;
155 int32_t ret = TransUdpChannelMgrInit();
156 EXPECT_EQ(ret, SOFTBUS_OK);
157 UdpChannelInfo *Channel = GetPackTest();
158 ASSERT_TRUE(Channel != nullptr);
159 ret = TransAddUdpChannel(NULL);
160 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
161
162 ret = TransAddUdpChannel(Channel);
163 EXPECT_EQ(ret, SOFTBUS_OK);
164
165 ret = TransAddUdpChannel(Channel);
166 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_ALREADY_EXIST);
167 ret = TransDelUdpChannel(invalidId);
168 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
169 ret = TransDelUdpChannel(Channel->info.myData.channelId);
170 EXPECT_EQ(ret, SOFTBUS_OK);
171
172 TransUdpChannelMgrDeinit();
173 ret = TransAddUdpChannel(Channel);
174 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
175 ret = TransDelUdpChannel(invalidId);
176 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
177 }
178
179 /**
180 * @tc.name: TransUdpManagerTest005
181 * @tc.desc: get UdpChannelInfo by seq, use normal param.
182 * @tc.type: FUNC
183 * @tc.require: Zero
184 */
185 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest005, TestSize.Level1)
186 {
187 int32_t ret = TransUdpChannelMgrInit();
188 EXPECT_EQ(ret, SOFTBUS_OK);
189 UdpChannelInfo *Channel = GetPackTest();
190 ASSERT_TRUE(Channel != nullptr);
191 Channel->seq = 20;
192 UdpChannelInfo *newChannel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
193 ASSERT_TRUE(newChannel != nullptr);
194 newChannel->seq = 20;
195 ret = TransAddUdpChannel(Channel);
196 EXPECT_EQ(ret, SOFTBUS_OK);
197 ret = TransGetUdpChannelBySeq(Channel->seq, newChannel);
198 EXPECT_EQ(ret, SOFTBUS_OK);
199 ret = TransDelUdpChannel(newChannel->info.myData.channelId);
200 EXPECT_EQ(ret, SOFTBUS_OK);
201 SoftBusFree(newChannel);
202 TransUdpChannelMgrDeinit();
203 }
204
205 /**
206 * @tc.name: TransUdpManagerTest006
207 * @tc.desc: get UdpChannelInfo by seq, use wrong param.
208 * @tc.type: FUNC
209 * @tc.require: NonZero
210 */
211 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest006, TestSize.Level1)
212 {
213 UdpChannelInfo *Channel = GetPackTest();
214 ASSERT_TRUE(Channel != nullptr);
215 int64_t seq = INVALID_CHANNEL_SEQ;
216 UdpChannelInfo *newChannel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
217 ASSERT_TRUE(newChannel != nullptr);
218 newChannel->seq = 20;
219 TransUdpChannelMgrDeinit();
220 int32_t ret = TransGetUdpChannelBySeq(Channel->seq, newChannel);
221 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
222
223 ret = TransUdpChannelMgrInit();
224 EXPECT_EQ(SOFTBUS_OK, ret);
225
226 ret = TransAddUdpChannel(Channel);
227 EXPECT_EQ(SOFTBUS_OK, ret);
228 ret = TransGetUdpChannelBySeq(seq, NULL);
229 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
230
231 ret = TransGetUdpChannelBySeq(seq, newChannel);
232 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
233 SoftBusFree(newChannel);
234 TransUdpChannelMgrDeinit();
235 }
236
237 /**
238 * @tc.name: TransUdpManagerTest007
239 * @tc.desc: get UdpChannelInfo by channelId, use normal param.
240 * @tc.type: FUNC
241 * @tc.require:
242 */
243 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest007, TestSize.Level1)
244 {
245 int32_t ret = TransUdpChannelMgrInit();
246 EXPECT_EQ(ret, SOFTBUS_OK);
247 UdpChannelInfo *Channel = GetPackTest();
248 ASSERT_TRUE(Channel != nullptr);
249 UdpChannelInfo *newChannel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
250 ASSERT_TRUE(newChannel != nullptr);
251 newChannel->seq = 20;
252 ret = TransAddUdpChannel(Channel);
253 EXPECT_EQ(ret, SOFTBUS_OK);
254
255 ret = TransGetUdpChannelBySeq(Channel->requestId, newChannel);
256 EXPECT_EQ(ret, SOFTBUS_OK);
257
258 ret = TransDelUdpChannel(newChannel->info.myData.channelId);
259 EXPECT_EQ(ret, SOFTBUS_OK);
260 TransUdpChannelMgrDeinit();
261 SoftBusFree(newChannel);
262 }
263
264 /**
265 * @tc.name: TransUdpManagerTest008
266 * @tc.desc: get UdpChannelInfo by channelId, use wrong param.
267 * @tc.type: FUNC
268 * @tc.require: NonZero
269 */
270 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest008, TestSize.Level1)
271 {
272 int64_t channlId = INVALID_CHAN_ID;
273 UdpChannelInfo *newChannel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
274 ASSERT_TRUE(newChannel != nullptr);
275 newChannel->seq = 20;
276 UdpChannelInfo *Channel = GetPackTest();
277 ASSERT_TRUE(Channel != nullptr);
278 TransUdpChannelMgrDeinit();
279 int32_t ret = TransGetUdpChannelById(Channel->info.myData.channelId, newChannel);
280 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
281
282 ret = TransUdpChannelMgrInit();
283 EXPECT_EQ(ret, SOFTBUS_OK);
284
285 ret = TransAddUdpChannel(Channel);
286 EXPECT_EQ(ret, SOFTBUS_OK);
287 ret = TransGetUdpChannelById(channlId, NULL);
288 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
289
290 ret = TransGetUdpChannelById(channlId, newChannel);
291 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
292 TransUdpChannelMgrDeinit();
293 SoftBusFree(newChannel);
294 }
295
296 /**
297 * @tc.name: TransUdpManagerTest009
298 * @tc.desc: get UdpChannelInfo by requestId, use normal param;
299 * @tc.type: FUNC
300 * @tc.require:
301 */
302 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest009, TestSize.Level1)
303 {
304 int32_t ret = TransUdpChannelMgrInit();
305 EXPECT_EQ(ret, SOFTBUS_OK);
306 UdpChannelInfo *Channel = GetPackTest();
307 ASSERT_TRUE(Channel != nullptr);
308 UdpChannelInfo *newChannel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
309 ASSERT_TRUE(newChannel != nullptr);
310 newChannel->seq = 20;
311 ret = TransAddUdpChannel(Channel);
312 EXPECT_EQ(ret, SOFTBUS_OK);
313 ret = TransGetUdpChannelByRequestId(Channel->requestId, newChannel);
314 EXPECT_EQ(ret, SOFTBUS_OK);
315 ret = TransDelUdpChannel(newChannel->info.myData.channelId);
316 EXPECT_EQ(ret, SOFTBUS_OK);
317 TransUdpChannelMgrDeinit();
318 SoftBusFree(newChannel);
319 }
320
321 /**
322 * @tc.name: TransUdpManagerTest010
323 * @tc.desc: get UdpChannelInfo by requestId, use wrong param;
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest010, TestSize.Level1)
328 {
329 uint32_t requestId = INVALID_CHANNEL_REQUETID;
330 UdpChannelInfo *newChannel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
331 ASSERT_TRUE(newChannel != nullptr);
332 newChannel->seq = 20;
333 UdpChannelInfo *Channel = GetPackTest();
334 ASSERT_TRUE(Channel != nullptr);
335 TransUdpChannelMgrDeinit();
336 int32_t ret = TransGetUdpChannelById(Channel->requestId, newChannel);
337 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
338
339 ret = TransUdpChannelMgrInit();
340 EXPECT_EQ(ret, SOFTBUS_OK);
341
342 ret =TransAddUdpChannel(Channel);
343 EXPECT_EQ(ret, SOFTBUS_OK);
344 ret = TransGetUdpChannelByRequestId(requestId, NULL);
345 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
346
347 ret = TransGetUdpChannelByRequestId(requestId, newChannel);
348 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
349
350 TransUdpChannelMgrDeinit();
351 ret = TransGetUdpChannelByRequestId(requestId, newChannel);
352 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
353 SoftBusFree(newChannel);
354 }
355
356 /**
357 * @tc.name: TransUdpManagerTest011
358 * @tc.desc: set UdpChannel status, use normal param first, then use wrong parameters.
359 * @tc.type: FUNC
360 * @tc.require:
361 */
362 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest011, TestSize.Level1)
363 {
364 int32_t ret = TransUdpChannelMgrInit();
365 EXPECT_EQ(ret, SOFTBUS_OK);
366 int64_t seq = INVALID_CHANNEL_SEQ;
367 UdpChannelInfo *Channel = GetPackTest();
368 ASSERT_TRUE(Channel != nullptr);
369 ret = TransAddUdpChannel(Channel);
370 EXPECT_EQ(ret, SOFTBUS_OK);
371 ret = TransSetUdpChannelStatus(Channel->seq, (UdpChannelStatus)UDP_CHANNEL_STATUS_INIT);
372 EXPECT_EQ(ret, SOFTBUS_OK);
373
374 ret = TransSetUdpChannelStatus(seq, UDP_CHANNEL_STATUS_INIT);
375 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
376 ret = TransSetUdpChannelStatus(seq, (UdpChannelStatus)UDP_CHANNEL_STATUS_INIT);
377 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
378
379 TransUdpChannelMgrDeinit();
380 ret = TransSetUdpChannelStatus(seq, (UdpChannelStatus)UDP_CHANNEL_STATUS_INIT);
381 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
382 }
383
384 /**
385 * @tc.name: TransUdpManagerTest012
386 * @tc.desc: set UdpChannel opt type, use wrong param first, then use normal parameters.
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest012, TestSize.Level1)
391 {
392 int32_t ret = TransUdpChannelMgrInit();
393 EXPECT_EQ(ret, SOFTBUS_OK);
394 int64_t channelId = INVALID_CHAN_ID;
395 UdpChannelInfo *Channel = GetPackTest();
396 ASSERT_TRUE(Channel != nullptr);
397 ret = TransAddUdpChannel(Channel);
398 EXPECT_EQ(ret, SOFTBUS_OK);
399 ret = TransSetUdpChannelOptType(Channel->info.myData.channelId, (UdpChannelOptType)TYPE_UDP_CHANNEL_OPEN);
400 EXPECT_EQ(ret, SOFTBUS_OK);
401
402 ret = TransSetUdpChannelOptType(channelId, (UdpChannelOptType)TYPE_UDP_CHANNEL_OPEN);
403 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
404 ret = TransSetUdpChannelOptType(channelId, (UdpChannelOptType)TYPE_UDP_CHANNEL_OPEN);
405 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
406 TransUdpChannelMgrDeinit();
407 }
408
409 /**
410 * @tc.name: TransUdpManagerTest013
411 * @tc.desc: update UdpChannelInfo by seq, use normal parameters.
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest013, TestSize.Level1)
416 {
417 int32_t ret = TransUdpChannelMgrInit();
418 EXPECT_EQ(ret, SOFTBUS_OK);
419 UdpChannelInfo *Channel = GetPackTest();
420 ASSERT_TRUE(Channel != nullptr);
421 AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
422 ASSERT_TRUE(appInfo != nullptr);
423 appInfo->myData.channelId = 20;
424 ret = TransAddUdpChannel(Channel);
425 EXPECT_EQ(ret, SOFTBUS_OK);
426 TransUpdateUdpChannelInfo(Channel->seq, appInfo);
427 TransUdpChannelMgrDeinit();
428 SoftBusFree(appInfo);
429 }
430
431 /**
432 * @tc.name: TransUdpManagerTest014
433 * @tc.desc: update UdpChannelInfo by seq, use wrong parameters.
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest014, TestSize.Level1)
438 {
439 int64_t seq = INVALID_CHANNEL_SEQ;
440 AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
441 ASSERT_TRUE(appInfo != nullptr);
442 appInfo->myData.channelId = 20;
443 UdpChannelInfo *Channel = GetPackTest();
444 ASSERT_TRUE(Channel != nullptr);
445 TransUdpChannelMgrDeinit();
446 TransUpdateUdpChannelInfo(Channel->seq, appInfo);
447
448 int32_t ret = TransUdpChannelMgrInit();
449 EXPECT_EQ(ret, SOFTBUS_OK);
450
451 ret = TransAddUdpChannel(Channel);
452 EXPECT_EQ(ret, SOFTBUS_OK);
453 TransUpdateUdpChannelInfo(seq, NULL);
454 TransUpdateUdpChannelInfo(Channel->seq, appInfo);
455 TransUdpChannelMgrDeinit();
456 SoftBusFree(appInfo);
457 }
458
459 /**
460 * @tc.name: TransUdpManagerTest015
461 * @tc.desc: get pkgName and sessionName by channelId, use normal parameters.
462 * @tc.type: FUNC
463 * @tc.require:
464 */
465 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest015, TestSize.Level1)
466 {
467 int32_t ret = TransUdpChannelMgrInit();
468 EXPECT_EQ(ret, SOFTBUS_OK);
469 char pkgName[65] = {"normal pakName"};
470 char sessionName[256] = {"normal sessionName"};
471 UdpChannelInfo *Channel = GetPackTest();
472 ASSERT_TRUE(Channel != nullptr);
473 ret = TransAddUdpChannel(Channel);
474 EXPECT_EQ(ret, SOFTBUS_OK);
475 ret = TransUdpGetNameByChanId(Channel->info.myData.channelId, pkgName, sessionName,
476 PKG_NAME_SIZE_MAX, SESSION_NAME_SIZE_MAX);
477 EXPECT_EQ(ret, SOFTBUS_OK);
478 TransUdpChannelMgrDeinit();
479 }
480
481 /**
482 * @tc.name: TransUdpManagerTest016
483 * @tc.desc: get pkgName and sessionName by channelId, use wrong parameters.
484 * @tc.type: FUNC
485 * @tc.require:
486 */
487 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest016, TestSize.Level1)
488 {
489 int32_t ret = TransUdpChannelMgrInit();
490 EXPECT_EQ(ret, SOFTBUS_OK);
491 int32_t channelId = INVALID_CHAN_ID;
492 char pkgName[65] = {"wrong pakName"};
493 char sessionName[256] = {"wrong sessionName"};
494 UdpChannelInfo *Channel = GetPackTest();
495 ASSERT_TRUE(Channel != nullptr);
496 ret = TransAddUdpChannel(Channel);
497 EXPECT_EQ(ret, SOFTBUS_OK);
498
499 ret = TransUdpGetNameByChanId(Channel->info.myData.channelId, pkgName, NULL,
500 PKG_NAME_SIZE_MAX, SESSION_NAME_SIZE_MAX);
501 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
502
503 ret = TransUdpGetNameByChanId(channelId, NULL, sessionName,
504 PKG_NAME_SIZE_MAX, SESSION_NAME_SIZE_MAX);
505 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
506
507 ret = TransUdpGetNameByChanId(channelId, pkgName, sessionName,
508 PKG_NAME_SIZE_MAX, SESSION_NAME_SIZE_MAX);
509 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
510
511 ret = TransUdpGetNameByChanId(Channel->info.myData.channelId, pkgName, sessionName,
512 PKG_NAME_SIZE_MAX, SESSION_NAME_SIZE_MAX);
513 EXPECT_EQ(ret, SOFTBUS_OK);
514
515 TransUdpChannelMgrDeinit();
516 ret = TransUdpGetNameByChanId(channelId, pkgName, sessionName, PKG_NAME_SIZE_MAX, SESSION_NAME_SIZE_MAX);
517 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
518 }
519
520 /**
521 * @tc.name: TransUdpManagerTest017
522 * @tc.desc: trans get channel obj by channelId.
523 * @tc.type: FUNC
524 * @tc.require:
525 */
526 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest017, TestSize.Level1)
527 {
528 int32_t channelId = INVALID_CHAN_ID;
529 int32_t ret = TransUdpChannelMgrInit();
530 EXPECT_EQ(ret, SOFTBUS_OK);
531 UdpChannelInfo* Channel_1 = TransGetChannelObj(INVALID_CHAN_ID);
532 EXPECT_TRUE(Channel_1 == nullptr);
533
534 UdpChannelInfo* Channel = GetPackTest();
535 ASSERT_TRUE(Channel != nullptr);
536 ret = TransAddUdpChannel(Channel);
537 EXPECT_EQ(ret, SOFTBUS_OK);
538 Channel_1 = TransGetChannelObj(Channel->info.myData.channelId);
539 EXPECT_TRUE(Channel != NULL);
540 Channel_1 = TransGetChannelObj(channelId);
541 EXPECT_TRUE(Channel_1 == NULL);
542
543 TransUdpChannelMgrDeinit();
544 Channel_1 = TransGetChannelObj(Channel->info.myData.channelId);
545 EXPECT_TRUE(Channel_1 == NULL);
546 }
547
548 /**
549 * @tc.name: TransUdpManagerTest018
550 * @tc.desc: trans get channel obj by channelId, use normal param.
551 * @tc.type: FUNC
552 * @tc.require:
553 */
554 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest018, TestSize.Level1)
555 {
556 int32_t ret = TransUdpChannelMgrInit();
557 EXPECT_EQ(ret, SOFTBUS_OK);
558 UdpChannelInfo* Channel = GetPackTest();
559 ASSERT_TRUE(Channel != nullptr);
560 AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
561 ASSERT_TRUE(appInfo != nullptr);
562 appInfo->myData.channelId = 20;
563 ret = TransAddUdpChannel(Channel);
564 EXPECT_EQ(ret, SOFTBUS_OK);
565 ret = TransGetUdpAppInfoByChannelId(Channel->info.myData.channelId, appInfo);
566 EXPECT_EQ(ret, SOFTBUS_OK);
567
568 TransUdpChannelMgrDeinit();
569 SoftBusFree(appInfo);
570 }
571
572 /**
573 * @tc.name: TransUdpManagerTest019
574 * @tc.desc: trans get channel obj by channelId, use wrong param.
575 * @tc.type: FUNC
576 * @tc.require:
577 */
578 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest019, TestSize.Level1)
579 {
580 int32_t ret = TransUdpChannelMgrInit();
581 EXPECT_EQ(ret, SOFTBUS_OK);
582 int32_t channelId = INVALID_CHAN_ID;
583 UdpChannelInfo* Channel = GetPackTest();
584 ASSERT_TRUE(Channel != nullptr);
585 AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
586 ASSERT_TRUE(appInfo != nullptr);
587 appInfo->myData.channelId = 20;
588 ret = TransAddUdpChannel(Channel);
589 EXPECT_EQ(ret, SOFTBUS_OK);
590 ret = TransGetUdpAppInfoByChannelId(channelId, appInfo);
591 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
592 ret = TransGetUdpAppInfoByChannelId(channelId, NULL);
593 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
594 TransUdpChannelMgrDeinit();
595 SoftBusFree(appInfo);
596 }
597
598 /**
599 * @tc.name: TransUdpManagerTest020
600 * @tc.desc: trans notify udp channel close list.
601 * @tc.type: FUNC
602 * @tc.require:
603 */
604 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest020, TestSize.Level1)
605 {
606 int32_t ret = TransUdpChannelMgrInit();
607 EXPECT_EQ(ret, SOFTBUS_OK);
608 UdpChannelInfo* channel = GetPackTest();
609 ASSERT_TRUE(channel != nullptr);
610 ret = TransAddUdpChannel(channel);
611 EXPECT_EQ(ret, SOFTBUS_OK);
612 ListNode udpDeleteChannelList;
613 ListInit(&udpDeleteChannelList);
614 NotifyUdpChannelCloseInList(&udpDeleteChannelList);
615 TransUdpChannelMgrDeinit();
616 }
617
618 /**
619 * @tc.name: TransUdpManagerTest021
620 * @tc.desc: trans close udp channel by networkId.
621 * @tc.type: FUNC
622 * @tc.require:
623 */
624 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest021, TestSize.Level1)
625 {
626 string networkId = "invalid networlId";
627 TransCloseUdpChannelByNetWorkId(networkId.c_str());
628 int32_t ret = TransUdpChannelMgrInit();
629 EXPECT_EQ(ret, SOFTBUS_OK);
630 TransCloseUdpChannelByNetWorkId(NULL);
631 UdpChannelInfo *channel = GetPackTest();
632 ASSERT_TRUE(channel != nullptr);
633 ret = TransAddUdpChannel(channel);
634 EXPECT_EQ(ret, SOFTBUS_OK);
635 TransUdpChannelMgrDeinit();
636 }
637
638 /**
639 * @tc.name: TransUdpManagerTest022
640 * @tc.desc: trans notify udp channel timeout use diff param.
641 * @tc.type: FUNC
642 * @tc.require:
643 */
644 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest022, TestSize.Level1)
645 {
646 int32_t ret = TransUdpChannelMgrInit();
647 EXPECT_EQ(ret, SOFTBUS_OK);
648 UdpChannelInfo* channel = GetPackTest();
649 ASSERT_TRUE(channel != nullptr);
650 channel->info.udpChannelOptType = TYPE_UDP_CHANNEL_OPEN;
651 ret = TransAddUdpChannel(channel);
652 EXPECT_EQ(ret, SOFTBUS_OK);
653 ListNode udpTmpChannelList;
654 ListInit(&udpTmpChannelList);
655 NotifyTimeOutUdpChannel(&udpTmpChannelList);
656 TransUdpChannelMgrDeinit();
657 }
658
659 /**
660 * @tc.name: TransUdpManagerTest023
661 * @tc.desc: trans notify udp channel timeout use diff param.
662 * @tc.type: FUNC
663 * @tc.require:
664 */
665 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest023, TestSize.Level1)
666 {
667 int32_t ret = TransUdpChannelMgrInit();
668 EXPECT_EQ(ret, SOFTBUS_OK);
669 UdpChannelInfo* channel = GetPackTest();
670 ASSERT_TRUE(channel != nullptr);
671 channel->info.udpChannelOptType = TYPE_UDP_CHANNEL_CLOSE;
672 ret = TransAddUdpChannel(channel);
673 EXPECT_EQ(ret, SOFTBUS_OK);
674
675 ListNode udpTmpChannelList;
676 ListInit(&udpTmpChannelList);
677 NotifyTimeOutUdpChannel(&udpTmpChannelList);
678 TransUdpChannelMgrDeinit();
679 }
680
681 /**
682 * @tc.name: TransUdpManagerTest024
683 * @tc.desc: trans notify udp channel timeout use diff param.
684 * @tc.type: FUNC
685 * @tc.require:
686 */
687 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest024, TestSize.Level1)
688 {
689 int32_t ret = TransUdpChannelMgrInit();
690 EXPECT_EQ(ret, SOFTBUS_OK);
691 UdpChannelInfo* channel = GetPackTest();
692 ASSERT_TRUE(channel != nullptr);
693 channel->info.udpChannelOptType = TYPE_INVALID_CHANNEL;
694 ret = TransAddUdpChannel(channel);
695 EXPECT_EQ(ret, SOFTBUS_OK);
696 ListNode udpTmpChannelList;
697 ListInit(&udpTmpChannelList);
698 NotifyTimeOutUdpChannel(&udpTmpChannelList);
699 TransUdpChannelMgrDeinit();
700 }
701
702 /**
703 * @tc.name: TransUdpManagerTest025
704 * @tc.desc: TransUdpGetIpAndConnectTypeById test.
705 * @tc.type: FUNC
706 * @tc.require:
707 */
708 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest025, TestSize.Level1)
709 {
710 int32_t ret = TransUdpChannelMgrInit();
711 EXPECT_EQ(SOFTBUS_OK, ret);
712 int32_t channelId = TEST_CHANNEL_ID;
713 uint32_t maxIpLen = TEST_LEN;
714 int32_t connectType = CONNECT_TYPE_MAX;
715
716 ret = TransUdpGetIpAndConnectTypeById(channelId, nullptr, nullptr, maxIpLen, &connectType);
717 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
718
719 char localIp[IP_LEN] = { 0 };
720 char remoteIp[IP_LEN] = { 0 };
721 ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, maxIpLen, &connectType);
722 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
723
724 UdpChannelInfo *channel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
725 ASSERT_TRUE(channel != nullptr);
726 channel->info.myData.channelId = channelId;
727 ret = TransAddUdpChannel(channel);
728 EXPECT_EQ(SOFTBUS_OK, ret);
729 ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, maxIpLen, &connectType);
730 EXPECT_EQ(SOFTBUS_OK, ret);
731
732 TransDelUdpChannel(channelId);
733 TransUdpChannelMgrDeinit();
734 }
735
736 /**
737 * @tc.name: TransUdpManagerTest026
738 * @tc.desc: IsUdpRecoveryTransLimit test.
739 * @tc.type: FUNC
740 * @tc.require:
741 */
742 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest026, TestSize.Level1)
743 {
744 int32_t ret = TransUdpChannelMgrInit();
745 EXPECT_EQ(SOFTBUS_OK, ret);
746 UdpChannelInfo *channel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
747 ASSERT_TRUE(channel != nullptr);
748 bool flag = IsUdpRecoveryTransLimit();
749 EXPECT_EQ(true, flag);
750 channel->info.myData.channelId = TEST_CHANNEL_ID;
751 channel->info.businessType = BUSINESS_TYPE_STREAM;
752 ret = TransAddUdpChannel(channel);
753 EXPECT_EQ(SOFTBUS_OK, ret);
754 flag = IsUdpRecoveryTransLimit();
755 EXPECT_EQ(false, flag);
756 TransDelUdpChannel(TEST_CHANNEL_ID);
757 TransUdpChannelMgrDeinit();
758 }
759
760 /**
761 * @tc.name: TransUdpGetIpAndConnectTypeById
762 * @tc.desc: Get localIp and connectType wiht channelId
763 * @tc.type: FUNC
764 * @tc.require:
765 */
766 HWTEST_F(TransUdpManagerTest, TransUdpGetIpAndConnectTypeById001, TestSize.Level1)
767 {
768 int32_t ret = TransUdpChannelMgrInit();
769 EXPECT_EQ(ret, SOFTBUS_OK);
770 int32_t channelId = -1;
771 char localIp[IP_LEN] = { 0 };
772 char remoteIp[IP_LEN] = { 0 };
773 int32_t connectType = CONNECT_TYPE_MAX;
774
775 ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, IP_LEN, &connectType);
776 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
777
778 channelId = INT32_MAX;
779 ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, IP_LEN, &connectType);
780 EXPECT_EQ(ret, SOFTBUS_NOT_FIND);
781
782 TransUdpChannelMgrDeinit();
783 }
784
785 /**
786 * @tc.name: TransUdpManagerTest027
787 * @tc.desc: UdpChannelFileTransLimit test.
788 * @tc.type: FUNC
789 * @tc.require:
790 */
791 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest027, TestSize.Level1)
792 {
793 TransUdpChannelMgrInit();
794 ChannelInfo *channel = nullptr;
795 int32_t ret = UdpChannelFileTransLimit(channel, FILE_PRIORITY_BK);
796 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
797
798 channel = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
799 ASSERT_TRUE(channel != nullptr);
800 channel->channelType = CHANNEL_TYPE_PROXY;
801 ret = UdpChannelFileTransLimit(channel, FILE_PRIORITY_BK);
802 EXPECT_EQ(SOFTBUS_OK, ret);
803
804 (void)memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
805 channel->businessType = BUSINESS_TYPE_MESSAGE;
806 ret = UdpChannelFileTransLimit(channel, FILE_PRIORITY_BK);
807 EXPECT_EQ(SOFTBUS_OK, ret);
808
809 (void)memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
810 ret = UdpChannelFileTransLimit(channel, FILE_PRIORITY_BK);
811 EXPECT_EQ(SOFTBUS_OK, ret);
812 TransUdpChannelMgrDeinit();
813 SoftBusFree(channel);
814 }
815
816 /**
817 * @tc.name: TransUdpManagerTest028
818 * @tc.desc: ModifyUpdChannelTos test.
819 * @tc.type: FUNC
820 * @tc.require:
821 */
822 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest028, TestSize.Level1)
823 {
824 uint8_t tos = FILE_PRIORITY_BK;
825 int32_t ret = ModifyUdpChannelTos(tos);
826 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
827
828 TransUdpChannelMgrInit();
829 UdpChannelInfo *channel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
830 ASSERT_TRUE(channel != nullptr);
831 channel->info.myData.channelId = TEST_CHANNEL_ID;
832 channel->info.businessType = BUSINESS_TYPE_FILE;
833 channel->info.isClient = true;
834 channel->tos = FILE_PRIORITY_BE;
835
836 ret = TransAddUdpChannel(channel);
837 EXPECT_EQ(SOFTBUS_OK, ret);
838 ret = ModifyUdpChannelTos(tos);
839 EXPECT_NE(SOFTBUS_OK, ret);
840 TransDelUdpChannel(TEST_CHANNEL_ID);
841 TransUdpChannelMgrDeinit();
842 }
843
844 /**
845 * @tc.name: TransUdpManagerTest029
846 * @tc.desc: UdpChannelFileTransLimit test.
847 * @tc.type: FUNC
848 * @tc.require:
849 */
850 HWTEST_F(TransUdpManagerTest, TransUdpManagerTest029, TestSize.Level1)
851 {
852 int32_t ret = TransUdpGetChannelIdByAddr(nullptr);
853 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
854
855 AppInfo *appInfo = (AppInfo *)SoftBusCalloc(sizeof(AppInfo));
856 ASSERT_TRUE(appInfo != nullptr);
857 ret = TransUdpGetChannelIdByAddr(appInfo);
858 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
859
860 ret = TransUdpChannelMgrInit();
861 EXPECT_EQ(SOFTBUS_OK, ret);
862 ret = TransUdpGetChannelIdByAddr(appInfo);
863 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
864 appInfo->peerData.channelId = TEST_CHANNEL_ID;
865 UdpChannelInfo *channel = (UdpChannelInfo *)SoftBusCalloc(sizeof(UdpChannelInfo));
866 channel->info.peerData.channelId = TEST_CHANNEL_ID;
867 ret = TransAddUdpChannel(channel);
868 EXPECT_EQ(SOFTBUS_OK, ret);
869 ret = TransUdpGetChannelIdByAddr(appInfo);
870 EXPECT_EQ(SOFTBUS_OK, ret);
871 TransDelUdpChannel(TEST_CHANNEL_ID);
872 TransUdpChannelMgrDeinit();
873 SoftBusFree(appInfo);
874 appInfo = nullptr;
875 }
876
877 /**
878 * @tc.name: TransUdpGetIpAndConnectTypeById002
879 * @tc.desc: Get localIp and connectType with 'localIp' parameter
880 * @tc.type: FUNC
881 * @tc.require:
882 */
883 HWTEST_F(TransUdpManagerTest, TransUdpGetIpAndConnectTypeById002, TestSize.Level1)
884 {
885 int32_t channelId = INT32_MAX;
886 int32_t connectType = CONNECT_TYPE_MAX;
887
888 int32_t ret = TransUdpGetIpAndConnectTypeById(channelId, nullptr, nullptr, 0, &connectType);
889 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
890
891 ret = TransUdpGetIpAndConnectTypeById(channelId, nullptr, nullptr, IP_LEN, &connectType);
892 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
893
894 char localIp[IP_LEN] = { 0 };
895 char remoteIp[IP_LEN] = { 0 };
896 ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, 0, &connectType);
897 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
898
899 ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, IP_LEN - 1, &connectType);
900 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
901
902 ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, IP_LEN, &connectType);
903 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
904 }
905
906 /**
907 * @tc.name: TransUdpGetIpAndConnectTypeById003
908 * @tc.desc: Get localIp and connectType with 'connectType' parameter
909 * @tc.type: FUNC
910 * @tc.require:
911 */
912 HWTEST_F(TransUdpManagerTest, TransUdpGetIpAndConnectTypeById003, TestSize.Level1)
913 {
914 int32_t channelId = INT32_MAX - 1;
915 char localIp[IP_LEN] = { 0 };
916 char remoteIp[IP_LEN] = { 0 };
917 int32_t connectType = CONNECT_TYPE_MAX;
918
919 int32_t ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, IP_LEN, nullptr);
920 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
921
922 ret = TransUdpGetIpAndConnectTypeById(channelId, localIp, remoteIp, IP_LEN, &connectType);
923 EXPECT_EQ(ret, SOFTBUS_NO_INIT);
924 }
925 }