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