1 /*
2 * Copyright (c) 2022-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 "securec.h"
17 #include <gtest/gtest.h>
18
19 #include "client_trans_proxy_manager.h"
20 #include "client_trans_proxy_manager.c"
21 #include "client_trans_proxy_manager_d2d_mock.h"
22 #include "client_trans_proxy_file_manager.h"
23 #include "client_trans_session_manager.h"
24 #include "session.h"
25 #include "softbus_access_token_test.h"
26 #include "softbus_def.h"
27 #include "softbus_error_code.h"
28
29 #define TEST_CHANNEL_ID (-10)
30 #define TEST_DATA_LENGTH_2 100
31
32 using namespace std;
33 using namespace testing;
34 using namespace testing::ext;
35
36 namespace OHOS {
37
TransOnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag,SocketAccessInfo * accessInfo)38 int32_t TransOnSessionOpened(
39 const char *sessionName, const ChannelInfo *channel, SessionType flag, SocketAccessInfo *accessInfo)
40 {
41 return SOFTBUS_OK;
42 }
43
TransOnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)44 int32_t TransOnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
45 {
46 return SOFTBUS_OK;
47 }
48
TransOnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)49 int32_t TransOnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
50 {
51 return SOFTBUS_OK;
52 }
53
TransOnBytesReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)54 int32_t TransOnBytesReceived(
55 int32_t channelId, int32_t channelType, const void *data, uint32_t len, SessionPktType type)
56 {
57 return SOFTBUS_OK;
58 }
59
TransOnOnStreamRecevied(int32_t channelId,int32_t channelType,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)60 int32_t TransOnOnStreamRecevied(
61 int32_t channelId, int32_t channelType, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
62 {
63 return SOFTBUS_OK;
64 }
65
TransOnGetSessionId(int32_t channelId,int32_t channelType,int32_t * sessionId)66 int32_t TransOnGetSessionId(int32_t channelId, int32_t channelType, int32_t *sessionId)
67 {
68 return SOFTBUS_OK;
69 }
TransOnQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)70 int32_t TransOnQosEvent(int32_t channelId, int32_t channelType, int32_t eventId, int32_t tvCount, const QosTv *tvList)
71 {
72 return SOFTBUS_OK;
73 }
74
75 static IClientSessionCallBack g_clientSessionCb = {
76 .OnSessionOpened = TransOnSessionOpened,
77 .OnSessionClosed = TransOnSessionClosed,
78 .OnSessionOpenFailed = TransOnSessionOpenFailed,
79 .OnDataReceived = TransOnBytesReceived,
80 .OnStreamReceived = TransOnOnStreamRecevied,
81 .OnQosEvent = TransOnQosEvent,
82 };
83
84 class ClientTransProxyD2DTest : public testing::Test {
85 public:
ClientTransProxyD2DTest()86 ClientTransProxyD2DTest() { }
~ClientTransProxyD2DTest()87 ~ClientTransProxyD2DTest() { }
88 static void SetUpTestCase(void);
89 static void TearDownTestCase(void);
SetUp()90 void SetUp() override { }
TearDown()91 void TearDown() override { }
92 };
93
SetUpTestCase(void)94 void ClientTransProxyD2DTest::SetUpTestCase(void)
95 {
96 int32_t ret = ClientTransProxyInit(&g_clientSessionCb);
97 EXPECT_EQ(SOFTBUS_OK, ret);
98 SetAccessTokenPermission("dsoftbusTransTest");
99 }
100
TearDownTestCase(void)101 void ClientTransProxyD2DTest::TearDownTestCase(void)
102 {
103 }
104
105 /**
106 * @tc.name: TransProxyChannelAsyncSendMessageTest001
107 * @tc.desc: trans proxy channel async send message
108 * @tc.type: FUNC
109 * @tc.require:
110 */
111 HWTEST_F(ClientTransProxyD2DTest, TransProxyChannelAsyncSendMessageTest001, TestSize.Level1)
112 {
113 char data[] = "1111";
114 uint32_t len = 5;
115 uint16_t dataSeq = 1;
116 int32_t channelId = 1;
117 int32_t ret = TransProxyChannelAsyncSendMessage(channelId, nullptr, len, dataSeq);
118 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
119
120 ret = TransProxyChannelAsyncSendMessage(channelId, data, len, dataSeq);
121 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
122 }
123
124 /**
125 * @tc.name: ClientTransProxyPackAndSendDataTest001
126 * @tc.desc: trans proxy channel async send data
127 * @tc.type: FUNC
128 * @tc.require:
129 */
130 HWTEST_F(ClientTransProxyD2DTest, ClientTransProxyPackAndSendDataTest001, TestSize.Level1)
131 {
132 char data[] = "1111";
133 uint32_t len = 5;
134 int32_t channelId = 1;
135 ProxyChannelInfoDetail info;
136 int32_t ret = ClientTransProxyPackAndSendData(channelId, nullptr, len, &info, TRANS_SESSION_MESSAGE);
137 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
138
139 ret = ClientTransProxyPackAndSendData(channelId, data, len, nullptr, TRANS_SESSION_MESSAGE);
140 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
141
142 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
143 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId).WillOnce(Return(SOFTBUS_NOT_FIND));
144 ret = ClientTransProxyPackAndSendData(channelId, data, len, &info, TRANS_SESSION_MESSAGE);
145 EXPECT_EQ(SOFTBUS_OK, ret);
146
147 int32_t businessType = BUSINESS_TYPE_BYTE;
148 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId)
149 .WillRepeatedly(DoAll(SetArgPointee<1>(businessType), Return(SOFTBUS_OK)));
150
151 ret = ClientTransProxyPackAndSendData(channelId, data, len, &info, TRANS_SESSION_MESSAGE);
152 EXPECT_EQ(SOFTBUS_OK, ret);
153
154 businessType = BUSINESS_TYPE_D2D_VOICE;
155 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId)
156 .WillRepeatedly(DoAll(SetArgPointee<1>(businessType), Return(SOFTBUS_OK)));
157 EXPECT_CALL(managerMock, TransProxyPackD2DBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM));
158 ret = ClientTransProxyPackAndSendData(channelId, data, len, &info, TRANS_SESSION_MESSAGE);
159 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
160 }
161
162 /**
163 * @tc.name: TransProxyProcessD2DBytesTest
164 * @tc.desc: trans proxy process d2d bytes
165 * @tc.type: FUNC
166 * @tc.require:
167 */
168 HWTEST_F(ClientTransProxyD2DTest, TransProxyProcessD2DBytesTest, TestSize.Level1)
169 {
170 uint8_t data[] = "1111";
171 uint32_t len = 5;
172 uint8_t *testData = static_cast<uint8_t *>(SoftBusCalloc(len));
173 ASSERT_TRUE(testData != nullptr);
174 int32_t channelId = 1;
175 ProxyChannelInfoDetail info;
176 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
177 EXPECT_CALL(managerMock, TransProxyPackD2DBytes).WillOnce(Return(SOFTBUS_INVALID_PARAM));
178 int32_t ret = TransProxyProcessD2DBytes(channelId, data, len, &info, TRANS_SESSION_MESSAGE);
179 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
180
181 EXPECT_CALL(managerMock, TransProxyPackD2DBytes).WillRepeatedly(Return(SOFTBUS_OK));
182 ProxyDataInfo dataInfo = { (uint8_t *)data, len, (uint8_t *)data, len };
183 dataInfo.outData = static_cast<uint8_t *>(SoftBusCalloc(dataInfo.outLen));
184 ASSERT_TRUE(dataInfo.outData != nullptr);
185 EXPECT_CALL(managerMock, TransProxyPackD2DData).WillRepeatedly(DoAll(SetArgPointee<0>(dataInfo), Return(nullptr)));
186 ret = TransProxyProcessD2DBytes(channelId, data, len, &info, TRANS_SESSION_MESSAGE);
187 EXPECT_EQ(SOFTBUS_MALLOC_ERR, ret);
188
189 dataInfo.outData = static_cast<uint8_t *>(SoftBusCalloc(dataInfo.outLen));
190 ASSERT_TRUE(dataInfo.outData != nullptr);
191 EXPECT_CALL(managerMock, TransProxyPackD2DData).WillRepeatedly(DoAll(SetArgPointee<0>(dataInfo), Return(testData)));
192 ret = TransProxyProcessD2DBytes(channelId, data, len, &info, TRANS_SESSION_MESSAGE);
193 EXPECT_EQ(SOFTBUS_OK, ret);
194 }
195
196 /**
197 * @tc.name: ClientTransProxyFirstSliceProcessTest
198 * @tc.desc: trans proxy process first slice
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(ClientTransProxyD2DTest, ClientTransProxyFirstSliceProcessTest, TestSize.Level1)
203 {
204 SliceProcessor processor;
205 SliceHead head;
206 char data[] = "1111";
207 uint32_t len = 5;
208 int32_t channelId = 1;
209 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
210 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId).WillOnce(Return(SOFTBUS_NOT_FIND));
211 int32_t ret = ClientTransProxyFirstSliceProcess(&processor, &head, data, len, channelId);
212 EXPECT_EQ(SOFTBUS_OK, ret);
213
214 int32_t businessType = BUSINESS_TYPE_D2D_VOICE;
215 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId)
216 .WillRepeatedly(DoAll(SetArgPointee<1>(businessType), Return(SOFTBUS_OK)));
217
218 ret = ClientTransProxyFirstSliceProcess(&processor, &head, data, len, channelId);
219 EXPECT_EQ(SOFTBUS_OK, ret);
220
221 businessType = BUSINESS_TYPE_D2D_MESSAGE;
222 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId)
223 .WillRepeatedly(DoAll(SetArgPointee<1>(businessType), Return(SOFTBUS_OK)));
224
225 ret = ClientTransProxyFirstSliceProcess(&processor, &head, data, len, channelId);
226 EXPECT_EQ(SOFTBUS_OK, ret);
227 }
228
229 /**
230 * @tc.name: ClientTransProxyNoSubPacketProc
231 * @tc.desc: trans proxy process first slice
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(ClientTransProxyD2DTest, ClientTransProxyNoSubPacketProc, TestSize.Level1)
236 {
237 char data[] = "1111";
238 uint32_t len = 5;
239 int32_t channelId = 1;
240 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
241 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId).WillOnce(Return(SOFTBUS_NOT_FIND));
242 int32_t ret = ClientTransProxyNoSubPacketProc(channelId, data, len);
243 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
244
245 int32_t businessType = BUSINESS_TYPE_D2D_VOICE;
246 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId)
247 .WillRepeatedly(DoAll(SetArgPointee<1>(businessType), Return(SOFTBUS_OK)));
248
249 ret = ClientTransProxyNoSubPacketProc(channelId, data, len);
250 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
251
252 businessType = BUSINESS_TYPE_D2D_MESSAGE;
253 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId)
254 .WillRepeatedly(DoAll(SetArgPointee<1>(businessType), Return(SOFTBUS_OK)));
255
256 ret = ClientTransProxyNoSubPacketProc(channelId, data, len);
257 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
258 }
259
260 /**
261 * @tc.name: ClientTransProxyNoSubPacketD2DDataProcTest
262 * @tc.desc: trans proxy process no sub packet
263 * @tc.type: FUNC
264 * @tc.require:
265 */
266 HWTEST_F(ClientTransProxyD2DTest, ClientTransProxyNoSubPacketD2DDataProcTest, TestSize.Level1)
267 {
268 char data[TEST_DATA_LENGTH_2] = "1111111111111";
269 uint32_t len = 14;
270 int32_t channelId = 1;
271 int32_t businessType = BUSINESS_TYPE_BYTE;
272 int32_t ret = ClientTransProxyNoSubPacketD2DDataProc(channelId, nullptr, len, businessType);
273 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
274
275 ret = ClientTransProxyNoSubPacketD2DDataProc(channelId, data, 0, businessType);
276 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
277
278 ret = ClientTransProxyNoSubPacketD2DDataProc(channelId, data, len, businessType);
279 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
280
281 PacketD2DHead head;
282 head.flags = TRANS_SESSION_BYTES;
283 head.dataLen = 6;
284 (void)memcpy_s(data, TEST_DATA_LENGTH_2, &head, sizeof(PacketD2DHead));
285 businessType = BUSINESS_TYPE_D2D_VOICE;
286 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
287 EXPECT_CALL(managerMock, TransProxyProcessD2DData).WillRepeatedly(Return(SOFTBUS_INVALID_DATA_HEAD));
288 ret = ClientTransProxyNoSubPacketD2DDataProc(channelId, data, len, businessType);
289 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
290
291 businessType = BUSINESS_TYPE_D2D_MESSAGE;
292 ret = ClientTransProxyNoSubPacketD2DDataProc(channelId, data, len, businessType);
293 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
294 }
295
296 /**
297 * @tc.name: ClientTransProxyProcD2DDataTest
298 * @tc.desc: trans proxy process d2d data
299 * @tc.type: FUNC
300 * @tc.require:
301 */
302 HWTEST_F(ClientTransProxyD2DTest, ClientTransProxyProcD2DDataTest, TestSize.Level1)
303 {
304 char data[TEST_DATA_LENGTH_2] = "1111111111111";
305 int32_t channelId = 1;
306 int32_t businessType = BUSINESS_TYPE_BYTE;
307 PacketD2DHead head;
308 PacketD2DIvSource ivSource = {
309 .dataSeq = 1,
310 .nonce = 1,
311 };
312
313 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
314 EXPECT_CALL(managerMock, TransProxyProcessD2DData).WillRepeatedly(Return(SOFTBUS_OK));
315 int32_t ret = ClientTransProxyProcD2DData(channelId, data, &head, businessType, &ivSource);
316 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
317 EXPECT_CALL(managerMock, TransProxyDecryptD2DData).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
318
319 ret = ClientTransProxyProcD2DData(channelId, data, &head, businessType, &ivSource);
320 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
321
322 EXPECT_CALL(managerMock, TransProxyDecryptD2DData).WillRepeatedly(Return(SOFTBUS_OK));
323 EXPECT_CALL(managerMock, TransProxySessionDataLenCheck).WillRepeatedly(Return(SOFTBUS_INVALID_PARAM));
324 ret = ClientTransProxyProcD2DData(channelId, data, &head, businessType, &ivSource);
325 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
326
327 EXPECT_CALL(managerMock, TransProxySessionDataLenCheck).WillRepeatedly(Return(SOFTBUS_OK));
328 ret = ClientTransProxyProcD2DData(channelId, data, &head, businessType, &ivSource);
329 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
330 }
331
332 /**
333 * @tc.name: ClientTransProxyNotifyD2DTest
334 * @tc.desc: trans proxy notify d2d data
335 * @tc.type: FUNC
336 * @tc.require:
337 */
338 HWTEST_F(ClientTransProxyD2DTest, ClientTransProxyNotifyD2DTest, TestSize.Level1)
339 {
340 char data[TEST_DATA_LENGTH_2] = "1111111111111";
341 uint32_t len = 14;
342 int32_t channelId = 1;
343 uint16_t dataSeq = 1;
344 int32_t ret = ClientTransProxyNotifyD2D(channelId, TRANS_SESSION_MESSAGE, dataSeq, data, len);
345 EXPECT_EQ(SOFTBUS_OK, ret);
346
347 ret = ClientTransProxyNotifyD2D(channelId, TRANS_SESSION_ACK, dataSeq, data, len);
348 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
349
350 ret = ClientTransProxyNotifyD2D(channelId, TRANS_SESSION_BYTES, dataSeq, data, len);
351 EXPECT_EQ(SOFTBUS_OK, ret);
352
353 ret = ClientTransProxyNotifyD2D(channelId, TRANS_SESSION_ASYNC_MESSAGE, dataSeq, data, len);
354 EXPECT_EQ(SOFTBUS_OK, ret);
355
356 ret = ClientTransProxyNotifyD2D(channelId, TRANS_SESSION_FILE_ACK_RESPONSE_SENT, dataSeq, data, len);
357 EXPECT_EQ(SOFTBUS_OK, ret);
358 }
359
360 /**
361 * @tc.name: ClientTransProxyProcD2DAckTest
362 * @tc.desc: trans proxy d2d ack
363 * @tc.type: FUNC
364 * @tc.require:
365 */
366 HWTEST_F(ClientTransProxyD2DTest, ClientTransProxyProcD2DAckTest, TestSize.Level1)
367 {
368 char data[TEST_DATA_LENGTH_2] = "1111111111111";
369 uint32_t len = 4;
370 int32_t channelId = 1;
371 uint16_t dataSeq = 1;
372 int32_t ret = ClientTransProxyProcD2DAck(channelId, nullptr, len, dataSeq);
373 EXPECT_EQ(SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL, ret);
374
375 ret = ClientTransProxyProcD2DAck(channelId, data, 0, dataSeq);
376 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
377
378 ret = ClientTransProxyProcD2DAck(channelId, data, len, 0);
379 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
380
381 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
382 EXPECT_CALL(managerMock, ClientGetSessionIdByChannelId).WillOnce(Return(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND));
383 ret = ClientTransProxyProcD2DAck(channelId, data, len, dataSeq);
384 EXPECT_EQ(SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND, ret);
385
386 EXPECT_CALL(managerMock, ClientGetSessionIdByChannelId).WillRepeatedly(Return(SOFTBUS_OK));
387 ret = ClientTransProxyProcD2DAck(channelId, data, len, dataSeq);
388 EXPECT_EQ(SOFTBUS_TRANS_REGISTER_LISTENER_FAILED, ret);
389
390 EXPECT_CALL(managerMock, ClientGetSessionCallbackAdapterById).WillRepeatedly(Return(SOFTBUS_OK));
391 ret = ClientTransProxyProcD2DAck(channelId, data, len, dataSeq);
392 EXPECT_EQ(SOFTBUS_TRANS_REGISTER_LISTENER_FAILED, ret);
393
394 EXPECT_CALL(managerMock, DeleteDataSeqInfoList).WillRepeatedly(Return(SOFTBUS_OK));
395 ret = ClientTransProxyProcD2DAck(channelId, data, len, dataSeq);
396 EXPECT_EQ(SOFTBUS_TRANS_REGISTER_LISTENER_FAILED, ret);
397 }
398
399 /**
400 * @tc.name: ClientTransProxySendD2DAckTest
401 * @tc.desc: trans proxy channel send d2d ack
402 * @tc.type: FUNC
403 * @tc.require:
404 */
405 HWTEST_F(ClientTransProxyD2DTest, ClientTransProxySendD2DAckTest, TestSize.Level1)
406 {
407 int32_t channelId = 1;
408 uint16_t dataSeq = 1;
409 EXPECT_NO_FATAL_FAILURE(ClientTransProxySendD2DAck(channelId, dataSeq));
410
411 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
412 EXPECT_NO_FATAL_FAILURE(ClientTransProxySendD2DAck(channelId, dataSeq));
413
414 int32_t businessType = BUSINESS_TYPE_BYTE;
415 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId)
416 .WillRepeatedly(DoAll(SetArgPointee<1>(businessType), Return(SOFTBUS_OK)));
417 EXPECT_NO_FATAL_FAILURE(ClientTransProxySendD2DAck(channelId, dataSeq));
418
419 businessType = BUSINESS_TYPE_D2D_MESSAGE;
420 EXPECT_CALL(managerMock, ClientGetChannelBusinessTypeByChannelId)
421 .WillRepeatedly(DoAll(SetArgPointee<1>(businessType), Return(SOFTBUS_OK)));
422 EXPECT_NO_FATAL_FAILURE(ClientTransProxySendD2DAck(channelId, dataSeq));
423 }
424
425 /**
426 * @tc.name: TransProxyChannelAsyncSendMessageTest
427 * @tc.desc: trans proxy channel async send message
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 HWTEST_F(ClientTransProxyD2DTest, TransProxyChannelAsyncSendMessageTest, TestSize.Level1)
432 {
433 char data[] = "1111";
434 uint32_t len = 5;
435 uint16_t dataSeq = 1;
436 int32_t channelId = 1;
437 NiceMock<TransClientProxyD2DInterfaceMock> managerMock;
438 EXPECT_CALL(managerMock, ServerIpcSendMessage).WillRepeatedly(Return(SOFTBUS_OK));
439 int32_t ret = TransProxyAsyncPackAndSendMessage(channelId, nullptr, len, dataSeq, TRANS_SESSION_MESSAGE);
440 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
441
442 ret = TransProxyAsyncPackAndSendMessage(channelId, data, len, dataSeq, TRANS_SESSION_MESSAGE);
443 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
444
445 ClientProxyChannelInfo *info = (ClientProxyChannelInfo *)SoftBusCalloc(sizeof(ClientProxyChannelInfo));
446 ASSERT_TRUE(info != nullptr);
447 info->channelId = 1;
448 ret = ClientTransProxyAddChannelInfo(info);
449 EXPECT_EQ(SOFTBUS_OK, ret);
450 EXPECT_CALL(managerMock, TransProxyPackD2DData).WillRepeatedly(Return(nullptr));
451 ret = TransProxyAsyncPackAndSendMessage(channelId, data, len, dataSeq, TRANS_SESSION_MESSAGE);
452 EXPECT_EQ(SOFTBUS_MALLOC_ERR, ret);
453 ret = ClientTransProxyDelChannelInfo(channelId);
454 EXPECT_EQ(SOFTBUS_OK, ret);
455
456 ClientProxyChannelInfo *info1 =
457 static_cast<ClientProxyChannelInfo *>(SoftBusCalloc(sizeof(ClientProxyChannelInfo)));
458 ASSERT_TRUE(info1 != nullptr);
459 info1->channelId = 1;
460 char sessionKey[] = "111111111111111";
461 (void)memcpy_s(info1->detail.pagingSessionkey, SHORT_SESSION_KEY_LENGTH, sessionKey, strlen(sessionKey));
462 char pagingNonce[] = "11111111111";
463 (void)memcpy_s(info1->detail.pagingNonce, PAGING_NONCE_LEN, pagingNonce, strlen(pagingNonce));
464
465 ret = ClientTransProxyAddChannelInfo(info1);
466 EXPECT_EQ(SOFTBUS_OK, ret);
467 ret = TransProxyAsyncPackAndSendMessage(channelId, data, len, dataSeq, TRANS_SESSION_MESSAGE);
468 EXPECT_EQ(SOFTBUS_MALLOC_ERR, ret);
469 ret = ClientTransProxyDelChannelInfo(channelId);
470 EXPECT_EQ(SOFTBUS_OK, ret);
471 }
472
473 /**
474 * @tc.name: TransProxyPackAsyncMessageTest
475 * @tc.desc: trans proxy channel pack message
476 * @tc.type: FUNC
477 * @tc.require:
478 */
479 HWTEST_F(ClientTransProxyD2DTest, TransProxyPackAsyncMessageTest, TestSize.Level1)
480 {
481 uint16_t dataSeq = 1;
482 int32_t channelId = 1;
483 ProxyChannelInfoDetail info;
484 ProxyDataInfo dataInfo;
485 int32_t ret = TransProxyPackAsyncMessage(channelId, nullptr, &dataInfo, TRANS_SESSION_MESSAGE, dataSeq);
486 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
487 ret = TransProxyPackAsyncMessage(channelId, &info, nullptr, TRANS_SESSION_MESSAGE, dataSeq);
488 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
489
490 ret = TransProxyPackAsyncMessage(channelId, &info, &dataInfo, TRANS_SESSION_MESSAGE, dataSeq);
491 EXPECT_EQ(SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR, ret);
492
493 ProxyChannelInfoDetail info1 = {
494 .pagingSessionkey = "111111111111111",
495 .pagingNonce = "11111111111",
496 };
497 ProxyDataInfo dataInfo1 = {
498 .inData = (uint8_t *)"1111",
499 .inLen = 5,
500 };
501 ret = TransProxyPackAsyncMessage(channelId, &info1, &dataInfo1, TRANS_SESSION_MESSAGE, dataSeq);
502 EXPECT_EQ(SOFTBUS_OK, ret);
503 }
504 } // namespace OHOS