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/string_number_conversions.h" 6#include "base/utf_string_conversions.h" 7#include "base/values.h" 8#include "chrome/browser/about_flags.h" 9#include "chrome/common/chrome_switches.h" 10#include "chrome/common/pref_names.h" 11#include "chrome/test/testing_pref_service.h" 12#include "grit/chromium_strings.h" 13#include "testing/gtest/include/gtest/gtest.h" 14 15const char kFlags1[] = "flag1"; 16const char kFlags2[] = "flag2"; 17const char kFlags3[] = "flag3"; 18const char kFlags4[] = "flag4"; 19 20const char kSwitch1[] = "switch"; 21const char kSwitch2[] = "switch2"; 22const char kSwitch3[] = "switch3"; 23const char kValueForSwitch2[] = "value_for_switch2"; 24 25const char kMultiSwitch1[] = "multi_switch1"; 26const char kMultiSwitch2[] = "multi_switch2"; 27const char kValueForMultiSwitch2[] = "value_for_multi_switch2"; 28 29namespace about_flags { 30 31const Experiment::Choice kMultiChoices[] = { 32 { IDS_PRODUCT_NAME, "", "" }, 33 { IDS_PRODUCT_NAME, kMultiSwitch1, "" }, 34 { IDS_PRODUCT_NAME, kMultiSwitch2, kValueForMultiSwitch2 }, 35}; 36 37// The experiments that are set for these tests. The 3rd experiment is not 38// supported on the current platform, all others are. 39static Experiment kExperiments[] = { 40 { 41 kFlags1, 42 IDS_PRODUCT_NAME, 43 IDS_PRODUCT_NAME, 44 0, // Ends up being mapped to the current platform. 45 Experiment::SINGLE_VALUE, 46 kSwitch1, 47 "", 48 NULL, 49 0 50 }, 51 { 52 kFlags2, 53 IDS_PRODUCT_NAME, 54 IDS_PRODUCT_NAME, 55 0, // Ends up being mapped to the current platform. 56 Experiment::SINGLE_VALUE, 57 kSwitch2, 58 kValueForSwitch2, 59 NULL, 60 0 61 }, 62 { 63 kFlags3, 64 IDS_PRODUCT_NAME, 65 IDS_PRODUCT_NAME, 66 0, // This ends up enabling for an OS other than the current. 67 Experiment::SINGLE_VALUE, 68 kSwitch3, 69 "", 70 NULL, 71 0 72 }, 73 { 74 kFlags4, 75 IDS_PRODUCT_NAME, 76 IDS_PRODUCT_NAME, 77 0, // Ends up being mapped to the current platform. 78 Experiment::MULTI_VALUE, 79 "", 80 "", 81 kMultiChoices, 82 arraysize(kMultiChoices) 83 }, 84}; 85 86class AboutFlagsTest : public ::testing::Test { 87 protected: 88 AboutFlagsTest() { 89 prefs_.RegisterListPref(prefs::kEnabledLabsExperiments); 90#if defined(OS_CHROMEOS) 91 prefs_.RegisterBooleanPref(prefs::kLabsMediaplayerEnabled, false); 92 prefs_.RegisterBooleanPref(prefs::kLabsAdvancedFilesystemEnabled, false); 93 prefs_.RegisterBooleanPref(prefs::kUseVerticalTabs, false); 94#endif 95 testing::ClearState(); 96 } 97 98 virtual void SetUp() { 99 for (size_t i = 0; i < arraysize(kExperiments); ++i) 100 kExperiments[i].supported_platforms = GetCurrentPlatform(); 101 102 int os_other_than_current = 1; 103 while (os_other_than_current == GetCurrentPlatform()) 104 os_other_than_current <<= 1; 105 kExperiments[2].supported_platforms = os_other_than_current; 106 107 testing::SetExperiments(kExperiments, arraysize(kExperiments)); 108 } 109 110 virtual void TearDown() { 111 testing::SetExperiments(NULL, 0); 112 } 113 114 TestingPrefService prefs_; 115}; 116 117TEST_F(AboutFlagsTest, ChangeNeedsRestart) { 118 EXPECT_FALSE(IsRestartNeededToCommitChanges()); 119 SetExperimentEnabled(&prefs_, kFlags1, true); 120 EXPECT_TRUE(IsRestartNeededToCommitChanges()); 121} 122 123TEST_F(AboutFlagsTest, AddTwoFlagsRemoveOne) { 124 // Add two experiments, check they're there. 125 SetExperimentEnabled(&prefs_, kFlags1, true); 126 SetExperimentEnabled(&prefs_, kFlags2, true); 127 128 const ListValue* experiments_list = prefs_.GetList( 129 prefs::kEnabledLabsExperiments); 130 ASSERT_TRUE(experiments_list != NULL); 131 132 ASSERT_EQ(2u, experiments_list->GetSize()); 133 134 std::string s0; 135 ASSERT_TRUE(experiments_list->GetString(0, &s0)); 136 std::string s1; 137 ASSERT_TRUE(experiments_list->GetString(1, &s1)); 138 139 EXPECT_TRUE(s0 == kFlags1 || s1 == kFlags1); 140 EXPECT_TRUE(s0 == kFlags2 || s1 == kFlags2); 141 142 // Remove one experiment, check the other's still around. 143 SetExperimentEnabled(&prefs_, kFlags2, false); 144 145 experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments); 146 ASSERT_TRUE(experiments_list != NULL); 147 ASSERT_EQ(1u, experiments_list->GetSize()); 148 ASSERT_TRUE(experiments_list->GetString(0, &s0)); 149 EXPECT_TRUE(s0 == kFlags1); 150} 151 152TEST_F(AboutFlagsTest, AddTwoFlagsRemoveBoth) { 153 // Add two experiments, check the pref exists. 154 SetExperimentEnabled(&prefs_, kFlags1, true); 155 SetExperimentEnabled(&prefs_, kFlags2, true); 156 const ListValue* experiments_list = prefs_.GetList( 157 prefs::kEnabledLabsExperiments); 158 ASSERT_TRUE(experiments_list != NULL); 159 160 // Remove both, the pref should have been removed completely. 161 SetExperimentEnabled(&prefs_, kFlags1, false); 162 SetExperimentEnabled(&prefs_, kFlags2, false); 163 experiments_list = prefs_.GetList(prefs::kEnabledLabsExperiments); 164 EXPECT_TRUE(experiments_list == NULL || experiments_list->GetSize() == 0); 165} 166 167TEST_F(AboutFlagsTest, ConvertFlagsToSwitches) { 168 SetExperimentEnabled(&prefs_, kFlags1, true); 169 170 CommandLine command_line(CommandLine::NO_PROGRAM); 171 command_line.AppendSwitch("foo"); 172 173 EXPECT_TRUE(command_line.HasSwitch("foo")); 174 EXPECT_FALSE(command_line.HasSwitch(kSwitch1)); 175 176 ConvertFlagsToSwitches(&prefs_, &command_line); 177 178 EXPECT_TRUE(command_line.HasSwitch("foo")); 179 EXPECT_TRUE(command_line.HasSwitch(kSwitch1)); 180} 181 182TEST_F(AboutFlagsTest, RemoveFlagSwitches) { 183 std::map<std::string, CommandLine::StringType> switch_list; 184 switch_list[kSwitch1] = CommandLine::StringType(); 185 switch_list[switches::kFlagSwitchesBegin] = CommandLine::StringType(); 186 switch_list[switches::kFlagSwitchesEnd] = CommandLine::StringType(); 187 switch_list["foo"] = CommandLine::StringType(); 188 189 SetExperimentEnabled(&prefs_, kFlags1, true); 190 191 // This shouldn't do anything before ConvertFlagsToSwitches() wasn't called. 192 RemoveFlagsSwitches(&switch_list); 193 ASSERT_EQ(4u, switch_list.size()); 194 EXPECT_TRUE(switch_list.find(kSwitch1) != switch_list.end()); 195 EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesBegin) != 196 switch_list.end()); 197 EXPECT_TRUE(switch_list.find(switches::kFlagSwitchesEnd) != 198 switch_list.end()); 199 EXPECT_TRUE(switch_list.find("foo") != switch_list.end()); 200 201 // Call ConvertFlagsToSwitches(), then RemoveFlagsSwitches() again. 202 CommandLine command_line(CommandLine::NO_PROGRAM); 203 command_line.AppendSwitch("foo"); 204 ConvertFlagsToSwitches(&prefs_, &command_line); 205 RemoveFlagsSwitches(&switch_list); 206 207 // Now the about:flags-related switch should have been removed. 208 ASSERT_EQ(1u, switch_list.size()); 209 EXPECT_TRUE(switch_list.find("foo") != switch_list.end()); 210} 211 212// Tests enabling experiments that aren't supported on the current platform. 213TEST_F(AboutFlagsTest, PersistAndPrune) { 214 // Enable experiments 1 and 3. 215 SetExperimentEnabled(&prefs_, kFlags1, true); 216 SetExperimentEnabled(&prefs_, kFlags3, true); 217 CommandLine command_line(CommandLine::NO_PROGRAM); 218 EXPECT_FALSE(command_line.HasSwitch(kSwitch1)); 219 EXPECT_FALSE(command_line.HasSwitch(kSwitch3)); 220 221 // Convert the flags to switches. Experiment 3 shouldn't be among the switches 222 // as it is not applicable to the current platform. 223 ConvertFlagsToSwitches(&prefs_, &command_line); 224 EXPECT_TRUE(command_line.HasSwitch(kSwitch1)); 225 EXPECT_FALSE(command_line.HasSwitch(kSwitch3)); 226 227 // Experiment 3 should show still be persisted in preferences though. 228 scoped_ptr<ListValue> switch_prefs(GetFlagsExperimentsData(&prefs_)); 229 ASSERT_TRUE(switch_prefs.get()); 230 EXPECT_EQ(arraysize(kExperiments) - 1, switch_prefs->GetSize()); 231} 232 233// Tests that switches which should have values get them in the command 234// line. 235TEST_F(AboutFlagsTest, CheckValues) { 236 // Enable experiments 1 and 2. 237 SetExperimentEnabled(&prefs_, kFlags1, true); 238 SetExperimentEnabled(&prefs_, kFlags2, true); 239 CommandLine command_line(CommandLine::NO_PROGRAM); 240 EXPECT_FALSE(command_line.HasSwitch(kSwitch1)); 241 EXPECT_FALSE(command_line.HasSwitch(kSwitch2)); 242 243 // Convert the flags to switches. 244 ConvertFlagsToSwitches(&prefs_, &command_line); 245 EXPECT_TRUE(command_line.HasSwitch(kSwitch1)); 246 EXPECT_EQ(std::string(""), 247 command_line.GetSwitchValueASCII(kSwitch1)); 248 EXPECT_TRUE(command_line.HasSwitch(kSwitch2)); 249 EXPECT_EQ(std::string(kValueForSwitch2), 250 command_line.GetSwitchValueASCII(kSwitch2)); 251 252 // Confirm that there is no '=' in the command line for simple switches. 253 std::string switch1_with_equals = std::string("--") + 254 std::string(kSwitch1) + 255 std::string("="); 256#if defined(OS_WIN) 257 EXPECT_EQ(std::wstring::npos, 258 command_line.command_line_string().find( 259 ASCIIToWide(switch1_with_equals))); 260#else 261 EXPECT_EQ(std::string::npos, 262 command_line.command_line_string().find(switch1_with_equals)); 263#endif 264 265 // And confirm there is a '=' for switches with values. 266 std::string switch2_with_equals = std::string("--") + 267 std::string(kSwitch2) + 268 std::string("="); 269#if defined(OS_WIN) 270 EXPECT_NE(std::wstring::npos, 271 command_line.command_line_string().find( 272 ASCIIToWide(switch2_with_equals))); 273#else 274 EXPECT_NE(std::string::npos, 275 command_line.command_line_string().find(switch2_with_equals)); 276#endif 277 278 // And it should persist 279 scoped_ptr<ListValue> switch_prefs(GetFlagsExperimentsData(&prefs_)); 280 ASSERT_TRUE(switch_prefs.get()); 281 EXPECT_EQ(arraysize(kExperiments) - 1, switch_prefs->GetSize()); 282} 283 284// Tests multi-value type experiments. 285TEST_F(AboutFlagsTest, MultiValues) { 286 // Initially, the first "deactivated" option of the multi experiment should 287 // be set. 288 { 289 CommandLine command_line(CommandLine::NO_PROGRAM); 290 ConvertFlagsToSwitches(&prefs_, &command_line); 291 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1)); 292 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2)); 293 } 294 295 // Enable the 2nd choice of the multi-value. 296 SetExperimentEnabled(&prefs_, std::string(kFlags4) + 297 std::string(testing::kMultiSeparator) + 298 base::IntToString(2), true); 299 { 300 CommandLine command_line(CommandLine::NO_PROGRAM); 301 ConvertFlagsToSwitches(&prefs_, &command_line); 302 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1)); 303 EXPECT_TRUE(command_line.HasSwitch(kMultiSwitch2)); 304 EXPECT_EQ(std::string(kValueForMultiSwitch2), 305 command_line.GetSwitchValueASCII(kMultiSwitch2)); 306 } 307 308 // Disable the multi-value experiment. 309 SetExperimentEnabled(&prefs_, std::string(kFlags4) + 310 std::string(testing::kMultiSeparator) + 311 base::IntToString(0), true); 312 { 313 CommandLine command_line(CommandLine::NO_PROGRAM); 314 ConvertFlagsToSwitches(&prefs_, &command_line); 315 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch1)); 316 EXPECT_FALSE(command_line.HasSwitch(kMultiSwitch2)); 317 } 318} 319 320// Makes sure there are no separators in any of the experiment names. 321TEST_F(AboutFlagsTest, NoSeparators) { 322 testing::SetExperiments(NULL, 0); 323 size_t count; 324 const Experiment* experiments = testing::GetExperiments(&count); 325 for (size_t i = 0; i < count; ++i) { 326 std::string name = experiments->internal_name; 327 EXPECT_EQ(std::string::npos, name.find(testing::kMultiSeparator)) << i; 328 } 329} 330 331} // namespace about_flags 332