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_errcode.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(int channelId,int status)49 void ClientSetStatus(int channelId, int 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 NULL,
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_ERR, ret);
90 ret = CloseVtpStreamChannel(channelId, g_pkgName);
91 EXPECT_EQ(SOFTBUS_ERR, 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_ERR, ret);
105 ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
106 EXPECT_EQ(SOFTBUS_ERR, 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_ERR, 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_NE(SOFTBUS_ERR, ret);
135 ret = CloseVtpStreamChannel(channelId, g_pkgName);
136 EXPECT_EQ(SOFTBUS_ERR, ret);
137 }
138
139 /**
140 * @tc.name: CloseVtpStreamChannelTest001
141 * @tc.desc: CloseVtpStreamChannel error.
142 * @tc.type: FUNC
143 * @tc.require:
144 */
145 HWTEST_F(ClientTransUdpStreamInterfaceTest, CloseVtpStreamChannelTest001, TestSize.Level0)
146 {
147 int32_t channelId = 1;
148 int32_t ret = CloseVtpStreamChannel(channelId, g_pkgName);
149 EXPECT_EQ(SOFTBUS_ERR, ret);
150 }
151
152 /**
153 * @tc.name: SendVtpStreamTest001
154 * @tc.desc: SendVtpStreamTest error.
155 * @tc.type: FUNC
156 * @tc.require:
157 */
158 HWTEST_F(ClientTransUdpStreamInterfaceTest, SendVtpStreamTest001, TestSize.Level0)
159 {
160 int32_t channelId = 1;
161 StreamData streamData = {
162 (char *)"diudiudiu\0",
163 CLIENT_STREAM_DATA_LENGTH,
164 };
165 const StreamData extData = {0};
166 const StreamFrameInfo frameInfo = {0};
167 int ret = SendVtpStream(channelId, nullptr, &extData, &frameInfo);
168 EXPECT_EQ(SOFTBUS_ERR, ret);
169
170 ret = SendVtpStream(channelId, &streamData, &extData, &frameInfo);
171 EXPECT_EQ(SOFTBUS_ERR, ret);
172 }
173
174 /**
175 * @tc.name: SendVtpStreamTest002
176 * @tc.desc: SendVtpStreamTest error.
177 * @tc.type: FUNC
178 * @tc.require:
179 */
180 HWTEST_F(ClientTransUdpStreamInterfaceTest, SendVtpStreamTest002, TestSize.Level0)
181 {
182 int32_t channelId = 1;
183 StreamData streamData = {
184 (char *)"diudiudiu\0",
185 CLIENT_STREAM_DATA_LENGTH,
186 };
187 const StreamFrameInfo frameInfo = {};
188 int32_t ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
189 EXPECT_NE(SOFTBUS_ERR, ret);
190 ret = SendVtpStream(channelId, &streamData, NULL, &frameInfo);
191 EXPECT_EQ(SOFTBUS_ERR, ret);
192 CloseVtpStreamChannel(channelId, g_pkgName);
193
194 g_serverParam1.type = INVALID;
195 ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
196 EXPECT_NE(SOFTBUS_ERR, ret);
197 ret = SendVtpStream(channelId, &streamData, NULL, &frameInfo);
198 EXPECT_EQ(SOFTBUS_ERR, ret);
199 CloseVtpStreamChannel(channelId, g_pkgName);
200
201 g_serverParam1.type = COMMON_VIDEO_STREAM;
202 ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
203 EXPECT_NE(SOFTBUS_ERR, ret);
204 ret = SendVtpStream(channelId, &streamData, NULL, &frameInfo);
205 EXPECT_EQ(SOFTBUS_ERR, ret);
206 CloseVtpStreamChannel(channelId, g_pkgName);
207 }
208
209 /**
210 * @tc.name: SendVtpStreamTest003
211 * @tc.desc: SendVtpStreamTest error.
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(ClientTransUdpStreamInterfaceTest, SendVtpStreamTest003, TestSize.Level0)
216 {
217 int32_t channelId = 1;
218 StreamData streamData1 = {
219 (char *)"",
220 -1,
221 };
222 StreamData streamData2 = {
223 (char *)"diudiudiu\0",
224 CLIENT_STREAM_DATA_LENGTH,
225 };
226 const StreamFrameInfo frameInfo = {};
227 g_serverParam1.type = COMMON_VIDEO_STREAM;
228
229 int32_t ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
230 EXPECT_NE(SOFTBUS_ERR, ret);
231 ret = SendVtpStream(channelId, &streamData1, NULL, &frameInfo);
232 EXPECT_EQ(SOFTBUS_TRANS_INVALID_DATA_LENGTH, ret);
233 CloseVtpStreamChannel(channelId, g_pkgName);
234
235 ret = StartVtpStreamChannelServer(channelId, &g_serverParam1, &g_callback);
236 EXPECT_NE(SOFTBUS_ERR, ret);
237 ret = SendVtpStream(channelId, &streamData2, &streamData2, &frameInfo);
238 EXPECT_EQ(SOFTBUS_ERR, ret);
239 CloseVtpStreamChannel(channelId, g_pkgName);
240 }
241 }