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