| Avi Drissman | e4622aa | 2022-09-08 20:36:06 | [diff] [blame] | 1 | // Copyright 2015 The Chromium Authors |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include"base/feature_list.h" |
| 6 | |
| avi | 9b6f4293 | 2015-12-26 22:15:14 | [diff] [blame] | 7 | #include<stddef.h> |
| 8 | |
| Peter Kasting | 025a9425 | 2025-01-29 21:28:37 | [diff] [blame] | 9 | #include<algorithm> |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 10 | #include<array> |
| Kendrake Tsui | d3895ec | 2024-01-22 22:08:39 | [diff] [blame] | 11 | #include<ostream> |
| 12 | #include<set> |
| 13 | #include<string> |
| Helmut Januschka | bf1d5e5 | 2024-04-05 02:30:27 | [diff] [blame] | 14 | #include<string_view> |
| danakj | 0c8d4aa | 2015-11-25 05:29:58 | [diff] [blame] | 15 | #include<utility> |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 16 | #include<vector> |
| danakj | 0c8d4aa | 2015-11-25 05:29:58 | [diff] [blame] | 17 | |
| Miriam Zimmerman | b4683c1 | 2021-12-01 15:44:33 | [diff] [blame] | 18 | #include"base/feature_list_buildflags.h" |
| Leszek Swirski | f7f53b43 | 2024-09-30 10:12:10 | [diff] [blame] | 19 | #include"base/feature_visitor.h" |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 20 | #include"base/format_macros.h" |
| Alexandr Ilin | 027ca3d3 | 2019-02-12 18:37:33 | [diff] [blame] | 21 | #include"base/memory/read_only_shared_memory_region.h" |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 22 | #include"base/metrics/field_trial.h" |
| Miriam Zimmerman | 79f6cac | 2022-06-17 17:58:25 | [diff] [blame] | 23 | #include"base/metrics/field_trial_param_associator.h" |
| lawrencewu | 5e03cd3 | 2016-12-05 16:23:28 | [diff] [blame] | 24 | #include"base/metrics/persistent_memory_allocator.h" |
| Miriam Zimmerman | b4683c1 | 2021-12-01 15:44:33 | [diff] [blame] | 25 | #include"base/strings/strcat.h" |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 26 | #include"base/strings/string_util.h" |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 27 | #include"base/strings/stringprintf.h" |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 28 | #include"base/test/scoped_feature_list.h" |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 29 | #include"testing/gtest/include/gtest/gtest.h" |
| 30 | |
| 31 | namespace base{ |
| 32 | |
| 33 | namespace{ |
| 34 | |
| brucedawson | 702ade7 | 2017-01-24 00:27:05 | [diff] [blame] | 35 | constexprchar kFeatureOnByDefaultName[]="OnByDefault"; |
| Daniel Cheng | 2628f68 | 2024-05-03 16:18:45 | [diff] [blame] | 36 | BASE_FEATURE(kFeatureOnByDefault, |
| 37 | kFeatureOnByDefaultName, |
| 38 | FEATURE_ENABLED_BY_DEFAULT); |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 39 | |
| brucedawson | 702ade7 | 2017-01-24 00:27:05 | [diff] [blame] | 40 | constexprchar kFeatureOffByDefaultName[]="OffByDefault"; |
| Daniel Cheng | 2628f68 | 2024-05-03 16:18:45 | [diff] [blame] | 41 | BASE_FEATURE(kFeatureOffByDefault, |
| 42 | kFeatureOffByDefaultName, |
| 43 | FEATURE_DISABLED_BY_DEFAULT); |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 44 | |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 45 | std::stringSortFeatureListString(const std::string& feature_list){ |
| Helmut Januschka | bf1d5e5 | 2024-04-05 02:30:27 | [diff] [blame] | 46 | std::vector<std::string_view> features= |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 47 | FeatureList::SplitFeatureListString(feature_list); |
| Peter Kasting | 025a9425 | 2025-01-29 21:28:37 | [diff] [blame] | 48 | std::ranges::sort(features); |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 49 | returnJoinString(features,","); |
| 50 | } |
| 51 | |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 52 | }// namespace |
| 53 | |
| 54 | classFeatureListTest:public testing::Test{ |
| 55 | public: |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 56 | FeatureListTest(){ |
| 57 | // Provide an empty FeatureList to each test by default. |
| 58 | scoped_feature_list_.InitWithFeatureList(std::make_unique<FeatureList>()); |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 59 | } |
| David Bienvenu | b4b441e | 2020-09-23 05:49:57 | [diff] [blame] | 60 | FeatureListTest(constFeatureListTest&)=delete; |
| 61 | FeatureListTest&operator=(constFeatureListTest&)=delete; |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 62 | ~FeatureListTest() override=default; |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 63 | |
| 64 | private: |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 65 | test::ScopedFeatureList scoped_feature_list_; |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 66 | }; |
| 67 | |
| 68 | TEST_F(FeatureListTest,DefaultStates){ |
| 69 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 70 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 71 | } |
| 72 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 73 | TEST_F(FeatureListTest,InitFromCommandLine){ |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 74 | structTestCases{ |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 75 | constchar* enable_features; |
| 76 | constchar* disable_features; |
| 77 | bool expected_feature_on_state; |
| 78 | bool expected_feature_off_state; |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 79 | }; |
| 80 | auto test_cases= std::to_array<TestCases>({ |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 81 | {"","",true,false}, |
| 82 | {"OffByDefault","",true,true}, |
| 83 | {"OffByDefault","OnByDefault",false,true}, |
| 84 | {"OnByDefault,OffByDefault","",true,true}, |
| 85 | {"","OnByDefault,OffByDefault",false,false}, |
| 86 | // In the case an entry is both, disable takes precedence. |
| 87 | {"OnByDefault","OnByDefault,OffByDefault",false,false}, |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 88 | }); |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 89 | |
| Daniel Cheng | f45f4760 | 2022-02-28 22:38:32 | [diff] [blame] | 90 | for(size_t i=0; i< std::size(test_cases);++i){ |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 91 | constauto& test_case= test_cases[i]; |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 92 | SCOPED_TRACE(base::StringPrintf("Test[%"PRIuS"]: [%s] [%s]", i, |
| 93 | test_case.enable_features, |
| 94 | test_case.disable_features)); |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 95 | |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 96 | auto feature_list= std::make_unique<FeatureList>(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 97 | feature_list->InitFromCommandLine(test_case.enable_features, |
| 98 | test_case.disable_features); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 99 | test::ScopedFeatureList scoped_feature_list; |
| 100 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 101 | |
| 102 | EXPECT_EQ(test_case.expected_feature_on_state, |
| 103 | FeatureList::IsEnabled(kFeatureOnByDefault)) |
| 104 | << i; |
| 105 | EXPECT_EQ(test_case.expected_feature_off_state, |
| 106 | FeatureList::IsEnabled(kFeatureOffByDefault)) |
| 107 | << i; |
| Anthony Vallee-Dubois | 3475f66 | 2022-08-30 14:24:28 | [diff] [blame] | 108 | |
| 109 | // Reading the state of each feature again will pull it from their |
| 110 | // respective caches instead of performing the full lookup, which should |
| 111 | // yield the same result. |
| 112 | EXPECT_EQ(test_case.expected_feature_on_state, |
| 113 | FeatureList::IsEnabled(kFeatureOnByDefault)) |
| 114 | << i; |
| 115 | EXPECT_EQ(test_case.expected_feature_off_state, |
| 116 | FeatureList::IsEnabled(kFeatureOffByDefault)) |
| 117 | << i; |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 118 | } |
| 119 | } |
| 120 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 121 | TEST_F(FeatureListTest,InitFromCommandLineWithFeatureParams){ |
| Weilun Shi | e81c6b9 | 2020-07-06 20:33:59 | [diff] [blame] | 122 | struct{ |
| 123 | const std::string enable_features; |
| 124 | const std::string expected_field_trial_created; |
| 125 | const std::map<std::string, std::string> expected_feature_params; |
| 126 | } test_cases[]={ |
| 127 | {"Feature:x/100/y/test","StudyFeature",{{"x","100"},{"y","test"}}}, |
| 128 | {"Feature<Trial1:x/200/y/123","Trial1",{{"x","200"},{"y","123"}}}, |
| 129 | {"Feature<Trial2.Group2:x/test/y/uma/z/ukm", |
| 130 | "Trial2", |
| 131 | {{"x","test"},{"y","uma"},{"z","ukm"}}}, |
| 132 | }; |
| 133 | |
| Miriam Zimmerman | 79f6cac | 2022-06-17 17:58:25 | [diff] [blame] | 134 | // Clear global state so that repeated runs of this test don't flake. |
| 135 | // When https://crrev.com/c/3694674 is submitted, we should be able to remove |
| 136 | // this. |
| 137 | base::FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting(); |
| 138 | |
| Daniel Cheng | 0fff5c23 | 2022-09-21 17:43:34 | [diff] [blame] | 139 | static BASE_FEATURE(kFeature,"Feature", FEATURE_DISABLED_BY_DEFAULT); |
| Weilun Shi | e81c6b9 | 2020-07-06 20:33:59 | [diff] [blame] | 140 | for(constauto& test_case: test_cases){ |
| 141 | SCOPED_TRACE(test_case.enable_features); |
| 142 | |
| 143 | auto feature_list= std::make_unique<FeatureList>(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 144 | feature_list->InitFromCommandLine(test_case.enable_features,""); |
| Weilun Shi | e81c6b9 | 2020-07-06 20:33:59 | [diff] [blame] | 145 | test::ScopedFeatureList scoped_feature_list; |
| 146 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| 147 | |
| 148 | EXPECT_TRUE(FeatureList::IsEnabled(kFeature)); |
| 149 | EXPECT_TRUE( |
| 150 | FieldTrialList::IsTrialActive(test_case.expected_field_trial_created)); |
| Miriam Zimmerman | 79f6cac | 2022-06-17 17:58:25 | [diff] [blame] | 151 | std::map<std::string, std::string> actual_params; |
| 152 | EXPECT_TRUE(GetFieldTrialParamsByFeature(kFeature,&actual_params)); |
| 153 | EXPECT_EQ(test_case.expected_feature_params, actual_params); |
| Weilun Shi | e81c6b9 | 2020-07-06 20:33:59 | [diff] [blame] | 154 | } |
| 155 | } |
| 156 | |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 157 | TEST_F(FeatureListTest,CheckFeatureIdentity){ |
| 158 | // Tests that CheckFeatureIdentity() correctly detects when two different |
| 159 | // structs with the same feature name are passed to it. |
| 160 | |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 161 | test::ScopedFeatureList scoped_feature_list; |
| 162 | scoped_feature_list.InitWithFeatureList(std::make_unique<FeatureList>()); |
| 163 | FeatureList* feature_list=FeatureList::GetInstance(); |
| 164 | |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 165 | // Call it twice for each feature at the top of the file, since the first call |
| 166 | // makes it remember the entry and the second call will verify it. |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 167 | EXPECT_TRUE(feature_list->CheckFeatureIdentity(kFeatureOnByDefault)); |
| 168 | EXPECT_TRUE(feature_list->CheckFeatureIdentity(kFeatureOnByDefault)); |
| 169 | EXPECT_TRUE(feature_list->CheckFeatureIdentity(kFeatureOffByDefault)); |
| 170 | EXPECT_TRUE(feature_list->CheckFeatureIdentity(kFeatureOffByDefault)); |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 171 | |
| 172 | // Now, call it with a distinct struct for |kFeatureOnByDefaultName|, which |
| 173 | // should return false. |
| Daniel Cheng | 2628f68 | 2024-05-03 16:18:45 | [diff] [blame] | 174 | static BASE_FEATURE(kFeatureOnByDefault2, kFeatureOnByDefaultName, |
| 175 | FEATURE_ENABLED_BY_DEFAULT); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 176 | EXPECT_FALSE(feature_list->CheckFeatureIdentity(kFeatureOnByDefault2)); |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 177 | } |
| 178 | |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 179 | TEST_F(FeatureListTest,FieldTrialOverrides){ |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 180 | structTestCases{ |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 181 | FeatureList::OverrideState trial1_state; |
| 182 | FeatureList::OverrideState trial2_state; |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 183 | }; |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 184 | auto test_cases= std::to_array<TestCases>({ |
| 185 | {FeatureList::OVERRIDE_DISABLE_FEATURE, |
| 186 | FeatureList::OVERRIDE_DISABLE_FEATURE}, |
| 187 | {FeatureList::OVERRIDE_DISABLE_FEATURE, |
| 188 | FeatureList::OVERRIDE_ENABLE_FEATURE}, |
| 189 | {FeatureList::OVERRIDE_ENABLE_FEATURE, |
| 190 | FeatureList::OVERRIDE_DISABLE_FEATURE}, |
| 191 | {FeatureList::OVERRIDE_ENABLE_FEATURE, |
| 192 | FeatureList::OVERRIDE_ENABLE_FEATURE}, |
| 193 | }); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 194 | |
| 195 | FieldTrial::ActiveGroup active_group; |
| Daniel Cheng | f45f4760 | 2022-02-28 22:38:32 | [diff] [blame] | 196 | for(size_t i=0; i< std::size(test_cases);++i){ |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 197 | constauto& test_case= test_cases[i]; |
| 198 | SCOPED_TRACE(base::StringPrintf("Test[%"PRIuS"]", i)); |
| 199 | |
| Takashi Sakamoto | 15d4a67 | 2022-08-05 07:24:16 | [diff] [blame] | 200 | test::ScopedFeatureList outer_scope; |
| 201 | outer_scope.InitWithEmptyFeatureAndFieldTrialLists(); |
| 202 | |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 203 | auto feature_list= std::make_unique<FeatureList>(); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 204 | |
| 205 | FieldTrial* trial1=FieldTrialList::CreateFieldTrial("TrialExample1","A"); |
| 206 | FieldTrial* trial2=FieldTrialList::CreateFieldTrial("TrialExample2","B"); |
| 207 | feature_list->RegisterFieldTrialOverride(kFeatureOnByDefaultName, |
| 208 | test_case.trial1_state, trial1); |
| 209 | feature_list->RegisterFieldTrialOverride(kFeatureOffByDefaultName, |
| 210 | test_case.trial2_state, trial2); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 211 | test::ScopedFeatureList scoped_feature_list; |
| 212 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 213 | |
| 214 | // Initially, neither trial should be active. |
| 215 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial1->trial_name())); |
| 216 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial2->trial_name())); |
| 217 | |
| 218 | constbool expected_enabled_1= |
| 219 | (test_case.trial1_state==FeatureList::OVERRIDE_ENABLE_FEATURE); |
| 220 | EXPECT_EQ(expected_enabled_1,FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 221 | // The above should have activated |trial1|. |
| 222 | EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name())); |
| 223 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial2->trial_name())); |
| 224 | |
| 225 | constbool expected_enabled_2= |
| 226 | (test_case.trial2_state==FeatureList::OVERRIDE_ENABLE_FEATURE); |
| 227 | EXPECT_EQ(expected_enabled_2,FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 228 | // The above should have activated |trial2|. |
| 229 | EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name())); |
| 230 | EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name())); |
| 231 | } |
| 232 | } |
| 233 | |
| asvitkine | 64e9e11 | 2016-03-17 17:32:00 | [diff] [blame] | 234 | TEST_F(FeatureListTest,FieldTrialAssociateUseDefault){ |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 235 | auto feature_list= std::make_unique<FeatureList>(); |
| asvitkine | 64e9e11 | 2016-03-17 17:32:00 | [diff] [blame] | 236 | |
| 237 | FieldTrial* trial1=FieldTrialList::CreateFieldTrial("TrialExample1","A"); |
| 238 | FieldTrial* trial2=FieldTrialList::CreateFieldTrial("TrialExample2","B"); |
| 239 | feature_list->RegisterFieldTrialOverride( |
| 240 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, trial1); |
| 241 | feature_list->RegisterFieldTrialOverride( |
| 242 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, trial2); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 243 | test::ScopedFeatureList scoped_feature_list; |
| 244 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | 64e9e11 | 2016-03-17 17:32:00 | [diff] [blame] | 245 | |
| 246 | // Initially, neither trial should be active. |
| 247 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial1->trial_name())); |
| 248 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial2->trial_name())); |
| 249 | |
| 250 | // Check the feature enabled state is its default. |
| 251 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 252 | // The above should have activated |trial1|. |
| 253 | EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name())); |
| 254 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial2->trial_name())); |
| 255 | |
| 256 | // Check the feature enabled state is its default. |
| 257 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 258 | // The above should have activated |trial2|. |
| 259 | EXPECT_TRUE(FieldTrialList::IsTrialActive(trial1->trial_name())); |
| 260 | EXPECT_TRUE(FieldTrialList::IsTrialActive(trial2->trial_name())); |
| 261 | } |
| 262 | |
| Alexei Svitkine | d3a55e7d4 | 2019-02-19 17:09:32 | [diff] [blame] | 263 | TEST_F(FeatureListTest,CommandLineEnableTakesPrecedenceOverFieldTrial){ |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 264 | auto feature_list= std::make_unique<FeatureList>(); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 265 | |
| 266 | // The feature is explicitly enabled on the command-line. |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 267 | feature_list->InitFromCommandLine(kFeatureOffByDefaultName,""); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 268 | |
| 269 | // But the FieldTrial would set the feature to disabled. |
| 270 | FieldTrial* trial=FieldTrialList::CreateFieldTrial("TrialExample2","A"); |
| 271 | feature_list->RegisterFieldTrialOverride( |
| 272 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE, trial); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 273 | test::ScopedFeatureList scoped_feature_list; |
| 274 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 275 | |
| 276 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name())); |
| 277 | // Command-line should take precedence. |
| 278 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 279 | // Since the feature is on due to the command-line, and not as a result of the |
| 280 | // field trial, the field trial should not be activated (since the Associate* |
| 281 | // API wasn't used.) |
| 282 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name())); |
| 283 | } |
| 284 | |
| Alexei Svitkine | d3a55e7d4 | 2019-02-19 17:09:32 | [diff] [blame] | 285 | TEST_F(FeatureListTest,CommandLineDisableTakesPrecedenceOverFieldTrial){ |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 286 | auto feature_list= std::make_unique<FeatureList>(); |
| Alexei Svitkine | d3a55e7d4 | 2019-02-19 17:09:32 | [diff] [blame] | 287 | |
| 288 | // The feature is explicitly disabled on the command-line. |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 289 | feature_list->InitFromCommandLine("", kFeatureOffByDefaultName); |
| Alexei Svitkine | d3a55e7d4 | 2019-02-19 17:09:32 | [diff] [blame] | 290 | |
| 291 | // But the FieldTrial would set the feature to enabled. |
| 292 | FieldTrial* trial=FieldTrialList::CreateFieldTrial("TrialExample2","A"); |
| 293 | feature_list->RegisterFieldTrialOverride( |
| 294 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE, trial); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 295 | test::ScopedFeatureList scoped_feature_list; |
| 296 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| Alexei Svitkine | d3a55e7d4 | 2019-02-19 17:09:32 | [diff] [blame] | 297 | |
| 298 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name())); |
| 299 | // Command-line should take precedence. |
| 300 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 301 | // Since the feature is on due to the command-line, and not as a result of the |
| 302 | // field trial, the field trial should not be activated (since the Associate* |
| 303 | // API wasn't used.) |
| 304 | EXPECT_FALSE(FieldTrialList::IsTrialActive(trial->trial_name())); |
| 305 | } |
| 306 | |
| Xianzhu Wang | 05355f4a | 2020-09-02 01:22:16 | [diff] [blame] | 307 | TEST_F(FeatureListTest,IsFeatureOverriddenFromFieldTrial){ |
| 308 | auto feature_list= std::make_unique<FeatureList>(); |
| 309 | |
| 310 | // No features are overridden from the field trails yet. |
| 311 | EXPECT_FALSE(feature_list->IsFeatureOverridden(kFeatureOnByDefaultName)); |
| 312 | EXPECT_FALSE(feature_list->IsFeatureOverridden(kFeatureOffByDefaultName)); |
| 313 | |
| Alexei Svitkine | aadca90 | 2025-06-12 22:41:18 | [diff] [blame] | 314 | // Now, register field trials to override `kFeatureOnByDefaultName` state and |
| 315 | // keeping `kFeatureOffByDefault` as the default. Check that both are |
| 316 | // considered overridden. |
| Xianzhu Wang | 05355f4a | 2020-09-02 01:22:16 | [diff] [blame] | 317 | feature_list->RegisterFieldTrialOverride( |
| 318 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, |
| 319 | FieldTrialList::CreateFieldTrial("Trial1","A")); |
| 320 | feature_list->RegisterFieldTrialOverride( |
| 321 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE, |
| 322 | FieldTrialList::CreateFieldTrial("Trial2","A")); |
| 323 | EXPECT_TRUE(feature_list->IsFeatureOverridden(kFeatureOnByDefaultName)); |
| 324 | EXPECT_TRUE(feature_list->IsFeatureOverridden(kFeatureOffByDefaultName)); |
| 325 | |
| 326 | test::ScopedFeatureList scoped_feature_list; |
| 327 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| 328 | // Check the expected feature states for good measure. |
| 329 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 330 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 331 | } |
| 332 | |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 333 | TEST_F(FeatureListTest,IsFeatureOverriddenFromCommandLine){ |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 334 | auto feature_list= std::make_unique<FeatureList>(); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 335 | |
| 336 | // No features are overridden from the command line yet |
| Xianzhu Wang | 05355f4a | 2020-09-02 01:22:16 | [diff] [blame] | 337 | EXPECT_FALSE(feature_list->IsFeatureOverridden(kFeatureOnByDefaultName)); |
| Collin Baker | 3435ba66 | 2020-10-07 18:07:09 | [diff] [blame] | 338 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 339 | kFeatureOnByDefaultName)); |
| Xianzhu Wang | 05355f4a | 2020-09-02 01:22:16 | [diff] [blame] | 340 | EXPECT_FALSE(feature_list->IsFeatureOverridden(kFeatureOffByDefaultName)); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 341 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| Collin Baker | 3435ba66 | 2020-10-07 18:07:09 | [diff] [blame] | 342 | kFeatureOffByDefaultName)); |
| 343 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 344 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE)); |
| 345 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 346 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE)); |
| 347 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 348 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE)); |
| 349 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 350 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE)); |
| 351 | |
| 352 | // Now, enable |kFeatureOffByDefaultName| via the command-line. |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 353 | feature_list->InitFromCommandLine(kFeatureOffByDefaultName,""); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 354 | |
| 355 | // It should now be overridden for the enabled group. |
| Xianzhu Wang | 05355f4a | 2020-09-02 01:22:16 | [diff] [blame] | 356 | EXPECT_TRUE(feature_list->IsFeatureOverridden(kFeatureOffByDefaultName)); |
| Collin Baker | 3435ba66 | 2020-10-07 18:07:09 | [diff] [blame] | 357 | EXPECT_TRUE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 358 | kFeatureOffByDefaultName)); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 359 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 360 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE)); |
| 361 | EXPECT_TRUE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 362 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE)); |
| 363 | |
| 364 | // Register a field trial to associate with the feature and ensure that the |
| 365 | // results are still the same. |
| 366 | feature_list->AssociateReportingFieldTrial( |
| 367 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE, |
| 368 | FieldTrialList::CreateFieldTrial("Trial1","A")); |
| Xianzhu Wang | 05355f4a | 2020-09-02 01:22:16 | [diff] [blame] | 369 | EXPECT_TRUE(feature_list->IsFeatureOverridden(kFeatureOffByDefaultName)); |
| Collin Baker | 3435ba66 | 2020-10-07 18:07:09 | [diff] [blame] | 370 | EXPECT_TRUE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 371 | kFeatureOffByDefaultName)); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 372 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 373 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE)); |
| 374 | EXPECT_TRUE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 375 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE)); |
| 376 | |
| 377 | // Now, register a field trial to override |kFeatureOnByDefaultName| state |
| 378 | // and check that the function still returns false for that feature. |
| 379 | feature_list->RegisterFieldTrialOverride( |
| 380 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE, |
| 381 | FieldTrialList::CreateFieldTrial("Trial2","A")); |
| Xianzhu Wang | 05355f4a | 2020-09-02 01:22:16 | [diff] [blame] | 382 | EXPECT_TRUE(feature_list->IsFeatureOverridden(kFeatureOnByDefaultName)); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 383 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| Collin Baker | 3435ba66 | 2020-10-07 18:07:09 | [diff] [blame] | 384 | kFeatureOnByDefaultName)); |
| 385 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 386 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE)); |
| 387 | EXPECT_FALSE(feature_list->IsFeatureOverriddenFromCommandLine( |
| 388 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE)); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 389 | test::ScopedFeatureList scoped_feature_list; |
| 390 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 391 | |
| 392 | // Check the expected feature states for good measure. |
| 393 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 394 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 395 | } |
| 396 | |
| 397 | TEST_F(FeatureListTest,AssociateReportingFieldTrial){ |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 398 | structTestCases{ |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 399 | constchar* enable_features; |
| 400 | constchar* disable_features; |
| 401 | bool expected_enable_trial_created; |
| 402 | bool expected_disable_trial_created; |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 403 | }; |
| 404 | auto test_cases= std::to_array<TestCases>({ |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 405 | // If no enable/disable flags are specified, no trials should be created. |
| 406 | {"","",false,false}, |
| 407 | // Enabling the feature should result in the enable trial created. |
| 408 | {kFeatureOffByDefaultName,"",true,false}, |
| 409 | // Disabling the feature should result in the disable trial created. |
| 410 | {"", kFeatureOffByDefaultName,false,true}, |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 411 | }); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 412 | |
| 413 | constchar kTrialName[]="ForcingTrial"; |
| 414 | constchar kForcedOnGroupName[]="ForcedOn"; |
| 415 | constchar kForcedOffGroupName[]="ForcedOff"; |
| 416 | |
| Daniel Cheng | f45f4760 | 2022-02-28 22:38:32 | [diff] [blame] | 417 | for(size_t i=0; i< std::size(test_cases);++i){ |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 418 | constauto& test_case= test_cases[i]; |
| 419 | SCOPED_TRACE(base::StringPrintf("Test[%"PRIuS"]: [%s] [%s]", i, |
| 420 | test_case.enable_features, |
| 421 | test_case.disable_features)); |
| 422 | |
| Takashi Sakamoto | 15d4a67 | 2022-08-05 07:24:16 | [diff] [blame] | 423 | test::ScopedFeatureList outer_scope; |
| 424 | outer_scope.InitWithEmptyFeatureAndFieldTrialLists(); |
| 425 | |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 426 | auto feature_list= std::make_unique<FeatureList>(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 427 | feature_list->InitFromCommandLine(test_case.enable_features, |
| 428 | test_case.disable_features); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 429 | |
| 430 | FieldTrial* enable_trial=nullptr; |
| 431 | if(feature_list->IsFeatureOverriddenFromCommandLine( |
| 432 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE)){ |
| 433 | enable_trial= base::FieldTrialList::CreateFieldTrial(kTrialName, |
| 434 | kForcedOnGroupName); |
| 435 | feature_list->AssociateReportingFieldTrial( |
| 436 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE, |
| 437 | enable_trial); |
| 438 | } |
| 439 | FieldTrial* disable_trial=nullptr; |
| 440 | if(feature_list->IsFeatureOverriddenFromCommandLine( |
| 441 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE)){ |
| 442 | disable_trial= base::FieldTrialList::CreateFieldTrial( |
| 443 | kTrialName, kForcedOffGroupName); |
| 444 | feature_list->AssociateReportingFieldTrial( |
| 445 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE, |
| 446 | disable_trial); |
| 447 | } |
| 448 | EXPECT_EQ(test_case.expected_enable_trial_created, enable_trial!=nullptr); |
| 449 | EXPECT_EQ(test_case.expected_disable_trial_created, |
| 450 | disable_trial!=nullptr); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 451 | test::ScopedFeatureList scoped_feature_list; |
| 452 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | 8423d17 | 2015-09-28 23:23:44 | [diff] [blame] | 453 | |
| 454 | EXPECT_FALSE(FieldTrialList::IsTrialActive(kTrialName)); |
| 455 | if(disable_trial){ |
| 456 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 457 | EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName)); |
| 458 | EXPECT_EQ(kForcedOffGroupName, disable_trial->group_name()); |
| 459 | }elseif(enable_trial){ |
| 460 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 461 | EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName)); |
| 462 | EXPECT_EQ(kForcedOnGroupName, enable_trial->group_name()); |
| 463 | } |
| 464 | } |
| 465 | } |
| 466 | |
| Alexei Svitkine | f3d64cae | 2024-11-20 19:55:56 | [diff] [blame] | 467 | TEST_F(FeatureListTest,RegisterExtraFeatureOverrides_ReplaceUseDefault){ |
| 468 | auto feature_list= std::make_unique<FeatureList>(); |
| 469 | |
| 470 | FieldTrial* trial1=FieldTrialList::CreateFieldTrial("Trial1","Group"); |
| 471 | feature_list->RegisterFieldTrialOverride( |
| 472 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, trial1); |
| 473 | |
| 474 | FieldTrial* trial2=FieldTrialList::CreateFieldTrial("Trial2","Group"); |
| 475 | feature_list->RegisterFieldTrialOverride( |
| 476 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, trial2); |
| 477 | |
| 478 | std::vector<FeatureList::FeatureOverrideInfo> overrides; |
| 479 | overrides.emplace_back(std::cref(kFeatureOnByDefault), |
| 480 | FeatureList::OverrideState::OVERRIDE_DISABLE_FEATURE); |
| 481 | overrides.emplace_back(std::cref(kFeatureOffByDefault), |
| 482 | FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE); |
| 483 | feature_list->RegisterExtraFeatureOverrides( |
| 484 | std::move(overrides),/*replace_use_default_overrides=*/true); |
| 485 | test::ScopedFeatureList scoped_feature_list; |
| 486 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| 487 | |
| 488 | // OVERRIDE_USE_DEFAULT entries should be overridden by AwFeatureOverrides. |
| 489 | // Before querying the feature, the trials shouldn't be active, but should |
| 490 | // be activated after querying. |
| 491 | |
| 492 | EXPECT_FALSE(base::FieldTrialList::IsTrialActive("Trial1")); |
| 493 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 494 | EXPECT_TRUE(base::FieldTrialList::IsTrialActive("Trial1")); |
| 495 | |
| 496 | EXPECT_FALSE(base::FieldTrialList::IsTrialActive("Trial2")); |
| 497 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 498 | EXPECT_TRUE(base::FieldTrialList::IsTrialActive("Trial2")); |
| 499 | } |
| 500 | |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 501 | TEST_F(FeatureListTest,RegisterExtraFeatureOverrides){ |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 502 | auto feature_list= std::make_unique<FeatureList>(); |
| 503 | std::vector<FeatureList::FeatureOverrideInfo> overrides; |
| Alexei Svitkine | f3d64cae | 2024-11-20 19:55:56 | [diff] [blame] | 504 | overrides.emplace_back(std::cref(kFeatureOnByDefault), |
| 505 | FeatureList::OverrideState::OVERRIDE_DISABLE_FEATURE); |
| 506 | overrides.emplace_back(std::cref(kFeatureOffByDefault), |
| 507 | FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 508 | feature_list->RegisterExtraFeatureOverrides(std::move(overrides)); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 509 | test::ScopedFeatureList scoped_feature_list; |
| 510 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 511 | |
| 512 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 513 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 514 | } |
| 515 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 516 | TEST_F(FeatureListTest,InitFromCommandLineThenRegisterExtraOverrides){ |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 517 | auto feature_list= std::make_unique<FeatureList>(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 518 | feature_list->InitFromCommandLine(kFeatureOnByDefaultName, |
| 519 | kFeatureOffByDefaultName); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 520 | std::vector<FeatureList::FeatureOverrideInfo> overrides; |
| Alexei Svitkine | f3d64cae | 2024-11-20 19:55:56 | [diff] [blame] | 521 | overrides.emplace_back(std::cref(kFeatureOnByDefault), |
| 522 | FeatureList::OverrideState::OVERRIDE_DISABLE_FEATURE); |
| 523 | overrides.emplace_back(std::cref(kFeatureOffByDefault), |
| 524 | FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 525 | feature_list->RegisterExtraFeatureOverrides(std::move(overrides)); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 526 | test::ScopedFeatureList scoped_feature_list; |
| 527 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 528 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 529 | // The InitFromCommandLine supersedes the RegisterExtraFeatureOverrides |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 530 | // because it was called first. |
| 531 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 532 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 533 | |
| 534 | std::string enable_features; |
| 535 | std::string disable_features; |
| 536 | FeatureList::GetInstance()->GetFeatureOverrides(&enable_features, |
| 537 | &disable_features); |
| 538 | EXPECT_EQ(kFeatureOnByDefaultName,SortFeatureListString(enable_features)); |
| 539 | EXPECT_EQ(kFeatureOffByDefaultName,SortFeatureListString(disable_features)); |
| 540 | } |
| 541 | |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 542 | TEST_F(FeatureListTest,GetFeatureOverrides){ |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 543 | auto feature_list= std::make_unique<FeatureList>(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 544 | feature_list->InitFromCommandLine("A,X","D"); |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 545 | |
| Daniel Cheng | 2628f68 | 2024-05-03 16:18:45 | [diff] [blame] | 546 | static BASE_FEATURE(feature_b,"B", FEATURE_ENABLED_BY_DEFAULT); |
| 547 | static BASE_FEATURE(feature_c,"C", FEATURE_DISABLED_BY_DEFAULT); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 548 | std::vector<FeatureList::FeatureOverrideInfo> overrides; |
| Alexei Svitkine | f3d64cae | 2024-11-20 19:55:56 | [diff] [blame] | 549 | overrides.emplace_back(std::cref(feature_b), |
| 550 | FeatureList::OverrideState::OVERRIDE_DISABLE_FEATURE); |
| 551 | overrides.emplace_back(std::cref(feature_c), |
| 552 | FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 553 | feature_list->RegisterExtraFeatureOverrides(std::move(overrides)); |
| 554 | |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 555 | FieldTrial* trial=FieldTrialList::CreateFieldTrial("Trial","Group"); |
| Peter Kasting | 134ef9af | 2024-12-28 02:30:09 | [diff] [blame] | 556 | feature_list->RegisterFieldTrialOverride( |
| 557 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE, trial); |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 558 | |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 559 | test::ScopedFeatureList scoped_feature_list; |
| 560 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 561 | |
| 562 | std::string enable_features; |
| 563 | std::string disable_features; |
| 564 | FeatureList::GetInstance()->GetFeatureOverrides(&enable_features, |
| 565 | &disable_features); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 566 | EXPECT_EQ("A,C,OffByDefault<Trial,X",SortFeatureListString(enable_features)); |
| 567 | EXPECT_EQ("B,D",SortFeatureListString(disable_features)); |
| Alexei Svitkine | 223d228 | 2018-02-08 00:18:35 | [diff] [blame] | 568 | |
| 569 | FeatureList::GetInstance()->GetCommandLineFeatureOverrides(&enable_features, |
| 570 | &disable_features); |
| Lily Chen | d49e375 | 2019-08-09 19:05:24 | [diff] [blame] | 571 | EXPECT_EQ("A,C,X",SortFeatureListString(enable_features)); |
| 572 | EXPECT_EQ("B,D",SortFeatureListString(disable_features)); |
| asvitkine | 8634019 | 2015-12-01 00:45:29 | [diff] [blame] | 573 | } |
| 574 | |
| asvitkine | 6d31c52e | 2016-03-22 15:37:52 | [diff] [blame] | 575 | TEST_F(FeatureListTest,GetFeatureOverrides_UseDefault){ |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 576 | auto feature_list= std::make_unique<FeatureList>(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 577 | feature_list->InitFromCommandLine("A,X","D"); |
| asvitkine | 6d31c52e | 2016-03-22 15:37:52 | [diff] [blame] | 578 | |
| 579 | FieldTrial* trial=FieldTrialList::CreateFieldTrial("Trial","Group"); |
| 580 | feature_list->RegisterFieldTrialOverride( |
| 581 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, trial); |
| 582 | |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 583 | test::ScopedFeatureList scoped_feature_list; |
| 584 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | 6d31c52e | 2016-03-22 15:37:52 | [diff] [blame] | 585 | |
| 586 | std::string enable_features; |
| 587 | std::string disable_features; |
| 588 | FeatureList::GetInstance()->GetFeatureOverrides(&enable_features, |
| 589 | &disable_features); |
| 590 | EXPECT_EQ("*OffByDefault<Trial,A,X",SortFeatureListString(enable_features)); |
| 591 | EXPECT_EQ("D",SortFeatureListString(disable_features)); |
| 592 | } |
| 593 | |
| jwd | 07b9038 | 2016-05-06 20:39:42 | [diff] [blame] | 594 | TEST_F(FeatureListTest,GetFieldTrial){ |
| jwd | 07b9038 | 2016-05-06 20:39:42 | [diff] [blame] | 595 | FieldTrial* trial=FieldTrialList::CreateFieldTrial("Trial","Group"); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 596 | auto feature_list= std::make_unique<FeatureList>(); |
| jwd | 07b9038 | 2016-05-06 20:39:42 | [diff] [blame] | 597 | feature_list->RegisterFieldTrialOverride( |
| 598 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, trial); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 599 | test::ScopedFeatureList scoped_feature_list; |
| 600 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| jwd | 07b9038 | 2016-05-06 20:39:42 | [diff] [blame] | 601 | |
| 602 | EXPECT_EQ(trial,FeatureList::GetFieldTrial(kFeatureOnByDefault)); |
| 603 | EXPECT_EQ(nullptr,FeatureList::GetFieldTrial(kFeatureOffByDefault)); |
| 604 | } |
| 605 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 606 | TEST_F(FeatureListTest,InitFromCommandLine_WithFieldTrials){ |
| asvitkine | b2e44d8 | 2015-12-01 04:10:28 | [diff] [blame] | 607 | FieldTrialList::CreateFieldTrial("Trial","Group"); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 608 | auto feature_list= std::make_unique<FeatureList>(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 609 | feature_list->InitFromCommandLine("A,OffByDefault<Trial,X","D"); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 610 | test::ScopedFeatureList scoped_feature_list; |
| 611 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | b2e44d8 | 2015-12-01 04:10:28 | [diff] [blame] | 612 | |
| 613 | EXPECT_FALSE(FieldTrialList::IsTrialActive("Trial")); |
| 614 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 615 | EXPECT_TRUE(FieldTrialList::IsTrialActive("Trial")); |
| 616 | } |
| 617 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 618 | TEST_F(FeatureListTest,InitFromCommandLine_UseDefault){ |
| asvitkine | 6d31c52e | 2016-03-22 15:37:52 | [diff] [blame] | 619 | FieldTrialList::CreateFieldTrial("T1","Group"); |
| 620 | FieldTrialList::CreateFieldTrial("T2","Group"); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 621 | auto feature_list= std::make_unique<FeatureList>(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 622 | feature_list->InitFromCommandLine("A,*OffByDefault<T1,*OnByDefault<T2,X", |
| 623 | "D"); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 624 | test::ScopedFeatureList scoped_feature_list; |
| 625 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| asvitkine | 6d31c52e | 2016-03-22 15:37:52 | [diff] [blame] | 626 | |
| 627 | EXPECT_FALSE(FieldTrialList::IsTrialActive("T1")); |
| 628 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 629 | EXPECT_TRUE(FieldTrialList::IsTrialActive("T1")); |
| 630 | |
| 631 | EXPECT_FALSE(FieldTrialList::IsTrialActive("T2")); |
| 632 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 633 | EXPECT_TRUE(FieldTrialList::IsTrialActive("T2")); |
| 634 | } |
| 635 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 636 | TEST_F(FeatureListTest,InitInstance){ |
| dcheng | 093de9b | 2016-04-04 21:25:51 | [diff] [blame] | 637 | std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 638 | test::ScopedFeatureList scoped_feature_list; |
| 639 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| 640 | |
| changwan | 5b9da19 | 2016-03-31 07:36:19 | [diff] [blame] | 641 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 642 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 643 | |
| 644 | // Initialize from command line if we haven't yet. |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 645 | FeatureList::InitInstance("", kFeatureOnByDefaultName); |
| changwan | 5b9da19 | 2016-03-31 07:36:19 | [diff] [blame] | 646 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 647 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 648 | |
| 649 | // Do not initialize from commandline if we have already. |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 650 | FeatureList::InitInstance(kFeatureOffByDefaultName,""); |
| changwan | 5b9da19 | 2016-03-31 07:36:19 | [diff] [blame] | 651 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 652 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 653 | } |
| 654 | |
| joedow | 958f047 | 2016-07-07 22:08:55 | [diff] [blame] | 655 | TEST_F(FeatureListTest,UninitializedInstance_IsEnabledReturnsFalse){ |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 656 | std::unique_ptr<FeatureList> original_feature_list= |
| 657 | FeatureList::ClearInstanceForTesting(); |
| 658 | |
| joedow | 958f047 | 2016-07-07 22:08:55 | [diff] [blame] | 659 | // This test case simulates the calling pattern found in code which does not |
| 660 | // explicitly initialize the features list. |
| 661 | // All IsEnabled() calls should return the default value in this scenario. |
| 662 | EXPECT_EQ(nullptr,FeatureList::GetInstance()); |
| 663 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 664 | EXPECT_EQ(nullptr,FeatureList::GetInstance()); |
| 665 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 666 | |
| Peter Kasting | 134ef9af | 2024-12-28 02:30:09 | [diff] [blame] | 667 | if(original_feature_list){ |
| Wez | ce49a7d | 2019-10-08 21:47:41 | [diff] [blame] | 668 | FeatureList::RestoreInstanceForTesting(std::move(original_feature_list)); |
| Peter Kasting | 134ef9af | 2024-12-28 02:30:09 | [diff] [blame] | 669 | } |
| joedow | 958f047 | 2016-07-07 22:08:55 | [diff] [blame] | 670 | } |
| 671 | |
| lawrencewu | 5e03cd3 | 2016-12-05 16:23:28 | [diff] [blame] | 672 | TEST_F(FeatureListTest,StoreAndRetrieveFeaturesFromSharedMemory){ |
| 673 | std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList); |
| 674 | |
| 675 | // Create some overrides. |
| 676 | feature_list->RegisterOverride(kFeatureOffByDefaultName, |
| 677 | FeatureList::OVERRIDE_ENABLE_FEATURE,nullptr); |
| 678 | feature_list->RegisterOverride( |
| 679 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE,nullptr); |
| 680 | feature_list->FinalizeInitialization(); |
| 681 | |
| 682 | // Create an allocator and store the overrides. |
| Alexandr Ilin | 027ca3d3 | 2019-02-12 18:37:33 | [diff] [blame] | 683 | base::MappedReadOnlyRegion shm= |
| 684 | base::ReadOnlySharedMemoryRegion::Create(4<<10); |
| 685 | WritableSharedPersistentMemoryAllocator allocator(std::move(shm.mapping),1, |
| 686 | ""); |
| lawrencewu | 5e03cd3 | 2016-12-05 16:23:28 | [diff] [blame] | 687 | feature_list->AddFeaturesToAllocator(&allocator); |
| 688 | |
| 689 | std::unique_ptr<base::FeatureList> feature_list2(new base::FeatureList); |
| 690 | |
| 691 | // Check that the new feature list is empty. |
| 692 | EXPECT_FALSE(feature_list2->IsFeatureOverriddenFromCommandLine( |
| 693 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE)); |
| 694 | EXPECT_FALSE(feature_list2->IsFeatureOverriddenFromCommandLine( |
| 695 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE)); |
| 696 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 697 | feature_list2->InitFromSharedMemory(&allocator); |
| lawrencewu | 5e03cd3 | 2016-12-05 16:23:28 | [diff] [blame] | 698 | // Check that the new feature list now has 2 overrides. |
| 699 | EXPECT_TRUE(feature_list2->IsFeatureOverriddenFromCommandLine( |
| 700 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_ENABLE_FEATURE)); |
| 701 | EXPECT_TRUE(feature_list2->IsFeatureOverriddenFromCommandLine( |
| 702 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_DISABLE_FEATURE)); |
| 703 | } |
| 704 | |
| 705 | TEST_F(FeatureListTest,StoreAndRetrieveAssociatedFeaturesFromSharedMemory){ |
| lawrencewu | 5e03cd3 | 2016-12-05 16:23:28 | [diff] [blame] | 706 | std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList); |
| 707 | |
| 708 | // Create some overrides. |
| 709 | FieldTrial* trial1=FieldTrialList::CreateFieldTrial("TrialExample1","A"); |
| 710 | FieldTrial* trial2=FieldTrialList::CreateFieldTrial("TrialExample2","B"); |
| 711 | feature_list->RegisterFieldTrialOverride( |
| 712 | kFeatureOnByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, trial1); |
| 713 | feature_list->RegisterFieldTrialOverride( |
| 714 | kFeatureOffByDefaultName,FeatureList::OVERRIDE_USE_DEFAULT, trial2); |
| 715 | feature_list->FinalizeInitialization(); |
| 716 | |
| 717 | // Create an allocator and store the overrides. |
| Alexandr Ilin | 027ca3d3 | 2019-02-12 18:37:33 | [diff] [blame] | 718 | base::MappedReadOnlyRegion shm= |
| 719 | base::ReadOnlySharedMemoryRegion::Create(4<<10); |
| 720 | WritableSharedPersistentMemoryAllocator allocator(std::move(shm.mapping),1, |
| 721 | ""); |
| lawrencewu | 5e03cd3 | 2016-12-05 16:23:28 | [diff] [blame] | 722 | feature_list->AddFeaturesToAllocator(&allocator); |
| 723 | |
| 724 | std::unique_ptr<base::FeatureList> feature_list2(new base::FeatureList); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 725 | feature_list2->InitFromSharedMemory(&allocator); |
| lawrencewu | 5e03cd3 | 2016-12-05 16:23:28 | [diff] [blame] | 726 | feature_list2->FinalizeInitialization(); |
| 727 | |
| 728 | // Check that the field trials are still associated. |
| 729 | FieldTrial* associated_trial1= |
| 730 | feature_list2->GetAssociatedFieldTrial(kFeatureOnByDefault); |
| 731 | FieldTrial* associated_trial2= |
| 732 | feature_list2->GetAssociatedFieldTrial(kFeatureOffByDefault); |
| 733 | EXPECT_EQ(associated_trial1, trial1); |
| 734 | EXPECT_EQ(associated_trial2, trial2); |
| 735 | } |
| 736 | |
| Marijn Kruisselbrink | 1934df7 | 2023-12-04 22:30:55 | [diff] [blame] | 737 | TEST_F(FeatureListTest,SetEarlyAccessInstance_AllowList){ |
| 738 | test::ScopedFeatureList clear_feature_list; |
| 739 | clear_feature_list.InitWithNullFeatureAndFieldTrialLists(); |
| 740 | |
| 741 | auto early_access_feature_list= std::make_unique<FeatureList>(); |
| 742 | early_access_feature_list->InitFromCommandLine("OffByDefault","OnByDefault"); |
| 743 | FeatureList::SetEarlyAccessInstance(std::move(early_access_feature_list), |
| Marijn Kruisselbrink | 0b6d5df | 2023-12-14 22:31:29 | [diff] [blame] | 744 | {"DcheckIsFatal","OnByDefault"}); |
| Marijn Kruisselbrink | 1934df7 | 2023-12-04 22:30:55 | [diff] [blame] | 745 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 746 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 747 | EXPECT_EQ(&kFeatureOffByDefault, |
| 748 | FeatureList::GetEarlyAccessedFeatureForTesting()); |
| 749 | FeatureList::ResetEarlyFeatureAccessTrackerForTesting(); |
| 750 | } |
| 751 | |
| 752 | TEST_F(FeatureListTest,SetEarlyAccessInstance_ReplaceByRealList){ |
| 753 | test::ScopedFeatureList clear_feature_list; |
| 754 | clear_feature_list.InitWithNullFeatureAndFieldTrialLists(); |
| 755 | |
| 756 | auto early_access_feature_list= std::make_unique<FeatureList>(); |
| 757 | early_access_feature_list->InitFromCommandLine("OffByDefault","OnByDefault"); |
| Marijn Kruisselbrink | 0b6d5df | 2023-12-14 22:31:29 | [diff] [blame] | 758 | FeatureList::SetEarlyAccessInstance( |
| 759 | std::move(early_access_feature_list), |
| 760 | {"DcheckIsFatal","OffByDefault","OnByDefault"}); |
| Marijn Kruisselbrink | 1934df7 | 2023-12-04 22:30:55 | [diff] [blame] | 761 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 762 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 763 | |
| 764 | auto feature_list= std::make_unique<FeatureList>(); |
| 765 | feature_list->InitFromCommandLine("",""); |
| 766 | FeatureList::SetInstance(std::move(feature_list)); |
| 767 | EXPECT_TRUE(FeatureList::IsEnabled(kFeatureOnByDefault)); |
| 768 | EXPECT_FALSE(FeatureList::IsEnabled(kFeatureOffByDefault)); |
| 769 | } |
| 770 | |
| Miriam Zimmerman | b4683c1 | 2021-12-01 15:44:33 | [diff] [blame] | 771 | #if BUILDFLAG(ENABLE_BANNED_BASE_FEATURE_PREFIX) && \ |
| 772 | defined(GTEST_HAS_DEATH_TEST) |
| 773 | usingFeatureListDeathTest=FeatureListTest; |
| 774 | TEST_F(FeatureListDeathTest,DiesWithBadFeatureName){ |
| Daniel Cheng | 2628f68 | 2024-05-03 16:18:45 | [diff] [blame] | 775 | // TODO(dcheng): Add a nocompile version of this test. In general, people |
| 776 | // should not be constructing features at runtime anyway but just in case... |
| Miriam Zimmerman | b4683c1 | 2021-12-01 15:44:33 | [diff] [blame] | 777 | EXPECT_DEATH( |
| 778 | Feature( |
| 779 | StrCat({BUILDFLAG(BANNED_BASE_FEATURE_PREFIX),"MyFeature"}).c_str(), |
| Daniel Cheng | 2628f68 | 2024-05-03 16:18:45 | [diff] [blame] | 780 | FEATURE_DISABLED_BY_DEFAULT, |
| 781 | internal::FeatureMacroHandshake::kSecret), |
| Miriam Zimmerman | b4683c1 | 2021-12-01 15:44:33 | [diff] [blame] | 782 | StrCat({"Invalid feature name ", BUILDFLAG(BANNED_BASE_FEATURE_PREFIX), |
| 783 | "MyFeature"})); |
| 784 | } |
| 785 | #endif// BUILDFLAG(ENABLE_BANNED_BASE_FEATURE_PREFIX) && |
| 786 | // defined(GTEST_HAS_DEATH_TEST) |
| 787 | |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 788 | TEST(FeatureListAccessorTest,DefaultStates){ |
| Tom Sepez | c0c75bee | 2022-12-16 03:12:38 | [diff] [blame] | 789 | test::ScopedFeatureList scoped_feature_list; |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 790 | auto feature_list= std::make_unique<FeatureList>(); |
| 791 | auto feature_list_accessor= feature_list->ConstructAccessor(); |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 792 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| 793 | |
| 794 | EXPECT_EQ(feature_list_accessor->GetOverrideStateByFeatureName( |
| 795 | kFeatureOnByDefault.name), |
| 796 | FeatureList::OVERRIDE_USE_DEFAULT); |
| 797 | EXPECT_EQ(feature_list_accessor->GetOverrideStateByFeatureName( |
| 798 | kFeatureOffByDefault.name), |
| 799 | FeatureList::OVERRIDE_USE_DEFAULT); |
| 800 | } |
| 801 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 802 | TEST(FeatureListAccessorTest,InitFromCommandLine){ |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 803 | structTestCases{ |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 804 | constchar* enable_features; |
| 805 | constchar* disable_features; |
| 806 | FeatureList::OverrideState expected_feature_on_state; |
| 807 | FeatureList::OverrideState expected_feature_off_state; |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 808 | }; |
| 809 | auto test_cases= std::to_array<TestCases>({ |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 810 | {"","",FeatureList::OVERRIDE_USE_DEFAULT, |
| 811 | FeatureList::OVERRIDE_USE_DEFAULT}, |
| 812 | {"OffByDefault","",FeatureList::OVERRIDE_USE_DEFAULT, |
| 813 | FeatureList::OVERRIDE_ENABLE_FEATURE}, |
| 814 | {"OffByDefault","OnByDefault",FeatureList::OVERRIDE_DISABLE_FEATURE, |
| 815 | FeatureList::OVERRIDE_ENABLE_FEATURE}, |
| 816 | {"OnByDefault,OffByDefault","",FeatureList::OVERRIDE_ENABLE_FEATURE, |
| 817 | FeatureList::OVERRIDE_ENABLE_FEATURE}, |
| 818 | {"","OnByDefault,OffByDefault",FeatureList::OVERRIDE_DISABLE_FEATURE, |
| 819 | FeatureList::OVERRIDE_DISABLE_FEATURE}, |
| 820 | // In the case an entry is both, disable takes precedence. |
| 821 | {"OnByDefault","OnByDefault,OffByDefault", |
| 822 | FeatureList::OVERRIDE_DISABLE_FEATURE, |
| 823 | FeatureList::OVERRIDE_DISABLE_FEATURE}, |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 824 | }); |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 825 | |
| Daniel Cheng | f45f4760 | 2022-02-28 22:38:32 | [diff] [blame] | 826 | for(size_t i=0; i< std::size(test_cases);++i){ |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 827 | constauto& test_case= test_cases[i]; |
| 828 | SCOPED_TRACE(base::StringPrintf("Test[%"PRIuS"]: [%s] [%s]", i, |
| 829 | test_case.enable_features, |
| 830 | test_case.disable_features)); |
| 831 | |
| Tom Sepez | c0c75bee | 2022-12-16 03:12:38 | [diff] [blame] | 832 | test::ScopedFeatureList scoped_feature_list; |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 833 | auto feature_list= std::make_unique<FeatureList>(); |
| 834 | auto feature_list_accessor= feature_list->ConstructAccessor(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 835 | feature_list->InitFromCommandLine(test_case.enable_features, |
| 836 | test_case.disable_features); |
| Miriam Zimmerman | dfe2807 | 2021-11-22 22:16:31 | [diff] [blame] | 837 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| 838 | |
| 839 | EXPECT_EQ(test_case.expected_feature_on_state, |
| 840 | feature_list_accessor->GetOverrideStateByFeatureName( |
| 841 | kFeatureOnByDefault.name)) |
| 842 | << i; |
| 843 | EXPECT_EQ(test_case.expected_feature_off_state, |
| 844 | feature_list_accessor->GetOverrideStateByFeatureName( |
| 845 | kFeatureOffByDefault.name)) |
| 846 | << i; |
| 847 | } |
| 848 | } |
| 849 | |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 850 | TEST(FeatureListAccessorTest,InitFromCommandLineWithFeatureParams){ |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 851 | structTestCases{ |
| Miriam Zimmerman | 79f6cac | 2022-06-17 17:58:25 | [diff] [blame] | 852 | const std::string enable_features; |
| 853 | const std::map<std::string, std::string> expected_feature_params; |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 854 | }; |
| 855 | auto test_cases= std::to_array<TestCases>({ |
| Miriam Zimmerman | 79f6cac | 2022-06-17 17:58:25 | [diff] [blame] | 856 | {"Feature:x/100/y/test",{{"x","100"},{"y","test"}}}, |
| 857 | {"Feature<Trial:asdf/ghjkl/y/123",{{"asdf","ghjkl"},{"y","123"}}}, |
| Arthur Sonzogni | 0844a99 | 2024-12-12 11:36:20 | [diff] [blame] | 858 | }); |
| Miriam Zimmerman | 79f6cac | 2022-06-17 17:58:25 | [diff] [blame] | 859 | |
| 860 | // Clear global state so that repeated runs of this test don't flake. |
| 861 | // When https://crrev.com/c/3694674 is submitted, we should be able to remove |
| 862 | // this. |
| 863 | base::FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting(); |
| 864 | |
| 865 | for(size_t i=0; i< std::size(test_cases);++i){ |
| 866 | constauto& test_case= test_cases[i]; |
| 867 | SCOPED_TRACE(test_case.enable_features); |
| 868 | |
| Tom Sepez | c0c75bee | 2022-12-16 03:12:38 | [diff] [blame] | 869 | test::ScopedFeatureList scoped_feature_list; |
| Miriam Zimmerman | 79f6cac | 2022-06-17 17:58:25 | [diff] [blame] | 870 | auto feature_list= std::make_unique<FeatureList>(); |
| 871 | auto feature_list_accessor= feature_list->ConstructAccessor(); |
| Gabriel Gauthier-Shalom | 89627a67a | 2023-11-29 22:11:19 | [diff] [blame] | 872 | feature_list->InitFromCommandLine(test_case.enable_features,""); |
| Miriam Zimmerman | 79f6cac | 2022-06-17 17:58:25 | [diff] [blame] | 873 | scoped_feature_list.InitWithFeatureList(std::move(feature_list)); |
| 874 | |
| 875 | EXPECT_EQ(FeatureList::OVERRIDE_ENABLE_FEATURE, |
| 876 | feature_list_accessor->GetOverrideStateByFeatureName("Feature")) |
| 877 | << i; |
| 878 | std::map<std::string, std::string> actual_params; |
| 879 | EXPECT_TRUE(feature_list_accessor->GetParamsByFeatureName("Feature", |
| 880 | &actual_params)) |
| 881 | << i; |
| 882 | EXPECT_EQ(test_case.expected_feature_params, actual_params)<< i; |
| 883 | } |
| 884 | } |
| 885 | |
| Kendrake Tsui | d3895ec | 2024-01-22 22:08:39 | [diff] [blame] | 886 | // Test only class to verify correctness of |
| 887 | // FeatureList::VisitFeaturesAndParams(). |
| 888 | classTestFeatureVisitor:publicFeatureVisitor{ |
| 889 | public: |
| 890 | TestFeatureVisitor()=default; |
| 891 | |
| 892 | TestFeatureVisitor(constTestFeatureVisitor&)=delete; |
| 893 | TestFeatureVisitor&operator=(constTestFeatureVisitor&)=delete; |
| 894 | |
| 895 | ~TestFeatureVisitor() override=default; |
| 896 | |
| 897 | structVisitedFeatureState{ |
| 898 | autooperator<=>(constVisitedFeatureState&)const=default; |
| 899 | |
| 900 | std::string feature_name; |
| 901 | const base::FeatureList::OverrideState override_state; |
| 902 | base::FieldTrialParams params; |
| 903 | std::string trial_name; |
| 904 | std::string group_name; |
| 905 | }; |
| 906 | |
| 907 | voidVisit(const std::string& feature_name, |
| 908 | FeatureList::OverrideState override_state, |
| 909 | constFieldTrialParams& params, |
| 910 | const std::string& trial_name, |
| 911 | const std::string& group_name) override{ |
| 912 | feature_state_.insert(TestFeatureVisitor::VisitedFeatureState{ |
| 913 | feature_name, override_state, params, trial_name, group_name}); |
| 914 | } |
| 915 | |
| 916 | const std::multiset<TestFeatureVisitor::VisitedFeatureState>& |
| 917 | feature_state(){ |
| 918 | return feature_state_; |
| 919 | } |
| 920 | |
| 921 | private: |
| 922 | std::multiset<VisitedFeatureState> feature_state_; |
| 923 | }; |
| 924 | |
| 925 | // Makes test output human readable. |
| 926 | std::ostream&operator<<(std::ostream& out, |
| 927 | constTestFeatureVisitor::VisitedFeatureState& state){ |
| 928 | out<<".feature_name='"<< state.feature_name |
| 929 | <<"', .override_state="<< state.override_state<<", .params={"; |
| 930 | |
| 931 | for(constauto& param: state.params){ |
| 932 | out<< param.first<<"="<< param.second<<", "; |
| 933 | } |
| 934 | |
| 935 | out<<"}, .trial_name='"<< state.trial_name<<"', .group_name='" |
| 936 | << state.group_name<<"'"; |
| 937 | return out; |
| 938 | } |
| 939 | |
| 940 | TEST(TestFeatureVisitor,FeatureWithNoFieldTrial){ |
| 941 | base::test::ScopedFeatureList outer_scope; |
| 942 | outer_scope.InitWithEmptyFeatureAndFieldTrialLists(); |
| 943 | |
| 944 | base::test::ScopedFeatureList feature_list; |
| 945 | feature_list.InitWithFeatures(/*enabled_features=*/{kFeatureOffByDefault}, |
| 946 | /*disabled_features=*/{kFeatureOnByDefault}); |
| 947 | |
| 948 | TestFeatureVisitor visitor; |
| 949 | base::FeatureList::VisitFeaturesAndParams(visitor); |
| 950 | std::multiset<TestFeatureVisitor::VisitedFeatureState> actual_feature_state= |
| 951 | visitor.feature_state(); |
| 952 | |
| 953 | std::multiset<TestFeatureVisitor::VisitedFeatureState> |
| 954 | expected_feature_state={ |
| 955 | {"OnByDefault",FeatureList::OverrideState::OVERRIDE_DISABLE_FEATURE, |
| 956 | FieldTrialParams{},"",""}, |
| 957 | {"OffByDefault",FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE, |
| 958 | FieldTrialParams{},"",""}, |
| 959 | }; |
| 960 | |
| 961 | EXPECT_EQ(actual_feature_state, expected_feature_state); |
| 962 | } |
| 963 | |
| 964 | TEST(TestFeatureVisitor,FeatureOverrideUseDefault){ |
| 965 | base::test::ScopedFeatureList outer_scope; |
| 966 | outer_scope.InitWithEmptyFeatureAndFieldTrialLists(); |
| 967 | |
| 968 | auto feature_list= std::make_unique<base::FeatureList>(); |
| 969 | base::FieldTrial* trial= |
| 970 | base::FieldTrialList::CreateFieldTrial("TrialExample","A"); |
| 971 | feature_list->RegisterFieldTrialOverride( |
| 972 | "TestFeature", base::FeatureList::OVERRIDE_USE_DEFAULT, trial); |
| 973 | |
| 974 | base::test::ScopedFeatureList initialized_feature_list; |
| 975 | initialized_feature_list.InitWithFeatureList(std::move(feature_list)); |
| 976 | |
| 977 | TestFeatureVisitor visitor; |
| 978 | base::FeatureList::VisitFeaturesAndParams(visitor); |
| 979 | std::multiset<TestFeatureVisitor::VisitedFeatureState> actual_feature_state= |
| 980 | visitor.feature_state(); |
| 981 | |
| 982 | std::multiset<TestFeatureVisitor::VisitedFeatureState> |
| 983 | expected_feature_state={ |
| 984 | {"TestFeature",FeatureList::OverrideState::OVERRIDE_USE_DEFAULT, |
| 985 | FieldTrialParams{},"TrialExample","A"}}; |
| 986 | |
| 987 | EXPECT_EQ(actual_feature_state, expected_feature_state); |
| 988 | } |
| 989 | |
| 990 | TEST(TestFeatureVisitor,FeatureHasParams){ |
| 991 | base::test::ScopedFeatureList outer_scope; |
| 992 | outer_scope.InitWithEmptyFeatureAndFieldTrialLists(); |
| 993 | |
| 994 | base::test::ScopedFeatureList initialized_feature_list; |
| 995 | |
| 996 | initialized_feature_list.InitFromCommandLine( |
| Peter Kasting | 811504a7 | 2025-01-09 03:18:50 | [diff] [blame] | 997 | /*enable_features=*/"TestFeature<foo.bar:k1/v1/k2/v2", |
| 998 | /*disable_features=*/""); |
| Kendrake Tsui | d3895ec | 2024-01-22 22:08:39 | [diff] [blame] | 999 | |
| Alex Kalugin | 1c7d85c9 | 2025-06-04 18:08:19 | [diff] [blame] | 1000 | const std::multiset<TestFeatureVisitor::VisitedFeatureState> |
| Kendrake Tsui | d3895ec | 2024-01-22 22:08:39 | [diff] [blame] | 1001 | expected_feature_state={ |
| 1002 | {"TestFeature",FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE, |
| 1003 | FieldTrialParams{{"k1","v1"},{"k2","v2"}},"foo","bar"}, |
| 1004 | }; |
| 1005 | |
| Alex Kalugin | 1c7d85c9 | 2025-06-04 18:08:19 | [diff] [blame] | 1006 | {// Check cached params. |
| 1007 | TestFeatureVisitor visitor; |
| 1008 | base::FeatureList::VisitFeaturesAndParams(visitor); |
| 1009 | std::multiset<TestFeatureVisitor::VisitedFeatureState> |
| 1010 | actual_feature_state= visitor.feature_state(); |
| 1011 | |
| 1012 | EXPECT_EQ(actual_feature_state, expected_feature_state); |
| 1013 | } |
| 1014 | |
| 1015 | {// Check that we fetch params from shared memory. |
| 1016 | FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded(); |
| 1017 | FieldTrialParamAssociator::GetInstance()->ClearAllCachedParamsForTesting(); |
| 1018 | |
| 1019 | TestFeatureVisitor visitor; |
| 1020 | base::FeatureList::VisitFeaturesAndParams(visitor); |
| 1021 | std::multiset<TestFeatureVisitor::VisitedFeatureState> |
| 1022 | actual_feature_state= visitor.feature_state(); |
| 1023 | |
| 1024 | EXPECT_EQ(actual_feature_state, expected_feature_state); |
| 1025 | } |
| Kendrake Tsui | d3895ec | 2024-01-22 22:08:39 | [diff] [blame] | 1026 | } |
| Leszek Swirski | f7f53b43 | 2024-09-30 10:12:10 | [diff] [blame] | 1027 | |
| 1028 | TEST(TestFeatureVisitor,FeatureWithPrefix){ |
| 1029 | base::test::ScopedFeatureList outer_scope; |
| 1030 | outer_scope.InitWithEmptyFeatureAndFieldTrialLists(); |
| 1031 | |
| 1032 | base::test::ScopedFeatureList initialized_feature_list; |
| 1033 | |
| 1034 | initialized_feature_list.InitFromCommandLine( |
| 1035 | /*enable_features=*/ |
| 1036 | "AFeature,AnotherFeature,TestFeature,TestFeature2,PrefixedFeature," |
| 1037 | "PrefixedFeature2", |
| 1038 | /*disable_features=*/""); |
| 1039 | |
| 1040 | TestFeatureVisitor visitor; |
| 1041 | base::FeatureList::VisitFeaturesAndParams(visitor,"Prefixed"); |
| 1042 | std::multiset<TestFeatureVisitor::VisitedFeatureState> actual_feature_state= |
| 1043 | visitor.feature_state(); |
| 1044 | |
| 1045 | std::multiset<TestFeatureVisitor::VisitedFeatureState> |
| 1046 | expected_feature_state={ |
| 1047 | {"PrefixedFeature", |
| 1048 | FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE, |
| 1049 | FieldTrialParams{},"",""}, |
| 1050 | {"PrefixedFeature2", |
| 1051 | FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE, |
| 1052 | FieldTrialParams{},"",""}, |
| 1053 | }; |
| 1054 | |
| 1055 | EXPECT_EQ(actual_feature_state, expected_feature_state); |
| 1056 | } |
| Kendrake Tsui | d3895ec | 2024-01-22 22:08:39 | [diff] [blame] | 1057 | |
| asvitkine | bccbb86 | 2015-09-04 17:17:45 | [diff] [blame] | 1058 | }// namespace base |
