1 /*
2 * Copyright (c) 2021-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
16 #include <cstdio>
17 #include <gtest/gtest.h>
18 #include <map>
19 #include <vector>
20 #include "securec.h"
21 #include "session.h"
22 #include "softbus_bus_center.h"
23 #include "softbus_errcode.h"
24
25 #define TEST_TMP_BUF "tmpBuf"
26 #define TEST_TMP_BUF_LEN 10
27 #define STR_LEN 100000
28 #define TMP_NUM 97
29
30 char g_tmpBuf[] = "tmpBuf";
31
32 using namespace testing::ext;
33 namespace OHOS {
34 static const char *UDP_TEST_PKG_NAME = "com.plrdtest.dsoftbus.client";
35 static const char *UDP_TEST_SESSION_NAME = "com.plrdtest.dsoftbus.JtSendRawStream_0";
36 std::map<int, int> g_qosEventCount;
37 std::map<int, uint64_t> g_timeDiff;
38 std::map<int, uint64_t> g_lastTimeStamp;
39 std::map<int, std::vector<uint64_t>> g_speedStat;
40
41 class TransQosStatClientTest : public testing::Test {
42 public:
TransQosStatClientTest()43 TransQosStatClientTest()
44 {}
~TransQosStatClientTest()45 ~TransQosStatClientTest()
46 {}
47 static void SetUpTestCase(void);
48 static void TearDownTestCase(void);
SetUp()49 void SetUp() override
50 {
51 g_timeDiff.clear();
52 g_speedStat.clear();
53 g_lastTimeStamp.clear();
54 g_qosEventCount.clear();
55 }
TearDown()56 void TearDown() override
57 {
58 g_timeDiff.clear();
59 g_speedStat.clear();
60 g_lastTimeStamp.clear();
61 g_qosEventCount.clear();
62 }
63 };
64
SetUpTestCase(void)65 void TransQosStatClientTest::SetUpTestCase(void)
66 {
67 g_timeDiff.clear();
68 g_speedStat.clear();
69 g_lastTimeStamp.clear();
70 g_qosEventCount.clear();
71 }
72
TearDownTestCase(void)73 void TransQosStatClientTest::TearDownTestCase(void)
74 {
75 g_timeDiff.clear();
76 g_speedStat.clear();
77 g_lastTimeStamp.clear();
78 g_qosEventCount.clear();
79 }
80
CalSendBits(const std::vector<uint64_t> & rateList)81 static uint64_t CalSendBits(const std::vector<uint64_t> &rateList)
82 {
83 if (rateList.size() > 0) {
84 return rateList[rateList.size() - 1];
85 }
86 return 0;
87 }
88
89 /**
90 * @tc.name: TransQosStatClientTest001
91 * @tc.desc: null sessionListener
92 * @tc.type: FUNC
93 * @tc.require:
94 */
95 HWTEST_F(TransQosStatClientTest, QosStatClientTest001, TestSize.Level0)
96 {
97 int32_t ret = CreateSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME, nullptr);
98 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
99 }
100
101 /**
102 * @tc.name: TransQosStatClientTest002
103 * @tc.desc: sessionListener without onQosEvent
104 * @tc.type: FUNC
105 * @tc.require:
106 */
107 HWTEST_F(TransQosStatClientTest, QosStatClientTest002, TestSize.Level0)
108 {
109 int32_t sendTimes = 10;
110 ISessionListener *g_noQosCb = nullptr;
111 int32_t ret = CreateSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME, g_noQosCb);
112 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
113 NodeBasicInfo *info;
114 int32_t infoNum;
115 ret = GetAllNodeDeviceInfo(UDP_TEST_PKG_NAME, &info, &infoNum);
116 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
117 SessionAttribute attr = {0};
118 attr.dataType = TYPE_STREAM;
119 attr.attr.streamAttr.streamType = RAW_STREAM;
120 int32_t sessionId = OpenSession(UDP_TEST_SESSION_NAME, UDP_TEST_SESSION_NAME,
121 info[0].networkId, "0", &attr);
122 EXPECT_NE(-1, sessionId);
123 sleep(2);
124
125 char sendStringData[STR_LEN];
126 memset_s(sendStringData, sizeof(sendStringData), TMP_NUM, sizeof(sendStringData));
127 StreamData d1 = {
128 sendStringData,
129 STR_LEN,
130 };
131 StreamData d2 = {
132 g_tmpBuf,
133 TEST_TMP_BUF_LEN,
134 };
135 StreamFrameInfo tmpf = {};
136 for (int32_t times = 0; times < sendTimes; times++) {
137 ret = SendStream(sessionId, &d1, &d2, &tmpf);
138 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
139 sleep(1);
140 }
141 EXPECT_EQ(g_qosEventCount[sessionId], 0);
142 CloseSession(sessionId);
143 sleep(1);
144 ret = RemoveSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME);
145 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
146 }
147
148 /**
149 * @tc.name: TransQosStatClientTest003
150 * @tc.desc: sessionListener with onQosEvent
151 * @tc.type: FUNC
152 * @tc.require:
153 */
154 HWTEST_F(TransQosStatClientTest, QosStatClientTest003, TestSize.Level0)
155 {
156 int32_t sendTimes = 10;
157 ISessionListener *g_hasQosCb = nullptr;
158 int32_t ret = CreateSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME, g_hasQosCb);
159 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
160 NodeBasicInfo *info;
161 int32_t infoNum;
162 ret = GetAllNodeDeviceInfo(UDP_TEST_PKG_NAME, &info, &infoNum);
163 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
164 SessionAttribute attr = {0};
165 attr.dataType = TYPE_STREAM;
166 attr.attr.streamAttr.streamType = RAW_STREAM;
167 int32_t sessionId = OpenSession(UDP_TEST_SESSION_NAME, UDP_TEST_SESSION_NAME,
168 info[0].networkId, "0", &attr);
169 EXPECT_NE(-1, sessionId);
170 sleep(2);
171
172 char sendStringData[STR_LEN];
173 memset_s(sendStringData, sizeof(sendStringData), TMP_NUM, sizeof(sendStringData));
174 StreamData d1 = {
175 sendStringData,
176 STR_LEN,
177 };
178 StreamData d2 = {
179 g_tmpBuf,
180 TEST_TMP_BUF_LEN,
181 };
182 StreamFrameInfo tmpf = {};
183 for (int32_t times = 0; times < sendTimes; times++) {
184 ret = SendStream(sessionId, &d1, &d2, &tmpf);
185 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
186 sleep(1);
187 }
188 EXPECT_EQ(g_qosEventCount[sessionId], 0);
189 CloseSession(sessionId);
190 sleep(1);
191 EXPECT_LE(g_timeDiff[sessionId], 100);
192 ret = RemoveSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME);
193 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
194 }
195
196 /**
197 * @tc.name: TransQosStatClientTest004
198 * @tc.desc: sessionListener with onQosEvent multichannel
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(TransQosStatClientTest, QosStatClientTest004, TestSize.Level0)
203 {
204 int32_t sendTimes = 10;
205 int32_t numChannels = 5;
206 ISessionListener *g_hasQosCb = nullptr;
207 int32_t ret = CreateSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME, g_hasQosCb);
208 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
209 NodeBasicInfo *info;
210 int32_t infoNum;
211 ret = GetAllNodeDeviceInfo(UDP_TEST_PKG_NAME, &info, &infoNum);
212 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
213 SessionAttribute attr = {0};
214 attr.dataType = TYPE_STREAM;
215 attr.attr.streamAttr.streamType = RAW_STREAM;
216 for (int32_t index = 0; index < numChannels; index++) {
217 std::string groupId = std::to_string(index);
218 int32_t sessionId = OpenSession(UDP_TEST_SESSION_NAME, UDP_TEST_SESSION_NAME,
219 info[0].networkId, groupId.c_str(), &attr);
220 EXPECT_NE(-1, sessionId);
221 }
222 sleep(2);
223 char sendStringData[STR_LEN];
224 memset_s(sendStringData, sizeof(sendStringData), TMP_NUM, sizeof(sendStringData));
225 StreamData d1 = { sendStringData, STR_LEN };
226 StreamData d2 = { g_tmpBuf, TEST_TMP_BUF_LEN };
227 StreamFrameInfo tmpf = {};
228 std::map<int32_t, int32_t>::iterator iter;
229 for (int32_t times = 0; times < sendTimes; times++) {
230 iter = g_qosEventCount.begin();
231 while (iter != g_qosEventCount.end()) {
232 ret = SendStream(iter->first, &d1, &d2, &tmpf);
233 EXPECT_EQ(ret, SOFTBUS_OK);
234 iter++;
235 }
236 sleep(1);
237 }
238 iter = g_qosEventCount.begin();
239 while (iter != g_qosEventCount.end()) {
240 EXPECT_GT(iter->second, 0);
241 CloseSession(iter->second);
242 iter++;
243 }
244 sleep(1);
245 ret = RemoveSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME);
246 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
247 }
248
249 /**
250 * @tc.name: TransQosStatClientTest005
251 * @tc.desc: sessionListener with onQosEvent speedUp
252 * @tc.type: FUNC
253 * @tc.require:
254 */
255 HWTEST_F(TransQosStatClientTest, QosStatClientTest005, TestSize.Level0)
256 {
257 int32_t sendTimes = 10;
258 uint64_t bigSpeed = 0;
259 uint64_t smallSpeed = 0;
260 ISessionListener *g_hasQosCb = nullptr;
261 int32_t ret = CreateSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME, g_hasQosCb);
262 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
263 NodeBasicInfo *info;
264 int32_t infoNum;
265 ret = GetAllNodeDeviceInfo(UDP_TEST_PKG_NAME, &info, &infoNum);
266 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
267 SessionAttribute attr = {0};
268 attr.dataType = TYPE_STREAM;
269 attr.attr.streamAttr.streamType = RAW_STREAM;
270 int32_t sessionId = OpenSession(UDP_TEST_SESSION_NAME, UDP_TEST_SESSION_NAME,
271 info[0].networkId, "0", &attr);
272 EXPECT_NE(-1, sessionId);
273 sleep(2);
274
275 // big speed
276 char sendStringData[STR_LEN];
277 memset_s(sendStringData, sizeof(sendStringData), TMP_NUM, sizeof(sendStringData));
278 StreamData d1 = {
279 sendStringData,
280 STR_LEN,
281 };
282 StreamData d2 = {
283 g_tmpBuf,
284 TEST_TMP_BUF_LEN,
285 };
286 StreamFrameInfo tmpf = {};
287 for (int32_t times = 0; times < sendTimes; times++) {
288 ret = SendStream(sessionId, &d1, &d2, &tmpf);
289 EXPECT_NE(ret, SOFTBUS_OK);
290 sleep(1);
291 }
292 bigSpeed = CalSendBits(g_speedStat[sessionId]);
293 g_speedStat[sessionId].clear();
294
295 // small speed
296 d1.bufLen = 1000;
297 for (int32_t times = 0; times < sendTimes; times++) {
298 ret = SendStream(sessionId, &d1, &d2, &tmpf);
299 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
300 sleep(1);
301 }
302 smallSpeed = CalSendBits(g_speedStat[sessionId]) - bigSpeed;
303 EXPECT_LE(smallSpeed, bigSpeed);
304 CloseSession(sessionId);
305 sleep(1);
306 ret = RemoveSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME);
307 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
308 }
309
310 /**
311 * @tc.name: TransQosStatClientTest006
312 * @tc.desc: sessionListener with onQosEvent speedDown
313 * @tc.type: FUNC
314 * @tc.require:
315 */
316 HWTEST_F(TransQosStatClientTest, QosStatClientTest006, TestSize.Level0)
317 {
318 int32_t sendTimes = 10;
319 uint64_t bigSpeed = 0;
320 uint64_t smallSpeed = 0;
321 ISessionListener *g_hasQosCb = nullptr;
322 int32_t ret = CreateSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME, g_hasQosCb);
323 EXPECT_EQ(ret, SOFTBUS_INVALID_PARAM);
324 NodeBasicInfo *info;
325 int32_t infoNum;
326 ret = GetAllNodeDeviceInfo(UDP_TEST_PKG_NAME, &info, &infoNum);
327 EXPECT_EQ(ret, SOFTBUS_NETWORK_NOT_INIT);
328 SessionAttribute attr = {0};
329 attr.dataType = TYPE_STREAM;
330 attr.attr.streamAttr.streamType = RAW_STREAM;
331 int32_t sessionId = OpenSession(UDP_TEST_SESSION_NAME, UDP_TEST_SESSION_NAME,
332 info[0].networkId, "0", &attr);
333 EXPECT_NE(-1, sessionId);
334 sleep(2);
335
336 // small speed
337 char sendStringData[STR_LEN];
338 memset_s(sendStringData, sizeof(sendStringData), TMP_NUM, sizeof(sendStringData));
339 StreamData d1 = {
340 sendStringData,
341 STR_LEN,
342 };
343 StreamData d2 = {
344 g_tmpBuf,
345 TEST_TMP_BUF_LEN,
346 };
347 StreamFrameInfo tmpf = {};
348 for (int32_t times = 0; times < sendTimes; times++) {
349 ret = SendStream(sessionId, &d1, &d2, &tmpf);
350 EXPECT_EQ(ret, SOFTBUS_TRANS_SESSION_INFO_NOT_FOUND);
351 sleep(1);
352 }
353 bigSpeed = CalSendBits(g_speedStat[sessionId]);
354 g_speedStat[sessionId].clear();
355
356 // small speed
357 d1.bufLen = 1000;
358 for (int32_t times = 0; times < sendTimes; times++) {
359 ret = SendStream(sessionId, &d1, &d2, &tmpf);
360 EXPECT_NE(ret, SOFTBUS_OK);
361 sleep(1);
362 }
363 smallSpeed = CalSendBits(g_speedStat[sessionId]) - bigSpeed;
364 EXPECT_LE(smallSpeed, bigSpeed);
365 CloseSession(sessionId);
366 sleep(1);
367 ret = RemoveSessionServer(UDP_TEST_PKG_NAME, UDP_TEST_SESSION_NAME);
368 EXPECT_EQ(ret, SOFTBUS_ACCESS_TOKEN_DENIED);
369 }
370 } // namespace OHOS
371