1 /*
2 * Copyright (c) 2022 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 "softbus_adapter_mem.h"
20 #include "trans_server_proxy.h"
21 #include "client_trans_udp_manager.h"
22 #include "client_trans_stream.h"
23 #include "client_trans_stream.c"
24
25 using namespace testing::ext;
26 namespace OHOS {
27 class ClientTransStreamTest : public testing::Test {
28 public:
ClientTransStreamTest()29 ClientTransStreamTest()
30 {}
~ClientTransStreamTest()31 ~ClientTransStreamTest()
32 {}
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
SetUp()35 void SetUp() override
36 {}
TearDown()37 void TearDown() override
38 {}
39 };
40
SetUpTestCase(void)41 void ClientTransStreamTest::SetUpTestCase(void)
42 {}
43
TearDownTestCase(void)44 void ClientTransStreamTest::TearDownTestCase(void)
45 {}
46
47 /**
48 * @tc.name: RegisterStreamCb001
49 * @tc.desc: RegisterStreamCb error.
50 * @tc.desc: UnregisterStreamCb error.
51 * @tc.desc: SetStreamChannelStatus error.
52 * @tc.type: FUNC
53 * @tc.require:
54 */
55 HWTEST_F(ClientTransStreamTest, RegisterStreamCb001, TestSize.Level0)
56 {
57 RegisterStreamCb(NULL);
58 UnregisterStreamCb();
59 int32_t channelId = 12;
60 int32_t status = 2;
61 SetStreamChannelStatus(channelId, status);
62
63 UdpChannelMgrCb *streamCb = (UdpChannelMgrCb*)SoftBusMalloc(sizeof(UdpChannelMgrCb));
64 ASSERT_TRUE(streamCb != nullptr);
65 (void)memset_s(streamCb, sizeof(UdpChannelMgrCb), 0, sizeof(UdpChannelMgrCb));
66
67 IClientSessionCallBack *cb = GetClientSessionCb();
68 int32_t ret = ClientTransUdpMgrInit(cb);
69 ASSERT_TRUE(ret == SOFTBUS_OK);
70 RegisterStreamCb(streamCb);
71 SetStreamChannelStatus(channelId, status);
72
73 status = STREAM_CONNECTED;
74 SetStreamChannelStatus(channelId, status);
75
76 status = STREAM_CLOSED;
77 SetStreamChannelStatus(channelId, status);
78
79 status = STREAM_INIT;
80 SetStreamChannelStatus(channelId, status);
81
82 status = STREAM_OPENING;
83 SetStreamChannelStatus(channelId, status);
84
85 status = STREAM_CONNECTING;
86 SetStreamChannelStatus(channelId, status);
87
88 status = STREAM_CLOSING;
89 SetStreamChannelStatus(channelId, status);
90
91 status = STREAM_OPENED;
92 SetStreamChannelStatus(channelId, status);
93 UnregisterStreamCb();
94
95 if (streamCb != nullptr) {
96 SoftBusFree(streamCb);
97 }
98 }
99
100 /**
101 * @tc.name: OnQosEvent001
102 * @tc.desc: OnQosEvent error.
103 * @tc.type: FUNC
104 * @tc.require:
105 */
106 HWTEST_F(ClientTransStreamTest, OnQosEvent001, TestSize.Level0)
107 {
108 QosTv *tvList = (QosTv*)SoftBusMalloc(sizeof(QosTv));
109 ASSERT_TRUE(tvList != nullptr);
110 (void)memset_s(tvList, sizeof(QosTv), 0, sizeof(QosTv));
111 int channelId = 12;
112 int eventId = 21;
113 int tvCount = 3;
114
115 OnQosEvent(channelId, eventId, tvCount, tvList);
116
117 IClientSessionCallBack *cb = GetClientSessionCb();
118 int32_t ret = ClientTransUdpMgrInit(cb);
119 ASSERT_TRUE(ret == SOFTBUS_OK);
120 OnQosEvent(channelId, eventId, tvCount, tvList);
121
122 ClientTransUdpMgrDeinit();
123 if (tvList != nullptr) {
124 SoftBusFree(tvList);
125 }
126 }
127
128 /**
129 * @tc.name: OnFrameStats001
130 * @tc.desc: OnFrameStats error.
131 * @tc.desc: OnRippleStats error.
132 * @tc.type: FUNC
133 * @tc.require:
134 */
135 HWTEST_F(ClientTransStreamTest, OnFrameStats001, TestSize.Level0)
136 {
137 StreamSendStats *dataStreamSendStats = (StreamSendStats*)SoftBusMalloc(sizeof(StreamSendStats));
138 ASSERT_TRUE(dataStreamSendStats != nullptr);
139 (void)memset_s(dataStreamSendStats, sizeof(StreamSendStats), 0, sizeof(StreamSendStats));
140 TrafficStats *dataTrafficStats = (TrafficStats*)SoftBusMalloc(sizeof(TrafficStats));
141 ASSERT_TRUE(dataTrafficStats != nullptr);
142 (void)memset_s(dataTrafficStats, sizeof(TrafficStats), 0, sizeof(TrafficStats));
143 UdpChannelMgrCb *streamCb = (UdpChannelMgrCb*)SoftBusMalloc(sizeof(UdpChannelMgrCb));
144 ASSERT_TRUE(streamCb != nullptr);
145 (void)memset_s(streamCb, sizeof(UdpChannelMgrCb), 0, sizeof(UdpChannelMgrCb));
146 int channelId = 12;
147
148 OnFrameStats(channelId, dataStreamSendStats);
149 OnRippleStats(channelId, dataTrafficStats);
150
151 IClientSessionCallBack *cb = GetClientSessionCb();
152 int32_t ret = ClientTransUdpMgrInit(cb);
153 ASSERT_TRUE(ret == SOFTBUS_OK);
154 RegisterStreamCb(streamCb);
155
156 OnFrameStats(channelId, dataStreamSendStats);
157 OnRippleStats(channelId, dataTrafficStats);
158
159 UnregisterStreamCb();
160 if (dataStreamSendStats != nullptr) {
161 SoftBusFree(dataStreamSendStats);
162 }
163 if (dataTrafficStats != nullptr) {
164 SoftBusFree(dataTrafficStats);
165 }
166 if (streamCb != nullptr) {
167 SoftBusFree(streamCb);
168 }
169 }
170
171 /**
172 * @tc.name: TransSendStream001
173 * @tc.desc: TransSendStream error.
174 * @tc.desc: OnRippleStats error.
175 * @tc.type: FUNC
176 * @tc.require:
177 */
178 HWTEST_F(ClientTransStreamTest, TransSendStream001, TestSize.Level0)
179 {
180 StreamData *dataStreamData = (StreamData*)SoftBusMalloc(sizeof(StreamData));
181 ASSERT_TRUE(dataStreamData != nullptr);
182 (void)memset_s(dataStreamData, sizeof(StreamData), 0, sizeof(StreamData));
183
184 StreamData *extStreamData = (StreamData*)SoftBusMalloc(sizeof(StreamData));
185 ASSERT_TRUE(extStreamData != nullptr);
186 (void)memset_s(extStreamData, sizeof(StreamData), 0, sizeof(StreamData));
187
188 StreamFrameInfo *paramStreamFrameInfo = (StreamFrameInfo*)SoftBusMalloc(sizeof(StreamFrameInfo));
189 ASSERT_TRUE(paramStreamFrameInfo != nullptr);
190 (void)memset_s(paramStreamFrameInfo, sizeof(StreamFrameInfo), 0, sizeof(StreamFrameInfo));
191
192 int32_t channelId = 12;
193 int ret = TransSendStream(channelId, dataStreamData, extStreamData, paramStreamFrameInfo);
194 EXPECT_EQ(SOFTBUS_ERR, ret);
195
196 if (dataStreamData != nullptr) {
197 SoftBusFree(dataStreamData);
198 }
199 if (extStreamData != nullptr) {
200 SoftBusFree(extStreamData);
201 }
202 if (paramStreamFrameInfo != nullptr) {
203 SoftBusFree(paramStreamFrameInfo);
204 }
205 }
206
207 /**
208 * @tc.name: TransOnstreamChannelOpened001
209 * @tc.desc: TransOnstreamChannelOpened error.
210 * @tc.desc: OnRippleStats error.
211 * @tc.type: FUNC
212 * @tc.require:
213 */
214 HWTEST_F(ClientTransStreamTest, TransOnstreamChannelOpened001, TestSize.Level0)
215 {
216 ChannelInfo *channel = (ChannelInfo*)SoftBusMalloc(sizeof(ChannelInfo));
217 ASSERT_TRUE(channel != nullptr);
218 (void)memset_s(channel, sizeof(ChannelInfo), 0, sizeof(ChannelInfo));
219
220 int32_t streamPort = 2;
221 int32_t ret = TransOnstreamChannelOpened(NULL, &streamPort);
222
223 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
224 ret = TransOnstreamChannelOpened(channel, NULL);
225
226 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
227 ret = TransOnstreamChannelOpened(NULL, NULL);
228
229 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
230
231 channel->streamType = INVALID;
232 ret = TransOnstreamChannelOpened(channel, &streamPort);
233 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
234
235 channel->streamType = VIDEO_SLICE_STREAM;
236 ret = TransOnstreamChannelOpened(channel, &streamPort);
237 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
238
239 channel->streamType = RAW_STREAM;
240 channel->isServer = false;
241 channel->channelId = -1;
242 ret = TransOnstreamChannelOpened(channel, &streamPort);
243 EXPECT_EQ(SOFTBUS_TRANS_UDP_START_STREAM_CLIENT_FAILED, ret);
244
245 channel->isServer = true;
246 ret = TransOnstreamChannelOpened(channel, &streamPort);
247 EXPECT_EQ(SOFTBUS_TRANS_UDP_START_STREAM_SERVER_FAILED, ret);
248
249 if (channel != nullptr) {
250 SoftBusFree(channel);
251 }
252 }
253
254 /**
255 * @tc.name: TransCloseStreamChannel001
256 * @tc.desc: TransCloseStreamChannel error.
257 * @tc.desc: OnRippleStats error.
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(ClientTransStreamTest, TransCloseStreamChannel001, TestSize.Level0)
262 {
263 int32_t channelId = -1;
264 int ret = TransCloseStreamChannel(channelId);
265 EXPECT_EQ(SOFTBUS_ERR, ret);
266
267 channelId = 1;
268 ret = TransCloseStreamChannel(channelId);
269 EXPECT_EQ(SOFTBUS_ERR, ret);
270 }
271 } // OHOS
272