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 <cstring>
17 #include <sys/utsname.h>
18
19 #include "gtest/gtest.h"
20
21 #include "qos_interface.h"
22
23 namespace OHOS {
24 namespace FFRT_TEST {
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace OHOS::FFRT_TEST;
28 using namespace std;
29
30 class QosInterfaceTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34 void SetUp();
35 void TearDown();
36 bool IsLinuxOs();
37 };
38
IsLinuxOs()39 bool QosInterfaceTest::IsLinuxOs()
40 {
41 struct utsname nameData;
42 uname(&nameData);
43 int cmpNum = 5;
44 return strncmp(nameData.sysname, "Linux", cmpNum) == 0 ? true : false;
45 }
46
SetUpTestCase()47 void QosInterfaceTest::SetUpTestCase()
48 {
49 }
50
TearDownTestCase()51 void QosInterfaceTest::TearDownTestCase()
52 {
53 }
54
SetUp()55 void QosInterfaceTest::SetUp()
56 {
57 }
58
TearDown()59 void QosInterfaceTest::TearDown()
60 {
61 }
62
63 extern "C" {
64 /**
65 * @tc.name: EnableRtgTest
66 * @tc.desc: Test whether the OnRemoteRequest interface are normal.
67 * @tc.type: FUNC
68 */
69 HWTEST_F(QosInterfaceTest, EnableRtgTest, TestSize.Level1)
70 {
71 bool flag = true;
72 int ret = EnableRtg(flag);
73 EXPECT_EQ(ret, 0);
74 }
75
76 /**
77 * @tc.name: QosApplyTest1
78 * @tc.desc: Test whether the QosApply interface are normal.
79 * @tc.type: FUNC
80 */
81 HWTEST_F(QosInterfaceTest, QosApplyTest1, TestSize.Level1)
82 {
83 unsigned int level = 1;
84 int ret = -1;
85 ret = QosApply(level);
86 #if defined(ARM64_TEST) && ARM64_TEST
87 EXPECT_EQ(ret, 0);
88 #else
89 (void)ret;
90 #endif
91 }
92
93 /**
94 * @tc.name: QosApplyTest2
95 * @tc.desc: Test whether the QosApply interface are normal.
96 * @tc.type: FUNC
97 */
98 HWTEST_F(QosInterfaceTest, QosApplyTest2, TestSize.Level1)
99 {
100 unsigned int level = 0;
101 int ret = -1;
102 ret = QosApply(level);
103 EXPECT_EQ(ret, 0);
104
105 level = 1;
106 ret = QosApply(level);
107 EXPECT_EQ(ret, 0);
108
109 level = 2;
110 ret = QosApply(level);
111 EXPECT_EQ(ret, 0);
112
113 level = 3;
114 ret = QosApply(level);
115 EXPECT_EQ(ret, 0);
116
117 level = 4;
118 ret = QosApply(level);
119 EXPECT_EQ(ret, 0);
120
121 level = 5;
122 ret = QosApply(level);
123 EXPECT_EQ(ret, 0);
124
125 level = 6;
126 ret = QosApply(level);
127 EXPECT_EQ(ret, 0);
128
129 level = 7;
130 ret = QosApply(level);
131 EXPECT_EQ(ret, -1);
132
133 level = 1024;
134 ret = QosApply(level);
135 EXPECT_EQ(ret, -1);
136 }
137
138 /**
139 * @tc.name: QosApplyForOtherTest1
140 * @tc.desc: Test whether the QosApplyForOther interface are normal.
141 * @tc.type: FUNC
142 */
143 HWTEST_F(QosInterfaceTest, QosApplyForOtherTest1, TestSize.Level1)
144 {
145 unsigned int level = 1;
146 int tid = gettid();
147 int ret = -1;
148 ret = QosApplyForOther(level, tid);
149 #if defined(ARM64_TEST) && ARM64_TEST
150 EXPECT_EQ(ret, 0);
151 #else
152 (void)ret;
153 #endif
154 }
155
156 /**
157 * @tc.name: QosApplyForOtherTest2
158 * @tc.desc: Test whether the QosApplyForOther interface are normal.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(QosInterfaceTest, QosApplyForOtherTest2, TestSize.Level1)
162 {
163 unsigned int level = 0;
164 int tid = gettid();
165 int ret = -1;
166 ret = QosApplyForOther(level, tid);
167 EXPECT_EQ(ret, 0);
168
169 level = 1;
170 ret = QosApplyForOther(level, tid);
171 EXPECT_EQ(ret, 0);
172
173 level = 2;
174 ret = QosApplyForOther(level, tid);
175 EXPECT_EQ(ret, 0);
176
177 level = 3;
178 ret = QosApplyForOther(level, tid);
179 EXPECT_EQ(ret, 0);
180
181 level = 4;
182 ret = QosApplyForOther(level, tid);
183 EXPECT_EQ(ret, 0);
184
185 level = 5;
186 ret = QosApplyForOther(level, tid);
187 EXPECT_EQ(ret, 0);
188
189 level = 6;
190 ret = QosApplyForOther(level, tid);
191 EXPECT_EQ(ret, 0);
192
193 level = 7;
194 ret = QosApplyForOther(level, tid);
195 EXPECT_EQ(ret, -1);
196
197 level = 1024;
198 ret = QosApplyForOther(level, tid);
199 EXPECT_EQ(ret, -1);
200 }
201
202 /**
203 * @tc.name: QosLeaveTest1
204 * @tc.desc: Test whether the QosLeave interface are normal.
205 * @tc.type: FUNC
206 */
207 HWTEST_F(QosInterfaceTest, QosLeaveTest1, TestSize.Level1)
208 {
209 int ret = -1;
210 ret = QosLeave();
211 #if defined(ARM64_TEST) && ARM64_TEST
212 EXPECT_EQ(ret, 0);
213 #else
214 (void)ret;
215 #endif
216 }
217
218 /**
219 * @tc.name: QosLeaveTest2
220 * @tc.desc: Test whether the QosLeave interface are normal.
221 * @tc.type: FUNC
222 */
223 HWTEST_F(QosInterfaceTest, QosLeaveTest2, TestSize.Level1)
224 {
225 int ret = -1;
226 ret = QosApply(0);
227 EXPECT_EQ(ret, 0);
228 ret = QosLeave();
229 EXPECT_EQ(ret, 0);
230
231 ret = QosApply(1);
232 EXPECT_EQ(ret, 0);
233 ret = QosLeave();
234 EXPECT_EQ(ret, 0);
235
236 ret = QosApply(2);
237 EXPECT_EQ(ret, 0);
238 ret = QosLeave();
239 EXPECT_EQ(ret, 0);
240
241 ret = QosApply(3);
242 EXPECT_EQ(ret, 0);
243 ret = QosLeave();
244 EXPECT_EQ(ret, 0);
245
246 ret = QosApply(4);
247 EXPECT_EQ(ret, 0);
248 ret = QosLeave();
249 EXPECT_EQ(ret, 0);
250
251 ret = QosApply(5);
252 EXPECT_EQ(ret, 0);
253 ret = QosLeave();
254 EXPECT_EQ(ret, 0);
255
256 ret = QosApply(6);
257 EXPECT_EQ(ret, 0);
258 ret = QosLeave();
259 EXPECT_EQ(ret, 0);
260
261 ret = QosApply(7);
262 EXPECT_EQ(ret, -1);
263 ret = QosLeave();
264 EXPECT_EQ(ret, -1);
265 }
266
267 /**
268 * @tc.name: QosLeaveForOtherTest1
269 * @tc.desc: Test whether the QosLeaveForOther interface are normal.
270 * @tc.type: FUNC
271 */
272 HWTEST_F(QosInterfaceTest, QosLeaveForOtherTest1, TestSize.Level1)
273 {
274 int ret = -1;
275 int tid = gettid();
276 int level = 1;
277 ret = QosApplyForOther(level, tid);
278 ret = QosLeaveForOther(tid);
279 #if defined(ARM64_TEST) && ARM64_TEST
280 EXPECT_EQ(ret, 0);
281 #else
282 (void)ret;
283 #endif
284 }
285
286 /**
287 * @tc.name: QosLeaveForOtherTest2
288 * @tc.desc: Test whether the QosLeaveForOther interface are normal.
289 * @tc.type: FUNC
290 */
291 HWTEST_F(QosInterfaceTest, QosLeaveForOtherTest2, TestSize.Level1)
292 {
293 int ret = -1;
294 int tid = gettid();
295 ret = QosApplyForOther(0, tid);
296 EXPECT_EQ(ret, 0);
297 ret = QosLeaveForOther(tid);
298 EXPECT_EQ(ret, 0);
299
300 ret = QosApplyForOther(1, tid);
301 EXPECT_EQ(ret, 0);
302 ret = QosLeaveForOther(tid);
303 EXPECT_EQ(ret, 0);
304
305 ret = QosApplyForOther(2, tid);
306 EXPECT_EQ(ret, 0);
307 ret = QosLeaveForOther(tid);
308 EXPECT_EQ(ret, 0);
309
310 ret = QosApplyForOther(3, tid);
311 EXPECT_EQ(ret, 0);
312 ret = QosLeaveForOther(tid);
313 EXPECT_EQ(ret, 0);
314
315 ret = QosApplyForOther(4, tid);
316 EXPECT_EQ(ret, 0);
317 ret = QosLeaveForOther(tid);
318 EXPECT_EQ(ret, 0);
319
320 ret = QosApplyForOther(5, tid);
321 EXPECT_EQ(ret, 0);
322 ret = QosLeaveForOther(tid);
323 EXPECT_EQ(ret, 0);
324
325 ret = QosApplyForOther(6, tid);
326 EXPECT_EQ(ret, 0);
327 ret = QosLeaveForOther(tid);
328 EXPECT_EQ(ret, 0);
329
330 ret = QosApplyForOther(7, tid);
331 EXPECT_EQ(ret, -1);
332 ret = QosLeaveForOther(tid);
333 EXPECT_EQ(ret, -1);
334 }
335
336 /**
337 * @tc.name: QosPolicyTest
338 * @tc.desc: Test whether the QosPolicy interface are normal.
339 * @tc.type: FUNC
340 */
341
342 static struct QosPolicyDatas g_defaultQosPolicy = {
343 .policyType = QOS_POLICY_DEFAULT,
344 .policyFlag = QOS_FLAG_ALL,
345 .policys = {
346 {0, 0, 0, 1024, 0},
347 {0, 0, 0, 1024, 0},
348 {0, 0, 0, 1024, 0},
349 {0, 0, 0, 1024, 0},
350 {0, 0, 0, 1024, 0},
351 {0, 0, 0, 1024, 0},
352 {0, 0, 0, 1024, 0},
353 }
354 };
355
356 HWTEST_F(QosInterfaceTest, QosPolicyTest, TestSize.Level1)
357 {
358 int ret = -1;
359 struct QosPolicyDatas *policyDatas = nullptr;
360 ret = QosPolicySet(policyDatas);
361 EXPECT_EQ(ret, -1);
362 }
363
364 /**
365 * @tc.name: QosGetTest1
366 * @tc.desc: Test whether the QosGet interface are normal.
367 * @tc.type: FUNC
368 */
369 HWTEST_F(QosInterfaceTest, QosGetTest1, TestSize.Level1)
370 {
371 int qos;
372 unsigned int level = 4;
373 int ret = QosApply(level);
374 EXPECT_EQ(ret, 0);
375 ret = QosGet(qos);
376 sleep(5);
377 EXPECT_EQ(ret, 0);
378 EXPECT_EQ(qos, level);
379 }
380
381 /**
382 * @tc.name: QosGetTest2
383 * @tc.desc: Test whether the QosGet interface are normal.
384 * @tc.type: FUNC
385 */
386 HWTEST_F(QosInterfaceTest, QosGetTest2, TestSize.Level1)
387 {
388 int qos;
389 unsigned int level = 0;
390 int ret = QosApply(level);
391 EXPECT_EQ(ret, 0);
392 ret = QosGet(qos);
393 sleep(1);
394 EXPECT_EQ(ret, 0);
395 EXPECT_EQ(qos, level);
396
397 level = 1;
398 ret = QosApply(level);
399 EXPECT_EQ(ret, 0);
400 ret = QosGet(qos);
401 sleep(1);
402 EXPECT_EQ(ret, 0);
403 EXPECT_EQ(qos, level);
404
405 level = 2;
406 ret = QosApply(level);
407 EXPECT_EQ(ret, 0);
408 ret = QosGet(qos);
409 sleep(1);
410 EXPECT_EQ(ret, 0);
411 EXPECT_EQ(qos, level);
412
413 level = 3;
414 ret = QosApply(level);
415 EXPECT_EQ(ret, 0);
416 ret = QosGet(qos);
417 sleep(1);
418 EXPECT_EQ(ret, 0);
419 EXPECT_EQ(qos, level);
420 }
421
422 /**
423 * @tc.name: QosGetTest3
424 * @tc.desc: Test whether the QosGet interface are normal.
425 * @tc.type: FUNC
426 */
427 HWTEST_F(QosInterfaceTest, QosGetTest3, TestSize.Level1)
428 {
429 int qos;
430 unsigned int level = 4;
431 int ret = QosApply(level);
432 EXPECT_EQ(ret, 0);
433 ret = QosGet(qos);
434 sleep(1);
435 EXPECT_EQ(ret, 0);
436 EXPECT_EQ(qos, level);
437
438 level = 5;
439 ret = QosApply(level);
440 EXPECT_EQ(ret, 0);
441 ret = QosGet(qos);
442 sleep(1);
443 EXPECT_EQ(ret, 0);
444 EXPECT_EQ(qos, level);
445
446 level = 6;
447 ret = QosApply(level);
448 EXPECT_EQ(ret, 0);
449 ret = QosGet(qos);
450 sleep(1);
451 EXPECT_EQ(ret, 0);
452 EXPECT_EQ(qos, level);
453 }
454
455 /**
456 * @tc.name: QosGetForOtherTest1
457 * @tc.desc: Test whether the QosGetForOther interface are normal.
458 * @tc.type: FUNC
459 */
460 HWTEST_F(QosInterfaceTest, QosGetForOtherTest1, TestSize.Level1)
461 {
462 int qos;
463 unsigned int level = 0;
464 int tid = gettid();
465 int ret = QosApplyForOther(level, tid);
466 EXPECT_EQ(ret, 0);
467 sleep(1);
468 ret = QosGetForOther(tid, qos);
469 EXPECT_EQ(ret, 0);
470 EXPECT_EQ(qos, level);
471
472 level = 1;
473 ret = QosApplyForOther(level, tid);
474 EXPECT_EQ(ret, 0);
475 sleep(1);
476 ret = QosGetForOther(tid, qos);
477 EXPECT_EQ(ret, 0);
478 EXPECT_EQ(qos, level);
479
480 level = 2;
481 ret = QosApplyForOther(level, tid);
482 EXPECT_EQ(ret, 0);
483 sleep(1);
484 ret = QosGetForOther(tid, qos);
485 EXPECT_EQ(ret, 0);
486 EXPECT_EQ(qos, level);
487
488 level = 3;
489 ret = QosApplyForOther(level, tid);
490 EXPECT_EQ(ret, 0);
491 sleep(1);
492 ret = QosGetForOther(tid, qos);
493 EXPECT_EQ(ret, 0);
494 EXPECT_EQ(qos, level);
495 }
496
497 /**
498 * @tc.name: QosGetForOtherTest2
499 * @tc.desc: Test whether the QosGetForOther interface are normal.
500 * @tc.type: FUNC
501 */
502 HWTEST_F(QosInterfaceTest, QosGetForOtherTest2, TestSize.Level1)
503 {
504 int qos;
505 unsigned int level = 4;
506 int tid = gettid();
507 int ret = QosApplyForOther(level, tid);
508 EXPECT_EQ(ret, 0);
509 sleep(1);
510 ret = QosGetForOther(tid, qos);
511 EXPECT_EQ(ret, 0);
512 EXPECT_EQ(qos, level);
513
514 level = 5;
515 ret = QosApplyForOther(level, tid);
516 EXPECT_EQ(ret, 0);
517 sleep(1);
518 ret = QosGetForOther(tid, qos);
519 EXPECT_EQ(ret, 0);
520 EXPECT_EQ(qos, level);
521
522 level = 6;
523 ret = QosApplyForOther(level, tid);
524 EXPECT_EQ(ret, 0);
525 sleep(1);
526 ret = QosGetForOther(tid, qos);
527 EXPECT_EQ(ret, 0);
528 EXPECT_EQ(qos, level);
529 }
530 }
531 }
532 }
533