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