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 "gtest/gtest.h"
17
18 #define private public
19 #define protected public
20 #include "intellisense_server.h"
21 #include "rtg_interface.h"
22 #undef private
23 #undef protected
24
25 namespace OHOS {
26 namespace RME {
27 using namespace testing;
28 using namespace testing::ext;
29
30 #define RTG_INTERFACE_SO_PATH "/system/lib/librtg_interface.z.so"
31
32 enum RtgType : int {
33 VIP = 0,
34 TOP_TASK_KEY,
35 NORMAL_TASK,
36 RTG_TYPE_MAX,
37 };
38
39 class RtgInterfaceTest : public testing::Test {
40 public:
41 static void SetUpTestCase();
42 static void TearDownTestCase();
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase()47 void RtgInterfaceTest::SetUpTestCase()
48 {
49 }
50
TearDownTestCase()51 void RtgInterfaceTest::TearDownTestCase()
52 {
53 }
54
SetUp()55 void RtgInterfaceTest::SetUp()
56 {
57 // must enable rtg before use the interface
58 bool ret = EnableRtg(true);
59 EXPECT_EQ(ret, false);
60 }
61
TearDown()62 void RtgInterfaceTest::TearDown()
63 {
64 }
65
66 /**
67 * @tc.name: RtgInterfaceCreateAndDestroy
68 * @tc.desc: Verify the CreateAndDestroy function.
69 * @tc.type: FUNC
70 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceCreateAndDestroy, TestSize.Level1)71 HWTEST_F(RtgInterfaceTest, RtgInterfaceCreateAndDestroy, TestSize.Level1)
72 {
73 int ret;
74 int grpId;
75 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(NORMAL_TASK, 0);
76 EXPECT_GT(grpId, 0);
77 ret = DestroyRtgGrp(grpId);
78 EXPECT_EQ(ret, 0);
79 }
80
81 /**
82 * @tc.name: RtgInterfaceDestroyErrorGroup
83 * @tc.desc: Verify Destroy function with error param.
84 * @tc.type: FUNC
85 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceDestroyErrorGroup, TestSize.Level1)86 HWTEST_F(RtgInterfaceTest, RtgInterfaceDestroyErrorGroup, TestSize.Level1)
87 {
88 int ret;
89 ret = DestroyRtgGrp(-1);
90 EXPECT_NE(ret, 0);
91 }
92
93 /**
94 * @tc.name: RtgInterfaceAddRtg
95 * @tc.desc: Verify Rtg add function.
96 * @tc.type: FUNC
97 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceAddRtg, TestSize.Level1)98 HWTEST_F(RtgInterfaceTest, RtgInterfaceAddRtg, TestSize.Level1)
99 {
100 int ret;
101 int grpId;
102 int pid = getpid();
103 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
104 EXPECT_GT(grpId, 0);
105 ret = AddThreadToRtg(pid, grpId);
106 EXPECT_EQ(ret, 0);
107 ret = DestroyRtgGrp(grpId);
108 EXPECT_EQ(ret, 0);
109 }
110
111 /**
112 * @tc.name: RtgInterfaceAddErrorThread
113 * @tc.desc: Verify Rtg add function with error pid.
114 * @tc.type: FUNC
115 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceAddErrorThread, TestSize.Level1)116 HWTEST_F(RtgInterfaceTest, RtgInterfaceAddErrorThread, TestSize.Level1)
117 {
118 int ret;
119 int grpId;
120 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
121 EXPECT_GT(grpId, 0);
122 ret = AddThreadToRtg(-1, grpId);
123 EXPECT_NE(ret, 0);
124 ret = DestroyRtgGrp(grpId);
125 EXPECT_EQ(ret, 0);
126 }
127
128 /**
129 * @tc.name: RtgInterfaceAddErrorGroup
130 * @tc.desc: Verify Rtg add function with error groupid.
131 * @tc.type: FUNC
132 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceAddErrorGroup, TestSize.Level1)133 HWTEST_F(RtgInterfaceTest, RtgInterfaceAddErrorGroup, TestSize.Level1)
134 {
135 int ret;
136 int pid = getpid();
137 ret = AddThreadToRtg(pid, -1);
138 EXPECT_NE(ret, 0);
139 }
140
141 /**
142 * @tc.name: RtgInterfaceAddRtgs
143 * @tc.desc: Verify Rtg add multiple thread function.
144 * @tc.type: FUNC
145 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceAddRtgs, TestSize.Level1)146 HWTEST_F(RtgInterfaceTest, RtgInterfaceAddRtgs, TestSize.Level1)
147 {
148 int ret;
149 int grpId;
150 int pid = getpid();
151 vector<int> pids = {};
152 pids.push_back(pid);
153 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
154 EXPECT_GT(grpId, 0);
155 ret = AddThreadsToRtg(pids, grpId);
156 EXPECT_EQ(ret, 0);
157 ret = DestroyRtgGrp(grpId);
158 EXPECT_EQ(ret, 0);
159 }
160
161 /**
162 * @tc.name: RtgInterfaceBeginFrameFreq
163 * @tc.desc: Verify rtg frame start function.
164 * @tc.type: FUNC
165 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceBeginFrameFreq, TestSize.Level1)166 HWTEST_F(RtgInterfaceTest, RtgInterfaceBeginFrameFreq, TestSize.Level1)
167 {
168 int ret;
169 int grpId;
170 int pid = getpid();
171 vector<int> pids = {};
172 pids.push_back(pid);
173 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
174 EXPECT_GT(grpId, 0);
175 ret = AddThreadsToRtg(pids, grpId);
176 EXPECT_EQ(ret, 0);
177 ret = BeginFrameFreq(0);
178 EXPECT_EQ(ret, 0);
179 ret = DestroyRtgGrp(grpId);
180 EXPECT_EQ(ret, 0);
181 }
182
183 /**
184 * @tc.name: RtgInterfaceBeginFrameFreqWithNoAddThreadtoGrp
185 * @tc.desc: Verify rtg frame start function with NoAddThreadtoGrp.
186 * @tc.type: FUNC
187 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceBeginFrameFreqWithNoAddThreadtoGrp, TestSize.Level1)188 HWTEST_F(RtgInterfaceTest, RtgInterfaceBeginFrameFreqWithNoAddThreadtoGrp, TestSize.Level1)
189 {
190 int ret;
191 int grpId;
192 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
193 EXPECT_GT(grpId, 0);
194 ret = BeginFrameFreq(0);
195 EXPECT_NE(ret, 0);
196 ret = DestroyRtgGrp(grpId);
197 EXPECT_EQ(ret, 0);
198 }
199
200 /**
201 * @tc.name: RtgInterfaceEndFrameFreq
202 * @tc.desc: Verify rtg frame end function.
203 * @tc.type: FUNC
204 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceEndFrameFreq, TestSize.Level1)205 HWTEST_F(RtgInterfaceTest, RtgInterfaceEndFrameFreq, TestSize.Level1)
206 {
207 int ret;
208 int grpId;
209 int pid = getpid();
210 vector<int> pids = {};
211 pids.push_back(pid);
212 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
213 EXPECT_GT(grpId, 0);
214 ret = AddThreadsToRtg(pids, grpId);
215 EXPECT_EQ(ret, 0);
216 ret = EndFrameFreq(0);
217 EXPECT_EQ(ret, 0);
218 ret = DestroyRtgGrp(grpId);
219 EXPECT_EQ(ret, 0);
220 }
221
222 /**
223 * @tc.name: RtgInterfaceEndFrameFreqWithNoAddThreadtoGrp
224 * @tc.desc: Verify rtg frame end function with NoAddThreadtoGrp.
225 * @tc.type: FUNC
226 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceEndFrameFreqWithNoAddThreadtoGrp, TestSize.Level1)227 HWTEST_F(RtgInterfaceTest, RtgInterfaceEndFrameFreqWithNoAddThreadtoGrp, TestSize.Level1)
228 {
229 int ret;
230 int grpId;
231 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
232 EXPECT_GT(grpId, 0);
233 ret = EndFrameFreq(0);
234 EXPECT_NE(ret, 0);
235 ret = DestroyRtgGrp(grpId);
236 EXPECT_EQ(ret, 0);
237 }
238
239 /**
240 * @tc.name: RtgInterfaceEndScene
241 * @tc.desc: Verify rtg frame scene end function.
242 * @tc.type: FUNC
243 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceEndScene, TestSize.Level1)244 HWTEST_F(RtgInterfaceTest, RtgInterfaceEndScene, TestSize.Level1)
245 {
246 int ret;
247 int grpId;
248 int pid = getpid();
249 vector<int> pids = {};
250 pids.push_back(pid);
251 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
252 EXPECT_GT(grpId, 0);
253 ret = AddThreadsToRtg(pids, grpId);
254 EXPECT_EQ(ret, 0);
255 ret = EndScene(grpId);
256 EXPECT_EQ(ret, 0);
257 ret = DestroyRtgGrp(grpId);
258 EXPECT_EQ(ret, 0);
259 }
260
261 /**
262 * @tc.name: RtgInterfaceEndSceneWithErrorGrp
263 * @tc.desc: Verify rtg frame scene end function with error groupid.
264 * @tc.type: FUNC
265 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceEndSceneWithErrorGrp, TestSize.Level1)266 HWTEST_F(RtgInterfaceTest, RtgInterfaceEndSceneWithErrorGrp, TestSize.Level1)
267 {
268 int ret;
269 ret = EndScene(-1);
270 EXPECT_NE(ret, 0);
271 }
272
273 /**
274 * @tc.name: RtgInterfaceSetMinUtil
275 * @tc.desc: Verify rtg minUtil set function.
276 * @tc.type: FUNC
277 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceSetMinUtil, TestSize.Level1)278 HWTEST_F(RtgInterfaceTest, RtgInterfaceSetMinUtil, TestSize.Level1)
279 {
280 int ret;
281 int grpId;
282 int pid = getpid();
283 vector<int> pids = {};
284 pids.push_back(pid);
285 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
286 EXPECT_GT(grpId, 0);
287 ret = AddThreadsToRtg(pids, grpId);
288 EXPECT_EQ(ret, 0);
289 ret = SetMinUtil(0);
290 EXPECT_EQ(ret, 0);
291 ret = DestroyRtgGrp(grpId);
292 EXPECT_EQ(ret, 0);
293 }
294
295 /**
296 * @tc.name: RtgInterfaceSetMinUtilWithNoAddThreadtoGrp
297 * @tc.desc: Verify rtg minUtil set function with NoAddThreadtoGrp.
298 * @tc.type: FUNC
299 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceSetMinUtilWithNoAddThreadtoGrp, TestSize.Level1)300 HWTEST_F(RtgInterfaceTest, RtgInterfaceSetMinUtilWithNoAddThreadtoGrp, TestSize.Level1)
301 {
302 int ret;
303 int grpId;
304 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
305 EXPECT_GT(grpId, 0);
306 ret = SetMinUtil(0);
307 EXPECT_NE(ret, 0);
308 ret = DestroyRtgGrp(grpId);
309 EXPECT_EQ(ret, 0);
310 }
311
312 /**
313 * @tc.name: RtgInterfaceSetMargin
314 * @tc.desc: Verify rtg margin set function.
315 * @tc.type: FUNC
316 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceSetMargin, TestSize.Level1)317 HWTEST_F(RtgInterfaceTest, RtgInterfaceSetMargin, TestSize.Level1)
318 {
319 int ret;
320 int grpId;
321 int pid = getpid();
322 vector<int> pids = {};
323 pids.push_back(pid);
324 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
325 EXPECT_GT(grpId, 0);
326 ret = AddThreadsToRtg(pids, grpId);
327 EXPECT_EQ(ret, 0);
328 ret = SetMargin(0);
329 EXPECT_EQ(ret, 0);
330 ret = DestroyRtgGrp(grpId);
331 EXPECT_EQ(ret, 0);
332 }
333
334 /**
335 * @tc.name: RtgInterfaceSetMarginWithNoAddThreadtoGrp
336 * @tc.desc: Verify rtg margin set function with NoAddThreadtoGrp.
337 * @tc.type: FUNC
338 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceSetMarginWithNoAddThreadtoGrp, TestSize.Level1)339 HWTEST_F(RtgInterfaceTest, RtgInterfaceSetMarginWithNoAddThreadtoGrp, TestSize.Level1)
340 {
341 int ret;
342 int grpId;
343 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
344 EXPECT_GT(grpId, 0);
345 ret = SetMargin(0);
346 EXPECT_NE(ret, 0);
347 ret = DestroyRtgGrp(grpId);
348 EXPECT_EQ(ret, 0);
349 }
350
351 /**
352 * @tc.name: RtgInterfaceSetAttr
353 * @tc.desc: Verify rtg attr set function.
354 * @tc.type: FUNC
355 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceSetAttr, TestSize.Level1)356 HWTEST_F(RtgInterfaceTest, RtgInterfaceSetAttr, TestSize.Level1)
357 {
358 int ret;
359 int grpId;
360 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
361 EXPECT_GT(grpId, 0);
362 ret = SetFrameRateAndPrioType(grpId, 60, VIP);
363 EXPECT_EQ(ret, 0);
364 ret = DestroyRtgGrp(grpId);
365 EXPECT_EQ(ret, 0);
366 }
367
368 /**
369 * @tc.name: RtgInterfaceSetErrorAttr
370 * @tc.desc: Verify rtg attr set function with error attr param.
371 * @tc.type: FUNC
372 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceSetErrorAttr, TestSize.Level1)373 HWTEST_F(RtgInterfaceTest, RtgInterfaceSetErrorAttr, TestSize.Level1)
374 {
375 int ret;
376 int grpId;
377 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(VIP, 0);
378 EXPECT_GT(grpId, 0);
379 ret = SetFrameRateAndPrioType(grpId, 0, VIP);
380 EXPECT_NE(ret, 0);
381 ret = SetFrameRateAndPrioType(grpId, -1, VIP);
382 EXPECT_NE(ret, 0);
383 ret = SetFrameRateAndPrioType(grpId, 121, VIP);
384 EXPECT_NE(ret, 0);
385 ret = DestroyRtgGrp(grpId);
386 EXPECT_EQ(ret, 0);
387 }
388
389 /**
390 * @tc.name: RtgInterfaceAddMultipleThreads
391 * @tc.desc: Verify rtg multiple add function.
392 * @tc.type: FUNC
393 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceAddMultipleThreads, TestSize.Level1)394 HWTEST_F(RtgInterfaceTest, RtgInterfaceAddMultipleThreads, TestSize.Level1)
395 {
396 int ret;
397 int pid[3];
398 vector<int> threads;
399 int grpId;
400 for (int i = 0; i < 3; i++) {
401 pid[i] = fork();
402 ASSERT_TRUE(pid[i] >= 0) << "> parent: fork errno = " << errno;
403 if (pid[i] == 0) {
404 usleep(50000);
405 _Exit(0);
406 }
407 threads.push_back(pid[i]);
408 }
409 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(NORMAL_TASK, 0);
410 EXPECT_GT(grpId, 0);
411 ret = AddThreadsToRtg(threads, grpId);
412 EXPECT_EQ(ret, 0);
413 ret = DestroyRtgGrp(grpId);
414 EXPECT_EQ(ret, 0);
415 }
416
417 /**
418 * @tc.name: RtgInterfaceAddMultipleThreadsOutOfLimit
419 * @tc.desc: Verify rtg multiple add function with out of limit threads.
420 * @tc.type: FUNC
421 */
HWTEST_F(RtgInterfaceTest, RtgInterfaceAddMultipleThreadsOutOfLimit, TestSize.Level1)422 HWTEST_F(RtgInterfaceTest, RtgInterfaceAddMultipleThreadsOutOfLimit, TestSize.Level1)
423 {
424 int ret;
425 int pid[8];
426 vector<int> threads;
427 int grpId;
428 for (int i = 0; i < 8; i++) {
429 pid[i] = fork();
430 ASSERT_TRUE(pid[i] >= 0) << "> parent: fork errno = " << errno;
431 if (pid[i] == 0) {
432 usleep(50000);
433 _Exit(0);
434 }
435 threads.push_back(pid[i]);
436 }
437 grpId = IntelliSenseServer::GetInstance().CreateNewRtgGrp(NORMAL_TASK, 0);
438 EXPECT_GT(grpId, 0);
439 ret = AddThreadsToRtg(threads, grpId);
440 EXPECT_NE(ret, 0);
441 ret = DestroyRtgGrp(grpId);
442 EXPECT_EQ(ret, 0);
443 }
444 } // namespace RME
445 } // namespace OHOS
446