Merge "SF: Update RefreshRateSelectorTest to check range of refresh rates."

1 files changed, 289 insertions, 131 deletions

diff --git a/services/surfaceflinger/tests/unittests/RefreshRateSelectorTest.cpp b/services/surfaceflinger/tests/unittests/RefreshRateSelectorTest.cpp
index 79d02dd512..c9fefe3dee 100644
--- a/services/surfaceflinger/tests/unittests/RefreshRateSelectorTest.cpp
+++ b/services/surfaceflinger/tests/unittests/RefreshRateSelectorTest.cpp
@@ -230,6 +230,12 @@ protected:
         config.enableFrameRateOverride = GetParam();
         return TestableRefreshRateSelector(modes, activeModeId, config);
     }
+
+    // TODO(b/262783137) Test the complete range of refresh rates
+    struct FpsBeginEnd {
+        std::vector<std::pair<Fps, Fps>> begin;
+        std::vector<std::pair<Fps, Fps>> end;
+    };
 };
 
 RefreshRateSelectorTest::RefreshRateSelectorTest() {
@@ -1125,29 +1131,39 @@ TEST_P(RefreshRateSelectorTest, getMaxRefreshRatesByPolicy) {
     const auto refreshRates = selector.rankRefreshRates(selector.getActiveMode().getGroup(),
                                                         RefreshRateOrder::Descending);
 
-    const auto expectedRefreshRates = []() -> std::vector<FrameRateMode> {
+    const auto expectedRefreshRates = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{90_Hz, kMode90}, {60_Hz, kMode60}, {30_Hz, kMode30}};
+                return {.begin{{90_Hz, 90_Hz}, {60_Hz, 60_Hz}, {30_Hz, 30_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{90_Hz, kMode90}, {60_Hz, kMode60}, {45_Hz, kMode90}, {30_Hz, kMode30}};
+                return {.begin{{90_Hz, 90_Hz}, {60_Hz, 60_Hz}, {45_Hz, 90_Hz}, {30_Hz, 30_Hz}},
+                        .end{{1.022_Hz, 90_Hz},
+                             {1.016_Hz, 60_Hz},
+                             {1.011_Hz, 90_Hz},
+                             {1_Hz, 30_Hz}}};
         }
     }();
 
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates120, refreshRates.size());
     } else {
-        ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
+        ASSERT_EQ(expectedRefreshRates.begin.size(), refreshRates.size());
     }
 
