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