1 /*
2 * Copyright 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #undef LOG_TAG
18 #define LOG_TAG "FlagManagerTest"
19
20 #include <common/FlagManager.h>
21 #include <common/test/FlagUtils.h>
22
23 #include <gmock/gmock.h>
24 #include <gtest/gtest.h>
25 #include <log/log.h>
26
27 #include <com_android_graphics_surfaceflinger_flags.h>
28
29 namespace android {
30
31 using namespace com::android::graphics::surfaceflinger;
32 using testing::Return;
33
34 class TestableFlagManager : public FlagManager {
35 public:
TestableFlagManager()36 TestableFlagManager() : FlagManager(ConstructorTag{}) { markBootCompleted(); }
37 ~TestableFlagManager() = default;
38
39 MOCK_METHOD(std::optional<bool>, getBoolProperty, (const char*), (const, override));
40 MOCK_METHOD(bool, getServerConfigurableFlag, (const char*), (const, override));
41
markBootIncomplete()42 void markBootIncomplete() { mBootCompleted = false; }
43 };
44
45 class FlagManagerTest : public testing::Test {
46 public:
FlagManagerTest()47 FlagManagerTest() {
48 const ::testing::TestInfo* const test_info =
49 ::testing::UnitTest::GetInstance()->current_test_info();
50 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
51 }
~FlagManagerTest()52 ~FlagManagerTest() override {
53 const ::testing::TestInfo* const test_info =
54 ::testing::UnitTest::GetInstance()->current_test_info();
55 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
56 }
57
58 TestableFlagManager mFlagManager;
59 };
60
TEST_F(FlagManagerTest,isSingleton)61 TEST_F(FlagManagerTest, isSingleton) {
62 EXPECT_EQ(&FlagManager::getInstance(), &FlagManager::getInstance());
63 }
64
TEST_F(FlagManagerTest,legacyCreashesIfQueriedBeforeBoot)65 TEST_F(FlagManagerTest, legacyCreashesIfQueriedBeforeBoot) {
66 mFlagManager.markBootIncomplete();
67 EXPECT_DEATH(FlagManager::getInstance().test_flag(), "");
68 }
69
TEST_F(FlagManagerTest,legacyReturnsOverride)70 TEST_F(FlagManagerTest, legacyReturnsOverride) {
71 EXPECT_CALL(mFlagManager, getBoolProperty).WillOnce(Return(true));
72 EXPECT_EQ(true, mFlagManager.test_flag());
73
74 EXPECT_CALL(mFlagManager, getBoolProperty).WillOnce(Return(false));
75 EXPECT_EQ(false, mFlagManager.test_flag());
76 }
77
TEST_F(FlagManagerTest,legacyReturnsValue)78 TEST_F(FlagManagerTest, legacyReturnsValue) {
79 EXPECT_CALL(mFlagManager, getBoolProperty).WillRepeatedly(Return(std::nullopt));
80
81 EXPECT_CALL(mFlagManager, getServerConfigurableFlag).WillOnce(Return(true));
82 EXPECT_EQ(true, mFlagManager.test_flag());
83
84 EXPECT_CALL(mFlagManager, getServerConfigurableFlag).WillOnce(Return(false));
85 EXPECT_EQ(false, mFlagManager.test_flag());
86 }
87
TEST_F(FlagManagerTest,returnsOverrideTrue)88 TEST_F(FlagManagerTest, returnsOverrideTrue) {
89 mFlagManager.markBootCompleted();
90
91 SET_FLAG_FOR_TEST(flags::refresh_rate_overlay_on_external_display, false);
92
93 // This is stored in a static variable, so this test depends on the fact
94 // that this flag has not been read in this process.
95 EXPECT_CALL(mFlagManager, getBoolProperty).WillOnce(Return(true));
96 EXPECT_TRUE(mFlagManager.refresh_rate_overlay_on_external_display());
97
98 // Further calls will not result in further calls to getBoolProperty.
99 EXPECT_TRUE(mFlagManager.refresh_rate_overlay_on_external_display());
100 }
101
TEST_F(FlagManagerTest,returnsOverrideReadonly)102 TEST_F(FlagManagerTest, returnsOverrideReadonly) {
103 SET_FLAG_FOR_TEST(flags::add_sf_skipped_frames_to_trace, false);
104
105 // This is stored in a static variable, so this test depends on the fact
106 // that this flag has not been read in this process.
107 EXPECT_CALL(mFlagManager, getBoolProperty).WillOnce(Return(true));
108 EXPECT_TRUE(mFlagManager.add_sf_skipped_frames_to_trace());
109 }
110
111 // disabling this test since we need to use a unique flag for this test,
112 // but we only one server flag currently. Re-enable once we have a new flag
113 // and change this test to use a unique flag.
TEST_F(FlagManagerTest,DISABLED_returnsOverrideFalse)114 TEST_F(FlagManagerTest, DISABLED_returnsOverrideFalse) {
115 mFlagManager.markBootCompleted();
116
117 SET_FLAG_FOR_TEST(flags::refresh_rate_overlay_on_external_display, true);
118
119 // This is stored in a static variable, so this test depends on the fact
120 // that this flag has not been read in this process.
121 EXPECT_CALL(mFlagManager, getBoolProperty).WillOnce(Return(false));
122 EXPECT_FALSE(mFlagManager.refresh_rate_overlay_on_external_display());
123 }
124
TEST_F(FlagManagerTest,ignoresOverrideInUnitTestMode)125 TEST_F(FlagManagerTest, ignoresOverrideInUnitTestMode) {
126 mFlagManager.setUnitTestMode();
127
128 SET_FLAG_FOR_TEST(flags::multithreaded_present, true);
129
130 // If this has not been called in this process, it will be called.
131 // Regardless, the result is ignored.
132 EXPECT_CALL(mFlagManager, getBoolProperty).WillRepeatedly(Return(false));
133
134 EXPECT_EQ(true, mFlagManager.multithreaded_present());
135 }
136
TEST_F(FlagManagerTest,returnsValue)137 TEST_F(FlagManagerTest, returnsValue) {
138 mFlagManager.setUnitTestMode();
139
140 EXPECT_CALL(mFlagManager, getBoolProperty).WillRepeatedly(Return(std::nullopt));
141
142 {
143 SET_FLAG_FOR_TEST(flags::refresh_rate_overlay_on_external_display, true);
144 EXPECT_EQ(true, mFlagManager.refresh_rate_overlay_on_external_display());
145 }
146
147 {
148 SET_FLAG_FOR_TEST(flags::refresh_rate_overlay_on_external_display, false);
149 EXPECT_EQ(false, mFlagManager.refresh_rate_overlay_on_external_display());
150 }
151 }
152
TEST_F(FlagManagerTest,readonlyReturnsValue)153 TEST_F(FlagManagerTest, readonlyReturnsValue) {
154 mFlagManager.setUnitTestMode();
155
156 EXPECT_CALL(mFlagManager, getBoolProperty).WillRepeatedly(Return(std::nullopt));
157
158 {
159 SET_FLAG_FOR_TEST(flags::misc1, true);
160 EXPECT_EQ(true, mFlagManager.misc1());
161 }
162
163 {
164 SET_FLAG_FOR_TEST(flags::misc1, false);
165 EXPECT_EQ(false, mFlagManager.misc1());
166 }
167 }
168
169 } // namespace android
170