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 #include <iostream>
16 #include <gtest/gtest.h>
17 #include <securec.h>
18
19 #include "client_trans_session_manager.h"
20 #include "client_trans_socket_manager.h"
21 #include "client_trans_stream.c"
22 #include "client_trans_stream.h"
23 #include "client_trans_udp_manager.h"
24 #include "softbus_adapter_mem.h"
25 #include "trans_server_proxy.h"
26
27 #define TEST_CHANNELID 1025
28
29 using namespace testing::ext;
30 namespace OHOS {
31 class ClientTransStreamTest : public testing::Test {
32 public:
ClientTransStreamTest()33 ClientTransStreamTest()
34 {}
~ClientTransStreamTest()35 ~ClientTransStreamTest()
36 {}
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
SetUp()39 void SetUp() override
40 {}
TearDown()41 void TearDown() override
42 {}
43 };
44
SetUpTestCase(void)45 void ClientTransStreamTest::SetUpTestCase(void)
46 {}
47
TearDownTestCase(void)48 void ClientTransStreamTest::TearDownTestCase(void)
49 {}
50
TestOnStreamReceived(int32_t channelId,const StreamData * data,const StreamData * ext,const StreamFrameInfo * param)51 static void TestOnStreamReceived(int32_t channelId, const StreamData *data, const StreamData *ext,
52 const StreamFrameInfo *param)
53 {
54 (void)channelId;
55 (void)data;
56 (void)ext;
57 (void)param;
58 }
59
TestOnFileGetSessionId(int32_t channelId,int32_t * sessionId)60 static int32_t TestOnFileGetSessionId(int32_t channelId, int32_t *sessionId)
61 {
62 (void)channelId;
63 (void)sessionId;
64 return SOFTBUS_OK;
65 }
66
TestOnUdpChannelOpened(int32_t channelId)67 static int32_t TestOnUdpChannelOpened(int32_t channelId)
68 {
69 (void)channelId;
70 return SOFTBUS_OK;
71 }
72
TestOnUdpChannelClosed(int32_t channelId,ShutdownReason reason)73 static void TestOnUdpChannelClosed(int32_t channelId, ShutdownReason reason)
74 {
75 (void)channelId;
76 (void)reason;
77 }
78
TestOnQosEvent(int channelId,int eventId,int tvCount,const QosTv * tvList)79 static void TestOnQosEvent(int channelId, int eventId, int tvCount, const QosTv *tvList)
80 {
81 (void)channelId;
82 (void)eventId;
83 (void)tvCount;
84 (void)tvList;
85 }
86
TestOnIdleTimeoutReset(int32_t sessionId)87 static int32_t TestOnIdleTimeoutReset(int32_t sessionId)
88 {
89 (void)sessionId;
90 return SOFTBUS_OK;
91 }
92
TestOnRawStreamEncryptOptGet(int32_t channelId,bool * isEncrypt)93 static int32_t TestOnRawStreamEncryptOptGet(int32_t channelId, bool *isEncrypt)
94 {
95 (void)channelId;
96 (void)isEncrypt;
97 return SOFTBUS_OK;
98 }
99
100 static UdpChannelMgrCb g_testUdpChannelCb = {
101 .OnStreamReceived = TestOnStreamReceived,
102 .OnFileGetSessionId = TestOnFileGetSessionId,
103 .OnMessageReceived = nullptr,
104 .OnUdpChannelOpened = TestOnUdpChannelOpened,
105 .OnUdpChannelClosed = TestOnUdpChannelClosed,
106 .OnQosEvent = TestOnQosEvent,
107 .OnIdleTimeoutReset = TestOnIdleTimeoutReset,
108 .OnRawStreamEncryptOptGet = TestOnRawStreamEncryptOptGet,
109 };
110
111 /**
112 * @tc.name: RegisterStreamCb001
113 * @tc.desc: RegisterStreamCb error.
114 * @tc.desc: UnregisterStreamCb error.
115 * @tc.desc: SetStreamChannelStatus error.
116 * @tc.type: FUNC
117 * @tc.require:
118 */
119 HWTEST_F(ClientTransStreamTest, RegisterStreamCb001, TestSize.Level0)
120 {
121 RegisterStreamCb(nullptr);
122 UnregisterStreamCb();
123 int32_t channelId = 12;
124 int32_t status = 2;
125 SetStreamChannelStatus(channelId, status);
126
127 UdpChannelMgrCb *streamCb = (UdpChannelMgrCb*)SoftBusMalloc(sizeof(UdpChannelMgrCb));
128 ASSERT_TRUE(streamCb != nullptr);
129 (void)memset_s(streamCb, sizeof(UdpChannelMgrCb), 0, sizeof(UdpChannelMgrCb));
130
131 IClientSessionCallBack *cb = GetClientSessionCb();
132 int32_t ret = ClientTransUdpMgrInit(cb);
133 EXPECT_EQ(ret, SOFTBUS_OK);
134 RegisterStreamCb(streamCb);
135 SetStreamChannelStatus(channelId, status);
136
137 status = STREAM_CONNECTED;
138 SetStreamChannelStatus(channelId, status);
139
140 status = STREAM_CLOSED;
141 SetStreamChannelStatus(channelId, status);
142
143 status = STREAM_INIT;
144 SetStreamChannelStatus(channelId, status);
145
146 status = STREAM_OPENING;
147 SetStreamChannelStatus(channelId, status);
148
149 status = STREAM_CONNECTING;
150 SetStreamChannelStatus(channelId, status);
151
152 status = STREAM_CLOSING;
153 SetStreamChannelStatus(channelId, status);
154
155 status = STREAM_OPENED;
156 SetStreamChannelStatus(channelId, status);
157
158 OnStreamReceived(channelId, nullptr, nullptr, nullptr);
159 UnregisterStreamCb();
160 OnStreamReceived(channelId, nullptr, nullptr, nullptr);
161 if (streamCb != nullptr) {
162 SoftBusFree(streamCb);
163 }
164 }
165
166 /**
167 * @tc.name: OnQosEvent001
168 * @tc.desc: OnQosEvent error.
169 * @tc.type: FUNC
170 * @tc.require:
171 */
172 HWTEST_F(ClientTransStreamTest, OnQosEvent001, TestSize.Level0)
173 {
174 QosTv *tvList = (QosTv*)SoftBusMalloc(sizeof(QosTv));
175 ASSERT_TRUE(tvList != nullptr);
176 (void)memset_s(tvList, sizeof(QosTv), 0, sizeof(QosTv));
177 int32_t channelId = 12;
178 int32_t eventId = 21;
179 int32_t tvCount = 3;
180
181 OnQosEvent(channelId, eventId, tvCount, tvList);
182
183 IClientSessionCallBack *cb = GetClientSessionCb();
184 int32_t ret = ClientTransUdpMgrInit(cb);
185 EXPECT_EQ(ret, SOFTBUS_OK);
186 OnQosEvent(channelId, eventId, tvCount, tvList);
187
188 ClientTransUdpMgrDeinit();
189 if (tvList != nullptr) {
190 SoftBusFree(tvList);
191 }
192 }
193
194 /**
195 * @tc.name: OnFrameStats001
196 * @tc.desc: OnFrameStats error.
197 * @tc.desc: OnRippleStats error.
198 * @tc.type: FUNC
199 * @tc.require:
200 */
201 HWTEST_F(ClientTransStreamTest, OnFrameStats001, TestSize.Level0)
202 {
203 StreamSendStats *dataStreamSendStats = (StreamSendStats*)SoftBusMalloc(sizeof(StreamSendStats));
204 ASSERT_TRUE(dataStreamSendStats != nullptr);
205 (void)memset_s(dataStreamSendStats, sizeof(StreamSendStats), 0, sizeof(StreamSendStats));
206 TrafficStats *dataTrafficStats = (TrafficStats*)SoftBusMalloc(sizeof(TrafficStats));
207 ASSERT_TRUE(dataTrafficStats != nullptr);
208 (void)memset_s(dataTrafficStats, sizeof(TrafficStats), 0, sizeof(TrafficStats));
209 UdpChannelMgrCb *streamCb = (UdpChannelMgrCb*)SoftBusMalloc(sizeof(UdpChannelMgrCb));
210 ASSERT_TRUE(streamCb != nullptr);
211 (void)memset_s(streamCb, sizeof(UdpChannelMgrCb), 0, sizeof(UdpChannelMgrCb));
212 int32_t channelId = 12;
213
214 OnFrameStats(channelId, dataStreamSendStats);
215 OnRippleStats(channelId, dataTrafficStats);
216
217 IClientSessionCallBack *cb = GetClientSessionCb();
218 int32_t ret = ClientTransUdpMgrInit(cb);
219 EXPECT_EQ(ret, SOFTBUS_OK);
220 RegisterStreamCb(streamCb);
221
222 OnFrameStats(channelId, dataStreamSendStats);
223 OnRippleStats(channelId, dataTrafficStats);
224
225 UnregisterStreamCb();
226 if (dataStreamSendStats != nullptr) {
227 SoftBusFree(dataStreamSendStats);
228 }
229 if (dataTrafficStats != nullptr) {
230 SoftBusFree(dataTrafficStats);
231 }
232 if (streamCb != nullptr) {
233 SoftBusFree(streamCb);
234 }
235 }
236
237 /**
238 * @tc.name: TransSendStream001
239 * @tc.desc: TransSendStream error.
240 * @tc.desc: OnRippleStats error.
241 * @tc.type: FUNC
242 * @tc.require:
243 */
244 HWTEST_F(ClientTransStreamTest, TransSendStream001, TestSize.Level0)
245 {
246 StreamData *dataStreamData = (StreamData*)SoftBusMalloc(sizeof(StreamData));
247 ASSERT_TRUE(dataStreamData != nullptr);
248 (void)memset_s(dataStreamData, sizeof(StreamData), 0, sizeof(StreamData));
249
250 StreamData *extStreamData = (StreamData*)SoftBusMalloc(sizeof(StreamData));
251 ASSERT_TRUE(extStreamData != nullptr);
252 (void)memset_s(extStreamData, sizeof(StreamData), 0, sizeof(StreamData));
253
254 StreamFrameInfo *paramStreamFrameInfo = (StreamFrameInfo*)SoftBusMalloc(sizeof(StreamFrameInfo));
255 ASSERT_TRUE(paramStreamFrameInfo != nullptr);
256 (void)memset_s(paramStreamFrameInfo, sizeof(StreamFrameInfo), 0, sizeof(StreamFrameInfo));
257
258 int32_t channelId = 12;
259 int32_t ret = TransSendStream(channelId, dataStreamData, extStreamData, paramStreamFrameInfo);
260 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
261
262 if (dataStreamData != nullptr) {
263 SoftBusFree(dataStreamData);
264 }
265 if (extStreamData != nullptr) {
266 SoftBusFree(extStreamData);
267 }
268 if (paramStreamFrameInfo != nullptr) {
269 SoftBusFree(paramStreamFrameInfo);
270 }
271 }
272
273 /**
274 * @tc.name: TransOnstreamChannelOpened001
275 * @tc.desc: Should return SOFTBUS_NO_INIT when given invalid parameters.
276 * @tc.desc: Should return SOFTBUS_INVALID_PARAM when given nullptr parameters.
277 * @tc.desc: OnRippleStats error.
278 * @tc.type: FUNC
279 * @tc.require:
280 */
281 HWTEST_F(ClientTransStreamTest, TransOnstreamChannelOpened001, TestSize.Level0)
282 {
283 int32_t ret = TransClientInit();
284 EXPECT_EQ(ret, SOFTBUS_OK);
285 ChannelInfo *channel = (ChannelInfo *)SoftBusCalloc(sizeof(ChannelInfo));
286 ASSERT_TRUE(channel != nullptr);
287
288 int32_t streamPort = 2;
289 ret = TransOnstreamChannelOpened(nullptr, &streamPort);
290
291 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
292 ret = TransOnstreamChannelOpened(channel, nullptr);
293
294 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
295 ret = TransOnstreamChannelOpened(nullptr, nullptr);
296
297 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
298
299 channel->streamType = INVALID;
300 ret = TransOnstreamChannelOpened(channel, &streamPort);
301 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
302
303 channel->streamType = VIDEO_SLICE_STREAM;
304 ret = TransOnstreamChannelOpened(channel, &streamPort);
305 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
306
307 channel->streamType = RAW_STREAM;
308 channel->isServer = false;
309 channel->channelId = -1;
310 ret = TransOnstreamChannelOpened(channel, &streamPort);
311 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
312
313 channel->isServer = true;
314 ret = TransOnstreamChannelOpened(channel, &streamPort);
315 EXPECT_EQ(SOFTBUS_NO_INIT, ret);
316
317 if (channel != nullptr) {
318 SoftBusFree(channel);
319 }
320 TransClientDeinit();
321 }
322
323 /**
324 * @tc.name: TransCloseStreamChannel001
325 * @tc.desc: TransCloseStreamChannel error.
326 * @tc.desc: OnRippleStats error.
327 * @tc.type: FUNC
328 * @tc.require:
329 */
330 HWTEST_F(ClientTransStreamTest, TransCloseStreamChannel001, TestSize.Level0)
331 {
332 int32_t channelId = -1;
333 int32_t ret = TransCloseStreamChannel(channelId);
334 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
335
336 channelId = 1;
337 ret = TransCloseStreamChannel(channelId);
338 EXPECT_EQ(SOFTBUS_TRANS_ADAPTOR_NOT_EXISTED, ret);
339
340 ret = OnStreamUdpChannelOpened(TEST_CHANNELID);
341 EXPECT_NE(SOFTBUS_OK, ret);
342
343 channelId = -1;
344 ret = TransSendStream(channelId, nullptr, nullptr, nullptr);
345 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
346
347 channelId = TEST_CHANNELID;
348 ret = TransSendStream(channelId, nullptr, nullptr, nullptr);
349 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
350
351 channelId = -1;
352 ret = TransSetStreamMultiLayer(channelId, nullptr);
353 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
354
355 channelId = TEST_CHANNELID;
356 ret = TransSetStreamMultiLayer(channelId, nullptr);
357 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
358 }
359
360 /**
361 * @tc.name: ClientTransStreamTest001
362 * @tc.desc: TransCloseStreamChannel error.
363 * @tc.desc: OnRippleStats error.
364 * @tc.type: FUNC
365 * @tc.require:
366 */
367 HWTEST_F(ClientTransStreamTest, ClientTransStreamTest001, TestSize.Level0)
368 {
369 RegisterStreamCb(&g_testUdpChannelCb);
370 OnQosEvent(TEST_CHANNELID, TEST_CHANNELID, TEST_CHANNELID, nullptr);
371 int32_t ret = OnStreamUdpChannelOpened(TEST_CHANNELID);
372 EXPECT_EQ(SOFTBUS_OK, ret);
373 UnregisterStreamCb();
374 }
375 } // OHOS
376