base/metrics/field_trial_unittest.cc

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