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 "common/rs_common_def.h" 21 #include "hgm_soft_vsync_manager.h" 22 #include "hgm_test_base.h" 23 #include "vsync_controller.h" 24 #include "vsync_generator.h" 25 26 using namespace testing; 27 using namespace testing::ext; 28 29 namespace OHOS { 30 namespace Rosen { 31 namespace { 32 constexpr int32_t frameRateLinkerId1 = 1; 33 constexpr int32_t frameRateLinkerId2 = 2; 34 constexpr int32_t frameRateLinkerId3 = 3; 35 constexpr int32_t frameRateLinkerId4 = 4; 36 constexpr int32_t frameRateLinkerId5 = 5; 37 constexpr uint64_t windowId1 = 1; 38 constexpr uint64_t windowId2 = 2; 39 constexpr uint64_t windowId3 = 3; 40 constexpr uint64_t windowId4 = 4; 41 constexpr uint64_t windowId5 = 5; 42 const std::string vsyncName1 = "vsync1"; 43 const std::string vsyncName2 = "vsync2"; 44 const std::string vsyncName3 = "vsync3"; 45 const std::string vsyncName4 = "vsync4"; 46 const std::string vsyncName5 = "vsync5"; 47 constexpr int32_t OLED_72_HZ = 72; 48 } 49 50 class HgmSoftVSyncManagerTest : public HgmTestBase { 51 public: SetUpTestCase()52 static void SetUpTestCase() { HgmTestBase::SetUpTestCase(); } TearDownTestCase()53 static void TearDownTestCase() {} SetUp()54 void SetUp() {} TearDown()55 void TearDown() {} InitController(HgmSoftVSyncManager & softVSyncMgr)56 std::shared_ptr<HgmVSyncGeneratorController> InitController(HgmSoftVSyncManager& softVSyncMgr) 57 { 58 auto vsyncGenerator = CreateVSyncGenerator(); 59 sptr<Rosen::VSyncController> rsController = new VSyncController(vsyncGenerator, 0); 60 sptr<Rosen::VSyncController> appController = new VSyncController(vsyncGenerator, 0); 61 sptr<VSyncDistributor> appDistributor = new VSyncDistributor(appController, "connection"); 62 auto controller = std::make_shared<HgmVSyncGeneratorController>(rsController, appController, vsyncGenerator); 63 softVSyncMgr.appDistributor_ = appDistributor; 64 return controller; 65 } InitHgmSoftVSyncManager(HgmSoftVSyncManager & softVSyncMgr)66 void InitHgmSoftVSyncManager(HgmSoftVSyncManager& softVSyncMgr) 67 { 68 InitController(softVSyncMgr); 69 70 FrameRateLinkerMap linkerMap = InitAppFrameRateLinkers(); 71 const std::map<uint64_t, int> vRatesMap; 72 softVSyncMgr.UniProcessDataForLtpo(vRatesMap, linkerMap); 73 } InitAppFrameRateLinkers()74 FrameRateLinkerMap InitAppFrameRateLinkers() 75 { 76 FrameRateRange appExpectedRange = {OLED_60_HZ, OLED_120_HZ, OLED_72_HZ}; 77 FrameRateLinkerMap appFrameRateLinkers; 78 79 std::shared_ptr<RSRenderFrameRateLinker> appFrameRateLinker1 = 80 std::make_shared<RSRenderFrameRateLinker>(frameRateLinkerId1); 81 appFrameRateLinker1->SetExpectedRange(appExpectedRange); 82 appFrameRateLinker1->SetWindowNodeId(windowId1); 83 appFrameRateLinker1->SetVsyncName(vsyncName1); 84 appFrameRateLinkers[frameRateLinkerId1] = appFrameRateLinker1; 85 86 std::shared_ptr<RSRenderFrameRateLinker> appFrameRateLinker2 = 87 std::make_shared<RSRenderFrameRateLinker>(frameRateLinkerId2); 88 appFrameRateLinker2->SetExpectedRange(appExpectedRange); 89 appFrameRateLinker2->SetWindowNodeId(windowId2); 90 appFrameRateLinker2->SetVsyncName(vsyncName2); 91 appFrameRateLinkers[frameRateLinkerId2] = appFrameRateLinker2; 92 93 std::shared_ptr<RSRenderFrameRateLinker> appFrameRateLinker3 = 94 std::make_shared<RSRenderFrameRateLinker>(frameRateLinkerId3); 95 appFrameRateLinker3->SetExpectedRange(appExpectedRange); 96 appFrameRateLinker3->SetWindowNodeId(windowId3); 97 appFrameRateLinker3->SetVsyncName(vsyncName3); 98 appFrameRateLinkers[frameRateLinkerId3] = appFrameRateLinker3; 99 100 std::shared_ptr<RSRenderFrameRateLinker> appFrameRateLinker4 = 101 std::make_shared<RSRenderFrameRateLinker>(frameRateLinkerId4); 102 appFrameRateLinker4->SetExpectedRange(appExpectedRange); 103 appFrameRateLinker4->SetWindowNodeId(windowId4); 104 appFrameRateLinker4->SetVsyncName(vsyncName4); 105 appFrameRateLinkers[frameRateLinkerId4] = appFrameRateLinker4; 106 107 std::shared_ptr<RSRenderFrameRateLinker> appFrameRateLinker5 = 108 std::make_shared<RSRenderFrameRateLinker>(frameRateLinkerId5); 109 appFrameRateLinker5->SetExpectedRange(appExpectedRange); 110 appFrameRateLinker5->SetWindowNodeId(windowId5); 111 appFrameRateLinker5->SetVsyncName(vsyncName5); 112 appFrameRateLinkers[frameRateLinkerId5] = appFrameRateLinker5; 113 114 return appFrameRateLinkers; 115 } 116 }; 117 118 /** 119 * @tc.name: SetWindowExpectedRefreshWindowIdRateTest_window001 120 * @tc.desc: Verify the result of SetWindowExpectedRefreshRate 121 * @tc.type: FUNC 122 * @tc.require: 123 */ 124 HWTEST_F(HgmSoftVSyncManagerTest, SetWindowExpectedRefreshRate_window001, Function | SmallTest | Level0) 125 { 126 auto softVSyncManager = HgmSoftVSyncManager(); 127 auto& appVoteData = softVSyncManager.appVoteData_; 128 129 EventInfo eventInfo1 = 130 { .eventName = "VOTER_LOW", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 131 EventInfo eventInfo2 = 132 { .eventName = "VOTER_MID", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 133 EventInfo eventInfo3 = 134 { .eventName = "VOTER_HIGH", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 135 EventInfo eventInfo4 = 136 { .eventName = "VOTER_GAMEFRAMEINSERTION", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 137 EventInfo eventInfo5 = 138 { .eventName = "VOTER_VIDEOCALL", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 139 std::unordered_map<WindowId, EventInfo> voters = { 140 { windowId1, eventInfo1 }, { windowId2, eventInfo2 }, { windowId3, eventInfo3 }, { windowId4, eventInfo4 }, 141 { windowId5, eventInfo5 }, 142 }; 143 InitHgmSoftVSyncManager(softVSyncManager); 144 EXPECT_EQ(softVSyncManager.winLinkerMap_.size(), 5); 145 EXPECT_EQ(softVSyncManager.vsyncLinkerMap_.size(), 5); 146 147 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 148 EXPECT_EQ(softVSyncManager.linkerVoteMap_.size(), 5); 149 EXPECT_EQ(appVoteData.size(), 5); 150 EXPECT_EQ(appVoteData[frameRateLinkerId1], 60); 151 EXPECT_EQ(appVoteData[frameRateLinkerId2], 60); 152 EXPECT_EQ(appVoteData[frameRateLinkerId3], 60); 153 EXPECT_EQ(appVoteData[frameRateLinkerId4], 60); 154 EXPECT_EQ(appVoteData[frameRateLinkerId5], 60); 155 156 eventInfo1 = 157 { .eventName = "VOTER_MID", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 158 eventInfo2 = 159 { .eventName = "VOTER_HIGH", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 160 eventInfo3 = 161 { .eventName = "VOTER_GAMEFRAMEINSERTION", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 162 eventInfo4 = 163 { .eventName = "VOTER_VIDEOCALL", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 164 eventInfo5 = 165 { .eventName = "VOTER_VRATE", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 166 voters = { 167 { windowId1, eventInfo1 }, { windowId2, eventInfo2 }, { windowId3, eventInfo3 }, { windowId4, eventInfo4 }, 168 { windowId5, eventInfo5 }, 169 }; 170 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 171 EXPECT_EQ(appVoteData.size(), 5); 172 EXPECT_EQ(appVoteData[frameRateLinkerId1], 90); 173 EXPECT_EQ(appVoteData[frameRateLinkerId2], 90); 174 EXPECT_EQ(appVoteData[frameRateLinkerId3], 90); 175 EXPECT_EQ(appVoteData[frameRateLinkerId4], 90); 176 EXPECT_EQ(appVoteData[frameRateLinkerId5], 90); 177 } 178 179 /** 180 * @tc.name: SetWindowExpectedRefreshWindowIdRateTest_window002 181 * @tc.desc: Verify the result of SetWindowExpectedRefreshRate 182 * @tc.type: FUNC 183 * @tc.require: 184 */ 185 HWTEST_F(HgmSoftVSyncManagerTest, SetWindowExpectedRefreshRate_window002, Function | SmallTest | Level0) 186 { 187 auto softVSyncManager = HgmSoftVSyncManager(); 188 auto& appVoteData = softVSyncManager.appVoteData_; 189 190 EventInfo eventInfo = 191 { .eventName = "VOTER_LOW", .minRefreshRate = -1, .maxRefreshRate = 150, .eventStatus = true }; 192 std::unordered_map<WindowId, EventInfo> voters = {{ windowId1, eventInfo }}; 193 InitHgmSoftVSyncManager(softVSyncManager); 194 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 195 EXPECT_EQ(appVoteData.size(), 0); 196 197 eventInfo = 198 { .eventName = "VOTER_LOW", .minRefreshRate = 60, .maxRefreshRate = 30, .eventStatus = true }; 199 voters = {{ windowId1, eventInfo }}; 200 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 201 EXPECT_EQ(appVoteData.size(), 0); 202 203 eventInfo = 204 { .eventName = "VOTER_LOW", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 205 voters = {{ windowId1, eventInfo }}; 206 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 207 EXPECT_EQ(appVoteData.size(), 1); 208 EXPECT_EQ(appVoteData[frameRateLinkerId1], 60); 209 210 eventInfo = 211 { .eventName = "VOTER_MID", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 212 voters = {{ windowId1, eventInfo }}; 213 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 214 EXPECT_EQ(appVoteData.size(), 1); 215 EXPECT_EQ(appVoteData[frameRateLinkerId1], 90); 216 217 voters[windowId1].eventStatus = false; 218 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 219 EXPECT_EQ(appVoteData.size(), 1); 220 EXPECT_EQ(appVoteData[frameRateLinkerId1], 60); 221 } 222 223 /** 224 * @tc.name: SetWindowExpectedRefreshWindowIdRateTest_vsync001 225 * @tc.desc: Verify the result of SetWindowExpectedRefreshRate 226 * @tc.type: FUNC 227 * @tc.require: 228 */ 229 HWTEST_F(HgmSoftVSyncManagerTest, SetWindowExpectedRefreshWindowIdRateTest_vsync001, Function | SmallTest | Level0) 230 { 231 auto softVSyncManager = HgmSoftVSyncManager(); 232 auto& appVoteData = softVSyncManager.appVoteData_; 233 234 EventInfo eventInfo1 = 235 { .eventName = "VOTER_LOW", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 236 EventInfo eventInfo2 = 237 { .eventName = "VOTER_MID", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 238 EventInfo eventInfo3 = 239 { .eventName = "VOTER_HIGH", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 240 EventInfo eventInfo4 = 241 { .eventName = "VOTER_GAMEFRAMEINSERTION", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 242 EventInfo eventInfo5 = 243 { .eventName = "VOTER_VIDEOCALL", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 244 std::unordered_map<VsyncName, EventInfo> voters = { 245 { vsyncName1, eventInfo1 }, { vsyncName2, eventInfo2 }, { vsyncName3, eventInfo3 }, { vsyncName4, eventInfo4 }, 246 { vsyncName5, eventInfo5 }, 247 }; 248 InitHgmSoftVSyncManager(softVSyncManager); 249 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 250 EXPECT_EQ(appVoteData.size(), 5); 251 EXPECT_EQ(appVoteData[frameRateLinkerId1], 60); 252 EXPECT_EQ(appVoteData[frameRateLinkerId2], 60); 253 EXPECT_EQ(appVoteData[frameRateLinkerId3], 60); 254 EXPECT_EQ(appVoteData[frameRateLinkerId4], 60); 255 EXPECT_EQ(appVoteData[frameRateLinkerId5], 60); 256 257 eventInfo1 = 258 { .eventName = "VOTER_MID", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 259 eventInfo2 = 260 { .eventName = "VOTER_HIGH", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 261 eventInfo3 = 262 { .eventName = "VOTER_GAMEFRAMEINSERTION", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 263 eventInfo4 = 264 { .eventName = "VOTER_VIDEOCALL", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 265 eventInfo5 = 266 { .eventName = "VOTER_VRATE", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 267 voters = { 268 { vsyncName1, eventInfo1 }, { vsyncName2, eventInfo2 }, { vsyncName3, eventInfo3 }, { vsyncName4, eventInfo4 }, 269 { vsyncName5, eventInfo5 }, 270 }; 271 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 272 EXPECT_EQ(appVoteData.size(), 5); 273 EXPECT_EQ(appVoteData[frameRateLinkerId1], 90); 274 EXPECT_EQ(appVoteData[frameRateLinkerId2], 90); 275 EXPECT_EQ(appVoteData[frameRateLinkerId3], 90); 276 EXPECT_EQ(appVoteData[frameRateLinkerId4], 90); 277 EXPECT_EQ(appVoteData[frameRateLinkerId5], 90); 278 } 279 280 /** 281 * @tc.name: SetWindowExpectedRefreshWindowIdRateTest_vsync002 282 * @tc.desc: Verify the result of SetWindowExpectedRefreshRate 283 * @tc.type: FUNC 284 * @tc.require: 285 */ 286 HWTEST_F(HgmSoftVSyncManagerTest, SetWindowExpectedRefreshRate_vsync002, Function | SmallTest | Level0) 287 { 288 auto softVSyncManager = HgmSoftVSyncManager(); 289 auto& appVoteData = softVSyncManager.appVoteData_; 290 291 EventInfo eventInfo = 292 { .eventName = "VOTER_LOW", .minRefreshRate = -1, .maxRefreshRate = 150, .eventStatus = true }; 293 std::unordered_map<VsyncName, EventInfo> voters = {{ vsyncName1, eventInfo }}; 294 InitHgmSoftVSyncManager(softVSyncManager); 295 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 296 EXPECT_EQ(appVoteData.size(), 0); 297 298 eventInfo = 299 { .eventName = "VOTER_LOW", .minRefreshRate = 60, .maxRefreshRate = 30, .eventStatus = true }; 300 voters = {{ vsyncName1, eventInfo }}; 301 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 302 EXPECT_EQ(appVoteData.size(), 0); 303 304 eventInfo = 305 { .eventName = "VOTER_LOW", .minRefreshRate = 60, .maxRefreshRate = 60, .eventStatus = true }; 306 voters = {{ vsyncName1, eventInfo }}; 307 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 308 EXPECT_EQ(appVoteData.size(), 1); 309 EXPECT_EQ(appVoteData[frameRateLinkerId1], 60); 310 311 eventInfo = 312 { .eventName = "VOTER_MID", .minRefreshRate = 90, .maxRefreshRate = 90, .eventStatus = true }; 313 voters = {{ vsyncName1, eventInfo }}; 314 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 315 EXPECT_EQ(appVoteData.size(), 1); 316 EXPECT_EQ(appVoteData[frameRateLinkerId1], 90); 317 318 voters[vsyncName1].eventStatus = false; 319 softVSyncManager.SetWindowExpectedRefreshRate(0, voters); 320 EXPECT_EQ(appVoteData.size(), 1); 321 EXPECT_EQ(appVoteData[frameRateLinkerId1], 60); 322 } 323 324 325 /** 326 * @tc.name: GetVRateMiniFPS 327 * @tc.desc: Verify the result of GetVRateMiniFPS 328 * @tc.type: FUNC 329 * @tc.require: 330 */ 331 HWTEST_F(HgmSoftVSyncManagerTest, GetVRateMiniFPS, Function | SmallTest | Level0) 332 { 333 HgmSoftVSyncManager mgr; 334 std::shared_ptr<PolicyConfigData> configData = std::make_shared<PolicyConfigData>(); 335 336 configData->vRateControlList_.clear(); 337 mgr.GetVRateMiniFPS(configData); 338 ASSERT_EQ(mgr.vrateControlMinifpsValue_, 1); 339 340 configData->vRateControlList_["minifps"] = "abc"; 341 mgr.GetVRateMiniFPS(configData); 342 ASSERT_EQ(mgr.vrateControlMinifpsValue_, 1); 343 344 configData->vRateControlList_["minifps"] = "-1"; 345 ASSERT_EQ(configData->vRateControlList_["minifps"], "-1"); 346 int32_t vrateControlMinifpsValue_ = static_cast<int32_t>(std::stoi(configData->vRateControlList_["minifps"])); 347 ASSERT_EQ(vrateControlMinifpsValue_, -1); 348 mgr.GetVRateMiniFPS(configData); 349 ASSERT_EQ(mgr.vrateControlMinifpsValue_, -1); 350 351 configData->vRateControlList_["minifps"] = "10"; 352 ASSERT_EQ(configData->vRateControlList_["minifps"], "10"); 353 vrateControlMinifpsValue_ = static_cast<int32_t>(std::stoi(configData->vRateControlList_["minifps"])); 354 ASSERT_EQ(vrateControlMinifpsValue_, 10); 355 mgr.GetVRateMiniFPS(configData); 356 ASSERT_EQ(mgr.vrateControlMinifpsValue_, 10); 357 } 358 359 /** 360 * @tc.name: CollectVRateChange 361 * @tc.desc: Verify the result of CollectVRateChange 362 * @tc.type: FUNC 363 * @tc.require: 364 */ 365 HWTEST_F(HgmSoftVSyncManagerTest, CollectVRateChange01, Function | SmallTest | Level0) 366 { 367 HgmSoftVSyncManager mgr; 368 FrameRateRange finalRange = { OLED_60_HZ, OLED_120_HZ, OLED_60_HZ }; 369 mgr.vRatesMap_ = { 370 { 0, 0 }, 371 { 1, 1 }, 372 { 2, 2 }, 373 { 3, 3 }, 374 { 4, std::numeric_limits<int>::max() } 375 }; 376 uint64_t linkerId = 2; 377 mgr.CollectVRateChange(linkerId, finalRange); 378 EXPECT_EQ(finalRange.min_, OLED_60_HZ); 379 EXPECT_EQ(finalRange.max_, OLED_120_HZ); 380 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ); 381 382 linkerId = 0; 383 mgr.CollectVRateChange(linkerId, finalRange); 384 EXPECT_EQ(finalRange.min_, OLED_60_HZ); 385 EXPECT_EQ(finalRange.max_, OLED_120_HZ); 386 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ); 387 388 linkerId = 1; 389 mgr.CollectVRateChange(linkerId, finalRange); 390 EXPECT_EQ(finalRange.min_, OLED_60_HZ); 391 EXPECT_EQ(finalRange.max_, OLED_120_HZ); 392 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ); 393 394 linkerId = 2; 395 mgr.CollectVRateChange(linkerId, finalRange); 396 EXPECT_EQ(finalRange.min_, OLED_60_HZ); 397 EXPECT_EQ(finalRange.max_, OLED_120_HZ); 398 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ); 399 400 finalRange.preferred_ = 0; 401 mgr.controllerRate_ = 0; 402 mgr.CollectVRateChange(linkerId, finalRange); 403 EXPECT_EQ(finalRange.min_, OLED_NULL_HZ); 404 EXPECT_EQ(finalRange.max_, OLED_144_HZ); 405 EXPECT_EQ(finalRange.preferred_, mgr.vrateControlMinifpsValue_); 406 } 407 408 /** 409 * @tc.name: CollectVRateChange 410 * @tc.desc: Verify the result of CollectVRateChange 411 * @tc.type: FUNC 412 * @tc.require: 413 */ 414 HWTEST_F(HgmSoftVSyncManagerTest, CollectVRateChange02, Function | SmallTest | Level0) 415 { 416 HgmSoftVSyncManager mgr; 417 FrameRateRange finalRange = { OLED_60_HZ, OLED_120_HZ, OLED_60_HZ }; 418 mgr.vRatesMap_ = { 419 { 0, 0 }, 420 { 1, 1 }, 421 { 2, 2 }, 422 { 3, 3 }, 423 { 4, std::numeric_limits<int>::max() } 424 }; 425 426 uint64_t linkerId = 2; 427 finalRange.preferred_ = 0; 428 mgr.controllerRate_ = 100; 429 mgr.CollectVRateChange(linkerId, finalRange); 430 EXPECT_EQ(finalRange.min_, OLED_NULL_HZ); 431 EXPECT_EQ(finalRange.max_, OLED_144_HZ); 432 EXPECT_EQ(finalRange.preferred_, 50); 433 434 linkerId = 3; 435 finalRange.type_ = 6; 436 finalRange.preferred_ = OLED_60_HZ; 437 mgr.CollectVRateChange(linkerId, finalRange); 438 EXPECT_EQ(finalRange.min_, OLED_NULL_HZ); 439 EXPECT_EQ(finalRange.max_, OLED_144_HZ); 440 EXPECT_EQ(finalRange.preferred_, OLED_60_HZ); 441 442 linkerId = 4; 443 finalRange.type_ = 6; 444 mgr.controllerRate_ = OLED_120_HZ; 445 mgr.CollectVRateChange(linkerId, finalRange); 446 EXPECT_EQ(finalRange.min_, OLED_NULL_HZ); 447 EXPECT_EQ(finalRange.max_, OLED_144_HZ); 448 EXPECT_EQ(finalRange.preferred_, 1); 449 } 450 451 /** 452 * @tc.name: GetDrawingFrameRate 453 * @tc.desc: Verify the result of GetDrawingFrameRate 454 * @tc.type: FUNC 455 * @tc.require: 456 */ 457 HWTEST_F(HgmSoftVSyncManagerTest, GetDrawingFrameRate01, Function | SmallTest | Level0) 458 { 459 HgmSoftVSyncManager mgr; 460 uint32_t refreshRate_60 = 60; 461 uint32_t refreshRate_120 = 120; 462 FrameRateRange dynamic_120(0, 120, 120); 463 EXPECT_EQ(dynamic_120.IsDynamic(), true); 464 FrameRateRange static_120(120, 120, 120); 465 EXPECT_EQ(static_120.IsDynamic(), false); 466 467 EXPECT_EQ(mgr.GetDrawingFrameRate(refreshRate_60, dynamic_120), 60); 468 EXPECT_EQ(mgr.GetDrawingFrameRate(refreshRate_60, static_120), 60); 469 EXPECT_EQ(mgr.GetDrawingFrameRate(refreshRate_120, dynamic_120), 120); 470 EXPECT_EQ(mgr.GetDrawingFrameRate(refreshRate_120, static_120), 120); 471 } 472 473 /** 474 * @tc.name: GetDrawingFrameRate 475 * @tc.desc: Verify the result of GetDrawingFrameRate 476 * @tc.type: FUNC 477 * @tc.require: 478 */ 479 HWTEST_F(HgmSoftVSyncManagerTest, GetDrawingFrameRate02, Function | SmallTest | Level0) 480 { 481 std::vector<std::pair<std::pair<uint32_t, FrameRateRange>, uint32_t>> inputAndOutput = { 482 { { 0, { 0, 120, 60 } }, 0 }, 483 { { 60, { 0, 120, 0 } }, 0 }, 484 { { 60, { 0, 90, 120 } }, 60 }, 485 { { 60, { 0, 120, 120 } }, 60 }, 486 { { 90, { 0, 120, 30 } }, 30 }, 487 { { 80, { 0, 120, 30 } }, 40 }, 488 { { 70, { 0, 120, 30 } }, 35 }, 489 { { 60, { 0, 120, 30 } }, 30 }, 490 { { 50, { 0, 120, 30 } }, 50 } 491 }; 492 493 for (const auto& [input, output] : inputAndOutput) { 494 EXPECT_EQ(HgmSoftVSyncManager::GetDrawingFrameRate(input.first, input.second), output); 495 } 496 } 497 498 /** 499 * @tc.name: CollectFrameRateChange 500 * @tc.desc: Verify the result of CollectFrameRateChange 501 * @tc.type: FUNC 502 * @tc.require: 503 */ 504 HWTEST_F(HgmSoftVSyncManagerTest, CollectFrameRateChangeTest, Function | SmallTest | Level0) 505 { 506 HgmSoftVSyncManager mgr; 507 InitHgmSoftVSyncManager(mgr); 508 FrameRateRange finalRange = { OLED_60_HZ, OLED_120_HZ, OLED_60_HZ }; 509 FrameRateRange appExpectedRange = { OLED_60_HZ, OLED_120_HZ, OLED_72_HZ }; 510 std::shared_ptr<RSRenderFrameRateLinker> rsFrameRateLinker = std::make_shared<RSRenderFrameRateLinker>(); 511 std::shared_ptr<RSRenderFrameRateLinker> appFrameRateLinker = std::make_shared<RSRenderFrameRateLinker>(); 512 appFrameRateLinker->SetExpectedRange(appExpectedRange); 513 514 FrameRateLinkerMap appFrameRateLinkers = { 515 {frameRateLinkerId1, nullptr}, 516 {frameRateLinkerId2, appFrameRateLinker} 517 }; 518 auto controller = InitController(mgr); 519 mgr.controller_ = controller; 520 EXPECT_EQ(mgr.CollectFrameRateChange(finalRange, rsFrameRateLinker, appFrameRateLinkers, 0), false); 521 EXPECT_GT(mgr.GetDrawingFrameRate(OLED_60_HZ, finalRange), 0); 522 EXPECT_EQ(mgr.CollectFrameRateChange(finalRange, rsFrameRateLinker, appFrameRateLinkers, OLED_60_HZ), true); 523 controller = nullptr; 524 EXPECT_EQ(mgr.CollectFrameRateChange(finalRange, rsFrameRateLinker, appFrameRateLinkers, OLED_60_HZ), false); 525 } 526 527 /** 528 * @tc.name: CollectGameRateDiscountChange 529 * @tc.desc: Verify the result of CollectGameRateDiscountChange 530 * @tc.type: FUNC 531 * @tc.require: 532 */ 533 HWTEST_F(HgmSoftVSyncManagerTest, CollectGameRateDiscountChange, Function | SmallTest | Level0) 534 { 535 HgmSoftVSyncManager mgr; 536 FrameRateRange appExpectedRange = { OLED_60_HZ, OLED_120_HZ, OLED_60_HZ }; 537 FrameRateRange appZeroExpectedRange = { OLED_MIN_HZ, OLED_120_HZ, OLED_MIN_HZ }; 538 FrameRateRange appErrExpectedRange = { OLED_60_HZ, OLED_120_HZ, OLED_MIN_HZ }; 539 540 EXPECT_EQ(mgr.CollectGameRateDiscountChange(frameRateLinkerId1, appExpectedRange, 0), false); 541 std::vector<uint64_t> linkerIds = { frameRateLinkerId1, frameRateLinkerId2 }; 542 543 uint32_t rateDiscount = 0; 544 mgr.SetVsyncRateDiscountLTPO(linkerIds, rateDiscount); 545 EXPECT_EQ(mgr.CollectGameRateDiscountChange(frameRateLinkerId1, appExpectedRange, OLED_60_HZ), false); 546 rateDiscount = 1; 547 mgr.SetVsyncRateDiscountLTPO(linkerIds, rateDiscount); 548 EXPECT_EQ(mgr.CollectGameRateDiscountChange(frameRateLinkerId1, appExpectedRange, OLED_60_HZ), false); 549 rateDiscount = 2; 550 mgr.SetVsyncRateDiscountLTPO(linkerIds, rateDiscount); 551 mgr.CollectGameRateDiscountChange(frameRateLinkerId1, appExpectedRange, OLED_60_HZ); 552 mgr.CollectGameRateDiscountChange(frameRateLinkerId1, appZeroExpectedRange, OLED_60_HZ); 553 EXPECT_EQ(mgr.CollectGameRateDiscountChange(frameRateLinkerId1, appErrExpectedRange, OLED_60_HZ), true); 554 555 mgr.CollectGameRateDiscountChange(frameRateLinkerId1, appExpectedRange, OLED_MIN_HZ); 556 EXPECT_EQ(mgr.CollectGameRateDiscountChange(frameRateLinkerId1, appZeroExpectedRange, OLED_MIN_HZ), true); 557 558 mgr.EraseGameRateDiscountMap(frameRateLinkerId1); 559 } 560 } // namespace Rosen 561 } // namespace OHOS