chrome/browser/about_flags_unittest.cc

   1 // Copyright (c) 2011 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/prefs/pref_registry_simple.h"
   6 #include "base/prefs/testing_pref_service.h"
   7 #include "base/strings/string_number_conversions.h"
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "base/values.h"
  10 #include "chrome/browser/about_flags.h"
  11 #include "chrome/browser/pref_service_flags_storage.h"
  12 #include "chrome/common/chrome_switches.h"
  13 #include "chrome/common/pref_names.h"
  14 #include "grit/chromium_strings.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 const char kFlags1[] = "flag1";
  18 const char kFlags2[] = "flag2";
  19 const char kFlags3[] = "flag3";
  20 const char kFlags4[] = "flag4";
  21 const char kFlags5[] = "flag5";
  22
  23 const char kSwitch1[] = "switch";
  24 const char kSwitch2[] = "switch2";
  25 const char kSwitch3[] = "switch3";
  26 const char kValueForSwitch2[] = "value_for_switch2";
  27
  28 const char kMultiSwitch1[] = "multi_switch1";
  29 const char kMultiSwitch2[] = "multi_switch2";
  30 const char kValueForMultiSwitch2[] = "value_for_multi_switch2";
  31
  32 const char kEnableDisableValue1[] = "value1";
  33 const char kEnableDisableValue2[] = "value2";
  34
  35 namespace about_flags {
  36
  37 const Experiment::Choice kMultiChoices[] = {
  38   { IDS_PRODUCT_NAME, "", "" },
  39   { IDS_PRODUCT_NAME, kMultiSwitch1, "" },
  40   { IDS_PRODUCT_NAME, kMultiSwitch2, kValueForMultiSwitch2 },
  41 };
  42
  43 // The experiments that are set for these tests. The 3rd experiment is not
  44 // supported on the current platform, all others are.
  45 static Experiment kExperiments[] = {
  46   {
  47     kFlags1,
  48     IDS_PRODUCT_NAME,
  49     IDS_PRODUCT_NAME,
  50     0,  // Ends up being mapped to the current platform.
  51     Experiment::SINGLE_VALUE,
  52     kSwitch1,
  53     "",
  54     NULL,
  55     NULL,
  56     NULL,
  57     0
  58   },
  59   {
  60     kFlags2,
  61     IDS_PRODUCT_NAME,
  62     IDS_PRODUCT_NAME,
  63     0,  // Ends up being mapped to the current platform.
  64     Experiment::SINGLE_VALUE,
  65     kSwitch2,
  66     kValueForSwitch2,
  67     NULL,
  68     NULL,
  69     NULL,
  70     0
  71   },
  72   {
  73     kFlags3,
  74     IDS_PRODUCT_NAME,
  75     IDS_PRODUCT_NAME,
  76     0,  // This ends up enabling for an OS other than the current.
  77     Experiment::SINGLE_VALUE,
  78     kSwitch3,
  79     "",
  80     NULL,
  81     NULL,
  82     NULL,
  83     0
  84   },
  85   {
  86     kFlags4,
  87     IDS_PRODUCT_NAME,
  88     IDS_PRODUCT_NAME,
  89     0,  // Ends up being mapped to the current platform.
  90     Experiment::MULTI_VALUE,
  91     "",
  92     "",
  93     "",
  94     "",
  95     kMultiChoices,
  96     arraysize(kMultiChoices)
  97   },
  98   {
  99     kFlags5,
 100     IDS_PRODUCT_NAME,
 101     IDS_PRODUCT_NAME,
 102     0,  // Ends up being mapped to the current platform.
 103     Experiment::ENABLE_DISABLE_VALUE,
 104     kSwitch1,
 105     kEnableDisableValue1,
 106     kSwitch2,
 107     kEnableDisableValue2,
 108     NULL,
 109     3
 110   },
 111 };
 112
 113 class AboutFlagsTest : public ::testing::Test {
 114  protected:
 115   AboutFlagsTest() : flags_storage_(&prefs_) {
 116     prefs_.registry()->RegisterListPref(prefs::kEnabledLabsExperiments);
 117     testing::ClearState();
 118   }
 119
 120   virtual void SetUp() OVERRIDE {
 121     for (size_t i = 0; i < arraysize(kExperiments); ++i)
 122       kExperiments[i].supported_platforms = GetCurrentPlatform();
 123
 124     int os_other_than_current = 1;
 125     while (os_other_than_current == GetCurrentPlatform())
 126       os_other_than_current <<= 1;
 127     kExperiments[2].supported_platforms = os_other_than_current;
 128
 129     testing::SetExperiments(kExperiments, arraysize(kExperiments));
 130   }
 131
 132   virtual void TearDown() OVERRIDE {
 133     testing::SetExperiments(NULL, 0);
 134   }
 135
 136   TestingPrefServiceSimple prefs_;
 137   PrefServiceFlagsStorage flags_storage_;
 138 };
 139
 140
 141 TEST_F(AboutFlagsTest, NoChangeNoRestart) {
 142   EXPECT_FALSE(IsRestartNeededToCommitChanges());
 143   SetExperimentEnabled(&flags_storage_, kFlags1, false);
 144   EXPECT_FALSE(IsRestartNeededToCommitChanges());
 145 }
 146
 147 TEST_F(AboutFlagsTest, ChangeNeedsRestart) {
 148   EXPECT_FALSE(IsRestartNeededToCommitChanges());
 149   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 150   EXPECT_TRUE(IsRestartNeededToCommitChanges());
 151 }
 152
 153 TEST_F(AboutFlagsTest, MultiFlagChangeNeedsRestart) {
 154   const Experiment& experiment = kExperiments[3];
 155   ASSERT_EQ(kFlags4, experiment.internal_name);
 156   EXPECT_FALSE(IsRestartNeededToCommitChanges());
 157   // Enable the 2nd choice of the multi-value.
 158   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
 159   EXPECT_TRUE(IsRestartNeededToCommitChanges());
 160   testing::ClearState();
 161   EXPECT_FALSE(IsRestartNeededToCommitChanges());
 162   // Enable the default choice now.
 163   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
 164   EXPECT_TRUE(IsRestartNeededToCommitChanges());
 165 }
 166
 167 TEST_F(AboutFlagsTest, AddTwoFlagsRemoveOne) {
 168   // Add two experiments, check they're there.
 169   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 170   SetExperimentEnabled(&flags_storage_, kFlags2, true);
 171
 172   const base::ListValue* experiments_list = prefs_.GetList(
 173       prefs::kEnabledLabsExperiments);
 174   ASSERT_TRUE(experiments_list != NULL);
 175
 176   ASSERT_EQ(2u, experiments_list->GetSize());
 177
 178   std::string s0;
 179   ASSERT_TRUE(experiments_list->GetString(0, &s0));
 180   std::string s1;
 181   ASSERT_TRUE(experiments_list->GetString(1, &s1));
 182
 183   EXPECT_TRUE(s0 == kFlags1 || s1 == kFlags1);
 184   EXPECT_TRUE(s0 == kFlags2 || s1 == kFlags2);
 185
 186   // Remove one experiment, check the other's still around.
 187   SetExperimentEnabled(&flags_storage_, kFlags2, false);
 188
 189   experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
 190   ASSERT_TRUE(experiments_list != NULL);
 191   ASSERT_EQ(1u, experiments_list->GetSize());
 192   ASSERT_TRUE(experiments_list->GetString(0, &s0));
 193   EXPECT_TRUE(s0 == kFlags1);
 194 }
 195
 196 TEST_F(AboutFlagsTest, AddTwoFlagsRemoveBoth) {
 197   // Add two experiments, check the pref exists.
 198   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 199   SetExperimentEnabled(&flags_storage_, kFlags2, true);
 200   const base::ListValue* experiments_list = prefs_.GetList(
 201       prefs::kEnabledLabsExperiments);
 202   ASSERT_TRUE(experiments_list != NULL);
 203
 204   // Remove both, the pref should have been removed completely.
 205   SetExperimentEnabled(&flags_storage_, kFlags1, false);
 206   SetExperimentEnabled(&flags_storage_, kFlags2, false);
 207   experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments);
 208   EXPECT_TRUE(experiments_list == NULL || experiments_list->GetSize() == 0);
 209 }
 210
 211 TEST_F(AboutFlagsTest, ConvertFlagsToSwitches) {
 212   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 213
 214   CommandLine command_line(CommandLine::NO_PROGRAM);
 215   command_line.AppendSwitch("foo");
 216
 217   EXPECT_TRUE(command_line.HasSwitch("foo"));
 218   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
 219
 220   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 221
 222   EXPECT_TRUE(command_line.HasSwitch("foo"));
 223   EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
 224   EXPECT_TRUE(command_line.HasSwitch(switches::kFlagSwitchesBegin));
 225   EXPECT_TRUE(command_line.HasSwitch(switches::kFlagSwitchesEnd));
 226
 227   CommandLine command_line2(CommandLine::NO_PROGRAM);
 228
 229   ConvertFlagsToSwitches(&flags_storage_, &command_line2, kNoSentinels);
 230
 231   EXPECT_TRUE(command_line2.HasSwitch(kSwitch1));
 232   EXPECT_FALSE(command_line2.HasSwitch(switches::kFlagSwitchesBegin));
 233   EXPECT_FALSE(command_line2.HasSwitch(switches::kFlagSwitchesEnd));
 234 }
 235
 236 TEST_F(AboutFlagsTest, CompareSwitchesToCurrentCommandLine) {
 237   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 238
 239   CommandLine command_line(CommandLine::NO_PROGRAM);
 240   command_line.AppendSwitch("foo");
 241
 242   CommandLine new_command_line(CommandLine::NO_PROGRAM);
 243   ConvertFlagsToSwitches(&flags_storage_, &new_command_line, kAddSentinels);
 244
 245   EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(new_command_line,
 246                                                         command_line));
 247
 248   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 249
 250   EXPECT_TRUE(AreSwitchesIdenticalToCurrentCommandLine(new_command_line,
 251                                                        command_line));
 252
 253   // Now both have flags but different.
 254   SetExperimentEnabled(&flags_storage_, kFlags1, false);
 255   SetExperimentEnabled(&flags_storage_, kFlags2, true);
 256
 257   CommandLine another_command_line(CommandLine::NO_PROGRAM);
 258   ConvertFlagsToSwitches(&flags_storage_, &another_command_line, kAddSentinels);
 259
 260   EXPECT_FALSE(AreSwitchesIdenticalToCurrentCommandLine(new_command_line,
 261                                                         another_command_line));
 262 }
 263
 264 TEST_F(AboutFlagsTest, RemoveFlagSwitches) {
 265   std::map<std::string, CommandLine::StringType> switch_list;
 266   switch_list[kSwitch1] = CommandLine::StringType();
 267   switch_list[switches::kFlagSwitchesBegin] = CommandLine::StringType();
 268   switch_list[switches::kFlagSwitchesEnd] = CommandLine::StringType();
 269   switch_list["foo"] = CommandLine::StringType();
 270
 271   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 272
 273   // This shouldn't do anything before ConvertFlagsToSwitches() wasn't called.
 274   RemoveFlagsSwitches(&switch_list);
 275   ASSERT_EQ(4u, switch_list.size());
 276   EXPECT_TRUE(switch_list.find(kSwitch1) != switch_list.end());
 277   EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesBegin) !=
 278               switch_list.end());
 279   EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesEnd) !=
 280               switch_list.end());
 281   EXPECT_TRUE(switch_list.find("foo") != switch_list.end());
 282
 283   // Call ConvertFlagsToSwitches(), then RemoveFlagsSwitches() again.
 284   CommandLine command_line(CommandLine::NO_PROGRAM);
 285   command_line.AppendSwitch("foo");
 286   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 287   RemoveFlagsSwitches(&switch_list);
 288
 289   // Now the about:flags-related switch should have been removed.
 290   ASSERT_EQ(1u, switch_list.size());
 291   EXPECT_TRUE(switch_list.find("foo") != switch_list.end());
 292 }
 293
 294 // Tests enabling experiments that aren't supported on the current platform.
 295 TEST_F(AboutFlagsTest, PersistAndPrune) {
 296   // Enable experiments 1 and 3.
 297   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 298   SetExperimentEnabled(&flags_storage_, kFlags3, true);
 299   CommandLine command_line(CommandLine::NO_PROGRAM);
 300   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
 301   EXPECT_FALSE(command_line.HasSwitch(kSwitch3));
 302
 303   // Convert the flags to switches. Experiment 3 shouldn't be among the switches
 304   // as it is not applicable to the current platform.
 305   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 306   EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
 307   EXPECT_FALSE(command_line.HasSwitch(kSwitch3));
 308
 309   // Experiment 3 should show still be persisted in preferences though.
 310   const base::ListValue* experiments_list =
 311       prefs_.GetList(prefs::kEnabledLabsExperiments);
 312   ASSERT_TRUE(experiments_list);
 313   EXPECT_EQ(2U, experiments_list->GetSize());
 314   std::string s0;
 315   ASSERT_TRUE(experiments_list->GetString(0, &s0));
 316   EXPECT_EQ(kFlags1, s0);
 317   std::string s1;
 318   ASSERT_TRUE(experiments_list->GetString(1, &s1));
 319   EXPECT_EQ(kFlags3, s1);
 320 }
 321
 322 // Tests that switches which should have values get them in the command
 323 // line.
 324 TEST_F(AboutFlagsTest, CheckValues) {
 325   // Enable experiments 1 and 2.
 326   SetExperimentEnabled(&flags_storage_, kFlags1, true);
 327   SetExperimentEnabled(&flags_storage_, kFlags2, true);
 328   CommandLine command_line(CommandLine::NO_PROGRAM);
 329   EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
 330   EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
 331
 332   // Convert the flags to switches.
 333   ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 334   EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
 335   EXPECT_EQ(std::string(), command_line.GetSwitchValueASCII(kSwitch1));
 336   EXPECT_TRUE(command_line.HasSwitch(kSwitch2));
 337   EXPECT_EQ(std::string(kValueForSwitch2),
 338             command_line.GetSwitchValueASCII(kSwitch2));
 339
 340   // Confirm that there is no '=' in the command line for simple switches.
 341   std::string switch1_with_equals = std::string("--") +
 342                                     std::string(kSwitch1) +
 343                                     std::string("=");
 344 #if defined(OS_WIN)
 345   EXPECT_EQ(std::wstring::npos,
 346             command_line.GetCommandLineString().find(
 347                 base::ASCIIToWide(switch1_with_equals)));
 348 #else
 349   EXPECT_EQ(std::string::npos,
 350             command_line.GetCommandLineString().find(switch1_with_equals));
 351 #endif
 352
 353   // And confirm there is a '=' for switches with values.
 354   std::string switch2_with_equals = std::string("--") +
 355                                     std::string(kSwitch2) +
 356                                     std::string("=");
 357 #if defined(OS_WIN)
 358   EXPECT_NE(std::wstring::npos,
 359             command_line.GetCommandLineString().find(
 360                 base::ASCIIToWide(switch2_with_equals)));
 361 #else
 362   EXPECT_NE(std::string::npos,
 363             command_line.GetCommandLineString().find(switch2_with_equals));
 364 #endif
 365
 366   // And it should persist.
 367   const base::ListValue* experiments_list =
 368       prefs_.GetList(prefs::kEnabledLabsExperiments);
 369   ASSERT_TRUE(experiments_list);
 370   EXPECT_EQ(2U, experiments_list->GetSize());
 371   std::string s0;
 372   ASSERT_TRUE(experiments_list->GetString(0, &s0));
 373   EXPECT_EQ(kFlags1, s0);
 374   std::string s1;
 375   ASSERT_TRUE(experiments_list->GetString(1, &s1));
 376   EXPECT_EQ(kFlags2, s1);
 377 }
 378
 379 // Tests multi-value type experiments.
 380 TEST_F(AboutFlagsTest, MultiValues) {
 381   const Experiment& experiment = kExperiments[3];
 382   ASSERT_EQ(kFlags4, experiment.internal_name);
 383
 384   // Initially, the first "deactivated" option of the multi experiment should
 385   // be set.
 386   {
 387     CommandLine command_line(CommandLine::NO_PROGRAM);
 388     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 389     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
 390     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
 391   }
 392
 393   // Enable the 2nd choice of the multi-value.
 394   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
 395   {
 396     CommandLine command_line(CommandLine::NO_PROGRAM);
 397     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 398     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
 399     EXPECT_TRUE(command_line.HasSwitch(kMultiSwitch2));
 400     EXPECT_EQ(std::string(kValueForMultiSwitch2),
 401               command_line.GetSwitchValueASCII(kMultiSwitch2));
 402   }
 403
 404   // Disable the multi-value experiment.
 405   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
 406   {
 407     CommandLine command_line(CommandLine::NO_PROGRAM);
 408     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 409     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
 410     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
 411   }
 412 }
 413
 414 TEST_F(AboutFlagsTest, EnableDisableValues) {
 415   const Experiment& experiment = kExperiments[4];
 416   ASSERT_EQ(kFlags5, experiment.internal_name);
 417
 418   // Nothing selected.
 419   {
 420     CommandLine command_line(CommandLine::NO_PROGRAM);
 421     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 422     EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
 423     EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
 424   }
 425
 426   // "Enable" option selected.
 427   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(1), true);
 428   {
 429     CommandLine command_line(CommandLine::NO_PROGRAM);
 430     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 431     EXPECT_TRUE(command_line.HasSwitch(kSwitch1));
 432     EXPECT_FALSE(command_line.HasSwitch(kSwitch2));
 433     EXPECT_EQ(kEnableDisableValue1, command_line.GetSwitchValueASCII(kSwitch1));
 434   }
 435
 436   // "Disable" option selected.
 437   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(2), true);
 438   {
 439     CommandLine command_line(CommandLine::NO_PROGRAM);
 440     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 441     EXPECT_FALSE(command_line.HasSwitch(kSwitch1));
 442     EXPECT_TRUE(command_line.HasSwitch(kSwitch2));
 443     EXPECT_EQ(kEnableDisableValue2, command_line.GetSwitchValueASCII(kSwitch2));
 444   }
 445
 446   // "Default" option selected, same as nothing selected.
 447   SetExperimentEnabled(&flags_storage_, experiment.NameForChoice(0), true);
 448   {
 449     CommandLine command_line(CommandLine::NO_PROGRAM);
 450     ConvertFlagsToSwitches(&flags_storage_, &command_line, kAddSentinels);
 451     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1));
 452     EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2));
 453   }
 454 }
 455
 456 // Makes sure there are no separators in any of the experiment names.
 457 TEST_F(AboutFlagsTest, NoSeparators) {
 458   testing::SetExperiments(NULL, 0);
 459   size_t count;
 460   const Experiment* experiments = testing::GetExperiments(&count);
 461     for (size_t i = 0; i < count; ++i) {
 462     std::string name = experiments->internal_name;
 463     EXPECT_EQ(std::string::npos, name.find(testing::kMultiSeparator)) << i;
 464   }
 465 }
 466
 467 }  // namespace about_flags