1 /*
2 * Copyright (c) 2025 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_command.h"
21 #include "hgm_test_base.h"
22 #include "parameters.h"
23
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 class HgmCommandTest : public HgmTestBase {
31 public:
SetUpTestCase()32 static void SetUpTestCase()
33 {
34 HgmTestBase::SetUpTestCase();
35 }
TearDownTestCase()36 static void TearDownTestCase() {}
37 void SetUp();
TearDown()38 void TearDown() {}
39 void LoadXmlContent1();
40 std::shared_ptr<PolicyConfigVisitorImpl> visitor_;
41 };
42
SetUp()43 void HgmCommandTest::SetUp()
44 {
45 auto& hgmCore = HgmCore::Instance();
46 visitor_ = std::make_shared<PolicyConfigVisitorImpl>(*hgmCore.mPolicyConfigData_);
47 }
48
LoadXmlContent1()49 void HgmCommandTest::LoadXmlContent1()
50 {
51 // test xml file TEST_XML_CONTENT_1;
52 auto& hgmCore = HgmCore::Instance();
53 std::unique_ptr<XMLParser> parser = std::make_unique<XMLParser>();
54 parser->mParsedData_ = std::make_unique<PolicyConfigData>();
55 ASSERT_NE(parser->mParsedData_, nullptr);
56 parser->xmlDocument_ = StringToXmlDoc(TEST_XML_CONTENT_1);
57 ASSERT_NE(parser->xmlDocument_, nullptr);
58 parser->Parse();
59 hgmCore.mPolicyConfigData_ = parser->GetParsedData();
60 hgmCore.mParser_ = std::move(parser);
61 visitor_ = std::make_shared<PolicyConfigVisitorImpl>(*hgmCore.mPolicyConfigData_);
62 }
63
64 /**
65 * @tc.name: Init001
66 * @tc.desc: Verify the result of Init001 function
67 * @tc.type: FUNC
68 * @tc.require:
69 */
70 HWTEST_F(HgmCommandTest, Init001, Function | SmallTest | Level0)
71 {
72 auto& hgmCore = HgmCore::Instance();
73 hgmCore.InitXmlConfig();
74 auto frameRateMgr = hgmCore.GetFrameRateMgr();
75 ASSERT_NE(frameRateMgr, nullptr);
76
77 // bk
78 auto configData = hgmCore.mPolicyConfigData_;
79 ASSERT_NE(configData, nullptr);
80 auto configVisitor = hgmCore.mPolicyConfigVisitor_;
81 ASSERT_NE(configVisitor, nullptr);
82 auto configVisitorImpl = static_cast<PolicyConfigVisitorImpl*>(configVisitor.get());
83 ASSERT_NE(configVisitorImpl, nullptr);
84
85 // data not null; visitor not null
86 frameRateMgr->HandleScreenFrameRate("");
87 frameRateMgr->Init(nullptr, nullptr, nullptr, nullptr);
88 frameRateMgr->HandleAppStrategyConfigEvent(1, "", {}); // pid=1
89 EXPECT_EQ(&(configVisitorImpl->GetXmlData()), configData.get());
90 EXPECT_EQ(configVisitorImpl->xmlModeId_, std::to_string(hgmCore.customFrameRateMode_));
91 EXPECT_EQ(configVisitorImpl->screenConfigType_, frameRateMgr->curScreenStrategyId_);
92
93 // data null; visitor null
94 hgmCore.mPolicyConfigData_ = nullptr;
95 hgmCore.mPolicyConfigVisitor_ = nullptr;
96 frameRateMgr->screenExtStrategyMap_ = HGM_CONFIG_SCREENEXT_STRATEGY_MAP;
97 frameRateMgr->curScreenStrategyId_ = "10"; // id donot existed
98 frameRateMgr->HandleScreenExtStrategyChange(false, HGM_CONFIG_TYPE_THERMAL_SUFFIX);
99 frameRateMgr->HandleScreenFrameRate("");
100 frameRateMgr->Init(nullptr, nullptr, nullptr, nullptr);
101 hgmCore.SetRefreshRateMode(-2); // mode donot existed
102 hgmCore.InitXmlConfig();
103
104 // data not null; visitor null
105 hgmCore.mPolicyConfigData_ = configData;
106 hgmCore.mPolicyConfigVisitor_ = nullptr;
107 frameRateMgr->HandleScreenFrameRate("");
108 frameRateMgr->Init(nullptr, nullptr, nullptr, nullptr);
109
110 // data null; visitor not null
111 hgmCore.mPolicyConfigVisitor_ = configVisitor;
112 hgmCore.mPolicyConfigData_ = nullptr;
113 hgmCore.SetRefreshRateMode(-2); // mode donot existed
114 frameRateMgr->screenExtStrategyMap_ = HGM_CONFIG_SCREENEXT_STRATEGY_MAP;
115 frameRateMgr->curScreenStrategyId_ = "11"; // donot existed id
116 frameRateMgr->HandleScreenExtStrategyChange(false, HGM_CONFIG_TYPE_THERMAL_SUFFIX);
117 frameRateMgr->HandleScreenFrameRate("");
118 frameRateMgr->Init(nullptr, nullptr, nullptr, nullptr);
119
120 // test xmlCompatibleMode_ equal false
121 hgmCore.mPolicyConfigData_ = configData;
122 hgmCore.mPolicyConfigVisitor_ = configVisitor;
123 configData->xmlCompatibleMode_ = false;
124 frameRateMgr->Init(nullptr, nullptr, nullptr, nullptr);
125 // recovery
126 hgmCore.mPolicyConfigData_ = configData;
127 hgmCore.mPolicyConfigVisitor_ = configVisitor;
128 }
129
130 /**
131 * @tc.name: SimpleGet
132 * @tc.desc: Verify the result of SimpleGet function
133 * @tc.type: FUNC
134 * @tc.require:
135 */
136 HWTEST_F(HgmCommandTest, SimpleGet, Function | SmallTest | Level0)
137 {
138 auto dynamicSettingMap = visitor_->GetAceSceneDynamicSettingMap();
139 EXPECT_NE(dynamicSettingMap.find("aaa"), dynamicSettingMap.end());
140
141 // pkgName, nodeName
142 EXPECT_EQ(visitor_->GetGameNodeName("bbb"), "12");
143 EXPECT_EQ(visitor_->GetGameNodeName("aaa"), "");
144
145 visitor_->ChangeScreen("LTPS-DEFAULT");
146 EXPECT_EQ(visitor_->screenConfigType_, "LTPS-DEFAULT");
147 }
148
149 /**
150 * @tc.name: GetRefreshRateModeName
151 * @tc.desc: Verify the result of GetRefreshRateModeName function
152 * @tc.type: FUNC
153 * @tc.require:
154 */
155 HWTEST_F(HgmCommandTest, GetRefreshRateModeName, Function | SmallTest | Level0)
156 {
157 std::vector<std::pair<int32_t, int32_t>> testCase = {
158 // <refreshRateModeId, fps>
159 { -1, -1 },
160 { 1, OLED_60_HZ },
161 { 2, OLED_120_HZ },
162 { 3, 0 },
163 };
164 for (const auto& [refreshRateModeId, fps] : testCase) {
165 EXPECT_EQ(visitor_->GetRefreshRateModeName(refreshRateModeId), fps);
166 }
167 }
168
169 /**
170 * @tc.name: XmlModeId2SettingModeId
171 * @tc.desc: Verify the result of XmlModeId2SettingModeId function
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 HWTEST_F(HgmCommandTest, XmlModeId2SettingModeId, Function | SmallTest | Level0)
176 {
177 std::vector<std::pair<std::string, std::optional<int32_t>>> testCase = {
178 // <xmlModeId, settingModeId>
179 { "-1", -1 },
180 { "0", std::optional<int32_t>() },
181 { "1", 1 },
182 { "2", 2 },
183 { "3", std::optional<int32_t>() },
184 { "0", std::optional<int32_t>() },
185 };
186 for (const auto& [xmlModeId, settingModeId] : testCase) {
187 EXPECT_EQ(visitor_->XmlModeId2SettingModeId(xmlModeId), settingModeId);
188 }
189
190 // for no auto mode test
191 using namespace std;
192 auto& hgmCore = HgmCore::Instance();
193 hgmCore.InitXmlConfig();
194 LoadXmlContent1();
195 EXPECT_NE(hgmCore.mPolicyConfigData_, nullptr);
196 vector<pair<int32_t, int32_t>> noAutoConfig = {
197 {60, 101},
198 {120, 102}
199 };
200 hgmCore.mPolicyConfigData_->UpdateRefreshRateForSettings("testmode_no_auto");
201 EXPECT_EQ(visitor_->configData_.refreshRateForSettings_.size(), noAutoConfig.size());
202 for (size_t i = 0; i < noAutoConfig.size(); ++i) {
203 EXPECT_EQ(noAutoConfig[i], visitor_->configData_.refreshRateForSettings_[i]);
204 }
205 testCase = {
206 { "-1", std::optional<int32_t>() },
207 { "0", std::optional<int32_t>() },
208 { "101", 1 },
209 { "102", 2 },
210 { "3", std::optional<int32_t>() },
211 { "0", std::optional<int32_t>() },
212 };
213 for (const auto& [xmlModeId, settingModeId] : testCase) {
214 EXPECT_EQ(visitor_->XmlModeId2SettingModeId(xmlModeId), settingModeId);
215 }
216 hgmCore.mPolicyConfigData_->UpdateRefreshRateForSettings("");
217 }
218
219 /**
220 * @tc.name: SetSettingModeId
221 * @tc.desc: Verify the result of SetSettingModeId function
222 * @tc.type: FUNC
223 * @tc.require:
224 */
225 HWTEST_F(HgmCommandTest, SetSettingModeId, Function | SmallTest | Level0)
226 {
227 visitor_->SetSettingModeId(0);
228 EXPECT_EQ(visitor_->settingModeId_, 0);
229 visitor_->SetSettingModeId(0);
230 EXPECT_EQ(visitor_->settingModeId_, 0);
231 visitor_->SetSettingModeId(1);
232 EXPECT_EQ(visitor_->settingModeId_, 1);
233
234 visitor_->SetXmlModeId("0");
235 EXPECT_EQ(visitor_->xmlModeId_, "1");
236 visitor_->SetXmlModeId("0");
237 EXPECT_EQ(visitor_->xmlModeId_, "1");
238 visitor_->SetXmlModeId("1");
239 EXPECT_EQ(visitor_->xmlModeId_, "1");
240 visitor_->SetXmlModeId("-1");
241 EXPECT_EQ(visitor_->xmlModeId_, "-1");
242 visitor_->SetXmlModeId("-1");
243 EXPECT_EQ(visitor_->xmlModeId_, "-1");
244 }
245
246 /**
247 * @tc.name: GetScreenSetting
248 * @tc.desc: Verify the result of GetScreenSetting function
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(HgmCommandTest, GetScreenSetting, Function | SmallTest | Level0)
253 {
254 visitor_->screenConfigType_ = "unknown";
255 EXPECT_TRUE(visitor_->GetScreenSetting().appList.empty());
256
257 visitor_->screenConfigType_ = "LTPO-DEFAULT";
258 visitor_->xmlModeId_ = "5"; // id dont existed
259 EXPECT_TRUE(visitor_->GetScreenSetting().appList.empty());
260
261 visitor_->xmlModeId_ = "-1"; // auto mode
262 EXPECT_FALSE(visitor_->GetScreenSetting().appList.empty());
263 }
264
265 /**
266 * @tc.name: GetAppStrategyConfig
267 * @tc.desc: Verify the result of GetAppStrategyConfig function
268 * @tc.type: FUNC
269 * @tc.require:
270 */
271 HWTEST_F(HgmCommandTest, GetAppStrategyConfig, Function | SmallTest | Level0)
272 {
273 int32_t appType = 111;
274 int32_t appType1 = 222;
275 int32_t appType2 = 333;
276
277 PolicyConfigData::StrategyConfig settingStrategy;
278 // aaa/bbb means pkgName
279 EXPECT_EQ(visitor_->GetAppStrategyConfig("aaa", appType, settingStrategy), EXEC_SUCCESS);
280 EXPECT_EQ(visitor_->GetAppStrategyConfig("bbb", appType, settingStrategy), EXEC_SUCCESS);
281 EXPECT_EQ(visitor_->GetAppStrategyConfig("bbb", appType1, settingStrategy), EXEC_SUCCESS);
282 EXPECT_EQ(visitor_->GetAppStrategyConfig("bbb", appType2, settingStrategy), HGM_ERROR);
283 }
284
285 /**
286 * @tc.name: SetRefreshRateMode
287 * @tc.desc: Verify the result of SetRefreshRateMode function
288 * @tc.type: FUNC
289 * @tc.require:
290 */
291 HWTEST_F(HgmCommandTest, SetRefreshRateMode, Function | SmallTest | Level0)
292 {
293 const std::vector<std::tuple<int32_t, int32_t, std::string>> testCase = {
294 // -1:dynamic 1:standard 2:high
295 // <input, settingModeId, xmlModeId>
296 { -1, -1, "-1" },
297 { 0, 0, "-1" },
298 { 1, 1, "1" },
299 { 2, 2, "2" },
300 { -1, -1, "-1" },
301 { 2, 2, "2" },
302 { 0, 0, "-1" },
303 { 3, 0, "-1" },
304 };
305
306 auto& hgmCore = HgmCore::Instance();
307 hgmCore.InitXmlConfig();
308 auto configVisitorImpl = static_cast<PolicyConfigVisitorImpl*>(hgmCore.mPolicyConfigVisitor_.get());
309 ASSERT_NE(configVisitorImpl, nullptr);
310
311 for (const auto& [input, settingModeId, xmlModeId] : testCase) {
312 hgmCore.SetRefreshRateMode(input);
313 EXPECT_EQ(configVisitorImpl->settingModeId_, settingModeId);
314 EXPECT_EQ(configVisitorImpl->xmlModeId_, xmlModeId);
315 }
316 }
317
318 /**
319 * @tc.name: UpdateRefreshRateForSettings
320 * @tc.desc: Verify the result of UpdateRefreshRateForSettings function
321 * @tc.type: FUNC
322 * @tc.require:
323 */
324 HWTEST_F(HgmCommandTest, UpdateRefreshRateForSettings001, Function | SmallTest | Level0)
325 {
326 auto& hgmCore = HgmCore::Instance();
327 hgmCore.InitXmlConfig();
328 LoadXmlContent1();
329 // padmode
330 hgmCore.mPolicyConfigData_->UpdateRefreshRateForSettings("padmode");
331 const auto& settings = hgmCore.mPolicyConfigData_->refreshRateForSettings_;
332 std::vector<std::pair<int32_t, int32_t>> padSettings = {
333 {-1, -1}, {60, 1}, {120, 2}, {144, 3}
334 };
335 ASSERT_EQ(settings.size(), padSettings.size());
336 for (size_t i = 0; i < settings.size(); ++i) {
337 EXPECT_EQ(settings[i], padSettings[i]);
338 }
339 // pcmode
340 hgmCore.mPolicyConfigData_->UpdateRefreshRateForSettings("pcmode");
341 std::vector<std::pair<int32_t, int32_t>> pcSettings = {
342 {-1, -101}, {60, 101}, {120, 102}
343 };
344 ASSERT_EQ(settings.size(), pcSettings.size());
345 for (size_t i = 0; i < settings.size(); ++i) {
346 EXPECT_EQ(settings[i], pcSettings[i]);
347 }
348 // test unknowmode
349 auto originSettings = settings;
350 hgmCore.mPolicyConfigData_->UpdateRefreshRateForSettings("unknownMode");
351 ASSERT_EQ(settings.size(), originSettings.size());
352 for (size_t i = 0; i < settings.size(); ++i) {
353 EXPECT_EQ(settings[i], originSettings[i]);
354 }
355 }
356
357 /**
358 * @tc.name: AddParamWatcher
359 * @tc.desc: Verify the result of AddParamWatcher function
360 * @tc.type: FUNC
361 * @tc.require:
362 */
363 HWTEST_F(HgmCommandTest, AddParamWatcher001, Function | SmallTest | Level0)
364 {
365 auto& hgmCore = HgmCore::Instance();
366 auto ret = hgmCore.AddParamWatcher();
367 // 110 means already added in HgmCore::Instance()
368 EXPECT_EQ(ret, 110);
369 }
370
371 /**
372 * @tc.name: SysModeChangeProcess
373 * @tc.desc: Verify the result of SysModeChangeProcess function
374 * @tc.type: FUNC
375 * @tc.require:
376 */
377 HWTEST_F(HgmCommandTest, SysModeChangeProcess001, Function | SmallTest | Level0)
378 {
379 auto& hgmCore = HgmCore::Instance();
380 hgmCore.InitXmlConfig();
381 ASSERT_NE(hgmCore.mPolicyConfigData_, nullptr);
382 auto policyConfigData = reinterpret_cast<PolicyConfigData*>(hgmCore.mPolicyConfigData_.get());
383 EXPECT_NE(policyConfigData, nullptr);
384 HgmCore::SysModeChangeProcess("persist.sys.mode", "testmode", policyConfigData);
385
386 HgmCore::SysModeChangeProcess("persist.sys.mode", "testmode", nullptr);
387 }
388
389 /**
390 * @tc.name: SettingModeId2XmlModeId
391 * @tc.desc: Verify the result of SettingModeId2XmlModeId function
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 HWTEST_F(HgmCommandTest, SettingModeId2XmlModeId, Function | SmallTest | Level0)
396 {
397 using namespace std;
398 auto& hgmCore = HgmCore::Instance();
399 hgmCore.InitXmlConfig();
400 LoadXmlContent1();
401 // test when auto mode exists
402 EXPECT_NE(hgmCore.mPolicyConfigData_, nullptr);
403 hgmCore.mPolicyConfigData_->UpdateRefreshRateForSettings("pcmode");
404 vector<pair<int, optional<string>>> testConfig = {
405 {-1, "-101"},
406 {-10, optional<string>()},
407 {10, optional<string>()},
408 {2, "102"}
409 };
410 for (const auto& p : testConfig) {
411 auto ret = visitor_->SettingModeId2XmlModeId(p.first);
412 EXPECT_EQ(ret, p.second);
413 }
414 // no auto mode
415 hgmCore.mPolicyConfigData_->UpdateRefreshRateForSettings("testmode_no_auto");
416 testConfig = {
417 {-10, optional<string>()},
418 {-1, optional<string>()},
419 {10, optional<string>()},
420 {1, "101"},
421 {2, "102"}
422 };
423 for (const auto& p : testConfig) {
424 auto ret = visitor_->SettingModeId2XmlModeId(p.first);
425 EXPECT_EQ(ret, p.second);
426 }
427 }
428 } // namespace Rosen
429 } // namespace OHOS