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