1 /*
2 * Copyright (c) 2024 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 #include <limits>
18 #include <test_header.h>
19
20 #include "hgm_core.h"
21 #include "hgm_frame_rate_manager.h"
22 #include "hgm_multi_app_strategy.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 namespace {
30 constexpr int32_t nodeIdOffset = 32;
31 const std::string settingStrategyName = "99";
32 const std::string otherPkgName = "com.pkg.other";
33 const std::string defaultPidStr = "0";
34
35 constexpr int32_t fps0 = 10;
36 constexpr int32_t downFps0 = 90;
37 constexpr int32_t pid0 = 10010;
38 const std::string strategyName0 = "110";
39 const std::string pkgName0 = "com.app10";
40 constexpr int32_t appType0 = 20010;
41
42 constexpr int32_t fps1 = 15;
43 constexpr int32_t downFps1 = 120;
44 constexpr int32_t pid1 = 10015;
45 const std::string strategyName1 = "115";
46 const std::string pkgName1 = "com.app15";
47 constexpr int32_t appType1 = 20015;
48 }
49
50 struct PkgParam {
51 std::string pkgName;
52 int32_t fps;
53 pid_t pid;
54 std::shared_ptr<RSRenderFrameRateLinker> linker;
55 };
56
57 class HgmMultiAppStrategyTest : public testing::Test {
58 public:
SetUpTestCase()59 static void SetUpTestCase() {}
TearDownTestCase()60 static void TearDownTestCase() {}
61 void SetUp();
TearDown()62 void TearDown() {}
63 void SetMultiAppStrategy(MultiAppStrategyType multiAppStrategyType, const std::string& strategyName = "");
64 std::vector<std::string> CreateVotePkgs();
65 HgmErrCode GetTouchVoteInfo(VoteInfo& touchVoteInfo);
66
67 std::vector<PkgParam> pkgParams_;
68 std::shared_ptr<HgmMultiAppStrategy> multiAppStrategy_;
69 };
70
SetUp()71 void HgmMultiAppStrategyTest::SetUp()
72 {
73 multiAppStrategy_ = std::make_shared<HgmMultiAppStrategy>();
74 // init config
75 // set app config
76 auto strategyConfigs = multiAppStrategy_->GetStrategyConfigs();
77 auto screenSetting = multiAppStrategy_->GetScreenSetting();
78 multiAppStrategy_->appBufferListCache_ = {"test1", "test2", "test3", "test4"};
79 auto &appTypes = screenSetting.appTypes;
80
81 strategyConfigs[settingStrategyName] = { .min = OLED_NULL_HZ, .max = OLED_120_HZ, .down = OLED_144_HZ,
82 .dynamicMode = DynamicModeType::TOUCH_ENABLED, .isFactor = true };
83 screenSetting.strategy = settingStrategyName;
84
85 strategyConfigs[strategyName0] = { .min = fps0, .max = fps0, .dynamicMode = DynamicModeType::TOUCH_ENABLED,
86 .drawMin = OLED_NULL_HZ, .drawMax = OLED_NULL_HZ, .down = downFps0,
87 .bufferFpsMap = {{"test2", OLED_NULL_HZ}, {"test4", OLED_NULL_HZ},
88 {"test3", OLED_120_HZ}, {"test1", OLED_90_HZ}},
89 };
90 screenSetting.appList[pkgName0] = strategyName0;
91 pkgParams_.push_back({ .pkgName = pkgName0, .fps = fps0, .pid = pid0,
92 .linker = std::make_shared<RSRenderFrameRateLinker>(((NodeId)pid0) << nodeIdOffset) });
93
94 strategyConfigs[strategyName1] = { .min = fps1, .max = fps1, .dynamicMode = DynamicModeType::TOUCH_ENABLED,
95 .drawMin = OLED_NULL_HZ, .drawMax = OLED_NULL_HZ, .down = downFps1 };
96 screenSetting.appList[pkgName1] = strategyName1;
97 pkgParams_.push_back({ .pkgName = pkgName1, .fps = fps1, .pid = pid1,
98 .linker = std::make_shared<RSRenderFrameRateLinker>(((NodeId)pid1) << nodeIdOffset) });
99
100 for (auto &pkgParam : pkgParams_) {
101 pkgParam.linker->SetExpectedRange(FrameRateRange(OLED_NULL_HZ, RANGE_MAX_REFRESHRATE, OLED_NULL_HZ));
102 }
103
104 appTypes[appType0] = strategyName0;
105 appTypes[appType1] = strategyName1;
106 multiAppStrategy_->SetStrategyConfigs(strategyConfigs);
107 multiAppStrategy_->SetScreenSetting(screenSetting);
108 }
109
SetMultiAppStrategy(MultiAppStrategyType multiAppStrategyType,const std::string & strategyName)110 void HgmMultiAppStrategyTest::SetMultiAppStrategy(
111 MultiAppStrategyType multiAppStrategyType, const std::string& strategyName)
112 {
113 auto screenSetting = multiAppStrategy_->GetScreenSetting();
114 screenSetting.multiAppStrategyType = multiAppStrategyType;
115 screenSetting.multiAppStrategyName = strategyName;
116 multiAppStrategy_->SetScreenSetting(screenSetting);
117 }
118
CreateVotePkgs()119 std::vector<std::string> HgmMultiAppStrategyTest::CreateVotePkgs()
120 {
121 std::vector<std::string> pkgs;
122 for (auto &pkgParam : pkgParams_) {
123 pkgs.push_back(pkgParam.pkgName + ":" + std::to_string(pkgParam.pid));
124 }
125 return pkgs;
126 }
127
GetTouchVoteInfo(VoteInfo & touchVoteInfo)128 HgmErrCode HgmMultiAppStrategyTest::GetTouchVoteInfo(VoteInfo& touchVoteInfo)
129 {
130 auto frameRateMgr = HgmCore::Instance().GetFrameRateMgr();
131 if (frameRateMgr == nullptr) {
132 return HGM_ERROR;
133 }
134 auto iter = frameRateMgr->voteRecord_.find("VOTER_TOUCH");
135 if (iter == frameRateMgr->voteRecord_.end()) {
136 return HGM_ERROR;
137 }
138 auto& [voteInfos, _] = iter->second;
139 if (voteInfos.empty()) {
140 return HGM_ERROR;
141 }
142 touchVoteInfo = voteInfos.back();
143 return EXEC_SUCCESS;
144 }
145
146 /**
147 * @tc.name: SingleAppTouch001
148 * @tc.desc: Verify the result of SingleAppTouch001 function
149 * @tc.type: FUNC
150 * @tc.require:
151 */
152 HWTEST_F(HgmMultiAppStrategyTest, SingleAppTouch001, Function | SmallTest | Level1)
153 {
154 PART("CaseDescription") {
155 auto &pkgParam = pkgParams_[0]; // first pkg
156 std::vector<std::string> voteParam = { pkgParam.pkgName + ":" + std::to_string(pkgParam.pid), };
157
158 PolicyConfigData::StrategyConfig strategyConfig;
159 VoteInfo touchVoteInfo;
160 HgmErrCode res;
161 SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
162
163 STEP("1. pkg vote") {
164 multiAppStrategy_->HandlePkgsEvent(voteParam);
165 res = multiAppStrategy_->GetVoteRes(strategyConfig);
166 ASSERT_EQ(res, EXEC_SUCCESS);
167 ASSERT_EQ(strategyConfig.min, fps0);
168 ASSERT_EQ(strategyConfig.max, fps0);
169 }
170 STEP("2. handle touch event") {
171 HgmMultiAppStrategy::TouchInfo touchInfo = {
172 .pkgName = pkgParam.pkgName,
173 .touchState = TouchState::DOWN_STATE,
174 .upExpectFps = OLED_120_HZ,
175 };
176 multiAppStrategy_->HandleTouchInfo(touchInfo);
177 ASSERT_EQ(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
178 ASSERT_EQ(touchVoteInfo.min, downFps0);
179 ASSERT_EQ(touchVoteInfo.max, downFps0);
180
181 touchInfo = {
182 .touchState = TouchState::UP_STATE,
183 };
184 multiAppStrategy_->HandleTouchInfo(touchInfo);
185 ASSERT_EQ(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
186 ASSERT_EQ(touchVoteInfo.min, downFps0);
187 ASSERT_EQ(touchVoteInfo.max, downFps0);
188
189 touchInfo = {
190 .touchState = TouchState::IDLE_STATE,
191 };
192 multiAppStrategy_->HandleTouchInfo(touchInfo);
193 ASSERT_NE(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
194 }
195 }
196 }
197
198 /**
199 * @tc.name: SingleAppTouch002
200 * @tc.desc: Verify the result of SingleAppTouch002 function
201 * @tc.type: FUNC
202 * @tc.require:
203 */
204 HWTEST_F(HgmMultiAppStrategyTest, SingleAppTouch002, Function | SmallTest | Level1)
205 {
206 PART("CaseDescription") {
207 std::string unConfigPkgName = "com.pkg.other";
208 auto &pkgParam = pkgParams_[0]; // first pkg
209 std::vector<std::string> voteParam = { pkgParam.pkgName + ":" + std::to_string(pkgParam.pid), };
210
211 PolicyConfigData::StrategyConfig strategyConfig;
212 VoteInfo touchVoteInfo;
213 HgmErrCode res;
214 SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
215
216 STEP("1. pkg vote") {
217 multiAppStrategy_->HandlePkgsEvent(voteParam);
218 res = multiAppStrategy_->GetVoteRes(strategyConfig);
219 ASSERT_EQ(res, EXEC_SUCCESS);
220 ASSERT_EQ(strategyConfig.min, fps0);
221 ASSERT_EQ(strategyConfig.max, fps0);
222 }
223 STEP("2. click other pkg which hasn't config") {
224 HgmMultiAppStrategy::TouchInfo touchInfo = {
225 .pkgName = unConfigPkgName,
226 .touchState = TouchState::DOWN_STATE,
227 .upExpectFps = OLED_120_HZ,
228 };
229 multiAppStrategy_->HandleTouchInfo(touchInfo);
230 ASSERT_EQ(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
231 ASSERT_EQ(touchVoteInfo.min, OLED_144_HZ);
232 ASSERT_EQ(touchVoteInfo.max, OLED_144_HZ);
233 touchInfo = {
234 .touchState = TouchState::UP_STATE,
235 };
236 multiAppStrategy_->HandleTouchInfo(touchInfo);
237 touchInfo = {
238 .touchState = TouchState::IDLE_STATE,
239 };
240 multiAppStrategy_->HandleTouchInfo(touchInfo);
241 ASSERT_NE(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
242 }
243 }
244 }
245
246 /**
247 * @tc.name: SingleAppTouch003
248 * @tc.desc: Verify the result of SingleAppTouch003 function
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(HgmMultiAppStrategyTest, SingleAppTouch003, Function | SmallTest | Level1)
253 {
254 PART("CaseDescription") {
255 std::string unConfigPkgName = "com.pkg.other";
256 auto &pkgParam = pkgParams_[0]; // first pkg
257 std::vector<std::string> voteParam = { pkgParam.pkgName + ":" + std::to_string(pkgParam.pid), };
258
259 PolicyConfigData::StrategyConfig strategyConfig;
260 VoteInfo touchVoteInfo;
261 HgmErrCode res;
262 SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
263
264 STEP("1. pkg vote") {
265 multiAppStrategy_->HandlePkgsEvent(voteParam);
266 }
267 STEP("2. start other pkg which hasn't config") {
268 res = multiAppStrategy_->HandlePkgsEvent({});
269 ASSERT_EQ(res, EXEC_SUCCESS);
270 multiAppStrategy_->HandlePkgsEvent({ unConfigPkgName, });
271 ASSERT_EQ(res, EXEC_SUCCESS);
272 res = multiAppStrategy_->GetVoteRes(strategyConfig);
273 ASSERT_EQ(res, EXEC_SUCCESS);
274 ASSERT_EQ(strategyConfig.min, OLED_NULL_HZ);
275 ASSERT_EQ(strategyConfig.max, OLED_120_HZ);
276
277 HgmMultiAppStrategy::TouchInfo touchInfo = {
278 .pkgName = unConfigPkgName,
279 .touchState = TouchState::DOWN_STATE,
280 .upExpectFps = OLED_120_HZ,
281 };
282 multiAppStrategy_->HandleTouchInfo(touchInfo);
283 ASSERT_EQ(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
284 ASSERT_EQ(touchVoteInfo.min, OLED_144_HZ);
285 ASSERT_EQ(touchVoteInfo.max, OLED_144_HZ);
286
287 touchInfo = {
288 .touchState = TouchState::UP_STATE,
289 };
290 multiAppStrategy_->HandleTouchInfo(touchInfo);
291 touchInfo = {
292 .touchState = TouchState::IDLE_STATE,
293 };
294 multiAppStrategy_->HandleTouchInfo(touchInfo);
295 ASSERT_NE(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
296 }
297 }
298 }
299
300 /**
301 * @tc.name: MultiAppTouch001
302 * @tc.desc: Verify the result of MultiAppTouch function
303 * @tc.type: FUNC
304 * @tc.require:
305 */
306 HWTEST_F(HgmMultiAppStrategyTest, MultiAppTouch001, Function | SmallTest | Level1)
307 {
308 PART("CaseDescription") {
309 PolicyConfigData::StrategyConfig strategyConfig;
310 VoteInfo touchVoteInfo;
311 SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
312 STEP("1. pkg vote") {
313 multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
314 multiAppStrategy_->GetVoteRes(strategyConfig);
315 ASSERT_EQ(strategyConfig.min, fps1);
316 ASSERT_EQ(strategyConfig.max, fps1);
317 }
318 STEP("2. handle pkg0 touch event") {
319 HgmMultiAppStrategy::TouchInfo touchInfo = {
320 .pkgName = pkgParams_[0].pkgName,
321 .touchState = TouchState::DOWN_STATE,
322 .upExpectFps = OLED_120_HZ,
323 };
324 multiAppStrategy_->HandleTouchInfo(touchInfo);
325 ASSERT_EQ(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
326 ASSERT_EQ(touchVoteInfo.min, downFps0);
327 ASSERT_EQ(touchVoteInfo.max, downFps0);
328
329 touchInfo = {
330 .touchState = TouchState::UP_STATE,
331 };
332 multiAppStrategy_->HandleTouchInfo(touchInfo);
333 touchInfo = {
334 .touchState = TouchState::IDLE_STATE,
335 };
336 multiAppStrategy_->HandleTouchInfo(touchInfo);
337 ASSERT_NE(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
338 }
339 }
340 }
341
342 /**
343 * @tc.name: MultiAppTouch002
344 * @tc.desc: Verify the result of MultiAppTouch function
345 * @tc.type: FUNC
346 * @tc.require:
347 */
348 HWTEST_F(HgmMultiAppStrategyTest, MultiAppTouch002, Function | SmallTest | Level1)
349 {
350 PART("CaseDescription") {
351 PolicyConfigData::StrategyConfig strategyConfig;
352 VoteInfo touchVoteInfo;
353 SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
354 STEP("1. pkg vote") {
355 multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
356 }
357 STEP("2. handle pkg1 touch event") {
358 HgmMultiAppStrategy::TouchInfo touchInfo = {
359 .pkgName = pkgParams_[1].pkgName,
360 .touchState = TouchState::DOWN_STATE,
361 .upExpectFps = OLED_120_HZ,
362 };
363 multiAppStrategy_->HandleTouchInfo(touchInfo);
364 ASSERT_EQ(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
365 ASSERT_EQ(touchVoteInfo.min, downFps1);
366 ASSERT_EQ(touchVoteInfo.max, downFps1);
367
368 touchInfo = {
369 .touchState = TouchState::UP_STATE,
370 };
371 multiAppStrategy_->HandleTouchInfo(touchInfo);
372 touchInfo = {
373 .touchState = TouchState::IDLE_STATE,
374 };
375 multiAppStrategy_->HandleTouchInfo(touchInfo);
376 ASSERT_NE(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
377 }
378 }
379 }
380
381 /**
382 * @tc.name: MultiAppTouch003
383 * @tc.desc: Verify the result of MultiAppTouch function
384 * @tc.type: FUNC
385 * @tc.require:
386 */
387 HWTEST_F(HgmMultiAppStrategyTest, MultiAppTouch003, Function | SmallTest | Level1)
388 {
389 PART("CaseDescription") {
390 PolicyConfigData::StrategyConfig strategyConfig;
391 VoteInfo touchVoteInfo;
392 SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
393 STEP("1. pkg vote") {
394 multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
395 }
396 STEP("2. handle empty pkg touch event") {
397 HgmMultiAppStrategy::TouchInfo touchInfo = {
398 .pkgName = otherPkgName,
399 .touchState = TouchState::DOWN_STATE,
400 .upExpectFps = OLED_120_HZ,
401 };
402 multiAppStrategy_->HandleTouchInfo(touchInfo);
403 ASSERT_EQ(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
404 ASSERT_EQ(touchVoteInfo.min, OLED_144_HZ);
405 ASSERT_EQ(touchVoteInfo.max, OLED_144_HZ);
406
407 touchInfo = {
408 .touchState = TouchState::UP_STATE,
409 };
410 multiAppStrategy_->HandleTouchInfo(touchInfo);
411 touchInfo = {
412 .touchState = TouchState::IDLE_STATE,
413 };
414 multiAppStrategy_->HandleTouchInfo(touchInfo);
415 ASSERT_NE(GetTouchVoteInfo(touchVoteInfo), EXEC_SUCCESS);
416 }
417 }
418 }
419
420 /**
421 * @tc.name: UseStrategyNum
422 * @tc.desc: Verify the result of UseStrategyNum function
423 * @tc.type: FUNC
424 * @tc.require:
425 */
426 HWTEST_F(HgmMultiAppStrategyTest, UseStrategyNum, Function | SmallTest | Level1)
427 {
428 PART("CaseDescription") {
429 PolicyConfigData::StrategyConfig strategyConfig;
430 SetMultiAppStrategy(MultiAppStrategyType::USE_STRATEGY_NUM, "110");
431 STEP("1. handle 2 packages") {
432 multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
433 multiAppStrategy_->GetVoteRes(strategyConfig);
434 ASSERT_EQ(strategyConfig.min, fps0);
435 ASSERT_EQ(strategyConfig.max, fps0);
436 }
437 STEP("2. empty pkgs") {
438 multiAppStrategy_->HandlePkgsEvent({ pkgName1, otherPkgName });
439 multiAppStrategy_->GetVoteRes(strategyConfig);
440 ASSERT_EQ(strategyConfig.min, fps0);
441 ASSERT_EQ(strategyConfig.max, fps0);
442 }
443 }
444 }
445
446 /**
447 * @tc.name: FollowFocus
448 * @tc.desc: Verify the result of FollowFocus function
449 * @tc.type: FUNC
450 * @tc.require:
451 */
452 HWTEST_F(HgmMultiAppStrategyTest, FollowFocus, Function | SmallTest | Level1)
453 {
454 PART("CaseDescription") {
455 PolicyConfigData::StrategyConfig strategyConfig;
456 SetMultiAppStrategy(MultiAppStrategyType::FOLLOW_FOCUS);
457 STEP("1. handle 2 packages") {
458 multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
459 multiAppStrategy_->GetVoteRes(strategyConfig);
460
461 auto pkgParam = pkgParams_[0];
462 ASSERT_EQ(strategyConfig.min, pkgParam.fps);
463 ASSERT_EQ(strategyConfig.max, pkgParam.fps);
464 }
465 STEP("2. empty pkgs") {
466 multiAppStrategy_->HandlePkgsEvent({});
467 multiAppStrategy_->GetVoteRes(strategyConfig);
468 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
469 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
470 }
471 }
472 }
473
474 /**
475 * @tc.name: UseMax
476 * @tc.desc: Verify the result of UseMax function
477 * @tc.type: FUNC
478 * @tc.require:
479 */
480 HWTEST_F(HgmMultiAppStrategyTest, UseMax, Function | SmallTest | Level1)
481 {
482 PART("CaseDescription") {
483 PolicyConfigData::StrategyConfig strategyConfig;
484 SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
485 STEP("1. handle 2 packages") {
486 multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
487 multiAppStrategy_->GetVoteRes(strategyConfig);
488 ASSERT_EQ(strategyConfig.min, fps1);
489 ASSERT_EQ(strategyConfig.max, fps1);
490 }
491 STEP("2. empty pkgs") {
492 multiAppStrategy_->HandlePkgsEvent({});
493 multiAppStrategy_->GetVoteRes(strategyConfig);
494 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
495 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
496 }
497 }
498 }
499
500 /**
501 * @tc.name: AppType
502 * @tc.desc: Verify the result of AppType
503 * @tc.type: FUNC
504 * @tc.require:
505 */
506 HWTEST_F(HgmMultiAppStrategyTest, AppType, Function | SmallTest | Level1)
507 {
508 PART("CaseDescription") {
509 PolicyConfigData::StrategyConfig strategyConfig;
510 multiAppStrategy_->HandlePkgsEvent({ otherPkgName + ":" + defaultPidStr + ":" + std::to_string(appType0) });
511 multiAppStrategy_->GetVoteRes(strategyConfig);
512 ASSERT_EQ(strategyConfig.min, fps0);
513 ASSERT_EQ(strategyConfig.max, fps0);
514
515 multiAppStrategy_->HandlePkgsEvent({ otherPkgName + ":" + defaultPidStr + ":" + std::to_string(appType1) });
516 multiAppStrategy_->GetVoteRes(strategyConfig);
517 ASSERT_EQ(strategyConfig.min, fps1);
518 ASSERT_EQ(strategyConfig.max, fps1);
519 }
520 }
521
522 /**
523 * @tc.name: LightFactor
524 * @tc.desc: Verify the result of LightFactor
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 HWTEST_F(HgmMultiAppStrategyTest, LightFactor, Function | SmallTest | Level1)
529 {
530 PART("CaseDescription") {
531 PolicyConfigData::StrategyConfig strategyConfig;
532 multiAppStrategy_->GetVoteRes(strategyConfig);
533 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
534 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
535
536 STEP("1. normal strategy") {
537 multiAppStrategy_->isLtpo_ = true;
538 multiAppStrategy_->lowAmbientStatus_ = false;
539 multiAppStrategy_->HandleLightFactorStatus(LightFactorStatus::NORMAL_LOW);
540 multiAppStrategy_->GetVoteRes(strategyConfig);
541 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_120_HZ);
542 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
543
544 multiAppStrategy_->HandleLightFactorStatus(LightFactorStatus::NORMAL_HIGH);
545 multiAppStrategy_->GetVoteRes(strategyConfig);
546 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
547 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
548
549 multiAppStrategy_->lowAmbientStatus_ = true;
550 multiAppStrategy_->HandleLightFactorStatus(LightFactorStatus::NORMAL_LOW);
551 multiAppStrategy_->GetVoteRes(strategyConfig);
552 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
553 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
554
555 multiAppStrategy_->HandleLightFactorStatus(LightFactorStatus::NORMAL_HIGH);
556 multiAppStrategy_->GetVoteRes(strategyConfig);
557 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
558 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
559 }
560 STEP("2. brightness level strategy") {
561 multiAppStrategy_->isLtpo_ = false;
562 multiAppStrategy_->lowAmbientStatus_ = true;
563 multiAppStrategy_->HandleLightFactorStatus(LightFactorStatus::LOW_LEVEL);
564 multiAppStrategy_->GetVoteRes(strategyConfig);
565 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_120_HZ);
566 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
567
568 multiAppStrategy_->HandleLightFactorStatus(LightFactorStatus::MIDDLE_LEVEL);
569 multiAppStrategy_->GetVoteRes(strategyConfig);
570 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
571 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
572
573 multiAppStrategy_->HandleLightFactorStatus(LightFactorStatus::HIGH_LEVEL);
574 multiAppStrategy_->GetVoteRes(strategyConfig);
575 ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
576 ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
577 }
578 }
579 }
580
581 /**
582 * @tc.name: HandleLowAmbientStatus
583 * @tc.desc: Verify the result of HandleLowAmbientStatus
584 * @tc.type: FUNC
585 * @tc.require:
586 */
587 HWTEST_F(HgmMultiAppStrategyTest, HandleLowAmbientStatus, Function | SmallTest | Level1)
588 {
589 for (bool status : {false, true}) {
590 multiAppStrategy_->lowAmbientStatus_ = status;
591 multiAppStrategy_->HandleLowAmbientStatus(true);
592 ASSERT_EQ(multiAppStrategy_->lowAmbientStatus_, true);
593 }
594
595 for (bool status : {false, true}) {
596 multiAppStrategy_->lowAmbientStatus_ = status;
597 multiAppStrategy_->HandleLowAmbientStatus(false);
598 ASSERT_EQ(multiAppStrategy_->lowAmbientStatus_, false);
599 }
600 }
601
602 /**
603 * @tc.name: BackgroundApp
604 * @tc.desc: Verify the result of BackgroundApp
605 * @tc.type: FUNC
606 * @tc.require:
607 */
608 HWTEST_F(HgmMultiAppStrategyTest, BackgroundApp, Function | SmallTest | Level1)
609 {
610 constexpr int32_t gameType0 = 10046;
611 PART("CaseDescription") {
612 multiAppStrategy_->HandlePkgsEvent({ pkgName0 + ":" + std::to_string(pid0) });
613 auto foregroundPidAppMap = multiAppStrategy_->GetForegroundPidApp();
614 ASSERT_TRUE(foregroundPidAppMap.find(pid0) != foregroundPidAppMap.end());
615
616 multiAppStrategy_->HandlePkgsEvent({ pkgName1 + ":" + std::to_string(pid1) + ":" + std::to_string(gameType0) });
617 foregroundPidAppMap = multiAppStrategy_->GetForegroundPidApp();
618 auto backgroundPid = multiAppStrategy_->GetBackgroundPid();
619 ASSERT_TRUE(foregroundPidAppMap.find(pid0) == foregroundPidAppMap.end());
620 ASSERT_TRUE(foregroundPidAppMap.find(pid1) != foregroundPidAppMap.end());
621 ASSERT_TRUE(backgroundPid.Existed(pid0));
622 ASSERT_FALSE(backgroundPid.Existed(pid1));
623 }
624 }
625
626 /**
627 * @tc.name: CheckPackageInConfigList
628 * @tc.desc: Verify the result of CheckPackageInConfigList
629 * @tc.type: FUNC
630 * @tc.require: IAHFXD
631 */
632 HWTEST_F(HgmMultiAppStrategyTest, CheckPackageInConfigList, Function | SmallTest | Level1)
633 {
634 std::vector<std::string> pkgs = {"com.app10", "com.app15"};
635 multiAppStrategy_->CheckPackageInConfigList(pkgs);
636 ASSERT_EQ(pkgs[0], "com.app10");
637 }
638
639 /**
640 * @tc.name: SpecialBranch
641 * @tc.desc: Verify the result of SpecialBranch
642 * @tc.type: FUNC
643 * @tc.require: IAHFXD
644 */
645 HWTEST_F(HgmMultiAppStrategyTest, SpecialBranch, Function | SmallTest | Level1)
646 {
647 std::vector<std::string> pkgs0 = {"com.app10", "com.app15"};
648 std::vector<std::string> pkgs1 = {"com.app10"};
649 MultiAppStrategyType undefineType = static_cast<MultiAppStrategyType>(100);
650 auto multiAppStrategy = std::make_shared<HgmMultiAppStrategy>();
651
652 STEP("HandlePkgsEvent") {
653 multiAppStrategy->HandlePkgsEvent(pkgs0);
654 multiAppStrategy->HandlePkgsEvent(pkgs1);
655 multiAppStrategy->screenSettingCache_.multiAppStrategyType = undefineType;
656 multiAppStrategy->CalcVote();
657 }
658 STEP("HandlePkgsEvent") {
659 multiAppStrategy->HandlePkgsEvent(pkgs0);
660 multiAppStrategy->HandlePkgsEvent(pkgs1);
661 multiAppStrategy->screenSettingCache_.multiAppStrategyType = undefineType;
662 multiAppStrategy->CalcVote();
663 }
664 STEP("AnalyzePkgParam") {
665 multiAppStrategy->AnalyzePkgParam("com.app10");
666 multiAppStrategy->AnalyzePkgParam("com.app10:0");
667 multiAppStrategy->AnalyzePkgParam("com.app10:a"); // err pid
668 multiAppStrategy->AnalyzePkgParam("com.app10:0:0");
669 multiAppStrategy->AnalyzePkgParam("com.app10:0:a"); // err appType
670 auto [pkgName, pid, appType] = multiAppStrategy->AnalyzePkgParam("com.app10");
671 ASSERT_EQ(pkgName, "com.app10");
672 }
673 STEP("OnStrategyChange") {
__anone63228480202(const PolicyConfigData::StrategyConfig&) 674 multiAppStrategy->RegisterStrategyChangeCallback([] (const PolicyConfigData::StrategyConfig&) {});
675 multiAppStrategy->RegisterStrategyChangeCallback(nullptr);
676 multiAppStrategy->OnStrategyChange();
677 }
678 }
679
680 /**
681 * @tc.name: SetHgmAppStrategyConfig1
682 * @tc.desc: Verify the result of SetHgmAppStrategyConfig
683 * @tc.type: FUNC
684 * @tc.require: IAHFXD
685 */
686 HWTEST_F(HgmMultiAppStrategyTest, SetHgmAppStrategyConfig1, Function | SmallTest | Level1)
687 {
688 std::string pkg1 = "com.app10";
689 PolicyConfigData::StrategyConfig appStrategyConfig;
690 multiAppStrategy_->GetAppStrategyConfig(pkg1, appStrategyConfig);
691 ASSERT_EQ(appStrategyConfig.min, fps0);
692 ASSERT_EQ(appStrategyConfig.max, fps0);
693 ASSERT_EQ(appStrategyConfig.dynamicMode, DynamicModeType::TOUCH_ENABLED);
694 ASSERT_EQ(appStrategyConfig.isFactor, false);
695 ASSERT_EQ(appStrategyConfig.drawMin, OLED_NULL_HZ);
696 ASSERT_EQ(appStrategyConfig.drawMax, OLED_NULL_HZ);
697
698 std::vector<std::pair<std::string, std::string>> newConfig = {
699 {"min", "60"},
700 {"max", "120"},
701 {"dynamicMode", "0"},
702 {"isFactor", "1"},
703 {"drawMin", "60"},
704 {"drawMax", "120"},
705 {"test4", "60"},
706 {"test1", "0"},
707 {"errorKey", "1"},
708 };
709
710 multiAppStrategy_->SetAppStrategyConfig(pkg1, newConfig);
711 multiAppStrategy_->UpdateAppStrategyConfigCache();
712 multiAppStrategy_->GetAppStrategyConfig(pkg1, appStrategyConfig);
713 ASSERT_EQ(appStrategyConfig.min, OLED_60_HZ);
714 ASSERT_EQ(appStrategyConfig.max, OLED_120_HZ);
715 ASSERT_EQ(appStrategyConfig.dynamicMode, DynamicModeType::TOUCH_DISENABLED);
716 ASSERT_EQ(appStrategyConfig.isFactor, true);
717 ASSERT_EQ(appStrategyConfig.drawMin, OLED_60_HZ);
718 ASSERT_EQ(appStrategyConfig.drawMax, OLED_120_HZ);
719
720 std::vector<std::pair<std::string, std::string>> emptyConfig = {};
721 multiAppStrategy_->SetAppStrategyConfig(pkg1, emptyConfig);
722 multiAppStrategy_->UpdateAppStrategyConfigCache();
723 multiAppStrategy_->GetAppStrategyConfig(pkg1, appStrategyConfig);
724 ASSERT_EQ(appStrategyConfig.min, fps0);
725 ASSERT_EQ(appStrategyConfig.max, fps0);
726 ASSERT_EQ(appStrategyConfig.dynamicMode, DynamicModeType::TOUCH_ENABLED);
727 ASSERT_EQ(appStrategyConfig.isFactor, false);
728 ASSERT_EQ(appStrategyConfig.drawMin, OLED_NULL_HZ);
729 ASSERT_EQ(appStrategyConfig.drawMax, OLED_NULL_HZ);
730 }
731
732 /**
733 * @tc.name: SetHgmAppStrategyConfig2
734 * @tc.desc: Verify the result of SetHgmAppStrategyConfig
735 * @tc.type: FUNC
736 * @tc.require: IAHFXD
737 */
738 HWTEST_F(HgmMultiAppStrategyTest, SetHgmAppStrategyConfig2, Function | SmallTest | Level1)
739 {
740 std::string pkg1 = "com.app10";
741 PolicyConfigData::StrategyConfig appStrategyConfig;
742 multiAppStrategy_->GetAppStrategyConfig(pkg1, appStrategyConfig);
743 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test4"], OLED_NULL_HZ);
744 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test1"], OLED_90_HZ);
745 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test3"], OLED_120_HZ);
746 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test2"], OLED_NULL_HZ);
747 std::vector<std::pair<std::string, std::string>> newConfig = {
748 {"test4", "60"},
749 {"test1", "0"},
750 {"test3", "120"}
751 };
752 multiAppStrategy_->SetAppStrategyConfig(pkg1, newConfig);
753 multiAppStrategy_->UpdateAppStrategyConfigCache();
754 multiAppStrategy_->GetAppStrategyConfig(pkg1, appStrategyConfig);
755 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test4"], OLED_60_HZ);
756 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test1"], OLED_NULL_HZ);
757 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test3"], OLED_120_HZ);
758 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test2"], OLED_NULL_HZ);
759 std::vector<std::pair<std::string, std::string>> emptyConfig = {};
760 multiAppStrategy_->SetAppStrategyConfig("", emptyConfig);
761 multiAppStrategy_->UpdateAppStrategyConfigCache();
762 multiAppStrategy_->GetAppStrategyConfig(pkg1, appStrategyConfig);
763 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test4"], OLED_NULL_HZ);
764 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test1"], OLED_90_HZ);
765 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test3"], OLED_120_HZ);
766 ASSERT_EQ(appStrategyConfig.bufferFpsMap["test2"], OLED_NULL_HZ);
767 }
768 } // namespace Rosen
769 } // namespace OHOS