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 <gtest/gtest.h>
17 #include "securec.h"
18
19 #include "client_trans_proxy_file_manager.h"
20 #include "client_trans_proxy_manager.c"
21 #include "client_trans_proxy_manager_mock.h"
22 #include "client_trans_session_manager.h"
23 #include "client_trans_socket_manager.h"
24 #include "client_trans_tcp_direct_message.h"
25 #include "session.h"
26 #include "softbus_access_token_test.h"
27 #include "softbus_def.h"
28 #include "softbus_error_code.h"
29 #include "trans_proxy_process_data.h"
30
31 using namespace testing;
32 using namespace testing::ext;
33
34 namespace OHOS {
TransOnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag,SocketAccessInfo * accessInfo)35 int32_t TransOnSessionOpened(
36 const char *sessionName, const ChannelInfo *channel, SessionType flag, SocketAccessInfo *accessInfo)
37 {
38 return SOFTBUS_OK;
39 }
40
TransOnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)41 int32_t TransOnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
42 {
43 return SOFTBUS_OK;
44 }
45
TransOnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)46 int32_t TransOnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
47 {
48 return SOFTBUS_OK;
49 }
50
TransOnBytesReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)51 int32_t TransOnBytesReceived(
52 int32_t channelId, int32_t channelType, const void *data, uint32_t len, SessionPktType type)
53 {
54 return SOFTBUS_OK;
55 }
56
TransOnOnStreamRecevied(int32_t channelId,int32_t channelType,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)57 int32_t TransOnOnStreamRecevied(
58 int32_t channelId, int32_t channelType, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
59 {
60 return SOFTBUS_OK;
61 }
62
TransOnGetSessionId(int32_t channelId,int32_t channelType,int32_t * sessionId)63 int32_t TransOnGetSessionId(int32_t channelId, int32_t channelType, int32_t *sessionId)
64 {
65 return SOFTBUS_OK;
66 }
67
TransOnQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)68 int32_t TransOnQosEvent(
69 int32_t channelId, int32_t channelType, int32_t eventId, int32_t tvCount, const QosTv *tvList)
70 {
71 return SOFTBUS_OK;
72 }
73
InitSoftBusList(void)74 static SoftBusList *InitSoftBusList(void)
75 {
76 int32_t ret = 0;
77 SoftBusList *list = reinterpret_cast<SoftBusList *>(SoftBusCalloc(sizeof(SoftBusList)));
78
79 SoftBusMutexAttr mutexAttr;
80 mutexAttr.type = SOFTBUS_MUTEX_RECURSIVE;
81 ret = SoftBusMutexInit(&list->lock, &mutexAttr);
82 EXPECT_EQ(SOFTBUS_OK, ret);
83 ListInit(&list->list);
84 return list;
85 }
86
87 static IClientSessionCallBack g_clientSessionCb = {
88 .OnSessionOpened = TransOnSessionOpened,
89 .OnSessionClosed = TransOnSessionClosed,
90 .OnSessionOpenFailed = TransOnSessionOpenFailed,
91 .OnDataReceived = TransOnBytesReceived,
92 .OnStreamReceived = TransOnOnStreamRecevied,
93 .OnQosEvent = TransOnQosEvent,
94 };
95
96 class ClientTransProxyManagerMockTest : public testing::Test {
97 public:
ClientTransProxyManagerMockTest()98 ClientTransProxyManagerMockTest() {}
~ClientTransProxyManagerMockTest()99 ~ClientTransProxyManagerMockTest() {}
100 static void SetUpTestCase(void);
101 static void TearDownTestCase(void);
SetUp()102 void SetUp() override {}
TearDown()103 void TearDown() override {}
104 };
105
SetUpTestCase(void)106 void ClientTransProxyManagerMockTest::SetUpTestCase(void)
107 {
108 return;
109 }
110
TearDownTestCase(void)111 void ClientTransProxyManagerMockTest::TearDownTestCase(void)
112 {
113 return;
114 }
115
116 /**
117 * @tc.name: ClientTransProxyInit001
118 * @tc.desc: ClientTransProxyInit, use the wrong parameter
119 * @tc.type: FUNC
120 * @tc.require:
121 */
122 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyInit001, TestSize.Level1)
123 {
124 int32_t ret = 0;
125 SoftBusList *infoList = InitSoftBusList();
126 SoftBusList *sliceList = InitSoftBusList();
127 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
128 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillOnce(Return(SOFTBUS_TIMOUT))
129 .WillRepeatedly(Return(SOFTBUS_OK));
130 ret = ClientTransProxyInit(&g_clientSessionCb);
131 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
132
133 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return((SoftBusList *)NULL));
134 ret = ClientTransProxyInit(&g_clientSessionCb);
135 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
136
137 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_TIMOUT));
138 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
139 ret = ClientTransProxyInit(&g_clientSessionCb);
140 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
141
142 (void)ClientTransProxyListDeinit();
143 }
144
145 /**
146 * @tc.name: ClientTransProxyOnChannelClosed001
147 * @tc.desc: ClientTransProxyOnChannelClosed, use the wrong parameter
148 * @tc.type: FUNC
149 * @tc.require:
150 */
151 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyOnChannelClosed001, TestSize.Level1)
152 {
153 IClientSessionCallBack temcb = g_clientSessionCb;
154 temcb.OnSessionClosed = [] (int32_t channelId, int32_t channelType, ShutdownReason reason)
__anonfc6ef6750102(int32_t channelId, int32_t channelType, ShutdownReason reason) 155 -> int32_t {return SOFTBUS_INVALID_PARAM;};
156 int32_t channelId = 1;
157 ShutdownReason reason = SHUTDOWN_REASON_UNKNOWN;
158 int32_t ret = 0;
159
160 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
161 SoftBusList *infoList = InitSoftBusList();
162 SoftBusList *sliceList = InitSoftBusList();
163 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
164 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
165 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
166 ret = ClientTransProxyInit(&temcb);
167 EXPECT_EQ(SOFTBUS_OK, ret);
168
169 ret = ClientTransProxyOnChannelClosed(channelId, reason);
170 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
171
172 (void)ClientTransProxyListDeinit();
173 }
174
175 /**
176 * @tc.name: ClientTransProxySendSessionAck001
177 * @tc.desc: ClientTransProxySendSessionAck, use the nomal parameter
178 * @tc.type: FUNC
179 * @tc.require:
180 */
181 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxySendSessionAck001, TestSize.Level1)
182 {
183 int32_t ret = 0;
184 int32_t channelId = 1;
185 int32_t Seq = 0;
186 uint8_t *temSliceData = reinterpret_cast<uint8_t *>(SoftBusCalloc(sizeof(uint8_t)));
187 ClientProxyChannelInfo *info =
188 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
189 ProxyChannelInfoDetail detail = {0};
190 detail.osType = OH_TYPE;
191 info->channelId = channelId;
192 info->detail = detail;
193 info->node.next = NULL;
194 info->node.prev = NULL;
195
196 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
197 SoftBusList *infoList = InitSoftBusList();
198 SoftBusList *sliceList = InitSoftBusList();
199 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
200 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
201 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
202 ret = ClientTransProxyInit(&g_clientSessionCb);
203 EXPECT_EQ(SOFTBUS_OK, ret);
204
205 ret = ClientTransProxyAddChannelInfo(info);
206 EXPECT_EQ(SOFTBUS_OK, ret);
207
208 EXPECT_CALL(ClientProxyManagerMock, SoftBusHtoLl).WillRepeatedly(Return(Seq));
209 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillRepeatedly(Return(SOFTBUS_OK));
210 EXPECT_CALL(ClientProxyManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_OK));
211 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackData).WillRepeatedly(Return(temSliceData));
212 ClientTransProxySendSessionAck(channelId, Seq);
213
214 (void)ClientTransProxyListDeinit();
215 }
216
217 /**
218 * @tc.name: ClientTransProxySendSessionAck002
219 * @tc.desc: ClientTransProxySendSessionAck, enter the banormal branch
220 * @tc.type: FUNC
221 * @tc.require:
222 */
223 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxySendSessionAck002, TestSize.Level1)
224 {
225 int32_t ret = 0;
226 int32_t channelId = 1;
227 int32_t Seq = 0;
228 ClientProxyChannelInfo *info =
229 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
230 ProxyChannelInfoDetail detail = {0};
231 detail.osType = OH_TYPE + 1;
232 info->channelId = channelId;
233 info->detail = detail;
234 info->node.next = NULL;
235 info->node.prev = NULL;
236
237 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
238 SoftBusList *infoList = InitSoftBusList();
239 SoftBusList *sliceList = InitSoftBusList();
240 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
241 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
242 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
243 ret = ClientTransProxyInit(&g_clientSessionCb);
244 EXPECT_EQ(SOFTBUS_OK, ret);
245
246 ret = ClientTransProxyAddChannelInfo(info);
247 EXPECT_EQ(SOFTBUS_OK, ret);
248
249 EXPECT_CALL(ClientProxyManagerMock, SoftBusHtoNl).WillRepeatedly(Return(Seq));
250 EXPECT_CALL(ClientProxyManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_TIMOUT));
251 ClientTransProxySendSessionAck(channelId, Seq);
252
253 (void)ClientTransProxyListDeinit();
254 }
255
256 /**
257 * @tc.name: ClientTransProxyProcSendMsgAck001
258 * @tc.desc: ClientTransProxyProcSendMsgAck, enter the banormal branch
259 * @tc.type: FUNC
260 * @tc.require:
261 */
262 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyProcSendMsgAck001, TestSize.Level1)
263 {
264 int32_t ret = 0;
265 int32_t channelId = 1;
266 const char *data = "000";
267 int32_t len = PROXY_ACK_SIZE;
268 int32_t dataHeadSeq = 0;
269 uint32_t dataSeq = 1;
270
271 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
272 EXPECT_CALL(ClientProxyManagerMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_OK));
273 EXPECT_CALL(ClientProxyManagerMock, ClientGetSessionCallbackAdapterById).WillOnce(Return(SOFTBUS_OK));
274 EXPECT_CALL(ClientProxyManagerMock, DeleteDataSeqInfoList).WillOnce(Return(SOFTBUS_TIMOUT));
275 ret = ClientTransProxyProcSendMsgAck(channelId, data, len, dataHeadSeq, dataSeq);
276 EXPECT_EQ(SOFTBUS_TIMOUT, ret);
277
278 EXPECT_CALL(ClientProxyManagerMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_OK));
279 EXPECT_CALL(ClientProxyManagerMock, ClientGetSessionCallbackAdapterById).WillOnce(Return(SOFTBUS_TIMOUT));
280 ret = ClientTransProxyProcSendMsgAck(channelId, data, len, dataHeadSeq, dataSeq);
281 EXPECT_EQ(SOFTBUS_TIMOUT, ret);
282
283 (void)ClientTransProxyListDeinit();
284 }
285
286 /**
287 * @tc.name: ClientTransProxySendBytesAck001
288 * @tc.desc: ClientTransProxySendBytesAck, enter the normal branch
289 * @tc.type: FUNC
290 * @tc.require:
291 */
292 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxySendBytesAck001, TestSize.Level1)
293 {
294 int32_t ret = 0;
295 int32_t channelId = 1;
296 int32_t Seq = 0;
297 uint32_t dataSeq = 0;
298 bool needAck = true;
299 ClientProxyChannelInfo *info =
300 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
301 ProxyChannelInfoDetail detail = {0};
302 detail.osType = OH_TYPE;
303 info->channelId = channelId;
304 info->detail = detail;
305 info->node.next = NULL;
306 info->node.prev = NULL;
307
308 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
309 SoftBusList *infoList = InitSoftBusList();
310 SoftBusList *sliceList = InitSoftBusList();
311 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
312 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
313 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
314 ret = ClientTransProxyInit(&g_clientSessionCb);
315 EXPECT_EQ(SOFTBUS_OK, ret);
316
317 ret = ClientTransProxyAddChannelInfo(info);
318 EXPECT_EQ(SOFTBUS_OK, ret);
319
320 EXPECT_CALL(ClientProxyManagerMock, SoftBusHtoLl).WillOnce(Return(Seq));
321 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackTlvBytes).WillOnce(Return(SOFTBUS_TIMOUT));
322 ClientTransProxySendBytesAck(channelId, Seq, dataSeq, needAck);
323
324 (void)ClientTransProxyListDeinit();
325 }
326
327 /**
328 * @tc.name: ClientTransProxySendBytesAck002
329 * @tc.desc: ClientTransProxySendBytesAck, enter the abnormal branch
330 * @tc.type: FUNC
331 * @tc.require:
332 */
333 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxySendBytesAck002, TestSize.Level1)
334 {
335 int32_t ret = 0;
336 int32_t channelId = 1;
337 int32_t Seq = 0;
338 uint32_t dataSeq = 1;
339 bool needAck = true;
340 ClientProxyChannelInfo *info =
341 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
342 ProxyChannelInfoDetail detail = {0};
343 detail.osType = OH_TYPE + 1;
344 info->channelId = channelId;
345 info->detail = detail;
346 info->node.next = NULL;
347 info->node.prev = NULL;
348
349 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
350 SoftBusList *infoList = InitSoftBusList();
351 SoftBusList *sliceList = InitSoftBusList();
352 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
353 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
354 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
355 ret = ClientTransProxyInit(&g_clientSessionCb);
356 EXPECT_EQ(SOFTBUS_OK, ret);
357
358 ret = ClientTransProxyAddChannelInfo(info);
359 EXPECT_EQ(SOFTBUS_OK, ret);
360
361 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackTlvBytes).WillOnce(Return(SOFTBUS_TIMOUT));
362 ClientTransProxySendBytesAck(channelId, Seq, dataSeq, needAck);
363
364 (void)ClientTransProxyListDeinit();
365 }
366
367 /**
368 * @tc.name: ClientTransProxyProcessSessionData001
369 * @tc.desc: ClientTransProxyProcessSessionData, enter the normal branch
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyProcessSessionData001, TestSize.Level1)
374 {
375 int32_t ret = 0;
376 int32_t channelId = 1;
377 ClientProxyChannelInfo *info =
378 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
379 ProxyChannelInfoDetail detail = {0};
380 detail.osType = OH_TYPE;
381 info->channelId = channelId;
382 info->detail = detail;
383 info->node.next = NULL;
384 info->node.prev = NULL;
385
386 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
387 SoftBusList *infoList = InitSoftBusList();
388 SoftBusList *sliceList = InitSoftBusList();
389 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
390 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
391 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
392 ret = ClientTransProxyInit(&g_clientSessionCb);
393 EXPECT_EQ(SOFTBUS_OK, ret);
394
395 ret = ClientTransProxyAddChannelInfo(info);
396 EXPECT_EQ(SOFTBUS_OK, ret);
397
398 PacketHead *dataHead = reinterpret_cast<PacketHead *>(SoftBusCalloc(sizeof(PacketHead)));
399 dataHead->dataLen = OVERHEAD_LEN + 8;
400 dataHead->flags = 12;
401 const char *data = "000";
402
403 EXPECT_CALL(ClientProxyManagerMock, TransProxyDecryptPacketData).WillOnce(Return(SOFTBUS_OK));
404 ret = ClientTransProxyProcessSessionData(channelId, dataHead, data);
405 EXPECT_EQ(SOFTBUS_OK, ret);
406
407 (void)ClientTransProxyListDeinit();
408 SoftBusFree(dataHead);
409 }
410
411 /**
412 * @tc.name: ClientTransProxyProcessSessionData002
413 * @tc.desc: ClientTransProxyProcessSessionData, enter the abnormal branch
414 * @tc.type: FUNC
415 * @tc.require:
416 */
417 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyProcessSessionData002, TestSize.Level1)
418 {
419 int32_t ret = 0;
420 IClientSessionCallBack temcb = g_clientSessionCb;
421 temcb.OnDataReceived = [] (int32_t channelId, int32_t channelType,
__anonfc6ef6750202(int32_t channelId, int32_t channelType, const void *data, uint32_t len, SessionPktType type) 422 const void *data, uint32_t len, SessionPktType type) -> int32_t {return SOFTBUS_TIMOUT;};
423
424 int32_t channelId = 1;
425 ClientProxyChannelInfo *info =
426 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
427 ProxyChannelInfoDetail detail = {0};
428 detail.osType = OH_TYPE;
429 info->channelId = channelId;
430 info->detail = detail;
431 info->node.next = NULL;
432 info->node.prev = NULL;
433
434 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
435 SoftBusList *infoList = InitSoftBusList();
436 SoftBusList *sliceList = InitSoftBusList();
437 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
438 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
439 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
440 ret = ClientTransProxyInit(&temcb);
441 EXPECT_EQ(SOFTBUS_OK, ret);
442
443 ret = ClientTransProxyAddChannelInfo(info);
444 EXPECT_EQ(SOFTBUS_OK, ret);
445
446 PacketHead *dataHead = (PacketHead *)SoftBusCalloc(sizeof(PacketHead));
447 dataHead->dataLen = OVERHEAD_LEN + 8;
448 dataHead->flags = 12;
449 const char *data = "000";
450
451 ret = ClientTransProxyProcessSessionData(channelId, dataHead, data);
452 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
453
454 EXPECT_CALL(ClientProxyManagerMock, TransProxySessionDataLenCheck).WillOnce(Return(SOFTBUS_TIMOUT));
455 ret = ClientTransProxyProcessSessionData(channelId, dataHead, data);
456 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
457
458 (void)ClientTransProxyListDeinit();
459 SoftBusFree(dataHead);
460 }
461
462 /**
463 * @tc.name: ClientTransProxyProcData001
464 * @tc.desc: ClientTransProxyProcData, enter the normal branch
465 * @tc.type: FUNC
466 * @tc.require:
467 */
468 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyProcData001, TestSize.Level1)
469 {
470 int32_t ret = 0;
471 int32_t channelId = 1;
472 ClientProxyChannelInfo *info =
473 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
474 ProxyChannelInfoDetail detail = {0};
475 detail.osType = OH_TYPE;
476 info->channelId = channelId;
477 info->detail = detail;
478 info->node.next = NULL;
479 info->node.prev = NULL;
480
481 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
482 SoftBusList *infoList = InitSoftBusList();
483 SoftBusList *sliceList = InitSoftBusList();
484 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
485 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
486 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
487 ret = ClientTransProxyInit(&g_clientSessionCb);
488 EXPECT_EQ(SOFTBUS_OK, ret);
489
490 ret = ClientTransProxyAddChannelInfo(info);
491 EXPECT_EQ(SOFTBUS_OK, ret);
492
493 DataHeadTlvPacketHead *dataHead = (DataHeadTlvPacketHead *)SoftBusCalloc(sizeof(DataHeadTlvPacketHead));
494 dataHead->dataLen = OVERHEAD_LEN + 8;
495 dataHead->flags = 12;
496 const char *data = "000";
497
498 ret = ClientTransProxyProcData(channelId, dataHead, data);
499 EXPECT_EQ(SOFTBUS_OK, ret);
500
501 (void)ClientTransProxyListDeinit();
502 SoftBusFree(dataHead);
503 }
504
505 /**
506 * @tc.name: ClientTransProxyProcData002
507 * @tc.desc: ClientTransProxyProcData, enter the abnormal branch
508 * @tc.type: FUNC
509 * @tc.require:
510 */
511 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyProcData002, TestSize.Level1)
512 {
513 int32_t ret = 0;
514 IClientSessionCallBack temcb = g_clientSessionCb;
515 temcb.OnDataReceived = [] (int32_t channelId, int32_t channelType,
__anonfc6ef6750302(int32_t channelId, int32_t channelType, const void *data, uint32_t len, SessionPktType type) 516 const void *data, uint32_t len, SessionPktType type) -> int32_t {return SOFTBUS_TIMOUT;};
517
518 int32_t channelId = 1;
519 ClientProxyChannelInfo *info =
520 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
521 ProxyChannelInfoDetail detail = {0};
522 detail.osType = OH_TYPE;
523 info->channelId = channelId;
524 info->detail = detail;
525 info->node.next = NULL;
526 info->node.prev = NULL;
527
528 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
529 SoftBusList *infoList = InitSoftBusList();
530 SoftBusList *sliceList = InitSoftBusList();
531 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
532 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
533 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
534 ret = ClientTransProxyInit(&temcb);
535 EXPECT_EQ(SOFTBUS_OK, ret);
536
537 ret = ClientTransProxyAddChannelInfo(info);
538 EXPECT_EQ(SOFTBUS_OK, ret);
539
540 DataHeadTlvPacketHead *dataHead = (DataHeadTlvPacketHead *)SoftBusCalloc(sizeof(DataHeadTlvPacketHead));
541 dataHead->dataLen = OVERHEAD_LEN + 8;
542 dataHead->flags = 12;
543 const char *data = "000";
544
545 ret = ClientTransProxyProcData(channelId, dataHead, data);
546 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
547
548 EXPECT_CALL(ClientProxyManagerMock, TransProxySessionDataLenCheck).WillOnce(Return(SOFTBUS_TIMOUT));
549 ret = ClientTransProxyProcData(channelId, dataHead, data);
550 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
551
552 (void)ClientTransProxyListDeinit();
553 SoftBusFree(dataHead);
554 }
555
556 /**
557 * @tc.name: TransProxyAsyncPackAndSendData001
558 * @tc.desc: TransProxyAsyncPackAndSendData, enter the normal branch
559 * @tc.type: FUNC
560 * @tc.require:
561 */
562 HWTEST_F(ClientTransProxyManagerMockTest, TransProxyAsyncPackAndSendData001, TestSize.Level1)
563 {
564 int32_t ret = 0;
565 int32_t channelId = 1;
566 const void *data = SoftBusCalloc(sizeof(int32_t));
567 uint32_t len = 4 * 1024;
568 uint32_t dataSeq = 0;
569 uint8_t *temSliceData = reinterpret_cast<uint8_t *>(SoftBusCalloc(sizeof(uint8_t)));
570 SessionPktType pktType = TRANS_SESSION_BYTES;
571
572 ClientProxyChannelInfo *info =
573 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
574 ProxyChannelInfoDetail detail = {0};
575 detail.osType = OH_TYPE;
576 info->channelId = channelId;
577 info->detail = detail;
578 info->node.next = NULL;
579 info->node.prev = NULL;
580
581 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
582 SoftBusList *infoList = InitSoftBusList();
583 SoftBusList *sliceList = InitSoftBusList();
584 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
585 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
586 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
587 ret = ClientTransProxyInit(&g_clientSessionCb);
588 EXPECT_EQ(SOFTBUS_OK, ret);
589
590 ret = ClientTransProxyAddChannelInfo(info);
591 EXPECT_EQ(SOFTBUS_OK, ret);
592
593 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackTlvBytes).WillOnce(Return(SOFTBUS_OK));
594 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackData).WillRepeatedly(Return(temSliceData));
595 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillRepeatedly(Return(SOFTBUS_OK));
596 ret = TransProxyAsyncPackAndSendData(channelId, data, len, dataSeq, pktType);
597 EXPECT_EQ(SOFTBUS_OK, ret);
598
599 (void)ClientTransProxyListDeinit();
600 }
601
602 /**
603 * @tc.name: TransProxyAsyncPackAndSendData002
604 * @tc.desc: TransProxyAsyncPackAndSendData, enter the abnormal branch
605 * @tc.type: FUNC
606 * @tc.require:
607 */
608 HWTEST_F(ClientTransProxyManagerMockTest, TransProxyAsyncPackAndSendData002, TestSize.Level1)
609 {
610 int32_t ret = 0;
611 int32_t channelId = 1;
612 const void *data = SoftBusCalloc(sizeof(int32_t));
613 uint32_t len = 4 * 1024;
614 uint32_t dataSeq = 0;
615 uint8_t *temSliceData = reinterpret_cast<uint8_t *>(SoftBusCalloc(sizeof(uint8_t)));
616 SessionPktType pktType = TRANS_SESSION_BYTES;
617
618 ClientProxyChannelInfo *info =
619 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
620 ProxyChannelInfoDetail detail = {0};
621 detail.osType = OH_TYPE;
622 info->channelId = channelId;
623 info->detail = detail;
624 info->node.next = NULL;
625 info->node.prev = NULL;
626
627 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
628 SoftBusList *infoList = InitSoftBusList();
629 SoftBusList *sliceList = InitSoftBusList();
630 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
631 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
632 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
633 ret = ClientTransProxyInit(&g_clientSessionCb);
634 EXPECT_EQ(SOFTBUS_OK, ret);
635
636 ret = TransProxyAsyncPackAndSendData(channelId, NULL, len, dataSeq, pktType);
637 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
638
639 ret = TransProxyAsyncPackAndSendData(channelId, data, len, dataSeq, pktType);
640 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
641
642 ret = ClientTransProxyAddChannelInfo(info);
643 EXPECT_EQ(SOFTBUS_OK, ret);
644
645 EXPECT_CALL(ClientProxyManagerMock, GetSupportTlvAndNeedAckById).WillOnce(Return(SOFTBUS_INVALID_PARAM));
646 ret = TransProxyAsyncPackAndSendData(channelId, data, len, dataSeq, pktType);
647 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
648
649 EXPECT_CALL(ClientProxyManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_OK));
650 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackTlvBytes).WillOnce(Return(SOFTBUS_OK));
651 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackData).WillOnce(Return(temSliceData));
652 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillOnce(Return(SOFTBUS_INVALID_PARAM));
653 ret = TransProxyAsyncPackAndSendData(channelId, data, len, dataSeq, pktType);
654 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
655
656 const void *newData = SoftBusCalloc(sizeof(int32_t));
657 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackTlvBytes).WillOnce(Return(SOFTBUS_OK));
658 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackData).WillOnce(Return((uint8_t *)NULL));
659 ret = TransProxyAsyncPackAndSendData(channelId, newData, len, dataSeq, pktType);
660 EXPECT_EQ(SOFTBUS_MALLOC_ERR, ret);
661
662 (void)ClientTransProxyListDeinit();
663 }
664
665 /**
666 * @tc.name: TransProxyChannelSendBytes001
667 * @tc.desc: TransProxyChannelSendBytes, enter the normal branch
668 * @tc.type: FUNC
669 * @tc.require:
670 */
671 HWTEST_F(ClientTransProxyManagerMockTest, TransProxyChannelSendBytes001, TestSize.Level1)
672 {
673 int32_t ret = 0;
674 int32_t channelId = 1;
675 const void *data = SoftBusCalloc(sizeof(int32_t));
676 uint32_t len = 1;
677 uint8_t *temSliceData = reinterpret_cast<uint8_t *>(SoftBusCalloc(sizeof(uint8_t)));
678 bool needAck = true;
679
680 ClientProxyChannelInfo *info =
681 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
682 ProxyChannelInfoDetail detail = {0};
683 detail.isEncrypted = true;
684 detail.sequence = 1;
685 detail.osType = OH_TYPE;
686 info->channelId = channelId;
687 info->detail = detail;
688 info->node.next = NULL;
689 info->node.prev = NULL;
690
691 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
692 SoftBusList *infoList = InitSoftBusList();
693 SoftBusList *sliceList = InitSoftBusList();
694 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
695 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
696 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
697 ret = ClientTransProxyInit(&g_clientSessionCb);
698 EXPECT_EQ(SOFTBUS_OK, ret);
699
700 ret = ClientTransProxyAddChannelInfo(info);
701 EXPECT_EQ(SOFTBUS_OK, ret);
702
703 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackData).WillOnce(Return(temSliceData));
704 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillOnce(Return(SOFTBUS_OK));
705 EXPECT_CALL(ClientProxyManagerMock, ProcPendingPacket).WillOnce(Return(SOFTBUS_OK));
706 EXPECT_CALL(ClientProxyManagerMock, GetSupportTlvAndNeedAckById).WillOnce(Return(SOFTBUS_OK));
707 EXPECT_CALL(ClientProxyManagerMock, AddPendingPacket).WillOnce(Return(SOFTBUS_OK));
708 ret = TransProxyChannelSendBytes(channelId, data, len, needAck);
709 EXPECT_EQ(SOFTBUS_OK, ret);
710
711 (void)ClientTransProxyListDeinit();
712 (void)PendingDeinit(PENDING_TYPE_PROXY);
713 }
714
715 /**
716 * @tc.name: TransProxyChannelSendBytes002
717 * @tc.desc: TransProxyChannelSendBytes, enter the abnormal branch
718 * @tc.type: FUNC
719 * @tc.require:
720 */
721 HWTEST_F(ClientTransProxyManagerMockTest, TransProxyChannelSendBytes002, TestSize.Level1)
722 {
723 int32_t ret = 0;
724 int32_t channelId = 1;
725 const void *data = SoftBusCalloc(sizeof(int32_t));
726 uint32_t len = 1;
727 bool needAck = true;
728
729 ClientProxyChannelInfo *info =
730 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
731 ProxyChannelInfoDetail detail = {0};
732 detail.isEncrypted = false;
733 detail.sequence = 1;
734 detail.osType = OH_TYPE;
735 info->channelId = channelId;
736 info->detail = detail;
737 info->node.next = NULL;
738 info->node.prev = NULL;
739
740 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
741 SoftBusList *infoList = InitSoftBusList();
742 SoftBusList *sliceList = InitSoftBusList();
743 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
744 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
745 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
746 ret = ClientTransProxyInit(&g_clientSessionCb);
747 EXPECT_EQ(SOFTBUS_OK, ret);
748
749 ret = TransProxyChannelSendBytes(channelId, NULL, len, needAck);
750 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
751
752 ret = ClientTransProxyAddChannelInfo(info);
753 EXPECT_EQ(SOFTBUS_OK, ret);
754
755 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillOnce(Return(SOFTBUS_OK));
756 ret = TransProxyChannelSendBytes(channelId, data, len, needAck);
757 EXPECT_EQ(SOFTBUS_OK, ret);
758
759 (void)ClientTransProxyListDeinit();
760 (void)PendingDeinit(PENDING_TYPE_PROXY);
761 }
762
763 /**
764 * @tc.name: TransProxyChannelSendBytes003
765 * @tc.desc: TransProxyChannelSendBytes, enter the abnormal branch
766 * @tc.type: FUNC
767 * @tc.require:
768 */
769 HWTEST_F(ClientTransProxyManagerMockTest, TransProxyChannelSendBytes003, TestSize.Level1)
770 {
771 int32_t ret = 0;
772 int32_t channelId = 1;
773 const void *data = SoftBusCalloc(sizeof(int32_t));
774 uint32_t len = 1;
775 bool needAck = true;
776
777 ClientProxyChannelInfo *info =
778 reinterpret_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
779 ProxyChannelInfoDetail detail = {0};
780 detail.isEncrypted = true;
781 detail.sequence = 1;
782 detail.osType = OH_TYPE;
783 info->channelId = channelId;
784 info->detail = detail;
785 info->node.next = NULL;
786 info->node.prev = NULL;
787
788 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
789 SoftBusList *infoList = InitSoftBusList();
790 SoftBusList *sliceList = InitSoftBusList();
791 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
792 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
793 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
794 ret = ClientTransProxyInit(&g_clientSessionCb);
795 EXPECT_EQ(SOFTBUS_OK, ret);
796
797 ret = ClientTransProxyAddChannelInfo(info);
798 EXPECT_EQ(SOFTBUS_OK, ret);
799
800 EXPECT_CALL(ClientProxyManagerMock, AddPendingPacket).WillOnce(Return(SOFTBUS_INVALID_PARAM));
801 ret = TransProxyChannelSendBytes(channelId, data, len, needAck);
802 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
803
804 EXPECT_CALL(ClientProxyManagerMock, AddPendingPacket).WillOnce(Return(SOFTBUS_OK));
805 EXPECT_CALL(ClientProxyManagerMock, GetSupportTlvAndNeedAckById).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
806 ret = TransProxyChannelSendBytes(channelId, data, len, needAck);
807 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
808
809 (void)ClientTransProxyListDeinit();
810 (void)PendingDeinit(PENDING_TYPE_PROXY);
811 }
812
813 /**
814 * @tc.name: ClientTransProxyOnChannelBind001
815 * @tc.desc: ClientTransProxyOnChannelBind, enter the abnormal branch
816 * @tc.type: FUNC
817 * @tc.require:
818 */
819 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyOnChannelBind001, TestSize.Level1)
820 {
821 int32_t ret = 0;
822 int32_t channelId = 1;
823 int32_t ChannelType = 2;
824
825 IClientSessionCallBack temcb = g_clientSessionCb;
__anonfc6ef6750402(int32_t channelId, int32_t channelType) 826 temcb.OnChannelBind = [](int32_t channelId, int32_t channelType) -> int32_t {return SOFTBUS_INVALID_PARAM;};
827
828 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
829 SoftBusList *infoList = InitSoftBusList();
830 SoftBusList *sliceList = InitSoftBusList();
831 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
832 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
833 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
834 ret = ClientTransProxyInit(&temcb);
835
836 ret = ClientTransProxyOnChannelBind(channelId, ChannelType);
837 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
838
839 (void)ClientTransProxyListDeinit();
840 }
841
842 /**
843 * @tc.name: ClientTransProxyOnChannelBind002
844 * @tc.desc: ClientTransProxyOnChannelBind, enter the abnormal branch
845 * @tc.type: FUNC
846 * @tc.require:
847 */
848 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyOnChannelBind002, TestSize.Level1)
849 {
850 int32_t ret = 0;
851 int32_t channelId = 1;
852 int32_t ChannelType = 2;
853
854 IClientSessionCallBack temcb = g_clientSessionCb;
__anonfc6ef6750502(int32_t channelId, int32_t channelType) 855 temcb.OnChannelBind = [](int32_t channelId, int32_t channelType) -> int32_t {return SOFTBUS_NOT_NEED_UPDATE;};
856
857 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
858 SoftBusList *infoList = InitSoftBusList();
859 SoftBusList *sliceList = InitSoftBusList();
860 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
861 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
862 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
863 ret = ClientTransProxyInit(&temcb);
864
865 ret = ClientTransProxyOnChannelBind(channelId, ChannelType);
866 EXPECT_EQ(SOFTBUS_OK, ret);
867
868 (void)ClientTransProxyListDeinit();
869 }
870
871 /**
872 * @tc.name: ClientTransProxyOnChannelBind003
873 * @tc.desc: ClientTransProxyOnChannelBind, enter the abnormal branch
874 * @tc.type: FUNC
875 * @tc.require:
876 */
877 HWTEST_F(ClientTransProxyManagerMockTest, ClientTransProxyOnChannelBind003, TestSize.Level1)
878 {
879 int32_t ret = 0;
880 int32_t channelId = 1;
881 int32_t ChannelType = 2;
882
883 IClientSessionCallBack temcb = g_clientSessionCb;
884 temcb.OnChannelBind = NULL;
885
886 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
887 SoftBusList *infoList = InitSoftBusList();
888 SoftBusList *sliceList = InitSoftBusList();
889 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
890 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
891 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
892 ret = ClientTransProxyInit(&temcb);
893
894 ret = ClientTransProxyOnChannelBind(channelId, ChannelType);
895 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
896
897 (void)ClientTransProxyListDeinit();
898 }
899
900 /**
901 * @tc.name: TransProxyChannelAsyncSendBytes001
902 * @tc.desc: TransProxyChannelAsyncSendBytes, enter the normal branch
903 * @tc.type: FUNC
904 * @tc.require:
905 */
906 HWTEST_F(ClientTransProxyManagerMockTest, TransProxyChannelAsyncSendBytes001, TestSize.Level1)
907 {
908 int32_t ret = 0;
909 int32_t channelId = 1;
910 const void *data = SoftBusCalloc(sizeof(int32_t));
911 uint32_t len = 1;
912 uint8_t *temSliceData = reinterpret_cast<uint8_t *>(SoftBusCalloc(sizeof(uint8_t)));
913 uint32_t dataSeq = 0;
914
915 ClientProxyChannelInfo *info =
916 reinterpret_cast<ClientProxyChannelInfo*>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
917 ProxyChannelInfoDetail detail = {0};
918 detail.isEncrypted = true;
919 detail.sequence = 1;
920 detail.osType = OH_TYPE;
921 info->channelId = channelId;
922 info->detail = detail;
923 info->node.next = NULL;
924 info->node.prev = NULL;
925
926 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
927 SoftBusList *infoList = InitSoftBusList();
928 SoftBusList *sliceList = InitSoftBusList();
929 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
930 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
931 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
932 ret = ClientTransProxyInit(&g_clientSessionCb);
933 EXPECT_EQ(SOFTBUS_OK, ret);
934
935 ret = ClientTransProxyAddChannelInfo(info);
936 EXPECT_EQ(SOFTBUS_OK, ret);
937
938 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackTlvBytes).WillOnce(Return(SOFTBUS_OK));
939 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackData).WillRepeatedly(Return(temSliceData));
940 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillRepeatedly(Return(SOFTBUS_OK));
941 EXPECT_CALL(ClientProxyManagerMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
942 EXPECT_CALL(ClientProxyManagerMock, DataSeqInfoListAddItem).WillRepeatedly(Return(SOFTBUS_OK));
943 ret = TransProxyChannelAsyncSendBytes(channelId, data, len, dataSeq);
944 EXPECT_EQ(SOFTBUS_OK, ret);
945
946 (void)ClientTransProxyListDeinit();
947 }
948
949 /**
950 * @tc.name: TransProxyChannelAsyncSendBytes002
951 * @tc.desc: TransProxyChannelAsyncSendBytes, enter the normal branch
952 * @tc.type: FUNC
953 * @tc.require:
954 */
955 HWTEST_F(ClientTransProxyManagerMockTest, TransProxyChannelAsyncSendBytes002, TestSize.Level1)
956 {
957 int32_t ret = 0;
958 int32_t channelId = 1;
959 const void *data = SoftBusCalloc(sizeof(int32_t));
960 uint32_t len = 1;
961 uint32_t dataSeq = 0;
962
963 ClientProxyChannelInfo *info =
964 reinterpret_cast<ClientProxyChannelInfo*>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
965 ProxyChannelInfoDetail detail = {0};
966 detail.isEncrypted = false;
967 detail.sequence = 1;
968 detail.osType = OH_TYPE;
969 info->channelId = channelId;
970 info->detail = detail;
971 info->node.next = NULL;
972 info->node.prev = NULL;
973
974 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
975 SoftBusList *infoList = InitSoftBusList();
976 SoftBusList *sliceList = InitSoftBusList();
977 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
978 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
979 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
980 ret = ClientTransProxyInit(&g_clientSessionCb);
981 EXPECT_EQ(SOFTBUS_OK, ret);
982
983 ret = ClientTransProxyAddChannelInfo(info);
984 EXPECT_EQ(SOFTBUS_OK, ret);
985
986 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillRepeatedly(Return(SOFTBUS_OK));
987 ret = TransProxyChannelAsyncSendBytes(channelId, data, len, dataSeq);
988 EXPECT_EQ(SOFTBUS_OK, ret);
989
990 (void)ClientTransProxyListDeinit();
991 }
992
993 /**
994 * @tc.name: TransProxyChannelAsyncSendBytes003
995 * @tc.desc: TransProxyChannelAsyncSendBytes, enter the normal branch
996 * @tc.type: FUNC
997 * @tc.require:
998 */
999 HWTEST_F(ClientTransProxyManagerMockTest, TransProxyChannelAsyncSendBytes003, TestSize.Level1)
1000 {
1001 int32_t ret = 0;
1002 int32_t channelId = 1;
1003 const void *data = SoftBusCalloc(sizeof(int32_t));
1004 uint32_t len = 1;
1005 uint8_t *temSliceData = reinterpret_cast<uint8_t *>(SoftBusCalloc(sizeof(uint8_t)));
1006 uint32_t dataSeq = 0;
1007
1008 ClientProxyChannelInfo *info =
1009 reinterpret_cast<ClientProxyChannelInfo*>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
1010 ProxyChannelInfoDetail detail = {0};
1011 detail.isEncrypted = true;
1012 detail.sequence = 1;
1013 detail.osType = OH_TYPE;
1014 info->channelId = channelId;
1015 info->detail = detail;
1016 info->node.next = NULL;
1017 info->node.prev = NULL;
1018
1019 NiceMock<ClientTransProxyManagerInterfaceMock> ClientProxyManagerMock;
1020 SoftBusList *infoList = InitSoftBusList();
1021 SoftBusList *sliceList = InitSoftBusList();
1022 EXPECT_CALL(ClientProxyManagerMock, ClinetTransProxyFileManagerInit).WillRepeatedly(Return(SOFTBUS_OK));
1023 EXPECT_CALL(ClientProxyManagerMock, PendingInit).WillOnce(Return(SOFTBUS_OK));
1024 EXPECT_CALL(ClientProxyManagerMock, CreateSoftBusList).WillOnce(Return(infoList)).WillOnce(Return(sliceList));
1025 ret = ClientTransProxyInit(&g_clientSessionCb);
1026 EXPECT_EQ(SOFTBUS_OK, ret);
1027
1028 ret = ClientTransProxyAddChannelInfo(info);
1029 EXPECT_EQ(SOFTBUS_OK, ret);
1030
1031 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackTlvBytes).WillOnce(Return(SOFTBUS_OK));
1032 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackData).WillRepeatedly(Return(temSliceData));
1033 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillRepeatedly(Return(SOFTBUS_OK));
1034 EXPECT_CALL(ClientProxyManagerMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_OK));
1035 EXPECT_CALL(ClientProxyManagerMock, DataSeqInfoListAddItem).WillOnce(Return(SOFTBUS_INVALID_PARAM));
1036 ret = TransProxyChannelAsyncSendBytes(channelId, data, len, dataSeq);
1037 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1038
1039 uint8_t *newSliceData = reinterpret_cast<uint8_t *>(SoftBusCalloc(sizeof(uint8_t)));
1040 const void *newdata = SoftBusCalloc(sizeof(int32_t));
1041 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackTlvBytes).WillOnce(Return(SOFTBUS_OK));
1042 EXPECT_CALL(ClientProxyManagerMock, TransProxyPackData).WillRepeatedly(Return(newSliceData));
1043 EXPECT_CALL(ClientProxyManagerMock, ServerIpcSendMessage).WillRepeatedly(Return(SOFTBUS_OK));
1044 EXPECT_CALL(ClientProxyManagerMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_INVALID_PARAM));
1045 ret = TransProxyChannelAsyncSendBytes(channelId, newdata, len, dataSeq);
1046 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
1047
1048 (void)ClientTransProxyListDeinit();
1049 }
1050 } // namespace OHOS