1 // Copyright (c) 2012 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 "base/metrics/field_trial.h"
6
7 #include <stddef.h>
8 #include <utility>
9
10 #include "base/base_switches.h"
11 #include "base/build_time.h"
12 #include "base/feature_list.h"
13 #include "base/memory/ptr_util.h"
14 #include "base/metrics/field_trial_param_associator.h"
15 #include "base/rand_util.h"
16 #include "base/run_loop.h"
17 #include "base/stl_util.h"
18 #include "base/strings/string_number_conversions.h"
19 #include "base/strings/stringprintf.h"
20 #include "base/test/gtest_util.h"
21 #include "base/test/mock_entropy_provider.h"
22 #include "base/test/multiprocess_test.h"
23 #include "base/test/scoped_feature_list.h"
24 #include "base/test/scoped_field_trial_list_resetter.h"
25 #include "base/test/task_environment.h"
26 #include "base/test/test_shared_memory_util.h"
27 #include "base/test/test_timeouts.h"
28 #include "build/build_config.h"
29 #include "testing/gtest/include/gtest/gtest.h"
30 #include "testing/multiprocess_func_list.h"
31
32 #if defined(OS_ANDROID)
33 #include "base/posix/global_descriptors.h"
34 #endif
35
36 #if defined(OS_MACOSX) && !defined(OS_IOS)
37 #include "base/mac/mach_port_rendezvous.h"
38 #endif
39
40 namespace base {
41
42 namespace {
43
44 // Default group name used by several tests.
45 const char kDefaultGroupName[] = "DefaultGroup";
46
47 // Call FieldTrialList::FactoryGetFieldTrial().
CreateFieldTrial(const std::string & trial_name,int total_probability,const std::string & default_group_name,int * default_group_number)48 scoped_refptr<FieldTrial> CreateFieldTrial(
49 const std::string& trial_name,
50 int total_probability,
51 const std::string& default_group_name,
52 int* default_group_number) {
53 return FieldTrialList::FactoryGetFieldTrial(
54 trial_name, total_probability, default_group_name,
55 FieldTrial::SESSION_RANDOMIZED, default_group_number);
56 }
57
58 // FieldTrialList::Observer implementation for testing.
59 class TestFieldTrialObserver : public FieldTrialList::Observer {
60 public:
61 enum Type {
62 ASYNCHRONOUS,
63 SYNCHRONOUS,
64 };
65
TestFieldTrialObserver(Type type)66 TestFieldTrialObserver(Type type) : type_(type) {
67 if (type == SYNCHRONOUS)
68 FieldTrialList::SetSynchronousObserver(this);
69 else
70 FieldTrialList::AddObserver(this);
71 }
72
~TestFieldTrialObserver()73 ~TestFieldTrialObserver() override {
74 if (type_ == SYNCHRONOUS)
75 FieldTrialList::RemoveSynchronousObserver(this);
76 else
77 FieldTrialList::RemoveObserver(this);
78 }
79
OnFieldTrialGroupFinalized(const std::string & trial,const std::string & group)80 void OnFieldTrialGroupFinalized(const std::string& trial,
81 const std::string& group) override {
82 trial_name_ = trial;
83 group_name_ = group;
84 }
85
trial_name() const86 const std::string& trial_name() const { return trial_name_; }
group_name() const87 const std::string& group_name() const { return group_name_; }
88
89 private:
90 const Type type_;
91 std::string trial_name_;
92 std::string group_name_;
93
94 DISALLOW_COPY_AND_ASSIGN(TestFieldTrialObserver);
95 };
96
MockEscapeQueryParamValue(const std::string & input)97 std::string MockEscapeQueryParamValue(const std::string& input) {
98 return input;
99 }
100
101 } // namespace
102
103 class FieldTrialTest : public ::testing::Test {
104 public:
FieldTrialTest()105 FieldTrialTest() : trial_list_(nullptr) {}
106
107 private:
108 test::TaskEnvironment task_environment_;
109 // The test suite instantiates a FieldTrialList but for the purpose of these
110 // tests it's cleaner to start from scratch.
111 test::ScopedFieldTrialListResetter trial_list_resetter_;
112 FieldTrialList trial_list_;
113
114 DISALLOW_COPY_AND_ASSIGN(FieldTrialTest);
115 };
116
117 // Test registration, and also check that destructors are called for trials.
TEST_F(FieldTrialTest,Registration)118 TEST_F(FieldTrialTest, Registration) {
119 const char name1[] = "name 1 test";
120 const char name2[] = "name 2 test";
121 EXPECT_FALSE(FieldTrialList::Find(name1));
122 EXPECT_FALSE(FieldTrialList::Find(name2));
123
124 scoped_refptr<FieldTrial> trial1 =
125 CreateFieldTrial(name1, 10, "default name 1 test", nullptr);
126 EXPECT_EQ(FieldTrial::kNotFinalized, trial1->group_);
127 EXPECT_EQ(name1, trial1->trial_name());
128 EXPECT_EQ("", trial1->group_name_internal());
129
130 trial1->AppendGroup(std::string(), 7);
131
132 EXPECT_EQ(trial1.get(), FieldTrialList::Find(name1));
133 EXPECT_FALSE(FieldTrialList::Find(name2));
134
135 scoped_refptr<FieldTrial> trial2 =
136 CreateFieldTrial(name2, 10, "default name 2 test", nullptr);
137 EXPECT_EQ(FieldTrial::kNotFinalized, trial2->group_);
138 EXPECT_EQ(name2, trial2->trial_name());
139 EXPECT_EQ("", trial2->group_name_internal());
140
141 trial2->AppendGroup("a first group", 7);
142
143 EXPECT_EQ(trial1.get(), FieldTrialList::Find(name1));
144 EXPECT_EQ(trial2.get(), FieldTrialList::Find(name2));
145 // Note: FieldTrialList should delete the objects at shutdown.
146 }
147
TEST_F(FieldTrialTest,AbsoluteProbabilities)148 TEST_F(FieldTrialTest, AbsoluteProbabilities) {
149 char always_true[] = " always true";
150 char default_always_true[] = " default always true";
151 char always_false[] = " always false";
152 char default_always_false[] = " default always false";
153 for (int i = 1; i < 250; ++i) {
154 // Try lots of names, by changing the first character of the name.
155 char c = static_cast<char>(i);
156 always_true[0] = c;
157 default_always_true[0] = c;
158 always_false[0] = c;
159 default_always_false[0] = c;
160
161 scoped_refptr<FieldTrial> trial_true =
162 CreateFieldTrial(always_true, 10, default_always_true, nullptr);
163 const std::string winner = "TheWinner";
164 int winner_group = trial_true->AppendGroup(winner, 10);
165
166 EXPECT_EQ(winner_group, trial_true->group());
167 EXPECT_EQ(winner, trial_true->group_name());
168
169 scoped_refptr<FieldTrial> trial_false =
170 CreateFieldTrial(always_false, 10, default_always_false, nullptr);
171 int loser_group = trial_false->AppendGroup("ALoser", 0);
172
173 EXPECT_NE(loser_group, trial_false->group());
174 }
175 }
176
TEST_F(FieldTrialTest,RemainingProbability)177 TEST_F(FieldTrialTest, RemainingProbability) {
178 // First create a test that hasn't had a winner yet.
179 const std::string winner = "Winner";
180 const std::string loser = "Loser";
181 scoped_refptr<FieldTrial> trial;
182 int counter = 0;
183 int default_group_number = -1;
184 do {
185 std::string name = StringPrintf("trial%d", ++counter);
186 trial = CreateFieldTrial(name, 10, winner, &default_group_number);
187 trial->AppendGroup(loser, 5); // 50% chance of not being chosen.
188 // If a group is not assigned, group_ will be kNotFinalized.
189 } while (trial->group_ != FieldTrial::kNotFinalized);
190
191 // And that 'default' group (winner) should always win.
192 EXPECT_EQ(default_group_number, trial->group());
193
194 // And that winner should ALWAYS win.
195 EXPECT_EQ(winner, trial->group_name());
196 }
197
TEST_F(FieldTrialTest,FiftyFiftyProbability)198 TEST_F(FieldTrialTest, FiftyFiftyProbability) {
199 // Check that even with small divisors, we have the proper probabilities, and
200 // all outcomes are possible. Since this is a 50-50 test, it should get both
201 // outcomes in a few tries, but we'll try no more than 100 times (and be flaky
202 // with probability around 1 in 2^99).
203 bool first_winner = false;
204 bool second_winner = false;
205 int counter = 0;
206 do {
207 std::string name = StringPrintf("FiftyFifty%d", ++counter);
208 std::string default_group_name =
209 StringPrintf("Default FiftyFifty%d", ++counter);
210 scoped_refptr<FieldTrial> trial =
211 CreateFieldTrial(name, 2, default_group_name, nullptr);
212 trial->AppendGroup("first", 1); // 50% chance of being chosen.
213 // If group_ is kNotFinalized, then a group assignement hasn't been done.
214 if (trial->group_ != FieldTrial::kNotFinalized) {
215 first_winner = true;
216 continue;
217 }
218 trial->AppendGroup("second", 1); // Always chosen at this point.
219 EXPECT_NE(FieldTrial::kNotFinalized, trial->group());
220 second_winner = true;
221 } while ((!second_winner || !first_winner) && counter < 100);
222 EXPECT_TRUE(second_winner);
223 EXPECT_TRUE(first_winner);
224 }
225
TEST_F(FieldTrialTest,MiddleProbabilities)226 TEST_F(FieldTrialTest, MiddleProbabilities) {
227 char name[] = " same name";
228 char default_group_name[] = " default same name";
229 bool false_event_seen = false;
230 bool true_event_seen = false;
231 for (int i = 1; i < 250; ++i) {
232 char c = static_cast<char>(i);
233 name[0] = c;
234 default_group_name[0] = c;
235 scoped_refptr<FieldTrial> trial =
236 CreateFieldTrial(name, 10, default_group_name, nullptr);
237 int might_win = trial->AppendGroup("MightWin", 5);
238
239 if (trial->group() == might_win) {
240 true_event_seen = true;
241 } else {
242 false_event_seen = true;
243 }
244 if (false_event_seen && true_event_seen)
245 return; // Successful test!!!
246 }
247 // Very surprising to get here. Probability should be around 1 in 2 ** 250.
248 // One of the following will fail.
249 EXPECT_TRUE(false_event_seen);
250 EXPECT_TRUE(true_event_seen);
251 }
252
TEST_F(FieldTrialTest,OneWinner)253 TEST_F(FieldTrialTest, OneWinner) {
254 char name[] = "Some name";
255 char default_group_name[] = "Default some name";
256 int group_count(10);
257
258 int default_group_number = -1;
259 scoped_refptr<FieldTrial> trial =
260 CreateFieldTrial(name, group_count, default_group_name, nullptr);
261 int winner_index(-2);
262 std::string winner_name;
263
264 for (int i = 1; i <= group_count; ++i) {
265 int might_win = trial->AppendGroup(std::string(), 1);
266
267 // Because we keep appending groups, we want to see if the last group that
268 // was added has been assigned or not.
269 if (trial->group_ == might_win) {
270 EXPECT_EQ(-2, winner_index);
271 winner_index = might_win;
272 StringAppendF(&winner_name, "%d", might_win);
273 EXPECT_EQ(winner_name, trial->group_name());
274 }
275 }
276 EXPECT_GE(winner_index, 0);
277 // Since all groups cover the total probability, we should not have
278 // chosen the default group.
279 EXPECT_NE(trial->group(), default_group_number);
280 EXPECT_EQ(trial->group(), winner_index);
281 EXPECT_EQ(trial->group_name(), winner_name);
282 }
283
TEST_F(FieldTrialTest,DisableProbability)284 TEST_F(FieldTrialTest, DisableProbability) {
285 const std::string default_group_name = "Default group";
286 const std::string loser = "Loser";
287 const std::string name = "Trial";
288
289 // Create a field trail that is disabled.
290 int default_group_number = -1;
291 FieldTrial* trial = FieldTrialList::FactoryGetFieldTrial(
292 name, 1000000000, default_group_name, FieldTrial::SESSION_RANDOMIZED,
293 &default_group_number);
294 trial->Disable();
295 trial->AppendGroup(loser, 999999999); // 99.9999999% chance of being chosen.
296
297 // Because trial has expired, we should always be in the default group.
298 EXPECT_EQ(default_group_number, trial->group());
299
300 // And that default_group_name should ALWAYS win.
301 EXPECT_EQ(default_group_name, trial->group_name());
302 }
303
TEST_F(FieldTrialTest,ActiveGroups)304 TEST_F(FieldTrialTest, ActiveGroups) {
305 std::string no_group("No Group");
306 scoped_refptr<FieldTrial> trial =
307 CreateFieldTrial(no_group, 10, "Default", nullptr);
308
309 // There is no winner yet, so no NameGroupId should be returned.
310 FieldTrial::ActiveGroup active_group;
311 EXPECT_FALSE(trial->GetActiveGroup(&active_group));
312
313 // Create a single winning group.
314 std::string one_winner("One Winner");
315 trial = CreateFieldTrial(one_winner, 10, "Default", nullptr);
316 std::string winner("Winner");
317 trial->AppendGroup(winner, 10);
318 EXPECT_FALSE(trial->GetActiveGroup(&active_group));
319 // Finalize the group selection by accessing the selected group.
320 trial->group();
321 EXPECT_TRUE(trial->GetActiveGroup(&active_group));
322 EXPECT_EQ(one_winner, active_group.trial_name);
323 EXPECT_EQ(winner, active_group.group_name);
324
325 std::string multi_group("MultiGroup");
326 scoped_refptr<FieldTrial> multi_group_trial =
327 CreateFieldTrial(multi_group, 9, "Default", nullptr);
328
329 multi_group_trial->AppendGroup("Me", 3);
330 multi_group_trial->AppendGroup("You", 3);
331 multi_group_trial->AppendGroup("Them", 3);
332 EXPECT_FALSE(multi_group_trial->GetActiveGroup(&active_group));
333 // Finalize the group selection by accessing the selected group.
334 multi_group_trial->group();
335 EXPECT_TRUE(multi_group_trial->GetActiveGroup(&active_group));
336 EXPECT_EQ(multi_group, active_group.trial_name);
337 EXPECT_EQ(multi_group_trial->group_name(), active_group.group_name);
338
339 // Now check if the list is built properly...
340 FieldTrial::ActiveGroups active_groups;
341 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
342 EXPECT_EQ(2U, active_groups.size());
343 for (size_t i = 0; i < active_groups.size(); ++i) {
344 // Order is not guaranteed, so check all values.
345 EXPECT_NE(no_group, active_groups[i].trial_name);
346 EXPECT_TRUE(one_winner != active_groups[i].trial_name ||
347 winner == active_groups[i].group_name);
348 EXPECT_TRUE(multi_group != active_groups[i].trial_name ||
349 multi_group_trial->group_name() == active_groups[i].group_name);
350 }
351 }
352
TEST_F(FieldTrialTest,GetActiveFieldTrialGroupsFromString)353 TEST_F(FieldTrialTest, GetActiveFieldTrialGroupsFromString) {
354 FieldTrial::ActiveGroups active_groups;
355 FieldTrialList::GetActiveFieldTrialGroupsFromString("*A/X/B/Y/*C/Z",
356 &active_groups);
357 ASSERT_EQ(2U, active_groups.size());
358 EXPECT_EQ("A", active_groups[0].trial_name);
359 EXPECT_EQ("X", active_groups[0].group_name);
360 EXPECT_EQ("C", active_groups[1].trial_name);
361 EXPECT_EQ("Z", active_groups[1].group_name);
362 }
363
TEST_F(FieldTrialTest,ActiveGroupsNotFinalized)364 TEST_F(FieldTrialTest, ActiveGroupsNotFinalized) {
365 const char kTrialName[] = "TestTrial";
366 const char kSecondaryGroupName[] = "SecondaryGroup";
367
368 int default_group = -1;
369 scoped_refptr<FieldTrial> trial =
370 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
371 const int secondary_group = trial->AppendGroup(kSecondaryGroupName, 50);
372
373 // Before |group()| is called, |GetActiveGroup()| should return false.
374 FieldTrial::ActiveGroup active_group;
375 EXPECT_FALSE(trial->GetActiveGroup(&active_group));
376
377 // |GetActiveFieldTrialGroups()| should also not include the trial.
378 FieldTrial::ActiveGroups active_groups;
379 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
380 EXPECT_TRUE(active_groups.empty());
381
382 // After |group()| has been called, both APIs should succeed.
383 const int chosen_group = trial->group();
384 EXPECT_TRUE(chosen_group == default_group || chosen_group == secondary_group);
385
386 EXPECT_TRUE(trial->GetActiveGroup(&active_group));
387 EXPECT_EQ(kTrialName, active_group.trial_name);
388 if (chosen_group == default_group)
389 EXPECT_EQ(kDefaultGroupName, active_group.group_name);
390 else
391 EXPECT_EQ(kSecondaryGroupName, active_group.group_name);
392
393 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
394 ASSERT_EQ(1U, active_groups.size());
395 EXPECT_EQ(kTrialName, active_groups[0].trial_name);
396 EXPECT_EQ(active_group.group_name, active_groups[0].group_name);
397 }
398
TEST_F(FieldTrialTest,GetGroupNameWithoutActivation)399 TEST_F(FieldTrialTest, GetGroupNameWithoutActivation) {
400 const char kTrialName[] = "TestTrial";
401 const char kSecondaryGroupName[] = "SecondaryGroup";
402
403 int default_group = -1;
404 scoped_refptr<FieldTrial> trial =
405 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
406 trial->AppendGroup(kSecondaryGroupName, 50);
407
408 // The trial should start inactive.
409 EXPECT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
410
411 // Calling |GetGroupNameWithoutActivation()| should not activate the trial.
412 std::string group_name = trial->GetGroupNameWithoutActivation();
413 EXPECT_FALSE(group_name.empty());
414 EXPECT_FALSE(FieldTrialList::IsTrialActive(kTrialName));
415
416 // Calling |group_name()| should activate it and return the same group name.
417 EXPECT_EQ(group_name, trial->group_name());
418 EXPECT_TRUE(FieldTrialList::IsTrialActive(kTrialName));
419 }
420
TEST_F(FieldTrialTest,Save)421 TEST_F(FieldTrialTest, Save) {
422 std::string save_string;
423
424 scoped_refptr<FieldTrial> trial =
425 CreateFieldTrial("Some name", 10, "Default some name", nullptr);
426 // There is no winner yet, so no textual group name is associated with trial.
427 // In this case, the trial should not be included.
428 EXPECT_EQ("", trial->group_name_internal());
429 FieldTrialList::StatesToString(&save_string);
430 EXPECT_EQ("", save_string);
431 save_string.clear();
432
433 // Create a winning group.
434 trial->AppendGroup("Winner", 10);
435 // Finalize the group selection by accessing the selected group.
436 trial->group();
437 FieldTrialList::StatesToString(&save_string);
438 EXPECT_EQ("Some name/Winner/", save_string);
439 save_string.clear();
440
441 // Create a second trial and winning group.
442 scoped_refptr<FieldTrial> trial2 =
443 CreateFieldTrial("xxx", 10, "Default xxx", nullptr);
444 trial2->AppendGroup("yyyy", 10);
445 // Finalize the group selection by accessing the selected group.
446 trial2->group();
447
448 FieldTrialList::StatesToString(&save_string);
449 // We assume names are alphabetized... though this is not critical.
450 EXPECT_EQ("Some name/Winner/xxx/yyyy/", save_string);
451 save_string.clear();
452
453 // Create a third trial with only the default group.
454 scoped_refptr<FieldTrial> trial3 =
455 CreateFieldTrial("zzz", 10, "default", nullptr);
456 // Finalize the group selection by accessing the selected group.
457 trial3->group();
458
459 FieldTrialList::StatesToString(&save_string);
460 EXPECT_EQ("Some name/Winner/xxx/yyyy/zzz/default/", save_string);
461 }
462
TEST_F(FieldTrialTest,SaveAll)463 TEST_F(FieldTrialTest, SaveAll) {
464 std::string save_string;
465
466 scoped_refptr<FieldTrial> trial =
467 CreateFieldTrial("Some name", 10, "Default some name", nullptr);
468 EXPECT_EQ("", trial->group_name_internal());
469 FieldTrialList::AllStatesToString(&save_string, false);
470 EXPECT_EQ("Some name/Default some name/", save_string);
471 // Getting all states should have finalized the trial.
472 EXPECT_EQ("Default some name", trial->group_name_internal());
473 save_string.clear();
474
475 // Create a winning group.
476 trial = CreateFieldTrial("trial2", 10, "Default some name", nullptr);
477 trial->AppendGroup("Winner", 10);
478 // Finalize the group selection by accessing the selected group.
479 trial->group();
480 FieldTrialList::AllStatesToString(&save_string, false);
481 EXPECT_EQ("Some name/Default some name/*trial2/Winner/", save_string);
482 save_string.clear();
483
484 // Create a second trial and winning group.
485 scoped_refptr<FieldTrial> trial2 =
486 CreateFieldTrial("xxx", 10, "Default xxx", nullptr);
487 trial2->AppendGroup("yyyy", 10);
488 // Finalize the group selection by accessing the selected group.
489 trial2->group();
490
491 FieldTrialList::AllStatesToString(&save_string, false);
492 // We assume names are alphabetized... though this is not critical.
493 EXPECT_EQ("Some name/Default some name/*trial2/Winner/*xxx/yyyy/",
494 save_string);
495 save_string.clear();
496
497 // Create a third trial with only the default group.
498 scoped_refptr<FieldTrial> trial3 =
499 CreateFieldTrial("zzz", 10, "default", nullptr);
500
501 FieldTrialList::AllStatesToString(&save_string, false);
502 EXPECT_EQ("Some name/Default some name/*trial2/Winner/*xxx/yyyy/zzz/default/",
503 save_string);
504
505 // Create disabled study.
506 int default_group_number = -1;
507 scoped_refptr<FieldTrial> disabled_trial =
508 FieldTrialList::FactoryGetFieldTrial(
509 "Disabled trial name", 1000000000, "Default group",
510 FieldTrial::SESSION_RANDOMIZED, &default_group_number);
511 disabled_trial->AppendGroup("Disabled trial group name", 999999999);
512 disabled_trial->Disable();
513
514 save_string.clear();
515 FieldTrialList::AllStatesToString(&save_string, false);
516 EXPECT_EQ("Some name/Default some name/*trial2/Winner/*xxx/yyyy/zzz/default/",
517 save_string);
518 save_string.clear();
519 FieldTrialList::AllStatesToString(&save_string, true);
520 EXPECT_EQ(
521 "Disabled trial name/Default group/"
522 "Some name/Default some name/*trial2/Winner/*xxx/yyyy/zzz/default/",
523 save_string);
524 }
525
TEST_F(FieldTrialTest,Restore)526 TEST_F(FieldTrialTest, Restore) {
527 ASSERT_FALSE(FieldTrialList::TrialExists("Some_name"));
528 ASSERT_FALSE(FieldTrialList::TrialExists("xxx"));
529
530 FieldTrialList::CreateTrialsFromString("Some_name/Winner/xxx/yyyy/",
531 std::set<std::string>());
532
533 FieldTrial* trial = FieldTrialList::Find("Some_name");
534 ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
535 EXPECT_EQ("Winner", trial->group_name());
536 EXPECT_EQ("Some_name", trial->trial_name());
537
538 trial = FieldTrialList::Find("xxx");
539 ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
540 EXPECT_EQ("yyyy", trial->group_name());
541 EXPECT_EQ("xxx", trial->trial_name());
542 }
543
TEST_F(FieldTrialTest,RestoreNotEndingWithSlash)544 TEST_F(FieldTrialTest, RestoreNotEndingWithSlash) {
545 EXPECT_TRUE(FieldTrialList::CreateTrialsFromString("tname/gname",
546 std::set<std::string>()));
547
548 FieldTrial* trial = FieldTrialList::Find("tname");
549 ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
550 EXPECT_EQ("gname", trial->group_name());
551 EXPECT_EQ("tname", trial->trial_name());
552 }
553
TEST_F(FieldTrialTest,BogusRestore)554 TEST_F(FieldTrialTest, BogusRestore) {
555 EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("MissingSlash",
556 std::set<std::string>()));
557 EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("MissingGroupName/",
558 std::set<std::string>()));
559 EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("noname, only group/",
560 std::set<std::string>()));
561 EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("/emptyname",
562 std::set<std::string>()));
563 EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("*/emptyname",
564 std::set<std::string>()));
565 }
566
TEST_F(FieldTrialTest,DuplicateRestore)567 TEST_F(FieldTrialTest, DuplicateRestore) {
568 scoped_refptr<FieldTrial> trial =
569 CreateFieldTrial("Some name", 10, "Default", nullptr);
570 trial->AppendGroup("Winner", 10);
571 // Finalize the group selection by accessing the selected group.
572 trial->group();
573 std::string save_string;
574 FieldTrialList::StatesToString(&save_string);
575 EXPECT_EQ("Some name/Winner/", save_string);
576
577 // It is OK if we redundantly specify a winner.
578 EXPECT_TRUE(FieldTrialList::CreateTrialsFromString(save_string,
579 std::set<std::string>()));
580
581 // But it is an error to try to change to a different winner.
582 EXPECT_FALSE(FieldTrialList::CreateTrialsFromString("Some name/Loser/",
583 std::set<std::string>()));
584 }
585
TEST_F(FieldTrialTest,CreateTrialsFromStringNotActive)586 TEST_F(FieldTrialTest, CreateTrialsFromStringNotActive) {
587 ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
588 ASSERT_FALSE(FieldTrialList::TrialExists("Xyz"));
589 ASSERT_TRUE(FieldTrialList::CreateTrialsFromString("Abc/def/Xyz/zyx/",
590 std::set<std::string>()));
591
592 FieldTrial::ActiveGroups active_groups;
593 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
594 ASSERT_TRUE(active_groups.empty());
595
596 // Check that the values still get returned and querying them activates them.
597 EXPECT_EQ("def", FieldTrialList::FindFullName("Abc"));
598 EXPECT_EQ("zyx", FieldTrialList::FindFullName("Xyz"));
599
600 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
601 ASSERT_EQ(2U, active_groups.size());
602 EXPECT_EQ("Abc", active_groups[0].trial_name);
603 EXPECT_EQ("def", active_groups[0].group_name);
604 EXPECT_EQ("Xyz", active_groups[1].trial_name);
605 EXPECT_EQ("zyx", active_groups[1].group_name);
606 }
607
TEST_F(FieldTrialTest,CreateTrialsFromStringForceActivation)608 TEST_F(FieldTrialTest, CreateTrialsFromStringForceActivation) {
609 ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
610 ASSERT_FALSE(FieldTrialList::TrialExists("def"));
611 ASSERT_FALSE(FieldTrialList::TrialExists("Xyz"));
612 ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
613 "*Abc/cba/def/fed/*Xyz/zyx/", std::set<std::string>()));
614
615 FieldTrial::ActiveGroups active_groups;
616 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
617 ASSERT_EQ(2U, active_groups.size());
618 EXPECT_EQ("Abc", active_groups[0].trial_name);
619 EXPECT_EQ("cba", active_groups[0].group_name);
620 EXPECT_EQ("Xyz", active_groups[1].trial_name);
621 EXPECT_EQ("zyx", active_groups[1].group_name);
622 }
623
TEST_F(FieldTrialTest,CreateTrialsFromStringNotActiveObserver)624 TEST_F(FieldTrialTest, CreateTrialsFromStringNotActiveObserver) {
625 ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
626
627 TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
628 ASSERT_TRUE(FieldTrialList::CreateTrialsFromString("Abc/def/",
629 std::set<std::string>()));
630 RunLoop().RunUntilIdle();
631 // Observer shouldn't be notified.
632 EXPECT_TRUE(observer.trial_name().empty());
633
634 // Check that the values still get returned and querying them activates them.
635 EXPECT_EQ("def", FieldTrialList::FindFullName("Abc"));
636
637 RunLoop().RunUntilIdle();
638 EXPECT_EQ("Abc", observer.trial_name());
639 EXPECT_EQ("def", observer.group_name());
640 }
641
TEST_F(FieldTrialTest,CreateTrialsFromStringWithIgnoredFieldTrials)642 TEST_F(FieldTrialTest, CreateTrialsFromStringWithIgnoredFieldTrials) {
643 ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted1"));
644 ASSERT_FALSE(FieldTrialList::TrialExists("Foo"));
645 ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted2"));
646 ASSERT_FALSE(FieldTrialList::TrialExists("Bar"));
647 ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted3"));
648
649 std::set<std::string> ignored_trial_names;
650 ignored_trial_names.insert("Unaccepted1");
651 ignored_trial_names.insert("Unaccepted2");
652 ignored_trial_names.insert("Unaccepted3");
653
654 FieldTrialList::CreateTrialsFromString(
655 "Unaccepted1/Unaccepted1_name/"
656 "Foo/Foo_name/"
657 "Unaccepted2/Unaccepted2_name/"
658 "Bar/Bar_name/"
659 "Unaccepted3/Unaccepted3_name/",
660 ignored_trial_names);
661
662 EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted1"));
663 EXPECT_TRUE(FieldTrialList::TrialExists("Foo"));
664 EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted2"));
665 EXPECT_TRUE(FieldTrialList::TrialExists("Bar"));
666 EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted3"));
667
668 FieldTrial::ActiveGroups active_groups;
669 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
670 EXPECT_TRUE(active_groups.empty());
671
672 FieldTrial* trial = FieldTrialList::Find("Foo");
673 ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
674 EXPECT_EQ("Foo", trial->trial_name());
675 EXPECT_EQ("Foo_name", trial->group_name());
676
677 trial = FieldTrialList::Find("Bar");
678 ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
679 EXPECT_EQ("Bar", trial->trial_name());
680 EXPECT_EQ("Bar_name", trial->group_name());
681 }
682
TEST_F(FieldTrialTest,CreateFieldTrial)683 TEST_F(FieldTrialTest, CreateFieldTrial) {
684 ASSERT_FALSE(FieldTrialList::TrialExists("Some_name"));
685
686 FieldTrialList::CreateFieldTrial("Some_name", "Winner");
687
688 FieldTrial* trial = FieldTrialList::Find("Some_name");
689 ASSERT_NE(static_cast<FieldTrial*>(nullptr), trial);
690 EXPECT_EQ("Winner", trial->group_name());
691 EXPECT_EQ("Some_name", trial->trial_name());
692 }
693
TEST_F(FieldTrialTest,CreateFieldTrialIsNotActive)694 TEST_F(FieldTrialTest, CreateFieldTrialIsNotActive) {
695 const char kTrialName[] = "CreateFieldTrialIsActiveTrial";
696 const char kWinnerGroup[] = "Winner";
697 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
698 FieldTrialList::CreateFieldTrial(kTrialName, kWinnerGroup);
699
700 FieldTrial::ActiveGroups active_groups;
701 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
702 EXPECT_TRUE(active_groups.empty());
703 }
704
TEST_F(FieldTrialTest,DuplicateFieldTrial)705 TEST_F(FieldTrialTest, DuplicateFieldTrial) {
706 scoped_refptr<FieldTrial> trial =
707 CreateFieldTrial("Some_name", 10, "Default", nullptr);
708 trial->AppendGroup("Winner", 10);
709
710 // It is OK if we redundantly specify a winner.
711 FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("Some_name", "Winner");
712 EXPECT_TRUE(trial1 != nullptr);
713
714 // But it is an error to try to change to a different winner.
715 FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("Some_name", "Loser");
716 EXPECT_TRUE(trial2 == nullptr);
717 }
718
TEST_F(FieldTrialTest,DisableImmediately)719 TEST_F(FieldTrialTest, DisableImmediately) {
720 int default_group_number = -1;
721 scoped_refptr<FieldTrial> trial =
722 CreateFieldTrial("trial", 100, "default", &default_group_number);
723 trial->Disable();
724 ASSERT_EQ("default", trial->group_name());
725 ASSERT_EQ(default_group_number, trial->group());
726 }
727
TEST_F(FieldTrialTest,DisableAfterInitialization)728 TEST_F(FieldTrialTest, DisableAfterInitialization) {
729 scoped_refptr<FieldTrial> trial =
730 CreateFieldTrial("trial", 100, "default", nullptr);
731 trial->AppendGroup("non_default", 100);
732 trial->Disable();
733 ASSERT_EQ("default", trial->group_name());
734 }
735
TEST_F(FieldTrialTest,ForcedFieldTrials)736 TEST_F(FieldTrialTest, ForcedFieldTrials) {
737 // Validate we keep the forced choice.
738 FieldTrial* forced_trial = FieldTrialList::CreateFieldTrial("Use the",
739 "Force");
740 EXPECT_STREQ("Force", forced_trial->group_name().c_str());
741
742 int default_group_number = -1;
743 scoped_refptr<FieldTrial> factory_trial =
744 CreateFieldTrial("Use the", 1000, "default", &default_group_number);
745 EXPECT_EQ(factory_trial.get(), forced_trial);
746
747 int chosen_group = factory_trial->AppendGroup("Force", 100);
748 EXPECT_EQ(chosen_group, factory_trial->group());
749 int not_chosen_group = factory_trial->AppendGroup("Dark Side", 100);
750 EXPECT_NE(chosen_group, not_chosen_group);
751
752 // Since we didn't force the default group, we should not be returned the
753 // chosen group as the default group.
754 EXPECT_NE(default_group_number, chosen_group);
755 int new_group = factory_trial->AppendGroup("Duck Tape", 800);
756 EXPECT_NE(chosen_group, new_group);
757 // The new group should not be the default group either.
758 EXPECT_NE(default_group_number, new_group);
759 }
760
TEST_F(FieldTrialTest,ForcedFieldTrialsDefaultGroup)761 TEST_F(FieldTrialTest, ForcedFieldTrialsDefaultGroup) {
762 // Forcing the default should use the proper group ID.
763 FieldTrial* forced_trial = FieldTrialList::CreateFieldTrial("Trial Name",
764 "Default");
765 int default_group_number = -1;
766 scoped_refptr<FieldTrial> factory_trial =
767 CreateFieldTrial("Trial Name", 1000, "Default", &default_group_number);
768 EXPECT_EQ(forced_trial, factory_trial.get());
769
770 int other_group = factory_trial->AppendGroup("Not Default", 100);
771 EXPECT_STREQ("Default", factory_trial->group_name().c_str());
772 EXPECT_EQ(default_group_number, factory_trial->group());
773 EXPECT_NE(other_group, factory_trial->group());
774
775 int new_other_group = factory_trial->AppendGroup("Not Default Either", 800);
776 EXPECT_NE(new_other_group, factory_trial->group());
777 }
778
TEST_F(FieldTrialTest,SetForced)779 TEST_F(FieldTrialTest, SetForced) {
780 // Start by setting a trial for which we ensure a winner...
781 int default_group_number = -1;
782 scoped_refptr<FieldTrial> forced_trial =
783 CreateFieldTrial("Use the", 1, "default", &default_group_number);
784 EXPECT_EQ(forced_trial, forced_trial);
785
786 int forced_group = forced_trial->AppendGroup("Force", 1);
787 EXPECT_EQ(forced_group, forced_trial->group());
788
789 // Now force it.
790 forced_trial->SetForced();
791
792 // Now try to set it up differently as a hard coded registration would.
793 scoped_refptr<FieldTrial> hard_coded_trial =
794 CreateFieldTrial("Use the", 1, "default", &default_group_number);
795 EXPECT_EQ(hard_coded_trial, forced_trial);
796
797 int would_lose_group = hard_coded_trial->AppendGroup("Force", 0);
798 EXPECT_EQ(forced_group, hard_coded_trial->group());
799 EXPECT_EQ(forced_group, would_lose_group);
800
801 // Same thing if we would have done it to win again.
802 scoped_refptr<FieldTrial> other_hard_coded_trial =
803 CreateFieldTrial("Use the", 1, "default", &default_group_number);
804 EXPECT_EQ(other_hard_coded_trial, forced_trial);
805
806 int would_win_group = other_hard_coded_trial->AppendGroup("Force", 1);
807 EXPECT_EQ(forced_group, other_hard_coded_trial->group());
808 EXPECT_EQ(forced_group, would_win_group);
809 }
810
TEST_F(FieldTrialTest,SetForcedDefaultOnly)811 TEST_F(FieldTrialTest, SetForcedDefaultOnly) {
812 const char kTrialName[] = "SetForcedDefaultOnly";
813 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
814
815 int default_group = -1;
816 scoped_refptr<FieldTrial> trial =
817 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
818 trial->SetForced();
819
820 trial = CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
821 EXPECT_EQ(default_group, trial->group());
822 EXPECT_EQ(kDefaultGroupName, trial->group_name());
823 }
824
TEST_F(FieldTrialTest,SetForcedDefaultWithExtraGroup)825 TEST_F(FieldTrialTest, SetForcedDefaultWithExtraGroup) {
826 const char kTrialName[] = "SetForcedDefaultWithExtraGroup";
827 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
828
829 int default_group = -1;
830 scoped_refptr<FieldTrial> trial =
831 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
832 trial->SetForced();
833
834 trial = CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
835 const int extra_group = trial->AppendGroup("Extra", 100);
836 EXPECT_EQ(default_group, trial->group());
837 EXPECT_NE(extra_group, trial->group());
838 EXPECT_EQ(kDefaultGroupName, trial->group_name());
839 }
840
TEST_F(FieldTrialTest,SetForcedTurnFeatureOn)841 TEST_F(FieldTrialTest, SetForcedTurnFeatureOn) {
842 const char kTrialName[] = "SetForcedTurnFeatureOn";
843 const char kExtraGroupName[] = "Extra";
844 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
845
846 // Simulate a server-side (forced) config that turns the feature on when the
847 // original hard-coded config had it disabled.
848 scoped_refptr<FieldTrial> forced_trial =
849 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
850 forced_trial->AppendGroup(kExtraGroupName, 100);
851 forced_trial->SetForced();
852
853 int default_group = -1;
854 scoped_refptr<FieldTrial> client_trial =
855 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
856 const int extra_group = client_trial->AppendGroup(kExtraGroupName, 0);
857 EXPECT_NE(default_group, extra_group);
858
859 EXPECT_FALSE(client_trial->group_reported_);
860 EXPECT_EQ(extra_group, client_trial->group());
861 EXPECT_TRUE(client_trial->group_reported_);
862 EXPECT_EQ(kExtraGroupName, client_trial->group_name());
863 }
864
TEST_F(FieldTrialTest,SetForcedTurnFeatureOff)865 TEST_F(FieldTrialTest, SetForcedTurnFeatureOff) {
866 const char kTrialName[] = "SetForcedTurnFeatureOff";
867 const char kExtraGroupName[] = "Extra";
868 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
869
870 // Simulate a server-side (forced) config that turns the feature off when the
871 // original hard-coded config had it enabled.
872 scoped_refptr<FieldTrial> forced_trial =
873 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
874 forced_trial->AppendGroup(kExtraGroupName, 0);
875 forced_trial->SetForced();
876
877 int default_group = -1;
878 scoped_refptr<FieldTrial> client_trial =
879 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
880 const int extra_group = client_trial->AppendGroup(kExtraGroupName, 100);
881 EXPECT_NE(default_group, extra_group);
882
883 EXPECT_FALSE(client_trial->group_reported_);
884 EXPECT_EQ(default_group, client_trial->group());
885 EXPECT_TRUE(client_trial->group_reported_);
886 EXPECT_EQ(kDefaultGroupName, client_trial->group_name());
887 }
888
TEST_F(FieldTrialTest,SetForcedChangeDefault_Default)889 TEST_F(FieldTrialTest, SetForcedChangeDefault_Default) {
890 const char kTrialName[] = "SetForcedDefaultGroupChange";
891 const char kGroupAName[] = "A";
892 const char kGroupBName[] = "B";
893 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
894
895 // Simulate a server-side (forced) config that switches which group is default
896 // and ensures that the non-forced code receives the correct group numbers.
897 scoped_refptr<FieldTrial> forced_trial =
898 CreateFieldTrial(kTrialName, 100, kGroupAName, nullptr);
899 forced_trial->AppendGroup(kGroupBName, 100);
900 forced_trial->SetForced();
901
902 int default_group = -1;
903 scoped_refptr<FieldTrial> client_trial =
904 CreateFieldTrial(kTrialName, 100, kGroupBName, &default_group);
905 const int extra_group = client_trial->AppendGroup(kGroupAName, 50);
906 EXPECT_NE(default_group, extra_group);
907
908 EXPECT_FALSE(client_trial->group_reported_);
909 EXPECT_EQ(default_group, client_trial->group());
910 EXPECT_TRUE(client_trial->group_reported_);
911 EXPECT_EQ(kGroupBName, client_trial->group_name());
912 }
913
TEST_F(FieldTrialTest,SetForcedChangeDefault_NonDefault)914 TEST_F(FieldTrialTest, SetForcedChangeDefault_NonDefault) {
915 const char kTrialName[] = "SetForcedDefaultGroupChange";
916 const char kGroupAName[] = "A";
917 const char kGroupBName[] = "B";
918 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
919
920 // Simulate a server-side (forced) config that switches which group is default
921 // and ensures that the non-forced code receives the correct group numbers.
922 scoped_refptr<FieldTrial> forced_trial =
923 CreateFieldTrial(kTrialName, 100, kGroupAName, nullptr);
924 forced_trial->AppendGroup(kGroupBName, 0);
925 forced_trial->SetForced();
926
927 int default_group = -1;
928 scoped_refptr<FieldTrial> client_trial =
929 CreateFieldTrial(kTrialName, 100, kGroupBName, &default_group);
930 const int extra_group = client_trial->AppendGroup(kGroupAName, 50);
931 EXPECT_NE(default_group, extra_group);
932
933 EXPECT_FALSE(client_trial->group_reported_);
934 EXPECT_EQ(extra_group, client_trial->group());
935 EXPECT_TRUE(client_trial->group_reported_);
936 EXPECT_EQ(kGroupAName, client_trial->group_name());
937 }
938
TEST_F(FieldTrialTest,Observe)939 TEST_F(FieldTrialTest, Observe) {
940 const char kTrialName[] = "TrialToObserve1";
941 const char kSecondaryGroupName[] = "SecondaryGroup";
942
943 TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
944 int default_group = -1;
945 scoped_refptr<FieldTrial> trial =
946 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
947 const int secondary_group = trial->AppendGroup(kSecondaryGroupName, 50);
948 const int chosen_group = trial->group();
949 EXPECT_TRUE(chosen_group == default_group || chosen_group == secondary_group);
950
951 EXPECT_EQ(kTrialName, observer.trial_name());
952 if (chosen_group == default_group)
953 EXPECT_EQ(kDefaultGroupName, observer.group_name());
954 else
955 EXPECT_EQ(kSecondaryGroupName, observer.group_name());
956 }
957
TEST_F(FieldTrialTest,SynchronousObserver)958 TEST_F(FieldTrialTest, SynchronousObserver) {
959 const char kTrialName[] = "TrialToObserve1";
960 const char kSecondaryGroupName[] = "SecondaryGroup";
961
962 TestFieldTrialObserver observer(TestFieldTrialObserver::SYNCHRONOUS);
963 int default_group = -1;
964 scoped_refptr<FieldTrial> trial =
965 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
966 const int secondary_group = trial->AppendGroup(kSecondaryGroupName, 50);
967 const int chosen_group = trial->group();
968 EXPECT_TRUE(chosen_group == default_group || chosen_group == secondary_group);
969
970 // The observer should be notified synchronously by the group() call.
971 EXPECT_EQ(kTrialName, observer.trial_name());
972 if (chosen_group == default_group)
973 EXPECT_EQ(kDefaultGroupName, observer.group_name());
974 else
975 EXPECT_EQ(kSecondaryGroupName, observer.group_name());
976 }
977
TEST_F(FieldTrialTest,ObserveDisabled)978 TEST_F(FieldTrialTest, ObserveDisabled) {
979 const char kTrialName[] = "TrialToObserve2";
980
981 TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
982 int default_group = -1;
983 scoped_refptr<FieldTrial> trial =
984 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
985 trial->AppendGroup("A", 25);
986 trial->AppendGroup("B", 25);
987 trial->AppendGroup("C", 25);
988 trial->Disable();
989
990 // Observer shouldn't be notified of a disabled trial.
991 RunLoop().RunUntilIdle();
992 EXPECT_TRUE(observer.trial_name().empty());
993 EXPECT_TRUE(observer.group_name().empty());
994
995 // Observer shouldn't be notified even after a |group()| call.
996 EXPECT_EQ(default_group, trial->group());
997 RunLoop().RunUntilIdle();
998 EXPECT_TRUE(observer.trial_name().empty());
999 EXPECT_TRUE(observer.group_name().empty());
1000 }
1001
TEST_F(FieldTrialTest,ObserveForcedDisabled)1002 TEST_F(FieldTrialTest, ObserveForcedDisabled) {
1003 const char kTrialName[] = "TrialToObserve3";
1004
1005 TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
1006 int default_group = -1;
1007 scoped_refptr<FieldTrial> trial =
1008 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
1009 trial->AppendGroup("A", 25);
1010 trial->AppendGroup("B", 25);
1011 trial->AppendGroup("C", 25);
1012 trial->SetForced();
1013 trial->Disable();
1014
1015 // Observer shouldn't be notified of a disabled trial, even when forced.
1016 RunLoop().RunUntilIdle();
1017 EXPECT_TRUE(observer.trial_name().empty());
1018 EXPECT_TRUE(observer.group_name().empty());
1019
1020 // Observer shouldn't be notified even after a |group()| call.
1021 EXPECT_EQ(default_group, trial->group());
1022 RunLoop().RunUntilIdle();
1023 EXPECT_TRUE(observer.trial_name().empty());
1024 EXPECT_TRUE(observer.group_name().empty());
1025 }
1026
TEST_F(FieldTrialTest,DisabledTrialNotActive)1027 TEST_F(FieldTrialTest, DisabledTrialNotActive) {
1028 const char kTrialName[] = "DisabledTrial";
1029 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
1030
1031 scoped_refptr<FieldTrial> trial =
1032 CreateFieldTrial(kTrialName, 100, kDefaultGroupName, nullptr);
1033 trial->AppendGroup("X", 50);
1034 trial->Disable();
1035
1036 // Ensure the trial is not listed as active.
1037 FieldTrial::ActiveGroups active_groups;
1038 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
1039 EXPECT_TRUE(active_groups.empty());
1040
1041 // Ensure the trial is not listed in the |StatesToString()| result.
1042 std::string states;
1043 FieldTrialList::StatesToString(&states);
1044 EXPECT_TRUE(states.empty());
1045 }
1046
TEST_F(FieldTrialTest,NotDisabled)1047 TEST_F(FieldTrialTest, NotDisabled) {
1048 const char kTrialName[] = "NotDisabled";
1049 const char kGroupName[] = "Group2";
1050 const int kProbability = 100;
1051 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
1052
1053 scoped_refptr<FieldTrial> trial =
1054 CreateFieldTrial(kTrialName, kProbability, kDefaultGroupName, nullptr);
1055 trial->AppendGroup(kGroupName, kProbability);
1056 EXPECT_EQ(kGroupName, trial->group_name());
1057 }
1058
TEST_F(FieldTrialTest,FloatBoundariesGiveEqualGroupSizes)1059 TEST_F(FieldTrialTest, FloatBoundariesGiveEqualGroupSizes) {
1060 const int kBucketCount = 100;
1061
1062 // Try each boundary value |i / 100.0| as the entropy value.
1063 for (int i = 0; i < kBucketCount; ++i) {
1064 const double entropy = i / static_cast<double>(kBucketCount);
1065
1066 scoped_refptr<FieldTrial> trial(
1067 new FieldTrial("test", kBucketCount, "default", entropy));
1068 for (int j = 0; j < kBucketCount; ++j)
1069 trial->AppendGroup(NumberToString(j), 1);
1070
1071 EXPECT_EQ(NumberToString(i), trial->group_name());
1072 }
1073 }
1074
TEST_F(FieldTrialTest,DoesNotSurpassTotalProbability)1075 TEST_F(FieldTrialTest, DoesNotSurpassTotalProbability) {
1076 const double kEntropyValue = 1.0 - 1e-9;
1077 ASSERT_LT(kEntropyValue, 1.0);
1078
1079 scoped_refptr<FieldTrial> trial(
1080 new FieldTrial("test", 2, "default", kEntropyValue));
1081 trial->AppendGroup("1", 1);
1082 trial->AppendGroup("2", 1);
1083
1084 EXPECT_EQ("2", trial->group_name());
1085 }
1086
TEST_F(FieldTrialTest,CreateSimulatedFieldTrial)1087 TEST_F(FieldTrialTest, CreateSimulatedFieldTrial) {
1088 const char kTrialName[] = "CreateSimulatedFieldTrial";
1089 ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
1090
1091 // Different cases to test, e.g. default vs. non default group being chosen.
1092 struct {
1093 double entropy_value;
1094 const char* expected_group;
1095 } test_cases[] = {
1096 { 0.4, "A" },
1097 { 0.85, "B" },
1098 { 0.95, kDefaultGroupName },
1099 };
1100
1101 for (size_t i = 0; i < base::size(test_cases); ++i) {
1102 TestFieldTrialObserver observer(TestFieldTrialObserver::ASYNCHRONOUS);
1103 scoped_refptr<FieldTrial> trial(
1104 FieldTrial::CreateSimulatedFieldTrial(kTrialName, 100, kDefaultGroupName,
1105 test_cases[i].entropy_value));
1106 trial->AppendGroup("A", 80);
1107 trial->AppendGroup("B", 10);
1108 EXPECT_EQ(test_cases[i].expected_group, trial->group_name());
1109
1110 // Field trial shouldn't have been registered with the list.
1111 EXPECT_FALSE(FieldTrialList::TrialExists(kTrialName));
1112 EXPECT_EQ(0u, FieldTrialList::GetFieldTrialCount());
1113
1114 // Observer shouldn't have been notified.
1115 RunLoop().RunUntilIdle();
1116 EXPECT_TRUE(observer.trial_name().empty());
1117
1118 // The trial shouldn't be in the active set of trials.
1119 FieldTrial::ActiveGroups active_groups;
1120 FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
1121 EXPECT_TRUE(active_groups.empty());
1122
1123 // The trial shouldn't be listed in the |StatesToString()| result.
1124 std::string states;
1125 FieldTrialList::StatesToString(&states);
1126 EXPECT_TRUE(states.empty());
1127 }
1128 }
1129
TEST(FieldTrialTestWithoutList,StatesStringFormat)1130 TEST(FieldTrialTestWithoutList, StatesStringFormat) {
1131 std::string save_string;
1132
1133 // The test suite instantiates a FieldTrialList but for the purpose of these
1134 // tests it's cleaner to start from scratch.
1135 test::ScopedFieldTrialListResetter trial_list_resetter_;
1136
1137 // Scoping the first FieldTrialList, as we need another one to test the
1138 // importing function.
1139 {
1140 FieldTrialList field_trial_list(nullptr);
1141 scoped_refptr<FieldTrial> trial =
1142 CreateFieldTrial("Abc", 10, "Default some name", nullptr);
1143 trial->AppendGroup("cba", 10);
1144 trial->group();
1145 scoped_refptr<FieldTrial> trial2 =
1146 CreateFieldTrial("Xyz", 10, "Default xxx", nullptr);
1147 trial2->AppendGroup("zyx", 10);
1148 trial2->group();
1149 scoped_refptr<FieldTrial> trial3 =
1150 CreateFieldTrial("zzz", 10, "default", nullptr);
1151
1152 FieldTrialList::AllStatesToString(&save_string, false);
1153 }
1154
1155 // Starting with a new blank FieldTrialList.
1156 FieldTrialList field_trial_list(nullptr);
1157 ASSERT_TRUE(field_trial_list.CreateTrialsFromString(save_string,
1158 std::set<std::string>()));
1159
1160 FieldTrial::ActiveGroups active_groups;
1161 field_trial_list.GetActiveFieldTrialGroups(&active_groups);
1162 ASSERT_EQ(2U, active_groups.size());
1163 EXPECT_EQ("Abc", active_groups[0].trial_name);
1164 EXPECT_EQ("cba", active_groups[0].group_name);
1165 EXPECT_EQ("Xyz", active_groups[1].trial_name);
1166 EXPECT_EQ("zyx", active_groups[1].group_name);
1167 EXPECT_TRUE(field_trial_list.TrialExists("zzz"));
1168 }
1169
TEST(FieldTrialDeathTest,OneTimeRandomizedTrialWithoutFieldTrialList)1170 TEST(FieldTrialDeathTest, OneTimeRandomizedTrialWithoutFieldTrialList) {
1171 test::ScopedFieldTrialListResetter resetter;
1172 // Trying to instantiate a one-time randomized field trial before the
1173 // FieldTrialList is created should crash.
1174 EXPECT_DEATH_IF_SUPPORTED(
1175 FieldTrialList::FactoryGetFieldTrial(
1176 "OneTimeRandomizedTrialWithoutFieldTrialList", 100, kDefaultGroupName,
1177 FieldTrial::ONE_TIME_RANDOMIZED, nullptr),
1178 "");
1179 }
1180
1181 class FieldTrialListTest : public ::testing::Test {
1182 public:
1183 FieldTrialListTest() = default;
1184
1185 private:
1186 // The test suite instantiates a FieldTrialList but for the purpose of these
1187 // tests it's cleaner to start from scratch.
1188 test::ScopedFieldTrialListResetter trial_list_resetter_;
1189 };
1190
1191 #if defined(OS_FUCHSIA)
1192 // TODO(crbug.com/752368): This is flaky on Fuchsia.
1193 #define MAYBE_TestCopyFieldTrialStateToFlags \
1194 DISABLED_TestCopyFieldTrialStateToFlags
1195 #else
1196 #define MAYBE_TestCopyFieldTrialStateToFlags TestCopyFieldTrialStateToFlags
1197 #endif
TEST_F(FieldTrialListTest,MAYBE_TestCopyFieldTrialStateToFlags)1198 TEST_F(FieldTrialListTest, MAYBE_TestCopyFieldTrialStateToFlags) {
1199 constexpr char kFieldTrialHandleSwitch[] = "test-field-trial-handle";
1200 constexpr char kEnableFeaturesSwitch[] = "test-enable-features";
1201 constexpr char kDisableFeaturesSwitch[] = "test-disable-features";
1202
1203 FieldTrialList field_trial_list(std::make_unique<MockEntropyProvider>());
1204
1205 std::unique_ptr<FeatureList> feature_list(new FeatureList);
1206 feature_list->InitializeFromCommandLine("A,B", "C");
1207
1208 FieldTrial* trial = FieldTrialList::CreateFieldTrial("Trial1", "Group1");
1209 feature_list->RegisterFieldTrialOverride(
1210 "MyFeature", FeatureList::OVERRIDE_ENABLE_FEATURE, trial);
1211
1212 test::ScopedFeatureList scoped_feature_list;
1213 scoped_feature_list.InitWithFeatureList(std::move(feature_list));
1214
1215 FilePath test_file_path = FilePath(FILE_PATH_LITERAL("Program"));
1216 CommandLine command_line = CommandLine(test_file_path);
1217
1218 FieldTrialList::CopyFieldTrialStateToFlags(
1219 kFieldTrialHandleSwitch, kEnableFeaturesSwitch, kDisableFeaturesSwitch,
1220 &command_line);
1221 EXPECT_TRUE(command_line.HasSwitch(kFieldTrialHandleSwitch));
1222
1223 // Explictly specified enabled/disabled features should be specified.
1224 EXPECT_EQ("A,B", command_line.GetSwitchValueASCII(kEnableFeaturesSwitch));
1225 EXPECT_EQ("C", command_line.GetSwitchValueASCII(kDisableFeaturesSwitch));
1226 }
1227
TEST_F(FieldTrialListTest,InstantiateAllocator)1228 TEST_F(FieldTrialListTest, InstantiateAllocator) {
1229 FieldTrialList field_trial_list(nullptr);
1230
1231 FieldTrialList::CreateFieldTrial("Trial1", "Group1");
1232
1233 FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
1234 const void* memory = field_trial_list.field_trial_allocator_->data();
1235 size_t used = field_trial_list.field_trial_allocator_->used();
1236
1237 // Ensure that the function is idempotent.
1238 FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
1239 const void* new_memory = field_trial_list.field_trial_allocator_->data();
1240 size_t new_used = field_trial_list.field_trial_allocator_->used();
1241 EXPECT_EQ(memory, new_memory);
1242 EXPECT_EQ(used, new_used);
1243 }
1244
TEST_F(FieldTrialListTest,AddTrialsToAllocator)1245 TEST_F(FieldTrialListTest, AddTrialsToAllocator) {
1246 std::string save_string;
1247 base::ReadOnlySharedMemoryRegion shm_region;
1248
1249 // Scoping the first FieldTrialList, as we need another one to test that it
1250 // matches.
1251 {
1252 FieldTrialList field_trial_list1(nullptr);
1253 FieldTrialList::CreateFieldTrial("Trial1", "Group1");
1254 FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
1255 FieldTrialList::AllStatesToString(&save_string, false);
1256 shm_region = FieldTrialList::DuplicateFieldTrialSharedMemoryForTesting();
1257 ASSERT_TRUE(shm_region.IsValid());
1258 }
1259
1260 FieldTrialList field_trial_list2(nullptr);
1261 // 4 KiB is enough to hold the trials only created for this test.
1262 base::ReadOnlySharedMemoryMapping shm_mapping = shm_region.MapAt(0, 4 << 10);
1263 ASSERT_TRUE(shm_mapping.IsValid());
1264 FieldTrialList::CreateTrialsFromSharedMemoryMapping(std::move(shm_mapping));
1265 std::string check_string;
1266 FieldTrialList::AllStatesToString(&check_string, false);
1267 EXPECT_EQ(save_string, check_string);
1268 }
1269
TEST_F(FieldTrialListTest,DoNotAddSimulatedFieldTrialsToAllocator)1270 TEST_F(FieldTrialListTest, DoNotAddSimulatedFieldTrialsToAllocator) {
1271 constexpr char kTrialName[] = "trial";
1272 base::ReadOnlySharedMemoryRegion shm_region;
1273 {
1274 FieldTrialList field_trial_list1(nullptr);
1275
1276 // Create a simulated trial and a real trial and call group() on them, which
1277 // should only add the real trial to the field trial allocator.
1278 FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
1279
1280 // This shouldn't add to the allocator.
1281 scoped_refptr<FieldTrial> simulated_trial =
1282 FieldTrial::CreateSimulatedFieldTrial(kTrialName, 100, "Simulated",
1283 0.95);
1284 simulated_trial->group();
1285
1286 // This should add to the allocator.
1287 FieldTrial* real_trial =
1288 FieldTrialList::CreateFieldTrial(kTrialName, "Real");
1289 real_trial->group();
1290
1291 shm_region = FieldTrialList::DuplicateFieldTrialSharedMemoryForTesting();
1292 ASSERT_TRUE(shm_region.IsValid());
1293 }
1294
1295 // Check that there's only one entry in the allocator.
1296 FieldTrialList field_trial_list2(nullptr);
1297 // 4 KiB is enough to hold the trials only created for this test.
1298 base::ReadOnlySharedMemoryMapping shm_mapping = shm_region.MapAt(0, 4 << 10);
1299 ASSERT_TRUE(shm_mapping.IsValid());
1300 FieldTrialList::CreateTrialsFromSharedMemoryMapping(std::move(shm_mapping));
1301 std::string check_string;
1302 FieldTrialList::AllStatesToString(&check_string, false);
1303 ASSERT_EQ(check_string.find("Simulated"), std::string::npos);
1304 }
1305
TEST_F(FieldTrialListTest,AssociateFieldTrialParams)1306 TEST_F(FieldTrialListTest, AssociateFieldTrialParams) {
1307 FieldTrialList field_trial_list(nullptr);
1308
1309 std::string trial_name("Trial1");
1310 std::string group_name("Group1");
1311
1312 // Create a field trial with some params.
1313 FieldTrialList::CreateFieldTrial(trial_name, group_name);
1314 std::map<std::string, std::string> params;
1315 params["key1"] = "value1";
1316 params["key2"] = "value2";
1317 FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
1318 trial_name, group_name, params);
1319 FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
1320
1321 // Clear all cached params from the associator.
1322 FieldTrialParamAssociator::GetInstance()->ClearAllCachedParamsForTesting();
1323 // Check that the params have been cleared from the cache.
1324 std::map<std::string, std::string> cached_params;
1325 FieldTrialParamAssociator::GetInstance()->GetFieldTrialParamsWithoutFallback(
1326 trial_name, group_name, &cached_params);
1327 EXPECT_EQ(0U, cached_params.size());
1328
1329 // Check that we fetch the param from shared memory properly.
1330 std::map<std::string, std::string> new_params;
1331 FieldTrialParamAssociator::GetInstance()->GetFieldTrialParams(trial_name,
1332 &new_params);
1333 EXPECT_EQ("value1", new_params["key1"]);
1334 EXPECT_EQ("value2", new_params["key2"]);
1335 EXPECT_EQ(2U, new_params.size());
1336 }
1337
1338 #if defined(OS_FUCHSIA)
1339 // TODO(crbug.com/752368): This is flaky on Fuchsia.
1340 #define MAYBE_ClearParamsFromSharedMemory DISABLED_ClearParamsFromSharedMemory
1341 #else
1342 #define MAYBE_ClearParamsFromSharedMemory ClearParamsFromSharedMemory
1343 #endif
TEST_F(FieldTrialListTest,MAYBE_ClearParamsFromSharedMemory)1344 TEST_F(FieldTrialListTest, MAYBE_ClearParamsFromSharedMemory) {
1345 std::string trial_name("Trial1");
1346 std::string group_name("Group1");
1347
1348 base::ReadOnlySharedMemoryRegion shm_region;
1349 {
1350 FieldTrialList field_trial_list1(nullptr);
1351
1352 // Create a field trial with some params.
1353 FieldTrial* trial =
1354 FieldTrialList::CreateFieldTrial(trial_name, group_name);
1355 std::map<std::string, std::string> params;
1356 params["key1"] = "value1";
1357 params["key2"] = "value2";
1358 FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
1359 trial_name, group_name, params);
1360 FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
1361
1362 // Clear all params from the associator AND shared memory. The allocated
1363 // segments should be different.
1364 FieldTrial::FieldTrialRef old_ref = trial->ref_;
1365 FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
1366 FieldTrial::FieldTrialRef new_ref = trial->ref_;
1367 EXPECT_NE(old_ref, new_ref);
1368
1369 // Check that there are no params associated with the field trial anymore.
1370 std::map<std::string, std::string> new_params;
1371 FieldTrialParamAssociator::GetInstance()->GetFieldTrialParams(trial_name,
1372 &new_params);
1373 EXPECT_EQ(0U, new_params.size());
1374
1375 // Now duplicate the handle so we can easily check that the trial is still
1376 // in shared memory via AllStatesToString.
1377 shm_region = FieldTrialList::DuplicateFieldTrialSharedMemoryForTesting();
1378 ASSERT_TRUE(shm_region.IsValid());
1379 }
1380
1381 // Check that we have the trial.
1382 FieldTrialList field_trial_list2(nullptr);
1383 // 4 KiB is enough to hold the trials only created for this test.
1384 base::ReadOnlySharedMemoryMapping shm_mapping = shm_region.MapAt(0, 4 << 10);
1385 ASSERT_TRUE(shm_mapping.IsValid());
1386 FieldTrialList::CreateTrialsFromSharedMemoryMapping(std::move(shm_mapping));
1387 std::string check_string;
1388 FieldTrialList::AllStatesToString(&check_string, false);
1389 EXPECT_EQ("*Trial1/Group1/", check_string);
1390 }
1391
TEST_F(FieldTrialListTest,DumpAndFetchFromSharedMemory)1392 TEST_F(FieldTrialListTest, DumpAndFetchFromSharedMemory) {
1393 std::string trial_name("Trial1");
1394 std::string group_name("Group1");
1395
1396 // Create a field trial with some params.
1397 FieldTrialList field_trial_list(nullptr);
1398 FieldTrialList::CreateFieldTrial(trial_name, group_name);
1399 std::map<std::string, std::string> params;
1400 params["key1"] = "value1";
1401 params["key2"] = "value2";
1402 FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
1403 trial_name, group_name, params);
1404
1405 // 4 KiB is enough to hold the trials only created for this test.
1406 base::MappedReadOnlyRegion shm =
1407 base::ReadOnlySharedMemoryRegion::Create(4 << 10);
1408 ASSERT_TRUE(shm.IsValid());
1409 // We _could_ use PersistentMemoryAllocator, this just has less params.
1410 WritableSharedPersistentMemoryAllocator allocator(std::move(shm.mapping), 1,
1411 "");
1412
1413 // Dump and subsequently retrieve the field trial to |allocator|.
1414 FieldTrialList::DumpAllFieldTrialsToPersistentAllocator(&allocator);
1415 std::vector<const FieldTrial::FieldTrialEntry*> entries =
1416 FieldTrialList::GetAllFieldTrialsFromPersistentAllocator(allocator);
1417
1418 // Check that we have the entry we put in.
1419 EXPECT_EQ(1u, entries.size());
1420 const FieldTrial::FieldTrialEntry* entry = entries[0];
1421
1422 // Check that the trial and group names match.
1423 StringPiece shm_trial_name;
1424 StringPiece shm_group_name;
1425 entry->GetTrialAndGroupName(&shm_trial_name, &shm_group_name);
1426 EXPECT_EQ(trial_name, shm_trial_name);
1427 EXPECT_EQ(group_name, shm_group_name);
1428
1429 // Check that the params match.
1430 std::map<std::string, std::string> shm_params;
1431 entry->GetParams(&shm_params);
1432 EXPECT_EQ(2u, shm_params.size());
1433 EXPECT_EQ("value1", shm_params["key1"]);
1434 EXPECT_EQ("value2", shm_params["key2"]);
1435 }
1436
1437 // Shared-memory distribution of FieldTrial to child process is not implemented
1438 // on Fuchsia: http://crbug.com/752368.
1439 #if !defined(OS_NACL) && !defined(OS_IOS) && !defined(OS_FUCHSIA)
MULTIPROCESS_TEST_MAIN(SerializeSharedMemoryRegionMetadata)1440 MULTIPROCESS_TEST_MAIN(SerializeSharedMemoryRegionMetadata) {
1441 std::string serialized =
1442 CommandLine::ForCurrentProcess()->GetSwitchValueASCII("field_trials");
1443 std::string guid_string =
1444 CommandLine::ForCurrentProcess()->GetSwitchValueASCII("guid");
1445
1446 #if defined(OS_WIN) || defined(OS_MACOSX)
1447 base::ReadOnlySharedMemoryRegion deserialized =
1448 FieldTrialList::DeserializeSharedMemoryRegionMetadata(serialized);
1449 #elif defined(OS_ANDROID)
1450 // Use the arbitrary fd value selected in the main process.
1451 // File descriptors are not remapped on Android. They have to be looked up in
1452 // the GlobalDescriptors table instead.
1453 int fd = base::GlobalDescriptors::GetInstance()->MaybeGet(42);
1454 CHECK_NE(fd, -1);
1455 base::ReadOnlySharedMemoryRegion deserialized =
1456 FieldTrialList::DeserializeSharedMemoryRegionMetadata(fd, serialized);
1457 #else
1458 // Use the arbitrary fd value selected in the main process.
1459 base::ReadOnlySharedMemoryRegion deserialized =
1460 FieldTrialList::DeserializeSharedMemoryRegionMetadata(42, serialized);
1461 #endif // defined(OS_WIN) || defined(OS_MACOSX)
1462 CHECK(deserialized.IsValid());
1463 CHECK_EQ(deserialized.GetGUID().ToString(), guid_string);
1464 CHECK(!deserialized.GetGUID().is_empty());
1465
1466 return 0;
1467 }
1468
TEST_F(FieldTrialListTest,SerializeSharedMemoryRegionMetadata)1469 TEST_F(FieldTrialListTest, SerializeSharedMemoryRegionMetadata) {
1470 base::MappedReadOnlyRegion shm =
1471 base::ReadOnlySharedMemoryRegion::Create(4 << 10);
1472 ASSERT_TRUE(shm.IsValid());
1473
1474 std::string serialized =
1475 FieldTrialList::SerializeSharedMemoryRegionMetadata(shm.region);
1476
1477 LaunchOptions options;
1478
1479 #if defined(OS_WIN)
1480 options.handles_to_inherit.push_back(shm.region.GetPlatformHandle());
1481 #elif defined(OS_MACOSX) && !defined(OS_IOS)
1482 options.mach_ports_for_rendezvous.insert(
1483 std::make_pair('fldt', MachRendezvousPort{shm.region.GetPlatformHandle(),
1484 MACH_MSG_TYPE_COPY_SEND}));
1485 #elif defined(OS_POSIX)
1486
1487 #if defined(OS_ANDROID)
1488 int shm_fd = shm.region.GetPlatformHandle();
1489 #else
1490 int shm_fd = shm.region.GetPlatformHandle().fd;
1491 #endif // defined(OS_ANDROID)
1492
1493 // Pick an arbitrary FD number to use for the shmem FD in the child.
1494 options.fds_to_remap.emplace_back(std::make_pair(shm_fd, 42));
1495 #endif // defined(OS_POSIX)
1496 CommandLine cmd_line = GetMultiProcessTestChildBaseCommandLine();
1497 cmd_line.AppendSwitchASCII("field_trials", serialized);
1498 cmd_line.AppendSwitchASCII("guid", shm.region.GetGUID().ToString());
1499
1500 Process process = SpawnMultiProcessTestChild(
1501 "SerializeSharedMemoryRegionMetadata", cmd_line, options);
1502
1503 int exit_code;
1504 EXPECT_TRUE(WaitForMultiprocessTestChildExit(
1505 process, TestTimeouts::action_timeout(), &exit_code));
1506 EXPECT_EQ(0, exit_code);
1507 }
1508 #endif // !defined(OS_NACL) && !defined(OS_IOS) && !defined(OS_FUCHSIA)
1509
1510 // Verify that the field trial shared memory handle is really read-only, and
1511 // does not allow writable mappings. Test disabled on NaCl, Fuchsia, and Mac,
1512 // which don't support/implement shared memory configuration. For Fuchsia, see
1513 // crbug.com/752368
1514 #if !defined(OS_NACL) && !defined(OS_FUCHSIA) && \
1515 !(defined(OS_MACOSX) && !defined(OS_IOS))
TEST_F(FieldTrialListTest,CheckReadOnlySharedMemoryRegion)1516 TEST_F(FieldTrialListTest, CheckReadOnlySharedMemoryRegion) {
1517 FieldTrialList field_trial_list(nullptr);
1518 FieldTrialList::CreateFieldTrial("Trial1", "Group1");
1519
1520 FieldTrialList::InstantiateFieldTrialAllocatorIfNeeded();
1521
1522 base::ReadOnlySharedMemoryRegion region =
1523 FieldTrialList::DuplicateFieldTrialSharedMemoryForTesting();
1524 ASSERT_TRUE(region.IsValid());
1525
1526 ASSERT_TRUE(CheckReadOnlyPlatformSharedMemoryRegionForTesting(
1527 base::ReadOnlySharedMemoryRegion::TakeHandleForSerialization(
1528 std::move(region))));
1529 }
1530 #endif // !OS_NACL && !OS_FUCHSIA && !(OS_MACOSX && !OS_IOS)
1531
TEST_F(FieldTrialTest,TestAllParamsToString)1532 TEST_F(FieldTrialTest, TestAllParamsToString) {
1533 std::string exptected_output = "t1.g1:p1/v1/p2/v2";
1534
1535 // Create study with one group and two params.
1536 std::map<std::string, std::string> params;
1537 params["p1"] = "v1";
1538 params["p2"] = "v2";
1539 FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
1540 "t1", "g1", params);
1541 EXPECT_EQ(
1542 "", FieldTrialList::AllParamsToString(false, &MockEscapeQueryParamValue));
1543
1544 scoped_refptr<FieldTrial> trial1 =
1545 CreateFieldTrial("t1", 100, "Default", nullptr);
1546 trial1->AppendGroup("g1", 100);
1547 trial1->group();
1548 EXPECT_EQ(exptected_output, FieldTrialList::AllParamsToString(
1549 false, &MockEscapeQueryParamValue));
1550
1551 // Create study with two groups and params that don't belog to the assigned
1552 // group. This should be in the output.
1553 FieldTrialParamAssociator::GetInstance()->AssociateFieldTrialParams(
1554 "t2", "g2", params);
1555 scoped_refptr<FieldTrial> trial2 =
1556 CreateFieldTrial("t2", 100, "Default", nullptr);
1557 trial2->AppendGroup("g1", 100);
1558 trial2->AppendGroup("g2", 0);
1559 trial2->group();
1560 EXPECT_EQ(exptected_output, FieldTrialList::AllParamsToString(
1561 false, &MockEscapeQueryParamValue));
1562 }
1563
1564 } // namespace base
1565