1 /*
2 * Copyright (c) 2022-2023 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
18 #include <gtest/gtest.h>
19 #include "softbus_def.h"
20 #include "softbus_error_code.h"
21 #include "softbus_trans_def.h"
22 #include "softbus_json_utils.h"
23 #include "softbus_app_info.h"
24 #include "softbus_config_type.h"
25 #include "softbus_server_frame.h"
26 #include "softbus_adapter_mem.h"
27 #include "client_trans_message_service.h"
28 #include "client_trans_message_service.c"
29 #include "client_trans_session_manager.h"
30 #include "client_trans_socket_manager.h"
31 #include "softbus_common.h"
32 #include "trans_log.h"
33 #include "softbus_feature_config.h"
34 #include "softbus_conn_interface.h"
35 #include "auth_interface.h"
36 #include "bus_center_manager.h"
37 #include "trans_session_service.h"
38
39
40 #define TRANS_TEST_SESSION_ID 10
41 #define TRANS_TEST_CHANNEL_ID 1000
42 #define TRANS_TEST_FILE_ENCRYPT 10
43 #define TRANS_TEST_ALGORITHM 1
44 #define TRANS_TEST_CRC 1
45 #define TRANS_TEST_AUTH_DATA "test auth message data"
46 #define TRANS_TEST_MAX_MSG_LEN (1 * 1024)
47 #define TRANS_TEST_MAX_BYTES_LEN (2 * 1024)
48 #define TRANS_TEST_BEYOND_MAX_MSG_LEN (6 * 1024)
49 #define TRANS_TEST_DEFAULT_MAX_MSG_LEN (4 * 1024)
50 #define TRANS_TEST_BEYOND_MAX_BYTES_LEN (6 * 1024 * 1024)
51 #define TRANS_TEST_SEND_LEN 123
52 #define TRANS_TEST_FILE_COUNT 2
53
54 #define TRANS_TEST_INVALID_SEND_LEN (1024 * 1024)
55
56 using namespace testing::ext;
57
58 namespace OHOS {
59
60 const char *g_pkgName = "dms";
61 const char *g_sessionName = "ohos.distributedschedule.dms.test";
62 const char *g_sessionKey = "www.test.com";
63 const char *g_networkId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
64 const char *g_deviceId = "ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF00ABCDEF0";
65 const char *g_groupId = "TEST_GROUP_ID";
66 static SessionAttribute g_sessionAttr = {
67 .dataType = TYPE_BYTES,
68 };
69 class TransClientMsgServiceTest : public testing::Test {
70 public:
TransClientMsgServiceTest()71 TransClientMsgServiceTest()
72 {}
~TransClientMsgServiceTest()73 ~TransClientMsgServiceTest()
74 {}
75 static void SetUpTestCase(void);
76 static void TearDownTestCase(void);
SetUp()77 void SetUp() override
78 {}
TearDown()79 void TearDown() override
80 {}
81 };
82
SetUpTestCase(void)83 void TransClientMsgServiceTest::SetUpTestCase(void)
84 {
85 SoftbusConfigInit();
86 ConnServerInit();
87 AuthInit();
88 BusCenterServerInit();
89 TransServerInit();
90 int32_t ret = TransClientInit();
91 ASSERT_EQ(ret, SOFTBUS_OK);
92 }
93
TearDownTestCase(void)94 void TransClientMsgServiceTest::TearDownTestCase(void)
95 {
96 ConnServerDeinit();
97 AuthDeinit();
98 BusCenterServerDeinit();
99 TransServerDeinit();
100 }
101
OnSessionOpened(int32_t sessionId,int32_t result)102 static int32_t OnSessionOpened(int32_t sessionId, int32_t result)
103 {
104 TRANS_LOGI(TRANS_TEST, "session opened, sessionId=%{public}d", sessionId);
105 return SOFTBUS_OK;
106 }
107
OnSessionClosed(int32_t sessionId)108 static void OnSessionClosed(int32_t sessionId)
109 {
110 TRANS_LOGI(TRANS_TEST, "session closed, sessionId=%{public}d", sessionId);
111 }
112
OnBytesReceived(int32_t sessionId,const void * data,unsigned int len)113 static void OnBytesReceived(int32_t sessionId, const void *data, unsigned int len)
114 {
115 TRANS_LOGI(TRANS_TEST, "session bytes received, sessionId=%{public}d", sessionId);
116 }
117
OnMessageReceived(int32_t sessionId,const void * data,unsigned int len)118 static void OnMessageReceived(int32_t sessionId, const void *data, unsigned int len)
119 {
120 TRANS_LOGI(TRANS_TEST, "session msg received, sessionId=%{public}d", sessionId);
121 }
122
OnStreamReceived(int32_t sessionId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)123 static void OnStreamReceived(int32_t sessionId, const StreamData *data,
124 const StreamData *ext, const StreamFrameInfo *param)
125 {
126 TRANS_LOGI(TRANS_TEST, "session stream received, sessionId=%{public}d", sessionId);
127 }
128
OnQosEvent(int32_t sessionId,int32_t eventId,int32_t tvCount,const QosTv * tvList)129 static void OnQosEvent(int32_t sessionId, int32_t eventId, int32_t tvCount, const QosTv *tvList)
130 {
131 TRANS_LOGI(TRANS_TEST, "session Qos event emit, sessionId=%{public}d", sessionId);
132 }
133
134 static ISessionListener g_sessionlistener = {
135 .OnSessionOpened = OnSessionOpened,
136 .OnSessionClosed = OnSessionClosed,
137 .OnBytesReceived = OnBytesReceived,
138 .OnMessageReceived = OnMessageReceived,
139 .OnStreamReceived = OnStreamReceived,
140 .OnQosEvent = OnQosEvent,
141 };
142
TestGenerateCommParam(SessionParam * sessionParam)143 static void TestGenerateCommParam(SessionParam *sessionParam)
144 {
145 sessionParam->sessionName = g_sessionName;
146 sessionParam->peerSessionName = g_sessionName;
147 sessionParam->peerDeviceId = g_deviceId;
148 sessionParam->groupId = g_groupId;
149 sessionParam->attr = &g_sessionAttr;
150 }
151
TestGenerateSession(const SessionParam * param)152 static SessionInfo *TestGenerateSession(const SessionParam *param)
153 {
154 SessionInfo *session = (SessionInfo*)SoftBusCalloc(sizeof(SessionInfo));
155 if (session == nullptr) {
156 return nullptr;
157 }
158
159 if (strcpy_s(session->info.peerSessionName, SESSION_NAME_SIZE_MAX, param->peerSessionName) != EOK ||
160 strcpy_s(session->info.peerDeviceId, DEVICE_ID_SIZE_MAX, param->peerDeviceId) != EOK ||
161 strcpy_s(session->info.groupId, GROUP_ID_SIZE_MAX, param->groupId) != EOK) {
162 SoftBusFree(session);
163 return nullptr;
164 }
165
166 session->sessionId = TRANS_TEST_SESSION_ID;
167 session->channelId = TRANS_TEST_CHANNEL_ID;
168 session->channelType = CHANNEL_TYPE_BUTT;
169 session->isServer = false;
170 session->enableStatus = ENABLE_STATUS_INIT;
171 session->routeType = ROUTE_TYPE_ALL;
172 session->info.flag = TYPE_BYTES;
173 session->isEncrypt = true;
174 session->algorithm = TRANS_TEST_ALGORITHM;
175 session->fileEncrypt = TRANS_TEST_FILE_ENCRYPT;
176 session->crc = TRANS_TEST_CRC;
177
178 return session;
179 }
180
AddSessionServerAndSession(const char * sessionName,int32_t channelType,int32_t businessType,bool isServer,SessionEnableStatus enableStatus)181 static int32_t AddSessionServerAndSession(
182 const char *sessionName, int32_t channelType, int32_t businessType, bool isServer, SessionEnableStatus enableStatus)
183 {
184 SessionParam *sessionParam = (SessionParam*)SoftBusCalloc(sizeof(SessionParam));
185 if (sessionParam == nullptr) {
186 return SOFTBUS_MALLOC_ERR;
187 }
188
189 TestGenerateCommParam(sessionParam);
190 sessionParam->sessionName = sessionName;
191 uint64_t timestamp = 0;
192 int32_t ret = ClientAddSessionServer(SEC_TYPE_PLAINTEXT, g_pkgName, sessionName, &g_sessionlistener, ×tamp);
193 if (ret != SOFTBUS_OK) {
194 return ret;
195 }
196
197 SessionInfo *session = TestGenerateSession(sessionParam);
198 if (session == nullptr) {
199 return SOFTBUS_MALLOC_ERR;
200 }
201
202 session->channelType = (ChannelType)channelType;
203 session->businessType = (BusinessType)businessType;
204 session->isServer = isServer;
205 session->enableStatus = enableStatus;
206 ret = ClientAddNewSession(sessionName, session);
207 if (ret != SOFTBUS_OK) {
208 return ret;
209 }
210
211 int32_t sessionId = 0;
212 bool isClosing = false;
213 ret = ClientGetSessionIdByChannelId(TRANS_TEST_CHANNEL_ID, channelType, &sessionId, isClosing);
214 if (ret != SOFTBUS_OK) {
215 return ret;
216 }
217 SoftBusFree(sessionParam);
218 return sessionId;
219 }
220
DeleteSessionServerAndSession(const char * sessionName,int32_t sessionId)221 static void DeleteSessionServerAndSession(const char *sessionName, int32_t sessionId)
222 {
223 int32_t ret = ClientDeleteSession(sessionId);
224 EXPECT_EQ(ret, SOFTBUS_OK);
225 ret = ClientDeleteSessionServer(SEC_TYPE_PLAINTEXT, sessionName);
226 EXPECT_EQ(ret, SOFTBUS_OK);
227 }
228
229 /**
230 * @tc.name: TransClientMsgServiceTest01
231 * @tc.desc: Transmission sdk message service check send length with different parameters.
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest01, TestSize.Level1)
236 {
237 int32_t ret = CheckSendLen(CHANNEL_TYPE_BUTT, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
238 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
239 ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_INVALID_SEND_LEN, BUSINESS_TYPE_MESSAGE);
240 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
241 ret = CheckSendLen(CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, TRANS_TEST_SEND_LEN, BUSINESS_TYPE_MESSAGE);
242 EXPECT_EQ(ret, SOFTBUS_GET_CONFIG_VAL_ERR);
243 }
244
245 /**
246 * @tc.name: TransClientMsgServiceTest02
247 * @tc.desc: Transmission sdk message service send bytes with different parameters.
248 * @tc.type: FUNC
249 * @tc.require:
250 */
251 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest02, TestSize.Level1)
252 {
253 int32_t sessionId =
254 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
255 ASSERT_GT(sessionId, 0);
256 int32_t ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, 0);
257 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
258 DeleteSessionServerAndSession(g_sessionName, sessionId);
259
260 sessionId =
261 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
262 ASSERT_GT(sessionId, 0);
263 ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
264 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
265 DeleteSessionServerAndSession(g_sessionName, sessionId);
266
267 sessionId =
268 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
269 ASSERT_GT(sessionId, 0);
270 ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, TRANS_TEST_BEYOND_MAX_BYTES_LEN);
271 EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
272 DeleteSessionServerAndSession(g_sessionName, sessionId);
273
274 sessionId =
275 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_INIT);
276 ASSERT_GT(sessionId, 0);
277 ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
278 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
279 DeleteSessionServerAndSession(g_sessionName, sessionId);
280
281 sessionId = AddSessionServerAndSession(
282 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
283 ASSERT_GT(sessionId, 0);
284 ret = SendBytes(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
285 EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
286 DeleteSessionServerAndSession(g_sessionName, sessionId);
287 }
288
289 /**
290 * @tc.name: TransClientMsgServiceTest03
291 * @tc.desc: Transmission sdk message service send message with different parameters.
292 * @tc.type: FUNC
293 * @tc.require:
294 */
295 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest03, TestSize.Level1)
296 {
297 int32_t sessionId =
298 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
299 ASSERT_GT(sessionId, 0);
300 int32_t ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, 0);
301 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
302 DeleteSessionServerAndSession(g_sessionName, sessionId);
303
304 sessionId =
305 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
306 ASSERT_GT(sessionId, 0);
307 ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
308 EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
309 DeleteSessionServerAndSession(g_sessionName, sessionId);
310
311 sessionId = AddSessionServerAndSession(
312 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_SUCCESS);
313 ASSERT_GT(sessionId, 0);
314 ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, TRANS_TEST_BEYOND_MAX_MSG_LEN);
315 EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
316 DeleteSessionServerAndSession(g_sessionName, sessionId);
317
318 sessionId = AddSessionServerAndSession(
319 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_INIT);
320 ASSERT_GT(sessionId, 0);
321 ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
322 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
323 DeleteSessionServerAndSession(g_sessionName, sessionId);
324
325 sessionId = AddSessionServerAndSession(
326 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
327 ASSERT_GT(sessionId, 0);
328 ret = SendMessage(sessionId, TRANS_TEST_AUTH_DATA, (unsigned int)strlen(TRANS_TEST_AUTH_DATA));
329 EXPECT_EQ(ret, SOFTBUS_PERMISSION_DENIED);
330 DeleteSessionServerAndSession(g_sessionName, sessionId);
331 }
332
333 /**
334 * @tc.name: TransClientMsgServiceTest04
335 * @tc.desc: Transmission sdk message service send stream with different parameters.
336 * @tc.type: FUNC
337 * @tc.require:
338 */
339 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest04, TestSize.Level1)
340 {
341 char dataBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
342 StreamData data = {
343 .buf = dataBuf,
344 .bufLen = TRANS_TEST_MAX_MSG_LEN
345 };
346 char extBuf[TRANS_TEST_MAX_MSG_LEN] = {0};
347 StreamData ext = {
348 .buf = extBuf,
349 .bufLen = TRANS_TEST_MAX_MSG_LEN
350 };
351 StreamFrameInfo streamFrameInfo = {0};
352 int32_t sessionId =
353 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_BUTT, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
354 ASSERT_GT(sessionId, 0);
355 int32_t ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
356 EXPECT_EQ(ret, SOFTBUS_TRANS_STREAM_ONLY_UDP_CHANNEL);
357 DeleteSessionServerAndSession(g_sessionName, sessionId);
358
359 sessionId =
360 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
361 ASSERT_GT(sessionId, 0);
362 ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
363 EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
364 DeleteSessionServerAndSession(g_sessionName, sessionId);
365
366 sessionId =
367 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, ENABLE_STATUS_INIT);
368 ASSERT_GT(sessionId, 0);
369 ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
370 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
371 DeleteSessionServerAndSession(g_sessionName, sessionId);
372
373 sessionId =
374 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_STREAM, false, ENABLE_STATUS_SUCCESS);
375 ASSERT_GT(sessionId, 0);
376 ret = SendStream(sessionId, &data, &ext, &streamFrameInfo);
377 EXPECT_NE(ret, SOFTBUS_OK);
378 DeleteSessionServerAndSession(g_sessionName, sessionId);
379 }
380
381 /**
382 * @tc.name: TransClientMsgServiceTest05
383 * @tc.desc: Transmission sdk message service send file with different parameters.
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(TransClientMsgServiceTest, TransClientMsgServiceTest05, TestSize.Level1)
388 {
389 const char *sFileList[TRANS_TEST_FILE_COUNT] = {
390 "/DATA/LOCAL/X",
391 "/DATA/LOCAL/Y"
392 };
393 const char *dFileList[TRANS_TEST_FILE_COUNT] = {
394 "/DATA/LOCAL/X",
395 "/DATA/LOCAL/Y"
396 };
397 int32_t sessionId =
398 AddSessionServerAndSession(g_sessionName, CHANNEL_TYPE_UDP, BUSINESS_TYPE_BUTT, false, ENABLE_STATUS_SUCCESS);
399 ASSERT_GT(sessionId, 0);
400 int32_t ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
401 EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
402 DeleteSessionServerAndSession(g_sessionName, sessionId);
403 sessionId = AddSessionServerAndSession(
404 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_INIT);
405 ASSERT_GT(sessionId, 0);
406 ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
407 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_NO_ENABLE);
408 DeleteSessionServerAndSession(g_sessionName, sessionId);
409 sessionId = AddSessionServerAndSession(
410 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_NOT_CARE, false, ENABLE_STATUS_SUCCESS);
411 ASSERT_GT(sessionId, 0);
412 ret = SendFile(sessionId, sFileList, dFileList, TRANS_TEST_FILE_COUNT);
413 EXPECT_EQ(ret, SOFTBUS_TRANS_CHANNEL_TYPE_INVALID);
414 DeleteSessionServerAndSession(g_sessionName, sessionId);
415 }
416
417 /**
418 * @tc.name: CheckSendLenForBoosterTest01
419 * @tc.desc: CheckSendLenForBooster with different parameters.
420 * @tc.type: FUNC
421 * @tc.require:
422 */
423 HWTEST_F(TransClientMsgServiceTest, CheckSendLenForBoosterTest01, TestSize.Level1)
424 {
425 int32_t ret = CheckSendLenForBooster(TRANS_TEST_BEYOND_MAX_BYTES_LEN);
426 EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
427
428 ret = CheckSendLenForBooster(TRANS_TEST_INVALID_SEND_LEN);
429 EXPECT_EQ(ret, SOFTBUS_OK);
430 }
431
432 /**
433 * @tc.name: CheckAsyncSendBytesFuncTest01
434 * @tc.desc: CheckAsyncSendBytesFunc with different parameters.
435 * @tc.type: FUNC
436 * @tc.require:
437 */
438 HWTEST_F(TransClientMsgServiceTest, CheckAsyncSendBytesFuncTest01, TestSize.Level1)
439 {
440 int32_t channelId = 0;
441 int32_t channelType = CHANNEL_TYPE_AUTH;
442 int32_t sessionId = AddSessionServerAndSession(
443 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_SUCCESS);
444 ASSERT_GT(sessionId, 0);
445 int32_t ret = CheckAsyncSendBytesFunc(channelId, channelType);
446 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
447 DeleteSessionServerAndSession(g_sessionName, sessionId);
448
449 sessionId = AddSessionServerAndSession(
450 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_SUCCESS);
451 ASSERT_GT(sessionId, 0);
452 channelId = TRANS_TEST_CHANNEL_ID;
453 ret = CheckAsyncSendBytesFunc(channelId, channelType);
454 EXPECT_EQ(ret, SOFTBUS_TRANS_NOT_SUPPORT_ASYNC_SEND_BYTES);
455 DeleteSessionServerAndSession(g_sessionName, sessionId);
456 }
457
458 /**
459 * @tc.name: SendBytesAsyncTest01
460 * @tc.desc: SendBytesAsync with different parameters.
461 * @tc.type: FUNC
462 * @tc.require:
463 */
464 HWTEST_F(TransClientMsgServiceTest, SendBytesAsyncTest01, TestSize.Level1)
465 {
466 int32_t socket = TRANS_TEST_SESSION_ID;
467 uint32_t dataSeq = 1;
468 const void *data = "testdata";
469 uint32_t len = TRANS_TEST_SEND_LEN;
470 int32_t ret = SendBytesAsync(socket, 0, data, len);
471 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
472
473 ret = SendBytesAsync(socket, dataSeq, nullptr, len);
474 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
475
476 ret = SendBytesAsync(socket, dataSeq, data, 0);
477 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
478
479 ret = SendBytesAsync(socket, 0, nullptr, len);
480 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
481
482 ret = SendBytesAsync(socket, dataSeq, nullptr, 0);
483 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
484
485 ret = SendBytesAsync(socket, 0, data, 0);
486 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
487
488 ret = SendBytesAsync(socket, dataSeq, data, len);
489 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
490
491 int32_t sessionId = AddSessionServerAndSession(
492 g_sessionName, CHANNEL_TYPE_AUTH, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_SUCCESS);
493 ASSERT_GT(sessionId, 0);
494 ret = SendBytesAsync(sessionId, dataSeq, data, len);
495 EXPECT_EQ(ret, SOFTBUS_TRANS_NOT_SUPPORT_ASYNC_SEND_BYTES);
496 DeleteSessionServerAndSession(g_sessionName, sessionId);
497 }
498
499 /**
500 * @tc.name: SendMessageAsyncTest01
501 * @tc.desc: SendMessageAsync with different parameters.
502 * @tc.type: FUNC
503 * @tc.require:
504 */
505 HWTEST_F(TransClientMsgServiceTest, SendMessageAsyncTest01, TestSize.Level1)
506 {
507 int32_t socket = TRANS_TEST_SESSION_ID;
508 uint16_t dataSeq = 0;
509 const void *data = "testdata";
510 uint32_t len = 0;
511 int32_t ret = SendMessageAsync(socket, dataSeq, nullptr, len);
512 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
513
514 ret = SendMessageAsync(socket, dataSeq, data, len);
515 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
516
517 len = TRANS_TEST_SEND_LEN;
518 ret = SendMessageAsync(socket, dataSeq, data, len);
519 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
520
521 dataSeq = 1;
522 ret = SendMessageAsync(socket, dataSeq, data, len);
523 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
524
525 ret = SendMessageAsync(0, dataSeq, data, len);
526 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
527
528 ret = SendMessageAsync(-1, dataSeq, data, len);
529 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
530
531 int32_t sessionId = AddSessionServerAndSession(
532 g_sessionName, CHANNEL_TYPE_PROXY, BUSINESS_TYPE_MESSAGE, false, ENABLE_STATUS_SUCCESS);
533 ASSERT_GT(sessionId, 0);
534 ret = SendMessageAsync(sessionId, dataSeq, data, len);
535 EXPECT_EQ(ret, SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH);
536 DeleteSessionServerAndSession(g_sessionName, sessionId);
537
538 sessionId = AddSessionServerAndSession(
539 g_sessionName, CHANNEL_TYPE_PROXY, BUSINESS_TYPE_D2D_MESSAGE, false, ENABLE_STATUS_SUCCESS);
540 ASSERT_GT(sessionId, 0);
541 ret = SendMessageAsync(sessionId, dataSeq, data, len);
542 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND);
543
544 len = TRANS_TEST_BEYOND_MAX_MSG_LEN;
545 ret = SendMessageAsync(sessionId, dataSeq, data, len);
546 EXPECT_EQ(ret, SOFTBUS_TRANS_SEND_LEN_BEYOND_LIMIT);
547
548 len = TRANS_TEST_DEFAULT_MAX_MSG_LEN;
549 ret = SendMessageAsync(sessionId, dataSeq, data, len);
550 EXPECT_EQ(ret, SOFTBUS_TRANS_PROXY_CHANNEL_NOT_FOUND);
551 DeleteSessionServerAndSession(g_sessionName, sessionId);
552 }
553 }
554