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 <cstring>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19
20 #include "client_trans_file.c"
21 #include "client_trans_file_listener.c"
22 #include "client_trans_session_callback.h"
23 #include "client_trans_stream.h"
24 #include "client_trans_udp_manager.h"
25 #include "client_trans_udp_manager.c"
26 #include "file_adapter.c"
27 #include "session.h"
28 #include "softbus_adapter_mem.h"
29
30 using namespace testing::ext;
31
32 namespace OHOS {
33
34 const uint32_t g_keyLen = 10;
35 char g_mySessionName[] = {"my sessionName"};
36 char g_peerSessionName[] = {"peer sessionName"};
37 char g_peerDeviceId[] = {"127.0.0.4"};
38 char g_groupId[] = {"12345"};
39 char g_peerIp[] = {"11111"};
40 char g_sessionKey[] = {"123548246"};
41 char g_myIp[] = {"coms.132465"};
42
TransGenerateChannelTest()43 UdpChannel *TransGenerateChannelTest()
44 {
45 UdpChannel *channel = (UdpChannel *)SoftBusCalloc(sizeof(UdpChannel));
46 if (channel == NULL) {
47 return nullptr;
48 }
49 channel->channelId = 1;
50 channel->dfileId = -1;
51 channel->channelId = 1;
52 channel->businessType = 1;
53 channel->isEnable = true;
54 channel->routeType = 1;
55 channel->info.isServer = 0;
56 channel->info.peerUid = 0;
57 channel->info.peerPid = 0;
58 (void)strcpy_s(channel->info.mySessionName, strlen("my sessionName")+1, "my sessionName");
59 (void)strcpy_s(channel->info.peerSessionName, strlen("peer sessionName")+1, "peer sessionName");
60 (void)strcpy_s(channel->info.peerDeviceId, strlen("127.0.0.4")+1, "127.0.0.4");
61 (void)strcpy_s(channel->info.groupId, strlen("12345")+1, "12345");
62 return channel;
63 }
TransGenerateChannleInfoTest()64 ChannelInfo *TransGenerateChannleInfoTest()
65 {
66 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
67 if (channelInfo == NULL) {
68 return nullptr;
69 }
70 channelInfo->channelId = 1;
71 channelInfo->channelType = 1;
72 channelInfo->businessType = 1;
73 channelInfo->fd = 1;
74 channelInfo->isServer = true;
75 channelInfo->isEnabled = true;
76 channelInfo->peerUid = 1;
77 channelInfo->peerPid = 1;
78 channelInfo->groupId = g_groupId;
79 channelInfo->keyLen = g_keyLen;
80 channelInfo->sessionKey = g_sessionKey;
81 channelInfo->peerSessionName = g_peerSessionName;
82 channelInfo->peerDeviceId = g_peerDeviceId;
83 channelInfo->myIp = g_myIp;
84 channelInfo->peerIp = g_peerIp;
85
86 channelInfo->peerPort = 1;
87 channelInfo->routeType = 1;
88 channelInfo->streamType = 1;
89 channelInfo->encrypt = 1;
90 channelInfo->algorithm = 1;
91 channelInfo->crc = 1;
92 channelInfo->isUdpFile = false;
93 return channelInfo;
94 }
95
96 class TransSdkFileTest : public testing::Test {
97 public:
TransSdkFileTest()98 TransSdkFileTest()
99 {}
~TransSdkFileTest()100 ~TransSdkFileTest()
101 {}
102 static void SetUpTestCase(void);
103 static void TearDownTestCase(void);
SetUp()104 void SetUp() override
105 {}
TearDown()106 void TearDown() override
107 {}
108 };
109
SetUpTestCase(void)110 void TransSdkFileTest::SetUpTestCase(void)
111 {
112 IClientSessionCallBack *cb = GetClientSessionCb();
113 int32_t ret = ClientTransUdpMgrInit(cb);
114 EXPECT_TRUE(ret == SOFTBUS_OK);
115 ret = TransFileInit();
116 EXPECT_TRUE(ret == SOFTBUS_OK);
117 }
118
TearDownTestCase(void)119 void TransSdkFileTest::TearDownTestCase(void)
120 {
121 ClientTransUdpMgrDeinit();
122 TransFileDeinit();
123 }
124
OnFileTransErrorTest(int sessionId)125 void OnFileTransErrorTest(int sessionId)
126 {
127 std::cout << "OnFileTransError sessionId = %d\n" << sessionId << std::endl;
128 }
129
OnReceiveFileStartedTest(int sessionId,const char * files,int fileCnt)130 int OnReceiveFileStartedTest(int sessionId, const char *files, int fileCnt)
131 {
132 std::cout << "File receive start sessionId = %d" << sessionId << std::endl;
133 return 0;
134 }
135
OnReceiveFileFinishedTest(int sessionId,const char * files,int fileCnt)136 void OnReceiveFileFinishedTest(int sessionId, const char *files, int fileCnt)
137 {
138 std::cout << "File receive finished sessionId = %d\n" << sessionId << std::endl;
139 }
140
OnReceiveFileProcessTest(int sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)141 int OnReceiveFileProcessTest(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
142 {
143 std::cout << "File receive process sessionId = %d\n" << sessionId << std::endl;
144 return 0;
145 }
146
OnSendFileProcessTest(int sessionId,uint64_t bytesUpload,uint64_t bytesTotal)147 int OnSendFileProcessTest(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
148 {
149 std::cout << "send process id = " << sessionId << " upload = "
150 << bytesUpload << ", total = " << bytesTotal << std::endl;
151 return 0;
152 }
153
OnSendFileFinishedTest(int sessionId,const char * firstFile)154 int OnSendFileFinishedTest(int sessionId, const char *firstFile)
155 {
156 std::cout << "send finished id = %d," << sessionId << "first file = %s." << firstFile << std::endl;
157 return 0;
158 }
159
DFileMsgReceiverTest(int32_t sessionId,DFileMsgType msgType,const DFileMsg * msg)160 void DFileMsgReceiverTest(int32_t sessionId, DFileMsgType msgType, const DFileMsg *msg)
161 {
162 std::cout << "file receiver id = %d" << sessionId << std::endl;
163 return;
164 }
165
166
167 static IFileSendListener g_fileSendListener = {
168 .OnSendFileProcess = OnSendFileProcessTest,
169 .OnSendFileFinished = OnSendFileFinishedTest,
170 .OnFileTransError = OnFileTransErrorTest,
171 };
172
173 static IFileReceiveListener g_fileRecvListener = {
174 .OnReceiveFileStarted = OnReceiveFileStartedTest,
175 .OnReceiveFileProcess = OnReceiveFileProcessTest,
176 .OnReceiveFileFinished = OnReceiveFileFinishedTest,
177 .OnFileTransError = OnFileTransErrorTest,
178 };
179
180 /**
181 * @tc.name: TransFileListenerTest001
182 * @tc.desc: trans file listener init.
183 * @tc.type: FUNC
184 * @tc.require:
185 */
186 HWTEST_F(TransSdkFileTest, TransFileListenerTest001, TestSize.Level0)
187 {
188 TransFileDeinit();
189 int32_t ret = TransFileInit();
190 EXPECT_TRUE(ret == SOFTBUS_OK);
191 ret = TransFileInit();
192 EXPECT_TRUE(ret == SOFTBUS_OK);
193 TransFileDeinit();
194 TransFileDeinit();
195 }
196
197 /**
198 * @tc.name: TransFileListenerTest002
199 * @tc.desc: trans set file receive listener by sessionName.
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 HWTEST_F(TransSdkFileTest, TransFileListenerTest002, TestSize.Level0)
204 {
205 int32_t ret = TransFileInit();
206 ASSERT_TRUE(ret == SOFTBUS_OK);
207 const char* rootDir = "rootDir";
208 const char* sessionName = "file receive";
209 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
210 EXPECT_TRUE(ret == SOFTBUS_OK);
211
212 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
213 EXPECT_TRUE(ret == SOFTBUS_OK);
214
215 TransDeleteFileListener(sessionName);
216 TransFileDeinit();
217
218 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
219 EXPECT_TRUE(ret == SOFTBUS_TRANS_FILE_LISTENER_NOT_INIT);
220
221 TransFileDeinit();
222 }
223
224 /**
225 * @tc.name: TransFileListenerTest003
226 * @tc.desc: trans delete file listener by sessionName.
227 * @tc.type: FUNC
228 * @tc.require:
229 */
230 HWTEST_F(TransSdkFileTest, TransFileListenerTest003, TestSize.Level0)
231 {
232 int32_t ret = TransFileInit();
233 ASSERT_TRUE(ret == SOFTBUS_OK);
234 const char* rootDir = "rootDir";
235 const char* sessionName = "file receive";
236 const char* inValidName = "invald file receive";
237 TransDeleteFileListener(NULL);
238
239 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
240 ASSERT_TRUE(ret == SOFTBUS_OK);
241 TransDeleteFileListener(inValidName);
242
243 TransDeleteFileListener(sessionName);
244 TransFileDeinit();
245
246 TransDeleteFileListener(sessionName);
247 TransFileDeinit();
248 }
249
250 /**
251 * @tc.name: TransFileListenerTest004
252 * @tc.desc: trans set file send listener by sessionName.
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(TransSdkFileTest, TransFileListenerTest004, TestSize.Level0)
257 {
258 int32_t ret = TransFileInit();
259 ASSERT_TRUE(ret == SOFTBUS_OK);
260 const char* sessionName = "file send";
261 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
262 EXPECT_TRUE(ret == SOFTBUS_OK);
263
264 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
265 ASSERT_TRUE(ret == SOFTBUS_OK);
266
267 TransDeleteFileListener(sessionName);
268 TransFileDeinit();
269
270 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
271 EXPECT_TRUE(ret != SOFTBUS_OK);
272 }
273
274 /**
275 * @tc.name: TransFileListenerTest005
276 * @tc.desc: trans get file listener by sessionName.
277 * @tc.type: FUNC
278 * @tc.require:
279 */
280 HWTEST_F(TransSdkFileTest, TransFileListenerTest005, TestSize.Level0)
281 {
282 int32_t ret = TransFileInit();
283 ASSERT_TRUE(ret == SOFTBUS_OK);
284 const char* rootDir = "rootDir";
285 const char* sessionName = "file receive";
286 const char* inValidName = "invald file receive";
287 FileListener* fileListener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
288 ASSERT_TRUE(fileListener != nullptr);
289 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
290 ASSERT_TRUE(ret == SOFTBUS_OK);
291
292 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
293 ASSERT_TRUE(ret == SOFTBUS_OK);
294
295 ret = TransGetFileListener(inValidName, fileListener);
296 EXPECT_TRUE(ret != SOFTBUS_OK);
297
298 ret = TransGetFileListener(sessionName, fileListener);
299 EXPECT_TRUE(ret == SOFTBUS_OK);
300 TransDeleteFileListener(sessionName);
301 TransFileDeinit();
302
303 ret = TransGetFileListener(sessionName, fileListener);
304 EXPECT_TRUE(ret != SOFTBUS_OK);
305 SoftBusFree(fileListener);
306 }
307
308 /**
309 * @tc.name: TransFileTest001
310 * @tc.desc: trans register file callback.
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 HWTEST_F(TransSdkFileTest, TransFileTest001, TestSize.Level0)
315 {
316 IClientSessionCallBack *cb = GetClientSessionCb();
317 int32_t ret = ClientTransUdpMgrInit(cb);
318 ASSERT_TRUE(ret == SOFTBUS_OK);
319
320 UdpChannelMgrCb *fileCb = NULL;
321 RegisterFileCb(NULL);
322 RegisterFileCb(fileCb);
323
324 ClientTransUdpMgrDeinit();
325 }
326
327 /**
328 * @tc.name: TransFileTest002
329 * @tc.desc: trans open file channel.
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(TransSdkFileTest, TransFileTest002, TestSize.Level0)
334 {
335 IClientSessionCallBack *cb = GetClientSessionCb();
336 int32_t ret = ClientTransUdpMgrInit(cb);
337 ASSERT_TRUE(ret == SOFTBUS_OK);
338 ret = TransFileInit();
339 ASSERT_TRUE(ret == SOFTBUS_OK);
340 const char* sessionName = "file send";
341 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
342 ASSERT_TRUE(channelInfo != nullptr);
343 UdpChannel *channel = TransGenerateChannelTest();
344 ASSERT_TRUE(channel != nullptr);
345 int32_t filePort = 22;
346 ret = ClientTransAddUdpChannel(channel);
347 ASSERT_TRUE(ret == SOFTBUS_OK);
348
349 ret = TransSetFileSendListener(sessionName, &g_fileSendListener);
350 ASSERT_TRUE(ret == SOFTBUS_OK);
351
352 ret = TransOnFileChannelOpened(sessionName, channelInfo, NULL);
353 EXPECT_TRUE(ret != SOFTBUS_OK);
354
355 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
356 EXPECT_TRUE(ret != SOFTBUS_OK);
357
358 (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
359 (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
360
361 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
362 EXPECT_TRUE(ret != SOFTBUS_OK);
363
364 channelInfo->isServer = false;
365 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
366 EXPECT_TRUE(ret != SOFTBUS_OK);
367 ClientTransUdpMgrDeinit();
368 }
369
370 /**
371 * @tc.name: TransFileTest003
372 * @tc.desc: trans open file channel use diff param.
373 * @tc.type: FUNC
374 * @tc.require:
375 */
376 HWTEST_F(TransSdkFileTest, TransFileTest003, TestSize.Level0)
377 {
378 IClientSessionCallBack *cb = GetClientSessionCb();
379 (void)ClientTransUdpMgrInit(cb);
380 (void)TransFileInit();
381 IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
382 ASSERT_TRUE(sendListener != nullptr);
383 int32_t filePort = 22;
384 ChannelInfo *channelInfo = TransGenerateChannleInfoTest();
385 ASSERT_TRUE(channelInfo != nullptr);
386 UdpChannel *channel = TransGenerateChannelTest();
387 ASSERT_TRUE(channel != nullptr);
388 DFileMsg *msgData = {};
389 DFileMsgType msgType = DFILE_ON_BIND;
390 FileSendListener(channel->dfileId, msgType, msgData);
391 int32_t ret = ClientTransAddUdpChannel(channel);
392 ASSERT_TRUE(ret == SOFTBUS_OK);
393
394 ret = TransSetFileSendListener(g_mySessionName, sendListener);
395 ASSERT_TRUE(ret == SOFTBUS_OK);
396
397 ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort);
398 EXPECT_TRUE(ret != SOFTBUS_OK);
399
400 TransDeleteFileListener(g_mySessionName);
401 TransFileDeinit();
402 ClientTransUdpMgrDeinit();
403 }
404
405 /**
406 * @tc.name: TransFileTest004
407 * @tc.desc: trans get udp channel.
408 * @tc.type: FUNC
409 * @tc.require:
410 */
411 HWTEST_F(TransSdkFileTest, TransFileTest004, TestSize.Level0)
412 {
413 int32_t dfileId = 0;
414 IClientSessionCallBack *cb = GetClientSessionCb();
415 (void)ClientTransUdpMgrInit(cb);
416 UdpChannel *newchannel = (UdpChannel *)SoftBusCalloc(sizeof(UdpChannel));
417 ASSERT_TRUE(newchannel != nullptr);
418 UdpChannel *channel = TransGenerateChannelTest();
419 ASSERT_TRUE(channel != nullptr);
420 int32_t ret = ClientTransAddUdpChannel(channel);
421 ASSERT_TRUE(ret == SOFTBUS_OK);
422
423 ret = GetUdpChannel(channel->dfileId, NULL);
424 EXPECT_TRUE(ret != SOFTBUS_OK);
425
426 ret = GetUdpChannel(dfileId, newchannel);
427 EXPECT_TRUE(ret != SOFTBUS_OK);
428
429 ret = GetUdpChannel(channel->dfileId, newchannel);
430 EXPECT_TRUE(ret == SOFTBUS_OK);
431
432 SoftBusFree(newchannel);
433 ClientTransUdpMgrDeinit();
434 }
435
436 /**
437 * @tc.name: TransFileTest005
438 * @tc.desc: trans file receive listener use diff param.
439 * @tc.type: FUNC
440 * @tc.require:
441 */
442 HWTEST_F(TransSdkFileTest, TransFileTest005, TestSize.Level0)
443 {
444 IClientSessionCallBack *cb = GetClientSessionCb();
445 (void)ClientTransUdpMgrInit(cb);
446 (void)TransFileInit();
447 const char* rootDir = "rootDir";
448 const char* sessionName = "file receive";
449 IFileReceiveListener *recvListener = (IFileReceiveListener *)SoftBusCalloc(sizeof(IFileReceiveListener));
450 ASSERT_TRUE(recvListener != nullptr);
451 UdpChannel *channel = TransGenerateChannelTest();
452 ASSERT_TRUE(channel != nullptr);
453 DFileMsg *msgData = {};
454 DFileMsgType msgType = DFILE_ON_BIND;
455 FileReceiveListener(channel->dfileId, msgType, msgData);
456
457 int32_t ret = ClientTransAddUdpChannel(channel);
458 ASSERT_TRUE(ret == SOFTBUS_OK);
459 ret = TransSetFileReceiveListener(sessionName, recvListener, rootDir);
460 ASSERT_TRUE(ret == SOFTBUS_OK);
461
462 msgType = DFILE_ON_FILE_LIST_RECEIVED;
463 FileReceiveListener(channel->dfileId, msgType, msgData);
464
465 msgType = DFILE_ON_FILE_RECEIVE_SUCCESS;
466 FileReceiveListener(channel->dfileId, msgType, msgData);
467
468 msgType = DFILE_ON_FILE_RECEIVE_FAIL;
469 FileReceiveListener(channel->dfileId, msgType, msgData);
470
471 msgType = DFILE_ON_TRANS_IN_PROGRESS;
472 FileReceiveListener(channel->dfileId, msgType, msgData);
473
474 msgType = DFILE_ON_FILE_SEND_SUCCESS;
475 FileReceiveListener(channel->dfileId, msgType, msgData);
476
477 msgType = DFILE_ON_CONNECT_FAIL;
478 FileReceiveListener(channel->dfileId, msgType, msgData);
479
480 TransDeleteFileListener(sessionName);
481 TransFileDeinit();
482 ClientTransUdpMgrDeinit();
483 }
484
485 /**
486 * @tc.name: TransFileTest006
487 * @tc.desc: trans file receive listener.
488 * @tc.type: FUNC
489 * @tc.require:
490 */
491 HWTEST_F(TransSdkFileTest, TransFileTest006, TestSize.Level0)
492 {
493 IClientSessionCallBack *cb = GetClientSessionCb();
494 (void)ClientTransUdpMgrInit(cb);
495 (void)TransFileInit();
496 UdpChannel *channel = TransGenerateChannelTest();
497 ASSERT_TRUE(channel != nullptr);
498 const char *rootDir = "root_dir";
499 const char* sessionName = "file receive";
500 DFileMsg *msgData = {};
501 DFileMsgType msgType = DFILE_ON_BIND;
502 FileReceiveListener(channel->dfileId, msgType, msgData);
503 int32_t ret = ClientTransAddUdpChannel(channel);
504 ASSERT_TRUE(ret == SOFTBUS_OK);
505
506 ret = TransSetFileReceiveListener(sessionName, &g_fileRecvListener, rootDir);
507 ASSERT_TRUE(ret == SOFTBUS_OK);
508
509 msgType = DFILE_ON_FILE_LIST_RECEIVED;
510 FileReceiveListener(channel->dfileId, msgType, msgData);
511
512 msgType = DFILE_ON_FILE_RECEIVE_SUCCESS;
513 FileReceiveListener(channel->dfileId, msgType, msgData);
514
515 msgType = DFILE_ON_FILE_RECEIVE_FAIL;
516 FileReceiveListener(channel->dfileId, msgType, msgData);
517
518 msgType = DFILE_ON_TRANS_IN_PROGRESS;
519 FileReceiveListener(channel->dfileId, msgType, msgData);
520
521 msgType = DFILE_ON_FILE_SEND_SUCCESS;
522 FileReceiveListener(channel->dfileId, msgType, msgData);
523
524 msgType = DFILE_ON_CONNECT_FAIL;
525 FileReceiveListener(channel->dfileId, msgType, msgData);
526 TransDeleteFileListener(sessionName);
527 TransFileDeinit();
528 ClientTransUdpMgrDeinit();
529 }
530
531 /**
532 * @tc.name: TransFileTest007
533 * @tc.desc: trans file channel open use diff param.
534 * @tc.type: FUNC
535 * @tc.require:
536 */
537 HWTEST_F(TransSdkFileTest, TransFileTest007, TestSize.Level0)
538 {
539 IClientSessionCallBack *cb = GetClientSessionCb();
540 int32_t ret = ClientTransUdpMgrInit(cb);
541 ASSERT_TRUE(ret == SOFTBUS_OK);
542 ret = TransFileInit();
543 ASSERT_TRUE(ret == SOFTBUS_OK);
544 const char* sessionName = "file send";
545 IFileSendListener *sendListener;
546 ChannelInfo *channelInfo = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
547 ASSERT_TRUE(channelInfo != nullptr);
548 UdpChannel *channel = TransGenerateChannelTest();
549 int32_t filePort = 22;
550
551 ret = ClientTransAddUdpChannel(channel);
552 ASSERT_TRUE(ret == SOFTBUS_OK);
553
554 ret = TransSetFileSendListener(sessionName, sendListener);
555 EXPECT_TRUE(ret != SOFTBUS_OK);
556
557 ret = TransOnFileChannelOpened(sessionName, channelInfo, NULL);
558 EXPECT_TRUE(ret != SOFTBUS_OK);
559
560 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
561 EXPECT_TRUE(ret != SOFTBUS_OK);
562
563 (void)strcpy_s(channelInfo->myIp, strlen("127.0.0.5") + 1, "127.0.0.5");
564 (void)strcpy_s(channelInfo->sessionKey, strlen("session key") + 1, "session key");
565
566 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
567 EXPECT_TRUE(ret != SOFTBUS_OK);
568
569 channelInfo->isServer = false;
570 ret = TransOnFileChannelOpened(sessionName, channelInfo, &filePort);
571 EXPECT_TRUE(ret != SOFTBUS_OK);
572 ClientTransUdpMgrDeinit();
573 }
574
575 /**
576 * @tc.name: TransFileTest008
577 * @tc.desc: trans file channel use wrong param.
578 * @tc.type: FUNC
579 * @tc.require:
580 */
581 HWTEST_F(TransSdkFileTest, TransFileTest008, TestSize.Level0)
582 {
583 IClientSessionCallBack *cb = GetClientSessionCb();
584 (void)ClientTransUdpMgrInit(cb);
585 (void)TransFileInit();
586 IFileSendListener *sendListener = (IFileSendListener *)SoftBusCalloc(sizeof(IFileSendListener));
587 ASSERT_TRUE(sendListener != nullptr);
588 int32_t filePort = 22;
589 ChannelInfo *channelInfo = TransGenerateChannleInfoTest();
590 ASSERT_TRUE(channelInfo != nullptr);
591 UdpChannel *channel = TransGenerateChannelTest();
592 ASSERT_TRUE(channel != nullptr);
593 DFileMsg *msgData = {};
594 DFileMsgType msgType = DFILE_ON_BIND;
595 FileSendListener(channel->dfileId, msgType, msgData);
596
597 int32_t ret = ClientTransAddUdpChannel(channel);
598 ASSERT_TRUE(ret == SOFTBUS_OK);
599
600 ret = TransSetFileSendListener(g_mySessionName, sendListener);
601 ASSERT_TRUE(ret == SOFTBUS_OK);
602
603 ret = TransOnFileChannelOpened(g_mySessionName, channelInfo, &filePort);
604 EXPECT_TRUE(ret != SOFTBUS_OK);
605
606 TransCloseFileChannel(channel->dfileId);
607
608 TransDeleteFileListener(g_mySessionName);
609 TransFileDeinit();
610 ClientTransUdpMgrDeinit();
611 }
612
613 /**
614 * @tc.name: TransFileTest009
615 * @tc.desc: trans file send use diff param.
616 * @tc.type: FUNC
617 * @tc.require:
618 */
619 HWTEST_F(TransSdkFileTest, TransFileTest009, TestSize.Level0)
620 {
621 int32_t sessionId = 0;
622 const char *sFileList = nullptr;
623 const char *dFileList = nullptr;
624 const char *fileList = "/file not null list/";
625 uint32_t fileCnt = 0;
626 int32_t ret = TransSendFile(sessionId, &sFileList, &dFileList, fileCnt);
627 EXPECT_TRUE(ret != SOFTBUS_OK);
628
629 ret = TransSendFile(sessionId, &fileList, &dFileList, fileCnt);
630 EXPECT_TRUE(ret != SOFTBUS_OK);
631 }
632 }