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 "client_trans_channel_manager.h"
18 #include "client_trans_session_callback.h"
19 #include "client_trans_udp_manager.c"
20 #include "securec.h"
21 #include "session.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_def.h"
24 #include "softbus_error_code.h"
25 #include "trans_udp_channel_manager.h"
26
27 using namespace std;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 #define TEST_CHANNELID 1030
32 #define TEST_SESSIONID 1
33 #define ERR_CHANNELID (-1)
34 #define TEST_COUNT 2
35 #define STREAM_DATA_LENGTH 10
36 #define TEST_EVENT_ID 2
37 #define TEST_ERRCODE 426442703
38 #define TEST_CHANNELTYPE 2
39 #define TEST_CLOSEID 1088
40 class ClientTransUdpManagerStaticTest : public testing::Test {
41 public:
ClientTransUdpManagerStaticTest()42 ClientTransUdpManagerStaticTest() {}
~ClientTransUdpManagerStaticTest()43 ~ClientTransUdpManagerStaticTest() {}
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
SetUp()46 void SetUp() override {}
TearDown()47 void TearDown() override {}
48 };
49
SetUpTestCase(void)50 void ClientTransUdpManagerStaticTest::SetUpTestCase(void) {}
51
TearDownTestCase(void)52 void ClientTransUdpManagerStaticTest::TearDownTestCase(void) {}
53
54 /**
55 * @tc.name: TransOnUdpChannelBind
56 * @tc.desc: udp channel on bind test, use the invalid parameter.
57 * @tc.type: FUNC
58 * @tc.require:
59 */
60 HWTEST_F(ClientTransUdpManagerStaticTest, TransOnUdpChannelBindTest001, TestSize.Level1)
61 {
62 int32_t ret = ClientTransUdpMgrInit(nullptr);
63 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
64 ret = TransOnUdpChannelBind(TEST_CHANNELID, TEST_CHANNELTYPE);
65 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
66
67 ret = TransSetdFileIdByChannelId(TEST_CHANNELID, TEST_COUNT);
68 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
69 ret = OnIdleTimeoutReset(TEST_CHANNELID);
70 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
71 }
72
73 /**
74 * @tc.name: OnRawStreamEncryptOptGetTest001
75 * @tc.desc: on raw stream encrypt test, use the wrong or normal parameter.
76 * @tc.type: FUNC
77 * @tc.require:
78 */
79 HWTEST_F(ClientTransUdpManagerStaticTest, OnRawStreamEncryptOptGetTest001, TestSize.Level1)
80 {
81 int32_t channelId = TEST_CHANNELID;
82 int32_t sessionId = TEST_SESSIONID;
83 bool encrypt = true;
84 int32_t ret = OnRawStreamEncryptOptGet(sessionId, channelId, &encrypt);
85 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
86 }
87
88 /**
89 * @tc.name: TransSetUdpChannelEnableTest001
90 * @tc.desc: trans delete businness channel test, use the wrong or normal parameter.
91 * @tc.type: FUNC
92 * @tc.require:
93 */
94 HWTEST_F(ClientTransUdpManagerStaticTest, TransSetUdpChannelEnableTest001, TestSize.Level1)
95 {
96 int32_t ret = TransSetUdpChannelEnable(TEST_CHANNELID, false);
97 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
98 }
99
100 /**
101 * @tc.name: ClientTransUdpManagerStaticTest001
102 * @tc.desc: client trans udp manager static test, use the wrong or normal parameter.
103 * @tc.type: FUNC
104 * @tc.require:
105 */
106 HWTEST_F(ClientTransUdpManagerStaticTest, ClientTransUdpManagerStaticTest001, TestSize.Level1)
107 {
108 char sendStringData[STREAM_DATA_LENGTH] = "diudiudiu";
109 StreamData tmpData = {
110 sendStringData,
111 STREAM_DATA_LENGTH,
112 };
113 char str[STREAM_DATA_LENGTH] = "oohoohooh";
114 StreamData tmpData2 = {
115 str,
116 STREAM_DATA_LENGTH,
117 };
118
119 StreamFrameInfo tmpf = {};
120 int32_t sessionId = 0;
121 QosTv tvList;
122 OnStreamReceived(TEST_CHANNELID, &tmpData, &tmpData2, &tmpf);
123
124 int32_t ret = OnFileGetSessionId(TEST_CHANNELID, &sessionId);
125 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
126
127 OnUdpChannelOpened(TEST_CHANNELID, nullptr);
128 OnUdpChannelClosed(TEST_CHANNELID, SHUTDOWN_REASON_UNKNOWN);
129 OnQosEvent(TEST_CHANNELID, TEST_EVENT_ID, TEST_COUNT, &tvList);
130
131 ret = TransDeleteUdpChannel(TEST_CHANNELID);
132 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
133
134 UdpChannel channel;
135 ret = TransGetUdpChannel(TEST_CHANNELID, &channel);
136 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
137
138 IClientSessionCallBack *cb = GetClientSessionCb();
139 ret = ClientTransUdpMgrInit(cb);
140 ret = TransGetUdpChannel(TEST_CHANNELID, nullptr);
141 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
142
143 ret = ClosePeerUdpChannel(TEST_CHANNELID);
144 EXPECT_EQ(SOFTBUS_ACCESS_TOKEN_DENIED, ret);
145 }
146
147 /**
148 * @tc.name: ClientTransUdpManagerStaticTest002
149 * @tc.desc: client trans udp manager static test, use the wrong or normal parameter.
150 * @tc.type: FUNC
151 * @tc.require:
152 */
153 HWTEST_F(ClientTransUdpManagerStaticTest, ClientTransUdpManagerStaticTest002, TestSize.Level1)
154 {
155 int32_t sessionId = 0;
156 char sendStringData[STREAM_DATA_LENGTH] = "diudiudiu";
157 QosTv tvList;
158 StreamData tmpData = {
159 sendStringData,
160 STREAM_DATA_LENGTH,
161 };
162 char str[STREAM_DATA_LENGTH] = "oohoohooh";
163 StreamData tmpData2 = {
164 str,
165 STREAM_DATA_LENGTH,
166 };
167
168 StreamFrameInfo tmpf = {};
169
170 IClientSessionCallBack *cb = GetClientSessionCb();
171 int32_t ret = ClientTransUdpMgrInit(cb);
172 ASSERT_EQ(SOFTBUS_OK, ret);
173
174 OnUdpChannelClosed(TEST_CHANNELID, SHUTDOWN_REASON_UNKNOWN);
175 EXPECT_EQ(SOFTBUS_OK, ret);
176
177 OnStreamReceived(TEST_CHANNELID, &tmpData, &tmpData2, &tmpf);
178
179 ret = OnFileGetSessionId(TEST_CHANNELID, &sessionId);
180 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
181
182 OnQosEvent(TEST_CHANNELID, TEST_EVENT_ID, TEST_COUNT, &tvList);
183 }
184
185 /**
186 * @tc.name: ClientTransAddUdpChannelTest001
187 * @tc.desc: client trans add udp channel test, use the wrong or normal parameter.
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(ClientTransUdpManagerStaticTest, ClientTransAddUdpChannelTest001, TestSize.Level1)
192 {
193 int32_t ret = ClientTransChannelInit();
194 ASSERT_EQ(SOFTBUS_OK, ret);
195
196 ret = ClientTransAddUdpChannel(nullptr);
197 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
198
199 UdpChannel *udpChannel = static_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
200 ASSERT_TRUE(udpChannel != nullptr);
201 udpChannel->channelId = TEST_CHANNELID;
202 udpChannel->businessType = BUSINESS_TYPE_FILE;
203 ret = ClientTransAddUdpChannel(udpChannel);
204 ASSERT_EQ(SOFTBUS_OK, ret);
205
206 ret = ClientTransAddUdpChannel(udpChannel);
207 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_ALREADY_EXIST, ret);
208
209 ret = TransGetUdpChannel(TEST_CHANNELID, udpChannel);
210 EXPECT_EQ(SOFTBUS_OK, ret);
211
212 OnUdpChannelOpened(TEST_CHANNELID, nullptr);
213
214 ret = TransSetUdpChannelEnable(TEST_CHANNELID, false);
215 EXPECT_EQ(SOFTBUS_OK, ret);
216
217 ret = TransSetUdpChannelEnable(ERR_CHANNELID, false);
218 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
219
220 (void)TransDeleteUdpChannel(udpChannel->channelId);
221 }
222
223 /**
224 * @tc.name: TransDeleteBusinnessChannelTest001
225 * @tc.desc: trans delete businness channel test, use the wrong or normal parameter.
226 * @tc.type: FUNC
227 * @tc.require:
228 */
229 HWTEST_F(ClientTransUdpManagerStaticTest, TransDeleteBusinnessChannelTest001, TestSize.Level1)
230 {
231 UdpChannel channel;
232 channel.businessType = BUSINESS_TYPE_STREAM;
233 channel.channelId = ERR_CHANNELID;
234 channel.dfileId = TEST_CHANNELID;
235
236 int32_t ret = TransDeleteBusinnessChannel(&channel);
237 EXPECT_EQ(SOFTBUS_TRANS_CLOSE_UDP_CHANNEL_FAILED, ret);
238
239 channel.channelId = TEST_CHANNELID;
240 ret = TransDeleteBusinnessChannel(&channel);
241 EXPECT_EQ(SOFTBUS_TRANS_CLOSE_UDP_CHANNEL_FAILED, ret);
242
243 channel.businessType = BUSINESS_TYPE_FILE;
244 ret = TransDeleteBusinnessChannel(&channel);
245 EXPECT_EQ(SOFTBUS_OK, ret);
246
247 channel.businessType = TEST_CHANNELID;
248 ret = TransDeleteBusinnessChannel(&channel);
249 EXPECT_EQ(SOFTBUS_TRANS_BUSINESS_TYPE_NOT_MATCH, ret);
250 }
251
252 /**
253 * @tc.name: TransSetdFileIdByChannelIdTest001
254 * @tc.desc: trans delete businness channel test, use the wrong or normal parameter.
255 * @tc.type: FUNC
256 * @tc.require:
257 */
258 HWTEST_F(ClientTransUdpManagerStaticTest, TransSetdFileIdByChannelIdTest001, TestSize.Level1)
259 {
260 int32_t ret = ClientTransChannelInit();
261 ASSERT_EQ(SOFTBUS_OK, ret);
262 ret = TransSetdFileIdByChannelId(TEST_CHANNELID, TEST_COUNT);
263 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
264
265 UdpChannel *udpChannel = static_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
266 ASSERT_TRUE(udpChannel != nullptr);
267 udpChannel->channelId = TEST_CHANNELID;
268 ret = ClientTransAddUdpChannel(udpChannel);
269 EXPECT_EQ(SOFTBUS_OK, ret);
270 ret = TransSetdFileIdByChannelId(TEST_CHANNELID, TEST_COUNT);
271 EXPECT_EQ(SOFTBUS_OK, ret);
272
273 (void)TransDeleteUdpChannel(udpChannel->channelId);
274 }
275
276 /**
277 * @tc.name: TransOnUdpChannelOpenFailedTest002
278 * @tc.desc: trans on udp channel opened test, use the wrong or normal parameter.
279 * @tc.type: FUNC
280 * @tc.require:
281 */
282 HWTEST_F(ClientTransUdpManagerStaticTest, TransOnUdpChannelOpenFailedTest001, TestSize.Level1)
283 {
284 int32_t ret = ClientTransChannelInit();
285 ASSERT_EQ(SOFTBUS_OK, ret);
286
287 UdpChannel udpChannel;
288 (void)memset_s(&udpChannel, sizeof(UdpChannel), 0, sizeof(UdpChannel));
289
290 udpChannel.isEnable = false;
291 ret = TransOnUdpChannelOpenFailed(TEST_CHANNELID, TEST_ERRCODE);
292 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
293
294 udpChannel.isEnable = true;
295 ret = TransOnUdpChannelOpenFailed(TEST_CHANNELID, TEST_ERRCODE);
296 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
297 }
298
299 /**
300 * @tc.name: NotifyCallbackTest001
301 * @tc.desc: trans NotifyCallback test, use the wrong or normal parameter.
302 * @tc.type: FUNC
303 * @tc.require:
304 */
305 HWTEST_F(ClientTransUdpManagerStaticTest, NotifyCallbackTest001, TestSize.Level1)
306 {
307 UdpChannel *testChannel = nullptr;
308 NotifyCallback(testChannel, TEST_CHANNELID, SHUTDOWN_REASON_UNKNOWN);
309
310 UdpChannel *channel = static_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
311 ASSERT_TRUE(channel != nullptr);
312 channel->channelId = TEST_CHANNELID;
313 channel->isEnable = false;
314 int32_t ret = ClientTransAddUdpChannel(channel);
315 EXPECT_EQ(SOFTBUS_OK, ret);
316 NotifyCallback(channel, TEST_CHANNELID, SHUTDOWN_REASON_UNKNOWN);
317
318 channel->isEnable = true;
319 ret = ClientTransAddUdpChannel(channel);
320 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_ALREADY_EXIST, ret);
321 NotifyCallback(channel, TEST_CHANNELID, SHUTDOWN_REASON_UNKNOWN);
322
323 (void)TransDeleteUdpChannel(channel->channelId);
324 }
325
326 /**
327 * @tc.name: CloseUdpChannelProcTest001
328 * @tc.desc: trans CloseUdpChannelProc test, use the wrong or normal parameter.
329 * @tc.type: FUNC
330 * @tc.require:
331 */
332 HWTEST_F(ClientTransUdpManagerStaticTest, CloseUdpChannelProc001, TestSize.Level1)
333 {
334 UdpChannel udpChannel;
335 (void)memset_s(&udpChannel, sizeof(UdpChannel), 0, sizeof(UdpChannel));
336 udpChannel.businessType = BUSINESS_TYPE_FILE;
337 int32_t ret = CloseUdpChannelProc(&udpChannel, TEST_CLOSEID, SHUTDOWN_REASON_PEER);
338 EXPECT_EQ(SOFTBUS_OK, ret);
339
340 ret = CloseUdpChannelProc(&udpChannel, TEST_CLOSEID, SHUTDOWN_REASON_SEND_FILE_ERR);
341 EXPECT_EQ(SOFTBUS_OK, ret);
342
343 ret = CloseUdpChannelProc(&udpChannel, TEST_CLOSEID, SHUTDOWN_REASON_RECV_FILE_ERR);
344 EXPECT_EQ(SOFTBUS_OK, ret);
345
346 ret = CloseUdpChannelProc(&udpChannel, TEST_CLOSEID, SHUTDOWN_REASON_LOCAL);
347 EXPECT_EQ(SOFTBUS_OK, ret);
348
349 ret = CloseUdpChannelProc(nullptr, TEST_CLOSEID, SHUTDOWN_REASON_PEER);
350 EXPECT_EQ(SOFTBUS_OK, ret);
351 }
352
353 /**
354 * @tc.name: CloseUdpChannelTest001
355 * @tc.desc: close udp channel test, use the wrong or normal parameter.
356 * @tc.type: FUNC
357 * @tc.require:
358 */
359 HWTEST_F(ClientTransUdpManagerStaticTest, CloseUdpChannelTest001, TestSize.Level1)
360 {
361 int32_t ret = ClientTransChannelInit();
362 EXPECT_EQ(SOFTBUS_OK, ret);
363
364 ret = CloseUdpChannel(TEST_CLOSEID, SHUTDOWN_REASON_PEER);
365 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
366
367 ret = CloseUdpChannel(TEST_CLOSEID, SHUTDOWN_REASON_PEER);
368 EXPECT_EQ(SOFTBUS_TRANS_UDP_GET_CHANNEL_FAILED, ret);
369 }
370
371 /**
372 * @tc.name: OnIdleTimeoutResetTest001
373 * @tc.desc: client On idle timeout reset test, use the wrong or normal parameter.
374 * @tc.type: FUNC
375 * @tc.require:
376 */
377 HWTEST_F(ClientTransUdpManagerStaticTest, OnIdleTimeoutResetTest001, TestSize.Level1)
378 {
379 int32_t ret = OnIdleTimeoutReset(TEST_CHANNELID);
380 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
381 }
382
383 /**
384 * @tc.name: OnRawStreamEncryptOptGetTest002
385 * @tc.desc: on raw stream encrypt test, use the wrong or normal parameter.
386 * @tc.type: FUNC
387 * @tc.require:
388 */
389 HWTEST_F(ClientTransUdpManagerStaticTest, OnRawStreamEncryptOptGetTest002, TestSize.Level1)
390 {
391 int32_t channelId = TEST_CHANNELID;
392 int32_t sessionId = TEST_SESSIONID;
393 bool encrypt = true;
394 int32_t ret = OnRawStreamEncryptOptGet(sessionId, channelId, &encrypt);
395 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
396 }
397
398 /**
399 * @tc.name: OnRawStreamEncryptOptGetTest003
400 * @tc.desc: on raw stream encrypt test, use the wrong or normal parameter.
401 * @tc.type: FUNC
402 * @tc.require:
403 */
404 HWTEST_F(ClientTransUdpManagerStaticTest, OnRawStreamEncryptOptGetTest003, TestSize.Level1)
405 {
406 int32_t channelId = TEST_CHANNELID;
407 int32_t sessionId = TEST_SESSIONID;
408 bool encrypt = true;
409 int32_t ret = OnRawStreamEncryptOptGet(sessionId, channelId, nullptr);
410 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
411
412 channelId = ERR_CHANNELID;
413 ret = OnRawStreamEncryptOptGet(sessionId, channelId, &encrypt);
414 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
415 }
416
417 /**
418 * @tc.name: OnRawStreamEncryptOptGetTest004
419 * @tc.desc: on raw stream encrypt test, use the wrong or normal parameter.
420 * @tc.type: FUNC
421 * @tc.require:
422 */
423 HWTEST_F(ClientTransUdpManagerStaticTest, OnRawStreamEncryptOptGetTest004, TestSize.Level1)
424 {
425 UdpChannel *udpChannel = static_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
426 ASSERT_TRUE(udpChannel != nullptr);
427 udpChannel->channelId = TEST_CHANNELID;
428 udpChannel->info.isServer = true;
429
430 int32_t ret = ClientTransAddUdpChannel(udpChannel);
431 EXPECT_EQ(SOFTBUS_OK, ret);
432 int32_t channelId = TEST_CHANNELID;
433 int32_t sessionId = TEST_SESSIONID;
434 bool encrypt = true;
435 ret = OnRawStreamEncryptOptGet(sessionId, channelId, &encrypt);
436 EXPECT_EQ(SOFTBUS_TRANS_SESSION_SERVER_NOINIT, ret);
437
438 udpChannel->channelId = TEST_CLOSEID;
439 udpChannel->info.isServer = false;
440 ret = ClientTransAddUdpChannel(udpChannel);
441 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_ALREADY_EXIST, ret);
442 ret = OnRawStreamEncryptOptGet(sessionId, channelId, &encrypt);
443 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_NOT_FOUND, ret);
444
445 (void)TransDeleteUdpChannel(udpChannel->channelId);
446 }
447
448 /**
449 * @tc.name: TransUdpChannelSetStreamMultiLayer
450 * @tc.desc: TransUdpChannelSetStreamMultiLayer
451 * @tc.type: FUNC
452 * @tc.require:
453 */
454 HWTEST_F(ClientTransUdpManagerStaticTest, TransUdpChannelSetStreamMultiLayer, TestSize.Level1)
455 {
456 UdpChannel *udpChannel = static_cast<UdpChannel *>(SoftBusCalloc(sizeof(UdpChannel)));
457 ASSERT_TRUE(udpChannel != nullptr);
458 udpChannel->channelId = TEST_CHANNELID;
459 udpChannel->isEnable = false;
460
461 ClientTransAddUdpChannel(udpChannel);
462 int32_t ret = TransUdpChannelSetStreamMultiLayer(TEST_CHANNELID, nullptr);
463 EXPECT_EQ(SOFTBUS_TRANS_UDP_CHANNEL_DISABLE, ret);
464
465 udpChannel->isEnable = true;
466 ret = TransUdpChannelSetStreamMultiLayer(TEST_CHANNELID, nullptr);
467 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
468
469 (void)TransDeleteUdpChannel(udpChannel->channelId);
470 }
471
472 /**
473 * @tc.name: TransSendLimitChangeDataToCoreTest001
474 * @tc.desc: TransSendLimitChangeDataToCore
475 * @tc.type: FUNC
476 * @tc.require:
477 */
478 HWTEST_F(ClientTransUdpManagerStaticTest, TransSendLimitChangeDataToCoreTest001, TestSize.Level1)
479 {
480 int32_t ret = TransSendLimitChangeDataToCore(TEST_CHANNELID, FILE_PRIORITY_BK, NSTACKX_EOK);
481 EXPECT_EQ(SOFTBUS_OK, ret);
482 }
483 } // namespace OHOS
484