1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <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_proxy_file_helper.c"
24 #include "client_trans_proxy_manager.c"
25 #include "client_trans_session_manager.c"
26 #include "client_trans_socket_manager.c"
27 #include "client_trans_file_listener.h"
28 #include "softbus_def.h"
29 #include "softbus_error_code.h"
30 #include "softbus_server_frame.h"
31 #include "session.h"
32 #include "softbus_app_info.h"
33 #include "softbus_access_token_test.h"
34
35 #define TEST_FILE_LENGTH 10
36 #define TEST_FILE_CNT 2
37 #define TEST_CHANNEL_ID 2
38 #define TEST_SESSION_ID 1
39 #define TEST_SEQ 1020
40 #define TEST_SEQ_SECOND 2
41 #define TEST_HEADER_LENGTH 24
42 #define TEST_HEADER_LENGTH_MIN 13
43 #define TEST_FILE_PATH "/data/file.txt"
44 #define TEST_DATA_LENGTH 6
45 #define TEST_FILE_SIZE 1000
46 #define TEST_PATH_SIZE 50
47 #define TEST_FILE_TEST_TXT_FILE 16
48 #define TEST_FILE_MAGIC_OFFSET 0
49 #define TEST_FRAME_NUMBER 2
50 #define TEST_FRAME_DATA_LENGTH 10
51 #define TEST_FILEPATH_LENGTH 4
52 #define TEST_SEQ8 8
53 #define TEST_SEQ16 16
54 #define TEST_SEQ32 32
55 #define TEST_SEQ126 126
56 #define TEST_SEQ128 128
57 #define TEST_OS_TYPE 10
58 #define TEST_PACKET_SIZE 1024
59 #define TEST_INVALID_LEN (-1)
60
61 using namespace std;
62 using namespace testing::ext;
63
64 namespace OHOS {
65 const char *g_pkgName = "dms";
66 const char *g_sessionName = "ohos.distributedschedule.dms.test";
67 const char *g_peerNetworkId = "1234567789";
68 const char *g_groupId = "123";
69 FILE *g_fileTest = nullptr;
70 FILE *g_fileSs = nullptr;
71 int32_t g_fd = 0;
72 char g_writeData[128] = "test111111111111111111111111111111111111111111111111111111111111";
73 const char *g_rootDir = "/data";
74 const char *g_destFile = "test.txt";
75 char g_recvFile[] = "/data/test.txt";
76 const char *g_sessionKey = "www.test.com";
77
78 SessionAttribute g_attr = {
79 .dataType = TYPE_MESSAGE,
80 .linkTypeNum = LINK_TYPE_WIFI_WLAN_5G,
81 };
82
83 SessionParam g_param = {
84 .sessionName = g_sessionName,
85 .peerSessionName = g_sessionName,
86 .peerDeviceId = g_peerNetworkId,
87 .groupId = g_groupId,
88 .attr = &g_attr,
89 };
90
91 const char *g_testProxyFileList[] = {
92 "/data/test.txt",
93 "/data/ss.txt",
94 };
95
96 const char *g_fileList[] = {
97 "/data/data/test.txt",
98 "/path/max/length/512/"
99 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
100 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
101 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
102 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
103 "111111111111111111111111111111111111111111111111111",
104 };
105
OnSessionOpened(int32_t sessionId,int32_t result)106 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
107 {
108 return SOFTBUS_OK;
109 }
110
OnSessionClosed(int32_t sessionId)111 static void OnSessionClosed(int32_t sessionId)
112 {
113 }
114
OnBytesReceived(int32_t sessionId,const void * data,unsigned int len)115 static void OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)
116 {
117 }
118
OnMessageReceived(int32_t sessionId,const void * data,unsigned int len)119 static void OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)
120 {
121 }
122
123 static ISessionListener g_sessionlistener = {
124 .OnSessionOpened = OnSessionOpened,
125 .OnSessionClosed = OnSessionClosed,
126 .OnBytesReceived = OnBytesReceived,
127 .OnMessageReceived = OnMessageReceived,
128 };
129
OnSendFileProcess(int32_t sessionId,uint64_t bytesUpload,uint64_t bytesTotal)130 static int32_t OnSendFileProcess(int32_t sessionId, uint64_t bytesUpload, uint64_t bytesTotal)
131 {
132 return SOFTBUS_OK;
133 }
134
OnSendFileFinished(int32_t sessionId,const char * firstFile)135 static int32_t OnSendFileFinished(int32_t sessionId, const char *firstFile)
136 {
137 return SOFTBUS_OK;
138 }
139
OnFileTransError(int32_t sessionId)140 void OnFileTransError(int32_t sessionId)
141 {
142 return;
143 }
144
OnReceiveFileStarted(int32_t sessionId,const char * files,int32_t fileCnt)145 static int32_t OnReceiveFileStarted(int32_t sessionId, const char *files, int32_t fileCnt)
146 {
147 return SOFTBUS_OK;
148 }
149
OnReceiveFileProcess(int32_t sessionId,const char * firstFile,uint64_t bytesUpload,uint64_t bytesTotal)150 static int32_t OnReceiveFileProcess(int32_t sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal)
151 {
152 return SOFTBUS_OK;
153 }
OnReceiveFileFinished(int32_t sessionId,const char * files,int32_t fileCnt)154 static void OnReceiveFileFinished(int32_t sessionId, const char *files, int32_t fileCnt)
155 {
156 return;
157 }
158
159 const IFileSendListener g_listener = {
160 .OnSendFileProcess = OnSendFileProcess,
161 .OnSendFileFinished = OnSendFileFinished,
162 .OnFileTransError = OnFileTransError,
163 };
164
165 const IFileReceiveListener g_fileRecvListener = {
166 .OnReceiveFileStarted = OnReceiveFileStarted,
167 .OnReceiveFileProcess = OnReceiveFileProcess,
168 .OnReceiveFileFinished = OnReceiveFileFinished,
169 .OnFileTransError = OnFileTransError,
170 };
171
172 class ClientTransProxyFileManagerTest : public testing::Test {
173 public:
ClientTransProxyFileManagerTest()174 ClientTransProxyFileManagerTest() {}
~ClientTransProxyFileManagerTest()175 ~ClientTransProxyFileManagerTest() {}
176 static void SetUpTestCase(void);
177 static void TearDownTestCase(void);
SetUp()178 void SetUp() override {}
TearDown()179 void TearDown() override {}
180 };
181
SetUpTestCase(void)182 void ClientTransProxyFileManagerTest::SetUpTestCase(void)
183 {
184 SetAccessTokenPermission("dsoftbusTransTest");
185 g_fileTest = fopen(g_testProxyFileList[0], "w+");
186 EXPECT_NE(g_fileTest, nullptr);
187
188 g_fileSs = fopen(g_testProxyFileList[1], "w+");
189 EXPECT_NE(g_fileSs, nullptr);
190 int32_t ret = fprintf(g_fileSs, "%s", "Hello world!\n");
191 EXPECT_LT(0, ret);
192 g_fd = open(TEST_FILE_PATH, O_RDWR | O_CREAT, S_IRWXU);
193 EXPECT_NE(g_fd, -1);
194 write(g_fd, g_writeData, sizeof(g_writeData));
195 ClientTransProxyListInit();
196 }
197
TearDownTestCase(void)198 void ClientTransProxyFileManagerTest::TearDownTestCase(void)
199 {
200 int32_t ret = fclose(g_fileTest);
201 EXPECT_EQ(ret, 0);
202 g_fileTest = nullptr;
203 ret = fclose(g_fileSs);
204 EXPECT_EQ(ret, 0);
205 g_fileSs = nullptr;
206 close(g_fd);
207 g_fd = -1;
208 ret = remove(g_testProxyFileList[0]);
209 EXPECT_EQ(SOFTBUS_OK, ret);
210
211 ret = remove(g_testProxyFileList[1]);
212 EXPECT_EQ(SOFTBUS_OK, ret);
213
214 ret = remove(TEST_FILE_PATH);
215 EXPECT_EQ(SOFTBUS_OK, ret);
216 ClinetTransProxyFileManagerDeinit();
217 ClientTransProxyListDeinit();
218 }
219
220 /**
221 * @tc.name: ClinetTransProxySendFileTest001
222 * @tc.desc: client trans proxy send file test, use the wrong parameter.
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendFileTest001, TestSize.Level1)
227 {
228 int32_t channelId = 1;
229 int32_t ret = ProxyChannelSendFile(channelId, g_testProxyFileList, g_testProxyFileList, 0);
230 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
231
232 ret = ProxyChannelSendFile(channelId, nullptr, g_testProxyFileList, TEST_FILE_CNT);
233 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
234
235 const char *proxyNullFileList[] = {
236 nullptr,
237 "/path/max/length/512",
238 };
239 ret = ProxyChannelSendFile(channelId, proxyNullFileList, g_testProxyFileList, TEST_FILE_CNT);
240 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
241
242 const char *proxyZeroLileList[] = {
243 "",
244 "/path/max/length/512",
245 };
246 ret = ProxyChannelSendFile(channelId, proxyZeroLileList, g_testProxyFileList, TEST_FILE_CNT);
247 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
248
249 const char *proxyLengthFileList[] = {
250 "/path/max/length/512",
251 "/path/max/length/512/"
252 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
253 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
254 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
255 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
256 "111111111111111111111111111111111111111111111111111",
257 };
258 ret = ProxyChannelSendFile(channelId, proxyLengthFileList, g_testProxyFileList, TEST_FILE_CNT);
259 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
260
261 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, nullptr, TEST_FILE_CNT);
262 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
263
264 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, proxyNullFileList, TEST_FILE_CNT);
265 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
266
267 ret = ProxyChannelSendFile(channelId, g_testProxyFileList, g_testProxyFileList, TEST_FILE_CNT);
268 EXPECT_EQ(SOFTBUS_LOCK_ERR, ret);
269 }
270
271 /**
272 * @tc.name: ClinetTransRecvFileFrameDataTest001
273 * @tc.desc: clent trans recv file frame data test, use the wrong parameter.
274 * @tc.type: FUNC
275 * @tc.require:
276 */
277 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransRecvFileFrameDataTest001, TestSize.Level1)
278 {
279 int32_t channelId = 1;
280 int32_t sessionId = 1;
281 int32_t ret = ProcessRecvFileFrameData(sessionId, channelId, nullptr);
282 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
283
284 ChannelInfo *channel = (ChannelInfo *)SoftBusMalloc(sizeof(ChannelInfo));
285 ASSERT_TRUE(channel != nullptr);
286 channel->channelId = 1;
287 channel->isEncrypt = 0;
288 channel->linkType = LANE_BR;
289 channel->sessionKey = (char *)g_sessionKey;
290 channel->osType = OH_TYPE;
291 channel->keyLen = TEST_SEQ32;
292 ret = ClientTransProxyAddChannelInfo(ClientTransProxyCreateChannelInfo(channel));
293 EXPECT_EQ(SOFTBUS_OK, ret);
294 SoftBusFree(channel);
295 FileFrame fileFrame;
296 fileFrame.frameLength = PROXY_BR_MAX_PACKET_SIZE + 1;
297 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
298 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
299
300 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
301 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
302 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
303 ret = ClientTransProxyDelChannelInfo(1);
304 EXPECT_EQ(SOFTBUS_OK, ret);
305 }
306
307 /**
308 * @tc.name: ClientTransProxyCreateChannelInfoTest001
309 * @tc.desc: clent trans recv file frame data test, use the wrong parameter.
310 * @tc.type: FUNC
311 * @tc.require:
312 */
313 HWTEST_F(ClientTransProxyFileManagerTest, ClientTransProxyCreateChannelInfoTest001, TestSize.Level1)
314 {
315 ChannelInfo *channel = (ChannelInfo *)SoftBusMalloc(sizeof(ChannelInfo));
316 ASSERT_TRUE(channel != nullptr);
317 channel->channelId = 1;
318 channel->isEncrypt = 0;
319 channel->linkType = LANE_BR;
320 channel->sessionKey = (char *)g_sessionKey;
321 channel->osType = OH_TYPE;
322 channel->isD2D = 1;
323 channel->dataLen = 0;
324 channel->isServer = 1;
325 channel->pagingNonce = (char *)g_sessionKey;
326 channel->pagingSessionkey = (char *)g_sessionKey;
327 channel->extraData = (char *)g_sessionKey;
328 channel->pagingAccountId = (char *)g_sessionKey;
329 channel->keyLen = TEST_SEQ32;
330 ClientProxyChannelInfo *info = ClientTransProxyCreateChannelInfo(channel);
331 ASSERT_TRUE(info != nullptr);
332 SoftBusFree(info);
333 channel->dataLen = EXTRA_DATA_MAX_LEN + 1;
334 channel->isServer = 0;
335 ClientProxyChannelInfo *testInfo = ClientTransProxyCreateChannelInfo(channel);
336 ASSERT_TRUE(testInfo != nullptr);
337 SoftBusFree(testInfo);
338 channel->dataLen = EXTRA_DATA_MAX_LEN - 1;
339 ClientProxyChannelInfo *testInfoTest = ClientTransProxyCreateChannelInfo(channel);
340 ASSERT_TRUE(testInfoTest != nullptr);
341 SoftBusFree(testInfoTest);
342 SoftBusFree(channel);
343 }
344
345 /**
346 * @tc.name: ClinetTransRecvFileFrameDataTest002
347 * @tc.desc: client trans recv file frame data test, use the wrong parameter.
348 * @tc.type: FUNC
349 * @tc.require:
350 */
351 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransRecvFileFrameDataTest002, TestSize.Level1)
352 {
353 int32_t channelId = 1;
354 int32_t sessionId = 1;
355
356 ChannelInfo *channel = (ChannelInfo *)SoftBusMalloc(sizeof(ChannelInfo));
357 ASSERT_TRUE(channel != nullptr);
358 channel->channelId = 1;
359 channel->isEncrypt = 0;
360 channel->linkType = LANE_BR;
361 channel->sessionKey = (char *)g_sessionKey;
362 channel->keyLen = TEST_SEQ32;
363 int32_t ret = ClientTransProxyAddChannelInfo(ClientTransProxyCreateChannelInfo(channel));
364 EXPECT_EQ(SOFTBUS_OK, ret);
365 SoftBusFree(channel);
366 FileFrame fileFrame;
367 fileFrame.frameLength = PROXY_BR_MAX_PACKET_SIZE - 1;
368
369 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
370 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
371 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
372
373 fileFrame.frameType = TRANS_SESSION_FILE_ONGOINE_FRAME;
374 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
375 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
376
377 fileFrame.frameType = TRANS_SESSION_FILE_ONLYONE_FRAME;
378 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
379 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
380
381 fileFrame.frameType = TRANS_SESSION_FILE_LAST_FRAME;
382 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
383 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
384
385 fileFrame.frameType = TRANS_SESSION_FILE_ACK_REQUEST_SENT;
386 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
387 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
388
389 fileFrame.frameType = TRANS_SESSION_FILE_ACK_RESPONSE_SENT;
390 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
391 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
392
393 fileFrame.frameType = TRANS_SESSION_FILE_CRC_CHECK_FRAME;
394 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
395 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
396
397 fileFrame.frameType = TRANS_SESSION_FILE_RESULT_FRAME;
398 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
399 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
400
401 fileFrame.frameType = TRANS_SESSION_FILE_ALLFILE_SENT;
402 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
403 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
404
405 fileFrame.frameType = -1;
406 ret = ProcessRecvFileFrameData(sessionId, channelId, &fileFrame);
407 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
408 ret = ClientTransProxyDelChannelInfo(1);
409 EXPECT_EQ(SOFTBUS_OK, ret);
410 }
411
412 /**
413 * @tc.name: ClinetTransProxyFileManagerInitDataTest001
414 * @tc.desc: client trans proxy file manager init data test, use the wrong or normal parameter.
415 * @tc.type: FUNC
416 * @tc.require:
417 */
418 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileManagerInitDataTest001, TestSize.Level1)
419 {
420 int32_t ret = ClinetTransProxyFileManagerInit();
421 EXPECT_EQ(SOFTBUS_OK, ret);
422
423 int32_t channelId = 1;
424 uint32_t seq = TEST_SEQ;
425 int32_t result = 0;
426 uint32_t side = 0;
427 ret = SendFileTransResult(channelId, seq, result, side);
428 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
429
430 uint32_t data = 0;
431 const uint8_t *data1 = (const uint8_t *)&data;
432 uint32_t len = TEST_HEADER_LENGTH;
433 ret = UnpackFileTransResultFrame(data1, len, nullptr, &result, &side);
434 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
435
436 ret = UnpackFileTransResultFrame(nullptr, len, &seq, &result, &side);
437 EXPECT_NE(SOFTBUS_OK, ret);
438
439 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, &side);
440 EXPECT_NE(SOFTBUS_OK, ret);
441
442 data = FILE_MAGIC_NUMBER;
443 const uint8_t *data2 = (const uint8_t *)&data;
444 ret = UnpackFileTransResultFrame(data2, len, &seq, &result, &side);
445 EXPECT_NE(SOFTBUS_OK, ret);
446 }
447
448 /**
449 * @tc.name: ClinetTransProxyGetSessionFileLockTest001
450 * @tc.desc: client trans proxy get session file lock test, use the wrong or normal parameter.
451 * @tc.type: FUNC
452 * @tc.require:
453 */
454 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetSessionFileLockTest001, TestSize.Level1)
455 {
456 int32_t channelId = 1;
457 ProxyFileMutexLock *sessionLock = GetSessionFileLock(channelId);
458 EXPECT_NE(nullptr, sessionLock);
459
460 sessionLock = GetSessionFileLock(channelId);
461 EXPECT_NE(nullptr, sessionLock);
462
463 DelSessionFileLock(nullptr);
464 sessionLock->count = 1;
465 DelSessionFileLock(sessionLock);
466
467 sessionLock->count = 2;
468 DelSessionFileLock(sessionLock);
469 }
470
471 /**
472 * @tc.name: ClinetTransProxyCreateSendListenerInfoTest001
473 * @tc.desc: client trans proxy create send listener info test, use the wrong or normal parameter.
474 * @tc.type: FUNC
475 * @tc.require:
476 */
477 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCreateSendListenerInfoTest001, TestSize.Level1)
478 {
479 int32_t ret = CreateSessionServer(g_pkgName, g_sessionName, &g_sessionlistener);
480 ASSERT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
481
482 int32_t sessionId = 1;
483 SessionEnableStatus isEnabled = ENABLE_STATUS_INIT;
484
485 ret = ClientAddSession(&g_param, &sessionId, &isEnabled);
486 ASSERT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
487
488 SendListenerInfo *sendListenerInfo;
489 ret = CreateSendListenerInfo(&sendListenerInfo, TEST_CHANNEL_ID, 0);
490 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
491
492 int32_t channelId = 1;
493 int32_t osType = TEST_OS_TYPE;
494 SessionInfo sessionInfo;
495 sessionInfo.sessionId = sessionId;
496 sessionInfo.channelId = channelId;
497 sessionInfo.channelType = CHANNEL_TYPE_PROXY;
498 ret = TransClientInit();
499 ASSERT_EQ(SOFTBUS_OK, ret);
500 ret = AddSession(g_sessionName, &sessionInfo);
501 ASSERT_EQ(SOFTBUS_TRANS_SESSIONSERVER_NOT_CREATED, ret);
502
503 ret = TransSetFileSendListener(g_sessionName, &g_listener);
504 ASSERT_EQ(SOFTBUS_OK, ret);
505
506 ret = TransSetFileReceiveListener(g_sessionName, &g_fileRecvListener, g_rootDir);
507 ASSERT_EQ(SOFTBUS_OK, ret);
508
509 ret = CreateSendListenerInfo(&sendListenerInfo, channelId, 0);
510 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
511
512 ret = CreateSendListenerInfo(&sendListenerInfo, channelId, 0);
513 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
514
515 ret = AddSendListenerInfo(nullptr);
516 EXPECT_NE(SOFTBUS_OK, ret);
517
518 FileRecipientInfo *result = CreateNewRecipient(sessionId, channelId, osType);
519 EXPECT_EQ(nullptr, result);
520 }
521
522 /**
523 * @tc.name: ClinetTransProxyGetAndCheckFileSizeTest001
524 * @tc.desc: improve branch coverage, use the wrong or normal parameter.
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetAndCheckFileSizeTest001, TestSize.Level1)
529 {
530 uint64_t fileSize = 0;
531 uint64_t frameNum = 0;
532 int32_t ret =
533 GetAndCheckFileSize(nullptr, &fileSize, &frameNum, APP_INFO_FILE_FEATURES_SUPPORT, PROXY_BLE_MAX_PACKET_SIZE);
534 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
535
536 ret = GetAndCheckFileSize(
537 g_testProxyFileList[0], &fileSize, &frameNum, APP_INFO_FILE_FEATURES_SUPPORT, PROXY_BLE_MAX_PACKET_SIZE);
538 EXPECT_EQ(SOFTBUS_OK, ret);
539
540 ret = GetAndCheckFileSize(
541 g_testProxyFileList[1], &fileSize, &frameNum, APP_INFO_FILE_FEATURES_NO_SUPPORT, PROXY_BLE_MAX_PACKET_SIZE);
542 EXPECT_EQ(SOFTBUS_OK, ret);
543 }
544
545 /**
546 * @tc.name: ClinetTransProxySendOneFrameTest001
547 * @tc.desc: client trans proxy send one frame test, use the wrong or normal parameter.
548 * @tc.type: FUNC
549 * @tc.require:
550 */
551 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendOneFrameTest001, TestSize.Level1)
552 {
553 SendListenerInfo info;
554 info.sessionId = TEST_SESSION_ID;
555 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
556 info.channelId = TEST_CHANNEL_ID;
557
558 FileFrame fileFrame = {
559 .frameType = TRANS_SESSION_BYTES,
560 .data = nullptr,
561 };
562 int32_t ret = SendOneFrame(nullptr, &fileFrame);
563 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
564
565 ret = SendOneFrame(&info, &fileFrame);
566 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
567
568 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
569 uint32_t dataTest = TEST_DATA_LENGTH;
570 fileFrame.data = (uint8_t *)&dataTest;
571 ret = SendOneFrame(&info, &fileFrame);
572 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
573
574 fileFrame.frameType = TRANS_SESSION_FILE_FIRST_FRAME;
575 ret = SendOneFrame(&info, &fileFrame);
576 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
577
578 ret = SendOneFrameFront(nullptr, fileFrame.frameType);
579 EXPECT_NE(SOFTBUS_OK, ret);
580
581 SendListenerInfo infoMiddle;
582 infoMiddle.sessionId = 1;
583 infoMiddle.channelId = 1;
584 infoMiddle.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
585 ret = SendOneFrameMiddle(nullptr, TRANS_SESSION_FILE_ONGOINE_FRAME);
586 EXPECT_NE(SOFTBUS_OK, ret);
587
588 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
589 EXPECT_EQ(SOFTBUS_OK, ret);
590
591 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
592 EXPECT_EQ(SOFTBUS_OK, ret);
593
594 infoMiddle.crc = APP_INFO_FILE_FEATURES_SUPPORT;
595 infoMiddle.seq = 0;
596 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_BYTES);
597 EXPECT_EQ(SOFTBUS_OK, ret);
598
599 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
600 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
601
602 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
603 EXPECT_EQ(SOFTBUS_OK, ret);
604
605 ret = SendOneFrameFront(&infoMiddle, TRANS_SESSION_FILE_FIRST_FRAME);
606 EXPECT_EQ(SOFTBUS_OK, ret);
607
608 infoMiddle.seq = TEST_SEQ;
609 ret = SendOneFrameMiddle(&infoMiddle, TRANS_SESSION_FILE_ONGOINE_FRAME);
610 EXPECT_EQ(SOFTBUS_OK, ret);
611 }
612
613 /**
614 * @tc.name: ClinetTransProxySendOneFrameTest002
615 * @tc.desc: client trans proxy send one frame test, use the wrong or normal parameter.
616 * @tc.type: FUNC
617 * @tc.require:
618 */
619 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendOneFrameTest002, TestSize.Level1)
620 {
621 SendListenerInfo *infoRear = (SendListenerInfo *)SoftBusCalloc(sizeof(SendListenerInfo));
622 infoRear->sessionId = 1;
623 infoRear->channelId = 1;
624 infoRear->crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
625 int32_t ret = SendOneFrameRear(nullptr, TRANS_SESSION_BYTES);
626 EXPECT_NE(SOFTBUS_OK, ret);
627
628 ret = SendOneFrameRear(infoRear, TRANS_SESSION_BYTES);
629 EXPECT_EQ(SOFTBUS_OK, ret);
630
631 infoRear->crc = APP_INFO_FILE_FEATURES_SUPPORT;
632 ret = SendOneFrameRear(infoRear, TRANS_SESSION_FILE_ONLYONE_FRAME);
633 EXPECT_EQ(SOFTBUS_OK, ret);
634
635 infoRear->waitSeq = 0;
636 ret = SendOneFrameRear(infoRear, TRANS_SESSION_FILE_LAST_FRAME);
637 EXPECT_EQ(SOFTBUS_OK, ret);
638
639 infoRear->waitSeq = TEST_SEQ;
640 ret = SendOneFrameRear(infoRear, TRANS_SESSION_FILE_LAST_FRAME);
641 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
642
643 SoftBusFree(infoRear);
644 }
645
646 /**
647 * @tc.name: ClinetTransProxyFileRecipientInfoTest001
648 * @tc.desc: client trans proxy file recipient info test, use the wrong or normal parameter.
649 * @tc.type: FUNC
650 * @tc.require:
651 */
652 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileRecipientInfoTest001, TestSize.Level1)
653 {
654 FileRecipientInfo info;
655 info.recvFileInfo.fileFd = -2;
656 info.recvState = TRANS_FILE_RECV_ERR_STATE;
657 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
658 info.channelId = 1;
659 info.recvFileInfo.seq = TEST_SEQ;
660 info.fileListener.recvListener.OnFileTransError = nullptr;
661 ClearRecipientResources(&info);
662
663 info.fileListener.recvListener.OnFileTransError = OnFileTransError;
664 SetRecipientRecvState(&info, TRANS_FILE_RECV_IDLE_STATE);
665 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
666 ClearRecipientResources(&info);
667
668 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
669 ClearRecipientResources(&info);
670
671 info.recvState = TRANS_FILE_RECV_IDLE_STATE;
672 SetRecipientRecvState(&info, TRANS_FILE_RECV_IDLE_STATE);
673 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
674 SetRecipientRecvState(&info, TRANS_FILE_RECV_PROCESS_STATE);
675 EXPECT_EQ(info.recvFileInfo.fileFd, INVALID_FD);
676 ClearRecipientResources(&info);
677
678 info.recvFileInfo.fileFd = INVALID_FD;
679 ClearRecipientResources(&info);
680 }
681
682 /**
683 * @tc.name: ClinetTransProxyFileAckReqAndResDataTest001
684 * @tc.desc: client trans proxy file ack req and res data test, use the wrong or normal parameter.
685 * @tc.type: FUNC
686 * @tc.require:
687 */
688 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckReqAndResDataTest001, TestSize.Level1)
689 {
690 int32_t channelId = 1;
691 uint32_t startSeq = TEST_SEQ;
692 uint32_t value = 0;
693 int32_t ret = SendFileAckReqAndResData(channelId, startSeq, value, CHANNEL_TYPE_PROXY);
694 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
695
696 FileFrame frame;
697 frame.frameLength = 0;
698 frame.data = nullptr;
699 uint64_t dataTest = 0;
700 ret = UnpackAckReqAndResData(nullptr, &startSeq, &value);
701 EXPECT_NE(SOFTBUS_OK, ret);
702
703 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
704 EXPECT_NE(SOFTBUS_OK, ret);
705
706 frame.data = (uint8_t *)&dataTest;
707 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
708 EXPECT_NE(SOFTBUS_OK, ret);
709
710 frame.frameLength = TEST_HEADER_LENGTH;
711 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
712 EXPECT_NE(SOFTBUS_OK, ret);
713
714 dataTest = FILE_MAGIC_NUMBER;
715 frame.data = (uint8_t *)&dataTest;
716 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
717 EXPECT_EQ(SOFTBUS_OK, ret);
718 }
719
720 /**
721 * @tc.name: ClinetTransProxyPackFileDataTest001
722 * @tc.desc: client trans proxy pack file data test, use the wrong parameter.
723 * @tc.type: FUNC
724 * @tc.require:
725 */
726 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataTest001, TestSize.Level1)
727 {
728 FileFrame fileFrame = {
729 .frameType = TRANS_SESSION_BYTES,
730 .data = nullptr,
731 };
732 uint64_t readLength = TEST_FILE_LENGTH;
733 uint64_t fileOffset = 0;
734 SendListenerInfo info;
735 info.fd = g_fd;
736 info.packetSize = PROXY_BLE_MAX_PACKET_SIZE;
737 uint32_t seq = TEST_SEQ;
738 int64_t len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
739 EXPECT_TRUE(len == -1);
740
741 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
742 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
743 EXPECT_TRUE(len == -1);
744
745 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
746 EXPECT_TRUE(len == -1);
747
748 uint32_t dataTest = TEST_DATA_LENGTH;
749 fileFrame.data = (uint8_t *)&dataTest;
750 fileFrame.fileData = (uint8_t *)&dataTest;
751 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
752 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
753 EXPECT_EQ(TEST_FILE_LENGTH, len);
754
755 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
756 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
757 EXPECT_EQ(TEST_FILE_LENGTH, len);
758
759 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
760 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, len);
761 }
762
763 /**
764 * @tc.name: ClinetTransProxyPackFileDataFrameTest001
765 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
766 * @tc.type: FUNC
767 * @tc.require:
768 */
769 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataFrameTest001, TestSize.Level1)
770 {
771 uint32_t dataTest = TEST_DATA_LENGTH;
772 FileFrame fileFrame = {
773 .magic = FILE_MAGIC_NUMBER,
774 .frameType = TRANS_SESSION_BYTES,
775 .frameLength = 0,
776 .data = (uint8_t *)&dataTest,
777 .fileData = (uint8_t *)&dataTest,
778 };
779
780 FileRecipientInfo info = {
781 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
782 .osType = OH_TYPE,
783 };
784
785 uint32_t fileDataLen = 0;
786 int32_t ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
787 EXPECT_NE(SOFTBUS_OK, ret);
788
789 fileFrame.frameLength = TEST_HEADER_LENGTH;
790 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
791 EXPECT_EQ(SOFTBUS_OK, ret);
792
793 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
794 info.osType = OH_TYPE;
795 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
796 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
797
798 fileFrame.magic = 0;
799 fileFrame.frameLength = TEST_HEADER_LENGTH_MIN;
800 ret = UnpackFileDataFrame(&info, &fileFrame, &fileDataLen);
801 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
802 }
803
804 /**
805 * @tc.name: ClinetTransProxyRetransFileFrameTest001
806 * @tc.desc: client trans proxy retrans file frame test, use normal parameter.
807 * @tc.type: FUNC
808 * @tc.require:
809 */
810 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRetransFileFrameTest001, TestSize.Level1)
811 {
812 SendListenerInfo info = {
813 .channelId = 1,
814 .fd = g_fd,
815 .fileSize = TEST_FILE_SIZE,
816 .frameNum = 1,
817 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
818 };
819 int32_t ret = RetransFileFrameBySeq(nullptr, TEST_SEQ);
820 EXPECT_NE(SOFTBUS_OK, ret);
821
822 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
823 EXPECT_EQ(SOFTBUS_OK, ret);
824
825 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
826 int32_t seq = TEST_SEQ_SECOND;
827 ret = RetransFileFrameBySeq(&info, seq);
828 EXPECT_NE(SOFTBUS_OK, ret);
829
830 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
831 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
832 }
833
834 /**
835 * @tc.name: ClinetTransProxyAckResponseDataHandleTest001
836 * @tc.desc: client trans proxy handle response data test, use normal parameter.
837 * @tc.type: FUNC
838 * @tc.require:
839 */
840 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyAckResponseDataHandleTest001, TestSize.Level1)
841 {
842 SendListenerInfo info = {
843 .fileSize = TEST_FILE_SIZE,
844 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
845 };
846 uint32_t len = 0;
847 int32_t ret = AckResponseDataHandle(&info, nullptr, len);
848 EXPECT_EQ(SOFTBUS_OK, ret);
849
850 const char *data = "test_data";
851 ret = AckResponseDataHandle(&info, data, len);
852 EXPECT_EQ(SOFTBUS_OK, ret);
853
854 len = sizeof(AckResponseData);
855 ret = AckResponseDataHandle(&info, data, len);
856 EXPECT_EQ(SOFTBUS_OK, ret);
857
858 AckResponseData ackResponseData = {
859 .startSeq = FILE_SEND_ACK_RESULT_SUCCESS,
860 .seqResult = TEST_SEQ_SECOND,
861 };
862 const char *dataTest = reinterpret_cast<const char*>(&ackResponseData);
863 ret = AckResponseDataHandle(&info, dataTest, len);
864 EXPECT_EQ(SOFTBUS_OK, ret);
865 }
866
867 /**
868 * @tc.name: ClinetTransProxyGetFullRecvPathTest001
869 * @tc.desc: client trans proxy get full recv path test, use normal parameter.
870 * @tc.type: FUNC
871 * @tc.require:
872 */
873 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFullRecvPathTest001, TestSize.Level1)
874 {
875 char *result = GetFullRecvPath(nullptr, nullptr);
876 EXPECT_EQ(nullptr, result);
877 const char *filePath1 = "";
878 const char *recvRootDir1 = "";
879
880 result = GetFullRecvPath(filePath1, recvRootDir1);
881 EXPECT_NE(nullptr, result);
882
883 const char *filePath2 = "/test.txt";
884 result = GetFullRecvPath(filePath2, recvRootDir1);
885 EXPECT_NE(nullptr, result);
886
887 const char *recvRootDir2 = "/data/";
888 result = GetFullRecvPath(filePath1, recvRootDir2);
889 EXPECT_NE(nullptr, result);
890
891 result = GetFullRecvPath(filePath2, recvRootDir2);
892 EXPECT_NE(nullptr, result);
893
894 const char *filePath3 = "/test.txt";
895 const char *recvRootDir3 = "/data";
896 result = GetFullRecvPath(filePath3, recvRootDir2);
897 EXPECT_NE(nullptr, result);
898
899 result = GetFullRecvPath(filePath2, recvRootDir3);
900 EXPECT_NE(nullptr, result);
901 }
902
903 /**
904 * @tc.name: ClinetTransProxyGetDirPathTest001
905 * @tc.desc: client trans proxy get dir path test, use normal parameter.
906 * @tc.type: FUNC
907 * @tc.require:
908 */
909 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetDirPathTest001, TestSize.Level1)
910 {
911 int32_t ret = GetDirPath(nullptr, nullptr, 0);
912 EXPECT_NE(SOFTBUS_OK, ret);
913
914 const char *fullPath1 = "";
915 char dirPath1[TEST_FILE_LENGTH] = {0};
916 ret = GetDirPath(fullPath1, nullptr, 0);
917 EXPECT_NE(SOFTBUS_OK, ret);
918
919 const char *fullPath2 = "/data/txt/";
920 ret = GetDirPath(fullPath2, nullptr, 0);
921 EXPECT_NE(SOFTBUS_OK, ret);
922
923 const char *fullPath3 = "/d/t.txt";
924 ret = GetDirPath(fullPath3, dirPath1, 0);
925 EXPECT_NE(SOFTBUS_OK, ret);
926
927 ret = GetDirPath(fullPath3, dirPath1, TEST_FILE_LENGTH);
928 EXPECT_EQ(SOFTBUS_OK, ret);
929 }
930
931 /**
932 * @tc.name: ClinetTransProxyGetAbsFullPathTest001
933 * @tc.desc: client trans proxy get path test, use normal parameter.
934 * @tc.type: FUNC
935 * @tc.require:
936 */
937 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetAbsFullPathTest001, TestSize.Level1)
938 {
939 int32_t ret = GetAbsFullPath(nullptr, nullptr, 0);
940 EXPECT_NE(SOFTBUS_OK, ret);
941
942 char recvAbsPath[TEST_PATH_SIZE];
943 ret = GetAbsFullPath(g_testProxyFileList[0], recvAbsPath, TEST_PATH_SIZE);
944 EXPECT_EQ(SOFTBUS_OK, ret);
945
946 ret = GetAbsFullPath(g_testProxyFileList[0], recvAbsPath, TEST_FILE_LENGTH);
947 EXPECT_NE(SOFTBUS_OK, ret);
948
949 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], nullptr, TEST_PATH_SIZE);
950 EXPECT_NE(SOFTBUS_OK, ret);
951
952 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], recvAbsPath, TEST_PATH_SIZE);
953 EXPECT_EQ(SOFTBUS_OK, ret);
954
955 ret = CreateDirAndGetAbsPath(g_testProxyFileList[0], recvAbsPath, TEST_FILE_LENGTH);
956 EXPECT_NE(SOFTBUS_OK, ret);
957 }
958
959 /**
960 * @tc.name: ClinetTransProxySendListenerInfoTest001
961 * @tc.desc: client trans proxy add and del SendListenerInfo test, use normal parameter.
962 * @tc.type: FUNC
963 * @tc.require:
964 */
965 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxySendListenerInfoTest001, TestSize.Level1)
966 {
967 SendListenerInfo *info = (SendListenerInfo *)SoftBusCalloc(sizeof(SendListenerInfo));
968 EXPECT_TRUE(info != nullptr);
969 info->sessionId = 1;
970 info->crc = 1;
971 info->channelId = 1;
972 int32_t ret = AddSendListenerInfo(info);
973 EXPECT_EQ(SOFTBUS_OK, ret);
974
975 int32_t sessionId = 1;
976 uint32_t seq = 0;
977 int32_t res = 0;
978 ret = ProcessFileRecvResult(sessionId, seq, res);
979 EXPECT_EQ(SOFTBUS_OK, ret);
980
981 DelSendListenerInfo(nullptr);
982
983 DelSendListenerInfo(info);
984 }
985
986 /**
987 * @tc.name: ClinetTransProxyFileTransStartInfoTest001
988 * @tc.desc: client trans proxy pack file start info test, use normal parameter.
989 * @tc.type: FUNC
990 * @tc.require:
991 */
992 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileTransStartInfoTest001, TestSize.Level1)
993 {
994 int32_t ret = PackFileTransStartInfo(nullptr, nullptr, TEST_FILE_TEST_TXT_FILE, nullptr);
995 EXPECT_NE(SOFTBUS_OK, ret);
996
997 uint32_t dataTest = TEST_DATA_LENGTH;
998 FileFrame fileFrame = {
999 .frameLength = 0,
1000 .data = (uint8_t *)&dataTest,
1001 .fileData = (uint8_t *)&dataTest,
1002 };
1003 SendListenerInfo info;
1004 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1005 info.sessionId = 1;
1006 info.channelId = 1;
1007 info.packetSize = PROXY_BLE_MAX_PACKET_SIZE;
1008
1009 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
1010 EXPECT_EQ(SOFTBUS_OK, ret);
1011
1012 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1013 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
1014 EXPECT_EQ(SOFTBUS_OK, ret);
1015 }
1016
1017 /**
1018 * @tc.name: ClinetTransProxyUnFileTransStartInfoTest001
1019 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
1020 * @tc.type: FUNC
1021 * @tc.require:
1022 */
1023 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyUnFileTransStartInfoTest001, TestSize.Level1)
1024 {
1025 uint32_t packetSize = TEST_PACKET_SIZE;
1026 int32_t ret = UnpackFileTransStartInfo(nullptr, nullptr, nullptr, packetSize);
1027 EXPECT_NE(SOFTBUS_OK, ret);
1028
1029 uint32_t dataTest = TEST_DATA_LENGTH;
1030 FileFrame fileFrame = {
1031 .frameLength = 0,
1032 .data = (uint8_t *)&dataTest,
1033 .fileData = (uint8_t *)&dataTest,
1034 };
1035 FileRecipientInfo info;
1036 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1037 info.osType = OH_TYPE;
1038 SingleFileInfo singleFileInfo;
1039 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1040 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1041
1042 fileFrame.frameLength = TEST_HEADER_LENGTH;
1043 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1044 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1045
1046 uint32_t data = FILE_MAGIC_NUMBER;
1047 fileFrame.data = (uint8_t *)&data;
1048 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1049 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1050
1051 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1052 fileFrame.frameLength = 0;
1053 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1054 EXPECT_NE(SOFTBUS_OK, ret);
1055
1056 fileFrame.frameLength = FRAME_DATA_SEQ_OFFSET;
1057 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1058 EXPECT_EQ(SOFTBUS_OK, ret);
1059
1060 fileFrame.frameLength = FRAME_DATA_SEQ_OFFSET + TEST_HEADER_LENGTH;
1061 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
1062 EXPECT_EQ(SOFTBUS_OK, ret);
1063 }
1064
1065 /**
1066 * @tc.name: ClinetTransProxyFileCrcCheckSumTest001
1067 * @tc.desc: client trans proxy crc check test, use normal parameter.
1068 * @tc.type: FUNC
1069 * @tc.require:
1070 */
1071 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileCrcCheckSumTest001, TestSize.Level1)
1072 {
1073 int32_t ret = SendFileCrcCheckSum(nullptr);
1074 EXPECT_NE(SOFTBUS_OK, ret);
1075
1076 SendListenerInfo info;
1077 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1078 ret = SendFileCrcCheckSum(&info);
1079 EXPECT_EQ(SOFTBUS_OK, ret);
1080
1081 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1082 ret = SendFileCrcCheckSum(&info);
1083 EXPECT_NE(SOFTBUS_OK, ret);
1084
1085 ret = UnpackFileCrcCheckSum(nullptr, nullptr);
1086 EXPECT_NE(SOFTBUS_OK, ret);
1087
1088 FileRecipientInfo fileInfo;
1089 fileInfo.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1090 FileFrame fileFrame;
1091 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1092 EXPECT_EQ(SOFTBUS_OK, ret);
1093
1094 fileInfo.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1095 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1096 EXPECT_NE(SOFTBUS_OK, ret);
1097
1098 fileFrame.frameLength = 20;
1099 ret = UnpackFileCrcCheckSum(&fileInfo, &fileFrame);
1100 EXPECT_NE(SOFTBUS_OK, ret);
1101 }
1102
1103 /**
1104 * @tc.name: ClinetTransProxyFileToFrameTest001
1105 * @tc.desc: client trans proxy send file test, use the wrong or normal parameter.
1106 * @tc.type: FUNC
1107 * @tc.require:
1108 */
1109 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileToFrameTest001, TestSize.Level1)
1110 {
1111 SendListenerInfo info;
1112 info.sessionId = 1;
1113 info.crc = 1;
1114 info.channelId = 1;
1115
1116 int32_t ret = SendSingleFile(&info, nullptr, g_testProxyFileList[0]);
1117 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1118
1119 ret = FileToFrameAndSendFile(nullptr, g_testProxyFileList[0], g_testProxyFileList[0]);
1120 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1121
1122 ret = FileToFrameAndSendFile(&info, g_testProxyFileList[0], nullptr);
1123 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1124
1125 ret = FileToFrameAndSendFile(&info, nullptr, g_testProxyFileList[0]);
1126 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1127
1128 ret = FileToFrameAndSendFile(&info, g_testProxyFileList[0], g_testProxyFileList[0]);
1129 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1130
1131 ret = SendSingleFile(&info, g_testProxyFileList[0], g_testProxyFileList[0]);
1132 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1133
1134 ret = SendFileList(info.channelId, g_testProxyFileList, TEST_FILE_CNT);
1135 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
1136
1137 ret = SendFileList(info.channelId, nullptr, TEST_FILE_CNT);
1138 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1139 }
1140
1141 /**
1142 * @tc.name: ClinetTransProxyFileToFrameTest002
1143 * @tc.desc: client trans proxy file to frame test, use normal parameter.
1144 * @tc.type: FUNC
1145 * @tc.require:
1146 */
1147 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileToFrameTest002, TestSize.Level1)
1148 {
1149 SendListenerInfo sendInfo = {
1150 .channelId = 1,
1151 .sessionId = 1,
1152 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1153 };
1154
1155 int32_t ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_destFile);
1156 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1157
1158 ret = FileToFrame(&sendInfo, TEST_FRAME_NUMBER, g_destFile, TEST_FILE_TEST_TXT_FILE);
1159 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1160
1161 sendInfo.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1162 ret = FileToFrame(&sendInfo, TEST_FRAME_NUMBER, g_destFile, TEST_FILE_TEST_TXT_FILE);
1163 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1164 }
1165
1166 /**
1167 * @tc.name: ClinetTransProxyStartSendFileTest001
1168 * @tc.desc: client trans proxy start send file test, use normal parameter.
1169 * @tc.type: FUNC
1170 * @tc.require:
1171 */
1172 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyStartSendFileTest001, TestSize.Level1)
1173 {
1174 SendListenerInfo sendInfo = {
1175 .channelId = 1,
1176 .sessionId = 1,
1177 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1178 };
1179
1180 int32_t ret = ProxyStartSendFile(&sendInfo, g_testProxyFileList, g_testProxyFileList, TEST_FILE_CNT);
1181 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1182 }
1183
1184 /**
1185 * @tc.name: ClinetTransProxyCheckFileTest001
1186 * @tc.desc: client trans proxy start send file test, use normal parameter.
1187 * @tc.type: FUNC
1188 * @tc.require:
1189 */
1190 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCheckFileTest001, TestSize.Level1)
1191 {
1192 bool result = CheckRecvFileExist(nullptr);
1193 EXPECT_EQ(false, result);
1194
1195 result = CheckRecvFileExist(g_testProxyFileList[0]);
1196 EXPECT_EQ(false, result);
1197 }
1198
1199 /**
1200 * @tc.name: ClinetTransProxyPutToRcvListTest001
1201 * @tc.desc: client trans proxy put to file list test, use normal parameter.
1202 * @tc.type: FUNC
1203 * @tc.require:
1204 */
1205 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPutToRcvListTest001, TestSize.Level1)
1206 {
1207 int32_t ret = PutToRecvFileList(nullptr, nullptr);
1208 EXPECT_NE(SOFTBUS_OK, ret);
1209
1210 FileRecipientInfo recipient = {
1211 .recvFileInfo.fileStatus = NODE_ERR,
1212 };
1213 const SingleFileInfo file = {0};
1214 ret = PutToRecvFileList(&recipient, &file);
1215 EXPECT_NE(SOFTBUS_OK, ret);
1216
1217 recipient.recvFileInfo.fileStatus = NODE_IDLE;
1218 ret = PutToRecvFileList(&recipient, &file);
1219 EXPECT_NE(SOFTBUS_OK, ret);
1220
1221 SingleFileInfo trueFile = {0};
1222 (void)memcpy_s(trueFile.filePath, MAX_FILE_PATH_NAME_LEN, g_recvFile, sizeof(g_recvFile));
1223 ret = PutToRecvFileList(&recipient, &trueFile);
1224 EXPECT_EQ(SOFTBUS_OK, ret);
1225 }
1226
1227 /**
1228 * @tc.name: ClinetTransProxyRecvRecipientInfoListTest001
1229 * @tc.desc: client trans proxy recv recipient info test, use normal parameter.
1230 * @tc.type: FUNC
1231 * @tc.require:
1232 */
1233 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRecvRecipientInfoListTest001, TestSize.Level1)
1234 {
1235 int32_t sessionId = 1;
1236 FileRecipientInfo *result = GetRecipientNoLock(sessionId);
1237 EXPECT_EQ(nullptr, result);
1238
1239 uint32_t seq = 0;
1240 int32_t res = 0;
1241 int32_t ret = ProcessFileSendResult(sessionId, seq, res);
1242 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
1243
1244 sessionId = -1;
1245 result = GetRecipientNoLock(sessionId);
1246 EXPECT_EQ(nullptr, result);
1247
1248 ret = ProcessFileSendResult(sessionId, seq, res);
1249 EXPECT_NE(SOFTBUS_OK, ret);
1250
1251 ret = ProcessFileRecvResult(sessionId, seq, res);
1252 EXPECT_NE(SOFTBUS_OK, ret);
1253
1254 ReleaseRecipientRef(nullptr);
1255
1256 FileRecipientInfo *info = (FileRecipientInfo *)SoftBusCalloc(sizeof(FileRecipientInfo));
1257 info->objRefCount = 2,
1258 ReleaseRecipientRef(info);
1259
1260 info->objRefCount = 1;
1261 ReleaseRecipientRef(info);
1262 }
1263
1264 /**
1265 * @tc.name: ClinetTransProxyGetRecipientInfoListTest001
1266 * @tc.desc: client trans proxy get recipient info test, use normal parameter.
1267 * @tc.type: FUNC
1268 * @tc.require:
1269 */
1270 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetRecipientInfoListTest001, TestSize.Level1)
1271 {
1272 int32_t sessionId = -1;
1273 int32_t channelId = 1;
1274 int32_t osType = TEST_OS_TYPE;
1275 FileRecipientInfo *result = GetRecipientInProcessRef(sessionId);
1276 EXPECT_EQ(nullptr, result);
1277
1278 result = GetRecipientInCreateFileRef(sessionId, channelId, osType);
1279 EXPECT_EQ(nullptr, result);
1280
1281 sessionId = 1;
1282 result = GetRecipientInCreateFileRef(sessionId, channelId, osType);
1283 EXPECT_EQ(nullptr, result);
1284
1285 result = GetRecipientInProcessRef(sessionId);
1286 EXPECT_EQ(nullptr, result);
1287 }
1288
1289 /**
1290 * @tc.name: ClinetTransProxyWriteEmptyFrameTest001
1291 * @tc.desc: client trans proxy write empty frame test, use normal parameter.
1292 * @tc.type: FUNC
1293 * @tc.require:
1294 */
1295 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyWriteEmptyFrameTest001, TestSize.Level1)
1296 {
1297 int32_t cnt = 0;
1298 int32_t ret = WriteEmptyFrame(nullptr, cnt);
1299 EXPECT_NE(SOFTBUS_OK, ret);
1300
1301 SingleFileInfo info = {0};
1302 ret = WriteEmptyFrame(&info, cnt);
1303 EXPECT_EQ(SOFTBUS_OK, ret);
1304
1305 cnt = 1;
1306 ret = WriteEmptyFrame(&info, cnt);
1307 EXPECT_NE(SOFTBUS_OK, ret);
1308
1309 info.fileFd = g_fd;
1310 info.oneFrameLen = -1;
1311 info.fileOffset = 0;
1312 ret = WriteEmptyFrame(&info, cnt);
1313 EXPECT_NE(SOFTBUS_OK, ret);
1314
1315 info.oneFrameLen = TEST_FILE_LENGTH;
1316 ret = WriteEmptyFrame(&info, cnt);
1317 EXPECT_EQ(SOFTBUS_OK, ret);
1318 }
1319
1320 /**
1321 * @tc.name: ClinetTransProxyProcessOneFrameCRCTest001
1322 * @tc.desc: client trans proxy process one frameCRC test, use normal parameter.
1323 * @tc.type: FUNC
1324 * @tc.require:
1325 */
1326 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessOneFrameCRCTest001, TestSize.Level1)
1327 {
1328 uint32_t dataLen = 0;
1329 int32_t ret = ProcessOneFrameCRC(nullptr, dataLen, nullptr);
1330 EXPECT_NE(SOFTBUS_OK, ret);
1331
1332 uint8_t *emptyBuff = (uint8_t *)SoftBusCalloc(TEST_FILE_SIZE);
1333 if (emptyBuff == nullptr) {
1334 return;
1335 }
1336 FileFrame frame = {
1337 .frameType = TRANS_SESSION_FILE_FIRST_FRAME,
1338 .seq = TEST_SEQ32,
1339 .fileData = emptyBuff,
1340 };
1341 SingleFileInfo fileInfo = {
1342 .seq = 0,
1343 .fileFd = g_fd,
1344 .fileOffset = 0,
1345 .oneFrameLen = TEST_FILE_LENGTH,
1346 .startSeq = 0,
1347 .preStartSeq = 0,
1348 };
1349 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1350 EXPECT_NE(SOFTBUS_OK, ret);
1351
1352 frame.seq = TEST_SEQ128;
1353 fileInfo.seq = TEST_SEQ126;
1354 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1355 EXPECT_NE(SOFTBUS_OK, ret);
1356
1357 fileInfo.preStartSeq = TEST_SEQ128;
1358 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1359 EXPECT_NE(SOFTBUS_OK, ret);
1360
1361 frame.frameType = TRANS_SESSION_FILE_LAST_FRAME;
1362 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1363 EXPECT_NE(SOFTBUS_OK, ret);
1364
1365 fileInfo.startSeq = TEST_SEQ8;
1366 frame.seq = TEST_SEQ_SECOND;
1367 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1368 EXPECT_NE(SOFTBUS_OK, ret);
1369
1370 dataLen = TEST_SEQ16;
1371 ret = ProcessOneFrameCRC(&frame, dataLen, &fileInfo);
1372 EXPECT_EQ(SOFTBUS_OK, ret);
1373 SoftBusFree(emptyBuff);
1374 }
1375
1376 /**
1377 * @tc.name: ClinetTransProxyProcessOneFrameTest001
1378 * @tc.desc: client trans proxy process one frame test, use normal parameter.
1379 * @tc.type: FUNC
1380 * @tc.require:
1381 */
1382 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessOneFrameTest001, TestSize.Level1)
1383 {
1384 FileFrame frame = {
1385 .frameType = TRANS_SESSION_FILE_FIRST_FRAME,
1386 .seq = TEST_SEQ32,
1387 };
1388 uint32_t dataLen = TEST_SEQ16;
1389 int32_t crc = APP_INFO_FILE_FEATURES_SUPPORT;
1390 int32_t osType = TEST_OS_TYPE;
1391 SingleFileInfo fileInfo = {
1392 .seq = 0,
1393 .fileFd = g_fd,
1394 .fileStatus = NODE_ERR,
1395 .fileOffset = 0,
1396 .oneFrameLen = TEST_FILE_LENGTH,
1397 .startSeq = 0,
1398 .preStartSeq = 0,
1399 };
1400 int32_t ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo, osType);
1401 EXPECT_NE(SOFTBUS_OK, ret);
1402
1403 fileInfo.fileStatus = NODE_IDLE;
1404 ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo, osType);
1405 EXPECT_NE(SOFTBUS_OK, ret);
1406
1407 crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1408 ret = ProcessOneFrame(&frame, dataLen, crc, &fileInfo, osType);
1409 EXPECT_NE(SOFTBUS_OK, ret);
1410 }
1411
1412 /**
1413 * @tc.name: ClinetTransProxyCrcCheckTest001
1414 * @tc.desc: client trans proxy process crc check test, use normal parameter.
1415 * @tc.type: FUNC
1416 * @tc.require:
1417 */
1418 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCrcCheckTest001, TestSize.Level1)
1419 {
1420 FileFrame frame = {
1421 .seq = TEST_SEQ32,
1422 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1423 };
1424 int32_t sessionId = -1;
1425
1426 int32_t ret = ProcessCrcCheckSumData(sessionId, nullptr);
1427 EXPECT_NE(SOFTBUS_OK, ret);
1428
1429 ret = ProcessCrcCheckSumData(sessionId, &frame);
1430 EXPECT_NE(SOFTBUS_OK, ret);
1431
1432 sessionId = 1;
1433 ret = ProcessCrcCheckSumData(sessionId, &frame);
1434 EXPECT_NE(SOFTBUS_OK, ret);
1435
1436 frame.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1437 ret = ProcessCrcCheckSumData(sessionId, &frame);
1438 EXPECT_NE(SOFTBUS_OK, ret);
1439 }
1440
1441 /**
1442 * @tc.name: ClinetTransProxyFileAckRequestTest001
1443 * @tc.desc: client trans proxy file ack request test, use normal parameter.
1444 * @tc.type: FUNC
1445 * @tc.require:
1446 */
1447 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckRequestTest001, TestSize.Level1)
1448 {
1449 FileFrame frame = {
1450 .frameLength = TEST_HEADER_LENGTH,
1451 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1452 .data = nullptr,
1453 };
1454 int32_t sessionId = -1;
1455
1456 int32_t ret = ProcessFileAckRequest(sessionId, nullptr);
1457 EXPECT_NE(SOFTBUS_OK, ret);
1458
1459 ret = ProcessFileAckRequest(sessionId, &frame);
1460 EXPECT_NE(SOFTBUS_OK, ret);
1461
1462 sessionId = 1;
1463 uint32_t dataTest = 0;
1464 dataTest = FILE_MAGIC_NUMBER;
1465 frame.data = (uint8_t *)&dataTest;
1466 ret = ProcessFileAckRequest(sessionId, &frame);
1467 EXPECT_NE(SOFTBUS_OK, ret);
1468
1469 ret = ProcessFileAckRequest(sessionId, &frame);
1470 EXPECT_NE(SOFTBUS_OK, ret);
1471 }
1472
1473 /**
1474 * @tc.name: ClinetTransProxyFileAckResponseTest001
1475 * @tc.desc: client trans proxy file ack response test, use normal parameter.
1476 * @tc.type: FUNC
1477 * @tc.require:
1478 */
1479 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckResponseTest001, TestSize.Level1)
1480 {
1481 FileFrame frame = {
1482 .frameLength = 0,
1483 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
1484 .data = nullptr,
1485 };
1486 int32_t sessionId = -1;
1487
1488 int32_t ret = ProcessFileAckResponse(sessionId, nullptr);
1489 EXPECT_NE(SOFTBUS_OK, ret);
1490
1491 ret = ProcessFileAckResponse(sessionId, &frame);
1492 EXPECT_NE(SOFTBUS_OK, ret);
1493
1494 uint32_t dataTest[TEST_FRAME_DATA_LENGTH] = {0};
1495 dataTest[TEST_FILE_MAGIC_OFFSET] = FILE_MAGIC_NUMBER;
1496 frame.data = (uint8_t *)dataTest;
1497 ret = ProcessFileAckResponse(sessionId, &frame);
1498 EXPECT_NE(SOFTBUS_OK, ret);
1499
1500 SendListenerInfo info;
1501 info.sessionId = 1;
1502 info.crc = 1;
1503 info.channelId = 1;
1504 ret = AddSendListenerInfo(&info);
1505 EXPECT_EQ(SOFTBUS_OK, ret);
1506
1507 frame.frameLength = TEST_HEADER_LENGTH;
1508 *(uint64_t *)(frame.data + FRAME_MAGIC_OFFSET) = FRAME_DATA_SEQ_OFFSET + FRAME_DATA_SEQ_OFFSET;
1509 ret = ProcessFileAckResponse(sessionId, &frame);
1510 EXPECT_NE(SOFTBUS_OK, ret);
1511
1512 sessionId = 1;
1513 ret = ProcessFileAckResponse(sessionId, &frame);
1514 EXPECT_EQ(SOFTBUS_OK, ret);
1515 }
1516
1517 /**
1518 * @tc.name: ClinetTransProxyCheckParameterTest001
1519 * @tc.desc: client trans proxy check parameter test, use normal parameter.
1520 * @tc.type: FUNC
1521 * @tc.require:
1522 */
1523 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCheckParameterTest001, TestSize.Level1)
1524 {
1525 bool result = IsValidFileString(nullptr, TEST_FILE_CNT, TEST_FILE_LENGTH);
1526 EXPECT_EQ(false, result);
1527
1528 uint32_t fileNum = 0;
1529 result = IsValidFileString(g_testProxyFileList, fileNum, TEST_FILE_LENGTH);
1530 EXPECT_EQ(false, result);
1531
1532 int32_t sessionId = 1;
1533 int32_t ret = ProcessFileTransResult(sessionId, nullptr);
1534 EXPECT_NE(SOFTBUS_OK, ret);
1535 }
1536
1537 /**
1538 * @tc.name: ClinetTransProxyProcessFileListDataTest001
1539 * @tc.desc: client trans proxy process file list data test, use normal parameter.
1540 * @tc.type: FUNC
1541 * @tc.require:
1542 */
1543 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyProcessFileListDataTest001, TestSize.Level1)
1544 {
1545 int32_t sessionId = 1;
1546 FileFrame frame = {
1547 .frameLength = TEST_FILE_SIZE,
1548 .data = (uint8_t *)"00010010datatest,"
1549 };
1550 int32_t ret = ProcessFileListData(sessionId, &frame);
1551 EXPECT_NE(SOFTBUS_OK, ret);
1552 }
1553
1554 /**
1555 * @tc.name: ClinetTransProxyGetFileInfoTest001
1556 * @tc.desc: client trans proxy get file info test, use normal parameter.
1557 * @tc.type: FUNC
1558 * @tc.require:
1559 */
1560 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFileInfoTest001, TestSize.Level1)
1561 {
1562 FileFrame frame = {
1563 .frameLength = 0,
1564 .data = (uint8_t *)"00010010datatest.txt",
1565 };
1566 FileRecipientInfo info = {
1567 .fileListener.rootDir = "../test",
1568 };
1569 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1570 SingleFileInfo file;
1571 uint32_t packetSize = TEST_PACKET_SIZE;
1572 int32_t ret = GetFileInfoByStartFrame(nullptr, nullptr, nullptr, packetSize);
1573 EXPECT_NE(SOFTBUS_OK, ret);
1574
1575 ret = GetFileInfoByStartFrame(&frame, &info, &file, packetSize);
1576 EXPECT_NE(SOFTBUS_OK, ret);
1577
1578 ret = memcpy_s(info.fileListener.rootDir, TEST_FILEPATH_LENGTH, g_rootDir + 1, TEST_FILEPATH_LENGTH);
1579 ASSERT_EQ(SOFTBUS_OK, ret);
1580 ret = GetFileInfoByStartFrame(&frame, &info, &file, packetSize);
1581 EXPECT_NE(SOFTBUS_OK, ret);
1582
1583 frame.frameLength = FRAME_DATA_SEQ_OFFSET + 9;
1584 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1585 ret = GetFileInfoByStartFrame(&frame, &info, &file, packetSize);
1586 EXPECT_EQ(SOFTBUS_OK, ret);
1587 }
1588
1589 /**
1590 * @tc.name: ClinetTransProxyWriteFrameTest001
1591 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1592 * @tc.type: FUNC
1593 * @tc.require:
1594 */
1595 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyWriteFrameTest001, TestSize.Level1)
1596 {
1597 int32_t sessionId = 1;
1598 FileFrame frame = {
1599 .frameLength = 0,
1600 .data = (uint8_t *)"00010010datatest.txt",
1601 };
1602 int32_t ret = WriteFrameToFile(sessionId, &frame);
1603 EXPECT_NE(SOFTBUS_OK, ret);
1604
1605 frame.frameLength = TEST_DATA_LENGTH;
1606 ret = WriteFrameToFile(sessionId, &frame);
1607 EXPECT_NE(SOFTBUS_OK, ret);
1608 }
1609
1610 /**
1611 * @tc.name: ClinetTransProxyChannelSendFileStreamTest001
1612 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1613 * @tc.type: FUNC
1614 * @tc.require:
1615 */
1616 HWTEST_F(ClientTransProxyFileManagerTest, ProxyChannelSendFileStreamTest001, TestSize.Level1)
1617 {
1618 int32_t channelId = 1;
1619 const char *data = "test_data";
1620 uint32_t len = TEST_HEADER_LENGTH;
1621 int32_t type = 1;
1622
1623 int32_t ret = ProxyChannelSendFileStream(channelId, data, len, type);
1624 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
1625 }
1626
1627 /**
1628 * @tc.name: ClinetTransProxySendFileTransResult001
1629 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1630 * @tc.type: FUNC
1631 * @tc.require:
1632 */
1633 HWTEST_F(ClientTransProxyFileManagerTest, ProxySendFileTransResultTest001, TestSize.Level1)
1634 {
1635 int32_t channelId = 1;
1636 uint32_t seq = TEST_SEQ;
1637 int32_t result = 0;
1638 uint32_t side = 0;
1639
1640 int32_t ret = SendFileTransResult(channelId, seq, result, side);
1641 EXPECT_NE(SOFTBUS_MALLOC_ERR, ret);
1642 }
1643
1644 /**
1645 * @tc.name: ClinetUnpackFileTransResultFrame001
1646 * @tc.desc: client trans proxy write frame to file test, use normal parameter.
1647 * @tc.type: FUNC
1648 * @tc.require:
1649 */
1650 HWTEST_F(ClientTransProxyFileManagerTest, ProxyUnpackFileTransResultFrame001, TestSize.Level1)
1651 {
1652 uint32_t seq = TEST_SEQ;
1653 int32_t result = 0;
1654 uint32_t side = 0;
1655 uint32_t data = 0;
1656 const uint8_t *data1 = (const uint8_t *)&data;
1657 uint32_t len = TEST_HEADER_LENGTH;
1658
1659 int32_t ret = UnpackFileTransResultFrame(data1, len, nullptr, &result, &side);
1660 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1661
1662 ret = UnpackFileTransResultFrame(data1, len, &seq, nullptr, &side);
1663 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1664
1665 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, nullptr);
1666 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1667
1668 ret = UnpackFileTransResultFrame(nullptr, len, &seq, &result, &side);
1669 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1670
1671 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, &side);
1672 EXPECT_NE(SOFTBUS_OK, ret);
1673
1674 len = 0;
1675 ret = UnpackFileTransResultFrame(data1, len, &seq, &result, &side);
1676 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1677 }
1678
1679 /**
1680 * @tc.name: ClinetTransProxyFileAckReqAndResDataTest002
1681 * @tc.desc: client trans proxy file ack req and res data test, use the wrong or normal parameter.
1682 * @tc.type: FUNC
1683 * @tc.require:
1684 */
1685 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyFileAckReqAndResDataTest002, TestSize.Level1)
1686 {
1687 int32_t channelId = 1;
1688 uint32_t startSeq = TEST_SEQ;
1689 uint32_t value = 0;
1690 int32_t ret = SendFileAckReqAndResData(channelId, startSeq, value, CHANNEL_TYPE_PROXY);
1691 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
1692
1693 FileFrame frame;
1694 frame.frameLength = 0;
1695 frame.data = nullptr;
1696 uint64_t dataTest = 0;
1697 ret = UnpackAckReqAndResData(nullptr, &startSeq, &value);
1698 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1699
1700 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1701 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1702
1703 ret = UnpackAckReqAndResData(&frame, nullptr, &value);
1704 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1705
1706 ret = UnpackAckReqAndResData(&frame, &startSeq, nullptr);
1707 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1708
1709 frame.data = (uint8_t *)&dataTest;
1710 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1711 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
1712
1713 frame.frameLength = TEST_HEADER_LENGTH;
1714 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1715 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
1716
1717 dataTest = TEST_HEADER_LENGTH;
1718 frame.data = (uint8_t *)&dataTest;
1719 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1720 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
1721
1722 dataTest = FILE_MAGIC_NUMBER;
1723 frame.data = (uint8_t *)&dataTest;
1724 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1725 EXPECT_EQ(SOFTBUS_OK, ret);
1726
1727 ret = UnpackAckReqAndResData(&frame, &startSeq, &value);
1728 EXPECT_EQ(SOFTBUS_OK, ret);
1729 }
1730
1731 /**
1732 * @tc.name: ClinetTransProxyPackFileDataTest002
1733 * @tc.desc: client trans proxy pack file data test, use the wrong parameter.
1734 * @tc.type: FUNC
1735 * @tc.require:
1736 */
1737 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyPackFileDataTest002, TestSize.Level1)
1738 {
1739 FileFrame fileFrame = {
1740 .frameType = TRANS_SESSION_BYTES,
1741 .data = nullptr,
1742 };
1743 uint64_t readLength = TEST_FILE_LENGTH;
1744 uint64_t fileOffset = 0;
1745 SendListenerInfo info;
1746 info.fd = g_fd;
1747 info.packetSize = PROXY_BLE_MAX_PACKET_SIZE;
1748 uint32_t seq = TEST_SEQ;
1749 int64_t len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
1750 EXPECT_EQ(TEST_INVALID_LEN, len);
1751
1752 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1753 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
1754 EXPECT_EQ(TEST_INVALID_LEN, len);
1755
1756 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
1757 EXPECT_EQ(TEST_INVALID_LEN, len);
1758
1759 uint32_t dataTest = TEST_DATA_LENGTH;
1760 fileFrame.data = (uint8_t *)&dataTest;
1761 fileFrame.fileData = (uint8_t *)&dataTest;
1762 info.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
1763 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
1764 EXPECT_EQ(TEST_FILE_LENGTH, len);
1765
1766 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1767 len = PackReadFileData(&fileFrame, readLength, fileOffset, &info);
1768 EXPECT_EQ(TEST_FILE_LENGTH, len);
1769
1770 len = PackReadFileRetransData(&fileFrame, seq, readLength, fileOffset, &info);
1771 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, len);
1772 }
1773
1774 /**
1775 * @tc.name: ClinetTransProxyRetransFileFrameTest002
1776 * @tc.desc: client trans proxy retrans file frame test, use normal parameter.
1777 * @tc.type: FUNC
1778 * @tc.require:
1779 */
1780 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyRetransFileFrameTest002, TestSize.Level1)
1781 {
1782 SendListenerInfo info = {
1783 .fileSize = TEST_FILE_SIZE,
1784 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1785 };
1786 int32_t seq = 0;
1787
1788 int32_t ret = RetransFileFrameBySeq(nullptr, TEST_SEQ);
1789 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1790
1791 ret = RetransFileFrameBySeq(&info, seq);
1792 EXPECT_EQ(SOFTBUS_OK, ret);
1793
1794 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
1795 EXPECT_EQ(SOFTBUS_OK, ret);
1796
1797 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
1798 seq = TEST_SEQ_SECOND;
1799
1800 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
1801 EXPECT_NE(SOFTBUS_MALLOC_ERR, ret);
1802
1803 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
1804 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1805
1806 ret = RetransFileFrameBySeq(&info, TEST_SEQ);
1807 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1808
1809 info.fileSize = 0;
1810 ret = RetransFileFrameBySeq(&info, seq);
1811 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1812 }
1813
1814 /**
1815 * @tc.name: ClinetTransProxyCalcAllFilesInfoTest001
1816 * @tc.desc: client trans proxy calc all files info test, use normal parameter.
1817 * @tc.type: FUNC
1818 * @tc.require:
1819 */
1820 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyGetFileSizeTest001, TestSize.Level1)
1821 {
1822 const char *fileList[] = {
1823 "test0",
1824 "test1",
1825 "test2",
1826 "test3",
1827 "test4"
1828 };
1829 FilesInfo totalInfo = {
1830 .files = fileList,
1831 .fileCnt = TEST_FILE_CNT,
1832 .bytesProcessed = 0,
1833 };
1834 uint32_t fileCnt = TEST_FILE_CNT;
1835
1836 SendListenerInfo info = {
1837 .fileSize = TEST_FILE_SIZE,
1838 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
1839 };
1840 ClearSendInfo(&info);
1841
1842 int32_t ret = CalcAllFilesInfo(&totalInfo, fileList, fileCnt);
1843 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
1844 }
1845
1846 /**
1847 * @tc.name: ClinetTransProxyUpdateFileReceivePathTest001
1848 * @tc.desc: client trans proxy update file receive path test, use normal and error parameter.
1849 * @tc.type: FUNC
1850 * @tc.require:
1851 */
1852 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyUpdateFileReceivePathTest001, TestSize.Level1)
1853 {
1854 int32_t sessionId = TEST_SESSION_ID;
1855 FileListener *fileListener = (FileListener *)SoftBusCalloc(sizeof(FileListener));
1856
1857 fileListener->socketRecvCallback = nullptr;
1858 int32_t ret = UpdateFileReceivePath(sessionId, fileListener);
1859 EXPECT_EQ(SOFTBUS_OK, ret);
1860
1861 ret = UpdateFileReceivePath(sessionId, fileListener);
1862 EXPECT_EQ(SOFTBUS_OK, ret);
1863 SoftBusFree(fileListener);
1864
1865 GetRecipientInfo(sessionId);
1866 }
1867
1868 /**
1869 * @tc.name: ClinetTransProxyCreateFileFromFrameTest001
1870 * @tc.desc: client trans proxy create file from frame test, use normal and error parameter.
1871 * @tc.type: FUNC
1872 * @tc.require:
1873 */
1874 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyCreateFileFromFrameTest001, TestSize.Level1)
1875 {
1876 int32_t sessionId = TEST_SESSION_ID;
1877 int32_t channelId = TEST_CHANNEL_ID;
1878 int32_t osType = TEST_OS_TYPE;
1879 uint8_t data = 0;
1880 uint32_t packetSize = TEST_PACKET_SIZE;
1881 FileFrame fileFrame = {
1882 .frameType = TRANS_SESSION_BYTES,
1883 .data = &data,
1884 .fileData = &data,
1885 };
1886
1887 int32_t ret = CreateFileFromFrame(sessionId, channelId, &fileFrame, osType, packetSize);
1888 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
1889
1890 const char *dataFile = "TEST_FILE_DATA";
1891 uint32_t len = TEST_HEADER_LENGTH;
1892 int32_t type = 0;
1893 ProcessFileFrameData(sessionId, channelId, dataFile, len, type);
1894 }
1895
1896 /**
1897 * @tc.name: ClinetTransProxyChannelSendFileTest001
1898 * @tc.desc: client trans proxy channel send file test, use normal and error parameter.
1899 * @tc.type: FUNC
1900 * @tc.require:
1901 */
1902 HWTEST_F(ClientTransProxyFileManagerTest, ClinetTransProxyChannelSendFileTest001, TestSize.Level1)
1903 {
1904 int32_t channelId = TEST_CHANNEL_ID;
1905 const char *sFileList[] = {
1906 "test0",
1907 "test1",
1908 "test2",
1909 "test3",
1910 "test4"
1911 };
1912 const char *dFileList[] = {
1913 "test0",
1914 "test1",
1915 "test2",
1916 "test3",
1917 "test4"
1918 };
1919 uint32_t fileCnt = TEST_FILE_CNT;
1920
1921 GenerateRemoteFiles(sFileList, fileCnt);
1922
1923 int32_t ret = TransProxyChannelSendFile(channelId, nullptr, dFileList, fileCnt);
1924 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1925
1926 fileCnt = 0;
1927 ret = TransProxyChannelSendFile(channelId, sFileList, dFileList, fileCnt);
1928 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1929
1930 fileCnt = 12; // 为满足if条件语句大于10，所以赋值12
1931 ret = TransProxyChannelSendFile(channelId, sFileList, dFileList, fileCnt);
1932 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1933 }
1934
1935 /**
1936 * @tc.name: CheckFrameLengthTest
1937 * @tc.desc: client trans proxy channel send file test, use normal and error parameter.
1938 * @tc.type: FUNC
1939 * @tc.require:
1940 */
1941 HWTEST_F(ClientTransProxyFileManagerTest, CheckFrameLengthTest, TestSize.Level1)
1942 {
1943 int32_t osType = TEST_OS_TYPE;
1944 uint32_t packetSize;
1945 int32_t ret = CheckFrameLength(1, PROXY_BR_MAX_PACKET_SIZE, osType, &packetSize);
1946 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
1947
1948 ChannelInfo *channel1 = (ChannelInfo *)SoftBusMalloc(sizeof(ChannelInfo));
1949 ASSERT_TRUE(channel1 != nullptr);
1950 channel1->channelId = 1;
1951 channel1->isEncrypt = 0;
1952 channel1->linkType = LANE_BR;
1953 channel1->sessionKey = (char *)g_sessionKey;
1954 channel1->keyLen = TEST_SEQ32;
1955 ret = ClientTransProxyAddChannelInfo(ClientTransProxyCreateChannelInfo(channel1));
1956 EXPECT_EQ(SOFTBUS_OK, ret);
1957 ret = CheckFrameLength(1, PROXY_BR_MAX_PACKET_SIZE + 1, osType, &packetSize);
1958 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1959 ret = CheckFrameLength(1, PROXY_BR_MAX_PACKET_SIZE - 1, osType, &packetSize);
1960 EXPECT_EQ(SOFTBUS_OK, ret);
1961
1962 ChannelInfo *channel2 = (ChannelInfo *)SoftBusMalloc(sizeof(ChannelInfo));
1963 ASSERT_TRUE(channel2 != nullptr);
1964 channel2->channelId = 2;
1965 channel2->isEncrypt = 0;
1966 channel2->linkType = LANE_BLE_DIRECT;
1967 channel2->sessionKey = (char *)g_sessionKey;
1968 channel2->keyLen = TEST_SEQ32;
1969 ret = ClientTransProxyAddChannelInfo(ClientTransProxyCreateChannelInfo(channel2));
1970 EXPECT_EQ(SOFTBUS_OK, ret);
1971 ret = CheckFrameLength(2, PROXY_BLE_MAX_PACKET_SIZE + 1, osType, &packetSize);
1972 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1973 ret = CheckFrameLength(2, PROXY_BLE_MAX_PACKET_SIZE - 1, osType, &packetSize);
1974 EXPECT_EQ(SOFTBUS_OK, ret);
1975
1976 ret = ClientTransProxyDelChannelInfo(1);
1977 EXPECT_EQ(SOFTBUS_OK, ret);
1978 ret = ClientTransProxyDelChannelInfo(2);
1979 EXPECT_EQ(SOFTBUS_OK, ret);
1980 SoftBusFree(channel1);
1981 SoftBusFree(channel2);
1982 }
1983 } // namespace OHOS