1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "securec.h"
18
19 #include "client_trans_proxy_manager.h"
20 #include "client_trans_session_manager.h"
21 #include "client_trans_socket_manager.h"
22 #include "session.h"
23 #include "softbus_def.h"
24 #include "softbus_errcode.h"
25 #include "softbus_access_token_test.h"
26 #include "client_trans_proxy_file_manager.h"
27 #include "client_trans_proxy_manager.c"
28 #include "client_trans_tcp_direct_message.h"
29
30 #define TEST_CHANNEL_ID (-10)
31 #define TEST_ERR_CODE (-1)
32 #define TEST_DATA "testdata"
33 #define TEST_DATA_LENGTH 9
34 #define TEST_DATA_LENGTH_2 100
35 #define TEST_FILE_CNT 4
36 #define TEST_SEQ 188
37 #define SILCE_NUM_COUNT 3
38 #define SLICE_SEQ_BEGIN 0
39 #define SLICE_SEQ_MID 1
40 #define SLICE_SEQ_END 2
41
42 using namespace std;
43 using namespace testing::ext;
44
45 namespace OHOS {
46 const char *g_proxyPkgName = "dms";
47 const char *g_proxySessionName = "ohos.distributedschedule.dms.test";
48 const char *g_testProxyFileName[] = {
49 "/data/test.txt",
50 "/data/ss.txt",
51 "/data/test.tar",
52 "/data/test.mp3",
53 };
54 const char *g_proxyFileSet[] = {
55 "/data/data/test.txt",
56 "/path/max/length/512/"
57 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
58 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
59 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
60 "11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
61 "111111111111111111111111111111111111111111111111111",
62 "ss",
63 "/data/ss",
64 };
65 char g_sessionKey[32] = "1234567812345678123456781234567";
66 #define DEFAULT_NEW_BYTES_LEN (4 * 1024 * 1024)
67 #define DEFAULT_NEW_MESSAGE_LEN (4 * 1024)
68
TransOnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag)69 int32_t TransOnSessionOpened(const char *sessionName, const ChannelInfo *channel, SessionType flag)
70 {
71 return SOFTBUS_OK;
72 }
73
TransOnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)74 int32_t TransOnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
75 {
76 return SOFTBUS_OK;
77 }
78
TransOnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)79 int32_t TransOnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
80 {
81 return SOFTBUS_OK;
82 }
83
TransOnBytesReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)84 int32_t TransOnBytesReceived(int32_t channelId, int32_t channelType,
85 const void *data, uint32_t len, SessionPktType type)
86 {
87 return SOFTBUS_OK;
88 }
89
TransOnOnStreamRecevied(int32_t channelId,int32_t channelType,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)90 int32_t TransOnOnStreamRecevied(int32_t channelId, int32_t channelType,
91 const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
92 {
93 return SOFTBUS_OK;
94 }
95
TransOnGetSessionId(int32_t channelId,int32_t channelType,int32_t * sessionId)96 int32_t TransOnGetSessionId(int32_t channelId, int32_t channelType, int32_t *sessionId)
97 {
98 return SOFTBUS_OK;
99 }
TransOnQosEvent(int32_t channelId,int32_t channelType,int32_t eventId,int32_t tvCount,const QosTv * tvList)100 int32_t TransOnQosEvent(int32_t channelId, int32_t channelType, int32_t eventId,
101 int32_t tvCount, const QosTv *tvList)
102 {
103 return SOFTBUS_OK;
104 }
105
106 static IClientSessionCallBack g_clientSessionCb = {
107 .OnSessionOpened = TransOnSessionOpened,
108 .OnSessionClosed = TransOnSessionClosed,
109 .OnSessionOpenFailed = TransOnSessionOpenFailed,
110 .OnDataReceived = TransOnBytesReceived,
111 .OnStreamReceived = TransOnOnStreamRecevied,
112 .OnQosEvent = TransOnQosEvent,
113 };
114
OnSessionOpened(const char * sessionName,const ChannelInfo * channel,SessionType flag)115 int32_t OnSessionOpened(const char *sessionName, const ChannelInfo *channel, SessionType flag)
116 {
117 (void)sessionName;
118 (void)channel;
119 (void)flag;
120 return SOFTBUS_INVALID_PARAM;
121 }
122
OnSessionClosed(int32_t channelId,int32_t channelType,ShutdownReason reason)123 int32_t OnSessionClosed(int32_t channelId, int32_t channelType, ShutdownReason reason)
124 {
125 (void)channelId;
126 (void)channelType;
127 (void)reason;
128 return SOFTBUS_INVALID_PARAM;
129 }
130
OnSessionOpenFailed(int32_t channelId,int32_t channelType,int32_t errCode)131 int32_t OnSessionOpenFailed(int32_t channelId, int32_t channelType, int32_t errCode)
132 {
133 (void)channelId;
134 (void)channelType;
135 (void)errCode;
136 return SOFTBUS_INVALID_PARAM;
137 }
138
OnBytesReceived(int32_t channelId,int32_t channelType,const void * data,uint32_t len,SessionPktType type)139 int32_t OnBytesReceived(int32_t channelId, int32_t channelType,
140 const void *data, uint32_t len, SessionPktType type)
141 {
142 (void)channelId;
143 (void)channelType;
144 (void)data;
145 (void)len;
146 (void)type;
147 return SOFTBUS_INVALID_PARAM;
148 }
149
150 static IClientSessionCallBack g_sessionCb = {
151 .OnSessionOpened = OnSessionOpened,
152 .OnSessionClosed = OnSessionClosed,
153 .OnSessionOpenFailed = OnSessionOpenFailed,
154 .OnDataReceived = OnBytesReceived,
155 };
156
157 class ClientTransProxyManagerTest : public testing::Test {
158 public:
ClientTransProxyManagerTest()159 ClientTransProxyManagerTest() {}
~ClientTransProxyManagerTest()160 ~ClientTransProxyManagerTest() {}
161 static void SetUpTestCase(void);
162 static void TearDownTestCase(void);
SetUp()163 void SetUp() override {}
TearDown()164 void TearDown() override {}
165 };
166
SetUpTestCase(void)167 void ClientTransProxyManagerTest::SetUpTestCase(void)
168 {
169 int ret = ClientTransProxyInit(&g_clientSessionCb);
170 EXPECT_EQ(SOFTBUS_OK, ret);
171 SetAceessTokenPermission("dsoftbusTransTest");
172 }
TearDownTestCase(void)173 void ClientTransProxyManagerTest::TearDownTestCase(void) {}
174
175 /**
176 * @tc.name: ClientTransProxyInitTest
177 * @tc.desc: client trans proxy init test, use the wrong or normal parameter.
178 * @tc.type: FUNC
179 * @tc.require:
180 */
181 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyInitTest, TestSize.Level0)
182 {
183 int ret = ClientTransProxyInit(nullptr);
184 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
185 }
186
187 /**
188 * @tc.name: ClientTransProxyOnChannelOpenedTest
189 * @tc.desc: client trans proxy on channel opened test, use the wrong or normal parameter.
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnChannelOpenedTest, TestSize.Level0)
194 {
195 int ret = ClientTransProxyOnChannelOpened(g_proxySessionName, nullptr);
196 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
197
198 ChannelInfo channelInfo = {0};
199 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
200 EXPECT_EQ(SOFTBUS_MEM_ERR, ret);
201 }
202
203 /**
204 * @tc.name: ClientTransProxyOnDataReceivedTest
205 * @tc.desc: client trans proxy on data received test, use the wrong or normal parameter.
206 * @tc.type: FUNC
207 * @tc.require:
208 */
209 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnDataReceivedTest, TestSize.Level0)
210 {
211 int32_t channelId = 1;
212 int ret = ClientTransProxyOnDataReceived(channelId, nullptr, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
213 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
214
215 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
216 EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_CHANNEL_ID, ret);
217 }
218
219 /**
220 * @tc.name: ClientTransProxyOnDataReceivedTest001
221 * @tc.desc: client trans proxy on data received test. test wrong slice head or packet head
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnDataReceivedTest001, TestSize.Level0)
226 {
227 int32_t channelId = 1;
228 ChannelInfo channelInfo;
229 channelInfo.channelId = channelId;
230 channelInfo.sessionKey = g_sessionKey;
231 channelInfo.isEncrypt = true;
232 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
233 EXPECT_EQ(SOFTBUS_OK, ret);
234 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
235 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
236
237 SliceHead sliceHead;
238 sliceHead.priority = PROXY_CHANNEL_PRORITY_BUTT;
239 char buf[TEST_DATA_LENGTH_2];
240 ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
241 EXPECT_EQ(EOK, ret);
242 PacketHead packetHead;
243 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
244 EXPECT_EQ(EOK, ret);
245 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
246 EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_SLICE_HEAD, ret);
247
248 sliceHead.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
249 sliceHead.sliceNum = 0;
250 sliceHead.sliceSeq = 0;
251 ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
252 EXPECT_EQ(EOK, ret);
253 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
254 EXPECT_EQ(SOFTBUS_TRANS_PROXY_INVALID_SLICE_HEAD, ret);
255
256 sliceHead.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
257 sliceHead.sliceNum = 1;
258 ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
259 EXPECT_EQ(EOK, ret);
260 packetHead.magicNumber = 1;
261 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
262 EXPECT_EQ(EOK, ret);
263 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
264 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
265
266 packetHead.magicNumber = MAGIC_NUMBER;
267 packetHead.dataLen = 0;
268 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
269 EXPECT_EQ(EOK, ret);
270 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
271 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
272
273 packetHead.dataLen = sizeof(PacketHead) - 1;
274 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
275 EXPECT_EQ(EOK, ret);
276 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
277 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
278 }
279
280 /**
281 * @tc.name: ClientTransProxyOnDataReceivedTest002
282 * @tc.desc: client trans proxy on data received test. test wrong slice data
283 * @tc.type: FUNC
284 * @tc.require:
285 */
286 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyOnDataReceivedTest002, TestSize.Level0)
287 {
288 g_proxyMaxByteBufSize = DEFAULT_NEW_BYTES_LEN;
289 g_proxyMaxMessageBufSize = DEFAULT_NEW_MESSAGE_LEN;
290 int32_t channelId = 1;
291
292 SliceHead sliceHead;
293 sliceHead.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
294 sliceHead.sliceNum = 1;
295 char buf[TEST_DATA_LENGTH_2];
296 int32_t ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
297 EXPECT_EQ(EOK, ret);
298 PacketHead packetHead;
299 packetHead.magicNumber = MAGIC_NUMBER;
300 packetHead.dataLen = TEST_DATA_LENGTH_2 - sizeof(SliceHead) - sizeof(PacketHead);
301 ret = memcpy_s(buf + sizeof(SliceHead), TEST_DATA_LENGTH_2, &packetHead, sizeof(PacketHead));
302 EXPECT_EQ(EOK, ret);
303 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
304 EXPECT_EQ(SOFTBUS_DECRYPT_ERR, ret);
305
306 sliceHead.sliceNum = SILCE_NUM_COUNT;
307 sliceHead.sliceSeq = SLICE_SEQ_BEGIN;
308 ret = memcpy_s(buf, TEST_DATA_LENGTH_2, &sliceHead, sizeof(SliceHead));
309 EXPECT_EQ(EOK, ret);
310 ret = ClientTransProxyOnDataReceived(channelId, buf, TEST_DATA_LENGTH_2, TRANS_SESSION_BYTES);
311 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ret);
312
313 sliceHead.priority = PROXY_CHANNEL_PRORITY_BYTES;
314 int32_t dataLen = sizeof(SliceHead) + sizeof(PacketHead) + 1;
315 char buf2[dataLen];
316 ret = memcpy_s(buf2, dataLen, &sliceHead, sizeof(SliceHead));
317 EXPECT_EQ(EOK, ret);
318 ret = memcpy_s(buf2 + sizeof(SliceHead), dataLen, &packetHead, sizeof(PacketHead));
319 EXPECT_EQ(EOK, ret);
320 ret = ClientTransProxyOnDataReceived(channelId, buf2, dataLen, TRANS_SESSION_BYTES);
321 EXPECT_EQ(SOFTBUS_OK, ret);
322
323 sliceHead.sliceSeq = SLICE_SEQ_MID;
324 ret = memcpy_s(buf2, dataLen, &sliceHead, sizeof(SliceHead));
325 EXPECT_EQ(EOK, ret);
326 ret = ClientTransProxyOnDataReceived(channelId, buf2, dataLen, TRANS_SESSION_BYTES);
327 EXPECT_EQ(SOFTBUS_OK, ret);
328
329 sliceHead.sliceSeq = SLICE_SEQ_END;
330 ret = memcpy_s(buf2, dataLen, &sliceHead, sizeof(SliceHead));
331 EXPECT_EQ(EOK, ret);
332 ret = ClientTransProxyOnDataReceived(channelId, buf2, dataLen, TRANS_SESSION_BYTES);
333 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
334
335 ClientTransProxyCloseChannel(channelId);
336 }
337
338 /**
339 * @tc.name: TransProxyChannelSendBytesTest
340 * @tc.desc: client trans proxy end bytes test
341 * @tc.type: FUNC
342 * @tc.require:
343 */
344 HWTEST_F(ClientTransProxyManagerTest, TransProxyChannelSendBytesTest, TestSize.Level0)
345 {
346 int32_t channelId = 1;
347 ChannelInfo channelInfo;
348 channelInfo.channelId = channelId;
349 channelInfo.sessionKey = g_sessionKey;
350 channelInfo.isEncrypt = false;
351 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
352 EXPECT_EQ(SOFTBUS_OK, ret);
353
354 ret = TransProxyChannelSendBytes(channelId, TEST_DATA, TEST_DATA_LENGTH);
355 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
356 ClientTransProxyCloseChannel(channelId);
357
358 channelInfo.isEncrypt = true;
359 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
360 EXPECT_EQ(SOFTBUS_OK, ret);
361
362 ret = TransProxyChannelSendBytes(channelId, TEST_DATA, TEST_DATA_LENGTH);
363 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
364 ClientTransProxyCloseChannel(channelId);
365 }
366
367 /**
368 * @tc.name: TransProxyChannelSendMessageTest
369 * @tc.desc: client trans proxy end bytes test
370 * @tc.type: FUNC
371 * @tc.require:
372 */
373 HWTEST_F(ClientTransProxyManagerTest, TransProxyChannelSendMessageTest, TestSize.Level0)
374 {
375 int32_t channelId = 1;
376 ChannelInfo channelInfo;
377 channelInfo.channelId = channelId;
378 channelInfo.sessionKey = g_sessionKey;
379 channelInfo.isEncrypt = false;
380 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
381 EXPECT_EQ(SOFTBUS_OK, ret);
382
383 ret = TransProxyChannelSendMessage(channelId, TEST_DATA, TEST_DATA_LENGTH);
384 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
385 ClientTransProxyCloseChannel(channelId);
386
387 channelInfo.isEncrypt = true;
388 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
389 EXPECT_EQ(SOFTBUS_OK, ret);
390
391 ret = TransProxyChannelSendMessage(channelId, TEST_DATA, TEST_DATA_LENGTH);
392 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
393 ClientTransProxyCloseChannel(channelId);
394 }
395
396 /**
397 * @tc.name: ClientTransProxyErrorCallBackTest
398 * @tc.desc: client trans proxy error callback test, use the wrong or normal parameter.
399 * @tc.type: FUNC
400 * @tc.require:
401 */
402 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyErrorCallBackTest, TestSize.Level0)
403 {
404 int32_t channelId = 1;
405 ChannelInfo channelInfo;
406 channelInfo.channelId = channelId;
407 channelInfo.sessionKey = g_sessionKey;
408 channelInfo.isEncrypt = false;
409 int32_t ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
410 EXPECT_EQ(SOFTBUS_OK, ret);
411
412 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
413 EXPECT_EQ(SOFTBUS_OK, ret);
414 ClientTransProxyCloseChannel(channelId);
415
416 ret = ClientTransProxyInit(&g_sessionCb);
417 EXPECT_EQ(SOFTBUS_OK, ret);
418
419 ret = ClientTransProxyOnChannelOpened(g_proxySessionName, &channelInfo);
420 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
421
422 ret = ClientTransProxyOnDataReceived(channelId, TEST_DATA, TEST_DATA_LENGTH, TRANS_SESSION_BYTES);
423 EXPECT_NE(SOFTBUS_OK, ret);
424 }
425
426 /**
427 * @tc.name: ClientTransProxyCloseChannelTest
428 * @tc.desc: client trans proxy close channel test, use the normal parameter.
429 * @tc.type: FUNC
430 * @tc.require:
431 */
432 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyCloseChannelTest, TestSize.Level0)
433 {
434 int32_t ret = ClientTransProxyInit(&g_sessionCb);
435 EXPECT_EQ(SOFTBUS_OK, ret);
436 int32_t channelId = 1;
437 ClientTransProxyCloseChannel(TEST_CHANNEL_ID);
438
439 ClientTransProxyCloseChannel(channelId);
440 }
441
442 /**
443 * @tc.name: TransProxyChannelSendFileTest
444 * @tc.desc: trans proxy channel send file test, use the wrong parameter.
445 * @tc.type: FUNC
446 * @tc.require:
447 */
448 HWTEST_F(ClientTransProxyManagerTest, TransProxyChannelSendFileTest, TestSize.Level0)
449 {
450 int32_t channelId = 1;
451 int ret = TransProxyChannelSendFile(channelId, nullptr, g_proxyFileSet, TEST_FILE_CNT);
452 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
453
454 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, g_proxyFileSet, MAX_SEND_FILE_NUM + TEST_FILE_CNT);
455 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
456
457 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, nullptr, TEST_FILE_CNT);
458 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
459
460 ret = TransProxyChannelSendFile(channelId, g_testProxyFileName, g_proxyFileSet, TEST_FILE_CNT);
461 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
462 }
463
464 /**
465 * @tc.name: ClientTransProxyGetInfoByChannelIdTest
466 * @tc.desc: Should return SOFTBUS_INVALID_PARAM when given channelInfo is null.
467 * @tc.desc: Should return SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND when given invalid parameter.
468 * @tc.type: FUNC
469 * @tc.require:
470 */
471 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyGetInfoByChannelIdTest, TestSize.Level0)
472 {
473 int32_t channelId = 1;
474 ProxyChannelInfoDetail info;
475 memset_s(&info, sizeof(ProxyChannelInfoDetail), 0, sizeof(ProxyChannelInfoDetail));
476 int ret = ClientTransProxyGetInfoByChannelId(channelId, nullptr);
477 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
478
479 ret = ClientTransProxyGetInfoByChannelId(channelId, &info);
480 EXPECT_EQ(SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND, ret);
481 }
482
483 /**
484 * @tc.name: TransProxyPackAndSendDataTest
485 * @tc.desc: Should return SOFTBUS_INVALID_PARAM when given channelInfo or data is null.
486 * @tc.desc: Should return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED when given invalid parameter.
487 * @tc.type: FUNC
488 * @tc.require:
489 */
490 HWTEST_F(ClientTransProxyManagerTest, TransProxyPackAndSendDataTest, TestSize.Level0)
491 {
492 int32_t channelId = 1;
493 const char *data = "test";
494 uint32_t len = 5;
495 ProxyChannelInfoDetail info;
496 memset_s(&info, sizeof(ProxyChannelInfoDetail), 0, sizeof(ProxyChannelInfoDetail));
497 SessionPktType pktType = TRANS_SESSION_MESSAGE;
498 int32_t ret = TransProxyPackAndSendData(channelId, nullptr, len, &info, pktType);
499 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
500 ret = TransProxyPackAndSendData(channelId, data, len, nullptr, pktType);
501 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
502 ret = TransProxyPackAndSendData(channelId,
503 static_cast<const void *>(data), len, &info, pktType);
504 EXPECT_EQ(SOFTBUS_PERMISSION_DENIED, ret);
505 }
506
507 /**
508 * @tc.name: ClientTransProxyGetLinkTypeByChannelId
509 * @tc.desc: Should return SOFTBUS_INVALID_PARAM when given linkType or data is null.
510 * @tc.desc: Should return SOFTBUS_NOT_FIND when get link type failed.
511 * @tc.type: FUNC
512 * @tc.require:
513 */
514 HWTEST_F(ClientTransProxyManagerTest, ClientTransProxyGetLinkTypeByChannelIdTest, TestSize.Level0)
515 {
516 int32_t channelId = -1;
517 int32_t ret = ClientTransProxyGetLinkTypeByChannelId(channelId, NULL);
518 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
519 int32_t linkType;
520 ret = ClientTransProxyGetLinkTypeByChannelId(channelId, &linkType);
521 EXPECT_EQ(SOFTBUS_NOT_FIND, ret);
522 }
523
524 /**
525 * @tc.name: ClientGetActualDataLen
526 * @tc.desc: ClientGetActualDataLen test.
527 * @tc.type: FUNC
528 * @tc.require:
529 */
530 HWTEST_F(ClientTransProxyManagerTest, ClientGetActualDataLenTest, TestSize.Level0)
531 {
532 SliceHead head = {};
533 uint32_t actualDataLen = 0;
534 g_proxyMaxByteBufSize = DEFAULT_NEW_BYTES_LEN;
535 g_proxyMaxMessageBufSize = DEFAULT_NEW_MESSAGE_LEN;
536
537 // Test case 1: Valid sliceNum, priority message
538 head.sliceNum = 1;
539 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
540 EXPECT_EQ(SOFTBUS_OK, ClientGetActualDataLen(&head, &actualDataLen));
541 EXPECT_EQ(head.sliceNum * SLICE_LEN, actualDataLen);
542
543 // Test case 2: Valid sliceNum, priority bytes
544 head.sliceNum = 10;
545 head.priority = PROXY_CHANNEL_PRORITY_BYTES;
546 EXPECT_EQ(SOFTBUS_OK, ClientGetActualDataLen(&head, &actualDataLen));
547 EXPECT_EQ(head.sliceNum * SLICE_LEN, actualDataLen);
548
549 // Test case 3: Invalid sliceNum (exceeds MAX_MALLOC_SIZE / SLICE_LEN)
550 head.sliceNum = (MAX_MALLOC_SIZE / SLICE_LEN) + 1;
551 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
552 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ClientGetActualDataLen(&head, &actualDataLen));
553
554 // Test case 4: Invalid sliceNum (actualLen exceeds maxDataLen)
555 head.sliceNum = (g_proxyMaxMessageBufSize / SLICE_LEN) + 2;
556 head.priority = PROXY_CHANNEL_PRORITY_MESSAGE;
557 EXPECT_EQ(SOFTBUS_INVALID_DATA_HEAD, ClientGetActualDataLen(&head, &actualDataLen));
558 }
559 } // namespace OHOS