1 // Copyright 2017 The Chromium Authors
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/metrics/field_trial_params.h"
6
7 #include "base/feature_list.h"
8 #include "base/metrics/field_trial.h"
9 #include "base/metrics/field_trial_param_associator.h"
10 #include "base/test/gtest_util.h"
11 #include "base/test/mock_entropy_provider.h"
12 #include "base/test/scoped_feature_list.h"
13 #include "base/time/time.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 namespace base {
17
18 namespace {
19
20 // Call FieldTrialList::FactoryGetFieldTrial().
CreateFieldTrial(const std::string & trial_name,int total_probability,const std::string & default_group_name)21 scoped_refptr<FieldTrial> CreateFieldTrial(
22 const std::string& trial_name,
23 int total_probability,
24 const std::string& default_group_name) {
25 MockEntropyProvider entropy_provider(0.9);
26 return FieldTrialList::FactoryGetFieldTrial(
27 trial_name, total_probability, default_group_name, entropy_provider);
28 }
29
30 } // namespace
31
32 class FieldTrialParamsTest : public ::testing::Test {
33 public:
34 FieldTrialParamsTest() = default;
35
36 FieldTrialParamsTest(const FieldTrialParamsTest&) = delete;
37 FieldTrialParamsTest& operator=(const FieldTrialParamsTest&) = delete;
38
~FieldTrialParamsTest()39 ~FieldTrialParamsTest() override {
40 // Ensure that the maps are cleared between tests, since they are stored as
41 // process singletons.
42 FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
43 }
44
CreateFeatureWithTrial(const Feature & feature,FeatureList::OverrideState override_state,FieldTrial * trial)45 void CreateFeatureWithTrial(const Feature& feature,
46 FeatureList::OverrideState override_state,
47 FieldTrial* trial) {
48 std::unique_ptr<FeatureList> feature_list(new FeatureList);
49 feature_list->RegisterFieldTrialOverride(feature.name, override_state,
50 trial);
51 scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
52 }
53
54 private:
55 test::ScopedFeatureList scoped_feature_list_;
56 };
57
TEST_F(FieldTrialParamsTest,AssociateFieldTrialParams)58 TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams) {
59 const std::string kTrialName = "AssociateFieldTrialParams";
60
61 {
62 std::map<std::string, std::string> params;
63 params["a"] = "10";
64 params["b"] = "test";
65 ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, "A", params));
66 }
67 {
68 std::map<std::string, std::string> params;
69 params["a"] = "5";
70 ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, "B", params));
71 }
72
73 FieldTrialList::CreateFieldTrial(kTrialName, "B");
74 EXPECT_EQ("5", GetFieldTrialParamValue(kTrialName, "a"));
75 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "b"));
76 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
77
78 std::map<std::string, std::string> params;
79 EXPECT_TRUE(GetFieldTrialParams(kTrialName, ¶ms));
80 EXPECT_EQ(1U, params.size());
81 EXPECT_EQ("5", params["a"]);
82 }
83
TEST_F(FieldTrialParamsTest,AssociateFieldTrialParams_Fail)84 TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_Fail) {
85 const std::string kTrialName = "AssociateFieldTrialParams_Fail";
86 const std::string kGroupName = "A";
87
88 std::map<std::string, std::string> params;
89 params["a"] = "10";
90 ASSERT_TRUE(AssociateFieldTrialParams(kTrialName, kGroupName, params));
91 params["a"] = "1";
92 params["b"] = "2";
93 ASSERT_FALSE(AssociateFieldTrialParams(kTrialName, kGroupName, params));
94
95 FieldTrialList::CreateFieldTrial(kTrialName, kGroupName);
96 EXPECT_EQ("10", GetFieldTrialParamValue(kTrialName, "a"));
97 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "b"));
98 }
99
TEST_F(FieldTrialParamsTest,AssociateFieldTrialParams_TrialActiveFail)100 TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_TrialActiveFail) {
101 const std::string kTrialName = "AssociateFieldTrialParams_TrialActiveFail";
102 FieldTrialList::CreateFieldTrial(kTrialName, "A");
103 ASSERT_EQ("A", FieldTrialList::FindFullName(kTrialName));
104
105 std::map<std::string, std::string> params;
106 params["a"] = "10";
107 EXPECT_FALSE(AssociateFieldTrialParams(kTrialName, "B", params));
108 EXPECT_FALSE(AssociateFieldTrialParams(kTrialName, "A", params));
109 }
110
TEST_F(FieldTrialParamsTest,AssociateFieldTrialParams_DoesntActivateTrial)111 TEST_F(FieldTrialParamsTest, AssociateFieldTrialParams_DoesntActivateTrial) {
112 const std::string kTrialName =
113 "AssociateFieldTrialParams_DoesntActivateTrial";
114
115 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
116 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
117 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
118
119 std::map<std::string, std::string> params;
120 params["a"] = "10";
121 EXPECT_TRUE(AssociateFieldTrialParams(kTrialName, "A", params));
122 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
123 }
124
TEST_F(FieldTrialParamsTest,GetFieldTrialParams_NoTrial)125 TEST_F(FieldTrialParamsTest, GetFieldTrialParams_NoTrial) {
126 const std::string kTrialName = "GetFieldTrialParams_NoParams";
127
128 std::map<std::string, std::string> params;
129 EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms));
130 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
131 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "y"));
132 }
133
TEST_F(FieldTrialParamsTest,GetFieldTrialParams_NoParams)134 TEST_F(FieldTrialParamsTest, GetFieldTrialParams_NoParams) {
135 const std::string kTrialName = "GetFieldTrialParams_NoParams";
136
137 FieldTrialList::CreateFieldTrial(kTrialName, "A");
138
139 std::map<std::string, std::string> params;
140 EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms));
141 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
142 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "y"));
143 }
144
TEST_F(FieldTrialParamsTest,GetFieldTrialParams_ActivatesTrial)145 TEST_F(FieldTrialParamsTest, GetFieldTrialParams_ActivatesTrial) {
146 const std::string kTrialName = "GetFieldTrialParams_ActivatesTrial";
147
148 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
149 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
150 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
151
152 std::map<std::string, std::string> params;
153 EXPECT_FALSE(GetFieldTrialParams(kTrialName, ¶ms));
154 ASSERT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
155 }
156
TEST_F(FieldTrialParamsTest,GetFieldTrialParamValue_ActivatesTrial)157 TEST_F(FieldTrialParamsTest, GetFieldTrialParamValue_ActivatesTrial) {
158 const std::string kTrialName = "GetFieldTrialParamValue_ActivatesTrial";
159
160 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
161 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
162 ASSERT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
163
164 std::map<std::string, std::string> params;
165 EXPECT_EQ(std::string(), GetFieldTrialParamValue(kTrialName, "x"));
166 ASSERT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
167 }
168
TEST_F(FieldTrialParamsTest,GetFieldTrialParamsByFeature)169 TEST_F(FieldTrialParamsTest, GetFieldTrialParamsByFeature) {
170 const std::string kTrialName = "GetFieldTrialParamsByFeature";
171 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
172
173 std::map<std::string, std::string> params;
174 params["x"] = "1";
175 AssociateFieldTrialParams(kTrialName, "A", params);
176 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
177
178 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
179 trial.get());
180
181 std::map<std::string, std::string> actualParams;
182 EXPECT_TRUE(GetFieldTrialParamsByFeature(kFeature, &actualParams));
183 EXPECT_EQ(params, actualParams);
184 }
185
TEST_F(FieldTrialParamsTest,GetFieldTrialParamValueByFeature)186 TEST_F(FieldTrialParamsTest, GetFieldTrialParamValueByFeature) {
187 const std::string kTrialName = "GetFieldTrialParamsByFeature";
188 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
189
190 std::map<std::string, std::string> params;
191 params["x"] = "1";
192 AssociateFieldTrialParams(kTrialName, "A", params);
193 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
194
195 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
196 trial.get());
197
198 std::map<std::string, std::string> actualParams;
199 EXPECT_EQ(params["x"], GetFieldTrialParamValueByFeature(kFeature, "x"));
200 }
201
TEST_F(FieldTrialParamsTest,GetFieldTrialParamsByFeature_Disable)202 TEST_F(FieldTrialParamsTest, GetFieldTrialParamsByFeature_Disable) {
203 const std::string kTrialName = "GetFieldTrialParamsByFeature";
204 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
205
206 std::map<std::string, std::string> params;
207 params["x"] = "1";
208 AssociateFieldTrialParams(kTrialName, "A", params);
209 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
210
211 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE,
212 trial.get());
213
214 std::map<std::string, std::string> actualParams;
215 EXPECT_FALSE(GetFieldTrialParamsByFeature(kFeature, &actualParams));
216 }
217
TEST_F(FieldTrialParamsTest,GetFieldTrialParamValueByFeature_Disable)218 TEST_F(FieldTrialParamsTest, GetFieldTrialParamValueByFeature_Disable) {
219 const std::string kTrialName = "GetFieldTrialParamsByFeature";
220 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
221
222 std::map<std::string, std::string> params;
223 params["x"] = "1";
224 AssociateFieldTrialParams(kTrialName, "A", params);
225 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
226
227 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_DISABLE_FEATURE,
228 trial.get());
229
230 std::map<std::string, std::string> actualParams;
231 EXPECT_EQ(std::string(), GetFieldTrialParamValueByFeature(kFeature, "x"));
232 }
233
TEST_F(FieldTrialParamsTest,FeatureParamString)234 TEST_F(FieldTrialParamsTest, FeatureParamString) {
235 const std::string kTrialName = "GetFieldTrialParamsByFeature";
236
237 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
238 static const FeatureParam<std::string> a{&kFeature, "a", "default"};
239 static const FeatureParam<std::string> b{&kFeature, "b", ""};
240 static const FeatureParam<std::string> c{&kFeature, "c", "default"};
241 static const FeatureParam<std::string> d{&kFeature, "d", ""};
242 static const FeatureParam<std::string> e{&kFeature, "e", "default"};
243 static const FeatureParam<std::string> f{&kFeature, "f", ""};
244
245 std::map<std::string, std::string> params;
246 params["a"] = "";
247 params["b"] = "non-default";
248 params["c"] = "non-default";
249 params["d"] = "";
250 // "e" is not registered
251 // "f" is not registered
252 AssociateFieldTrialParams(kTrialName, "A", params);
253 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
254
255 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
256 trial.get());
257
258 EXPECT_EQ("", a.Get()); // empty
259 EXPECT_EQ("non-default", b.Get());
260 EXPECT_EQ("non-default", c.Get());
261 EXPECT_EQ("", d.Get()); // empty
262 EXPECT_EQ("default", e.Get()); // not registered
263 EXPECT_EQ("", f.Get()); // not registered
264 }
265
TEST_F(FieldTrialParamsTest,FeatureParamString_Disable)266 TEST_F(FieldTrialParamsTest, FeatureParamString_Disable) {
267 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
268 static const FeatureParam<std::string> a{&kFeature, "a", "default"};
269 EXPECT_EQ("default", a.Get());
270 }
271
TEST_F(FieldTrialParamsTest,FeatureParamInt)272 TEST_F(FieldTrialParamsTest, FeatureParamInt) {
273 const std::string kTrialName = "GetFieldTrialParamsByFeature";
274
275 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
276 static const FeatureParam<int> a{&kFeature, "a", 0};
277 static const FeatureParam<int> b{&kFeature, "b", 0};
278 static const FeatureParam<int> c{&kFeature, "c", 0};
279 static const FeatureParam<int> d{&kFeature, "d", 0};
280 static const FeatureParam<int> e{&kFeature, "e", 0};
281
282 std::map<std::string, std::string> params;
283 params["a"] = "1";
284 params["b"] = "1.5";
285 params["c"] = "foo";
286 params["d"] = "";
287 // "e" is not registered
288 AssociateFieldTrialParams(kTrialName, "A", params);
289 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
290
291 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
292 trial.get());
293
294 EXPECT_EQ(1, GetFieldTrialParamByFeatureAsInt(kFeature, "a", 0));
295 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "b", 0)); // invalid
296 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "c", 0)); // invalid
297 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "d", 0)); // empty
298 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsInt(kFeature, "e", 0)); // empty
299
300 EXPECT_EQ(1, a.Get());
301 EXPECT_EQ(0, b.Get()); // invalid
302 EXPECT_EQ(0, c.Get()); // invalid
303 EXPECT_EQ(0, d.Get()); // empty
304 EXPECT_EQ(0, e.Get()); // empty
305 }
306
TEST_F(FieldTrialParamsTest,FeatureParamInt_Disable)307 TEST_F(FieldTrialParamsTest, FeatureParamInt_Disable) {
308 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
309 static const FeatureParam<int> a{&kFeature, "a", 123};
310 EXPECT_EQ(123, a.Get());
311 }
312
TEST_F(FieldTrialParamsTest,FeatureParamDouble)313 TEST_F(FieldTrialParamsTest, FeatureParamDouble) {
314 const std::string kTrialName = "GetFieldTrialParamsByFeature";
315
316 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
317 static const FeatureParam<double> a{&kFeature, "a", 0.0};
318 static const FeatureParam<double> b{&kFeature, "b", 0.0};
319 static const FeatureParam<double> c{&kFeature, "c", 0.0};
320 static const FeatureParam<double> d{&kFeature, "d", 0.0};
321 static const FeatureParam<double> e{&kFeature, "e", 0.0};
322 static const FeatureParam<double> f{&kFeature, "f", 0.0};
323
324 std::map<std::string, std::string> params;
325 params["a"] = "1";
326 params["b"] = "1.5";
327 params["c"] = "1.0e-10";
328 params["d"] = "foo";
329 params["e"] = "";
330 // "f" is not registered
331 AssociateFieldTrialParams(kTrialName, "A", params);
332 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
333
334 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
335 trial.get());
336
337 EXPECT_EQ(1, GetFieldTrialParamByFeatureAsDouble(kFeature, "a", 0));
338 EXPECT_EQ(1.5, GetFieldTrialParamByFeatureAsDouble(kFeature, "b", 0));
339 EXPECT_EQ(1.0e-10, GetFieldTrialParamByFeatureAsDouble(kFeature, "c", 0));
340 EXPECT_EQ(0,
341 GetFieldTrialParamByFeatureAsDouble(kFeature, "d", 0)); // invalid
342 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "e", 0)); // empty
343 EXPECT_EQ(0, GetFieldTrialParamByFeatureAsDouble(kFeature, "f", 0)); // empty
344
345 EXPECT_EQ(1, a.Get());
346 EXPECT_EQ(1.5, b.Get());
347 EXPECT_EQ(1.0e-10, c.Get());
348 EXPECT_EQ(0, d.Get()); // invalid
349 EXPECT_EQ(0, e.Get()); // empty
350 EXPECT_EQ(0, f.Get()); // empty
351 }
352
TEST_F(FieldTrialParamsTest,FeatureParamDouble_Disable)353 TEST_F(FieldTrialParamsTest, FeatureParamDouble_Disable) {
354 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
355 static const FeatureParam<double> a{&kFeature, "a", 0.123};
356 EXPECT_EQ(0.123, a.Get());
357 }
358
TEST_F(FieldTrialParamsTest,FeatureParamBool)359 TEST_F(FieldTrialParamsTest, FeatureParamBool) {
360 const std::string kTrialName = "GetFieldTrialParamsByFeature";
361
362 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
363 static const FeatureParam<bool> a{&kFeature, "a", false};
364 static const FeatureParam<bool> b{&kFeature, "b", true};
365 static const FeatureParam<bool> c{&kFeature, "c", false};
366 static const FeatureParam<bool> d{&kFeature, "d", true};
367 static const FeatureParam<bool> e{&kFeature, "e", true};
368 static const FeatureParam<bool> f{&kFeature, "f", true};
369
370 std::map<std::string, std::string> params;
371 params["a"] = "true";
372 params["b"] = "false";
373 params["c"] = "1";
374 params["d"] = "False";
375 params["e"] = "";
376 // "f" is not registered
377 AssociateFieldTrialParams(kTrialName, "A", params);
378 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
379
380 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
381 trial.get());
382
383 EXPECT_TRUE(a.Get());
384 EXPECT_FALSE(b.Get());
385 EXPECT_EQ(false, c.Get()); // invalid
386 EXPECT_EQ(true, d.Get()); // invalid
387 EXPECT_TRUE(e.Get()); // empty
388 EXPECT_TRUE(f.Get()); // empty
389 }
390
TEST_F(FieldTrialParamsTest,FeatureParamBool_Disable)391 TEST_F(FieldTrialParamsTest, FeatureParamBool_Disable) {
392 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
393 static const FeatureParam<bool> a{&kFeature, "a", true};
394 EXPECT_EQ(true, a.Get());
395 }
396
TEST_F(FieldTrialParamsTest,FeatureParamTimeDelta)397 TEST_F(FieldTrialParamsTest, FeatureParamTimeDelta) {
398 const std::string kTrialName = "GetFieldTrialParamsByFeature";
399
400 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
401 static const FeatureParam<TimeDelta> a{&kFeature, "a", TimeDelta()};
402 static const FeatureParam<TimeDelta> b{&kFeature, "b", TimeDelta()};
403 static const FeatureParam<TimeDelta> c{&kFeature, "c", TimeDelta()};
404 static const FeatureParam<TimeDelta> d{&kFeature, "d", TimeDelta()};
405 static const FeatureParam<TimeDelta> e{&kFeature, "e", TimeDelta()};
406 static const FeatureParam<TimeDelta> f{&kFeature, "f", TimeDelta()};
407
408 std::map<std::string, std::string> params;
409 params["a"] = "1.5s";
410 params["b"] = "1h2m";
411 params["c"] = "1";
412 params["d"] = "true";
413 params["e"] = "";
414 // "f" is not registered
415 AssociateFieldTrialParams(kTrialName, "A", params);
416 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
417
418 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
419 trial.get());
420
421 EXPECT_EQ(a.Get(), Seconds(1.5));
422 EXPECT_EQ(b.Get(), Minutes(62));
423 EXPECT_EQ(c.Get(), TimeDelta()); // invalid
424 EXPECT_EQ(d.Get(), TimeDelta()); // invalid
425 EXPECT_EQ(e.Get(), TimeDelta()); // empty
426 EXPECT_EQ(f.Get(), TimeDelta()); // empty
427 }
428
TEST_F(FieldTrialParamsTest,FeatureParamTimeDelta_Disable)429 TEST_F(FieldTrialParamsTest, FeatureParamTimeDelta_Disable) {
430 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
431 static const FeatureParam<TimeDelta> a{&kFeature, "a", Seconds(1.5)};
432 EXPECT_EQ(Seconds(1.5), a.Get());
433 }
434
435 enum Hand { ROCK, PAPER, SCISSORS };
436
TEST_F(FieldTrialParamsTest,FeatureParamEnum)437 TEST_F(FieldTrialParamsTest, FeatureParamEnum) {
438 const std::string kTrialName = "GetFieldTrialParamsByFeature";
439
440 static const FeatureParam<Hand>::Option hands[] = {
441 {ROCK, "rock"}, {PAPER, "paper"}, {SCISSORS, "scissors"}};
442 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
443 static const FeatureParam<Hand> a{&kFeature, "a", ROCK, &hands};
444 static const FeatureParam<Hand> b{&kFeature, "b", ROCK, &hands};
445 static const FeatureParam<Hand> c{&kFeature, "c", ROCK, &hands};
446 static const FeatureParam<Hand> d{&kFeature, "d", ROCK, &hands};
447 static const FeatureParam<Hand> e{&kFeature, "e", PAPER, &hands};
448 static const FeatureParam<Hand> f{&kFeature, "f", SCISSORS, &hands};
449
450 std::map<std::string, std::string> params;
451 params["a"] = "rock";
452 params["b"] = "paper";
453 params["c"] = "scissors";
454 params["d"] = "lizard";
455 params["e"] = "";
456 // "f" is not registered
457 AssociateFieldTrialParams(kTrialName, "A", params);
458 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
459
460 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
461 trial.get());
462
463 EXPECT_EQ(ROCK, a.Get());
464 EXPECT_EQ(PAPER, b.Get());
465 EXPECT_EQ(SCISSORS, c.Get());
466 EXPECT_EQ(ROCK, d.Get()); // invalid
467 EXPECT_EQ(PAPER, e.Get()); // empty
468 EXPECT_EQ(SCISSORS, f.Get()); // not registered
469 }
470
471 enum class UI { ONE_D, TWO_D, THREE_D };
472
TEST_F(FieldTrialParamsTest,FeatureParamEnumClass)473 TEST_F(FieldTrialParamsTest, FeatureParamEnumClass) {
474 const std::string kTrialName = "GetFieldTrialParamsByFeature";
475
476 static const FeatureParam<UI>::Option uis[] = {
477 {UI::ONE_D, "1d"}, {UI::TWO_D, "2d"}, {UI::THREE_D, "3d"}};
478 static BASE_FEATURE(kFeature, "TestFeature", FEATURE_DISABLED_BY_DEFAULT);
479 static const FeatureParam<UI> a{&kFeature, "a", UI::ONE_D, &uis};
480 static const FeatureParam<UI> b{&kFeature, "b", UI::ONE_D, &uis};
481 static const FeatureParam<UI> c{&kFeature, "c", UI::ONE_D, &uis};
482 static const FeatureParam<UI> d{&kFeature, "d", UI::ONE_D, &uis};
483 static const FeatureParam<UI> e{&kFeature, "e", UI::TWO_D, &uis};
484 static const FeatureParam<UI> f{&kFeature, "f", UI::THREE_D, &uis};
485
486 std::map<std::string, std::string> params;
487 params["a"] = "1d";
488 params["b"] = "2d";
489 params["c"] = "3d";
490 params["d"] = "4d";
491 params["e"] = "";
492 // "f" is not registered
493 AssociateFieldTrialParams(kTrialName, "A", params);
494 scoped_refptr<FieldTrial> trial(CreateFieldTrial(kTrialName, 100, "A"));
495
496 CreateFeatureWithTrial(kFeature, FeatureList::OVERRIDE_ENABLE_FEATURE,
497 trial.get());
498
499 EXPECT_EQ(UI::ONE_D, a.Get());
500 EXPECT_EQ(UI::TWO_D, b.Get());
501 EXPECT_EQ(UI::THREE_D, c.Get());
502 EXPECT_EQ(UI::ONE_D, d.Get()); // invalid
503 EXPECT_EQ(UI::TWO_D, e.Get()); // empty
504 EXPECT_EQ(UI::THREE_D, f.Get()); // not registered
505 }
506
507 } // namespace base
508