1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <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 "trans_client_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_CHANNEL_ID 1049
34 #define TEST_IS_ENCRYPTED 1
35 #define TEST_LINK_TYPE 11
36 #define TEST_OS_TYPE 10
37 #define TEST_SEQ 1234
38 #define TEST_DATA_LENGTH 9
39 #define TEST_DATA "testdata"
40
41 static const char *TEST_SESSION_NAME = "test.trans.proxy.demo";
42
43 namespace OHOS {
44
45 class TransClientProxyFileManagerMockTest : public testing::Test {
46 public:
TransClientProxyFileManagerMockTest()47 TransClientProxyFileManagerMockTest() {}
~TransClientProxyFileManagerMockTest()48 ~TransClientProxyFileManagerMockTest() {}
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
SetUp()51 void SetUp() override {}
TearDown()52 void TearDown() override {}
53 };
54
SetUpTestCase(void)55 void TransClientProxyFileManagerMockTest::SetUpTestCase(void)
56 {
57 }
58
TearDownTestCase(void)59 void TransClientProxyFileManagerMockTest::TearDownTestCase(void)
60 {
61 }
62
TestOnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)63 static int32_t TestOnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
64 {
65 (void)channelId;
66 (void)channelType;
67 (void)reason;
68 return SOFTBUS_INVALID_PARAM;
69 }
70
TestOnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)71 int32_t TestOnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
72 {
73 (void)channelId;
74 (void)channelType;
75 (void)errCode;
76 return SOFTBUS_INVALID_PARAM;
77 }
78
79 IClientSessionCallBack cb {
80 .OnSessionClosed = TestOnSessionClosed,
81 .OnSessionOpenFailed = TestOnSessionOpenFailed,
82 };
83
TestCreateClientProxyChannelInfo()84 static ClientProxyChannelInfo *TestCreateClientProxyChannelInfo()
85 {
86 ClientProxyChannelInfo *info = (ClientProxyChannelInfo *)SoftBusCalloc(sizeof(ClientProxyChannelInfo));
87 if (info == NULL) {
88 TRANS_LOGE(TRANS_SDK, "info is null");
89 return NULL;
90 }
91 info->channelId = TEST_CHANNEL_ID;
92 info->detail.isEncrypted = TEST_IS_ENCRYPTED;
93 info->detail.sequence = 0;
94 info->detail.linkType = TEST_LINK_TYPE;
95 info->detail.osType = TEST_OS_TYPE;
96 return info;
97 }
98
99 /**
100 * @tc.name: ClientTransProxyListInitTest001
101 * @tc.desc: use normal parameter.
102 * @tc.type: FUNC
103 * @tc.require:
104 */
105 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyListInitTest001, TestSize.Level1)
106 {
107 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
108 EXPECT_CALL(TransProxyFileManagerMock, CreateSoftBusList).WillOnce(Return(nullptr));
109 int32_t ret = ClientTransProxyListInit();
110 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
111 SoftBusList *list = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
112 ASSERT_NE(nullptr, list);
113 SoftBusMutexAttr mutexAttr;
114 mutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
115 ret = SoftBusMutexInit(&list->lock, &mutexAttr);
116 EXPECT_EQ(SOFTBUS_OK, ret);
117 ListInit(&list->list);
118 SoftBusList *testList = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
119 ASSERT_NE(nullptr, testList);
120 SoftBusMutexAttr testMutexAttr;
121 testMutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
122 ret = SoftBusMutexInit(&testList->lock, &testMutexAttr);
123 EXPECT_EQ(SOFTBUS_OK, ret);
124 ListInit(&testList->list);
125 SoftBusList *testListTest = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
126 ASSERT_NE(nullptr, testListTest);
127 SoftBusMutexAttr testMutexAttrTest;
128 testMutexAttrTest.type = SOFTBUS_MUTEX_RECURSIVE;
129 ret = SoftBusMutexInit(&testListTest->lock, &testMutexAttrTest);
130 EXPECT_EQ(SOFTBUS_OK, ret);
131 ListInit(&testListTest->list);
132
133 EXPECT_CALL(TransProxyFileManagerMock, CreateSoftBusList).WillOnce(Return(list)).WillOnce(Return(nullptr));
134 ret = ClientTransProxyListInit();
135 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
136
137 EXPECT_CALL(TransProxyFileManagerMock, CreateSoftBusList).WillOnce(Return(testListTest)).WillOnce(Return(testList));
138 EXPECT_CALL(TransProxyFileManagerMock, RegisterTimeoutCallback).WillOnce(Return(SOFTBUS_INVALID_PARAM));
139 ret = ClientTransProxyListInit();
140 EXPECT_EQ(SOFTBUS_TIMOUT, ret);
141 }
142
143 /**
144 * @tc.name: ClientTransProxyListInitTest002
145 * @tc.desc: use normal parameter.
146 * @tc.type: FUNC
147 * @tc.require:
148 */
149 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyListInitTest002, TestSize.Level1)
150 {
151 SoftBusList *list = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
152 ASSERT_NE(nullptr, list);
153 SoftBusMutexAttr mutexAttr;
154 mutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
155 int32_t ret = SoftBusMutexInit(&list->lock, &mutexAttr);
156 EXPECT_EQ(SOFTBUS_OK, ret);
157 ListInit(&list->list);
158 SoftBusList *testList = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
159 ASSERT_NE(nullptr, testList);
160 SoftBusMutexAttr testMutexAttr;
161 testMutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
162 ret = SoftBusMutexInit(&testList->lock, &testMutexAttr);
163 EXPECT_EQ(SOFTBUS_OK, ret);
164 ListInit(&testList->list);
165
166 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
167 EXPECT_CALL(TransProxyFileManagerMock, CreateSoftBusList).WillOnce(Return(list)).WillOnce(Return(testList));
168 EXPECT_CALL(TransProxyFileManagerMock, RegisterTimeoutCallback).WillOnce(Return(SOFTBUS_OK));
169 ret = ClientTransProxyListInit();
170 EXPECT_EQ(SOFTBUS_OK, ret);
171 EXPECT_CALL(TransProxyFileManagerMock, UnRegisterTimeoutCallback).WillOnce(Return(SOFTBUS_INVALID_PARAM));
172 ClientTransProxyListDeinit();
173 EXPECT_CALL(TransProxyFileManagerMock, UnRegisterTimeoutCallback).WillOnce(Return(SOFTBUS_OK));
174 ClientTransProxyListDeinit();
175 }
176
177 /**
178 * @tc.name: ClientTransProxyListInitTest003
179 * @tc.desc: use normal parameter.
180 * @tc.type: FUNC
181 * @tc.require:
182 */
183 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyListInitTest003, TestSize.Level1)
184 {
185 int32_t ret = ClientTransProxyInit(nullptr);
186 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
187 SoftBusList *list = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
188 ASSERT_NE(nullptr, list);
189 SoftBusMutexAttr mutexAttr;
190 mutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
191 ret = SoftBusMutexInit(&list->lock, &mutexAttr);
192 EXPECT_EQ(SOFTBUS_OK, ret);
193 ListInit(&list->list);
194 SoftBusList *testList = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
195 ASSERT_NE(nullptr, testList);
196 SoftBusMutexAttr testMutexAttr;
197 testMutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
198 ret = SoftBusMutexInit(&testList->lock, &testMutexAttr);
199 EXPECT_EQ(SOFTBUS_OK, ret);
200 ListInit(&testList->list);
201
202 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
203 EXPECT_CALL(TransProxyFileManagerMock, InitPendingPacket).WillOnce(Return(SOFTBUS_INVALID_PARAM));
204 ret = ClientTransProxyInit(&cb);
205 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
206 EXPECT_CALL(TransProxyFileManagerMock, InitPendingPacket).WillRepeatedly(Return(SOFTBUS_OK));
207 EXPECT_CALL(TransProxyFileManagerMock, CreateSoftBusList).WillOnce(Return(list)).WillOnce(Return(testList));
208 EXPECT_CALL(TransProxyFileManagerMock, RegisterTimeoutCallback).WillRepeatedly(Return(SOFTBUS_OK));
209 EXPECT_CALL(TransProxyFileManagerMock, PendingInit).WillOnce(Return(SOFTBUS_INVALID_PARAM));
210 ret = ClientTransProxyInit(&cb);
211 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
212 EXPECT_CALL(TransProxyFileManagerMock, UnRegisterTimeoutCallback).WillOnce(Return(SOFTBUS_OK));
213 ClientTransProxyListDeinit();
214 }
215
216 /**
217 * @tc.name: ClientTransProxyListInitTest004
218 * @tc.desc: use normal parameter.
219 * @tc.type: FUNC
220 * @tc.require:
221 */
222 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyListInitTest004, TestSize.Level1)
223 {
224 SoftBusList *list = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
225 ASSERT_NE(nullptr, list);
226 SoftBusMutexAttr mutexAttr;
227 mutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
228 int32_t ret = SoftBusMutexInit(&list->lock, &mutexAttr);
229 EXPECT_EQ(SOFTBUS_OK, ret);
230 ListInit(&list->list);
231 SoftBusList *testList = (SoftBusList *)SoftBusCalloc(sizeof(SoftBusList));
232 ASSERT_NE(nullptr, testList);
233 SoftBusMutexAttr testMutexAttr;
234 testMutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
235 ret = SoftBusMutexInit(&testList->lock, &testMutexAttr);
236 EXPECT_EQ(SOFTBUS_OK, ret);
237 ListInit(&testList->list);
238
239 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
240 EXPECT_CALL(TransProxyFileManagerMock, InitPendingPacket).WillRepeatedly(Return(SOFTBUS_OK));
241 EXPECT_CALL(TransProxyFileManagerMock, CreateSoftBusList).WillOnce(Return(list)).WillOnce(Return(testList));
242 EXPECT_CALL(TransProxyFileManagerMock, RegisterTimeoutCallback).WillRepeatedly(Return(SOFTBUS_OK));
243 EXPECT_CALL(TransProxyFileManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
244 ret = ClientTransProxyInit(&cb);
245 EXPECT_EQ(SOFTBUS_OK, ret);
246 }
247
248 /**
249 * @tc.name: ClientTransProxyAddChannelInfoTest001
250 * @tc.desc: use normal parameter.
251 * @tc.type: FUNC
252 * @tc.require:
253 */
254 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyAddChannelInfoTest001, TestSize.Level1)
255 {
256 ProxyChannelInfoDetail detailInfo;
257 int32_t osType;
258 int32_t linkType;
259 ClientProxyChannelInfo *info = TestCreateClientProxyChannelInfo();
260 ASSERT_NE(nullptr, info);
261 int32_t ret = ClientTransProxyAddChannelInfo(nullptr);
262 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
263 ret = ClientTransProxyAddChannelInfo(info);
264 EXPECT_EQ(SOFTBUS_OK, ret);
265
266 ret = ClientTransProxyGetInfoByChannelId(TEST_CHANNEL_ID, nullptr);
267 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
268 ret = ClientTransProxyGetInfoByChannelId(TEST_CHANNEL_ID + 1, &detailInfo);
269 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
270 ret = ClientTransProxyGetInfoByChannelId(TEST_CHANNEL_ID, &detailInfo);
271 EXPECT_EQ(SOFTBUS_OK, ret);
272
273 ret = ClientTransProxyGetOsTypeByChannelId(TEST_CHANNEL_ID, nullptr);
274 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
275 ret = ClientTransProxyGetOsTypeByChannelId(TEST_CHANNEL_ID + 1, &osType);
276 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
277 ret = ClientTransProxyGetOsTypeByChannelId(TEST_CHANNEL_ID, &osType);
278 EXPECT_EQ(SOFTBUS_OK, ret);
279
280 ret = ClientTransProxyGetLinkTypeByChannelId(TEST_CHANNEL_ID, nullptr);
281 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
282 ret = ClientTransProxyGetLinkTypeByChannelId(TEST_CHANNEL_ID + 1, &linkType);
283 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
284 ret = ClientTransProxyGetLinkTypeByChannelId(TEST_CHANNEL_ID, &linkType);
285 EXPECT_EQ(SOFTBUS_OK, ret);
286
287 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
288 EXPECT_EQ(SOFTBUS_OK, ret);
289 }
290
291 /**
292 * @tc.name: ClientTransProxyOnChannelClosedTest001
293 * @tc.desc: use normal parameter.
294 * @tc.type: FUNC
295 * @tc.require:
296 */
297 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyOnChannelClosedTest001, TestSize.Level1)
298 {
299 ShutdownReason reason = SHUTDOWN_REASON_LNN_OFFLINE;
300 int32_t ret = ClientTransProxyOnChannelClosed(TEST_CHANNEL_ID, reason);
301 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
302 ret = ClientTransProxyOnChannelOpenFailed(TEST_CHANNEL_ID, SOFTBUS_INVALID_PARAM);
303 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
304 }
305
306 /**
307 * @tc.name: ClientTransProxyOnChannelOpenedTest001
308 * @tc.desc: use normal parameter.
309 * @tc.type: FUNC
310 * @tc.require:
311 */
312 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyOnChannelOpenedTest001, TestSize.Level1)
313 {
314 ChannelInfo channel;
315 SocketAccessInfo accessInfo;
316 int32_t ret = ClientTransProxyOnChannelOpened(nullptr, &channel, &accessInfo);
317 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
318 ret = ClientTransProxyOnChannelOpened(TEST_SESSION_NAME, nullptr, &accessInfo);
319 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
320 }
321
322 /**
323 * @tc.name: ClientTransProxyDecryptPacketDataTest001
324 * @tc.desc: use normal parameter.
325 * @tc.type: FUNC
326 * @tc.require:
327 */
328 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyDecryptPacketDataTest001, TestSize.Level1)
329 {
330 ProxyDataInfo dataInfo;
331 ClientProxyChannelInfo *info = TestCreateClientProxyChannelInfo();
332 ASSERT_NE(nullptr, info);
333 int32_t ret = ClientTransProxyAddChannelInfo(nullptr);
334 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
335 ret = ClientTransProxyAddChannelInfo(info);
336 EXPECT_EQ(SOFTBUS_OK, ret);
337 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
338 EXPECT_CALL(TransProxyFileManagerMock, TransProxyDecryptPacketData).WillRepeatedly(Return(SOFTBUS_OK));
339
340 ret = ClientTransProxyDecryptPacketData(TEST_CHANNEL_ID, TEST_SEQ, &dataInfo);
341 EXPECT_EQ(SOFTBUS_OK, ret);
342
343 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
344 EXPECT_EQ(SOFTBUS_OK, ret);
345 }
346
347 /**
348 * @tc.name: ClientTransProxySendSessionAckTest001
349 * @tc.desc: use normal parameter.
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxySendSessionAckTest001, TestSize.Level1)
354 {
355 ClientProxyChannelInfo *info = TestCreateClientProxyChannelInfo();
356 ASSERT_NE(nullptr, info);
357 int32_t ret = ClientTransProxyAddChannelInfo(nullptr);
358 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
359 info->detail.osType = OH_TYPE;
360 ret = ClientTransProxyAddChannelInfo(info);
361 EXPECT_EQ(SOFTBUS_OK, ret);
362 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
363 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
364
365 ClientTransProxySendSessionAck(TEST_CHANNEL_ID, TEST_SEQ);
366
367 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
368 EXPECT_EQ(SOFTBUS_OK, ret);
369 }
370
371 /**
372 * @tc.name: ClientTransProxySendSessionAckTest002
373 * @tc.desc: use normal parameter.
374 * @tc.type: FUNC
375 * @tc.require:
376 */
377 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxySendSessionAckTest002, TestSize.Level1)
378 {
379 ClientProxyChannelInfo *info = TestCreateClientProxyChannelInfo();
380 ASSERT_NE(nullptr, info);
381 int32_t ret = ClientTransProxyAddChannelInfo(nullptr);
382 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
383 info->detail.osType = TEST_LINK_TYPE;
384 ret = ClientTransProxyAddChannelInfo(info);
385 EXPECT_EQ(SOFTBUS_OK, ret);
386 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
387 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
388
389 ClientTransProxySendSessionAck(TEST_CHANNEL_ID, TEST_SEQ);
390
391 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
392 EXPECT_EQ(SOFTBUS_OK, ret);
393 }
394
395 /**
396 * @tc.name: ClientTransProxySendBytesAckTest001
397 * @tc.desc: use normal parameter.
398 * @tc.type: FUNC
399 * @tc.require:
400 */
401 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxySendBytesAckTest001, TestSize.Level1)
402 {
403 uint32_t dataSeq = TEST_CHANNEL_ID;
404 ClientProxyChannelInfo *info = TestCreateClientProxyChannelInfo();
405 ASSERT_NE(nullptr, info);
406 int32_t ret = ClientTransProxyAddChannelInfo(nullptr);
407 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
408 info->detail.osType = TEST_LINK_TYPE;
409 ret = ClientTransProxyAddChannelInfo(info);
410 EXPECT_EQ(SOFTBUS_OK, ret);
411 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
412 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
413
414 ClientTransProxySendBytesAck(TEST_CHANNEL_ID, TEST_SEQ, dataSeq, true);
415
416 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
417 EXPECT_EQ(SOFTBUS_OK, ret);
418 }
419
420 /**
421 * @tc.name: ClientTransProxySendBytesAckTest002
422 * @tc.desc: use normal parameter.
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxySendBytesAckTest002, TestSize.Level1)
427 {
428 uint32_t dataSeq = TEST_CHANNEL_ID;
429 ClientProxyChannelInfo *info = TestCreateClientProxyChannelInfo();
430 ASSERT_NE(nullptr, info);
431 int32_t ret = ClientTransProxyAddChannelInfo(nullptr);
432 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
433 info->detail.osType = OH_TYPE;
434 ret = ClientTransProxyAddChannelInfo(info);
435 EXPECT_EQ(SOFTBUS_OK, ret);
436 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
437 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
438
439 ClientTransProxySendBytesAck(TEST_CHANNEL_ID, TEST_SEQ, dataSeq, true);
440
441 ret = ClientTransProxyDelChannelInfo(TEST_CHANNEL_ID);
442 EXPECT_EQ(SOFTBUS_OK, ret);
443 }
444
445 /**
446 * @tc.name: ClientTransProxyPackTlvBytesTest001
447 * @tc.desc: use normal parameter.
448 * @tc.type: FUNC
449 * @tc.require:
450 */
451 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyPackTlvBytesTest001, TestSize.Level1)
452 {
453 ProxyDataInfo dataInfo;
454 ProxyChannelInfoDetail info;
455 SessionPktType flag = TRANS_SESSION_FILE_RESULT_FRAME;
456 uint32_t dataSeq = 0;
457 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
458 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillOnce(Return(SOFTBUS_INVALID_PARAM));
459 int32_t ret = ClientTransProxyPackTlvBytes(TEST_CHANNEL_ID, &dataInfo, &info, flag, dataSeq);
460 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
461 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_OK));
462 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillOnce(Return(SOFTBUS_INVALID_PARAM));
463 ret = ClientTransProxyPackTlvBytes(TEST_CHANNEL_ID, &dataInfo, &info, flag, dataSeq);
464 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
465 }
466
467 /**
468 * @tc.name: ClientTransProxyPackBytesTest001
469 * @tc.desc: use normal parameter.
470 * @tc.type: FUNC
471 * @tc.require:
472 */
473 HWTEST_F(TransClientProxyFileManagerMockTest, ClientTransProxyPackBytesTest001, TestSize.Level1)
474 {
475 ProxyDataInfo dataInfo;
476 ProxyChannelInfoDetail info;
477 SessionPktType flag = TRANS_SESSION_FILE_RESULT_FRAME;
478 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
479 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById)
480 .WillRepeatedly(DoAll(SetArgPointee<2>(true), Return(SOFTBUS_OK)));
481 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
482 int32_t ret = ClientTransProxyPackBytes(TEST_CHANNEL_ID, &dataInfo, &info, flag);
483 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
484 EXPECT_CALL(TransProxyFileManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_OK));
485 EXPECT_CALL(TransProxyFileManagerMock, TransProxyPackBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM));
486 ret = ClientTransProxyPackBytes(TEST_CHANNEL_ID, &dataInfo, &info, flag);
487 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
488 ret = ClientTransProxyPackBytes(TEST_CHANNEL_ID, nullptr, &info, flag);
489 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
490 ret = ClientTransProxyPackBytes(TEST_CHANNEL_ID, &dataInfo, nullptr, flag);
491 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
492 }
493
494 /**
495 * @tc.name: TransProxyAsyncPackAndSendDataTest002
496 * @tc.desc: use normal parameter.
497 * @tc.type: FUNC
498 * @tc.require:
499 */
500 HWTEST_F(TransClientProxyFileManagerMockTest, TransProxyAsyncPackAndSendDataTest002, TestSize.Level1)
501 {
502 int32_t ret = TransProxyChannelSendBytes(TEST_CHANNEL_ID, nullptr, TEST_DATA_LENGTH, false);
503 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
504 }
505
506 /**
507 * @tc.name: SendOneFrame001
508 * @tc.desc: use abnormal parameter.
509 * @tc.type: FUNC
510 * @tc.require:
511 */
512 HWTEST_F(TransClientProxyFileManagerMockTest, SendOneFrame001, TestSize.Level1)
513 {
514 int32_t ret = 0;
515 SendListenerInfo *sendInfo = reinterpret_cast<SendListenerInfo *>(SoftBusCalloc(sizeof(SendListenerInfo)));
516 FileFrame *fileFrame = reinterpret_cast<FileFrame *>(SoftBusCalloc(sizeof(FileFrame)));
517 sendInfo->osType = OH_TYPE;
518 sendInfo->crc = 0;
519
520 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
521 ret = SendOneFrame(sendInfo, NULL);
522 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
523
524 ret = SendOneFrame(sendInfo, fileFrame);
525 EXPECT_EQ(SOFTBUS_OK, ret);
526
527 sendInfo->osType = 0;
528 EXPECT_CALL(TransProxyFileManagerMock, ProxyChannelSendFileStream).WillOnce(Return(SOFTBUS_OK));
529 ret = SendOneFrame(sendInfo, fileFrame);
530 EXPECT_EQ(SOFTBUS_OK, ret);
531
532 SoftBusFree(sendInfo);
533 SoftBusFree(fileFrame);
534 }
535 /**
536 * @tc.name: SendFileCrcCheckSum001
537 * @tc.desc: use abnormal parameter.
538 * @tc.type: FUNC
539 * @tc.require:
540 */
541 HWTEST_F(TransClientProxyFileManagerMockTest, SendFileCrcCheckSum001, TestSize.Level1)
542 {
543 int32_t ret = 0;
544 SendListenerInfo *sendInfo = reinterpret_cast<SendListenerInfo *>(SoftBusCalloc(sizeof(SendListenerInfo)));
545 sendInfo->crc = APP_INFO_FILE_FEATURES_SUPPORT;
546
547 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
548 EXPECT_CALL(TransProxyFileManagerMock, CreatePendingPacket).WillRepeatedly(Return(SOFTBUS_OK));
549 EXPECT_CALL(TransProxyFileManagerMock, ProxyChannelSendFileStream).WillRepeatedly(Return(SOFTBUS_OK));
550 EXPECT_CALL(TransProxyFileManagerMock, GetPendingPacketData).WillOnce(Return(SOFTBUS_ALREADY_TRIGGERED));
551 ret = SendFileCrcCheckSum(sendInfo);
552 EXPECT_EQ(SOFTBUS_OK, ret);
553
554 EXPECT_CALL(TransProxyFileManagerMock, GetPendingPacketData).WillOnce(Return(SOFTBUS_OK));
555 ret = SendFileCrcCheckSum(sendInfo);
556 EXPECT_EQ(SOFTBUS_OK, ret);
557
558 EXPECT_CALL(TransProxyFileManagerMock, GetPendingPacketData).WillOnce(Return(SOFTBUS_INVALID_PARAM));
559 ret = SendFileCrcCheckSum(sendInfo);
560 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
561
562 SoftBusFree(sendInfo);
563 }
564
565 /**
566 * @tc.name: HandleSendProgress001
567 * @tc.desc: use normal parameter.
568 * @tc.type: FUNC
569 * @tc.require:
570 */
571 HWTEST_F(TransClientProxyFileManagerMockTest, HandleSendProgress001, TestSize.Level1)
572 {
573 uint64_t fileOffset = 0;
574 uint64_t fileSize = 0;
575 SendListenerInfo *sendInfo = reinterpret_cast<SendListenerInfo *>(SoftBusCalloc(sizeof(SendListenerInfo)));
576 FileListener *fileListener = reinterpret_cast<FileListener *>(SoftBusCalloc(sizeof(FileListener)));
577
578 (void)HandleSendProgress(sendInfo, fileOffset, fileSize);
579
580 sendInfo->fileListener.sendListener.OnSendFileProcess = [](
__anon667ab4140102( int sessionId, uint64_t bytesUpload, uint64_t bytesTotal) 581 int sessionId, uint64_t bytesUpload, uint64_t bytesTotal) -> int {return SOFTBUS_OK;};
582 sendInfo->fileListener = *fileListener;
583 (void)HandleSendProgress(sendInfo, fileOffset, fileSize);
584
__anon667ab4140202(int32_t socket, FileEvent *event) 585 fileListener->socketSendCallback = [](int32_t socket, FileEvent *event) {};
586 sendInfo->fileListener = *fileListener;
587 (void)HandleSendProgress(sendInfo, fileOffset, fileSize);
588 EXPECT_EQ(0, fileSize);
589
590 SoftBusFree(sendInfo);
591 SoftBusFree(fileListener);
592 }
593
594 /**
595 * @tc.name: DelRecipient001
596 * @tc.desc: use normal parameter.
597 * @tc.type: FUNC
598 * @tc.require:
599 */
600 HWTEST_F(TransClientProxyFileManagerMockTest, DelRecipient001, TestSize.Level1)
601 {
602 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
603 EXPECT_CALL(TransProxyFileManagerMock, InitPendingPacket).WillRepeatedly(Return(SOFTBUS_OK));
604 int32_t ret = ClinetTransProxyFileManagerInit();
605 EXPECT_EQ(SOFTBUS_OK, ret);
606
607 FileRecipientInfo *info = reinterpret_cast<FileRecipientInfo *>(SoftBusCalloc(sizeof(FileRecipientInfo)));
608 info->channelId = 1;
609 info->sessionId = 1;
610 info->osType = 0;
611 ListInit(&info->node);
612 info->objRefCount = 1;
613 info->recvFileInfo.fileFd = INVALID_FD;
614 ListTailInsert(&g_recvRecipientInfoList, &info->node);
615
616 FileRecipientInfo *tarinfo = reinterpret_cast<FileRecipientInfo *>(SoftBusCalloc(sizeof(FileRecipientInfo)));
617 tarinfo->channelId = 2;
618 tarinfo->sessionId = 2;
619 tarinfo->osType = 10;
620 ListInit(&tarinfo->node);
621 tarinfo->objRefCount = 2;
622 tarinfo->recvFileInfo.fileFd = INVALID_FD;
623 ListTailInsert(&g_recvRecipientInfoList, &tarinfo->node);
624
625 (void)DelRecipient(info->sessionId);
626 (void)DelRecipient(tarinfo->sessionId);
627 (void)DelRecipient(tarinfo->sessionId);
628 ClinetTransProxyFileManagerDeinit();
629 }
630
631 /**
632 * @tc.name: ClientDeleteRecvFileList001
633 * @tc.desc: use abnormal parameter.
634 * @tc.type: FUNC
635 * @tc.require:
636 */
637 HWTEST_F(TransClientProxyFileManagerMockTest, ClientDeleteRecvFileList001, TestSize.Level1)
638 {
639 int32_t sessionId = -1;
640 (void)ClientDeleteRecvFileList(sessionId);
641 EXPECT_EQ(-1, sessionId);
642 }
643
644 /**
645 * @tc.name: UpdateFileReceivePath001
646 * @tc.desc: use abnormal parameter.
647 * @tc.type: FUNC
648 * @tc.require:
649 */
650 HWTEST_F(TransClientProxyFileManagerMockTest, UpdateFileReceivePath001, TestSize.Level1)
651 {
652 int32_t ret = 0;
653 FileListener *fileListener = reinterpret_cast<FileListener *>(SoftBusCalloc(sizeof(FileListener)));
__anon667ab4140302(int32_t socket, FileEvent *event)654 fileListener->socketRecvCallback = [] (int32_t socket, FileEvent *event){return;};
655
656 int32_t sessionId = 1;
657
658 ret = UpdateFileReceivePath(sessionId, fileListener);
659 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
660
661 SoftBusFree(fileListener);
662 }
663
664 /**
665 * @tc.name: HandleFileTransferCompletion001
666 * @tc.desc: use abnormal parameter.
667 * @tc.type: FUNC
668 * @tc.require:
669 */
670 HWTEST_F(TransClientProxyFileManagerMockTest, HandleFileTransferCompletion001, TestSize.Level1)
671 {
672 FileRecipientInfo *recipient = reinterpret_cast<FileRecipientInfo *>(SoftBusCalloc(sizeof(FileRecipientInfo)));
673 SingleFileInfo *file = reinterpret_cast<SingleFileInfo *>(SoftBusCalloc(sizeof(SingleFileInfo)));
674
675 int32_t sessionId = 1;
676
677 HandleFileTransferCompletion(recipient, sessionId, file);
678
679 recipient->fileListener.recvListener.OnReceiveFileStarted = [](int sessionId, const char *files, int fileCnt)
__anon667ab4140402(int sessionId, const char *files, int fileCnt) 680 -> int {return 0;};
681 HandleFileTransferCompletion(recipient, sessionId, file);
682
__anon667ab4140502(int32_t socket, FileEvent *event)683 recipient->fileListener.socketRecvCallback = [] (int32_t socket, FileEvent *event){return;};
684 HandleFileTransferCompletion(recipient, sessionId, file);
685 EXPECT_EQ(1, sessionId);
686
687 SoftBusFree(recipient);
688 SoftBusFree(file);
689 }
690
691 /**
692 * @tc.name: ProcessOneFrame001
693 * @tc.desc: use abnormal parameter.
694 * @tc.type: FUNC
695 * @tc.require:
696 */
697 HWTEST_F(TransClientProxyFileManagerMockTest, ProcessOneFrame001, TestSize.Level1)
698 {
699 int32_t ret = 0;
700 FileFrame *fileFrame = reinterpret_cast<FileFrame *>(SoftBusCalloc(sizeof(FileFrame)));
701 SingleFileInfo *fileInfo = reinterpret_cast<SingleFileInfo *>(SoftBusCalloc(sizeof(SingleFileInfo)));
702 uint32_t dataLen = MAX_FILE_SIZE + FRAME_DATA_SEQ_OFFSET + 1;
703 int32_t crc = APP_INFO_FILE_FEATURES_SUPPORT;
704 int32_t osType = OH_TYPE;
705 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
706
707 ret = ProcessOneFrame(fileFrame, dataLen, crc, fileInfo, osType);
708 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
709
710 osType = 0;
711 ret = ProcessOneFrame(fileFrame, dataLen, crc, fileInfo, osType);
712 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
713
714 dataLen = FRAME_DATA_SEQ_OFFSET + 1;
715 fileInfo->fileOffset = MAX_FILE_SIZE + 1;
716 ret = ProcessOneFrame(fileFrame, dataLen, crc, fileInfo, osType);
717 EXPECT_EQ(SOFTBUS_FILE_ERR, ret);
718
719 int64_t writeLength = dataLen - FRAME_DATA_SEQ_OFFSET;
720 fileInfo->fileOffset = MAX_FILE_SIZE - FRAME_DATA_SEQ_OFFSET;
721 EXPECT_CALL(TransProxyFileManagerMock, SoftBusPwriteFile).WillOnce(Return(writeLength));
722 ret = ProcessOneFrame(fileFrame, dataLen, crc, fileInfo, osType);
723 EXPECT_EQ(SOFTBUS_OK, ret);
724
725 SoftBusFree(fileFrame);
726 SoftBusFree(fileInfo);
727 }
728
729 /**
730 * @tc.name: UpdateFileReceptionStatus001
731 * @tc.desc: use abnormal parameter.
732 * @tc.type: FUNC
733 * @tc.require:
734 */
735 HWTEST_F(TransClientProxyFileManagerMockTest, UpdateFileReceptionStatus001, TestSize.Level1)
736 {
737 int32_t ret = 0;
738 FileFrame *fileFrame = reinterpret_cast<FileFrame *>(SoftBusCalloc(sizeof(FileFrame)));
739 SingleFileInfo *fileInfo = reinterpret_cast<SingleFileInfo *>(SoftBusCalloc(sizeof(SingleFileInfo)));
740 FileRecipientInfo *recipient = reinterpret_cast<FileRecipientInfo *>(SoftBusCalloc(sizeof(FileRecipientInfo)));
741 int32_t sessionId = 1;
742 NiceMock<TransClientProxyFileManagerInterfaceMock> TransProxyFileManagerMock;
743
744 recipient->crc = APP_INFO_FILE_FEATURES_SUPPORT;
745 ret = UpdateFileReceptionStatus(fileInfo, recipient, fileFrame, sessionId);
746 EXPECT_EQ(SOFTBUS_OK, ret);
747
748 recipient->crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
749 fileFrame->frameType = TRANS_SESSION_ACK;
750 ret = UpdateFileReceptionStatus(fileInfo, recipient, fileFrame, sessionId);
751 EXPECT_EQ(SOFTBUS_OK, ret);
752
753 recipient->fileListener.recvListener.OnReceiveFileProcess = [](int sessionId, const char *firstFile,
__anon667ab4140602(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal) 754 uint64_t bytesUpload, uint64_t bytesTotal) -> int {return 0;};
755 recipient->crc = APP_INFO_FILE_FEATURES_SUPPORT;
756 ret = UpdateFileReceptionStatus(fileInfo, recipient, fileFrame, sessionId);
757 EXPECT_EQ(SOFTBUS_OK, ret);
758
__anon667ab4140702(int32_t socket, FileEvent *event)759 recipient->fileListener.socketRecvCallback = [] (int32_t socket, FileEvent *event){return;};
760 ret = UpdateFileReceptionStatus(fileInfo, recipient, fileFrame, sessionId);
761 EXPECT_EQ(SOFTBUS_OK, ret);
762
763 SoftBusFree(fileFrame);
764 SoftBusFree(fileInfo);
765 SoftBusFree(recipient);
766 }
767
768
769 } // namespace OHOS