-    for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
-        EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
-                << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
-                << expectedRefreshRates[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
-                << refreshRates[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRefreshRates.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.begin[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, refreshRates[i].frameRateMode.modePtr->getFps());
+    }
+
+    for (size_t i = 0; i < expectedRefreshRates.end.size(); i++) {
+        const size_t refreshRateIndex = refreshRates.size() - expectedRefreshRates.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.end[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  refreshRates[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 }
 
@@ -1159,32 +1175,39 @@ TEST_P(RefreshRateSelectorTest, getMinRefreshRatesByPolicy) {
     const auto refreshRates = selector.rankRefreshRates(selector.getActiveMode().getGroup(),
                                                         RefreshRateOrder::Ascending);
 
-    const auto expectedRefreshRates = []() -> std::vector<FrameRateMode> {
+    const auto expectedRefreshRates = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{30_Hz, kMode30}, {60_Hz, kMode60}, {90_Hz, kMode90}};
+                return {.begin{{30_Hz, 30_Hz}, {60_Hz, 60_Hz}, {90_Hz, 90_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{1_Hz, kMode30},
-                        {1.011_Hz, kMode90},
-                        {1.016_Hz, kMode60},
-                        {1.022_Hz, kMode90}};
+                return {.begin{{1_Hz, 30_Hz},
+                               {1.011_Hz, 90_Hz},
+                               {1.016_Hz, 60_Hz},
+                               {1.022_Hz, 90_Hz}},
+                        .end{{30_Hz, 30_Hz}, {45_Hz, 90_Hz}, {60_Hz, 60_Hz}, {90_Hz, 90_Hz}}};
         }
     }();
 
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates120, refreshRates.size());
     } else {
-        ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
+        ASSERT_EQ(expectedRefreshRates.begin.size(), refreshRates.size());
     }
 
-    for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
-        EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
-                << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
-                << expectedRefreshRates[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
-                << refreshRates[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRefreshRates.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.begin[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, refreshRates[i].frameRateMode.modePtr->getFps());
+    }
+
+    for (size_t i = 0; i < expectedRefreshRates.end.size(); i++) {
+        const size_t refreshRateIndex = refreshRates.size() - expectedRefreshRates.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.end[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  refreshRates[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 }
 
@@ -1258,30 +1281,44 @@ TEST_P(RefreshRateSelectorTest, powerOnImminentConsidered) {
     auto [refreshRates, signals] = selector.getRankedFrameRates({}, {});
     EXPECT_FALSE(signals.powerOnImminent);
 
-    auto expectedRefreshRates = []() -> std::vector<FrameRateMode> {
+    auto expectedRefreshRates = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{90_Hz, kMode90}, {60_Hz, kMode60}};
+                return {.begin{{90_Hz, 90_Hz}, {60_Hz, 60_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{90_Hz, kMode90}, {60_Hz, kMode60},   {45_Hz, kMode90},
-                        {30_Hz, kMode60}, {22.5_Hz, kMode90}, {20_Hz, kMode60}};
+                return {.begin{{90_Hz, 90_Hz},
+                               {60_Hz, 60_Hz},
+                               {45_Hz, 90_Hz},
+                               {30_Hz, 60_Hz},
+                               {22.5_Hz, 90_Hz},
+                               {20_Hz, 60_Hz}},
+                        .end{{1.022_Hz, 90_Hz},
+                             {1.016_Hz, 60_Hz},
+                             {1.011_Hz, 90_Hz},
+                             {1_Hz, 60_Hz}}};
         }
     }();
 
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates120, refreshRates.size());
     } else {
-        ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
+        ASSERT_EQ(expectedRefreshRates.begin.size(), refreshRates.size());
     }
 
-    for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
-        EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
-                << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
-                << expectedRefreshRates[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
-                << refreshRates[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRefreshRates.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.begin[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, refreshRates[i].frameRateMode.modePtr->getFps());
+    }
+
+    for (size_t i = 0; i < expectedRefreshRates.end.size(); i++) {
+        const size_t refreshRateIndex = refreshRates.size() - expectedRefreshRates.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.end[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  refreshRates[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 
     std::tie(refreshRates, signals) =
@@ -1291,15 +1328,21 @@ TEST_P(RefreshRateSelectorTest, powerOnImminentConsidered) {
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates120, refreshRates.size());
     } else {
-        ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
+        ASSERT_EQ(expectedRefreshRates.begin.size(), refreshRates.size());
     }
 
-    for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
-        EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
-                << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
-                << expectedRefreshRates[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
-                << refreshRates[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRefreshRates.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.begin[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, refreshRates[i].frameRateMode.modePtr->getFps());
+    }
+
+    for (size_t i = 0; i < expectedRefreshRates.end.size(); i++) {
+        const size_t refreshRateIndex = refreshRates.size() - expectedRefreshRates.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.end[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  refreshRates[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 
     std::vector<LayerRequirement> layers = {{.weight = 1.f}};
@@ -1315,45 +1358,65 @@ TEST_P(RefreshRateSelectorTest, powerOnImminentConsidered) {
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates120, refreshRates.size());
     } else {
-        ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
+        ASSERT_EQ(expectedRefreshRates.begin.size(), refreshRates.size());
     }
 
-    for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
-        EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
-                << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
-                << expectedRefreshRates[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
-                << refreshRates[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRefreshRates.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.begin[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, refreshRates[i].frameRateMode.modePtr->getFps());
+    }
+
+    for (size_t i = 0; i < expectedRefreshRates.end.size(); i++) {
+        const size_t refreshRateIndex = refreshRates.size() - expectedRefreshRates.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.end[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  refreshRates[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 
     std::tie(refreshRates, signals) =
             selector.getRankedRefreshRatesAsPair(layers, {.powerOnImminent = false});
     EXPECT_FALSE(signals.powerOnImminent);
 
-    expectedRefreshRates = []() -> std::vector<FrameRateMode> {
+    expectedRefreshRates = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{60_Hz, kMode60}, {90_Hz, kMode90}};
+                return {.begin{{60_Hz, 60_Hz}, {90_Hz, 90_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{60_Hz, kMode60}, {90_Hz, kMode90},   {45_Hz, kMode90},
-                        {30_Hz, kMode60}, {22.5_Hz, kMode90}, {20_Hz, kMode60}};
+                return {.begin{{60_Hz, 60_Hz},
+                               {90_Hz, 90_Hz},
+                               {45_Hz, 90_Hz},
+                               {30_Hz, 60_Hz},
+                               {22.5_Hz, 90_Hz},
+                               {20_Hz, 60_Hz}},
+                        .end{{1.034_Hz, 60_Hz},
+                             {1.046_Hz, 90_Hz},
+                             {1.052_Hz, 60_Hz},
+                             {1.058_Hz, 90_Hz}}};
         }
     }();
 
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates120, refreshRates.size());
     } else {
-        ASSERT_EQ(expectedRefreshRates.size(), refreshRates.size());
+        ASSERT_EQ(expectedRefreshRates.begin.size(), refreshRates.size());
     }
 
-    for (size_t i = 0; i < expectedRefreshRates.size(); ++i) {
-        EXPECT_EQ(expectedRefreshRates[i], refreshRates[i].frameRateMode)
-                << "Expected " << expectedRefreshRates[i].fps.getIntValue() << " ("
-                << expectedRefreshRates[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << refreshRates[i].frameRateMode.fps.getIntValue() << " ("
-                << refreshRates[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRefreshRates.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.begin[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, refreshRates[i].frameRateMode.modePtr->getFps());
+    }
+
+    for (size_t i = 0; i < expectedRefreshRates.end.size(); i++) {
+        const size_t refreshRateIndex = refreshRates.size() - expectedRefreshRates.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRefreshRates.end[i];
+        EXPECT_EQ(expectedRenderRate, refreshRates[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  refreshRates[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 }
 
@@ -1582,19 +1645,33 @@ TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
     lr5.name = "30Hz";
     lr5.focused = true;
 
-    auto expectedRanking = []() -> std::vector<FrameRateMode> {
+    auto expectedRanking = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{120_Hz, kMode120},
-                        {90_Hz, kMode90},
-                        {72_Hz, kMode72},
-                        {60_Hz, kMode60},
-                        {30_Hz, kMode30}};
+                return {.begin{{120_Hz, 120_Hz},
+                               {90_Hz, 90_Hz},
+                               {72_Hz, 72_Hz},
+                               {60_Hz, 60_Hz},
+                               {30_Hz, 30_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{120_Hz, kMode120}, {90_Hz, kMode90},  {72_Hz, kMode72}, {60_Hz, kMode60},
-                        {45_Hz, kMode90},   {40_Hz, kMode120}, {36_Hz, kMode72}, {30_Hz, kMode30}};
+                return {.begin{{120_Hz, 120_Hz},
+                               {90_Hz, 90_Hz},
+                               {72_Hz, 72_Hz},
+                               {60_Hz, 60_Hz},
+                               {45_Hz, 90_Hz},
+                               {40_Hz, 120_Hz},
+                               {36_Hz, 72_Hz},
+                               {30_Hz, 30_Hz}},
+                        .end{{1.028_Hz, 72_Hz},
+                             {1.0256_Hz, 120_Hz},
+                             {1.022_Hz, 90_Hz},
+                             {1.016_Hz, 60_Hz},
+                             {1.014_Hz, 72_Hz},
+                             {1.011_Hz, 90_Hz},
+                             {1.008_Hz, 120_Hz},
+                             {1_Hz, 30_Hz}}};
         }
     }();
 
@@ -1602,15 +1679,21 @@ TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates216, actualRanking.size());
     } else {
-        ASSERT_EQ(expectedRanking.size(), actualRanking.size());
+        ASSERT_EQ(expectedRanking.begin.size(), actualRanking.size());
+    }
+
+    for (size_t i = 0; i < expectedRanking.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRanking.begin[i];
+        EXPECT_EQ(expectedRenderRate, actualRanking[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, actualRanking[i].frameRateMode.modePtr->getFps());
     }
 
-    for (size_t i = 0; i < expectedRanking.size(); ++i) {
-        EXPECT_EQ(expectedRanking[i], actualRanking[i].frameRateMode)
-                << "Expected " << expectedRanking[i].fps.getIntValue() << " ("
-                << expectedRanking[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << actualRanking[i].frameRateMode.fps.getIntValue() << " ("
-                << actualRanking[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRanking.end.size(); i++) {
+        const size_t refreshRateIndex = actualRanking.size() - expectedRanking.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRanking.end[i];
+        EXPECT_EQ(expectedRenderRate, actualRanking[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  actualRanking[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 
     lr1.vote = LayerVoteType::Max;
@@ -1628,19 +1711,33 @@ TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
     lr5.desiredRefreshRate = 120_Hz;
     lr5.name = "120Hz";
 
-    expectedRanking = []() -> std::vector<FrameRateMode> {
+    expectedRanking = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{120_Hz, kMode120},
-                        {90_Hz, kMode90},
-                        {72_Hz, kMode72},
-                        {60_Hz, kMode60},
-                        {30_Hz, kMode30}};
+                return {.begin{{120_Hz, 120_Hz},
+                               {90_Hz, 90_Hz},
+                               {72_Hz, 72_Hz},
+                               {60_Hz, 60_Hz},
+                               {30_Hz, 30_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{120_Hz, kMode120}, {90_Hz, kMode90},  {72_Hz, kMode72}, {60_Hz, kMode60},
-                        {45_Hz, kMode90},   {40_Hz, kMode120}, {36_Hz, kMode72}, {30_Hz, kMode30}};
+                return {.begin{{120_Hz, 120_Hz},
+                               {90_Hz, 90_Hz},
+                               {72_Hz, 72_Hz},
+                               {60_Hz, 60_Hz},
+                               {45_Hz, 90_Hz},
+                               {40_Hz, 120_Hz},
+                               {36_Hz, 72_Hz},
+                               {30_Hz, 30_Hz}},
+                        .end{{1.028_Hz, 72_Hz},
+                             {1.0256_Hz, 120_Hz},
+                             {1.022_Hz, 90_Hz},
+                             {1.016_Hz, 60_Hz},
+                             {1.014_Hz, 72_Hz},
+                             {1.011_Hz, 90_Hz},
+                             {1.008_Hz, 120_Hz},
+                             {1_Hz, 30_Hz}}};
         }
     }();
     actualRanking = selector.getRankedFrameRates(layers, {}).ranking;
@@ -1648,15 +1745,21 @@ TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates216, actualRanking.size());
     } else {
-        ASSERT_EQ(expectedRanking.size(), actualRanking.size());
+        ASSERT_EQ(expectedRanking.begin.size(), actualRanking.size());
     }
 
-    for (size_t i = 0; i < expectedRanking.size(); ++i) {
-        EXPECT_EQ(expectedRanking[i], actualRanking[i].frameRateMode)
-                << "Expected " << expectedRanking[i].fps.getIntValue() << " ("
-                << expectedRanking[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << actualRanking[i].frameRateMode.fps.getIntValue() << " ("
-                << actualRanking[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRanking.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRanking.begin[i];
+        EXPECT_EQ(expectedRenderRate, actualRanking[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, actualRanking[i].frameRateMode.modePtr->getFps());
+    }
+
+    for (size_t i = 0; i < expectedRanking.end.size(); i++) {
+        const size_t refreshRateIndex = actualRanking.size() - expectedRanking.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRanking.end[i];
+        EXPECT_EQ(expectedRenderRate, actualRanking[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  actualRanking[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 
     lr1.vote = LayerVoteType::Heuristic;
@@ -1672,19 +1775,33 @@ TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
     lr5.desiredRefreshRate = 72_Hz;
     lr5.name = "72Hz";
 
-    expectedRanking = []() -> std::vector<FrameRateMode> {
+    expectedRanking = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{30_Hz, kMode30},
-                        {60_Hz, kMode60},
-                        {90_Hz, kMode90},
-                        {120_Hz, kMode120},
-                        {72_Hz, kMode72}};
+                return {.begin{{30_Hz, 30_Hz},
+                               {60_Hz, 60_Hz},
+                               {90_Hz, 90_Hz},
+                               {120_Hz, 120_Hz},
+                               {72_Hz, 72_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{30_Hz, kMode30}, {60_Hz, kMode60},  {90_Hz, kMode90}, {120_Hz, kMode120},
-                        {45_Hz, kMode90}, {40_Hz, kMode120}, {72_Hz, kMode72}, {36_Hz, kMode72}};
+                return {.begin{{30_Hz, 30_Hz},
+                               {60_Hz, 60_Hz},
+                               {90_Hz, 90_Hz},
+                               {120_Hz, 120_Hz},
+                               {45_Hz, 90_Hz},
+                               {40_Hz, 120_Hz},
+                               {72_Hz, 72_Hz},
+                               {36_Hz, 72_Hz}},
+                        .end{{1.074_Hz, 72_Hz},
+                             {1.081_Hz, 120_Hz},
+                             {1.084_Hz, 90_Hz},
+                             {1.00_Hz, 30_Hz},
+                             {1.008_Hz, 120_Hz},
+                             {1.011_Hz, 90_Hz},
+                             {1.014_Hz, 72_Hz},
+                             {1.016_Hz, 60_Hz}}};
         }
     }();
     actualRanking = selector.getRankedFrameRates(layers, {}).ranking;
@@ -1692,15 +1809,21 @@ TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates216, actualRanking.size());
     } else {
-        ASSERT_EQ(expectedRanking.size(), actualRanking.size());
+        ASSERT_EQ(expectedRanking.begin.size(), actualRanking.size());
+    }
+
+    for (size_t i = 0; i < expectedRanking.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRanking.begin[i];
+        EXPECT_EQ(expectedRenderRate, actualRanking[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, actualRanking[i].frameRateMode.modePtr->getFps());
     }
 
-    for (size_t i = 0; i < expectedRanking.size(); ++i) {
-        EXPECT_EQ(expectedRanking[i], actualRanking[i].frameRateMode)
-                << "Expected " << expectedRanking[i].fps.getIntValue() << " ("
-                << expectedRanking[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << actualRanking[i].frameRateMode.fps.getIntValue() << " ("
-                << actualRanking[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRanking.end.size(); i++) {
+        const size_t refreshRateIndex = actualRanking.size() - expectedRanking.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRanking.end[i];
+        EXPECT_EQ(expectedRenderRate, actualRanking[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  actualRanking[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 
     lr1.desiredRefreshRate = 120_Hz;
@@ -1719,19 +1842,26 @@ TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
     lr5.desiredRefreshRate = 120_Hz;
     lr5.name = "120Hz-2";
 
-    expectedRanking = []() -> std::vector<FrameRateMode> {
+    expectedRanking = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{90_Hz, kMode90},
-                        {60_Hz, kMode60},
-                        {120_Hz, kMode120},
-                        {72_Hz, kMode72},
-                        {30_Hz, kMode30}};
+                return {.begin{{90_Hz, 90_Hz},
+                               {60_Hz, 60_Hz},
+                               {120_Hz, 120_Hz},
+                               {72_Hz, 72_Hz},
+                               {30_Hz, 30_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{90_Hz, kMode90}, {60_Hz, kMode60},  {120_Hz, kMode120}, {72_Hz, kMode72},
-                        {45_Hz, kMode90}, {40_Hz, kMode120}, {36_Hz, kMode72},   {30_Hz, kMode30}};
+                return {.begin{{90_Hz, 90_Hz},
+                               {60_Hz, 60_Hz},
+                               {120_Hz, 120_Hz},
+                               {72_Hz, 72_Hz},
+                               {45_Hz, 90_Hz},
+                               {40_Hz, 120_Hz},
+                               {36_Hz, 72_Hz},
+                               {30_Hz, 30_Hz}},
+                        .end{}};
         }
     }();
     actualRanking = selector.getRankedFrameRates(layers, {}).ranking;
@@ -1739,15 +1869,21 @@ TEST_P(RefreshRateSelectorTest, testDisplayModeOrdering) {
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates216, actualRanking.size());
     } else {
-        ASSERT_EQ(expectedRanking.size(), actualRanking.size());
+        ASSERT_EQ(expectedRanking.begin.size(), actualRanking.size());
     }
 
-    for (size_t i = 0; i < expectedRanking.size(); ++i) {
-        EXPECT_EQ(expectedRanking[i], actualRanking[i].frameRateMode)
-                << "Expected " << expectedRanking[i].fps.getIntValue() << " ("
-                << expectedRanking[i].modePtr->getFps().getIntValue() << ")"
-                << " Actual " << actualRanking[i].frameRateMode.fps.getIntValue() << " ("
-                << actualRanking[i].frameRateMode.modePtr->getFps().getIntValue() << ")";
+    for (size_t i = 0; i < expectedRanking.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRanking.begin[i];
+        EXPECT_EQ(expectedRenderRate, actualRanking[i].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate, actualRanking[i].frameRateMode.modePtr->getFps());
+    }
+
+    for (size_t i = 0; i < expectedRanking.end.size(); i++) {
+        const size_t refreshRateIndex = actualRanking.size() - expectedRanking.end.size() + i;
+        const auto [expectedRenderRate, expectedRefreshRate] = expectedRanking.end[i];
+        EXPECT_EQ(expectedRenderRate, actualRanking[refreshRateIndex].frameRateMode.fps);
+        EXPECT_EQ(expectedRefreshRate,
+                  actualRanking[refreshRateIndex].frameRateMode.modePtr->getFps());
     }
 }
 
@@ -2943,20 +3079,35 @@ TEST_P(RefreshRateSelectorTest, renderFrameRates) {
     auto selector = createSelector(kModes_30_60_72_90_120, kModeId120);
 
     // [renderRate, refreshRate]
-    const auto expected = []() -> std::vector<std::pair<Fps, Fps>> {
+    const auto expected = []() -> FpsBeginEnd {
         switch (GetParam()) {
             case Config::FrameRateOverride::Disabled:
             case Config::FrameRateOverride::AppOverrideNativeRefreshRates:
             case Config::FrameRateOverride::AppOverride:
-                return {{30_Hz, 30_Hz},
-                        {60_Hz, 60_Hz},
-                        {72_Hz, 72_Hz},
-                        {90_Hz, 90_Hz},
-                        {120_Hz, 120_Hz}};
+                return {.begin{{30_Hz, 30_Hz},
+                               {60_Hz, 60_Hz},
+                               {72_Hz, 72_Hz},
+                               {90_Hz, 90_Hz},
+                               {120_Hz, 120_Hz}}};
             case Config::FrameRateOverride::Enabled:
-                return {{1_Hz, 30_Hz},       {1.008_Hz, 120_Hz}, {1.011_Hz, 90_Hz},
-                        {1.014_Hz, 72_Hz},   {1.016_Hz, 60_Hz},  {1.022_Hz, 90_Hz},
-                        {1.0256_Hz, 120_Hz}, {1.028_Hz, 72_Hz}};
+                return {.begin{{1_Hz, 30_Hz},
+                               {1.008_Hz, 120_Hz},
+                               {1.011_Hz, 90_Hz},
+                               {1.014_Hz, 72_Hz},
+                               {1.016_Hz, 60_Hz},
+                               {1.022_Hz, 90_Hz},
+                               {1.0256_Hz, 120_Hz},
+                               {1.028_Hz, 72_Hz}},
+                        .end{
+                                {30_Hz, 30_Hz},
+                                {36_Hz, 72_Hz},
+                                {40_Hz, 120_Hz},
+                                {45_Hz, 90_Hz},
+                                {60_Hz, 60_Hz},
+                                {72_Hz, 72_Hz},
+                                {90_Hz, 90_Hz},
+                                {120_Hz, 120_Hz},
+                        }};
         }
     }();
 
@@ -2964,14 +3115,21 @@ TEST_P(RefreshRateSelectorTest, renderFrameRates) {
     if (GetParam() == Config::FrameRateOverride::Enabled) {
         ASSERT_EQ(kTotalRefreshRates216, primaryRefreshRates.size());
     } else {
-        ASSERT_EQ(expected.size(), primaryRefreshRates.size());
+        ASSERT_EQ(expected.begin.size(), primaryRefreshRates.size());
     }
 
-    for (size_t i = 0; i < expected.size(); i++) {
-        const auto [expectedRenderRate, expectedRefreshRate] = expected[i];
+    for (size_t i = 0; i < expected.begin.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expected.begin[i];
         EXPECT_EQ(expectedRenderRate, primaryRefreshRates[i].fps);
         EXPECT_EQ(expectedRefreshRate, primaryRefreshRates[i].modePtr->getFps());
     }
+
+    for (size_t i = 0; i < expected.end.size(); i++) {
+        const auto [expectedRenderRate, expectedRefreshRate] = expected.end[i];
+        const size_t refreshRateIndex = primaryRefreshRates.size() - expected.end.size() + i;
+        EXPECT_EQ(expectedRenderRate, primaryRefreshRates[refreshRateIndex].fps);
+        EXPECT_EQ(expectedRefreshRate, primaryRefreshRates[refreshRateIndex].modePtr->getFps());
+    }
 }
 
 TEST_P(RefreshRateSelectorTest, refreshRateIsCappedWithRenderFrameRate) {