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 
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace Rosen {
28 namespace {
29     constexpr int32_t nodeIdOffset = 32;
30     const std::string settingStrategyName = "99";
31     const std::string otherPkgName = "com.pkg.other";
32     const std::string defaultPidStr = "0";
33 
34     constexpr int32_t fps0 = 10;
35     constexpr int32_t downFps0 = 90;
36     constexpr int32_t pid0 = 10010;
37     const std::string strategyName0 = "110";
38     const std::string pkgName0 = "com.app10";
39     constexpr int32_t appType0 = 20010;
40 
41     constexpr int32_t fps1 = 15;
42     constexpr int32_t downFps1 = 120;
43     constexpr int32_t pid1 = 10015;
44     const std::string strategyName1 = "115";
45     const std::string pkgName1 = "com.app15";
46     constexpr int32_t appType1 = 20015;
47 }
48 
49 struct PkgParam {
50     std::string pkgName;
51     int32_t fps;
52     pid_t pid;
53     std::shared_ptr<RSRenderFrameRateLinker> linker;
54 };
55 
56 class HgmMultiAppStrategyTest : public testing::Test {
57 public:
SetUpTestCase()58     static void SetUpTestCase() {}
TearDownTestCase()59     static void TearDownTestCase() {}
60     void SetUp();
TearDown()61     void TearDown() {}
62     void SetMultiAppStrategy(MultiAppStrategyType multiAppStrategyType, const std::string& strategyName = "");
63     std::vector<std::string> CreateVotePkgs();
64 
65     std::vector<PkgParam> pkgParams_;
66     std::shared_ptr<HgmMultiAppStrategy> multiAppStrategy_;
67 };
68 
SetUp()69 void HgmMultiAppStrategyTest::SetUp()
70 {
71     multiAppStrategy_ = std::make_shared<HgmMultiAppStrategy>();
72     // init config
73     // set app config
74     auto strategyConfigs = multiAppStrategy_->GetStrategyConfigs();
75     auto screenSetting = multiAppStrategy_->GetScreenSetting();
76     auto &appTypes = screenSetting.appTypes;
77 
78     strategyConfigs[settingStrategyName] = { .min = OLED_NULL_HZ, .max = OLED_120_HZ, .down = OLED_144_HZ,
79         .dynamicMode = DynamicModeType::TOUCH_ENABLED, .isFactor = true };
80     screenSetting.strategy = settingStrategyName;
81 
82     strategyConfigs[strategyName0] = { .min = fps0, .max = fps0, .dynamicMode = DynamicModeType::TOUCH_ENABLED,
83         .drawMin = OLED_NULL_HZ, .drawMax = OLED_NULL_HZ, .down = downFps0 };
84     screenSetting.appList[pkgName0] = strategyName0;
85     pkgParams_.push_back({ .pkgName = pkgName0, .fps = fps0, .pid = pid0,
86         .linker = std::make_shared<RSRenderFrameRateLinker>(((NodeId)pid0) << nodeIdOffset) });
87 
88     strategyConfigs[strategyName1] = { .min = fps1, .max = fps1, .dynamicMode = DynamicModeType::TOUCH_ENABLED,
89         .drawMin = OLED_NULL_HZ, .drawMax = OLED_NULL_HZ, .down = downFps1 };
90     screenSetting.appList[pkgName1] = strategyName1;
91     pkgParams_.push_back({ .pkgName = pkgName1, .fps = fps1, .pid = pid1,
92         .linker = std::make_shared<RSRenderFrameRateLinker>(((NodeId)pid1) << nodeIdOffset) });
93 
94     for (auto &pkgParam : pkgParams_) {
95         pkgParam.linker->SetExpectedRange(FrameRateRange(OLED_NULL_HZ, RANGE_MAX_REFRESHRATE, OLED_NULL_HZ));
96     }
97 
98     appTypes[appType0] = strategyName0;
99     appTypes[appType1] = strategyName1;
100     multiAppStrategy_->SetStrategyConfigs(strategyConfigs);
101     multiAppStrategy_->SetScreenSetting(screenSetting);
102 }
103 
SetMultiAppStrategy(MultiAppStrategyType multiAppStrategyType,const std::string & strategyName)104 void HgmMultiAppStrategyTest::SetMultiAppStrategy(
105     MultiAppStrategyType multiAppStrategyType, const std::string& strategyName)
106 {
107     auto screenSetting = multiAppStrategy_->GetScreenSetting();
108     screenSetting.multiAppStrategyType = multiAppStrategyType;
109     screenSetting.multiAppStrategyName = strategyName;
110     multiAppStrategy_->SetScreenSetting(screenSetting);
111 }
112 
CreateVotePkgs()113 std::vector<std::string> HgmMultiAppStrategyTest::CreateVotePkgs()
114 {
115     std::vector<std::string> pkgs;
116     for (auto &pkgParam : pkgParams_) {
117         pkgs.push_back(pkgParam.pkgName + ":" + std::to_string(pkgParam.pid));
118     }
119     return pkgs;
120 }
121 
122 /**
123  * @tc.name: SingleAppTouch001
124  * @tc.desc: Verify the result of SingleAppTouch001 function
125  * @tc.type: FUNC
126  * @tc.require:
127  */
128 HWTEST_F(HgmMultiAppStrategyTest, SingleAppTouch001, Function | SmallTest | Level1)
129 {
130     PART("CaseDescription") {
131         auto &pkgParam = pkgParams_[0]; // first pkg
132         std::vector<std::string> voteParam = { pkgParam.pkgName + ":" + std::to_string(pkgParam.pid), };
133 
134         PolicyConfigData::StrategyConfig strategyConfig;
135         HgmErrCode res;
136         SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
137 
138         STEP("1. pkg vote") {
139             multiAppStrategy_->HandlePkgsEvent(voteParam);
140             res = multiAppStrategy_->GetVoteRes(strategyConfig);
141             ASSERT_EQ(res, EXEC_SUCCESS);
142             ASSERT_EQ(strategyConfig.min, fps0);
143             ASSERT_EQ(strategyConfig.max, fps0);
144         }
145         STEP("2. handle touch event") {
146             HgmMultiAppStrategy::TouchInfo touchInfo = {
147                 .pkgName = pkgParam.pkgName,
148                 .touchState = TouchState::DOWN_STATE,
149                 .upExpectFps = OLED_120_HZ,
150             };
151             multiAppStrategy_->HandleTouchInfo(touchInfo);
152             res = multiAppStrategy_->GetVoteRes(strategyConfig);
153             ASSERT_EQ(res, EXEC_SUCCESS);
154             ASSERT_EQ(strategyConfig.min, downFps0);
155             ASSERT_EQ(strategyConfig.max, downFps0);
156 
157             touchInfo = {
158                 .touchState = TouchState::UP_STATE,
159             };
160             multiAppStrategy_->HandleTouchInfo(touchInfo);
161             res = multiAppStrategy_->GetVoteRes(strategyConfig);
162             ASSERT_EQ(res, EXEC_SUCCESS);
163             ASSERT_EQ(strategyConfig.min, fps0);
164             ASSERT_EQ(strategyConfig.max, fps0);
165 
166             touchInfo = {
167                 .touchState = TouchState::IDLE_STATE,
168             };
169             multiAppStrategy_->HandleTouchInfo(touchInfo);
170             res = multiAppStrategy_->GetVoteRes(strategyConfig);
171             ASSERT_EQ(res, EXEC_SUCCESS);
172             ASSERT_EQ(strategyConfig.min, fps0);
173             ASSERT_EQ(strategyConfig.max, fps0);
174         }
175     }
176 }
177 
178 /**
179  * @tc.name: SingleAppTouch002
180  * @tc.desc: Verify the result of SingleAppTouch002 function
181  * @tc.type: FUNC
182  * @tc.require:
183  */
184 HWTEST_F(HgmMultiAppStrategyTest, SingleAppTouch002, Function | SmallTest | Level1)
185 {
186     PART("CaseDescription") {
187         std::string unConfigPkgName = "com.pkg.other";
188         auto &pkgParam = pkgParams_[0]; // first pkg
189         std::vector<std::string> voteParam = { pkgParam.pkgName + ":" + std::to_string(pkgParam.pid), };
190 
191         PolicyConfigData::StrategyConfig strategyConfig;
192         HgmErrCode res;
193         SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
194 
195         STEP("1. pkg vote") {
196             multiAppStrategy_->HandlePkgsEvent(voteParam);
197             res = multiAppStrategy_->GetVoteRes(strategyConfig);
198             ASSERT_EQ(res, EXEC_SUCCESS);
199             ASSERT_EQ(strategyConfig.min, fps0);
200             ASSERT_EQ(strategyConfig.max, fps0);
201         }
202         STEP("2. click other pkg which hasn't config") {
203             HgmMultiAppStrategy::TouchInfo touchInfo = {
204                 .pkgName = unConfigPkgName,
205                 .touchState = TouchState::DOWN_STATE,
206                 .upExpectFps = OLED_120_HZ,
207             };
208             multiAppStrategy_->HandleTouchInfo(touchInfo);
209             res = multiAppStrategy_->GetVoteRes(strategyConfig);
210             ASSERT_EQ(res, EXEC_SUCCESS);
211             ASSERT_EQ(strategyConfig.min, OLED_144_HZ);
212             ASSERT_EQ(strategyConfig.max, OLED_144_HZ);
213             touchInfo = {
214                 .touchState = TouchState::UP_STATE,
215             };
216             multiAppStrategy_->HandleTouchInfo(touchInfo);
217             touchInfo = {
218                 .touchState = TouchState::IDLE_STATE,
219             };
220             multiAppStrategy_->HandleTouchInfo(touchInfo);
221             res = multiAppStrategy_->GetVoteRes(strategyConfig);
222             ASSERT_EQ(res, EXEC_SUCCESS);
223         }
224     }
225 }
226 
227 /**
228  * @tc.name: SingleAppTouch003
229  * @tc.desc: Verify the result of SingleAppTouch003 function
230  * @tc.type: FUNC
231  * @tc.require:
232  */
233 HWTEST_F(HgmMultiAppStrategyTest, SingleAppTouch003, Function | SmallTest | Level1)
234 {
235     PART("CaseDescription") {
236         std::string unConfigPkgName = "com.pkg.other";
237         auto &pkgParam = pkgParams_[0]; // first pkg
238         std::vector<std::string> voteParam = { pkgParam.pkgName + ":" + std::to_string(pkgParam.pid), };
239 
240         PolicyConfigData::StrategyConfig strategyConfig;
241         HgmErrCode res;
242         SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
243 
244         STEP("1. pkg vote") {
245             multiAppStrategy_->HandlePkgsEvent(voteParam);
246         }
247         STEP("2. start other pkg which hasn't config") {
248             res = multiAppStrategy_->HandlePkgsEvent({});
249             ASSERT_EQ(res, EXEC_SUCCESS);
250             multiAppStrategy_->HandlePkgsEvent({ unConfigPkgName, });
251             ASSERT_EQ(res, EXEC_SUCCESS);
252             res = multiAppStrategy_->GetVoteRes(strategyConfig);
253             ASSERT_EQ(res, EXEC_SUCCESS);
254             ASSERT_EQ(strategyConfig.min, OLED_NULL_HZ);
255             ASSERT_EQ(strategyConfig.max, OLED_120_HZ);
256 
257             HgmMultiAppStrategy::TouchInfo touchInfo = {
258                 .pkgName = unConfigPkgName,
259                 .touchState = TouchState::DOWN_STATE,
260                 .upExpectFps = OLED_120_HZ,
261             };
262             multiAppStrategy_->HandleTouchInfo(touchInfo);
263             res = multiAppStrategy_->GetVoteRes(strategyConfig);
264             ASSERT_EQ(res, EXEC_SUCCESS);
265             ASSERT_EQ(strategyConfig.min, OLED_144_HZ);
266             ASSERT_EQ(strategyConfig.max, OLED_144_HZ);
267 
268             touchInfo = {
269                 .touchState = TouchState::UP_STATE,
270             };
271             multiAppStrategy_->HandleTouchInfo(touchInfo);
272             touchInfo = {
273                 .touchState = TouchState::IDLE_STATE,
274             };
275             multiAppStrategy_->HandleTouchInfo(touchInfo);
276             res = multiAppStrategy_->GetVoteRes(strategyConfig);
277             ASSERT_EQ(res, EXEC_SUCCESS);
278             ASSERT_EQ(strategyConfig.min, OLED_NULL_HZ);
279             ASSERT_EQ(strategyConfig.max, OLED_120_HZ);
280         }
281     }
282 }
283 
284 /**
285  * @tc.name: MultiAppTouch001
286  * @tc.desc: Verify the result of MultiAppTouch function
287  * @tc.type: FUNC
288  * @tc.require:
289  */
290 HWTEST_F(HgmMultiAppStrategyTest, MultiAppTouch001, Function | SmallTest | Level1)
291 {
292     PART("CaseDescription") {
293         PolicyConfigData::StrategyConfig strategyConfig;
294         SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
295         STEP("1. pkg vote") {
296             multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
297             multiAppStrategy_->GetVoteRes(strategyConfig);
298             ASSERT_EQ(strategyConfig.min, fps1);
299             ASSERT_EQ(strategyConfig.max, fps1);
300         }
301         STEP("2. handle pkg0 touch event") {
302             HgmMultiAppStrategy::TouchInfo touchInfo = {
303                 .pkgName = pkgParams_[0].pkgName,
304                 .touchState = TouchState::DOWN_STATE,
305                 .upExpectFps = OLED_120_HZ,
306             };
307             multiAppStrategy_->HandleTouchInfo(touchInfo);
308             multiAppStrategy_->GetVoteRes(strategyConfig);
309             ASSERT_EQ(strategyConfig.min, downFps0);
310             ASSERT_EQ(strategyConfig.max, downFps0);
311 
312             touchInfo = {
313                 .touchState = TouchState::UP_STATE,
314             };
315             multiAppStrategy_->HandleTouchInfo(touchInfo);
316             touchInfo = {
317                 .touchState = TouchState::IDLE_STATE,
318             };
319             multiAppStrategy_->HandleTouchInfo(touchInfo);
320 
321             multiAppStrategy_->GetVoteRes(strategyConfig);
322             ASSERT_EQ(strategyConfig.min, fps1);
323             ASSERT_EQ(strategyConfig.max, fps1);
324         }
325     }
326 }
327 
328 /**
329  * @tc.name: MultiAppTouch002
330  * @tc.desc: Verify the result of MultiAppTouch function
331  * @tc.type: FUNC
332  * @tc.require:
333  */
334 HWTEST_F(HgmMultiAppStrategyTest, MultiAppTouch002, Function | SmallTest | Level1)
335 {
336     PART("CaseDescription") {
337         PolicyConfigData::StrategyConfig strategyConfig;
338         SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
339         STEP("1. pkg vote") {
340             multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
341         }
342         STEP("2. handle pkg1 touch event") {
343             HgmMultiAppStrategy::TouchInfo touchInfo = {
344                 .pkgName = pkgParams_[1].pkgName,
345                 .touchState = TouchState::DOWN_STATE,
346                 .upExpectFps = OLED_120_HZ,
347             };
348             multiAppStrategy_->HandleTouchInfo(touchInfo);
349             multiAppStrategy_->GetVoteRes(strategyConfig);
350             ASSERT_EQ(strategyConfig.min, downFps1);
351             ASSERT_EQ(strategyConfig.max, downFps1);
352 
353             touchInfo = {
354                 .touchState = TouchState::UP_STATE,
355             };
356             multiAppStrategy_->HandleTouchInfo(touchInfo);
357             touchInfo = {
358                 .touchState = TouchState::IDLE_STATE,
359             };
360             multiAppStrategy_->HandleTouchInfo(touchInfo);
361 
362             multiAppStrategy_->GetVoteRes(strategyConfig);
363             ASSERT_EQ(strategyConfig.min, fps1);
364             ASSERT_EQ(strategyConfig.max, fps1);
365         }
366     }
367 }
368 
369 /**
370  * @tc.name: MultiAppTouch003
371  * @tc.desc: Verify the result of MultiAppTouch function
372  * @tc.type: FUNC
373  * @tc.require:
374  */
375 HWTEST_F(HgmMultiAppStrategyTest, MultiAppTouch003, Function | SmallTest | Level1)
376 {
377     PART("CaseDescription") {
378         PolicyConfigData::StrategyConfig strategyConfig;
379         SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
380         STEP("1. pkg vote") {
381             multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
382         }
383         STEP("2. handle empty pkg touch event") {
384             HgmMultiAppStrategy::TouchInfo touchInfo = {
385                 .pkgName = otherPkgName,
386                 .touchState = TouchState::DOWN_STATE,
387                 .upExpectFps = OLED_120_HZ,
388             };
389             multiAppStrategy_->HandleTouchInfo(touchInfo);
390             multiAppStrategy_->GetVoteRes(strategyConfig);
391             ASSERT_EQ(strategyConfig.min, OLED_144_HZ);
392             ASSERT_EQ(strategyConfig.max, OLED_144_HZ);
393 
394             touchInfo = {
395                 .touchState = TouchState::UP_STATE,
396             };
397             multiAppStrategy_->HandleTouchInfo(touchInfo);
398             touchInfo = {
399                 .touchState = TouchState::IDLE_STATE,
400             };
401             multiAppStrategy_->HandleTouchInfo(touchInfo);
402 
403             multiAppStrategy_->GetVoteRes(strategyConfig);
404             ASSERT_EQ(strategyConfig.min, fps1);
405             ASSERT_EQ(strategyConfig.max, fps1);
406         }
407     }
408 }
409 
410 /**
411  * @tc.name: UseStrategyNum
412  * @tc.desc: Verify the result of UseStrategyNum function
413  * @tc.type: FUNC
414  * @tc.require:
415  */
416 HWTEST_F(HgmMultiAppStrategyTest, UseStrategyNum, Function | SmallTest | Level1)
417 {
418     PART("CaseDescription") {
419         PolicyConfigData::StrategyConfig strategyConfig;
420         SetMultiAppStrategy(MultiAppStrategyType::USE_STRATEGY_NUM, "110");
421         STEP("1. handle 2 packages") {
422             multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
423             multiAppStrategy_->GetVoteRes(strategyConfig);
424             ASSERT_EQ(strategyConfig.min, fps0);
425             ASSERT_EQ(strategyConfig.max, fps0);
426         }
427         STEP("2. empty pkgs") {
428             multiAppStrategy_->HandlePkgsEvent({ pkgName1, otherPkgName });
429             multiAppStrategy_->GetVoteRes(strategyConfig);
430             ASSERT_EQ(strategyConfig.min, fps0);
431             ASSERT_EQ(strategyConfig.max, fps0);
432         }
433     }
434 }
435 
436 /**
437  * @tc.name: FollowFocus
438  * @tc.desc: Verify the result of FollowFocus function
439  * @tc.type: FUNC
440  * @tc.require:
441  */
442 HWTEST_F(HgmMultiAppStrategyTest, FollowFocus, Function | SmallTest | Level1)
443 {
444     PART("CaseDescription") {
445         PolicyConfigData::StrategyConfig strategyConfig;
446         SetMultiAppStrategy(MultiAppStrategyType::FOLLOW_FOCUS);
447         STEP("1. handle 2 packages") {
448             multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
449             multiAppStrategy_->GetVoteRes(strategyConfig);
450 
451             auto pkgParam = pkgParams_[0];
452             ASSERT_EQ(strategyConfig.min, pkgParam.fps);
453             ASSERT_EQ(strategyConfig.max, pkgParam.fps);
454         }
455         STEP("2. empty pkgs") {
456             multiAppStrategy_->HandlePkgsEvent({});
457             multiAppStrategy_->GetVoteRes(strategyConfig);
458             ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
459             ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
460         }
461     }
462 }
463 
464 /**
465  * @tc.name: UseMax
466  * @tc.desc: Verify the result of UseMax function
467  * @tc.type: FUNC
468  * @tc.require:
469  */
470 HWTEST_F(HgmMultiAppStrategyTest, UseMax, Function | SmallTest | Level1)
471 {
472     PART("CaseDescription") {
473     PolicyConfigData::StrategyConfig strategyConfig;
474     SetMultiAppStrategy(MultiAppStrategyType::USE_MAX);
475         STEP("1. handle 2 packages") {
476             multiAppStrategy_->HandlePkgsEvent(CreateVotePkgs());
477             multiAppStrategy_->GetVoteRes(strategyConfig);
478             ASSERT_EQ(strategyConfig.min, fps1);
479             ASSERT_EQ(strategyConfig.max, fps1);
480         }
481         STEP("2. empty pkgs") {
482             multiAppStrategy_->HandlePkgsEvent({});
483             multiAppStrategy_->GetVoteRes(strategyConfig);
484             ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
485             ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
486         }
487     }
488 }
489 
490 /**
491  * @tc.name: AppType
492  * @tc.desc: Verify the result of AppType
493  * @tc.type: FUNC
494  * @tc.require:
495  */
496 HWTEST_F(HgmMultiAppStrategyTest, AppType, Function | SmallTest | Level1)
497 {
498     PART("CaseDescription") {
499         PolicyConfigData::StrategyConfig strategyConfig;
500         multiAppStrategy_->HandlePkgsEvent({ otherPkgName + ":" + defaultPidStr + ":" + std::to_string(appType0) });
501         multiAppStrategy_->GetVoteRes(strategyConfig);
502         ASSERT_EQ(strategyConfig.min, fps0);
503         ASSERT_EQ(strategyConfig.max, fps0);
504 
505         multiAppStrategy_->HandlePkgsEvent({ otherPkgName + ":" + defaultPidStr + ":" + std::to_string(appType1) });
506         multiAppStrategy_->GetVoteRes(strategyConfig);
507         ASSERT_EQ(strategyConfig.min, fps1);
508         ASSERT_EQ(strategyConfig.max, fps1);
509     }
510 }
511 
512 /**
513  * @tc.name: LightFactor
514  * @tc.desc: Verify the result of LightFactor
515  * @tc.type: FUNC
516  * @tc.require:
517  */
518 HWTEST_F(HgmMultiAppStrategyTest, LightFactor, Function | SmallTest | Level1)
519 {
520     PART("CaseDescription") {
521         PolicyConfigData::StrategyConfig strategyConfig;
522         multiAppStrategy_->GetVoteRes(strategyConfig);
523         ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
524         ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
525 
526         multiAppStrategy_->HandleLightFactorStatus(true);
527         multiAppStrategy_->GetVoteRes(strategyConfig);
528         ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_120_HZ);
529         ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
530 
531         multiAppStrategy_->HandleLightFactorStatus(false);
532         multiAppStrategy_->GetVoteRes(strategyConfig);
533         ASSERT_EQ(strategyConfig.min, OledRefreshRate::OLED_NULL_HZ);
534         ASSERT_EQ(strategyConfig.max, OledRefreshRate::OLED_120_HZ);
535     }
536 }
537 
538 /**
539  * @tc.name: BackgroundApp
540  * @tc.desc: Verify the result of BackgroundApp
541  * @tc.type: FUNC
542  * @tc.require:
543  */
544 HWTEST_F(HgmMultiAppStrategyTest, BackgroundApp, Function | SmallTest | Level1)
545 {
546     constexpr int32_t gameType0 = 10046;
547     PART("CaseDescription") {
548         multiAppStrategy_->HandlePkgsEvent({ pkgName0 + ":" + std::to_string(pid0) });
549         auto foregroundPidAppMap = multiAppStrategy_->GetForegroundPidApp();
550         ASSERT_TRUE(foregroundPidAppMap.find(pid0) != foregroundPidAppMap.end());
551 
552         multiAppStrategy_->HandlePkgsEvent({ pkgName1 + ":" + std::to_string(pid1) + ":" + std::to_string(gameType0) });
553         foregroundPidAppMap = multiAppStrategy_->GetForegroundPidApp();
554         auto backgroundPid = multiAppStrategy_->GetBackgroundPid();
555         ASSERT_TRUE(foregroundPidAppMap.find(pid0) == foregroundPidAppMap.end());
556         ASSERT_TRUE(foregroundPidAppMap.find(pid1) != foregroundPidAppMap.end());
557         ASSERT_TRUE(backgroundPid.Existed(pid0));
558         ASSERT_FALSE(backgroundPid.Existed(pid1));
559     }
560 }
561 
562 /**
563  * @tc.name: CheckPackageInConfigList
564  * @tc.desc: Verify the result of CheckPackageInConfigList
565  * @tc.type: FUNC
566  * @tc.require: IAHFXD
567  */
568 HWTEST_F(HgmMultiAppStrategyTest, CheckPackageInConfigList, Function | SmallTest | Level1)
569 {
570     std::vector<std::string> pkgs = {"com.app10", "com.app15"};
571     multiAppStrategy_->CheckPackageInConfigList(pkgs);
572     ASSERT_EQ(pkgs[0], "com.app10");
573 }
574 
575 } // namespace Rosen
576 } // namespace OHOS