1 /*
2 * Copyright (c) 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 <fcntl.h>
17 #include <gtest/gtest.h>
18 #include "securec.h"
19 #include <sys/stat.h>
20 #include <sys/types.h>
21
22 #include "client_trans_proxy_file_manager.c"
23 #include "client_trans_proxy_file_manager_mock.h"
24 #include "client_trans_proxy_manager.c"
25 #include "softbus_access_token_test.h"
26 #include "softbus_def.h"
27 #include "softbus_error_code.h"
28 #include "trans_proxy_process_data.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 #define TEST_SESSION_ID 1026
34 #define TEST_CHANNEL_ID 2058
35 #define TEST_HEADER_LENGTH 24
36 #define TEST_DATA_LENGTH 100
37 #define TEST_PACKET_SIZE 1024
38 #define TEST_FILE_LENGTH 12
39 #define TEST_FILE_DATA_SIZE 958
40 #define TEST_FILE_TEST_TXT_FILE 16
41 #define TEST_SEQ 15
42 #define TEST_ZERO 0
43 #define TEST_NUM 2
44 #define TEST_DATA_LEN 5000
45
46 static const char *TEST_SESSION_NAME = "test.trans.proxy.demo";
47 static const char *TEST_SESSION_KEY = "Test_OpenHarmony";
48
49 namespace OHOS {
50
51 const char *g_testProxyFileList[] = {
52 "/data/test.txt",
53 "/data/ss.txt",
54 };
55
56 class ClientTransProxyFileManagerMockTest : public testing::Test {
57 public:
ClientTransProxyFileManagerMockTest()58 ClientTransProxyFileManagerMockTest() {}
~ClientTransProxyFileManagerMockTest()59 ~ClientTransProxyFileManagerMockTest() {}
60 static void SetUpTestCase(void);
61 static void TearDownTestCase(void);
SetUp()62 void SetUp() override {}
TearDown()63 void TearDown() override {}
64 };
65
SetUpTestCase(void)66 void ClientTransProxyFileManagerMockTest::SetUpTestCase(void)
67 {
68 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
69 EXPECT_CALL(ClientProxyFileManagerMock, InitPendingPacket).WillRepeatedly(Return(SOFTBUS_OK));
70 int32_t ret = ClinetTransProxyFileManagerInit();
71 EXPECT_EQ(SOFTBUS_OK, ret);
72 ClientTransProxyListInit();
73 }
74
TearDownTestCase(void)75 void ClientTransProxyFileManagerMockTest::TearDownTestCase(void)
76 {
77 ClinetTransProxyFileManagerDeinit();
78 ClientTransProxyListDeinit();
79 }
80
TestCreatInfo(void)81 ClientProxyChannelInfo *TestCreatInfo(void)
82 {
83 ClientProxyChannelInfo *info = (ClientProxyChannelInfo *)SoftBusCalloc(sizeof(ClientProxyChannelInfo));
84 if (info == nullptr) {
85 return nullptr;
86 }
87 info->channelId = TEST_CHANNEL_ID;
88 info->detail.linkType = LANE_HML;
89 info->detail.osType = OH_TYPE;
90 info->detail.isEncrypted = true;
91 return info;
92 }
93
94 /**
95 * @tc.name: AddSendListenerInfoTest001
96 * @tc.desc: client add send listener info, use normal parameter.
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(ClientTransProxyFileManagerMockTest, AddSendListenerInfoTest001, TestSize.Level1)
101 {
102 // will free in DelSendListenerInfo
103 SendListenerInfo *info = (SendListenerInfo *)SoftBusCalloc(sizeof(SendListenerInfo));
104 EXPECT_TRUE(info != nullptr);
105 info->sessionId = TEST_SESSION_ID;
106
107 int32_t ret = AddSendListenerInfo(nullptr);
108 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
109
110 ret = AddSendListenerInfo(info);
111 EXPECT_EQ(SOFTBUS_OK, ret);
112
113 ret = AddSendListenerInfo(info);
114 EXPECT_EQ(SOFTBUS_ALREADY_EXISTED, ret);
115
116 ReleaseSendListenerInfo(info);
117 }
118
119 /**
120 * @tc.name: PackFileTransStartInfoTest001
121 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(ClientTransProxyFileManagerMockTest, PackFileTransStartInfoTest001, TestSize.Level1)
126 {
127 uint8_t data[TEST_DATA_LENGTH] = {0};
128 FileFrame fileFrame = {
129 .frameLength = TEST_HEADER_LENGTH,
130 .data = data,
131 .fileData = data,
132 };
133 SendListenerInfo info = {
134 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
135 .osType = OH_TYPE,
136 .packetSize = 1,
137 };
138
139 int32_t ret = PackFileTransStartInfo(nullptr, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
140 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
141
142 ret = PackFileTransStartInfo(&fileFrame, nullptr, TEST_FILE_TEST_TXT_FILE, &info);
143 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
144
145 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, nullptr);
146 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
147
148 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
149 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
150
151 info.packetSize = PROXY_BLE_MAX_PACKET_SIZE;
152 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
153 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillRepeatedly(Return(FILE_MAGIC_NUMBER));
154 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillRepeatedly(
155 Return(FILE_MAGIC_NUMBER + FRAME_MAGIC_OFFSET));
156 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillRepeatedly(Return(TEST_FILE_DATA_SIZE));
157 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillRepeatedly(Return(TEST_FILE_TEST_TXT_FILE));
158
159 ret = PackFileTransStartInfo(&fileFrame, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE, &info);
160 EXPECT_EQ(SOFTBUS_OK, ret);
161 }
162
163 /**
164 * @tc.name: UnpackFileTransStartInfoTest001
165 * @tc.desc: client trans proxy pack file data frame test, use normal parameter.
166 * @tc.type: FUNC
167 * @tc.require:
168 */
169 HWTEST_F(ClientTransProxyFileManagerMockTest, UnpackFileTransStartInfoTest001, TestSize.Level1)
170 {
171 uint32_t packetSize = TEST_PACKET_SIZE;
172
173 uint8_t data[TEST_DATA_LENGTH] = {0};
174 FileFrame fileFrame = {
175 .frameLength = TEST_HEADER_LENGTH,
176 .data = data,
177 .fileData = data,
178 };
179 FileRecipientInfo info;
180 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
181 info.osType = OH_TYPE;
182 SingleFileInfo singleFileInfo;
183 int32_t ret = UnpackFileTransStartInfo(nullptr, &info, &singleFileInfo, packetSize);
184 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
185 ret = UnpackFileTransStartInfo(&fileFrame, nullptr, &singleFileInfo, packetSize);
186 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
187 ret = UnpackFileTransStartInfo(&fileFrame, &info, nullptr, packetSize);
188 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
189
190 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
191 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
192 .WillRepeatedly(Return(TEST_FILE_LENGTH));
193 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_FILE_LENGTH))
194 .WillRepeatedly(Return(MAX_FILE_SIZE));
195
196 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
197 EXPECT_EQ(SOFTBUS_OK, ret);
198
199 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
200 .WillRepeatedly(Return(TEST_FILE_LENGTH));
201 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_FILE_LENGTH))
202 .WillRepeatedly(Return(MAX_FILE_SIZE + 1));
203 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
204 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
205
206 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
207 .WillRepeatedly(Return(TEST_FILE_LENGTH));
208 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_DATA_LENGTH))
209 .WillRepeatedly(Return(MAX_FILE_SIZE + 1));
210 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
211 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
212
213 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
214 .WillRepeatedly(Return(TEST_SESSION_ID));
215 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_FILE_LENGTH))
216 .WillRepeatedly(Return(MAX_FILE_SIZE + 1));
217 ret = UnpackFileTransStartInfo(&fileFrame, &info, &singleFileInfo, packetSize);
218 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
219 }
220
221 /**
222 * @tc.name: GetAndCheckFileSizeTest001
223 * @tc.desc: client get and check file size, use normal parameter.
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(ClientTransProxyFileManagerMockTest, GetAndCheckFileSizeTest001, TestSize.Level1)
228 {
229 uint64_t fileSize = MAX_FILE_SIZE + 1;
230 uint64_t frameNum = 1;
231 int32_t crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
232 uint32_t packetSize = FRAME_DATA_SEQ_OFFSET;
233 int32_t ret = GetAndCheckFileSize(nullptr, &fileSize, &frameNum, crc, packetSize);
234 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
235 ret = GetAndCheckFileSize(g_testProxyFileList[0], nullptr, &frameNum, crc, packetSize);
236 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
237 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, nullptr, crc, packetSize);
238 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
239 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
240 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_INVALID_PARAM));
241 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, crc, packetSize);
242 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
243
244 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillRepeatedly(Return(SOFTBUS_OK));
245 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, crc, packetSize);
246 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
247 fileSize = MAX_FILE_SIZE;
248 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, crc, packetSize);
249 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
250 packetSize = FRAME_DATA_SEQ_OFFSET + 1;
251 ret = GetAndCheckFileSize(g_testProxyFileList[0], &fileSize, &frameNum, crc, packetSize);
252 EXPECT_EQ(SOFTBUS_OK, ret);
253 }
254
255 /**
256 * @tc.name: SendOneFrameMiddleTest001
257 * @tc.desc: client send one frame middle test, use normal parameter.
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(ClientTransProxyFileManagerMockTest, SendOneFrameMiddleTest001, TestSize.Level1)
262 {
263 SendListenerInfo info = {
264 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
265 .seq = FILE_SEND_ACK_INTERVAL,
266 };
267 int32_t frameType = TRANS_SESSION_FILE_FIRST_FRAME;
268 int32_t ret = SendOneFrameMiddle(nullptr, frameType);
269 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
270 ret = SendOneFrameMiddle(&info, frameType);
271 EXPECT_EQ(SOFTBUS_OK, ret);
272 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
273 ret = SendOneFrameMiddle(&info, frameType);
274 EXPECT_EQ(SOFTBUS_OK, ret);
275 }
276
277 /**
278 * @tc.name: SendOneFrameRearTest001
279 * @tc.desc: client send one frame rear test, use normal parameter.
280 * @tc.type: FUNC
281 * @tc.require:
282 */
283 HWTEST_F(ClientTransProxyFileManagerMockTest, SendOneFrameRearTest001, TestSize.Level1)
284 {
285 SendListenerInfo info = {
286 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
287 .seq = FILE_SEND_ACK_INTERVAL,
288 .waitSeq = 0,
289 .waitTimeoutCount = WAIT_FRAME_ACK_TIMEOUT_COUNT,
290 };
291 int32_t frameType = TRANS_SESSION_FILE_ONLYONE_FRAME;
292 int32_t ret = SendOneFrameRear(nullptr, frameType);
293 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
294 ret = SendOneFrameRear(&info, frameType);
295 EXPECT_EQ(SOFTBUS_OK, ret);
296 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
297 ret = SendOneFrameRear(&info, frameType);
298 EXPECT_EQ(SOFTBUS_OK, ret);
299 frameType = TRANS_SESSION_FILE_FIRST_FRAME;
300 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
301 EXPECT_CALL(ClientProxyFileManagerMock, GetPendingPacketData).WillOnce(Return(SOFTBUS_OK))
302 .WillOnce(Return(SOFTBUS_ALREADY_TRIGGERED)).WillOnce(Return(SOFTBUS_TIMOUT)).WillOnce(Return(SOFTBUS_OK))
303 .WillOnce(Return(SOFTBUS_ALREADY_TRIGGERED)).WillRepeatedly(Return(SOFTBUS_TIMOUT));
304 ret = SendOneFrameRear(&info, frameType);
305 EXPECT_EQ(SOFTBUS_OK, ret);
306 ret = SendOneFrameRear(&info, frameType);
307 EXPECT_EQ(SOFTBUS_OK, ret);
308 ret = SendOneFrameRear(&info, frameType);
309 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
310 frameType = TRANS_SESSION_FILE_LAST_FRAME;
311 ret = SendOneFrameRear(&info, frameType);
312 EXPECT_EQ(SOFTBUS_OK, ret);
313 info.waitSeq = 1;
314 ret = SendOneFrameRear(&info, frameType);
315 EXPECT_EQ(SOFTBUS_OK, ret);
316 info.waitSeq = 1;
317 ret = SendOneFrameRear(&info, frameType);
318 EXPECT_EQ(SOFTBUS_OK, ret);
319 info.waitSeq = 1;
320 ret = SendOneFrameRear(&info, frameType);
321 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
322 frameType = TRANS_SESSION_ACK;
323 info.waitSeq = 1;
324 ret = SendOneFrameRear(&info, frameType);
325 EXPECT_EQ(SOFTBUS_OK, ret);
326 info.waitTimeoutCount = WAIT_FRAME_ACK_TIMEOUT_COUNT - 1;
327 ret = SendOneFrameRear(&info, frameType);
328 EXPECT_EQ(SOFTBUS_OK, ret);
329 }
330
331 /**
332 * @tc.name: SendFileCrcCheckSumTest001
333 * @tc.desc: client send file crc check sum, use normal parameter.
334 * @tc.type: FUNC
335 * @tc.require:
336 */
337 HWTEST_F(ClientTransProxyFileManagerMockTest, SendFileCrcCheckSumTest001, TestSize.Level1)
338 {
339 SendListenerInfo info = {
340 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
341 .seq = FILE_SEND_ACK_INTERVAL,
342 .osType = OH_TYPE,
343 .checkSumCRC = TEST_FILE_TEST_TXT_FILE,
344 };
345 int32_t ret = SendFileCrcCheckSum(nullptr);
346 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
347 ret = SendFileCrcCheckSum(&info);
348 EXPECT_EQ(SOFTBUS_OK, ret);
349 info.crc = APP_INFO_FILE_FEATURES_SUPPORT;
350 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
351 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillOnce(Return(FILE_MAGIC_NUMBER))
352 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
353 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillOnce(Return(TEST_FILE_LENGTH))
354 .WillRepeatedly(Return(TEST_FILE_TEST_TXT_FILE));
355 EXPECT_CALL(ClientProxyFileManagerMock, CreatePendingPacket).WillOnce(Return(SOFTBUS_INVALID_PARAM));
356 ret = SendFileCrcCheckSum(&info);
357 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
358 }
359
360 /**
361 * @tc.name: UnpackFileCrcCheckSumTest001
362 * @tc.desc: client unpack file crc check sum, use normal parameter.
363 * @tc.type: FUNC
364 * @tc.require:
365 */
366 HWTEST_F(ClientTransProxyFileManagerMockTest, UnpackFileCrcCheckSumTest001, TestSize.Level1)
367 {
368 SendListenerInfo fileInfo = {
369 .checkSumCRC = TEST_FILE_DATA_SIZE,
370 };
371 FileRecipientInfo info = {
372 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
373 .osType = OH_TYPE,
374 };
375 (void)memcpy_s(&info.recvFileInfo, sizeof(SendListenerInfo), &fileInfo, sizeof(SendListenerInfo));
376 uint8_t data[TEST_DATA_LENGTH] = {0};
377 FileFrame fileFrame = {
378 .frameLength = TEST_FILE_LENGTH,
379 .data = data,
380 .fileData = data,
381 };
382 int32_t ret = UnpackFileCrcCheckSum(nullptr, &fileFrame);
383 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
384 ret = UnpackFileCrcCheckSum(&info, nullptr);
385 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
386 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
387 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
388 fileFrame.frameLength = FRAME_HEAD_LEN + FRAME_DATA_SEQ_OFFSET + sizeof(uint64_t);
389 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
390 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(TEST_DATA_LENGTH));
391 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_DATA_LENGTH));
392 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
393 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
394 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER));
395 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll).WillOnce(Return(TEST_DATA_LENGTH));
396 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
397 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
398
399 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
400 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
401 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll)
402 .WillOnce(Return(FRAME_DATA_SEQ_OFFSET + sizeof(uint64_t)))
403 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
404 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
405 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
406
407 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHl).WillOnce(Return(FILE_MAGIC_NUMBER))
408 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
409 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusLtoHll)
410 .WillOnce(Return(FRAME_DATA_SEQ_OFFSET + sizeof(uint64_t)))
411 .WillRepeatedly(Return(TEST_ZERO));
412 ret = UnpackFileCrcCheckSum(&info, &fileFrame);
413 EXPECT_EQ(SOFTBUS_OK, ret);
414 }
415
416 /**
417 * @tc.name: FileToFrameTest001
418 * @tc.desc: client send file crc check sum, use normal parameter.
419 * @tc.type: FUNC
420 * @tc.require:
421 */
422 HWTEST_F(ClientTransProxyFileManagerMockTest, FileToFrameTest001, TestSize.Level1)
423 {
424 SendListenerInfo sendInfo = {
425 .crc = APP_INFO_FILE_FEATURES_SUPPORT,
426 .seq = FILE_SEND_ACK_INTERVAL,
427 .osType = OH_TYPE,
428 .checkSumCRC = TEST_FILE_TEST_TXT_FILE,
429 .packetSize = TEST_HEADER_LENGTH,
430 };
431 uint64_t frameNum = TEST_NUM;
432 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
433 EXPECT_CALL(ClientProxyFileManagerMock, FrameIndexToType).WillRepeatedly(Return(TRANS_SESSION_FILE_ONLYONE_FRAME));
434 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillRepeatedly(Return(FILE_MAGIC_NUMBER));
435 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillRepeatedly(Return(
436 FILE_MAGIC_NUMBER + FRAME_MAGIC_OFFSET));
437 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillRepeatedly(Return(TEST_FILE_DATA_SIZE));
438 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillRepeatedly(Return(TEST_FILE_TEST_TXT_FILE));
439 int32_t ret = FileToFrame(&sendInfo, frameNum, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE);
440 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
441 frameNum = 0;
442 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLl).WillOnce(Return(FILE_MAGIC_NUMBER))
443 .WillRepeatedly(Return(FILE_SEND_ACK_INTERVAL + 1));
444 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusHtoLll).WillOnce(Return(TEST_FILE_LENGTH))
445 .WillRepeatedly(Return(TEST_FILE_TEST_TXT_FILE));
446 EXPECT_CALL(ClientProxyFileManagerMock, CreatePendingPacket).WillOnce(Return(SOFTBUS_INVALID_PARAM));
447 ret = FileToFrame(&sendInfo, frameNum, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE);
448 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
449 sendInfo.osType = TEST_ZERO;
450 ret = FileToFrame(&sendInfo, frameNum, g_testProxyFileList[0], TEST_FILE_TEST_TXT_FILE);
451 EXPECT_EQ(SOFTBUS_OK, ret);
452 }
453
454 /**
455 * @tc.name: FileToFrameAndSendFileTest001
456 * @tc.desc: client send file crc check sum, use normal parameter.
457 * @tc.type: FUNC
458 * @tc.require:
459 */
460 HWTEST_F(ClientTransProxyFileManagerMockTest, FileToFrameAndSendFileTest001, TestSize.Level1)
461 {
462 SendListenerInfo sendInfo = {
463 .crc = APP_INFO_FILE_FEATURES_NO_SUPPORT,
464 .seq = FILE_SEND_ACK_INTERVAL,
465 .osType = OH_TYPE,
466 .checkSumCRC = TEST_FILE_TEST_TXT_FILE,
467 .packetSize = FRAME_DATA_SEQ_OFFSET + 1,
468 };
469 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
470 EXPECT_CALL(ClientProxyFileManagerMock, CheckDestFilePathValid).WillOnce(Return(false));
471 int32_t ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
472 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
473 EXPECT_CALL(ClientProxyFileManagerMock, CheckDestFilePathValid).WillRepeatedly(Return(true));
474 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillOnce(Return(SOFTBUS_INVALID_PARAM));
475 ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
476 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
477 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillRepeatedly(Return(SOFTBUS_OK));
478 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_INVALID_PARAM));
479 ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
480 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
481 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillRepeatedly(Return(SOFTBUS_OK));
482 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusOpenFile).WillOnce(Return(-1));
483 ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
484 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
485 sendInfo.osType = TEST_ZERO;
486 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusOpenFile).WillRepeatedly(Return(1));
487 EXPECT_CALL(ClientProxyFileManagerMock, TryFileLock).WillOnce(Return(SOFTBUS_OK));
488 ret = FileToFrameAndSendFile(&sendInfo, g_testProxyFileList[0], g_testProxyFileList[1]);
489 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
490 }
491
492 /**
493 * @tc.name: ClearSendInfoTest001
494 * @tc.desc: client send file crc check sum, use normal parameter.
495 * @tc.type: FUNC
496 * @tc.require:
497 */
498 HWTEST_F(ClientTransProxyFileManagerMockTest, ClearSendInfoTest001, TestSize.Level1)
499 {
500 SendListenerInfo testSendInfo = {
501 .fd = -1,
502 .fileSize = 1,
503 };
504 ClearSendInfo(&testSendInfo);
505 EXPECT_EQ(0, testSendInfo.fileSize);
506 }
507
508 /**
509 * @tc.name: GetFileSizeTest001
510 * @tc.desc: client send file crc check sum, use normal parameter.
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(ClientTransProxyFileManagerMockTest, GetFileSizeTest001, TestSize.Level1)
515 {
516 uint64_t fileSize = TEST_PACKET_SIZE;
517 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
518 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillRepeatedly(Return(SOFTBUS_OK));
519 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_INVALID_PARAM));
520 int32_t ret = GetFileSize(g_testProxyFileList[0], &fileSize);
521 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
522
523 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_OK));
524 ret = GetFileSize(g_testProxyFileList[0], &fileSize);
525 EXPECT_EQ(SOFTBUS_OK, ret);
526 }
527
528 /**
529 * @tc.name: ProxyStartSendFileTest001
530 * @tc.desc: client send file crc check sum, use normal parameter.
531 * @tc.type: FUNC
532 * @tc.require:
533 */
534 HWTEST_F(ClientTransProxyFileManagerMockTest, ProxyStartSendFileTest001, TestSize.Level1)
535 {
536 SendListenerInfo testSendInfo = {
537 .fd = -1,
538 .fileSize = 1,
539 };
540 uint32_t fileCnt = 1;
541 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
542 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillRepeatedly(Return(SOFTBUS_OK));
543 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillOnce(Return(SOFTBUS_INVALID_PARAM));
544 int32_t ret = ProxyStartSendFile(&testSendInfo, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
545 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
546
547 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillRepeatedly(Return(SOFTBUS_OK));
548 EXPECT_CALL(ClientProxyFileManagerMock, CheckDestFilePathValid).WillOnce(Return(false));
549 ret = ProxyStartSendFile(&testSendInfo, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
550 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
551
552 fileCnt = 0;
553 ret = ProxyStartSendFile(&testSendInfo, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
554 EXPECT_EQ(SOFTBUS_OK, ret);
555 }
556
557 /**
558 * @tc.name: GetSendListenerInfoByChannelIdTest001
559 * @tc.desc: client send file crc check sum, use normal parameter.
560 * @tc.type: FUNC
561 * @tc.require:
562 */
563 HWTEST_F(ClientTransProxyFileManagerMockTest, GetSendListenerInfoByChannelIdTest001, TestSize.Level1)
564 {
565 SendListenerInfo *info = (SendListenerInfo *)SoftBusCalloc(sizeof(SendListenerInfo));
566 EXPECT_TRUE(info != nullptr);
567 info->sessionId = TEST_SESSION_ID;
568 int32_t channelId = TEST_CHANNEL_ID;
569 int32_t osType = OH_TYPE;
570 // will free in ClientTransProxyDelChannelInfo
571 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
572 ASSERT_TRUE(channelInfo != nullptr);
573
574 int32_t ret = GetSendListenerInfoByChannelId(channelId, nullptr, osType);
575 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
576 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
577 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_NO_INIT));
578 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
579 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
580
581 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
582 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionDataById).WillOnce(Return(SOFTBUS_INVALID_PARAM));
583 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
584 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
585
586 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionDataById).WillRepeatedly(Return(SOFTBUS_OK));
587 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetFileConfigInfoById).WillOnce(Return(SOFTBUS_NO_INIT));
588 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
589 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
590
591 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetFileConfigInfoById).WillRepeatedly(Return(SOFTBUS_OK));
592 EXPECT_CALL(ClientProxyFileManagerMock, TransGetFileListener).WillOnce(Return(SOFTBUS_INVALID_PARAM));
593 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
594 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
595
596 EXPECT_CALL(ClientProxyFileManagerMock, TransGetFileListener).WillRepeatedly(Return(SOFTBUS_OK));
597 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
598 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
599
600 ret = ClientTransProxyAddChannelInfo(channelInfo);
601 EXPECT_EQ(SOFTBUS_OK, ret);
602 ret = GetSendListenerInfoByChannelId(channelId, info, osType);
603 EXPECT_EQ(SOFTBUS_OK, ret);
604 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
605 EXPECT_EQ(SOFTBUS_OK, ret);
606 SoftBusFree(info);
607 }
608
609 /**
610 * @tc.name: CreateSendListenerInfoTest001
611 * @tc.desc: client send file crc check sum, use normal parameter.
612 * @tc.type: FUNC
613 * @tc.require:
614 */
615 HWTEST_F(ClientTransProxyFileManagerMockTest, CreateSendListenerInfoTest001, TestSize.Level1)
616 {
617 // will free in DelSendListenerInfo
618 SendListenerInfo *info = (SendListenerInfo *)SoftBusCalloc(sizeof(SendListenerInfo));
619 EXPECT_TRUE(info != nullptr);
620 info->sessionId = TEST_SESSION_ID;
621 int32_t channelId = TEST_CHANNEL_ID;
622 int32_t osType = OH_TYPE;
623 // will free in ClientTransProxyDelChannelInfo
624 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
625 ASSERT_TRUE(channelInfo != nullptr);
626 int32_t ret = ClientTransProxyAddChannelInfo(channelInfo);
627 EXPECT_EQ(SOFTBUS_OK, ret);
628
629 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
630 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
631 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionDataById).WillRepeatedly(Return(SOFTBUS_OK));
632 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetFileConfigInfoById).WillRepeatedly(Return(SOFTBUS_OK));
633 EXPECT_CALL(ClientProxyFileManagerMock, TransGetFileListener).WillRepeatedly(Return(SOFTBUS_OK));
634 ret = CreateSendListenerInfo(&info, channelId, osType);
635 EXPECT_EQ(SOFTBUS_OK, ret);
636
637 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
638 EXPECT_EQ(SOFTBUS_OK, ret);
639 ReleaseSendListenerInfo(info);
640 }
641
642 /**
643 * @tc.name: HandleFileSendingProcessTest001
644 * @tc.desc: client send file crc check sum, use normal parameter.
645 * @tc.type: FUNC
646 * @tc.require:
647 */
648 HWTEST_F(ClientTransProxyFileManagerMockTest, HandleFileSendingProcessTest001, TestSize.Level1)
649 {
650 int channelId = TEST_CHANNEL_ID;
651 uint32_t fileCnt = 1;
652 // will free in ClientTransProxyDelChannelInfo
653 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
654 ASSERT_TRUE(channelInfo != nullptr);
655 int32_t ret = ClientTransProxyAddChannelInfo(channelInfo);
656 EXPECT_EQ(SOFTBUS_OK, ret);
657
658 NiceMock<ClientTransProxyFileManagerInterfaceMock> ClientProxyFileManagerMock;
659 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
660 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetSessionDataById).WillRepeatedly(Return(SOFTBUS_OK));
661 EXPECT_CALL(ClientProxyFileManagerMock, ClientGetFileConfigInfoById).WillRepeatedly(Return(SOFTBUS_OK));
662 EXPECT_CALL(ClientProxyFileManagerMock, TransGetFileListener).WillRepeatedly(Return(SOFTBUS_OK));
663 EXPECT_CALL(ClientProxyFileManagerMock, GetAndCheckRealPath).WillRepeatedly(Return(SOFTBUS_OK));
664 EXPECT_CALL(ClientProxyFileManagerMock, SoftBusGetFileSize).WillRepeatedly(Return(SOFTBUS_OK));
665 EXPECT_CALL(ClientProxyFileManagerMock, CheckDestFilePathValid).WillOnce(Return(false));
666 ret = HandleFileSendingProcess(channelId, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
667 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SENDMSG_ERR, ret);
668
669 fileCnt = 0;
670 ret = HandleFileSendingProcess(channelId, &g_testProxyFileList[0], &g_testProxyFileList[1], fileCnt);
671 EXPECT_EQ(SOFTBUS_OK, ret);
672
673 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
674 EXPECT_EQ(SOFTBUS_OK, ret);
675 }
676
677 /**
678 * @tc.name: ClientTransProxyAddChannelInfoTest001
679 * @tc.desc: client send file crc check sum, use normal parameter.
680 * @tc.type: FUNC
681 * @tc.require:
682 */
683 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxyAddChannelInfoTest001, TestSize.Level1)
684 {
685 // will free in ClientTransProxyDelChannelInfo
686 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
687 ASSERT_TRUE(channelInfo != nullptr);
688 int32_t ret = ClientTransProxyAddChannelInfo(nullptr);
689 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
690 ret = ClientTransProxyAddChannelInfo(channelInfo);
691 EXPECT_EQ(SOFTBUS_OK, ret);
692 ret = ClientTransProxyAddChannelInfo(channelInfo);
693 EXPECT_EQ(SOFTBUS_ALREADY_EXISTED, ret);
694
695 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
696 EXPECT_EQ(SOFTBUS_OK, ret);
697 }
698
699 /**
700 * @tc.name: ClientTransProxyOnChannelOpenedTest001
701 * @tc.desc: client send file crc check sum, use normal parameter.
702 * @tc.type: FUNC
703 * @tc.require:
704 */
705 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxyOnChannelOpenedTest001, TestSize.Level1)
706 {
707 ChannelInfo channel = {
708 .channelId = TEST_CHANNEL_ID,
709 .isEncrypt = true,
710 .linkType = LANE_HML,
711 .osType = OH_TYPE,
712 .sessionKey = const_cast<char *>(TEST_SESSION_KEY),
713 };
714 // will free in ClientTransProxyDelChannelInfo
715 ClientProxyChannelInfo *channelInfo = TestCreatInfo();
716 ASSERT_TRUE(channelInfo != nullptr);
717 int32_t ret = ClientTransProxyAddChannelInfo(channelInfo);
718 EXPECT_EQ(SOFTBUS_OK, ret);
719 ret = ClientTransProxyOnChannelOpened(TEST_SESSION_NAME, &channel, nullptr);
720 EXPECT_EQ(SOFTBUS_ALREADY_EXISTED, ret);
721 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
722 EXPECT_EQ(SOFTBUS_OK, ret);
723 }
724
725 /**
726 * @tc.name: TransProxySessionDataLenCheckTest001
727 * @tc.desc: client send file crc check sum, use normal parameter.
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 HWTEST_F(ClientTransProxyFileManagerMockTest, TransProxySessionDataLenCheckTest001, TestSize.Level1)
732 {
733 uint32_t len = TEST_DATA_LEN;
734 SessionPktType type = TRANS_SESSION_MESSAGE;
735 int32_t ret = TransProxySessionDataLenCheck(len, type);
736 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
737 type = TRANS_SESSION_BYTES;
738 ret = TransProxySessionDataLenCheck(len, type);
739 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
740 type = TRANS_SESSION_FILE_LAST_FRAME;
741 ret = TransProxySessionDataLenCheck(len, type);
742 EXPECT_EQ(SOFTBUS_OK, ret);
743 len = 0;
744 type = TRANS_SESSION_ASYNC_MESSAGE;
745 ret = TransProxySessionDataLenCheck(len, type);
746 EXPECT_EQ(SOFTBUS_OK, ret);
747 type = TRANS_SESSION_BYTES;
748 ret = TransProxySessionDataLenCheck(len, type);
749 EXPECT_EQ(SOFTBUS_OK, ret);
750 }
751
752 /**
753 * @tc.name: ClientTransProxyDecryptPacketDataTest001
754 * @tc.desc: client send file crc check sum, use normal parameter.
755 * @tc.type: FUNC
756 * @tc.require:
757 */
758 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxyDecryptPacketDataTest001, TestSize.Level1)
759 {
760 int32_t channelId = TEST_CHANNEL_ID;
761 int32_t seq = TEST_SEQ;
762 ProxyDataInfo dataInfo;
763 int32_t ret = ClientTransProxyDecryptPacketData(channelId, seq, &dataInfo);
764 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
765
766 ret = TransProxyCheckSliceHead(nullptr);
767 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
768 }
769
770 /**
771 * @tc.name: ClientTransProxyProcSendMsgAckTest001
772 * @tc.desc: client send file crc check sum, use normal parameter.
773 * @tc.type: FUNC
774 * @tc.require:
775 */
776 HWTEST_F(ClientTransProxyFileManagerMockTest, ClientTransProxyProcSendMsgAckTest001, TestSize.Level1)
777 {
778 int32_t channelId = TEST_CHANNEL_ID;
779 int32_t len = TEST_DATA_LEN;
780 int32_t dataHeadSeq = TEST_DATA_LEN;
781 int32_t ret = ClientTransProxyProcSendMsgAck(channelId, TEST_SESSION_NAME, len, dataHeadSeq, 0);
782 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
783
784 len = PROXY_ACK_SIZE;
785 ret = ClientTransProxyProcSendMsgAck(channelId, nullptr, len, dataHeadSeq, 0);
786 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL, ret);
787 }
788 } // namespace OHOS