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