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
18 #include "session.h"
19 #include "softbus_error_code.h"
20 #include "softbus_def.h"
21 #include "client_trans_udp_stream_interface.h"
22
23 #define CLIENT_STREAM_DATA_LENGTH 10
24 #define CLIENT_LOOP_ROUND 10
25 #define CLIENT_LONG_SLEEP 3
26
27 using namespace testing::ext;
28 namespace OHOS {
29 class ClientTransUdpStreamInterfaceTest : public testing::Test {
30 public:
ClientTransUdpStreamInterfaceTest()31 ClientTransUdpStreamInterfaceTest()
32 {}
~ClientTransUdpStreamInterfaceTest()33 ~ClientTransUdpStreamInterfaceTest()
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 ClientTransUdpStreamInterfaceTest::SetUpTestCase(void)
44 {}
45
TearDownTestCase(void)46 void ClientTransUdpStreamInterfaceTest::TearDownTestCase(void)
47 {}
48
ClientSetStatus(int32_t channelId,int32_t status)49 void ClientSetStatus(int32_t channelId, int32_t status)
50 {
51 std::cout << "[server]:channelID:" << channelId << ", status:" << status << std::endl;
52 }
53
54 static IStreamListener g_callback = {
55 .OnStatusChange = ClientSetStatus,
56 };
57 static char g_pkgName[] = "test";
58 static char g_ip[] = "127.0.0.1";
59 static VtpStreamOpenParam g_serverParam1 = {
60 g_pkgName,
61 g_ip,
62 nullptr,
63 -1,
64 RAW_STREAM,
65 (uint8_t*)"abcdef@ghabcdefghabcdefghfgdabc",
66 SESSION_KEY_LENGTH,
67 };
68
69 static VtpStreamOpenParam g_clientParam1 = {
70 g_pkgName,
71 g_ip,
72 g_ip,
73 1,
74 RAW_STREAM,
75 (uint8_t*)"abcdef@ghabcdefghabcdefghfgdabc",
76 SESSION_KEY_LENGTH,
77 };
78
79 /**
80 * @tc.name: StartVtpStreamChannelServerTest001
81 * @tc.desc: StartVtpStreamChannelServer error.
82 * @tc.type: FUNC
83 * @tc.require:
84 */
85 HWTEST_F(ClientTransUdpStreamInterfaceTest, StartVtpStreamChannelServerTest001, TestSize.Level0)
86 {
87 int32_t channelId = -1;
88 int32_t ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
89 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
90 ret = CloseVtpStreamChannel(channelId, g_pkgName);
91 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
92 }
93
94 /**
95 * @tc.name: StartVtpStreamChannelServerTest002
96 * @tc.desc: StartVtpStreamChannelServer error.
97 * @tc.type: FUNC
98 * @tc.require:
99 */
100 HWTEST_F(ClientTransUdpStreamInterfaceTest, StartVtpStreamChannelServerTest002, TestSize.Level0)
101 {
102 int32_t channelId = 1;
103 int32_t ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
104 EXPECT_NE(SOFTBUS_TRANS_ADAPTOR_ALREADY_EXISTED, ret);
105 ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
106 EXPECT_EQ(SOFTBUS_TRANS_ADAPTOR_ALREADY_EXISTED, ret);
107 CloseVtpStreamChannel(channelId, g_pkgName);
108 }
109
110 /**
111 * @tc.name: StartVtpStreamChannelClientTest001
112 * @tc.desc: StartVtpStreamChannelClient error.
113 * @tc.type: FUNC
114 * @tc.require:
115 */
116 HWTEST_F(ClientTransUdpStreamInterfaceTest, StartVtpStreamChannelClientTest001, TestSize.Level0)
117 {
118 int32_t channelId = -1;
119 int32_t ret = StartVtpStreamChannelClient(channelId, &g_clientParam1, &g_callback);
120 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
121 CloseVtpStreamChannel(channelId, g_pkgName);
122 }
123
124 /**
125 * @tc.name: StartVtpStreamChannelClientTest002
126 * @tc.desc: StartVtpStreamChannelClient success CloseVtpStreamChannel error.
127 * @tc.type: FUNC
128 * @tc.require:
129 */
130 HWTEST_F(ClientTransUdpStreamInterfaceTest, StartVtpStreamChannelClientTest002, TestSize.Level0)
131 {
132 int32_t channelId = 1;
133 int32_t ret = StartVtpStreamChannelClient(channelId, &g_clientParam1, &g_callback);
134 EXPECT_EQ(SOFTBUS_OK, ret);
135 ret = CloseVtpStreamChannel(channelId, g_pkgName);
136 EXPECT_EQ(SOFTBUS_TRANS_ADAPTOR_NOT_EXISTED, ret);
137 }
138
139 /**
140 * @tc.name: StartVtpStreamChannelClientTest003
141 * @tc.desc: StartVtpStreamChannelClient error.
142 * @tc.type: FUNC
143 * @tc.require:
144 */
145 HWTEST_F(ClientTransUdpStreamInterfaceTest, StartVtpStreamChannelClientTest003, TestSize.Level0)
146 {
147 int32_t channelId = 1;
148 VtpStreamOpenParam clientParam = {
149 g_pkgName,
150 g_ip,
151 g_ip,
152 1,
153 RAW_STREAM,
154 (uint8_t *)"abcdef@ghabcdefghabcdefghfgdabc",
155 SESSION_KEY_LENGTH,
156 };
157 int32_t ret = StartVtpStreamChannelClient(channelId, &clientParam, nullptr);
158 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
159 }
160
161 /**
162 * @tc.name: StartVtpStreamChannelClientTest004
163 * @tc.desc: StartVtpStreamChannelClient error.
164 * @tc.type: FUNC
165 * @tc.require:
166 */
167 HWTEST_F(ClientTransUdpStreamInterfaceTest, StartVtpStreamChannelClientTest004, TestSize.Level0)
168 {
169 int32_t channelId = 1;
170 int32_t ret = StartVtpStreamChannelClient(channelId, nullptr, &g_callback);
171 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
172 VtpStreamOpenParam clientParam = {
173 nullptr,
174 g_ip,
175 g_ip,
176 1,
177 RAW_STREAM,
178 (uint8_t *)"abcdef@ghabcdefghabcdefghfgdabc",
179 SESSION_KEY_LENGTH,
180 };
181 ret = StartVtpStreamChannelClient(channelId, &clientParam, &g_callback);
182 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
183 }
184
185 /**
186 * @tc.name: CloseVtpStreamChannelTest001
187 * @tc.desc: CloseVtpStreamChannel error.
188 * @tc.type: FUNC
189 * @tc.require:
190 */
191 HWTEST_F(ClientTransUdpStreamInterfaceTest, CloseVtpStreamChannelTest001, TestSize.Level0)
192 {
193 int32_t channelId = 1;
194 int32_t ret = CloseVtpStreamChannel(channelId, g_pkgName);
195 EXPECT_EQ(SOFTBUS_TRANS_ADAPTOR_NOT_EXISTED, ret);
196 }
197
198 /**
199 * @tc.name: SendVtpStreamTest001
200 * @tc.desc: SendVtpStreamTest error.
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(ClientTransUdpStreamInterfaceTest, SendVtpStreamTest001, TestSize.Level0)
205 {
206 int32_t channelId = 1;
207 StreamData streamData = {
208 (char *)"diudiudiu\0",
209 CLIENT_STREAM_DATA_LENGTH,
210 };
211 const StreamData extData = {0};
212 const StreamFrameInfo frameInfo = {0};
213 int32_t ret = SendVtpStream(channelId, nullptr, &extData, &frameInfo);
214 EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
215
216 ret = SendVtpStream(channelId, &streamData, &extData, &frameInfo);
217 EXPECT_EQ(SOFTBUS_TRANS_ADAPTOR_NOT_EXISTED, ret);
218 }
219
220 /**
221 * @tc.name: SendVtpStreamTest002
222 * @tc.desc: SendVtpStreamTest error.
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(ClientTransUdpStreamInterfaceTest, SendVtpStreamTest002, TestSize.Level0)
227 {
228 int32_t channelId = 1;
229 StreamData streamData = {
230 (char *)"diudiudiu\0",
231 CLIENT_STREAM_DATA_LENGTH,
232 };
233 const StreamFrameInfo frameInfo = {};
234 int32_t ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
235 EXPECT_NE(SOFTBUS_OK, ret);
236 ret = SendVtpStream(channelId, &streamData, nullptr, &frameInfo);
237 EXPECT_EQ(SOFTBUS_TRANS_MAKE_STREAM_FAILED, ret);
238 CloseVtpStreamChannel(channelId, g_pkgName);
239
240 g_serverParam1.type = INVALID;
241 ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
242 EXPECT_NE(SOFTBUS_OK, ret);
243 ret = SendVtpStream(channelId, &streamData, nullptr, &frameInfo);
244 EXPECT_EQ(SOFTBUS_FUNC_NOT_SUPPORT, ret);
245 CloseVtpStreamChannel(channelId, g_pkgName);
246
247 g_serverParam1.type = COMMON_VIDEO_STREAM;
248 ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
249 EXPECT_NE(SOFTBUS_OK, ret);
250 ret = SendVtpStream(channelId, &streamData, nullptr, &frameInfo);
251 EXPECT_EQ(SOFTBUS_TRANS_MAKE_STREAM_FAILED, ret);
252 CloseVtpStreamChannel(channelId, g_pkgName);
253 }
254
255 /**
256 * @tc.name: SendVtpStreamTest003
257 * @tc.desc: SendVtpStreamTest error.
258 * @tc.type: FUNC
259 * @tc.require:
260 */
261 HWTEST_F(ClientTransUdpStreamInterfaceTest, SendVtpStreamTest003, TestSize.Level0)
262 {
263 int32_t channelId = 1;
264 StreamData streamData1 = {
265 (char *)"",
266 -1,
267 };
268 StreamData streamData2 = {
269 (char *)"diudiudiu\0",
270 CLIENT_STREAM_DATA_LENGTH,
271 };
272 const StreamFrameInfo frameInfo = {};
273 g_serverParam1.type = COMMON_VIDEO_STREAM;
274
275 int32_t ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
276 EXPECT_NE(SOFTBUS_OK, ret);
277 ret = SendVtpStream(channelId, &streamData1, nullptr, &frameInfo);
278 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
279 CloseVtpStreamChannel(channelId, g_pkgName);
280
281 ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
282 EXPECT_NE(SOFTBUS_OK, ret);
283 ret = SendVtpStream(channelId, &streamData2, &streamData2, &frameInfo);
284 EXPECT_EQ(SOFTBUS_TRANS_MAKE_STREAM_FAILED, ret);
285 CloseVtpStreamChannel(channelId, g_pkgName);
286 }
287
288 /**
289 * @tc.name: SetVtpStreamMultiLayerOpt001
290 * @tc.desc: SetVtpStreamMultiLayerOpt invalid channelId test.
291 * @tc.type: FUNC
292 * @tc.require:
293 */
294 HWTEST_F(ClientTransUdpStreamInterfaceTest, SetVtpStreamMultiLayerOpt001, TestSize.Level0)
295 {
296 int32_t channelId = 1;
297 StreamData streamData1 = {
298 (char *)"",
299 -1,
300 };
301 int32_t ret = SetVtpStreamMultiLayerOpt(channelId, &streamData1);
302 EXPECT_EQ(SOFTBUS_TRANS_ADAPTOR_NOT_EXISTED, ret);
303 }
304 }