| OLD | NEW |
|---|
| (Empty) |
| 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 <string> | |
| 6 | |
| 7 #include "base/prefs/json_pref_store.h" | |
| 8 #include "base/prefs/mock_pref_change_callback.h" | |
| 9 #include "base/prefs/pref_change_registrar.h" | |
| 10 #include "base/prefs/pref_registry_simple.h" | |
| 11 #include "base/prefs/pref_service_factory.h" | |
| 12 #include "base/prefs/pref_value_store.h" | |
| 13 #include "base/prefs/testing_pref_service.h" | |
| 14 #include "base/prefs/testing_pref_store.h" | |
| 15 #include "base/values.h" | |
| 16 #include "testing/gmock/include/gmock/gmock.h" | |
| 17 #include "testing/gtest/include/gtest/gtest.h" | |
| 18 | |
| 19 using testing::_; | |
| 20 using testing::Mock; | |
| 21 | |
| 22 const char kPrefName[] = "pref.name"; | |
| 23 | |
| 24 TEST(PrefServiceTest, NoObserverFire) { | |
| 25 TestingPrefServiceSimple prefs; | |
| 26 | |
| 27 const char pref_name[] = "homepage"; | |
| 28 prefs.registry()->RegisterStringPref(pref_name, std::string()); | |
| 29 | |
| 30 const char new_pref_value[] = "http://www.google.com/"; | |
| 31 MockPrefChangeCallback obs(&prefs); | |
| 32 PrefChangeRegistrar registrar; | |
| 33 registrar.Init(&prefs); | |
| 34 registrar.Add(pref_name, obs.GetCallback()); | |
| 35 | |
| 36 // This should fire the checks in MockPrefChangeCallback::OnPreferenceChanged. | |
| 37 const base::StringValue expected_value(new_pref_value); | |
| 38 obs.Expect(pref_name, &expected_value); | |
| 39 prefs.SetString(pref_name, new_pref_value); | |
| 40 Mock::VerifyAndClearExpectations(&obs); | |
| 41 | |
| 42 // Setting the pref to the same value should not set the pref value a second | |
| 43 // time. | |
| 44 EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0); | |
| 45 prefs.SetString(pref_name, new_pref_value); | |
| 46 Mock::VerifyAndClearExpectations(&obs); | |
| 47 | |
| 48 // Clearing the pref should cause the pref to fire. | |
| 49 const base::StringValue expected_default_value((std::string())); | |
| 50 obs.Expect(pref_name, &expected_default_value); | |
| 51 prefs.ClearPref(pref_name); | |
| 52 Mock::VerifyAndClearExpectations(&obs); | |
| 53 | |
| 54 // Clearing the pref again should not cause the pref to fire. | |
| 55 EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0); | |
| 56 prefs.ClearPref(pref_name); | |
| 57 Mock::VerifyAndClearExpectations(&obs); | |
| 58 } | |
| 59 | |
| 60 TEST(PrefServiceTest, HasPrefPath) { | |
| 61 TestingPrefServiceSimple prefs; | |
| 62 | |
| 63 const char path[] = "fake.path"; | |
| 64 | |
| 65 // Shouldn't initially have a path. | |
| 66 EXPECT_FALSE(prefs.HasPrefPath(path)); | |
| 67 | |
| 68 // Register the path. This doesn't set a value, so the path still shouldn't | |
| 69 // exist. | |
| 70 prefs.registry()->RegisterStringPref(path, std::string()); | |
| 71 EXPECT_FALSE(prefs.HasPrefPath(path)); | |
| 72 | |
| 73 // Set a value and make sure we have a path. | |
| 74 prefs.SetString(path, "blah"); | |
| 75 EXPECT_TRUE(prefs.HasPrefPath(path)); | |
| 76 } | |
| 77 | |
| 78 TEST(PrefServiceTest, Observers) { | |
| 79 const char pref_name[] = "homepage"; | |
| 80 | |
| 81 TestingPrefServiceSimple prefs; | |
| 82 prefs.SetUserPref(pref_name, | |
| 83 new base::StringValue("http://www.cnn.com")); | |
| 84 prefs.registry()->RegisterStringPref(pref_name, std::string()); | |
| 85 | |
| 86 const char new_pref_value[] = "http://www.google.com/"; | |
| 87 const base::StringValue expected_new_pref_value(new_pref_value); | |
| 88 MockPrefChangeCallback obs(&prefs); | |
| 89 PrefChangeRegistrar registrar; | |
| 90 registrar.Init(&prefs); | |
| 91 registrar.Add(pref_name, obs.GetCallback()); | |
| 92 | |
| 93 PrefChangeRegistrar registrar_two; | |
| 94 registrar_two.Init(&prefs); | |
| 95 | |
| 96 // This should fire the checks in MockPrefChangeCallback::OnPreferenceChanged. | |
| 97 obs.Expect(pref_name, &expected_new_pref_value); | |
| 98 prefs.SetString(pref_name, new_pref_value); | |
| 99 Mock::VerifyAndClearExpectations(&obs); | |
| 100 | |
| 101 // Now try adding a second pref observer. | |
| 102 const char new_pref_value2[] = "http://www.youtube.com/"; | |
| 103 const base::StringValue expected_new_pref_value2(new_pref_value2); | |
| 104 MockPrefChangeCallback obs2(&prefs); | |
| 105 obs.Expect(pref_name, &expected_new_pref_value2); | |
| 106 obs2.Expect(pref_name, &expected_new_pref_value2); | |
| 107 registrar_two.Add(pref_name, obs2.GetCallback()); | |
| 108 // This should fire the checks in obs and obs2. | |
| 109 prefs.SetString(pref_name, new_pref_value2); | |
| 110 Mock::VerifyAndClearExpectations(&obs); | |
| 111 Mock::VerifyAndClearExpectations(&obs2); | |
| 112 | |
| 113 // Set a recommended value. | |
| 114 const base::StringValue recommended_pref_value("http://www.gmail.com/"); | |
| 115 obs.Expect(pref_name, &expected_new_pref_value2); | |
| 116 obs2.Expect(pref_name, &expected_new_pref_value2); | |
| 117 // This should fire the checks in obs and obs2 but with an unchanged value | |
| 118 // as the recommended value is being overridden by the user-set value. | |
| 119 prefs.SetRecommendedPref(pref_name, recommended_pref_value.DeepCopy()); | |
| 120 Mock::VerifyAndClearExpectations(&obs); | |
| 121 Mock::VerifyAndClearExpectations(&obs2); | |
| 122 | |
| 123 // Make sure obs2 still works after removing obs. | |
| 124 registrar.Remove(pref_name); | |
| 125 EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0); | |
| 126 obs2.Expect(pref_name, &expected_new_pref_value); | |
| 127 // This should only fire the observer in obs2. | |
| 128 prefs.SetString(pref_name, new_pref_value); | |
| 129 Mock::VerifyAndClearExpectations(&obs); | |
| 130 Mock::VerifyAndClearExpectations(&obs2); | |
| 131 } | |
| 132 | |
| 133 // Make sure that if a preference changes type, so the wrong type is stored in | |
| 134 // the user pref file, it uses the correct fallback value instead. | |
| 135 TEST(PrefServiceTest, GetValueChangedType) { | |
| 136 const int kTestValue = 10; | |
| 137 TestingPrefServiceSimple prefs; | |
| 138 prefs.registry()->RegisterIntegerPref(kPrefName, kTestValue); | |
| 139 | |
| 140 // Check falling back to a recommended value. | |
| 141 prefs.SetUserPref(kPrefName, | |
| 142 new base::StringValue("not an integer")); | |
| 143 const PrefService::Preference* pref = prefs.FindPreference(kPrefName); | |
| 144 ASSERT_TRUE(pref); | |
| 145 const base::Value* value = pref->GetValue(); | |
| 146 ASSERT_TRUE(value); | |
| 147 EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType()); | |
| 148 int actual_int_value = -1; | |
| 149 EXPECT_TRUE(value->GetAsInteger(&actual_int_value)); | |
| 150 EXPECT_EQ(kTestValue, actual_int_value); | |
| 151 } | |
| 152 | |
| 153 TEST(PrefServiceTest, GetValueAndGetRecommendedValue) { | |
| 154 const int kDefaultValue = 5; | |
| 155 const int kUserValue = 10; | |
| 156 const int kRecommendedValue = 15; | |
| 157 TestingPrefServiceSimple prefs; | |
| 158 prefs.registry()->RegisterIntegerPref(kPrefName, kDefaultValue); | |
| 159 | |
| 160 // Create pref with a default value only. | |
| 161 const PrefService::Preference* pref = prefs.FindPreference(kPrefName); | |
| 162 ASSERT_TRUE(pref); | |
| 163 | |
| 164 // Check that GetValue() returns the default value. | |
| 165 const base::Value* value = pref->GetValue(); | |
| 166 ASSERT_TRUE(value); | |
| 167 EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType()); | |
| 168 int actual_int_value = -1; | |
| 169 EXPECT_TRUE(value->GetAsInteger(&actual_int_value)); | |
| 170 EXPECT_EQ(kDefaultValue, actual_int_value); | |
| 171 | |
| 172 // Check that GetRecommendedValue() returns no value. | |
| 173 value = pref->GetRecommendedValue(); | |
| 174 ASSERT_FALSE(value); | |
| 175 | |
| 176 // Set a user-set value. | |
| 177 prefs.SetUserPref(kPrefName, new base::FundamentalValue(kUserValue)); | |
| 178 | |
| 179 // Check that GetValue() returns the user-set value. | |
| 180 value = pref->GetValue(); | |
| 181 ASSERT_TRUE(value); | |
| 182 EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType()); | |
| 183 actual_int_value = -1; | |
| 184 EXPECT_TRUE(value->GetAsInteger(&actual_int_value)); | |
| 185 EXPECT_EQ(kUserValue, actual_int_value); | |
| 186 | |
| 187 // Check that GetRecommendedValue() returns no value. | |
| 188 value = pref->GetRecommendedValue(); | |
| 189 ASSERT_FALSE(value); | |
| 190 | |
| 191 // Set a recommended value. | |
| 192 prefs.SetRecommendedPref(kPrefName, | |
| 193 new base::FundamentalValue(kRecommendedValue)); | |
| 194 | |
| 195 // Check that GetValue() returns the user-set value. | |
| 196 value = pref->GetValue(); | |
| 197 ASSERT_TRUE(value); | |
| 198 EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType()); | |
| 199 actual_int_value = -1; | |
| 200 EXPECT_TRUE(value->GetAsInteger(&actual_int_value)); | |
| 201 EXPECT_EQ(kUserValue, actual_int_value); | |
| 202 | |
| 203 // Check that GetRecommendedValue() returns the recommended value. | |
| 204 value = pref->GetRecommendedValue(); | |
| 205 ASSERT_TRUE(value); | |
| 206 EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType()); | |
| 207 actual_int_value = -1; | |
| 208 EXPECT_TRUE(value->GetAsInteger(&actual_int_value)); | |
| 209 EXPECT_EQ(kRecommendedValue, actual_int_value); | |
| 210 | |
| 211 // Remove the user-set value. | |
| 212 prefs.RemoveUserPref(kPrefName); | |
| 213 | |
| 214 // Check that GetValue() returns the recommended value. | |
| 215 value = pref->GetValue(); | |
| 216 ASSERT_TRUE(value); | |
| 217 EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType()); | |
| 218 actual_int_value = -1; | |
| 219 EXPECT_TRUE(value->GetAsInteger(&actual_int_value)); | |
| 220 EXPECT_EQ(kRecommendedValue, actual_int_value); | |
| 221 | |
| 222 // Check that GetRecommendedValue() returns the recommended value. | |
| 223 value = pref->GetRecommendedValue(); | |
| 224 ASSERT_TRUE(value); | |
| 225 EXPECT_EQ(base::Value::TYPE_INTEGER, value->GetType()); | |
| 226 actual_int_value = -1; | |
| 227 EXPECT_TRUE(value->GetAsInteger(&actual_int_value)); | |
| 228 EXPECT_EQ(kRecommendedValue, actual_int_value); | |
| 229 } | |
| 230 | |
| 231 // A PrefStore which just stores the last write flags that were used to write | |
| 232 // values to it. | |
| 233 class WriteFlagChecker : public TestingPrefStore { | |
| 234 public: | |
| 235 WriteFlagChecker() {} | |
| 236 | |
| 237 void ReportValueChanged(const std::string& key, uint32 flags) override { | |
| 238 SetLastWriteFlags(flags); | |
| 239 } | |
| 240 | |
| 241 void SetValue(const std::string& key, | |
| 242 scoped_ptr<base::Value> value, | |
| 243 uint32 flags) override { | |
| 244 SetLastWriteFlags(flags); | |
| 245 } | |
| 246 | |
| 247 void SetValueSilently(const std::string& key, | |
| 248 scoped_ptr<base::Value> value, | |
| 249 uint32 flags) override { | |
| 250 SetLastWriteFlags(flags); | |
| 251 } | |
| 252 | |
| 253 void RemoveValue(const std::string& key, uint32 flags) override { | |
| 254 SetLastWriteFlags(flags); | |
| 255 } | |
| 256 | |
| 257 uint32 GetLastFlagsAndClear() { | |
| 258 CHECK(last_write_flags_set_); | |
| 259 uint32 result = last_write_flags_; | |
| 260 last_write_flags_set_ = false; | |
| 261 last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS; | |
| 262 return result; | |
| 263 } | |
| 264 | |
| 265 bool last_write_flags_set() { return last_write_flags_set_; } | |
| 266 | |
| 267 private: | |
| 268 ~WriteFlagChecker() override {} | |
| 269 | |
| 270 void SetLastWriteFlags(uint32 flags) { | |
| 271 CHECK(!last_write_flags_set_); | |
| 272 last_write_flags_set_ = true; | |
| 273 last_write_flags_ = flags; | |
| 274 } | |
| 275 | |
| 276 bool last_write_flags_set_ = false; | |
| 277 uint32 last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS; | |
| 278 }; | |
| 279 | |
| 280 TEST(PrefServiceTest, WriteablePrefStoreFlags) { | |
| 281 scoped_refptr<WriteFlagChecker> flag_checker(new WriteFlagChecker); | |
| 282 scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple); | |
| 283 base::PrefServiceFactory factory; | |
| 284 factory.set_user_prefs(flag_checker); | |
| 285 scoped_ptr<PrefService> prefs(factory.Create(registry.get())); | |
| 286 | |
| 287 // The first 8 bits of write flags are reserved for subclasses. Create a | |
| 288 // custom flag in this range | |
| 289 uint32 kCustomRegistrationFlag = 1 << 2; | |
| 290 | |
| 291 // A map of the registration flags that will be tested and the write flags | |
| 292 // they are expected to convert to. | |
| 293 struct RegistrationToWriteFlags { | |
| 294 const char* pref_name; | |
| 295 uint32 registration_flags; | |
| 296 uint32 write_flags; | |
| 297 }; | |
| 298 const RegistrationToWriteFlags kRegistrationToWriteFlags[] = { | |
| 299 {"none", | |
| 300 PrefRegistry::NO_REGISTRATION_FLAGS, | |
| 301 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS}, | |
| 302 {"lossy", | |
| 303 PrefRegistry::LOSSY_PREF, | |
| 304 WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}, | |
| 305 {"custom", | |
| 306 kCustomRegistrationFlag, | |
| 307 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS}, | |
| 308 {"lossyandcustom", | |
| 309 PrefRegistry::LOSSY_PREF | kCustomRegistrationFlag, | |
| 310 WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}}; | |
| 311 | |
| 312 for (size_t i = 0; i < arraysize(kRegistrationToWriteFlags); ++i) { | |
| 313 RegistrationToWriteFlags entry = kRegistrationToWriteFlags[i]; | |
| 314 registry->RegisterDictionaryPref( | |
| 315 entry.pref_name, new base::DictionaryValue(), entry.registration_flags); | |
| 316 | |
| 317 SCOPED_TRACE("Currently testing pref with name: " + | |
| 318 std::string(entry.pref_name)); | |
| 319 | |
| 320 prefs->GetMutableUserPref(entry.pref_name, base::Value::TYPE_DICTIONARY); | |
| 321 EXPECT_TRUE(flag_checker->last_write_flags_set()); | |
| 322 EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear()); | |
| 323 | |
| 324 prefs->ReportUserPrefChanged(entry.pref_name); | |
| 325 EXPECT_TRUE(flag_checker->last_write_flags_set()); | |
| 326 EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear()); | |
| 327 | |
| 328 prefs->ClearPref(entry.pref_name); | |
| 329 EXPECT_TRUE(flag_checker->last_write_flags_set()); | |
| 330 EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear()); | |
| 331 | |
| 332 prefs->SetUserPrefValue(entry.pref_name, new base::DictionaryValue()); | |
| 333 EXPECT_TRUE(flag_checker->last_write_flags_set()); | |
| 334 EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear()); | |
| 335 } | |
| 336 } | |
| 337 | |
| 338 class PrefServiceSetValueTest : public testing::Test { | |
| 339 protected: | |
| 340 static const char kName[]; | |
| 341 static const char kValue[]; | |
| 342 | |
| 343 PrefServiceSetValueTest() : observer_(&prefs_) {} | |
| 344 | |
| 345 TestingPrefServiceSimple prefs_; | |
| 346 MockPrefChangeCallback observer_; | |
| 347 }; | |
| 348 | |
| 349 const char PrefServiceSetValueTest::kName[] = "name"; | |
| 350 const char PrefServiceSetValueTest::kValue[] = "value"; | |
| 351 | |
| 352 TEST_F(PrefServiceSetValueTest, SetStringValue) { | |
| 353 const char default_string[] = "default"; | |
| 354 const base::StringValue default_value(default_string); | |
| 355 prefs_.registry()->RegisterStringPref(kName, default_string); | |
| 356 | |
| 357 PrefChangeRegistrar registrar; | |
| 358 registrar.Init(&prefs_); | |
| 359 registrar.Add(kName, observer_.GetCallback()); | |
| 360 | |
| 361 // Changing the controlling store from default to user triggers notification. | |
| 362 observer_.Expect(kName, &default_value); | |
| 363 prefs_.Set(kName, default_value); | |
| 364 Mock::VerifyAndClearExpectations(&observer_); | |
| 365 | |
| 366 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0); | |
| 367 prefs_.Set(kName, default_value); | |
| 368 Mock::VerifyAndClearExpectations(&observer_); | |
| 369 | |
| 370 base::StringValue new_value(kValue); | |
| 371 observer_.Expect(kName, &new_value); | |
| 372 prefs_.Set(kName, new_value); | |
| 373 Mock::VerifyAndClearExpectations(&observer_); | |
| 374 } | |
| 375 | |
| 376 TEST_F(PrefServiceSetValueTest, SetDictionaryValue) { | |
| 377 prefs_.registry()->RegisterDictionaryPref(kName); | |
| 378 PrefChangeRegistrar registrar; | |
| 379 registrar.Init(&prefs_); | |
| 380 registrar.Add(kName, observer_.GetCallback()); | |
| 381 | |
| 382 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0); | |
| 383 prefs_.RemoveUserPref(kName); | |
| 384 Mock::VerifyAndClearExpectations(&observer_); | |
| 385 | |
| 386 base::DictionaryValue new_value; | |
| 387 new_value.SetString(kName, kValue); | |
| 388 observer_.Expect(kName, &new_value); | |
| 389 prefs_.Set(kName, new_value); | |
| 390 Mock::VerifyAndClearExpectations(&observer_); | |
| 391 | |
| 392 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0); | |
| 393 prefs_.Set(kName, new_value); | |
| 394 Mock::VerifyAndClearExpectations(&observer_); | |
| 395 | |
| 396 base::DictionaryValue empty; | |
| 397 observer_.Expect(kName, &empty); | |
| 398 prefs_.Set(kName, empty); | |
| 399 Mock::VerifyAndClearExpectations(&observer_); | |
| 400 } | |
| 401 | |
| 402 TEST_F(PrefServiceSetValueTest, SetListValue) { | |
| 403 prefs_.registry()->RegisterListPref(kName); | |
| 404 PrefChangeRegistrar registrar; | |
| 405 registrar.Init(&prefs_); | |
| 406 registrar.Add(kName, observer_.GetCallback()); | |
| 407 | |
| 408 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0); | |
| 409 prefs_.RemoveUserPref(kName); | |
| 410 Mock::VerifyAndClearExpectations(&observer_); | |
| 411 | |
| 412 base::ListValue new_value; | |
| 413 new_value.Append(new base::StringValue(kValue)); | |
| 414 observer_.Expect(kName, &new_value); | |
| 415 prefs_.Set(kName, new_value); | |
| 416 Mock::VerifyAndClearExpectations(&observer_); | |
| 417 | |
| 418 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0); | |
| 419 prefs_.Set(kName, new_value); | |
| 420 Mock::VerifyAndClearExpectations(&observer_); | |
| 421 | |
| 422 base::ListValue empty; | |
| 423 observer_.Expect(kName, &empty); | |
| 424 prefs_.Set(kName, empty); | |
| 425 Mock::VerifyAndClearExpectations(&observer_); | |
| 426 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
