1 /*
2 * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "client_trans_session_callback.h"
19 #include "client_trans_session_manager.h"
20 #include "client_trans_socket_manager.h"
21 #include "client_trans_udp_manager.h"
22 #include "client_trans_udp_manager.c"
23 #include "securec.h"
24 #include "session.h"
25 #include "softbus_def.h"
26 #include "softbus_error_code.h"
27 #include "trans_udp_channel_manager.h"
28
29 using namespace std;
30 using namespace testing::ext;
31
32 const char *g_sessionName = "ohos.distributedschedule.dms.test";
33 const char *g_networkid = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00";
34 const char *g_groupid = "TEST_GROUP_ID";
35
36 namespace OHOS {
37 #define TEST_ERR_PID (-1)
38 #define TEST_LEN 10
39 #define TEST_DATA_TYPE 2
40 #define TEST_PID 2
41 #define TEST_STATE 1
42 #define TEST_ERR_CODE 1
43 #define TEST_CHANNELID 5
44 #define TEST_SESSIONID 100
45 #define TEST_CHANNELTYPE 2
46 #define TEST_REMOTE_TYPE 0
47 #define TEST_EVENT_ID 2
48 #define TEST_COUNT 2
49 #define TEST_ERR_COUNT (-2)
50 #define TEST_ERRCODE 0
51 #define TEST_FILE_NAME "test.filename.01"
52 #define STREAM_DATA_LENGTH 10
53 #define TEST_ERR_CHANNELID (-1)
54 #define TEST_ERR_SESSIONID (-1)
55 #define FILE_PRIORITY_TEST 0x06
56
57 class ClientTransUdpManagerTest : public testing::Test {
58 public:
ClientTransUdpManagerTest()59 ClientTransUdpManagerTest() {}
~ClientTransUdpManagerTest()60 ~ClientTransUdpManagerTest() {}
61 static void SetUpTestCase(void);
62 static void TearDownTestCase(void);
SetUp()63 void SetUp() override {}
TearDown()64 void TearDown() override {}
65 };
66
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag)67 static int32_t OnSessionOpened(const char *sessionName, const ChannelInfo *channel, SessionType flag)
68 {
69 return SOFTBUS_OK;
70 }
71
OnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)72 static int32_t OnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
73 {
74 return SOFTBUS_OK;
75 }
76
OnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)77 static int32_t OnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
78 {
79 return SOFTBUS_OK;
80 }
81
OnDataReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)82 static int32_t OnDataReceived(int32_t channelId, int32_t channelType, const void *data,
83 uint32_t len, SessionPktType type)
84 {
85 return SOFTBUS_OK;
86 }
87 static IClientSessionCallBack g_sessionCb = {
88 .OnSessionOpened = OnSessionOpened,
89 .OnSessionClosed = OnSessionClosed,
90 .OnSessionOpenFailed = OnSessionOpenFailed,
91 .OnDataReceived = OnDataReceived,
92 };
93
SetUpTestCase(void)94 void ClientTransUdpManagerTest::SetUpTestCase(void)
95 {
96 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
97 EXPECT_EQ(SOFTBUS_OK, ret);
98 ret = TransClientInit();
99 EXPECT_EQ(ret, SOFTBUS_OK);
100 }
101
TearDownTestCase(void)102 void ClientTransUdpManagerTest::TearDownTestCase(void) {}
103
InitChannelInfo()104 static ChannelInfo InitChannelInfo()
105 {
106 ChannelInfo channel;
107 char strTmp[] = "ABCDEFG";
108 char strSessionName[] = "ohos.distributedschedule.dms.test";
109 channel.channelId = TEST_CHANNELID;
110 channel.businessType = BUSINESS_TYPE_STREAM;
111 channel.channelType = TEST_CHANNELTYPE;
112 channel.fd = TEST_DATA_TYPE;
113 channel.isServer = true;
114 channel.isEnabled = true;
115 channel.peerUid = TEST_CHANNELID;
116 channel.peerPid = TEST_CHANNELID;
117 channel.groupId = strTmp;
118 channel.sessionKey = strTmp;
119 channel.keyLen = sizeof(channel.sessionKey);
120 channel.peerSessionName = strSessionName;
121 channel.peerDeviceId = strTmp;
122 channel.myIp = strTmp;
123 channel.streamType = TEST_COUNT;
124 channel.isUdpFile = true;
125 channel.peerPort = TEST_COUNT;
126 channel.peerIp = strTmp;
127 channel.routeType = TEST_DATA_TYPE;
128 return channel;
129 }
130
131 /**
132 * @tc.name: TransOnUdpChannelOpenedTest001
133 * @tc.desc: trans on udp channel opened test, use the wrong parameter.
134 * @tc.type: FUNC
135 * @tc.require:
136 */
137 HWTEST_F(ClientTransUdpManagerTest, TransOnUdpChannelOpenedTest001, TestSize.Level0)
138 {
139 int32_t ret;
140 ChannelInfo channel = InitChannelInfo();
141 int32_t udpPort;
142
143 ret = TransOnUdpChannelOpened(nullptr, &channel, &udpPort);
144 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
145
146 ret = TransOnUdpChannelOpened(g_sessionName, nullptr, &udpPort);
147 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
148
149 ret = TransOnUdpChannelOpened(g_sessionName, &channel, nullptr);
150 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
151 }
152
153 /**
154 * @tc.name: TransOnUdpChannelOpenedTest002
155 * @tc.desc: trans on udp channel opened test, use the wrong or normal parameter.
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(ClientTransUdpManagerTest, TransOnUdpChannelOpenedTest002, TestSize.Level0)
160 {
161 int32_t ret;
162 ChannelInfo channel = InitChannelInfo();
163 int32_t udpPort;
164 char strSessionName[] = "ohos.distributedschedule.dms.test";
165
166 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
167 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
168
169 ret = TransOnUdpChannelClosed(channel.channelId, SHUTDOWN_REASON_UNKNOWN);
170 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
171
172 channel.businessType = BUSINESS_TYPE_FILE;
173 ret = TransOnUdpChannelOpened(strSessionName, &channel, &udpPort);
174 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
175
176 channel.businessType = BUSINESS_TYPE_FILE;
177 channel.channelId = TEST_CHANNELID + 1;
178 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
179 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
180
181 channel.businessType = TEST_COUNT;
182 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
183 EXPECT_EQ(SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH, ret);
184 }
185
186 /**
187 * @tc.name: TransOnUdpChannelOpenedTest003
188 * @tc.desc: trans on udp channel opened test, use the wrong or normal parameter.
189 * @tc.type: FUNC
190 * @tc.require:
191 */
192 HWTEST_F(ClientTransUdpManagerTest, TransOnUdpChannelOpenedTest003, TestSize.Level0)
193 {
194 int32_t ret;
195 ChannelInfo channel = InitChannelInfo();
196 int32_t udpPort;
197 QosTv tvList;
198
199 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
200 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
201
202 ret = TransOnUdpChannelQosEvent(TEST_CHANNELID, TEST_EVENT_ID, TEST_COUNT, &tvList);
203 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
204
205 channel.businessType = BUSINESS_TYPE_BUTT;
206 ret = TransOnUdpChannelOpenFailed(TEST_CHANNELID, TEST_ERRCODE);
207 EXPECT_EQ(SOFTBUS_OK, ret);
208 }
209
210 /**
211 * @tc.name: TransOnUdpChannelOpenFailedTest001
212 * @tc.desc: trans on udp channel opened test, use the wrong or normal parameter.
213 * @tc.type: FUNC
214 * @tc.require:
215 */
216 HWTEST_F(ClientTransUdpManagerTest, TransOnUdpChannelOpenFailedTest001, TestSize.Level0)
217 {
218 int32_t ret;
219 ret = TransOnUdpChannelOpenFailed(TEST_CHANNELID, TEST_ERRCODE);
220 EXPECT_EQ(SOFTBUS_OK, ret);
221
222 ret = TransOnUdpChannelOpenFailed(0, TEST_ERRCODE);
223 EXPECT_EQ(SOFTBUS_OK, ret);
224 }
225
226 /**
227 * @tc.name: TransOnUdpChannelClosedTest001
228 * @tc.desc: trans on udp channel closed test, use the wrong or normal parameter.
229 * @tc.type: FUNC
230 * @tc.require:
231 */
232 HWTEST_F(ClientTransUdpManagerTest, TransOnUdpChannelClosedTest001, TestSize.Level0)
233 {
234 int32_t ret;
235 ret = TransOnUdpChannelClosed(TEST_CHANNELID, SHUTDOWN_REASON_UNKNOWN);
236 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
237 }
238
239 /**
240 * @tc.name: TransOnUdpChannelClosedTest002
241 * @tc.desc: trans on udp channel closed test, use the wrong or normal parameter.
242 * @tc.type: FUNC
243 * @tc.require:
244 */
245 HWTEST_F(ClientTransUdpManagerTest, TransOnUdpChannelClosedTest002, TestSize.Level0)
246 {
247 int32_t ret;
248 ChannelInfo channel = InitChannelInfo();
249 int32_t udpPort;
250 channel.businessType = BUSINESS_TYPE_FILE;
251
252 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
253 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
254
255 ret = ClientTransUdpMgrInit(&g_sessionCb);
256 EXPECT_EQ(SOFTBUS_OK, ret);
257
258 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
259 EXPECT_EQ(SOFTBUS_TRANS_NODE_NOT_FOUND, ret);
260
261 ret = TransOnUdpChannelClosed(channel.channelId, SHUTDOWN_REASON_UNKNOWN);
262 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
263
264 ret = TransOnUdpChannelClosed(channel.channelId, SHUTDOWN_REASON_PEER);
265 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
266
267 ret = TransOnUdpChannelClosed(channel.channelId, SHUTDOWN_REASON_SEND_FILE_ERR);
268 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
269
270 ret = TransOnUdpChannelClosed(TEST_CHANNELID + TEST_CHANNELID, SHUTDOWN_REASON_SEND_FILE_ERR);
271 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
272 }
273
274 /**
275 * @tc.name: TransOnUdpChannelQosEventTest001
276 * @tc.desc: trans on udp channel qos event test, use the wrong or normal parameter.
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(ClientTransUdpManagerTest, TransOnUdpChannelQosEventTest001, TestSize.Level0)
281 {
282 int32_t ret;
283 QosTv tvList;
284 ret = TransOnUdpChannelQosEvent(TEST_CHANNELID, TEST_EVENT_ID, TEST_COUNT, &tvList);
285 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
286 }
287
288 /**
289 * @tc.name: ClientTransCloseUdpChannelTest001
290 * @tc.desc: client trans close udp channel test, use the wrong or normal parameter.
291 * @tc.type: FUNC
292 * @tc.require:
293 */
294 HWTEST_F(ClientTransUdpManagerTest, ClientTransCloseUdpChannelTest001, TestSize.Level0)
295 {
296 int32_t ret;
297 ret = ClientTransCloseUdpChannel(TEST_CHANNELID, SHUTDOWN_REASON_UNKNOWN);
298 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
299 }
300
301 /**
302 * @tc.name: TransUdpChannelSendStreamTest001
303 * @tc.desc: trans udp channel send stream test, use the wrong or normal parameter.
304 * @tc.type: FUNC
305 * @tc.require:
306 */
307 HWTEST_F(ClientTransUdpManagerTest, TransUdpChannelSendStreamTest001, TestSize.Level0)
308 {
309 int32_t ret;
310 ChannelInfo channel = InitChannelInfo();
311 int32_t udpPort;
312
313 char sendStringData[STREAM_DATA_LENGTH] = "diudiudiu";
314 StreamData tmpData = {
315 sendStringData,
316 STREAM_DATA_LENGTH,
317 };
318 char str[STREAM_DATA_LENGTH] = "oohoohooh";
319 StreamData tmpData2 = {
320 str,
321 STREAM_DATA_LENGTH,
322 };
323
324 StreamFrameInfo tmpf = {};
325 ret = TransUdpChannelSendStream(TEST_CHANNELID, &tmpData, &tmpData2, &tmpf);
326 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
327
328 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
329 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
330
331 ret = TransUdpChannelSendStream(TEST_CHANNELID, &tmpData, &tmpData2, &tmpf);
332 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
333
334 ret = TransUdpChannelSetStreamMultiLayer(TEST_CHANNELID, nullptr);
335 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
336 }
337
338 /**
339 * @tc.name: TransUdpChannelSendFileTest001
340 * @tc.desc: trans udp channel send file test, use the wrong or normal parameter.
341 * @tc.type: FUNC
342 * @tc.require:
343 */
344 HWTEST_F(ClientTransUdpManagerTest, TransUdpChannelSendFileTest001, TestSize.Level0)
345 {
346 int32_t ret;
347 const char *sFileList[] = {
348 "/data/big.tar",
349 "/data/richu.jpg",
350 "/data/richu-002.jpg",
351 "/data/richu-003.jpg",
352 };
353 ret = TransUdpChannelSendFile(TEST_CHANNELID, nullptr, nullptr, 1);
354 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
355
356 ret = TransUdpChannelSendFile(TEST_CHANNELID, sFileList, nullptr, 0);
357 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
358
359 ret = TransUdpChannelSendFile(TEST_CHANNELID, sFileList, nullptr, 1);
360 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
361 }
362
363 /**
364 * @tc.name: TransGetUdpChannelByFileIdTest001
365 * @tc.desc: trans get udp channel by fileid test, use the wrong or normal parameter.
366 * @tc.type: FUNC
367 * @tc.require:
368 */
369 HWTEST_F(ClientTransUdpManagerTest, TransGetUdpChannelByFileIdTest001, TestSize.Level0)
370 {
371 int32_t ret;
372 UdpChannel udpChannel;
373 (void)memset_s(&udpChannel, sizeof(UdpChannel), 0, sizeof(UdpChannel));
374 ret = TransGetUdpChannelByFileId(TEST_DATA_TYPE, &udpChannel);
375 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
376
377 ClientTransUdpMgrDeinit();
378 ret = TransGetUdpChannelByFileId(TEST_DATA_TYPE, &udpChannel);
379 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
380 }
381
382 /**
383 * @tc.name: ClientTransAddUdpChannelTest001
384 * @tc.desc: client trans add udp channel test, use the wrong or normal parameter.
385 * @tc.type: FUNC
386 * @tc.require:
387 */
388 HWTEST_F(ClientTransUdpManagerTest, ClientTransAddUdpChannelTest001, TestSize.Level0)
389 {
390 int32_t ret;
391 ChannelInfo channel = InitChannelInfo();
392 int32_t udpPort;
393
394 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
395 EXPECT_EQ(SOFTBUS_TRANS_UDP_CLIENT_ADD_CHANNEL_FAILED, ret);
396
397 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
398 EXPECT_EQ(SOFTBUS_TRANS_UDP_CLIENT_ADD_CHANNEL_FAILED, ret);
399
400 ClientTransUdpMgrDeinit();
401 ret = TransOnUdpChannelOpened(g_sessionName, &channel, &udpPort);
402 EXPECT_EQ(SOFTBUS_TRANS_UDP_CLIENT_ADD_CHANNEL_FAILED, ret);
403 }
404
405 /**
406 * @tc.name: ClientTransUdpManagerTest001
407 * @tc.desc: client trans udp manager test, use the normal parameter.
408 * @tc.type: FUNC
409 * @tc.require:
410 */
411 HWTEST_F(ClientTransUdpManagerTest, ClientTransUdpManagerTest001, TestSize.Level0)
412 {
413 int32_t ret;
414
415 IClientSessionCallBack *cb = GetClientSessionCb();
416 ret = ClientTransUdpMgrInit(cb);
417 EXPECT_EQ(SOFTBUS_OK, ret);
418 }
419
420 /**
421 * @tc.name: ClientEmitFileEventTest001
422 * @tc.desc: client emit file event test, use the invalid parameter.
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(ClientTransUdpManagerTest, ClientEmitFileEventTest001, TestSize.Level0)
427 {
428 int32_t channelId = TEST_ERR_CHANNELID;
429 int32_t ret = ClientEmitFileEvent(channelId);
430 EXPECT_NE(SOFTBUS_OK, ret);
431 }
432
433 /**
434 * @tc.name: ClientEmitFileEventTest002
435 * @tc.desc: client emit file event test, use the invalid parameter.
436 * @tc.type: FUNC
437 * @tc.require:
438 */
439 HWTEST_F(ClientTransUdpManagerTest, ClientEmitFileEventTest002, TestSize.Level0)
440 {
441 int32_t channelId = TEST_CHANNELID;
442 int32_t ret = ClientEmitFileEvent(channelId);
443 EXPECT_NE(SOFTBUS_OK, ret);
444
445 ret = TransSetUdpChanelSessionId(TEST_CHANNELID, TEST_SESSIONID);
446 EXPECT_NE(SOFTBUS_NO_INIT, ret);
447
448 ret = TransSetUdpChannelRenameHook(TEST_CHANNELID, nullptr);
449 EXPECT_NE(SOFTBUS_OK, ret);
450 }
451
452 /**
453 * @tc.name: TransLimitChangeTest
454 * @tc.desc: trans limit change test, use the invalid parameter.
455 * @tc.type: FUNC
456 * @tc.require:
457 */
458 HWTEST_F(ClientTransUdpManagerTest, TransLimitChangeTest, TestSize.Level0)
459 {
460 int32_t channelId = TEST_ERR_CHANNELID;
461 int32_t ret = TransLimitChange(channelId, FILE_PRIORITY_BK);
462 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
463
464 channelId = TEST_CHANNELID;
465 ret = TransLimitChange(channelId, FILE_PRIORITY_BE);
466 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
467
468 ret = TransLimitChange(channelId, FILE_PRIORITY_TEST);
469 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
470 }
471
472 /**
473 * @tc.name: TransSetUdpChannelTosTest
474 * @tc.desc: trans set udp channel tos test.
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(ClientTransUdpManagerTest, TransSetUdpChannelTosTest, TestSize.Level0)
479 {
480 int32_t channelId = TEST_ERR_CHANNELID;
481 int32_t ret = TransSetUdpChannelTos(channelId);
482 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
483 }
484
485 /**
486 * @tc.name: TransGetUdpChannelTosTest001
487 * @tc.desc: trans get udp channel tos test.
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(ClientTransUdpManagerTest, TransGetUdpChannelTosTest001, TestSize.Level0)
492 {
493 int32_t channelId = TEST_ERR_CHANNELID;
494 bool isTosSet = false;
495 int32_t ret = TransGetUdpChannelTos(channelId, &isTosSet);
496 EXPECT_EQ(ret, SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND);
497 EXPECT_FALSE(isTosSet);
498 ret = TransGetUdpChannelTos(TEST_CHANNELID, nullptr);
499 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
500 }
501
502 /**
503 * @tc.name: TransUdpChannelSendStreamTest002
504 * @tc.desc: trans udp channel sendstream test, use the wrong or normal parameter.
505 * @tc.type: FUNC
506 * @tc.require:
507 */
508 HWTEST_F(ClientTransUdpManagerTest, TransUdpChannelSendStreamTest002, TestSize.Level0)
509 {
510 int32_t channelId = TEST_CHANNELID;
511
512 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
513 EXPECT_EQ(SOFTBUS_OK, ret);
514
515 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
516 ASSERT_NE(newChannel, nullptr);
517 newChannel->channelId = channelId;
518 newChannel->isEnable = false;
519 ret = ClientTransAddUdpChannel(newChannel);
520 EXPECT_EQ(SOFTBUS_OK, ret);
521 StreamFrameInfo tmpf = {};
522 char sendStringData[STREAM_DATA_LENGTH] = "diudiudiu";
523 StreamData tmpData1 = {
524 sendStringData,
525 STREAM_DATA_LENGTH,
526 };
527 char str[STREAM_DATA_LENGTH] = "ooooooood";
528 StreamData tmpData2 = {
529 str,
530 STREAM_DATA_LENGTH,
531 };
532 ret = TransUdpChannelSendStream(channelId, &tmpData1, &tmpData2, &tmpf);
533 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_DISABLE, ret);
534
535 newChannel->isEnable = true;
536 ret = TransUdpChannelSendStream(channelId, nullptr, nullptr, &tmpf);
537 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
538
539 ret = TransDeleteUdpChannel(channelId);
540 EXPECT_EQ(SOFTBUS_OK, ret);
541 ClientTransUdpMgrDeinit();
542 }
543
544 /**
545 * @tc.name: TransUdpChannelSendFileTest002
546 * @tc.desc: trans udp channel sendfile test, use the wrong or normal parameter.
547 * @tc.type: FUNC
548 * @tc.require:
549 */
550 HWTEST_F(ClientTransUdpManagerTest, TransUdpChannelSendFileTest002, TestSize.Level0)
551 {
552 int32_t channelId = TEST_CHANNELID;
553 const char *sFileList[] = {
554 "/data/big.tar",
555 "/data/richu.jpg",
556 "/data/richu-002.jpg",
557 "/data/richu-003.jpg",
558 };
559 const char *dFileList[] = {
560 "/data/big.tar",
561 "/data/richu.jpg",
562 "/data/richu-002.jpg",
563 "/data/richu-003.jpg",
564 };
565 uint32_t fileCnt = 0;
566
567 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
568 EXPECT_EQ(SOFTBUS_OK, ret);
569
570 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
571 ASSERT_NE(newChannel, nullptr);
572 newChannel->channelId = channelId;
573 newChannel->isEnable = false;
574 newChannel->dfileId = TEST_ERR_SESSIONID;
575 ret = ClientTransAddUdpChannel(newChannel);
576 EXPECT_EQ(SOFTBUS_OK, ret);
577
578 ret = TransUdpChannelSendFile(channelId, sFileList, dFileList, fileCnt);
579 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_DISABLE, ret);
580 ret = TransDeleteUdpChannel(channelId);
581 EXPECT_EQ(SOFTBUS_OK, ret);
582
583 newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
584 ASSERT_NE(newChannel, nullptr);
585 newChannel->channelId = channelId;
586 newChannel->isEnable = true;
587 newChannel->dfileId = TEST_SESSIONID;
588 ret = ClientTransAddUdpChannel(newChannel);
589 EXPECT_EQ(SOFTBUS_OK, ret);
590
591 ret = TransUdpChannelSendFile(channelId, sFileList, dFileList, fileCnt);
592 EXPECT_NE(SOFTBUS_OK, ret);
593
594 ret = TransDeleteUdpChannel(channelId);
595 EXPECT_EQ(SOFTBUS_OK, ret);
596 ClientTransUdpMgrDeinit();
597 }
598
599 /**
600 * @tc.name: TransLimitChangeTest002
601 * @tc.desc: trans limit change test, use the wrong or normal parameter.
602 * @tc.type: FUNC
603 * @tc.require:
604 */
605 HWTEST_F(ClientTransUdpManagerTest, TransLimitChangeTest002, TestSize.Level0)
606 {
607 int32_t channelId = TEST_CHANNELID;
608
609 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
610 EXPECT_EQ(SOFTBUS_OK, ret);
611
612 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
613 ASSERT_NE(newChannel, nullptr);
614 newChannel->channelId = channelId;
615 newChannel->businessType = BUSINESS_TYPE_FILE;
616 newChannel->info.isServer = true;
617 ret = ClientTransAddUdpChannel(newChannel);
618 EXPECT_EQ(SOFTBUS_OK, ret);
619
620 ret = TransLimitChange(channelId, FILE_PRIORITY_BK);
621 EXPECT_EQ(SOFTBUS_NOT_NEED_UPDATE, ret);
622 ret = TransDeleteUdpChannel(channelId);
623 EXPECT_EQ(SOFTBUS_OK, ret);
624
625 newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
626 ASSERT_NE(newChannel, nullptr);
627 newChannel->channelId = channelId;
628 newChannel->businessType = BUSINESS_TYPE_BYTE;
629 newChannel->info.isServer = false;
630 ret = ClientTransAddUdpChannel(newChannel);
631 EXPECT_EQ(SOFTBUS_OK, ret);
632
633 ret = TransLimitChange(channelId, FILE_PRIORITY_BK);
634 EXPECT_EQ(SOFTBUS_NOT_NEED_UPDATE, ret);
635
636 ret = TransDeleteUdpChannel(channelId);
637 EXPECT_EQ(SOFTBUS_OK, ret);
638 ClientTransUdpMgrDeinit();
639 }
640
641 /**
642 * @tc.name: TransLimitChangeTest003
643 * @tc.desc: trans limit change test, use the wrong or normal parameter.
644 * @tc.type: FUNC
645 * @tc.require:
646 */
647 HWTEST_F(ClientTransUdpManagerTest, TransLimitChangeTest003, TestSize.Level0)
648 {
649 int32_t channelId = TEST_CHANNELID;
650
651 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
652 EXPECT_EQ(SOFTBUS_OK, ret);
653
654 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
655 ASSERT_NE(newChannel, nullptr);
656 newChannel->channelId = channelId;
657 newChannel->businessType = BUSINESS_TYPE_FILE;
658 newChannel->info.isServer = false;
659 newChannel->isTosSet = false;
660 newChannel->dfileId = TEST_ERR_SESSIONID;
661 ret = ClientTransAddUdpChannel(newChannel);
662 EXPECT_EQ(SOFTBUS_OK, ret);
663
664 ret = TransLimitChange(channelId, FILE_PRIORITY_BK);
665 EXPECT_EQ(SOFTBUS_OK, ret);
666 ret = TransDeleteUdpChannel(channelId);
667 EXPECT_EQ(SOFTBUS_OK, ret);
668
669 newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
670 ASSERT_NE(newChannel, nullptr);
671 newChannel->channelId = channelId;
672 newChannel->businessType = BUSINESS_TYPE_FILE;
673 newChannel->info.isServer = false;
674 newChannel->isTosSet = true;
675 newChannel->dfileId = TEST_ERR_SESSIONID;
676 ret = ClientTransAddUdpChannel(newChannel);
677 EXPECT_EQ(SOFTBUS_OK, ret);
678
679 ret = TransLimitChange(channelId, FILE_PRIORITY_BK);
680 EXPECT_EQ(SOFTBUS_NOT_NEED_UPDATE, ret);
681
682 ret = TransDeleteUdpChannel(channelId);
683 EXPECT_EQ(SOFTBUS_OK, ret);
684 ClientTransUdpMgrDeinit();
685 }
686
687 /**
688 * @tc.name: ClientEmitFileEventTest003
689 * @tc.desc: client emit file event test, use the wrong or normal parameter.
690 * @tc.type: FUNC
691 * @tc.require:
692 */
693 HWTEST_F(ClientTransUdpManagerTest, ClientEmitFileEventTest003, TestSize.Level0)
694 {
695 int32_t channelId = TEST_CHANNELID;
696
697 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
698 EXPECT_EQ(SOFTBUS_OK, ret);
699
700 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
701 ASSERT_NE(newChannel, nullptr);
702 newChannel->channelId = channelId;
703 newChannel->businessType = BUSINESS_TYPE_FILE;
704 newChannel->dfileId = TEST_ERR_SESSIONID;
705 ret = ClientTransAddUdpChannel(newChannel);
706 EXPECT_EQ(SOFTBUS_OK, ret);
707
708 ret = ClientEmitFileEvent(channelId);
709 EXPECT_NE(SOFTBUS_NO_INIT, ret);
710
711 ret = TransDeleteUdpChannel(channelId);
712 EXPECT_EQ(SOFTBUS_OK, ret);
713 ClientTransUdpMgrDeinit();
714 }
715
716 /**
717 * @tc.name: TransSetUdpChanelSessionIdTest001
718 * @tc.desc: trans set udpchannel sessionid test, use the wrong or normal parameter.
719 * @tc.type: FUNC
720 * @tc.require:
721 */
722 HWTEST_F(ClientTransUdpManagerTest, TransSetUdpChanelSessionIdTest001, TestSize.Level0)
723 {
724 int32_t channelId = TEST_CHANNELID;
725 int32_t sessionId = TEST_SESSIONID;
726 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
727 EXPECT_EQ(SOFTBUS_OK, ret);
728 ClientTransUdpMgrDeinit();
729
730 ret = TransSetUdpChanelSessionId(channelId, sessionId);
731 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
732
733 ret = ClientTransUdpMgrInit(&g_sessionCb);
734 EXPECT_EQ(SOFTBUS_OK, ret);
735 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
736 ASSERT_NE(newChannel, nullptr);
737 newChannel->channelId = channelId;
738 ret = ClientTransAddUdpChannel(newChannel);
739 EXPECT_EQ(SOFTBUS_OK, ret);
740
741 ret = TransSetUdpChanelSessionId(channelId, sessionId);
742 EXPECT_EQ(SOFTBUS_OK, ret);
743
744 ret = TransDeleteUdpChannel(channelId);
745 EXPECT_EQ(SOFTBUS_OK, ret);
746 ClientTransUdpMgrDeinit();
747 }
748
OnRenameFileCb(RenameParam * renameParam)749 static void OnRenameFileCb(RenameParam *renameParam)
750 {
751 return;
752 }
753
754 /**
755 * @tc.name: TransSetUdpChannelRenameHookTest001
756 * @tc.desc: trans set udpchannel rename hook test, use the wrong or normal parameter.
757 * @tc.type: FUNC
758 * @tc.require:
759 */
760 HWTEST_F(ClientTransUdpManagerTest, TransSetUdpChannelRenameHookTest001, TestSize.Level0)
761 {
762 int32_t channelId = TEST_CHANNELID;
763 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
764 EXPECT_EQ(SOFTBUS_OK, ret);
765 ClientTransUdpMgrDeinit();
766 OnRenameFileCallback onRenameFile = OnRenameFileCb;
767
768 ret = TransSetUdpChannelRenameHook(channelId, onRenameFile);
769 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
770
771 ret = ClientTransUdpMgrInit(&g_sessionCb);
772 EXPECT_EQ(SOFTBUS_OK, ret);
773 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
774 ASSERT_NE(newChannel, nullptr);
775 newChannel->channelId = channelId;
776 newChannel->businessType = BUSINESS_TYPE_FILE;
777 ret = TransSetUdpChannelRenameHook(channelId, onRenameFile);
778 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
779
780 ret = ClientTransAddUdpChannel(newChannel);
781 EXPECT_EQ(SOFTBUS_OK, ret);
782
783 ret = TransSetUdpChannelRenameHook(channelId, onRenameFile);
784 EXPECT_EQ(SOFTBUS_OK, ret);
785
786 ret = TransDeleteUdpChannel(channelId);
787 EXPECT_EQ(SOFTBUS_OK, ret);
788 ClientTransUdpMgrDeinit();
789 }
790
791 /**
792 * @tc.name: TransSetUdpChannelTosTest001
793 * @tc.desc: trans set udpchannel tos test, use the wrong or normal parameter.
794 * @tc.type: FUNC
795 * @tc.require:
796 */
797 HWTEST_F(ClientTransUdpManagerTest, TransSetUdpChannelTosTest001, TestSize.Level0)
798 {
799 int32_t channelId = TEST_CHANNELID;
800 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
801 EXPECT_EQ(SOFTBUS_OK, ret);
802 ClientTransUdpMgrDeinit();
803
804 ret = TransSetUdpChannelTos(channelId);
805 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
806
807 ret = ClientTransUdpMgrInit(&g_sessionCb);
808 EXPECT_EQ(SOFTBUS_OK, ret);
809 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
810 ASSERT_NE(newChannel, nullptr);
811 newChannel->channelId = channelId;
812
813 ret = ClientTransAddUdpChannel(newChannel);
814 EXPECT_EQ(SOFTBUS_OK, ret);
815
816 ret = TransSetUdpChannelTos(channelId);
817 EXPECT_EQ(SOFTBUS_OK, ret);
818
819 ret = TransDeleteUdpChannel(channelId);
820 EXPECT_EQ(SOFTBUS_OK, ret);
821 ClientTransUdpMgrDeinit();
822 }
823
824 /**
825 * @tc.name: TransGetUdpChannelTosTest002
826 * @tc.desc: trans get udpchannel tos test, use the wrong or normal parameter.
827 * @tc.type: FUNC
828 * @tc.require:
829 */
830 HWTEST_F(ClientTransUdpManagerTest, TransGetUdpChannelTosTest002, TestSize.Level0)
831 {
832 int32_t channelId = TEST_CHANNELID;
833 bool isTosSet = false;
834 int32_t ret = ClientTransUdpMgrInit(&g_sessionCb);
835 EXPECT_EQ(SOFTBUS_OK, ret);
836 ClientTransUdpMgrDeinit();
837
838 ret = TransGetUdpChannelTos(channelId, &isTosSet);
839 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
840
841 ret = ClientTransUdpMgrInit(&g_sessionCb);
842 EXPECT_EQ(SOFTBUS_OK, ret);
843 UdpChannel *newChannel = reinterpret_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
844 ASSERT_NE(newChannel, nullptr);
845 newChannel->channelId = channelId;
846
847 ret = ClientTransAddUdpChannel(newChannel);
848 EXPECT_EQ(SOFTBUS_OK, ret);
849
850 ret = TransGetUdpChannelTos(channelId, &isTosSet);
851 EXPECT_EQ(SOFTBUS_OK, ret);
852
853 ret = TransDeleteUdpChannel(channelId);
854 EXPECT_EQ(SOFTBUS_OK, ret);
855 ClientTransUdpMgrDeinit();
856 }
857 } // namespace OHOS
858
