| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. | |
| 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 "chromecast/base/cast_features.h" | |
| 6 | |
| 7 #include "base/feature_list.h" | |
| 8 #include "base/macros.h" | |
| 9 #include "base/memory/ptr_util.h" | |
| 10 #include "base/metrics/field_trial.h" | |
| 11 #include "base/metrics/field_trial_params.h" | |
| 12 #include "base/values.h" | |
| 13 #include "testing/gmock/include/gmock/gmock.h" | |
| 14 #include "testing/gtest/include/gtest/gtest.h" | |
| 15 | |
| 16 namespace chromecast { | |
| 17 namespace { | |
| 18 | |
| 19 const char kTestBooleanFeatureName[] = "test_boolean_feature"; | |
| 20 const char kTestBooleanFeatureName2[] = "test_boolean_feature_2"; | |
| 21 const char kTestBooleanFeatureName3[] = "test_boolean_feature_3"; | |
| 22 const char kTestBooleanFeatureName4[] = "test_boolean_feature_4"; | |
| 23 | |
| 24 const char kTestParamsFeatureName[] = "test_params_feature"; | |
| 25 | |
| 26 } // namespace | |
| 27 | |
| 28 class CastFeaturesTest : public testing::Test { | |
| 29 public: | |
| 30 CastFeaturesTest() : field_trial_list_(nullptr) {} | |
| 31 ~CastFeaturesTest() override {} | |
| 32 | |
| 33 // testing::Test implementation: | |
| 34 void SetUp() override { ResetCastFeaturesForTesting(); } | |
| 35 | |
| 36 private: | |
| 37 // A field trial list must be created before attempting to create FieldTrials. | |
| 38 // In production, this instance lives in CastBrowserMainParts. | |
| 39 base::FieldTrialList field_trial_list_; | |
| 40 | |
| 41 DISALLOW_COPY_AND_ASSIGN(CastFeaturesTest); | |
| 42 }; | |
| 43 | |
| 44 TEST_F(CastFeaturesTest, EnableDisableMultipleBooleanFeatures) { | |
| 45 // Declare several boolean features. | |
| 46 base::Feature bool_feature(kTestBooleanFeatureName, | |
| 47 base::FEATURE_DISABLED_BY_DEFAULT); | |
| 48 base::Feature bool_feature_2(kTestBooleanFeatureName2, | |
| 49 base::FEATURE_ENABLED_BY_DEFAULT); | |
| 50 base::Feature bool_feature_3(kTestBooleanFeatureName3, | |
| 51 base::FEATURE_DISABLED_BY_DEFAULT); | |
| 52 base::Feature bool_feature_4(kTestBooleanFeatureName4, | |
| 53 base::FEATURE_ENABLED_BY_DEFAULT); | |
| 54 | |
| 55 // Override those features with DCS configs. | |
| 56 auto experiments = base::MakeUnique<base::ListValue>(); | |
| 57 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 58 features->SetBoolean(kTestBooleanFeatureName, false); | |
| 59 features->SetBoolean(kTestBooleanFeatureName2, false); | |
| 60 features->SetBoolean(kTestBooleanFeatureName3, true); | |
| 61 features->SetBoolean(kTestBooleanFeatureName4, true); | |
| 62 | |
| 63 InitializeFeatureList(*features, *experiments, "", ""); | |
| 64 | |
| 65 // Test that features are properly enabled (they should match the | |
| 66 // DCS config). | |
| 67 ASSERT_FALSE(base::FeatureList::IsEnabled(bool_feature)); | |
| 68 ASSERT_FALSE(base::FeatureList::IsEnabled(bool_feature_2)); | |
| 69 ASSERT_TRUE(base::FeatureList::IsEnabled(bool_feature_3)); | |
| 70 ASSERT_TRUE(base::FeatureList::IsEnabled(bool_feature_4)); | |
| 71 } | |
| 72 | |
| 73 TEST_F(CastFeaturesTest, EnableSingleFeatureWithParams) { | |
| 74 // Define a feature with params. | |
| 75 base::Feature test_feature(kTestParamsFeatureName, | |
| 76 base::FEATURE_DISABLED_BY_DEFAULT); | |
| 77 | |
| 78 // Pass params via DCS. | |
| 79 auto experiments = base::MakeUnique<base::ListValue>(); | |
| 80 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 81 auto params = base::MakeUnique<base::DictionaryValue>(); | |
| 82 params->SetString("foo_key", "foo"); | |
| 83 params->SetString("bar_key", "bar"); | |
| 84 params->SetString("doub_key", "3.14159"); | |
| 85 params->SetString("long_doub_key", "1.23459999999999999"); | |
| 86 params->SetString("int_key", "4242"); | |
| 87 params->SetString("bool_key", "true"); | |
| 88 features->Set(kTestParamsFeatureName, std::move(params)); | |
| 89 | |
| 90 InitializeFeatureList(*features, *experiments, "", ""); | |
| 91 | |
| 92 // Test that this feature is enabled, and params are correct. | |
| 93 ASSERT_TRUE(base::FeatureList::IsEnabled(test_feature)); | |
| 94 ASSERT_EQ("foo", | |
| 95 base::GetFieldTrialParamValueByFeature(test_feature, "foo_key")); | |
| 96 ASSERT_EQ("bar", | |
| 97 base::GetFieldTrialParamValueByFeature(test_feature, "bar_key")); | |
| 98 ASSERT_EQ(3.14159, base::GetFieldTrialParamByFeatureAsDouble( | |
| 99 test_feature, "doub_key", 0.000)); | |
| 100 ASSERT_EQ(1.23459999999999999, base::GetFieldTrialParamByFeatureAsDouble( | |
| 101 test_feature, "long_doub_key", 0.000)); | |
| 102 ASSERT_EQ(4242, base::GetFieldTrialParamByFeatureAsInt(test_feature, | |
| 103 "int_key", -1)); | |
| 104 ASSERT_EQ(true, base::GetFieldTrialParamByFeatureAsBool(test_feature, | |
| 105 "bool_key", false)); | |
| 106 } | |
| 107 | |
| 108 TEST_F(CastFeaturesTest, CommandLineOverridesDcsAndDefault) { | |
| 109 // Declare several boolean features. | |
| 110 base::Feature bool_feature(kTestBooleanFeatureName, | |
| 111 base::FEATURE_DISABLED_BY_DEFAULT); | |
| 112 base::Feature bool_feature_2(kTestBooleanFeatureName2, | |
| 113 base::FEATURE_ENABLED_BY_DEFAULT); | |
| 114 base::Feature bool_feature_3(kTestBooleanFeatureName3, | |
| 115 base::FEATURE_DISABLED_BY_DEFAULT); | |
| 116 base::Feature bool_feature_4(kTestBooleanFeatureName4, | |
| 117 base::FEATURE_ENABLED_BY_DEFAULT); | |
| 118 | |
| 119 // Override those features with DCS configs. | |
| 120 auto experiments = base::MakeUnique<base::ListValue>(); | |
| 121 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 122 features->SetBoolean(kTestBooleanFeatureName, false); | |
| 123 features->SetBoolean(kTestBooleanFeatureName2, false); | |
| 124 features->SetBoolean(kTestBooleanFeatureName3, true); | |
| 125 features->SetBoolean(kTestBooleanFeatureName4, true); | |
| 126 | |
| 127 // Also override a param feature with DCS config. | |
| 128 base::Feature params_feature(kTestParamsFeatureName, | |
| 129 base::FEATURE_ENABLED_BY_DEFAULT); | |
| 130 auto params = base::MakeUnique<base::DictionaryValue>(); | |
| 131 params->SetString("foo_key", "foo"); | |
| 132 features->Set(kTestParamsFeatureName, std::move(params)); | |
| 133 | |
| 134 // Now override with command line flags. Command line flags should have the | |
| 135 // final say. | |
| 136 std::string enabled_features = std::string(kTestBooleanFeatureName) | |
| 137 .append(",") | |
| 138 .append(kTestBooleanFeatureName2); | |
| 139 | |
| 140 std::string disabled_features = std::string(kTestBooleanFeatureName4) | |
| 141 .append(",") | |
| 142 .append(kTestParamsFeatureName); | |
| 143 | |
| 144 InitializeFeatureList(*features, *experiments, enabled_features, | |
| 145 disabled_features); | |
| 146 | |
| 147 // Test that features are properly enabled (they should match the | |
| 148 // DCS config). | |
| 149 ASSERT_TRUE(base::FeatureList::IsEnabled(bool_feature)); | |
| 150 ASSERT_TRUE(base::FeatureList::IsEnabled(bool_feature_2)); | |
| 151 ASSERT_TRUE(base::FeatureList::IsEnabled(bool_feature_3)); | |
| 152 ASSERT_FALSE(base::FeatureList::IsEnabled(bool_feature_4)); | |
| 153 | |
| 154 // Test that the params feature is disabled, and params are not set. | |
| 155 ASSERT_FALSE(base::FeatureList::IsEnabled(params_feature)); | |
| 156 ASSERT_EQ("", | |
| 157 base::GetFieldTrialParamValueByFeature(params_feature, "foo_key")); | |
| 158 } | |
| 159 | |
| 160 TEST_F(CastFeaturesTest, SetEmptyExperiments) { | |
| 161 // Override those features with DCS configs. | |
| 162 auto experiments = base::MakeUnique<base::ListValue>(); | |
| 163 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 164 | |
| 165 InitializeFeatureList(*features, *experiments, "", ""); | |
| 166 ASSERT_EQ(0u, GetDCSExperimentIds().size()); | |
| 167 } | |
| 168 | |
| 169 TEST_F(CastFeaturesTest, SetGoodExperiments) { | |
| 170 // Override those features with DCS configs. | |
| 171 auto experiments = base::MakeUnique<base::ListValue>(); | |
| 172 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 173 | |
| 174 int32_t ids[] = {12345678, 123, 0, -1}; | |
| 175 std::unordered_set<int32_t> expected; | |
| 176 for (int32_t id : ids) { | |
| 177 experiments->AppendInteger(id); | |
| 178 expected.insert(id); | |
| 179 } | |
| 180 | |
| 181 InitializeFeatureList(*features, *experiments, "", ""); | |
| 182 ASSERT_EQ(expected, GetDCSExperimentIds()); | |
| 183 } | |
| 184 | |
| 185 TEST_F(CastFeaturesTest, SetSomeGoodExperiments) { | |
| 186 // Override those features with DCS configs. | |
| 187 auto experiments = base::MakeUnique<base::ListValue>(); | |
| 188 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 189 experiments->AppendInteger(1234); | |
| 190 experiments->AppendString("foobar"); | |
| 191 experiments->AppendBoolean(true); | |
| 192 experiments->AppendInteger(1); | |
| 193 experiments->AppendDouble(1.23456); | |
| 194 | |
| 195 std::unordered_set<int32_t> expected; | |
| 196 expected.insert(1234); | |
| 197 expected.insert(1); | |
| 198 | |
| 199 InitializeFeatureList(*features, *experiments, "", ""); | |
| 200 ASSERT_EQ(expected, GetDCSExperimentIds()); | |
| 201 } | |
| 202 | |
| 203 TEST_F(CastFeaturesTest, SetAllBadExperiments) { | |
| 204 // Override those features with DCS configs. | |
| 205 auto experiments = base::MakeUnique<base::ListValue>(); | |
| 206 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 207 experiments->AppendString("foobar"); | |
| 208 experiments->AppendBoolean(true); | |
| 209 experiments->AppendDouble(1.23456); | |
| 210 | |
| 211 std::unordered_set<int32_t> expected; | |
| 212 | |
| 213 InitializeFeatureList(*features, *experiments, "", ""); | |
| 214 ASSERT_EQ(expected, GetDCSExperimentIds()); | |
| 215 } | |
| 216 | |
| 217 TEST_F(CastFeaturesTest, GetOverriddenFeaturesForStorage) { | |
| 218 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 219 features->SetBoolean("bool_key", false); | |
| 220 features->SetBoolean("bool_key_2", true); | |
| 221 | |
| 222 auto params = base::MakeUnique<base::DictionaryValue>(); | |
| 223 params->SetString("foo_key", "foo"); | |
| 224 params->SetString("bar_key", "bar"); | |
| 225 params->SetDouble("doub_key", 3.14159); | |
| 226 params->SetDouble("long_doub_key", 1.234599999999999); | |
| 227 params->SetInteger("int_key", 4242); | |
| 228 params->SetInteger("negint_key", -273); | |
| 229 params->SetBoolean("bool_key", true); | |
| 230 features->Set("params_key", std::move(params)); | |
| 231 | |
| 232 auto dict = GetOverriddenFeaturesForStorage(*features); | |
| 233 bool bval; | |
| 234 ASSERT_EQ(3u, dict.size()); | |
| 235 ASSERT_TRUE(dict.GetBoolean("bool_key", &bval)); | |
| 236 ASSERT_EQ(false, bval); | |
| 237 ASSERT_TRUE(dict.GetBoolean("bool_key_2", &bval)); | |
| 238 ASSERT_EQ(true, bval); | |
| 239 | |
| 240 const base::DictionaryValue* dval; | |
| 241 std::string sval; | |
| 242 ASSERT_TRUE(dict.GetDictionary("params_key", &dval)); | |
| 243 ASSERT_EQ(7u, dval->size()); | |
| 244 ASSERT_TRUE(dval->GetString("foo_key", &sval)); | |
| 245 ASSERT_EQ("foo", sval); | |
| 246 ASSERT_TRUE(dval->GetString("bar_key", &sval)); | |
| 247 ASSERT_EQ("bar", sval); | |
| 248 ASSERT_TRUE(dval->GetString("doub_key", &sval)); | |
| 249 ASSERT_EQ("3.14159", sval); | |
| 250 ASSERT_TRUE(dval->GetString("long_doub_key", &sval)); | |
| 251 ASSERT_EQ("1.234599999999999", sval); | |
| 252 ASSERT_TRUE(dval->GetString("int_key", &sval)); | |
| 253 ASSERT_EQ("4242", sval); | |
| 254 ASSERT_TRUE(dval->GetString("negint_key", &sval)); | |
| 255 ASSERT_EQ("-273", sval); | |
| 256 ASSERT_TRUE(dval->GetString("bool_key", &sval)); | |
| 257 ASSERT_EQ("true", sval); | |
| 258 } | |
| 259 | |
| 260 TEST_F(CastFeaturesTest, GetOverriddenFeaturesForStorage_BadParams) { | |
| 261 auto features = base::MakeUnique<base::DictionaryValue>(); | |
| 262 features->SetBoolean("bool_key", false); | |
| 263 features->SetString("str_key", "foobar"); | |
| 264 features->SetInteger("int_key", 12345); | |
| 265 features->SetDouble("doub_key", 4.5678); | |
| 266 | |
| 267 auto params = base::MakeUnique<base::DictionaryValue>(); | |
| 268 params->SetString("foo_key", "foo"); | |
| 269 features->Set("params_key", std::move(params)); | |
| 270 | |
| 271 auto dict = GetOverriddenFeaturesForStorage(*features); | |
| 272 bool bval; | |
| 273 ASSERT_EQ(2u, dict.size()); | |
| 274 ASSERT_TRUE(dict.GetBoolean("bool_key", &bval)); | |
| 275 ASSERT_EQ(false, bval); | |
| 276 | |
| 277 const base::DictionaryValue* dval; | |
| 278 std::string sval; | |
| 279 ASSERT_TRUE(dict.GetDictionary("params_key", &dval)); | |
| 280 ASSERT_EQ(1u, dval->size()); | |
| 281 ASSERT_TRUE(dval->GetString("foo_key", &sval)); | |
| 282 ASSERT_EQ("foo", sval); | |
| 283 } | |
| 284 | |
| 285 } // namespace chromecast | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2838813003:
Revert of [Chromecast] Use base::FeatureList to control features. (Closed)
