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 "base/message_loop/message_loop.h"
8#include "base/rand_util.h"
9#include "base/run_loop.h"
10#include "base/strings/string_number_conversions.h"
11#include "base/strings/stringprintf.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14namespace base {
15
16namespace {
17
18// Default group name used by several tests.
19const char kDefaultGroupName[] = "DefaultGroup";
20
21// Call FieldTrialList::FactoryGetFieldTrial() with a future expiry date.
22scoped_refptr<base::FieldTrial> CreateFieldTrial(
23    const std::string& trial_name,
24    int total_probability,
25    const std::string& default_group_name,
26    int* default_group_number) {
27  return FieldTrialList::FactoryGetFieldTrial(
28      trial_name, total_probability, default_group_name,
29      base::FieldTrialList::kNoExpirationYear, 1, 1,
30      base::FieldTrial::SESSION_RANDOMIZED, default_group_number);
31}
32
33int GetLastYear() {
34  Time last_year_time = Time::NowFromSystemTime() - TimeDelta::FromDays(365);
35  Time::Exploded exploded;
36  last_year_time.LocalExplode(&exploded);
37  return exploded.year;
38}
39
40// FieldTrialList::Observer implementation for testing.
41class TestFieldTrialObserver : public FieldTrialList::Observer {
42 public:
43  TestFieldTrialObserver() {
44    FieldTrialList::AddObserver(this);
45  }
46
47  virtual ~TestFieldTrialObserver() {
48    FieldTrialList::RemoveObserver(this);
49  }
50
51  virtual void OnFieldTrialGroupFinalized(const std::string& trial,
52                                          const std::string& group) OVERRIDE {
53    trial_name_ = trial;
54    group_name_ = group;
55  }
56
57  const std::string& trial_name() const { return trial_name_; }
58  const std::string& group_name() const { return group_name_; }
59
60 private:
61  std::string trial_name_;
62  std::string group_name_;
63
64  DISALLOW_COPY_AND_ASSIGN(TestFieldTrialObserver);
65};
66
67}  // namespace
68
69class FieldTrialTest : public testing::Test {
70 public:
71  FieldTrialTest() : trial_list_(NULL) {}
72
73 private:
74  MessageLoop message_loop_;
75  FieldTrialList trial_list_;
76};
77
78// Test registration, and also check that destructors are called for trials
79// (and that Valgrind doesn't catch us leaking).
80TEST_F(FieldTrialTest, Registration) {
81  const char* name1 = "name 1 test";
82  const char* name2 = "name 2 test";
83  EXPECT_FALSE(FieldTrialList::Find(name1));
84  EXPECT_FALSE(FieldTrialList::Find(name2));
85
86  scoped_refptr<FieldTrial> trial1 =
87      CreateFieldTrial(name1, 10, "default name 1 test", NULL);
88  EXPECT_EQ(FieldTrial::kNotFinalized, trial1->group_);
89  EXPECT_EQ(name1, trial1->trial_name());
90  EXPECT_EQ("", trial1->group_name_internal());
91
92  trial1->AppendGroup(std::string(), 7);
93
94  EXPECT_EQ(trial1.get(), FieldTrialList::Find(name1));
95  EXPECT_FALSE(FieldTrialList::Find(name2));
96
97  scoped_refptr<FieldTrial> trial2 =
98      CreateFieldTrial(name2, 10, "default name 2 test", NULL);
99  EXPECT_EQ(FieldTrial::kNotFinalized, trial2->group_);
100  EXPECT_EQ(name2, trial2->trial_name());
101  EXPECT_EQ("", trial2->group_name_internal());
102
103  trial2->AppendGroup("a first group", 7);
104
105  EXPECT_EQ(trial1.get(), FieldTrialList::Find(name1));
106  EXPECT_EQ(trial2.get(), FieldTrialList::Find(name2));
107  // Note: FieldTrialList should delete the objects at shutdown.
108}
109
110TEST_F(FieldTrialTest, AbsoluteProbabilities) {
111  char always_true[] = " always true";
112  char default_always_true[] = " default always true";
113  char always_false[] = " always false";
114  char default_always_false[] = " default always false";
115  for (int i = 1; i < 250; ++i) {
116    // Try lots of names, by changing the first character of the name.
117    always_true[0] = i;
118    default_always_true[0] = i;
119    always_false[0] = i;
120    default_always_false[0] = i;
121
122    scoped_refptr<FieldTrial> trial_true =
123        CreateFieldTrial(always_true, 10, default_always_true, NULL);
124    const std::string winner = "TheWinner";
125    int winner_group = trial_true->AppendGroup(winner, 10);
126
127    EXPECT_EQ(winner_group, trial_true->group());
128    EXPECT_EQ(winner, trial_true->group_name());
129
130    scoped_refptr<FieldTrial> trial_false =
131        CreateFieldTrial(always_false, 10, default_always_false, NULL);
132    int loser_group = trial_false->AppendGroup("ALoser", 0);
133
134    EXPECT_NE(loser_group, trial_false->group());
135  }
136}
137
138TEST_F(FieldTrialTest, RemainingProbability) {
139  // First create a test that hasn't had a winner yet.
140  const std::string winner = "Winner";
141  const std::string loser = "Loser";
142  scoped_refptr<FieldTrial> trial;
143  int counter = 0;
144  int default_group_number = -1;
145  do {
146    std::string name = StringPrintf("trial%d", ++counter);
147    trial = CreateFieldTrial(name, 10, winner, &default_group_number);
148    trial->AppendGroup(loser, 5);  // 50% chance of not being chosen.
149    // If a group is not assigned, group_ will be kNotFinalized.
150  } while (trial->group_ != FieldTrial::kNotFinalized);
151
152  // And that 'default' group (winner) should always win.
153  EXPECT_EQ(default_group_number, trial->group());
154
155  // And that winner should ALWAYS win.
156  EXPECT_EQ(winner, trial->group_name());
157}
158
159TEST_F(FieldTrialTest, FiftyFiftyProbability) {
160  // Check that even with small divisors, we have the proper probabilities, and
161  // all outcomes are possible.  Since this is a 50-50 test, it should get both
162  // outcomes in a few tries, but we'll try no more than 100 times (and be flaky
163  // with probability around 1 in 2^99).
164  bool first_winner = false;
165  bool second_winner = false;
166  int counter = 0;
167  do {
168    std::string name = base::StringPrintf("FiftyFifty%d", ++counter);
169    std::string default_group_name = base::StringPrintf("Default FiftyFifty%d",
170                                                        ++counter);
171    scoped_refptr<FieldTrial> trial =
172        CreateFieldTrial(name, 2, default_group_name, NULL);
173    trial->AppendGroup("first", 1);  // 50% chance of being chosen.
174    // If group_ is kNotFinalized, then a group assignement hasn't been done.
175    if (trial->group_ != FieldTrial::kNotFinalized) {
176      first_winner = true;
177      continue;
178    }
179    trial->AppendGroup("second", 1);  // Always chosen at this point.
180    EXPECT_NE(FieldTrial::kNotFinalized, trial->group());
181    second_winner = true;
182  } while ((!second_winner || !first_winner) && counter < 100);
183  EXPECT_TRUE(second_winner);
184  EXPECT_TRUE(first_winner);
185}
186
187TEST_F(FieldTrialTest, MiddleProbabilities) {
188  char name[] = " same name";
189  char default_group_name[] = " default same name";
190  bool false_event_seen = false;
191  bool true_event_seen = false;
192  for (int i = 1; i < 250; ++i) {
193    name[0] = i;
194    default_group_name[0] = i;
195    scoped_refptr<FieldTrial> trial =
196        CreateFieldTrial(name, 10, default_group_name, NULL);
197    int might_win = trial->AppendGroup("MightWin", 5);
198
199    if (trial->group() == might_win) {
200      true_event_seen = true;
201    } else {
202      false_event_seen = true;
203    }
204    if (false_event_seen && true_event_seen)
205      return;  // Successful test!!!
206  }
207  // Very surprising to get here. Probability should be around 1 in 2 ** 250.
208  // One of the following will fail.
209  EXPECT_TRUE(false_event_seen);
210  EXPECT_TRUE(true_event_seen);
211}
212
213TEST_F(FieldTrialTest, OneWinner) {
214  char name[] = "Some name";
215  char default_group_name[] = "Default some name";
216  int group_count(10);
217
218  int default_group_number = -1;
219  scoped_refptr<FieldTrial> trial =
220      CreateFieldTrial(name, group_count, default_group_name, NULL);
221  int winner_index(-2);
222  std::string winner_name;
223
224  for (int i = 1; i <= group_count; ++i) {
225    int might_win = trial->AppendGroup(std::string(), 1);
226
227    // Because we keep appending groups, we want to see if the last group that
228    // was added has been assigned or not.
229    if (trial->group_ == might_win) {
230      EXPECT_EQ(-2, winner_index);
231      winner_index = might_win;
232      StringAppendF(&winner_name, "%d", might_win);
233      EXPECT_EQ(winner_name, trial->group_name());
234    }
235  }
236  EXPECT_GE(winner_index, 0);
237  // Since all groups cover the total probability, we should not have
238  // chosen the default group.
239  EXPECT_NE(trial->group(), default_group_number);
240  EXPECT_EQ(trial->group(), winner_index);
241  EXPECT_EQ(trial->group_name(), winner_name);
242}
243
244TEST_F(FieldTrialTest, DisableProbability) {
245  const std::string default_group_name = "Default group";
246  const std::string loser = "Loser";
247  const std::string name = "Trial";
248
249  // Create a field trail that has expired.
250  int default_group_number = -1;
251  FieldTrial* trial = FieldTrialList::FactoryGetFieldTrial(
252      name, 1000000000, default_group_name, GetLastYear(), 1, 1,
253      FieldTrial::SESSION_RANDOMIZED,
254      &default_group_number);
255  trial->AppendGroup(loser, 999999999);  // 99.9999999% chance of being chosen.
256
257  // Because trial has expired, we should always be in the default group.
258  EXPECT_EQ(default_group_number, trial->group());
259
260  // And that default_group_name should ALWAYS win.
261  EXPECT_EQ(default_group_name, trial->group_name());
262}
263
264TEST_F(FieldTrialTest, ActiveGroups) {
265  std::string no_group("No Group");
266  scoped_refptr<FieldTrial> trial =
267      CreateFieldTrial(no_group, 10, "Default", NULL);
268
269  // There is no winner yet, so no NameGroupId should be returned.
270  FieldTrial::ActiveGroup active_group;
271  EXPECT_FALSE(trial->GetActiveGroup(&active_group));
272
273  // Create a single winning group.
274  std::string one_winner("One Winner");
275  trial = CreateFieldTrial(one_winner, 10, "Default", NULL);
276  std::string winner("Winner");
277  trial->AppendGroup(winner, 10);
278  EXPECT_FALSE(trial->GetActiveGroup(&active_group));
279  // Finalize the group selection by accessing the selected group.
280  trial->group();
281  EXPECT_TRUE(trial->GetActiveGroup(&active_group));
282  EXPECT_EQ(one_winner, active_group.trial_name);
283  EXPECT_EQ(winner, active_group.group_name);
284
285  std::string multi_group("MultiGroup");
286  scoped_refptr<FieldTrial> multi_group_trial =
287      CreateFieldTrial(multi_group, 9, "Default", NULL);
288
289  multi_group_trial->AppendGroup("Me", 3);
290  multi_group_trial->AppendGroup("You", 3);
291  multi_group_trial->AppendGroup("Them", 3);
292  EXPECT_FALSE(multi_group_trial->GetActiveGroup(&active_group));
293  // Finalize the group selection by accessing the selected group.
294  multi_group_trial->group();
295  EXPECT_TRUE(multi_group_trial->GetActiveGroup(&active_group));
296  EXPECT_EQ(multi_group, active_group.trial_name);
297  EXPECT_EQ(multi_group_trial->group_name(), active_group.group_name);
298
299  // Now check if the list is built properly...
300  FieldTrial::ActiveGroups active_groups;
301  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
302  EXPECT_EQ(2U, active_groups.size());
303  for (size_t i = 0; i < active_groups.size(); ++i) {
304    // Order is not guaranteed, so check all values.
305    EXPECT_NE(no_group, active_groups[i].trial_name);
306    EXPECT_TRUE(one_winner != active_groups[i].trial_name ||
307                winner == active_groups[i].group_name);
308    EXPECT_TRUE(multi_group != active_groups[i].trial_name ||
309                multi_group_trial->group_name() == active_groups[i].group_name);
310  }
311}
312
313TEST_F(FieldTrialTest, ActiveGroupsNotFinalized) {
314  const char kTrialName[] = "TestTrial";
315  const char kSecondaryGroupName[] = "SecondaryGroup";
316
317  int default_group = -1;
318  scoped_refptr<FieldTrial> trial =
319      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
320  const int secondary_group = trial->AppendGroup(kSecondaryGroupName, 50);
321
322  // Before |group()| is called, |GetActiveGroup()| should return false.
323  FieldTrial::ActiveGroup active_group;
324  EXPECT_FALSE(trial->GetActiveGroup(&active_group));
325
326  // |GetActiveFieldTrialGroups()| should also not include the trial.
327  FieldTrial::ActiveGroups active_groups;
328  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
329  EXPECT_TRUE(active_groups.empty());
330
331  // After |group()| has been called, both APIs should succeed.
332  const int chosen_group = trial->group();
333  EXPECT_TRUE(chosen_group == default_group || chosen_group == secondary_group);
334
335  EXPECT_TRUE(trial->GetActiveGroup(&active_group));
336  EXPECT_EQ(kTrialName, active_group.trial_name);
337  if (chosen_group == default_group)
338    EXPECT_EQ(kDefaultGroupName, active_group.group_name);
339  else
340    EXPECT_EQ(kSecondaryGroupName, active_group.group_name);
341
342  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
343  ASSERT_EQ(1U, active_groups.size());
344  EXPECT_EQ(kTrialName, active_groups[0].trial_name);
345  EXPECT_EQ(active_group.group_name, active_groups[0].group_name);
346}
347
348TEST_F(FieldTrialTest, Save) {
349  std::string save_string;
350
351  scoped_refptr<FieldTrial> trial =
352      CreateFieldTrial("Some name", 10, "Default some name", NULL);
353  // There is no winner yet, so no textual group name is associated with trial.
354  // In this case, the trial should not be included.
355  EXPECT_EQ("", trial->group_name_internal());
356  FieldTrialList::StatesToString(&save_string);
357  EXPECT_EQ("", save_string);
358  save_string.clear();
359
360  // Create a winning group.
361  trial->AppendGroup("Winner", 10);
362  // Finalize the group selection by accessing the selected group.
363  trial->group();
364  FieldTrialList::StatesToString(&save_string);
365  EXPECT_EQ("Some name/Winner/", save_string);
366  save_string.clear();
367
368  // Create a second trial and winning group.
369  scoped_refptr<FieldTrial> trial2 =
370      CreateFieldTrial("xxx", 10, "Default xxx", NULL);
371  trial2->AppendGroup("yyyy", 10);
372  // Finalize the group selection by accessing the selected group.
373  trial2->group();
374
375  FieldTrialList::StatesToString(&save_string);
376  // We assume names are alphabetized... though this is not critical.
377  EXPECT_EQ("Some name/Winner/xxx/yyyy/", save_string);
378  save_string.clear();
379
380  // Create a third trial with only the default group.
381  scoped_refptr<FieldTrial> trial3 =
382      CreateFieldTrial("zzz", 10, "default", NULL);
383  // Finalize the group selection by accessing the selected group.
384  trial3->group();
385
386  FieldTrialList::StatesToString(&save_string);
387  EXPECT_EQ("Some name/Winner/xxx/yyyy/zzz/default/", save_string);
388}
389
390TEST_F(FieldTrialTest, Restore) {
391  ASSERT_FALSE(FieldTrialList::TrialExists("Some_name"));
392  ASSERT_FALSE(FieldTrialList::TrialExists("xxx"));
393
394  FieldTrialList::CreateTrialsFromString("Some_name/Winner/xxx/yyyy/",
395                                         FieldTrialList::DONT_ACTIVATE_TRIALS,
396                                         std::set<std::string>());
397
398  FieldTrial* trial = FieldTrialList::Find("Some_name");
399  ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
400  EXPECT_EQ("Winner", trial->group_name());
401  EXPECT_EQ("Some_name", trial->trial_name());
402
403  trial = FieldTrialList::Find("xxx");
404  ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
405  EXPECT_EQ("yyyy", trial->group_name());
406  EXPECT_EQ("xxx", trial->trial_name());
407}
408
409TEST_F(FieldTrialTest, RestoreNotEndingWithSlash) {
410  EXPECT_TRUE(FieldTrialList::CreateTrialsFromString(
411      "tname/gname", FieldTrialList::DONT_ACTIVATE_TRIALS,
412      std::set<std::string>()));
413
414  FieldTrial* trial = FieldTrialList::Find("tname");
415  ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
416  EXPECT_EQ("gname", trial->group_name());
417  EXPECT_EQ("tname", trial->trial_name());
418}
419
420TEST_F(FieldTrialTest, BogusRestore) {
421  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
422      "MissingSlash", FieldTrialList::DONT_ACTIVATE_TRIALS,
423      std::set<std::string>()));
424  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
425      "MissingGroupName/", FieldTrialList::DONT_ACTIVATE_TRIALS,
426      std::set<std::string>()));
427  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
428      "noname, only group/", FieldTrialList::DONT_ACTIVATE_TRIALS,
429      std::set<std::string>()));
430}
431
432TEST_F(FieldTrialTest, DuplicateRestore) {
433  scoped_refptr<FieldTrial> trial =
434      CreateFieldTrial("Some name", 10, "Default", NULL);
435  trial->AppendGroup("Winner", 10);
436  // Finalize the group selection by accessing the selected group.
437  trial->group();
438  std::string save_string;
439  FieldTrialList::StatesToString(&save_string);
440  EXPECT_EQ("Some name/Winner/", save_string);
441
442  // It is OK if we redundantly specify a winner.
443  EXPECT_TRUE(FieldTrialList::CreateTrialsFromString(
444      save_string, FieldTrialList::DONT_ACTIVATE_TRIALS,
445      std::set<std::string>()));
446
447  // But it is an error to try to change to a different winner.
448  EXPECT_FALSE(FieldTrialList::CreateTrialsFromString(
449      "Some name/Loser/", FieldTrialList::DONT_ACTIVATE_TRIALS,
450      std::set<std::string>()));
451}
452
453TEST_F(FieldTrialTest, CreateTrialsFromStringActive) {
454  ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
455  ASSERT_FALSE(FieldTrialList::TrialExists("Xyz"));
456  ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
457      "Abc/def/Xyz/zyx/", FieldTrialList::ACTIVATE_TRIALS,
458      std::set<std::string>()));
459
460  FieldTrial::ActiveGroups active_groups;
461  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
462  ASSERT_EQ(2U, active_groups.size());
463  EXPECT_EQ("Abc", active_groups[0].trial_name);
464  EXPECT_EQ("def", active_groups[0].group_name);
465  EXPECT_EQ("Xyz", active_groups[1].trial_name);
466  EXPECT_EQ("zyx", active_groups[1].group_name);
467}
468
469TEST_F(FieldTrialTest, CreateTrialsFromStringNotActive) {
470  ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
471  ASSERT_FALSE(FieldTrialList::TrialExists("Xyz"));
472  ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
473      "Abc/def/Xyz/zyx/", FieldTrialList::DONT_ACTIVATE_TRIALS,
474      std::set<std::string>()));
475
476  FieldTrial::ActiveGroups active_groups;
477  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
478  ASSERT_TRUE(active_groups.empty());
479
480  // Check that the values still get returned and querying them activates them.
481  EXPECT_EQ("def", FieldTrialList::FindFullName("Abc"));
482  EXPECT_EQ("zyx", FieldTrialList::FindFullName("Xyz"));
483
484  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
485  ASSERT_EQ(2U, active_groups.size());
486  EXPECT_EQ("Abc", active_groups[0].trial_name);
487  EXPECT_EQ("def", active_groups[0].group_name);
488  EXPECT_EQ("Xyz", active_groups[1].trial_name);
489  EXPECT_EQ("zyx", active_groups[1].group_name);
490}
491
492TEST_F(FieldTrialTest, CreateTrialsFromStringActiveObserver) {
493  ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
494
495  TestFieldTrialObserver observer;
496  ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
497      "Abc/def/", FieldTrialList::ACTIVATE_TRIALS, std::set<std::string>()));
498
499  RunLoop().RunUntilIdle();
500  EXPECT_EQ("Abc", observer.trial_name());
501  EXPECT_EQ("def", observer.group_name());
502}
503
504TEST_F(FieldTrialTest, CreateTrialsFromStringNotActiveObserver) {
505  ASSERT_FALSE(FieldTrialList::TrialExists("Abc"));
506
507  TestFieldTrialObserver observer;
508  ASSERT_TRUE(FieldTrialList::CreateTrialsFromString(
509      "Abc/def/", FieldTrialList::DONT_ACTIVATE_TRIALS,
510      std::set<std::string>()));
511  RunLoop().RunUntilIdle();
512  // Observer shouldn't be notified.
513  EXPECT_TRUE(observer.trial_name().empty());
514
515  // Check that the values still get returned and querying them activates them.
516  EXPECT_EQ("def", FieldTrialList::FindFullName("Abc"));
517
518  RunLoop().RunUntilIdle();
519  EXPECT_EQ("Abc", observer.trial_name());
520  EXPECT_EQ("def", observer.group_name());
521}
522
523TEST_F(FieldTrialTest, CreateTrialsFromStringWithIgnoredFieldTrials) {
524  ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted1"));
525  ASSERT_FALSE(FieldTrialList::TrialExists("Foo"));
526  ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted2"));
527  ASSERT_FALSE(FieldTrialList::TrialExists("Bar"));
528  ASSERT_FALSE(FieldTrialList::TrialExists("Unaccepted3"));
529
530  std::set<std::string> ignored_trial_names;
531  ignored_trial_names.insert("Unaccepted1");
532  ignored_trial_names.insert("Unaccepted2");
533  ignored_trial_names.insert("Unaccepted3");
534
535  FieldTrialList::CreateTrialsFromString(
536      "Unaccepted1/Unaccepted1_name/"
537      "Foo/Foo_name/"
538      "Unaccepted2/Unaccepted2_name/"
539      "Bar/Bar_name/"
540      "Unaccepted3/Unaccepted3_name/",
541      FieldTrialList::DONT_ACTIVATE_TRIALS,
542      ignored_trial_names);
543
544  EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted1"));
545  EXPECT_TRUE(FieldTrialList::TrialExists("Foo"));
546  EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted2"));
547  EXPECT_TRUE(FieldTrialList::TrialExists("Bar"));
548  EXPECT_FALSE(FieldTrialList::TrialExists("Unaccepted3"));
549
550  FieldTrial::ActiveGroups active_groups;
551  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
552  EXPECT_TRUE(active_groups.empty());
553
554  FieldTrial* trial = FieldTrialList::Find("Foo");
555  ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
556  EXPECT_EQ("Foo", trial->trial_name());
557  EXPECT_EQ("Foo_name", trial->group_name());
558
559  trial = FieldTrialList::Find("Bar");
560  ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
561  EXPECT_EQ("Bar", trial->trial_name());
562  EXPECT_EQ("Bar_name", trial->group_name());
563}
564
565TEST_F(FieldTrialTest, CreateFieldTrial) {
566  ASSERT_FALSE(FieldTrialList::TrialExists("Some_name"));
567
568  FieldTrialList::CreateFieldTrial("Some_name", "Winner");
569
570  FieldTrial* trial = FieldTrialList::Find("Some_name");
571  ASSERT_NE(static_cast<FieldTrial*>(NULL), trial);
572  EXPECT_EQ("Winner", trial->group_name());
573  EXPECT_EQ("Some_name", trial->trial_name());
574}
575
576TEST_F(FieldTrialTest, CreateFieldTrialIsNotActive) {
577  const char kTrialName[] = "CreateFieldTrialIsActiveTrial";
578  const char kWinnerGroup[] = "Winner";
579  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
580  FieldTrialList::CreateFieldTrial(kTrialName, kWinnerGroup);
581
582  FieldTrial::ActiveGroups active_groups;
583  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
584  EXPECT_TRUE(active_groups.empty());
585}
586
587TEST_F(FieldTrialTest, DuplicateFieldTrial) {
588  scoped_refptr<FieldTrial> trial =
589      CreateFieldTrial("Some_name", 10, "Default", NULL);
590  trial->AppendGroup("Winner", 10);
591
592  // It is OK if we redundantly specify a winner.
593  FieldTrial* trial1 = FieldTrialList::CreateFieldTrial("Some_name", "Winner");
594  EXPECT_TRUE(trial1 != NULL);
595
596  // But it is an error to try to change to a different winner.
597  FieldTrial* trial2 = FieldTrialList::CreateFieldTrial("Some_name", "Loser");
598  EXPECT_TRUE(trial2 == NULL);
599}
600
601TEST_F(FieldTrialTest, DisableImmediately) {
602  int default_group_number = -1;
603  scoped_refptr<FieldTrial> trial =
604      CreateFieldTrial("trial", 100, "default", &default_group_number);
605  trial->Disable();
606  ASSERT_EQ("default", trial->group_name());
607  ASSERT_EQ(default_group_number, trial->group());
608}
609
610TEST_F(FieldTrialTest, DisableAfterInitialization) {
611  scoped_refptr<FieldTrial> trial =
612      CreateFieldTrial("trial", 100, "default", NULL);
613  trial->AppendGroup("non_default", 100);
614  trial->Disable();
615  ASSERT_EQ("default", trial->group_name());
616}
617
618TEST_F(FieldTrialTest, ForcedFieldTrials) {
619  // Validate we keep the forced choice.
620  FieldTrial* forced_trial = FieldTrialList::CreateFieldTrial("Use the",
621                                                              "Force");
622  EXPECT_STREQ("Force", forced_trial->group_name().c_str());
623
624  int default_group_number = -1;
625  scoped_refptr<FieldTrial> factory_trial =
626      CreateFieldTrial("Use the", 1000, "default", &default_group_number);
627  EXPECT_EQ(factory_trial.get(), forced_trial);
628
629  int chosen_group = factory_trial->AppendGroup("Force", 100);
630  EXPECT_EQ(chosen_group, factory_trial->group());
631  int not_chosen_group = factory_trial->AppendGroup("Dark Side", 100);
632  EXPECT_NE(chosen_group, not_chosen_group);
633
634  // Since we didn't force the default group, we should not be returned the
635  // chosen group as the default group.
636  EXPECT_NE(default_group_number, chosen_group);
637  int new_group = factory_trial->AppendGroup("Duck Tape", 800);
638  EXPECT_NE(chosen_group, new_group);
639  // The new group should not be the default group either.
640  EXPECT_NE(default_group_number, new_group);
641}
642
643TEST_F(FieldTrialTest, ForcedFieldTrialsDefaultGroup) {
644  // Forcing the default should use the proper group ID.
645  FieldTrial* forced_trial = FieldTrialList::CreateFieldTrial("Trial Name",
646                                                              "Default");
647  int default_group_number = -1;
648  scoped_refptr<FieldTrial> factory_trial =
649      CreateFieldTrial("Trial Name", 1000, "Default", &default_group_number);
650  EXPECT_EQ(forced_trial, factory_trial.get());
651
652  int other_group = factory_trial->AppendGroup("Not Default", 100);
653  EXPECT_STREQ("Default", factory_trial->group_name().c_str());
654  EXPECT_EQ(default_group_number, factory_trial->group());
655  EXPECT_NE(other_group, factory_trial->group());
656
657  int new_other_group = factory_trial->AppendGroup("Not Default Either", 800);
658  EXPECT_NE(new_other_group, factory_trial->group());
659}
660
661TEST_F(FieldTrialTest, SetForced) {
662  // Start by setting a trial for which we ensure a winner...
663  int default_group_number = -1;
664  scoped_refptr<FieldTrial> forced_trial =
665      CreateFieldTrial("Use the", 1, "default", &default_group_number);
666  EXPECT_EQ(forced_trial, forced_trial);
667
668  int forced_group = forced_trial->AppendGroup("Force", 1);
669  EXPECT_EQ(forced_group, forced_trial->group());
670
671  // Now force it.
672  forced_trial->SetForced();
673
674  // Now try to set it up differently as a hard coded registration would.
675  scoped_refptr<FieldTrial> hard_coded_trial =
676      CreateFieldTrial("Use the", 1, "default", &default_group_number);
677  EXPECT_EQ(hard_coded_trial, forced_trial);
678
679  int would_lose_group = hard_coded_trial->AppendGroup("Force", 0);
680  EXPECT_EQ(forced_group, hard_coded_trial->group());
681  EXPECT_EQ(forced_group, would_lose_group);
682
683  // Same thing if we would have done it to win again.
684  scoped_refptr<FieldTrial> other_hard_coded_trial =
685      CreateFieldTrial("Use the", 1, "default", &default_group_number);
686  EXPECT_EQ(other_hard_coded_trial, forced_trial);
687
688  int would_win_group = other_hard_coded_trial->AppendGroup("Force", 1);
689  EXPECT_EQ(forced_group, other_hard_coded_trial->group());
690  EXPECT_EQ(forced_group, would_win_group);
691}
692
693TEST_F(FieldTrialTest, SetForcedDefaultOnly) {
694  const char kTrialName[] = "SetForcedDefaultOnly";
695  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
696
697  int default_group = -1;
698  scoped_refptr<FieldTrial> trial =
699      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
700  trial->SetForced();
701
702  trial = CreateFieldTrial(kTrialName, 100, kDefaultGroupName, NULL);
703  EXPECT_EQ(default_group, trial->group());
704  EXPECT_EQ(kDefaultGroupName, trial->group_name());
705}
706
707TEST_F(FieldTrialTest, SetForcedDefaultWithExtraGroup) {
708  const char kTrialName[] = "SetForcedDefaultWithExtraGroup";
709  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
710
711  int default_group = -1;
712  scoped_refptr<FieldTrial> trial =
713      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
714  trial->SetForced();
715
716  trial = CreateFieldTrial(kTrialName, 100, kDefaultGroupName, NULL);
717  const int extra_group = trial->AppendGroup("Extra", 100);
718  EXPECT_EQ(default_group, trial->group());
719  EXPECT_NE(extra_group, trial->group());
720  EXPECT_EQ(kDefaultGroupName, trial->group_name());
721}
722
723TEST_F(FieldTrialTest, SetForcedTurnFeatureOn) {
724  const char kTrialName[] = "SetForcedTurnFeatureOn";
725  const char kExtraGroupName[] = "Extra";
726  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
727
728  // Simulate a server-side (forced) config that turns the feature on when the
729  // original hard-coded config had it disabled.
730  scoped_refptr<FieldTrial> forced_trial =
731      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, NULL);
732  forced_trial->AppendGroup(kExtraGroupName, 100);
733  forced_trial->SetForced();
734
735  int default_group = -1;
736  scoped_refptr<FieldTrial> client_trial =
737      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
738  const int extra_group = client_trial->AppendGroup(kExtraGroupName, 0);
739  EXPECT_NE(default_group, extra_group);
740
741  EXPECT_FALSE(client_trial->group_reported_);
742  EXPECT_EQ(extra_group, client_trial->group());
743  EXPECT_TRUE(client_trial->group_reported_);
744  EXPECT_EQ(kExtraGroupName, client_trial->group_name());
745}
746
747TEST_F(FieldTrialTest, SetForcedTurnFeatureOff) {
748  const char kTrialName[] = "SetForcedTurnFeatureOff";
749  const char kExtraGroupName[] = "Extra";
750  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
751
752  // Simulate a server-side (forced) config that turns the feature off when the
753  // original hard-coded config had it enabled.
754  scoped_refptr<FieldTrial> forced_trial =
755      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, NULL);
756  forced_trial->AppendGroup(kExtraGroupName, 0);
757  forced_trial->SetForced();
758
759  int default_group = -1;
760  scoped_refptr<FieldTrial> client_trial =
761      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
762  const int extra_group = client_trial->AppendGroup(kExtraGroupName, 100);
763  EXPECT_NE(default_group, extra_group);
764
765  EXPECT_FALSE(client_trial->group_reported_);
766  EXPECT_EQ(default_group, client_trial->group());
767  EXPECT_TRUE(client_trial->group_reported_);
768  EXPECT_EQ(kDefaultGroupName, client_trial->group_name());
769}
770
771TEST_F(FieldTrialTest, SetForcedChangeDefault_Default) {
772  const char kTrialName[] = "SetForcedDefaultGroupChange";
773  const char kGroupAName[] = "A";
774  const char kGroupBName[] = "B";
775  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
776
777  // Simulate a server-side (forced) config that switches which group is default
778  // and ensures that the non-forced code receives the correct group numbers.
779  scoped_refptr<FieldTrial> forced_trial =
780      CreateFieldTrial(kTrialName, 100, kGroupAName, NULL);
781  forced_trial->AppendGroup(kGroupBName, 100);
782  forced_trial->SetForced();
783
784  int default_group = -1;
785  scoped_refptr<FieldTrial> client_trial =
786      CreateFieldTrial(kTrialName, 100, kGroupBName, &default_group);
787  const int extra_group = client_trial->AppendGroup(kGroupAName, 50);
788  EXPECT_NE(default_group, extra_group);
789
790  EXPECT_FALSE(client_trial->group_reported_);
791  EXPECT_EQ(default_group, client_trial->group());
792  EXPECT_TRUE(client_trial->group_reported_);
793  EXPECT_EQ(kGroupBName, client_trial->group_name());
794}
795
796TEST_F(FieldTrialTest, SetForcedChangeDefault_NonDefault) {
797  const char kTrialName[] = "SetForcedDefaultGroupChange";
798  const char kGroupAName[] = "A";
799  const char kGroupBName[] = "B";
800  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
801
802  // Simulate a server-side (forced) config that switches which group is default
803  // and ensures that the non-forced code receives the correct group numbers.
804  scoped_refptr<FieldTrial> forced_trial =
805      CreateFieldTrial(kTrialName, 100, kGroupAName, NULL);
806  forced_trial->AppendGroup(kGroupBName, 0);
807  forced_trial->SetForced();
808
809  int default_group = -1;
810  scoped_refptr<FieldTrial> client_trial =
811      CreateFieldTrial(kTrialName, 100, kGroupBName, &default_group);
812  const int extra_group = client_trial->AppendGroup(kGroupAName, 50);
813  EXPECT_NE(default_group, extra_group);
814
815  EXPECT_FALSE(client_trial->group_reported_);
816  EXPECT_EQ(extra_group, client_trial->group());
817  EXPECT_TRUE(client_trial->group_reported_);
818  EXPECT_EQ(kGroupAName, client_trial->group_name());
819}
820
821TEST_F(FieldTrialTest, Observe) {
822  const char kTrialName[] = "TrialToObserve1";
823  const char kSecondaryGroupName[] = "SecondaryGroup";
824
825  TestFieldTrialObserver observer;
826  int default_group = -1;
827  scoped_refptr<FieldTrial> trial =
828      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
829  const int secondary_group = trial->AppendGroup(kSecondaryGroupName, 50);
830  const int chosen_group = trial->group();
831  EXPECT_TRUE(chosen_group == default_group || chosen_group == secondary_group);
832
833  RunLoop().RunUntilIdle();
834  EXPECT_EQ(kTrialName, observer.trial_name());
835  if (chosen_group == default_group)
836    EXPECT_EQ(kDefaultGroupName, observer.group_name());
837  else
838    EXPECT_EQ(kSecondaryGroupName, observer.group_name());
839}
840
841TEST_F(FieldTrialTest, ObserveDisabled) {
842  const char kTrialName[] = "TrialToObserve2";
843
844  TestFieldTrialObserver observer;
845  int default_group = -1;
846  scoped_refptr<FieldTrial> trial =
847      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
848  trial->AppendGroup("A", 25);
849  trial->AppendGroup("B", 25);
850  trial->AppendGroup("C", 25);
851  trial->Disable();
852
853  // Observer shouldn't be notified of a disabled trial.
854  RunLoop().RunUntilIdle();
855  EXPECT_TRUE(observer.trial_name().empty());
856  EXPECT_TRUE(observer.group_name().empty());
857
858  // Observer shouldn't be notified even after a |group()| call.
859  EXPECT_EQ(default_group, trial->group());
860  RunLoop().RunUntilIdle();
861  EXPECT_TRUE(observer.trial_name().empty());
862  EXPECT_TRUE(observer.group_name().empty());
863}
864
865TEST_F(FieldTrialTest, ObserveForcedDisabled) {
866  const char kTrialName[] = "TrialToObserve3";
867
868  TestFieldTrialObserver observer;
869  int default_group = -1;
870  scoped_refptr<FieldTrial> trial =
871      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, &default_group);
872  trial->AppendGroup("A", 25);
873  trial->AppendGroup("B", 25);
874  trial->AppendGroup("C", 25);
875  trial->SetForced();
876  trial->Disable();
877
878  // Observer shouldn't be notified of a disabled trial, even when forced.
879  RunLoop().RunUntilIdle();
880  EXPECT_TRUE(observer.trial_name().empty());
881  EXPECT_TRUE(observer.group_name().empty());
882
883  // Observer shouldn't be notified even after a |group()| call.
884  EXPECT_EQ(default_group, trial->group());
885  RunLoop().RunUntilIdle();
886  EXPECT_TRUE(observer.trial_name().empty());
887  EXPECT_TRUE(observer.group_name().empty());
888}
889
890TEST_F(FieldTrialTest, DisabledTrialNotActive) {
891  const char kTrialName[] = "DisabledTrial";
892  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
893
894  scoped_refptr<FieldTrial> trial =
895      CreateFieldTrial(kTrialName, 100, kDefaultGroupName, NULL);
896  trial->AppendGroup("X", 50);
897  trial->Disable();
898
899  // Ensure the trial is not listed as active.
900  FieldTrial::ActiveGroups active_groups;
901  FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
902  EXPECT_TRUE(active_groups.empty());
903
904  // Ensure the trial is not listed in the |StatesToString()| result.
905  std::string states;
906  FieldTrialList::StatesToString(&states);
907  EXPECT_TRUE(states.empty());
908}
909
910TEST_F(FieldTrialTest, ExpirationYearNotExpired) {
911  const char kTrialName[] = "NotExpired";
912  const char kGroupName[] = "Group2";
913  const int kProbability = 100;
914  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
915
916  scoped_refptr<FieldTrial> trial =
917      CreateFieldTrial(kTrialName, kProbability, kDefaultGroupName, NULL);
918  trial->AppendGroup(kGroupName, kProbability);
919  EXPECT_EQ(kGroupName, trial->group_name());
920}
921
922TEST_F(FieldTrialTest, FloatBoundariesGiveEqualGroupSizes) {
923  const int kBucketCount = 100;
924
925  // Try each boundary value |i / 100.0| as the entropy value.
926  for (int i = 0; i < kBucketCount; ++i) {
927    const double entropy = i / static_cast<double>(kBucketCount);
928
929    scoped_refptr<base::FieldTrial> trial(
930        new base::FieldTrial("test", kBucketCount, "default", entropy));
931    for (int j = 0; j < kBucketCount; ++j)
932      trial->AppendGroup(base::StringPrintf("%d", j), 1);
933
934    EXPECT_EQ(base::StringPrintf("%d", i), trial->group_name());
935  }
936}
937
938TEST_F(FieldTrialTest, DoesNotSurpassTotalProbability) {
939  const double kEntropyValue = 1.0 - 1e-9;
940  ASSERT_LT(kEntropyValue, 1.0);
941
942  scoped_refptr<base::FieldTrial> trial(
943      new base::FieldTrial("test", 2, "default", kEntropyValue));
944  trial->AppendGroup("1", 1);
945  trial->AppendGroup("2", 1);
946
947  EXPECT_EQ("2", trial->group_name());
948}
949
950TEST_F(FieldTrialTest, CreateSimulatedFieldTrial) {
951  const char kTrialName[] = "CreateSimulatedFieldTrial";
952  ASSERT_FALSE(FieldTrialList::TrialExists(kTrialName));
953
954  // Different cases to test, e.g. default vs. non default group being chosen.
955  struct {
956    double entropy_value;
957    const char* expected_group;
958  } test_cases[] = {
959    { 0.4, "A" },
960    { 0.85, "B" },
961    { 0.95, kDefaultGroupName },
962  };
963
964  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
965    TestFieldTrialObserver observer;
966    scoped_refptr<FieldTrial> trial(
967       FieldTrial::CreateSimulatedFieldTrial(kTrialName, 100, kDefaultGroupName,
968                                             test_cases[i].entropy_value));
969    trial->AppendGroup("A", 80);
970    trial->AppendGroup("B", 10);
971    EXPECT_EQ(test_cases[i].expected_group, trial->group_name());
972
973    // Field trial shouldn't have been registered with the list.
974    EXPECT_FALSE(FieldTrialList::TrialExists(kTrialName));
975    EXPECT_EQ(0u, FieldTrialList::GetFieldTrialCount());
976
977    // Observer shouldn't have been notified.
978    RunLoop().RunUntilIdle();
979    EXPECT_TRUE(observer.trial_name().empty());
980
981    // The trial shouldn't be in the active set of trials.
982    FieldTrial::ActiveGroups active_groups;
983    FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
984    EXPECT_TRUE(active_groups.empty());
985
986    // The trial shouldn't be listed in the |StatesToString()| result.
987    std::string states;
988    FieldTrialList::StatesToString(&states);
989    EXPECT_TRUE(states.empty());
990  }
991}
992
993}  // namespace base
994