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 <gtest/gtest.h>
17 #include <sys/types.h>
18 #include <sys/stat.h>
19 #include <fcntl.h>
20 #include "securec.h"
21
22 #include "client_trans_proxy_file_manager.c"
23 #include "client_trans_session_manager.c"
24 #include "client_trans_file_listener.h"
25 #include "softbus_def.h"
26 #include "softbus_errcode.h"
27 #include "softbus_server_frame.h"
28 #include "session.h"
29 #include "softbus_app_info.h"
30 #include "softbus_access_token_test.h"
31
32 #define TEST_FILE_LENGTH 10
33 #define TEST_FILE_CNT 2
34 #define TEST_CHANNEL_ID 2
35 #define TEST_SESSION_ID 1
36 #define TEST_SEQ 1020
37 #define TEST_SEQ_SECOND 2
38 #define TEST_HEADER_LENGTH 24
39 #define TEST_FILE_PATH "/data/file.txt"
40 #define TEST_DATA_LENGTH 6
41 #define TEST_FILE_SIZE 1000
42 #define TEST_PATH_SIZE 50
43 #define TEST_FILE_TEST_TXT_FILE 16
44 #define TEST_FILE_MAGIC_OFFSET 0
45 #define TEST_FRAME_NUMBER 2
46 #define TEST_FRAME_DATA_LENGTH 10
47 #define TEST_FILEPATH_LENGTH 4
48 #define TEST_SEQ8 8
49 #define TEST_SEQ16 16
50 #define TEST_SEQ32 32
51 #define TEST_SEQ126 126
52 #define TEST_SEQ128 128
53
54 using namespace std;
55 using namespace testing::ext;
56
57 namespace OHOS {
58 const char *g_pkgName = "dms";
59 const char *g_sessionName = "ohos.distributedschedule.dms.test";
60 const char *g_peerNetworkId = "1234567789";
61 const char *g_groupId = "123";
62 FILE *g_fileTest = NULL;
63 FILE *g_fileSs = NULL;
64 int g_fd = 0;
65 char g_writeData[128] = "test111111111111111111111111111111111111111111111111111111111111";
66 const char *g_rootDir = "/data";
67 const char *g_destFile = "test.txt";
68 char g_recvFile[] = "/data/test.txt";
69
70 SessionAttribute g_attr = {
71 .dataType = TYPE_MESSAGE,
72 .linkTypeNum = LINK_TYPE_WIFI_WLAN_5G,
73 };
74
75 SessionParam g_param = {
76 .sessionName = g_sessionName,
77 .peerSessionName = g_sessionName,
78 .peerDeviceId = g_peerNetworkId,
79 .groupId = g_groupId,
80 .attr = &g_attr,
81 };
82
83 const char *g_testProxyFileList[] = {
84 "/data/test.txt",
85 "/data/ss.txt",
86 };
87
88 const char *g_fileList[] = {
89 "/data/data/test.txt",
90 "/path/max/length/512/"
91 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
92 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
93 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
94 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
95 "111111111111111111111111111111111111111111111111111",
96 };
97
OnSessionOpened(int sessionId,int result)98 static int OnSessionOpened(int sessionId, int result)
99 {
100 return SOFTBUS_OK;
101 }
102
OnSessionClosed(int sessionId)103 static void OnSessionClosed(int sessionId)
104 {
105 }
106
OnBytesReceived(int sessionId,const void * data,unsigned int len)107 static void OnBytesReceived(int sessionId, const void *data, unsigned int len)
108 {
109 }
110
OnMessageReceived(int sessionId,const void * data,unsigned int len)111 static void OnMessageReceived(int sessionId, const void *data, unsigned int len)
112 {
113 }
114
115 static ISessionListener g_sessionlistener = {
116 .OnSessionOpened = OnSessionOpened,
117 .OnSessionClosed = OnSessionClosed,
118 .OnBytesReceived = OnBytesReceived,
119 .OnMessageReceived = OnMessageReceived,
120 };
121
OnSendFileProcess(int sessionId,uint64_t bytesUpload,uint64_t bytesTotal)122 static int OnSendFileProcess(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
123 {
124 return SOFTBUS_OK;
125 }
126
OnSendFileFinished(int sessionId,const char * firstFile)127 static int OnSendFileFinished(int sessionId, const char *firstFile)
128 {
129 return SOFTBUS_OK;
130 }
131
OnFileTransError(int sessionId)132 void OnFileTransError(int sessionId)
133 {
134 return;
135 }
136
OnReceiveFileStarted(int sessionId,const char * files,int fileCnt)137 static int OnReceiveFileStarted(int sessionId, const char *files, int fileCnt)
138 {
139 return SOFTBUS_OK;
140 }
141
OnReceiveFileProcess(int sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)142 static int OnReceiveFileProcess(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
143 {
144 return SOFTBUS_OK;
145 }
OnReceiveFileFinished(int sessionId,const char * files,int fileCnt)146 static void OnReceiveFileFinished(int sessionId, const char *files, int fileCnt)
147 {
148 return;
149 }
150
151 const IFileSendListener g_listener = {
152 .OnSendFileProcess = OnSendFileProcess,
153 .OnSendFileFinished = OnSendFileFinished,
154 .OnFileTransError = OnFileTransError,
155 };
156
157 const IFileReceiveListener g_fileRecvListener = {
158 .OnReceiveFileStarted = OnReceiveFileStarted,
159 .OnReceiveFileProcess = OnReceiveFileProcess,
160 .OnReceiveFileFinished = OnReceiveFileFinished,
161 .OnFileTransError = OnFileTransError,
162 };
163
164 class ClientTransProxyFileManagerTest : public testing::Test {
165 public:
ClientTransProxyFileManagerTest()166 ClientTransProxyFileManagerTest() {}
~ClientTransProxyFileManagerTest()167 ~ClientTransProxyFileManagerTest() {}
168 static void SetUpTestCase(void);
169 static void TearDownTestCase(void);
SetUp()170 void SetUp() override {}
TearDown()171 void TearDown() override {}
172 };
173
SetUpTestCase(void)174 void ClientTransProxyFileManagerTest::SetUpTestCase(void)
175 {
176 SetAceessTokenPermission("dsoftbusTransTest");
177 int ret = TransServerProxyInit();
178 EXPECT_EQ(SOFTBUS_OK, ret);
179 g_fileTest = fopen(g_testProxyFileList[0], "w+");
180 EXPECT_NE(g_fileTest, nullptr);
181
182 g_fileSs = fopen(g_testProxyFileList[1], "w+");
183 EXPECT_NE(g_fileSs, nullptr);
184 ret = fprintf(g_fileSs, "%s", "Hello world!\n");
185 EXPECT_GE(ret, 0);
186 g_fd = open(TEST_FILE_PATH, O_RDWR | O_CREAT, S_IRWXU);
187 EXPECT_NE(g_fd, -1);
188 write(g_fd, g_writeData, sizeof(g_writeData));
189 }
190
TearDownTestCase(void)191 void ClientTransProxyFileManagerTest::TearDownTestCase(void)
192 {
193 int ret = fclose(g_fileTest);
194 EXPECT_EQ(ret, 0);
195 g_fileTest = NULL;
196 ret = fclose(g_fileSs);
197 EXPECT_EQ(ret, 0);
198 g_fileSs = NULL;
199 close(g_fd);
200 g_fd = -1;
201 ret = remove(g_testProxyFileList[0]);
202 EXPECT_EQ(SOFTBUS_OK, ret);
203
204 ret = remove(g_testProxyFileList[1]);
205 EXPECT_EQ(SOFTBUS_OK, ret);
206
207 ret = remove(TEST_FILE_PATH);
208 EXPECT_EQ(SOFTBUS_OK, ret);
209 ClinetTransProxyFileManagerDeinit();
210 }
211
212 /**
213 * @tc.name: ClinetTransProxySendFileTest001
214 * @tc.desc: client trans proxy send file test, use the wrong parameter.
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendFileTest001, TestSize.Level0)
219 {
220 int32_t channelId = 1;
221 int ret = ProxyChannelSendFile(channelId, g_testProxyFileList, g_testProxyFileList, 0);
222 EXPECT_EQ(SOFTBUS_ERR, ret);
223
224 ret = ProxyChannelSendFile(channelId, nullptr, g_testProxyFileList, TEST_FILE_CNT);
225 EXPECT_EQ(SOFTBUS_ERR, ret);
226
227 const char *proxyNullFileList[] = {
228 nullptr,
229 "/path/max/length/512",
230 };
231 ret = ProxyChannelSendFile(channelId, proxyNullFileList, g_testProxyFileList, TEST_FILE_CNT);
232 EXPECT_EQ(SOFTBUS_ERR, ret);
233
234 const char *proxyZeroLileList[] = {
235 "",
236 "/path/max/length/512",
237 };
238 ret = ProxyChannelSendFile(channelId, proxyZeroLileList, g_testProxyFileList, TEST_FILE_CNT);
239 EXPECT_EQ(SOFTBUS_ERR, ret);
240
241 const char *proxyLengthFileList[] = {
242 "/path/max/length/512",
243 "/path/max/length/512/"
244 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
245 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
246 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
247 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
248 "111111111111111111111111111111111111111111111111111",
249 };
250 ret = ProxyChannelSendFile(channelId, proxyLengthFileList, g_testProxyFileList, TEST_FILE_CNT);
251 EXPECT_EQ(SOFTBUS_ERR, ret);
252
253 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, nullptr, TEST_FILE_CNT);
254 EXPECT_EQ(SOFTBUS_ERR, ret);
255
256 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, proxyNullFileList, TEST_FILE_CNT);
257 EXPECT_EQ(SOFTBUS_ERR, ret);
258
259 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, g_testProxyFileList, TEST_FILE_CNT);
260 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
261 }
262
263 /**
264 * @tc.name: ClinetTransRecvFileFrameDataTest001
265 * @tc.desc: clent trans recv file frame data test, use the wrong parameter.
266 * @tc.type: FUNC
267 * @tc.require:
268 */
269 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransRecvFileFrameDataTest001, TestSize.Level0)
270 {
271 int32_t channelId = 1;
272 int32_t sessionId = 1;
273 int ret = ProcessRecvFileFrameData(sessionId, channelId, nullptr);
274 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
275
276 FileFrame fileFrame;
277 fileFrame.frameLength = PROXY_MAX_PACKET_SIZE + 1;
278 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
279 EXPECT_EQ(SOFTBUS_ERR, ret);
280
281 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
282 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
283 EXPECT_EQ(SOFTBUS_ERR, ret);
284 }
285
286 /**
287 * @tc.name: ClinetTransRecvFileFrameDataTest002
288 * @tc.desc: client trans recv file frame data test, use the wrong parameter.
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransRecvFileFrameDataTest002, TestSize.Level0)
293 {
294 int32_t channelId = 1;
295 int32_t sessionId = 1;
296
297 FileFrame fileFrame;
298 fileFrame.frameLength = PROXY_MAX_PACKET_SIZE - 1;
299
300 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
301 int ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
302 EXPECT_EQ(SOFTBUS_ERR, ret);
303
304 fileFrame.frameType = TRANS_SESSION_FILE_ONGOINE_FRAME;
305 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
306 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
307
308 fileFrame.frameType = TRANS_SESSION_FILE_ONLYONE_FRAME;
309 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
310 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
311
312 fileFrame.frameType = TRANS_SESSION_FILE_LAST_FRAME;
313 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
314 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
315
316 fileFrame.frameType = TRANS_SESSION_FILE_ACK_REQUEST_SENT;
317 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
318 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
319
320 fileFrame.frameType = TRANS_SESSION_FILE_ACK_RESPONSE_SENT;
321 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
322 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
323
324 fileFrame.frameType = TRANS_SESSION_FILE_CRC_CHECK_FRAME;
325 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
326 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
327
328 fileFrame.frameType = TRANS_SESSION_FILE_RESULT_FRAME;
329 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
330 EXPECT_EQ(SOFTBUS_ERR, ret);
331
332 fileFrame.frameType = TRANS_SESSION_FILE_ALLFILE_SENT;
333 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
334 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
335
336 fileFrame.frameType = -1;
337 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
338 EXPECT_EQ(SOFTBUS_ERR, ret);
339 }
340
341 /**
342 * @tc.name: ClinetTransProxyFileManagerInitDataTest001
343 * @tc.desc: client trans proxy file manager init data test, use the wrong or normal parameter.
344 * @tc.type: FUNC
345 * @tc.require:
346 */
347 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileManagerInitDataTest001, TestSize.Level0)
348 {
349 int32_t ret = ClinetTransProxyFileManagerInit();
350 EXPECT_EQ(SOFTBUS_OK, ret);
351
352 int32_t channelId = 1;
353 uint32_t seq = TEST_SEQ;
354 int32_t result = 0;
355 uint32_t side = 0;
356 ret = SendFileTransResult(channelId, seq, result, side);
357 EXPECT_EQ(SOFTBUS_ERR, ret);
358
359 uint32_t data = 0;
360 const uint8_t *data1 = (const uint8_t *)&data;
361 uint32_t len = TEST_HEADER_LENGTH;
362 ret = UnpackFileTransResultFrame(data1, len, nullptr, &result, &side);
363 EXPECT_EQ(SOFTBUS_ERR, ret);
364
365 ret = UnpackFileTransResultFrame(nullptr, len, &seq, &result, &side);
366 EXPECT_NE(SOFTBUS_OK, ret);
367
368 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, &side);
369 EXPECT_NE(SOFTBUS_OK, ret);
370
371 data = FILE_MAGIC_NUMBER;
372 const uint8_t *data2 = (const uint8_t *)&data;
373 ret = UnpackFileTransResultFrame(data2, len, &seq, &result, &side);
374 EXPECT_NE(SOFTBUS_OK, ret);
375 }
376
377 /**
378 * @tc.name: ClinetTransProxyGetSessionFileLockTest001
379 * @tc.desc: client trans proxy get session file lock test, use the wrong or normal parameter.
380 * @tc.type: FUNC
381 * @tc.require:
382 */
383 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetSessionFileLockTest001, TestSize.Level0)
384 {
385 int32_t channelId = 1;
386 ProxyFileMutexLock *sessionLock = GetSessionFileLock(channelId);
387 EXPECT_NE(nullptr, sessionLock);
388
389 sessionLock = GetSessionFileLock(channelId);
390 EXPECT_NE(nullptr, sessionLock);
391
392 DelSessionFileLock(nullptr);
393 sessionLock->count = 1;
394 DelSessionFileLock(sessionLock);
395
396 sessionLock->count = 2;
397 DelSessionFileLock(sessionLock);
398 }
399
400 /**
401 * @tc.name: ClinetTransProxyCreateSendListenerInfoTest001
402 * @tc.desc: client trans proxy create send listener info test, use the wrong or normal parameter.
403 * @tc.type: FUNC
404 * @tc.require:
405 */
406 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCreateSendListenerInfoTest001, TestSize.Level0)
407 {
408 int ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
409 ASSERT_EQ(SOFTBUS_OK, ret);
410
411 int32_t sessionId = 1;
412 bool isEnabled = false;
413
414 ret = ClientAddSession(&g_param, &sessionId, &isEnabled);
415 ASSERT_EQ(SOFTBUS_OK, ret);
416
417 SendListenerInfo *sendListenerInfo;
418 ret = CreateSendListenerInfo(&sendListenerInfo, TEST_CHANNEL_ID);
419 EXPECT_EQ(SOFTBUS_ERR, ret);
420
421 int32_t channelId = 1;
422 SessionInfo sessionInfo;
423 sessionInfo.sessionId = sessionId;
424 sessionInfo.channelId = channelId;
425 sessionInfo.channelType = CHANNEL_TYPE_PROXY;
426 ret = AddSession(g_sessionName, &sessionInfo);
427 ASSERT_EQ(SOFTBUS_OK, ret);
428
429 ret = TransSetFileSendListener(g_sessionName, &g_listener);
430 ASSERT_EQ(SOFTBUS_OK, ret);
431
432 ret = TransSetFileReceiveListener(g_sessionName, &g_fileRecvListener, g_rootDir);
433 ASSERT_EQ(SOFTBUS_OK, ret);
434
435 ret = CreateSendListenerInfo(&sendListenerInfo, channelId);
436 EXPECT_EQ(SOFTBUS_OK, ret);
437
438 ret = CreateSendListenerInfo(&sendListenerInfo, channelId);
439 EXPECT_EQ(SOFTBUS_ALREADY_EXISTED, ret);
440
441 ret = AddSendListenerInfo(nullptr);
442 EXPECT_NE(SOFTBUS_OK, ret);
443
444 FileRecipientInfo *result = CreateNewRecipient(sessionId, channelId);
445 EXPECT_NE(nullptr, result);
446 }
447
448 /**
449 * @tc.name: ClinetTransProxyGetAndCheckFileSizeTest001
450 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
451 * @tc.type: FUNC
452 * @tc.require:
453 */
454 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetAndCheckFileSizeTest001, TestSize.Level0)
455 {
456 uint64_t fileSize = 0;
457 uint64_t frameNum = 0;
458 int ret = GetAndCheckFileSize(nullptr, &fileSize, &frameNum, APP_INFO_FILE_FEATURES_SUPPORT);
459 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
460
461 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, APP_INFO_FILE_FEATURES_SUPPORT);
462 EXPECT_EQ(SOFTBUS_OK, ret);
463
464 ret = GetAndCheckFileSize(g_testProxyFileList[1], &fileSize, &frameNum, APP_INFO_FILE_FEATURES_NO_SUPPORT);
465 EXPECT_EQ(SOFTBUS_OK, ret);
466 }
467
468 /**
469 * @tc.name: ClinetTransProxySendOneFrameTest001
470 * @tc.desc: client trans proxy send one frame test, use the wrong or normal parameter.
471 * @tc.type: FUNC
472 * @tc.require:
473 */
474 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendOneFrameTest001, TestSize.Level0)
475 {
476 SendListenerInfo info;
477 info.sessionId = TEST_SESSION_ID;
478 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
479 info.channelId = TEST_CHANNEL_ID;
480
481 FileFrame fileFrame = {
482 .frameType = TRANS_SESSION_BYTES,
483 .data = nullptr,
484 };
485 int ret = SendOneFrame(nullptr, &fileFrame);
486 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
487
488 ret = SendOneFrame(&info, &fileFrame);
489 EXPECT_EQ(SOFTBUS_ERR, ret);
490
491 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
492 uint32_t dataTest = TEST_DATA_LENGTH;
493 fileFrame.data = (uint8_t *)&dataTest;
494 ret = SendOneFrame(&info, &fileFrame);
495 EXPECT_EQ(SOFTBUS_ERR, ret);
496
497 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
498 ret = SendOneFrame(&info, &fileFrame);
499 EXPECT_EQ(SOFTBUS_ERR, ret);
500
501 ret = SendOneFrameFront(nullptr, fileFrame.frameType);
502 EXPECT_NE(SOFTBUS_OK, ret);
503
504 SendListenerInfo infoMiddle;
505 infoMiddle.sessionId = 1;
506 infoMiddle.channelId = 1;
507 infoMiddle.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
508 ret = SendOneFrameMiddle(nullptr, TRANS_SESSION_FILE_ONGOINE_FRAME);
509 EXPECT_NE(SOFTBUS_OK, ret);
510
511 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
512 EXPECT_EQ(SOFTBUS_OK, ret);
513
514 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
515 EXPECT_EQ(SOFTBUS_OK, ret);
516
517 infoMiddle.crc = APP_INFO_FILE_FEATURES_SUPPORT;
518 infoMiddle.seq = 0;
519 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_BYTES);
520 EXPECT_EQ(SOFTBUS_OK, ret);
521
522 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
523 EXPECT_EQ(SOFTBUS_ERR, ret);
524
525 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
526 EXPECT_EQ(SOFTBUS_OK, ret);
527
528 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_FIRST_FRAME);
529 EXPECT_EQ(SOFTBUS_OK, ret);
530
531 infoMiddle.seq = TEST_SEQ;
532 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
533 EXPECT_EQ(SOFTBUS_OK, ret);
534 }
535
536 /**
537 * @tc.name: ClinetTransProxySendOneFrameTest002
538 * @tc.desc: client trans proxy send one frame test, use the wrong or normal parameter.
539 * @tc.type: FUNC
540 * @tc.require:
541 */
542 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendOneFrameTest002, TestSize.Level0)
543 {
544 SendListenerInfo infoRear;
545 infoRear.sessionId = 1;
546 infoRear.channelId = 1;
547 infoRear.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
548 int ret = SendOneFrameRear(nullptr, TRANS_SESSION_BYTES);
549 EXPECT_NE(SOFTBUS_OK, ret);
550
551 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_BYTES);
552 EXPECT_EQ(SOFTBUS_OK, ret);
553
554 infoRear.crc = APP_INFO_FILE_FEATURES_SUPPORT;
555 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_FILE_ONLYONE_FRAME);
556 EXPECT_EQ(SOFTBUS_OK, ret);
557
558 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_FILE_FIRST_FRAME);
559 EXPECT_EQ(SOFTBUS_ERR, ret);
560
561 infoRear.waitSeq = 0;
562 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_FILE_LAST_FRAME);
563 EXPECT_EQ(SOFTBUS_OK, ret);
564
565 infoRear.waitSeq = TEST_SEQ;
566 ret = SendOneFrameRear(&infoRear, TRANS_SESSION_FILE_LAST_FRAME);
567 EXPECT_EQ(SOFTBUS_ERR, ret);
568 }
569
570 /**
571 * @tc.name: ClinetTransProxyFileRecipientInfoTest001
572 * @tc.desc: client trans proxy file recipient info test, use the wrong or normal parameter.
573 * @tc.type: FUNC
574 * @tc.require:
575 */
576 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileRecipientInfoTest001, TestSize.Level0)
577 {
578 FileRecipientInfo info;
579 info.recvFileInfo.fileFd = -2;
580 info.recvState = TRANS_FILE_RECV_ERR_STATE;
581 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
582 info.channelId = 1;
583 info.recvFileInfo.seq = TEST_SEQ;
584 info.fileListener.recvListener.OnFileTransError = nullptr;
585 ClearRecipientResources(&info);
586
587 info.fileListener.recvListener.OnFileTransError = OnFileTransError;
588 SetRecipientRecvState(&info, TRANS_FILE_RECV_IDLE_STATE);
589 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
590 ClearRecipientResources(&info);
591
592 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
593 ClearRecipientResources(&info);
594
595 info.recvState = TRANS_FILE_RECV_IDLE_STATE;
596 SetRecipientRecvState(&info, TRANS_FILE_RECV_IDLE_STATE);
597 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
598 SetRecipientRecvState(&info, TRANS_FILE_RECV_PROCESS_STATE);
599 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
600 ClearRecipientResources(&info);
601
602 info.recvFileInfo.fileFd = INVALID_FD;
603 ClearRecipientResources(&info);
604 }
605
606 /**
607 * @tc.name: ClinetTransProxyFileAckReqAndResDataTest001
608 * @tc.desc: client trans proxy file ack req and res data test, use the wrong or normal parameter.
609 * @tc.type: FUNC
610 * @tc.require:
611 */
612 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckReqAndResDataTest001, TestSize.Level0)
613 {
614 int32_t channelId = 1;
615 uint32_t startSeq = TEST_SEQ;
616 uint32_t value = 0;
617 int ret = SendFileAckReqAndResData(channelId, startSeq, value, CHANNEL_TYPE_PROXY);
618 EXPECT_EQ(SOFTBUS_ERR, ret);
619
620 FileFrame frame;
621 frame.frameLength = 0;
622 frame.data = nullptr;
623 uint64_t dataTest = 0;
624 ret = UnpackAckReqAndResData(nullptr, &startSeq, &value);
625 EXPECT_NE(SOFTBUS_OK, ret);
626
627 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
628 EXPECT_NE(SOFTBUS_OK, ret);
629
630 frame.data = (uint8_t *)&dataTest;
631 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
632 EXPECT_NE(SOFTBUS_OK, ret);
633
634 frame.frameLength = TEST_HEADER_LENGTH;
635 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
636 EXPECT_NE(SOFTBUS_OK, ret);
637
638 dataTest = FILE_MAGIC_NUMBER;
639 frame.data = (uint8_t *)&dataTest;
640 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
641 EXPECT_NE(SOFTBUS_OK, ret);
642 }
643
644 /**
645 * @tc.name: ClinetTransProxyPackFileDataTest001
646 * @tc.desc: client trans proxy pack file data test, use the wrong parameter.
647 * @tc.type: FUNC
648 * @tc.require:
649 */
650 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataTest001, TestSize.Level0)
651 {
652 FileFrame fileFrame = {
653 .frameType = TRANS_SESSION_BYTES,
654 .data = nullptr,
655 };
656 uint64_t readLength = TEST_FILE_LENGTH;
657 uint64_t fileOffset = 0;
658 SendListenerInfo info;
659 info.fd = g_fd;
660 uint32_t seq = TEST_SEQ;
661 int64_t len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
662 EXPECT_EQ(SOFTBUS_ERR, len);
663
664 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
665 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
666 EXPECT_EQ(SOFTBUS_ERR, len);
667
668 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
669 EXPECT_EQ(SOFTBUS_ERR, len);
670
671 uint32_t dataTest = TEST_DATA_LENGTH;
672 fileFrame.data = (uint8_t *)&dataTest;
673 fileFrame.fileData = (uint8_t *)&dataTest;
674 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
675 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
676 EXPECT_NE(SOFTBUS_ERR, len);
677
678 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
679 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
680 EXPECT_NE(SOFTBUS_ERR, len);
681
682 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
683 EXPECT_EQ(SOFTBUS_ERR, len);
684 }
685
686 /**
687 * @tc.name: ClinetTransProxyPackFileDataFrameTest001
688 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
689 * @tc.type: FUNC
690 * @tc.require:
691 */
692 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataFrameTest001, TestSize.Level0)
693 {
694 uint32_t dataTest = TEST_DATA_LENGTH;
695 FileFrame fileFrame = {
696 .magic = FILE_MAGIC_NUMBER,
697 .frameType = TRANS_SESSION_BYTES,
698 .frameLength = 0,
699 .data = (uint8_t *)&dataTest,
700 .fileData = (uint8_t *)&dataTest,
701 };
702
703 FileRecipientInfo info = {
704 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
705 };
706
707 uint32_t fileDataLen = 0;
708 int ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
709 EXPECT_NE(SOFTBUS_OK, ret);
710
711 fileFrame.frameLength = TEST_HEADER_LENGTH;
712 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
713 EXPECT_EQ(SOFTBUS_OK, ret);
714
715 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
716 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
717 EXPECT_NE(SOFTBUS_OK, ret);
718
719 fileFrame.magic = 0;
720 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
721 EXPECT_NE(SOFTBUS_OK, ret);
722 }
723
724 /**
725 * @tc.name: ClinetTransProxyRetransFileFrameTest001
726 * @tc.desc: client trans proxy retrans file frame test, use normal parameter.
727 * @tc.type: FUNC
728 * @tc.require:
729 */
730 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRetransFileFrameTest001, TestSize.Level0)
731 {
732 SendListenerInfo info = {
733 .fileSize = TEST_FILE_SIZE,
734 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
735 };
736 int ret = RetransFileFrameBySeq(nullptr, TEST_SEQ);
737 EXPECT_NE(SOFTBUS_OK, ret);
738
739 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
740 EXPECT_EQ(SOFTBUS_OK, ret);
741
742 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
743 int32_t seq = TEST_SEQ_SECOND;
744 ret = RetransFileFrameBySeq(&info, seq);
745 EXPECT_NE(SOFTBUS_OK, ret);
746
747 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
748 EXPECT_NE(SOFTBUS_OK, ret);
749 }
750
751 /**
752 * @tc.name: ClinetTransProxyAckResponseDataHandleTest001
753 * @tc.desc: client trans proxy handle response data test, use normal parameter.
754 * @tc.type: FUNC
755 * @tc.require:
756 */
757 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyAckResponseDataHandleTest001, TestSize.Level0)
758 {
759 SendListenerInfo info = {
760 .fileSize = TEST_FILE_SIZE,
761 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
762 };
763 uint32_t len = 0;
764 int ret = AckResponseDataHandle(&info, nullptr, len);
765 EXPECT_EQ(SOFTBUS_OK, ret);
766
767 const char *data = "test_data";
768 ret = AckResponseDataHandle(&info, data, len);
769 EXPECT_EQ(SOFTBUS_OK, ret);
770
771 len = sizeof(AckResponseData);
772 ret = AckResponseDataHandle(&info, data, len);
773 EXPECT_EQ(SOFTBUS_OK, ret);
774
775 AckResponseData ackResponseData = {
776 .startSeq = FILE_SEND_ACK_RESULT_SUCCESS,
777 .seqResult = TEST_SEQ_SECOND,
778 };
779 const char *dataTest = reinterpret_cast<const char*>(&ackResponseData);
780 ret = AckResponseDataHandle(&info, dataTest, len);
781 EXPECT_EQ(SOFTBUS_OK, ret);
782 }
783
784 /**
785 * @tc.name: ClinetTransProxyGetFullRecvPathTest001
786 * @tc.desc: client trans proxy get full recv path test, use normal parameter.
787 * @tc.type: FUNC
788 * @tc.require:
789 */
790 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFullRecvPathTest001, TestSize.Level0)
791 {
792 char *result = GetFullRecvPath(nullptr, nullptr);
793 EXPECT_EQ(nullptr, result);
794 const char *filePath1 = "";
795 const char *recvRootDir1 = "";
796
797 result = GetFullRecvPath(filePath1, recvRootDir1);
798 EXPECT_NE(nullptr, result);
799
800 const char *filePath2 = "/test.txt";
801 result = GetFullRecvPath(filePath2, recvRootDir1);
802 EXPECT_NE(nullptr, result);
803
804 const char *recvRootDir2 = "/data/";
805 result = GetFullRecvPath(filePath1, recvRootDir2);
806 EXPECT_NE(nullptr, result);
807
808 result = GetFullRecvPath(filePath2, recvRootDir2);
809 EXPECT_NE(nullptr, result);
810
811 const char *filePath3 = "/test.txt";
812 const char *recvRootDir3 = "/data";
813 result = GetFullRecvPath(filePath3, recvRootDir2);
814 EXPECT_NE(nullptr, result);
815
816 result = GetFullRecvPath(filePath2, recvRootDir3);
817 EXPECT_NE(nullptr, result);
818 }
819
820 /**
821 * @tc.name: ClinetTransProxyGetDirPathTest001
822 * @tc.desc: client trans proxy get dir path test, use normal parameter.
823 * @tc.type: FUNC
824 * @tc.require:
825 */
826 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetDirPathTest001, TestSize.Level0)
827 {
828 int ret = GetDirPath(nullptr, nullptr, 0);
829 EXPECT_NE(SOFTBUS_OK, ret);
830
831 const char *fullPath1 = "";
832 char dirPath1[TEST_FILE_LENGTH] = {0};
833 ret = GetDirPath(fullPath1, nullptr, 0);
834 EXPECT_NE(SOFTBUS_OK, ret);
835
836 const char *fullPath2 = "/data/txt/";
837 ret = GetDirPath(fullPath2, nullptr, 0);
838 EXPECT_NE(SOFTBUS_OK, ret);
839
840 const char *fullPath3 = "/d/t.txt";
841 ret = GetDirPath(fullPath3, dirPath1, 0);
842 EXPECT_NE(SOFTBUS_OK, ret);
843
844 ret = GetDirPath(fullPath3, dirPath1, TEST_FILE_LENGTH);
845 EXPECT_EQ(SOFTBUS_OK, ret);
846 }
847
848 /**
849 * @tc.name: ClinetTransProxyGetAbsFullPathTest001
850 * @tc.desc: client trans proxy get path test, use normal parameter.
851 * @tc.type: FUNC
852 * @tc.require:
853 */
854 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetAbsFullPathTest001, TestSize.Level0)
855 {
856 int ret = GetAbsFullPath(nullptr, nullptr, 0);
857 EXPECT_NE(SOFTBUS_OK, ret);
858
859 char recvAbsPath[TEST_PATH_SIZE];
860 ret = GetAbsFullPath(g_testProxyFileList[0], recvAbsPath, TEST_PATH_SIZE);
861 EXPECT_EQ(SOFTBUS_OK, ret);
862
863 ret = GetAbsFullPath(g_testProxyFileList[0], recvAbsPath, TEST_FILE_LENGTH);
864 EXPECT_NE(SOFTBUS_OK, ret);
865
866 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], nullptr, TEST_PATH_SIZE);
867 EXPECT_NE(SOFTBUS_OK, ret);
868
869 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], recvAbsPath, TEST_PATH_SIZE);
870 EXPECT_EQ(SOFTBUS_OK, ret);
871
872 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], recvAbsPath, TEST_FILE_LENGTH);
873 EXPECT_NE(SOFTBUS_OK, ret);
874 }
875
876 /**
877 * @tc.name: ClinetTransProxySendListenerInfoTest001
878 * @tc.desc: client trans proxy add and del SendListenerInfo test, use normal parameter.
879 * @tc.type: FUNC
880 * @tc.require:
881 */
882 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendListenerInfoTest001, TestSize.Level0)
883 {
884 SendListenerInfo info;
885 info.sessionId = 1;
886 info.crc = 1;
887 info.channelId = 1;
888 int ret = AddSendListenerInfo(&info);
889 EXPECT_EQ(SOFTBUS_OK, ret);
890
891 int32_t sessionId = 1;
892 uint32_t seq = 0;
893 int32_t res = 0;
894 ret = ProcessFileRecvResult(sessionId, seq, res);
895 EXPECT_EQ(SOFTBUS_OK, ret);
896
897 DelSendListenerInfo(nullptr);
898
899 DelSendListenerInfo(&info);
900 }
901
902 /**
903 * @tc.name: ClinetTransProxyFileTransStartInfoTest001
904 * @tc.desc: client trans proxy pack file start info test, use normal parameter.
905 * @tc.type: FUNC
906 * @tc.require:
907 */
908 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileTransStartInfoTest001, TestSize.Level0)
909 {
910 int ret = PackFileTransStartInfo(nullptr, nullptr, TEST_FILE_TEST_TXT_FILE, nullptr);
911 EXPECT_NE(SOFTBUS_OK, ret);
912
913 uint32_t dataTest = TEST_DATA_LENGTH;
914 FileFrame fileFrame = {
915 .frameLength = 0,
916 .data = (uint8_t *)&dataTest,
917 .fileData = (uint8_t *)&dataTest,
918 };
919 SendListenerInfo info;
920 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
921 info.sessionId = 1;
922 info.channelId = 1;
923
924 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
925 EXPECT_EQ(SOFTBUS_OK, ret);
926
927 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
928 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
929 EXPECT_EQ(SOFTBUS_OK, ret);
930 }
931
932 /**
933 * @tc.name: ClinetTransProxyUnFileTransStartInfoTest001
934 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
935 * @tc.type: FUNC
936 * @tc.require:
937 */
938 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyUnFileTransStartInfoTest001, TestSize.Level0)
939 {
940 int ret = UnpackFileTransStartInfo(nullptr, nullptr, nullptr);
941 EXPECT_NE(SOFTBUS_OK, ret);
942
943 uint32_t dataTest = TEST_DATA_LENGTH;
944 FileFrame fileFrame = {
945 .frameLength = 0,
946 .data = (uint8_t *)&dataTest,
947 .fileData = (uint8_t *)&dataTest,
948 };
949 FileRecipientInfo info;
950 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
951 SingleFileInfo singleFileInfo;
952 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
953 EXPECT_NE(SOFTBUS_OK, ret);
954
955 fileFrame.frameLength = TEST_HEADER_LENGTH;
956 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
957 EXPECT_NE(SOFTBUS_OK, ret);
958
959 uint32_t data = FILE_MAGIC_NUMBER;
960 fileFrame.data = (uint8_t *)&data;
961 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
962 EXPECT_NE(SOFTBUS_OK, ret);
963
964 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
965 fileFrame.frameLength = 0;
966 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
967 EXPECT_NE(SOFTBUS_OK, ret);
968
969 fileFrame.frameLength = FRAME_DATA_SEQ_OFFSET;
970 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
971 EXPECT_EQ(SOFTBUS_OK, ret);
972
973 fileFrame.frameLength = FRAME_DATA_SEQ_OFFSET + TEST_HEADER_LENGTH;
974 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo);
975 EXPECT_EQ(SOFTBUS_OK, ret);
976 }
977
978 /**
979 * @tc.name: ClinetTransProxyFileCrcCheckSumTest001
980 * @tc.desc: client trans proxy crc check test, use normal parameter.
981 * @tc.type: FUNC
982 * @tc.require:
983 */
984 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileCrcCheckSumTest001, TestSize.Level0)
985 {
986 int ret = SendFileCrcCheckSum(nullptr);
987 EXPECT_NE(SOFTBUS_OK, ret);
988
989 SendListenerInfo info;
990 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
991 ret = SendFileCrcCheckSum(&info);
992 EXPECT_EQ(SOFTBUS_OK, ret);
993
994 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
995 ret = SendFileCrcCheckSum(&info);
996 EXPECT_NE(SOFTBUS_OK, ret);
997
998 ret = UnpackFileCrcCheckSum(nullptr, nullptr);
999 EXPECT_NE(SOFTBUS_OK, ret);
1000
1001 FileRecipientInfo fileInfo;
1002 fileInfo.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1003 FileFrame fileFrame;
1004 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1005 EXPECT_EQ(SOFTBUS_OK, ret);
1006
1007 fileInfo.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1008 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1009 EXPECT_NE(SOFTBUS_OK, ret);
1010
1011 fileFrame.frameLength = 20;
1012 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1013 EXPECT_NE(SOFTBUS_OK, ret);
1014 }
1015
1016 /**
1017 * @tc.name: ClinetTransProxyFileToFrameTest001
1018 * @tc.desc: client trans proxy send file test, use the wrong or normal parameter.
1019 * @tc.type: FUNC
1020 * @tc.require:
1021 */
1022 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileToFrameTest001, TestSize.Level0)
1023 {
1024 SendListenerInfo info;
1025 info.sessionId = 1;
1026 info.crc = 1;
1027 info.channelId = 1;
1028
1029 int ret = SendSingleFile(&info, nullptr, g_testProxyFileList[0]);
1030 EXPECT_EQ(SOFTBUS_ERR, ret);
1031
1032 ret = FileToFrameAndSendFile(nullptr, g_testProxyFileList[0], g_testProxyFileList[0]);
1033 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1034
1035 ret = FileToFrameAndSendFile(&info, g_testProxyFileList[0], nullptr);
1036 EXPECT_EQ(SOFTBUS_ERR, ret);
1037
1038 ret = FileToFrameAndSendFile(&info, nullptr, g_testProxyFileList[0]);
1039 EXPECT_EQ(SOFTBUS_ERR, ret);
1040
1041 ret = FileToFrameAndSendFile(&info, g_testProxyFileList[0], g_testProxyFileList[0]);
1042 EXPECT_EQ(SOFTBUS_ERR, ret);
1043
1044 ret = SendSingleFile(&info, g_testProxyFileList[0], g_testProxyFileList[0]);
1045 EXPECT_EQ(SOFTBUS_ERR, ret);
1046
1047 ret = SendFileList(info.channelId, g_testProxyFileList, TEST_FILE_CNT);
1048 EXPECT_EQ(SOFTBUS_ERR, ret);
1049
1050 ret = SendFileList(info.channelId, nullptr, TEST_FILE_CNT);
1051 EXPECT_EQ(SOFTBUS_ERR, ret);
1052 }
1053
1054 /**
1055 * @tc.name: ClinetTransProxyFileToFrameTest002
1056 * @tc.desc: client trans proxy file to frame test, use normal parameter.
1057 * @tc.type: FUNC
1058 * @tc.require:
1059 */
1060 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileToFrameTest002, TestSize.Level0)
1061 {
1062 SendListenerInfo sendInfo = {
1063 .channelId = 1,
1064 .sessionId = 1,
1065 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1066 };
1067
1068 int ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_destFile);
1069 EXPECT_EQ(SOFTBUS_ERR, ret);
1070
1071 ret = FileToFrame(&sendInfo, TEST_FRAME_NUMBER, g_destFile, TEST_FILE_TEST_TXT_FILE);
1072 EXPECT_EQ(SOFTBUS_ERR, ret);
1073
1074 sendInfo.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1075 ret = FileToFrame(&sendInfo, TEST_FRAME_NUMBER, g_destFile, TEST_FILE_TEST_TXT_FILE);
1076 EXPECT_EQ(SOFTBUS_ERR, ret);
1077 }
1078
1079 /**
1080 * @tc.name: ClinetTransProxyStartSendFileTest001
1081 * @tc.desc: client trans proxy start send file test, use normal parameter.
1082 * @tc.type: FUNC
1083 * @tc.require:
1084 */
1085 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyStartSendFileTest001, TestSize.Level0)
1086 {
1087 SendListenerInfo sendInfo = {
1088 .channelId = 1,
1089 .sessionId = 1,
1090 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1091 };
1092
1093 int ret = ProxyStartSendFile(&sendInfo, g_testProxyFileList, g_testProxyFileList, TEST_FILE_CNT);
1094 EXPECT_EQ(SOFTBUS_ERR, ret);
1095 }
1096
1097 /**
1098 * @tc.name: ClinetTransProxyCheckFileTest001
1099 * @tc.desc: client trans proxy start send file test, use normal parameter.
1100 * @tc.type: FUNC
1101 * @tc.require:
1102 */
1103 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCheckFileTest001, TestSize.Level0)
1104 {
1105 bool result = CheckRecvFileExist(nullptr);
1106 EXPECT_EQ(false, result);
1107
1108 result = CheckRecvFileExist(g_testProxyFileList[0]);
1109 EXPECT_EQ(false, result);
1110 }
1111
1112 /**
1113 * @tc.name: ClinetTransProxyPutToRcvListTest001
1114 * @tc.desc: client trans proxy put to file list test, use normal parameter.
1115 * @tc.type: FUNC
1116 * @tc.require:
1117 */
1118 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPutToRcvListTest001, TestSize.Level0)
1119 {
1120 int ret = PutToRecvFileList(nullptr, nullptr);
1121 EXPECT_NE(SOFTBUS_OK, ret);
1122
1123 FileRecipientInfo recipient = {
1124 .recvFileInfo.fileStatus = NODE_ERR,
1125 };
1126 const SingleFileInfo file = {0};
1127 ret = PutToRecvFileList(&recipient, &file);
1128 EXPECT_NE(SOFTBUS_OK, ret);
1129
1130 recipient.recvFileInfo.fileStatus = NODE_IDLE;
1131 ret = PutToRecvFileList(&recipient, &file);
1132 EXPECT_NE(SOFTBUS_OK, ret);
1133
1134 SingleFileInfo trueFile = {0};
1135 (void)memcpy_s(trueFile.filePath, MAX_FILE_PATH_NAME_LEN, g_recvFile, sizeof(g_recvFile));
1136 ret = PutToRecvFileList(&recipient, &trueFile);
1137 EXPECT_EQ(SOFTBUS_OK, ret);
1138 }
1139
1140 /**
1141 * @tc.name: ClinetTransProxyRecvRecipientInfoListTest001
1142 * @tc.desc: client trans proxy recv recipient info test, use normal parameter.
1143 * @tc.type: FUNC
1144 * @tc.require:
1145 */
1146 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRecvRecipientInfoListTest001, TestSize.Level0)
1147 {
1148 int32_t sessionId = 1;
1149 FileRecipientInfo *result = GetRecipientNoLock(sessionId);
1150 EXPECT_NE(nullptr, result);
1151
1152 uint32_t seq = 0;
1153 int32_t res = 0;
1154 int ret = ProcessFileSendResult(sessionId, seq, res);
1155 EXPECT_EQ(SOFTBUS_OK, ret);
1156
1157 sessionId = -1;
1158 result = GetRecipientNoLock(sessionId);
1159 EXPECT_EQ(nullptr, result);
1160
1161 ret = ProcessFileSendResult(sessionId, seq, res);
1162 EXPECT_NE(SOFTBUS_OK, ret);
1163
1164 ret = ProcessFileRecvResult(sessionId, seq, res);
1165 EXPECT_NE(SOFTBUS_OK, ret);
1166
1167 ReleaseRecipientRef(nullptr);
1168
1169 FileRecipientInfo *info = (FileRecipientInfo *)SoftBusCalloc(sizeof(FileRecipientInfo));
1170 info->objRefCount = 2,
1171 ReleaseRecipientRef(info);
1172
1173 info->objRefCount = 1;
1174 ReleaseRecipientRef(info);
1175 }
1176
1177 /**
1178 * @tc.name: ClinetTransProxyGetRecipientInfoListTest001
1179 * @tc.desc: client trans proxy get recipient info test, use normal parameter.
1180 * @tc.type: FUNC
1181 * @tc.require:
1182 */
1183 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetRecipientInfoListTest001, TestSize.Level0)
1184 {
1185 int32_t sessionId = -1;
1186 int32_t channelId = 1;
1187 FileRecipientInfo *result = GetRecipientInProcessRef(sessionId);
1188 EXPECT_EQ(nullptr, result);
1189
1190 result = GetRecipientInCreateFileRef(sessionId, channelId);
1191 EXPECT_EQ(nullptr, result);
1192
1193 sessionId = 1;
1194 result = GetRecipientInCreateFileRef(sessionId, channelId);
1195 EXPECT_NE(nullptr, result);
1196
1197 result = GetRecipientInProcessRef(sessionId);
1198 EXPECT_NE(nullptr, result);
1199 }
1200
1201 /**
1202 * @tc.name: ClinetTransProxyWriteEmptyFrameTest001
1203 * @tc.desc: client trans proxy write empty frame test, use normal parameter.
1204 * @tc.type: FUNC
1205 * @tc.require:
1206 */
1207 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyWriteEmptyFrameTest001, TestSize.Level0)
1208 {
1209 int32_t cnt = 0;
1210 int ret = WriteEmptyFrame(nullptr, cnt);
1211 EXPECT_NE(SOFTBUS_OK, ret);
1212
1213 SingleFileInfo info = {0};
1214 ret = WriteEmptyFrame(&info, cnt);
1215 EXPECT_EQ(SOFTBUS_OK, ret);
1216
1217 cnt = 1;
1218 ret = WriteEmptyFrame(&info, cnt);
1219 EXPECT_NE(SOFTBUS_OK, ret);
1220
1221 info.fileFd = g_fd;
1222 info.oneFrameLen = -1;
1223 info.fileOffset = 0;
1224 ret = WriteEmptyFrame(&info, cnt);
1225 EXPECT_NE(SOFTBUS_OK, ret);
1226
1227 info.oneFrameLen = TEST_FILE_LENGTH;
1228 ret = WriteEmptyFrame(&info, cnt);
1229 EXPECT_EQ(SOFTBUS_OK, ret);
1230 }
1231
1232 /**
1233 * @tc.name: ClinetTransProxyProcessOneFrameCRCTest001
1234 * @tc.desc: client trans proxy process one frameCRC test, use normal parameter.
1235 * @tc.type: FUNC
1236 * @tc.require:
1237 */
1238 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessOneFrameCRCTest001, TestSize.Level0)
1239 {
1240 uint32_t dataLen = 0;
1241 int ret = ProcessOneFrameCRC(nullptr, dataLen, nullptr);
1242 EXPECT_NE(SOFTBUS_OK, ret);
1243
1244 uint8_t *emptyBuff = (uint8_t *)SoftBusCalloc(TEST_FILE_SIZE);
1245 if (emptyBuff == NULL) {
1246 return;
1247 }
1248 FileFrame frame = {
1249 .frameType = TRANS_SESSION_FILE_FIRST_FRAME,
1250 .seq = TEST_SEQ32,
1251 .fileData = emptyBuff,
1252 };
1253 SingleFileInfo fileInfo = {
1254 .seq = 0,
1255 .fileFd = g_fd,
1256 .fileOffset = 0,
1257 .oneFrameLen = TEST_FILE_LENGTH,
1258 .startSeq = 0,
1259 .preStartSeq = 0,
1260 };
1261 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1262 EXPECT_NE(SOFTBUS_OK, ret);
1263
1264 frame.seq = TEST_SEQ128;
1265 fileInfo.seq = TEST_SEQ126;
1266 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1267 EXPECT_NE(SOFTBUS_OK, ret);
1268
1269 fileInfo.preStartSeq = TEST_SEQ128;
1270 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1271 EXPECT_NE(SOFTBUS_OK, ret);
1272
1273 frame.frameType = TRANS_SESSION_FILE_LAST_FRAME;
1274 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1275 EXPECT_NE(SOFTBUS_OK, ret);
1276
1277 fileInfo.startSeq = TEST_SEQ8;
1278 frame.seq = TEST_SEQ_SECOND;
1279 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1280 EXPECT_NE(SOFTBUS_OK, ret);
1281
1282 dataLen = TEST_SEQ16;
1283 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1284 EXPECT_EQ(SOFTBUS_OK, ret);
1285 SoftBusFree(emptyBuff);
1286 }
1287
1288 /**
1289 * @tc.name: ClinetTransProxyProcessOneFrameTest001
1290 * @tc.desc: client trans proxy process one frame test, use normal parameter.
1291 * @tc.type: FUNC
1292 * @tc.require:
1293 */
1294 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessOneFrameTest001, TestSize.Level0)
1295 {
1296 FileFrame frame = {
1297 .frameType = TRANS_SESSION_FILE_FIRST_FRAME,
1298 .seq = TEST_SEQ32,
1299 };
1300 uint32_t dataLen = TEST_SEQ16;
1301 int32_t crc = APP_INFO_FILE_FEATURES_SUPPORT;
1302 SingleFileInfo fileInfo = {
1303 .seq = 0,
1304 .fileFd = g_fd,
1305 .fileStatus = NODE_ERR,
1306 .fileOffset = 0,
1307 .oneFrameLen = TEST_FILE_LENGTH,
1308 .startSeq = 0,
1309 .preStartSeq = 0,
1310 };
1311 int ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo);
1312 EXPECT_NE(SOFTBUS_OK, ret);
1313
1314 fileInfo.fileStatus = NODE_IDLE;
1315 ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo);
1316 EXPECT_NE(SOFTBUS_OK, ret);
1317
1318 crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1319 ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo);
1320 EXPECT_NE(SOFTBUS_OK, ret);
1321 }
1322
1323 /**
1324 * @tc.name: ClinetTransProxyCrcCheckTest001
1325 * @tc.desc: client trans proxy process crc check test, use normal parameter.
1326 * @tc.type: FUNC
1327 * @tc.require:
1328 */
1329 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCrcCheckTest001, TestSize.Level0)
1330 {
1331 FileFrame frame = {
1332 .seq = TEST_SEQ32,
1333 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1334 };
1335 int32_t sessionId = -1;
1336
1337 int ret = ProcessCrcCheckSumData(sessionId, nullptr);
1338 EXPECT_NE(SOFTBUS_OK, ret);
1339
1340 ret = ProcessCrcCheckSumData(sessionId, &frame);
1341 EXPECT_NE(SOFTBUS_OK, ret);
1342
1343 sessionId = 1;
1344 ret = ProcessCrcCheckSumData(sessionId, &frame);
1345 EXPECT_NE(SOFTBUS_OK, ret);
1346
1347 frame.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1348 ret = ProcessCrcCheckSumData(sessionId, &frame);
1349 EXPECT_NE(SOFTBUS_OK, ret);
1350 }
1351
1352 /**
1353 * @tc.name: ClinetTransProxyFileAckRequestTest001
1354 * @tc.desc: client trans proxy file ack request test, use normal parameter.
1355 * @tc.type: FUNC
1356 * @tc.require:
1357 */
1358 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckRequestTest001, TestSize.Level0)
1359 {
1360 FileFrame frame = {
1361 .frameLength = TEST_HEADER_LENGTH,
1362 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1363 .data = nullptr,
1364 };
1365 int32_t sessionId = -1;
1366
1367 int ret = ProcessFileAckRequest(sessionId, nullptr);
1368 EXPECT_NE(SOFTBUS_OK, ret);
1369
1370 ret = ProcessFileAckRequest(sessionId, &frame);
1371 EXPECT_NE(SOFTBUS_OK, ret);
1372
1373 sessionId = 1;
1374 uint32_t dataTest = 0;
1375 dataTest = FILE_MAGIC_NUMBER;
1376 frame.data = (uint8_t *)&dataTest;
1377 ret = ProcessFileAckRequest(sessionId, &frame);
1378 EXPECT_NE(SOFTBUS_OK, ret);
1379
1380 ret = ProcessFileAckRequest(sessionId, &frame);
1381 EXPECT_NE(SOFTBUS_OK, ret);
1382 }
1383
1384 /**
1385 * @tc.name: ClinetTransProxyFileAckResponseTest001
1386 * @tc.desc: client trans proxy file ack response test, use normal parameter.
1387 * @tc.type: FUNC
1388 * @tc.require:
1389 */
1390 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckResponseTest001, TestSize.Level0)
1391 {
1392 FileFrame frame = {
1393 .frameLength = 0,
1394 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1395 .data = nullptr,
1396 };
1397 int32_t sessionId = -1;
1398
1399 int ret = ProcessFileAckResponse(sessionId, nullptr);
1400 EXPECT_NE(SOFTBUS_OK, ret);
1401
1402 ret = ProcessFileAckResponse(sessionId, &frame);
1403 EXPECT_NE(SOFTBUS_OK, ret);
1404
1405 uint32_t dataTest[TEST_FRAME_DATA_LENGTH] = {0};
1406 dataTest[TEST_FILE_MAGIC_OFFSET] = FILE_MAGIC_NUMBER;
1407 frame.data = (uint8_t *)dataTest;
1408 ret = ProcessFileAckResponse(sessionId, &frame);
1409 EXPECT_NE(SOFTBUS_OK, ret);
1410
1411 SendListenerInfo info;
1412 info.sessionId = 1;
1413 info.crc = 1;
1414 info.channelId = 1;
1415 ret = AddSendListenerInfo(&info);
1416 EXPECT_EQ(SOFTBUS_OK, ret);
1417
1418 frame.frameLength = TEST_HEADER_LENGTH;
1419 *(uint64_t *)(frame.data + FRAME_MAGIC_OFFSET) = FRAME_DATA_SEQ_OFFSET + FRAME_DATA_SEQ_OFFSET;
1420 ret = ProcessFileAckResponse(sessionId, &frame);
1421 EXPECT_NE(SOFTBUS_OK, ret);
1422
1423 sessionId = 1;
1424 ret = ProcessFileAckResponse(sessionId, &frame);
1425 EXPECT_EQ(SOFTBUS_OK, ret);
1426 }
1427
1428 /**
1429 * @tc.name: ClinetTransProxyCheckParameterTest001
1430 * @tc.desc: client trans proxy check parameter test, use normal parameter.
1431 * @tc.type: FUNC
1432 * @tc.require:
1433 */
1434 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCheckParameterTest001, TestSize.Level0)
1435 {
1436 bool result = IsValidFileString(nullptr, TEST_FILE_CNT, TEST_FILE_LENGTH);
1437 EXPECT_EQ(false, result);
1438
1439 uint32_t fileNum = 0;
1440 result = IsValidFileString(g_testProxyFileList, fileNum, TEST_FILE_LENGTH);
1441 EXPECT_EQ(false, result);
1442
1443 int32_t sessionId = 1;
1444 int ret = ProcessFileTransResult(sessionId, nullptr);
1445 EXPECT_NE(SOFTBUS_OK, ret);
1446 }
1447
1448 /**
1449 * @tc.name: ClinetTransProxyProcessFileListDataTest001
1450 * @tc.desc: client trans proxy process file list data test, use normal parameter.
1451 * @tc.type: FUNC
1452 * @tc.require:
1453 */
1454 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessFileListDataTest001, TestSize.Level0)
1455 {
1456 int32_t sessionId = 1;
1457 FileFrame frame = {
1458 .frameLength = TEST_FILE_SIZE,
1459 .data = (uint8_t *)"00010010datatest,"
1460 };
1461 int ret = ProcessFileListData(sessionId, &frame);
1462 EXPECT_NE(SOFTBUS_OK, ret);
1463 }
1464
1465 /**
1466 * @tc.name: ClinetTransProxyGetFileInfoTest001
1467 * @tc.desc: client trans proxy get file info test, use normal parameter.
1468 * @tc.type: FUNC
1469 * @tc.require:
1470 */
1471 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFileInfoTest001, TestSize.Level0)
1472 {
1473 FileFrame frame = {
1474 .frameLength = 0,
1475 .data = (uint8_t *)"00010010datatest.txt",
1476 };
1477 FileRecipientInfo info = {
1478 .fileListener.rootDir = "../test",
1479 };
1480 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1481 SingleFileInfo file;
1482 int ret = GetFileInfoByStartFrame(nullptr, nullptr, nullptr);
1483 EXPECT_NE(SOFTBUS_OK, ret);
1484
1485 ret = GetFileInfoByStartFrame(&frame, &info, &file);
1486 EXPECT_NE(SOFTBUS_OK, ret);
1487
1488 ret = memcpy_s(info.fileListener.rootDir, TEST_FILEPATH_LENGTH, g_rootDir + 1, TEST_FILEPATH_LENGTH);
1489 ASSERT_EQ(SOFTBUS_OK, ret);
1490 ret = GetFileInfoByStartFrame(&frame, &info, &file);
1491 EXPECT_NE(SOFTBUS_OK, ret);
1492
1493 frame.frameLength = FRAME_DATA_SEQ_OFFSET + 9;
1494 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1495 ret = GetFileInfoByStartFrame(&frame, &info, &file);
1496 EXPECT_EQ(SOFTBUS_OK, ret);
1497 }
1498
1499 /**
1500 * @tc.name: ClinetTransProxyWriteFrameTest001
1501 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1502 * @tc.type: FUNC
1503 * @tc.require:
1504 */
1505 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyWriteFrameTest001, TestSize.Level0)
1506 {
1507 int32_t sessionId = 1;
1508 FileFrame frame = {
1509 .frameLength = 0,
1510 .data = (uint8_t *)"00010010datatest.txt",
1511 };
1512 int ret = WriteFrameToFile(sessionId, &frame);
1513 EXPECT_NE(SOFTBUS_OK, ret);
1514
1515 frame.frameLength = TEST_DATA_LENGTH;
1516 ret = WriteFrameToFile(sessionId, &frame);
1517 EXPECT_NE(SOFTBUS_OK, ret);
1518 }
1519 } // namespace OHOS