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