| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/prefs/pref_value_store.h" |
| |
| #include <memory> |
| #include <string> |
| |
| #include "base/bind.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/values.h" |
| #include "components/prefs/pref_notifier.h" |
| #include "components/prefs/testing_pref_store.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| using testing::Mock; |
| using testing::_; |
| |
| namespace { |
| |
| // Allows to capture pref notifications through gmock. |
| class MockPrefNotifier : public PrefNotifier { |
| public: |
| MOCK_METHOD1(OnPreferenceChanged, void(const std::string&)); |
| MOCK_METHOD1(OnInitializationCompleted, void(bool)); |
| }; |
| |
| // Allows to capture sync model associator interaction. |
| class MockPrefModelAssociator { |
| public: |
| MOCK_METHOD1(ProcessPrefChange, void(const std::string&)); |
| }; |
| |
| } // namespace |
| |
| // Names of the preferences used in this test. |
| namespace prefs { |
| const char kManagedPref[] = "this.pref.managed"; |
| const char kSupervisedUserPref[] = "this.pref.supervised_user"; |
| const char kCommandLinePref[] = "this.pref.command_line"; |
| const char kExtensionPref[] = "this.pref.extension"; |
| const char kUserPref[] = "this.pref.user"; |
| const char kRecommendedPref[] = "this.pref.recommended"; |
| const char kDefaultPref[] = "this.pref.default"; |
| const char kMissingPref[] = "this.pref.does_not_exist"; |
| } // namespace prefs |
| |
| // Potentially expected values of all preferences used in this test program. |
| namespace managed_pref { |
| const char kManagedValue[] = "managed:managed"; |
| } |
| |
| namespace supervised_user_pref { |
| const char kManagedValue[] = "supervised_user:managed"; |
| const char kSupervisedUserValue[] = "supervised_user:supervised_user"; |
| } // namespace supervised_user_pref |
| |
| namespace extension_pref { |
| const char kManagedValue[] = "extension:managed"; |
| const char kSupervisedUserValue[] = "extension:supervised_user"; |
| const char kExtensionValue[] = "extension:extension"; |
| } // namespace extension_pref |
| |
| namespace command_line_pref { |
| const char kManagedValue[] = "command_line:managed"; |
| const char kSupervisedUserValue[] = "command_line:supervised_user"; |
| const char kExtensionValue[] = "command_line:extension"; |
| const char kCommandLineValue[] = "command_line:command_line"; |
| } // namespace command_line_pref |
| |
| namespace user_pref { |
| const char kManagedValue[] = "user:managed"; |
| const char kSupervisedUserValue[] = "supervised_user:supervised_user"; |
| const char kExtensionValue[] = "user:extension"; |
| const char kCommandLineValue[] = "user:command_line"; |
| const char kUserValue[] = "user:user"; |
| } // namespace user_pref |
| |
| namespace recommended_pref { |
| const char kManagedValue[] = "recommended:managed"; |
| const char kSupervisedUserValue[] = "recommended:supervised_user"; |
| const char kExtensionValue[] = "recommended:extension"; |
| const char kCommandLineValue[] = "recommended:command_line"; |
| const char kUserValue[] = "recommended:user"; |
| const char kRecommendedValue[] = "recommended:recommended"; |
| } // namespace recommended_pref |
| |
| namespace default_pref { |
| const char kManagedValue[] = "default:managed"; |
| const char kSupervisedUserValue[] = "default:supervised_user"; |
| const char kExtensionValue[] = "default:extension"; |
| const char kCommandLineValue[] = "default:command_line"; |
| const char kUserValue[] = "default:user"; |
| const char kRecommendedValue[] = "default:recommended"; |
| const char kDefaultValue[] = "default:default"; |
| } // namespace default_pref |
| |
| class PrefValueStoreTest : public testing::Test { |
| protected: |
| void SetUp() override { |
| // Create TestingPrefStores. |
| CreateManagedPrefs(); |
| CreateSupervisedUserPrefs(); |
| CreateExtensionPrefs(); |
| CreateCommandLinePrefs(); |
| CreateUserPrefs(); |
| CreateRecommendedPrefs(); |
| CreateDefaultPrefs(); |
| sync_associator_.reset(new MockPrefModelAssociator()); |
| |
| // Create a fresh PrefValueStore. |
| pref_value_store_.reset(new PrefValueStore( |
| managed_pref_store_.get(), supervised_user_pref_store_.get(), |
| extension_pref_store_.get(), command_line_pref_store_.get(), |
| user_pref_store_.get(), recommended_pref_store_.get(), |
| default_pref_store_.get(), &pref_notifier_)); |
| |
| pref_value_store_->set_callback( |
| base::Bind(&MockPrefModelAssociator::ProcessPrefChange, |
| base::Unretained(sync_associator_.get()))); |
| } |
| |
| void CreateManagedPrefs() { |
| managed_pref_store_ = new TestingPrefStore; |
| managed_pref_store_->SetString(prefs::kManagedPref, |
| managed_pref::kManagedValue); |
| } |
| |
| void CreateSupervisedUserPrefs() { |
| supervised_user_pref_store_ = new TestingPrefStore; |
| supervised_user_pref_store_->SetString(prefs::kManagedPref, |
| supervised_user_pref::kManagedValue); |
| supervised_user_pref_store_->SetString( |
| prefs::kSupervisedUserPref, supervised_user_pref::kSupervisedUserValue); |
| } |
| |
| void CreateExtensionPrefs() { |
| extension_pref_store_ = new TestingPrefStore; |
| extension_pref_store_->SetString(prefs::kManagedPref, |
| extension_pref::kManagedValue); |
| extension_pref_store_->SetString(prefs::kSupervisedUserPref, |
| extension_pref::kSupervisedUserValue); |
| extension_pref_store_->SetString(prefs::kExtensionPref, |
| extension_pref::kExtensionValue); |
| } |
| |
| void CreateCommandLinePrefs() { |
| command_line_pref_store_ = new TestingPrefStore; |
| |
| command_line_pref_store_->SetString(prefs::kManagedPref, |
| command_line_pref::kManagedValue); |
| command_line_pref_store_->SetString( |
| prefs::kSupervisedUserPref, command_line_pref::kSupervisedUserValue); |
| command_line_pref_store_->SetString(prefs::kExtensionPref, |
| command_line_pref::kExtensionValue); |
| command_line_pref_store_->SetString(prefs::kCommandLinePref, |
| command_line_pref::kCommandLineValue); |
| } |
| |
| void CreateUserPrefs() { |
| user_pref_store_ = new TestingPrefStore; |
| user_pref_store_->SetString(prefs::kManagedPref, user_pref::kManagedValue); |
| user_pref_store_->SetString(prefs::kSupervisedUserPref, |
| user_pref::kSupervisedUserValue); |
| user_pref_store_->SetString(prefs::kCommandLinePref, |
| user_pref::kCommandLineValue); |
| user_pref_store_->SetString(prefs::kExtensionPref, |
| user_pref::kExtensionValue); |
| user_pref_store_->SetString(prefs::kUserPref, user_pref::kUserValue); |
| } |
| |
| void CreateRecommendedPrefs() { |
| recommended_pref_store_ = new TestingPrefStore; |
| recommended_pref_store_->SetString(prefs::kManagedPref, |
| recommended_pref::kManagedValue); |
| recommended_pref_store_->SetString(prefs::kSupervisedUserPref, |
| recommended_pref::kSupervisedUserValue); |
| recommended_pref_store_->SetString(prefs::kCommandLinePref, |
| recommended_pref::kCommandLineValue); |
| recommended_pref_store_->SetString(prefs::kExtensionPref, |
| recommended_pref::kExtensionValue); |
| recommended_pref_store_->SetString(prefs::kUserPref, |
| recommended_pref::kUserValue); |
| recommended_pref_store_->SetString(prefs::kRecommendedPref, |
| recommended_pref::kRecommendedValue); |
| } |
| |
| void CreateDefaultPrefs() { |
| default_pref_store_ = new TestingPrefStore; |
| default_pref_store_->SetString(prefs::kSupervisedUserPref, |
| default_pref::kSupervisedUserValue); |
| default_pref_store_->SetString(prefs::kManagedPref, |
| default_pref::kManagedValue); |
| default_pref_store_->SetString(prefs::kCommandLinePref, |
| default_pref::kCommandLineValue); |
| default_pref_store_->SetString(prefs::kExtensionPref, |
| default_pref::kExtensionValue); |
| default_pref_store_->SetString(prefs::kUserPref, default_pref::kUserValue); |
| default_pref_store_->SetString(prefs::kRecommendedPref, |
| default_pref::kRecommendedValue); |
| default_pref_store_->SetString(prefs::kDefaultPref, |
| default_pref::kDefaultValue); |
| } |
| |
| void ExpectValueChangeNotifications(const std::string& name) { |
| EXPECT_CALL(pref_notifier_, OnPreferenceChanged(name)); |
| EXPECT_CALL(*sync_associator_, ProcessPrefChange(name)); |
| } |
| |
| void CheckAndClearValueChangeNotifications() { |
| Mock::VerifyAndClearExpectations(&pref_notifier_); |
| Mock::VerifyAndClearExpectations(sync_associator_.get()); |
| } |
| |
| MockPrefNotifier pref_notifier_; |
| std::unique_ptr<MockPrefModelAssociator> sync_associator_; |
| std::unique_ptr<PrefValueStore> pref_value_store_; |
| |
| scoped_refptr<TestingPrefStore> managed_pref_store_; |
| scoped_refptr<TestingPrefStore> supervised_user_pref_store_; |
| scoped_refptr<TestingPrefStore> extension_pref_store_; |
| scoped_refptr<TestingPrefStore> command_line_pref_store_; |
| scoped_refptr<TestingPrefStore> user_pref_store_; |
| scoped_refptr<TestingPrefStore> recommended_pref_store_; |
| scoped_refptr<TestingPrefStore> default_pref_store_; |
| }; |
| |
| TEST_F(PrefValueStoreTest, GetValue) { |
| const base::Value* value; |
| |
| // The following tests read a value from the PrefService. The preferences are |
| // set in a way such that all lower-priority stores have a value and we can |
| // test whether overrides work correctly. |
| |
| // Test getting a managed value. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetValue(prefs::kManagedPref, |
| base::Value::Type::STRING, &value)); |
| std::string actual_str_value; |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(managed_pref::kManagedValue, actual_str_value); |
| |
| // Test getting a supervised user value. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetValue(prefs::kSupervisedUserPref, |
| base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(supervised_user_pref::kSupervisedUserValue, actual_str_value); |
| |
| // Test getting an extension value. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetValue(prefs::kExtensionPref, |
| base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(extension_pref::kExtensionValue, actual_str_value); |
| |
| // Test getting a command-line value. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetValue(prefs::kCommandLinePref, |
| base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(command_line_pref::kCommandLineValue, actual_str_value); |
| |
| // Test getting a user-set value. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetValue(prefs::kUserPref, |
| base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(user_pref::kUserValue, actual_str_value); |
| |
| // Test getting a user set value overwriting a recommended value. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetValue(prefs::kRecommendedPref, |
| base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(recommended_pref::kRecommendedValue, actual_str_value); |
| |
| // Test getting a default value. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDefaultPref, |
| base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(default_pref::kDefaultValue, actual_str_value); |
| |
| // Test getting a preference value that the |PrefValueStore| |
| // does not contain. |
| base::Value tmp_dummy_value(true); |
| value = &tmp_dummy_value; |
| ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref, |
| base::Value::Type::STRING, &value)); |
| ASSERT_FALSE(value); |
| } |
| |
| TEST_F(PrefValueStoreTest, GetRecommendedValue) { |
| const base::Value* value; |
| |
| // The following tests read a value from the PrefService. The preferences are |
| // set in a way such that all lower-priority stores have a value and we can |
| // test whether overrides do not clutter the recommended value. |
| |
| // Test getting recommended value when a managed value is present. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetRecommendedValue( |
| prefs::kManagedPref, base::Value::Type::STRING, &value)); |
| std::string actual_str_value; |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(recommended_pref::kManagedValue, actual_str_value); |
| |
| // Test getting recommended value when a supervised user value is present. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetRecommendedValue( |
| prefs::kSupervisedUserPref, base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(recommended_pref::kSupervisedUserValue, actual_str_value); |
| |
| // Test getting recommended value when an extension value is present. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetRecommendedValue( |
| prefs::kExtensionPref, base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(recommended_pref::kExtensionValue, actual_str_value); |
| |
| // Test getting recommended value when a command-line value is present. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetRecommendedValue( |
| prefs::kCommandLinePref, base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(recommended_pref::kCommandLineValue, actual_str_value); |
| |
| // Test getting recommended value when a user-set value is present. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetRecommendedValue( |
| prefs::kUserPref, base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(recommended_pref::kUserValue, actual_str_value); |
| |
| // Test getting recommended value when no higher-priority value is present. |
| value = nullptr; |
| ASSERT_TRUE(pref_value_store_->GetRecommendedValue( |
| prefs::kRecommendedPref, base::Value::Type::STRING, &value)); |
| EXPECT_TRUE(value->GetAsString(&actual_str_value)); |
| EXPECT_EQ(recommended_pref::kRecommendedValue, actual_str_value); |
| |
| // Test getting recommended value when no recommended value is present. |
| base::Value tmp_dummy_value(true); |
| value = &tmp_dummy_value; |
| ASSERT_FALSE(pref_value_store_->GetRecommendedValue( |
| prefs::kDefaultPref, base::Value::Type::STRING, &value)); |
| ASSERT_FALSE(value); |
| |
| // Test getting a preference value that the |PrefValueStore| |
| // does not contain. |
| value = &tmp_dummy_value; |
| ASSERT_FALSE(pref_value_store_->GetRecommendedValue( |
| prefs::kMissingPref, base::Value::Type::STRING, &value)); |
| ASSERT_FALSE(value); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefChanges) { |
| // Check pref controlled by highest-priority store. |
| ExpectValueChangeNotifications(prefs::kManagedPref); |
| managed_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kManagedPref); |
| supervised_user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kManagedPref); |
| extension_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kManagedPref); |
| command_line_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kManagedPref); |
| user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kManagedPref); |
| recommended_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kManagedPref); |
| default_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| // Check pref controlled by user store. |
| ExpectValueChangeNotifications(prefs::kUserPref); |
| managed_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kUserPref); |
| extension_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kUserPref); |
| command_line_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kUserPref); |
| user_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kUserPref); |
| recommended_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kUserPref); |
| default_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| // Check pref controlled by default-pref store. |
| ExpectValueChangeNotifications(prefs::kDefaultPref); |
| managed_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kDefaultPref); |
| extension_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kDefaultPref); |
| command_line_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kDefaultPref); |
| user_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kDefaultPref); |
| recommended_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); |
| CheckAndClearValueChangeNotifications(); |
| |
| ExpectValueChangeNotifications(prefs::kDefaultPref); |
| default_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); |
| CheckAndClearValueChangeNotifications(); |
| } |
| |
| TEST_F(PrefValueStoreTest, OnInitializationCompleted) { |
| EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(0); |
| managed_pref_store_->SetInitializationCompleted(); |
| supervised_user_pref_store_->SetInitializationCompleted(); |
| extension_pref_store_->SetInitializationCompleted(); |
| command_line_pref_store_->SetInitializationCompleted(); |
| recommended_pref_store_->SetInitializationCompleted(); |
| default_pref_store_->SetInitializationCompleted(); |
| Mock::VerifyAndClearExpectations(&pref_notifier_); |
| |
| // The notification should only be triggered after the last store is done. |
| EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(1); |
| user_pref_store_->SetInitializationCompleted(); |
| Mock::VerifyAndClearExpectations(&pref_notifier_); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueInManagedStore) { |
| EXPECT_TRUE(pref_value_store_->PrefValueInManagedStore(prefs::kManagedPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInManagedStore(prefs::kSupervisedUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInManagedStore(prefs::kExtensionPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInManagedStore(prefs::kCommandLinePref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(prefs::kUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInManagedStore(prefs::kRecommendedPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(prefs::kDefaultPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(prefs::kMissingPref)); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueInExtensionStore) { |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueInExtensionStore(prefs::kManagedPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueInExtensionStore(prefs::kSupervisedUserPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueInExtensionStore(prefs::kExtensionPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInExtensionStore(prefs::kCommandLinePref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(prefs::kUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInExtensionStore(prefs::kRecommendedPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInExtensionStore(prefs::kDefaultPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInExtensionStore(prefs::kMissingPref)); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueInUserStore) { |
| EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(prefs::kManagedPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueInUserStore(prefs::kSupervisedUserPref)); |
| EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(prefs::kExtensionPref)); |
| EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(prefs::kCommandLinePref)); |
| EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(prefs::kUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueInUserStore(prefs::kRecommendedPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(prefs::kDefaultPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(prefs::kMissingPref)); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueFromExtensionStore) { |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromExtensionStore(prefs::kManagedPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore( |
| prefs::kSupervisedUserPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueFromExtensionStore(prefs::kExtensionPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromExtensionStore(prefs::kCommandLinePref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromExtensionStore(prefs::kUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromExtensionStore(prefs::kRecommendedPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromExtensionStore(prefs::kDefaultPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromExtensionStore(prefs::kMissingPref)); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueFromUserStore) { |
| EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kManagedPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromUserStore(prefs::kSupervisedUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromUserStore(prefs::kExtensionPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromUserStore(prefs::kCommandLinePref)); |
| EXPECT_TRUE(pref_value_store_->PrefValueFromUserStore(prefs::kUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromUserStore(prefs::kRecommendedPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kDefaultPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kMissingPref)); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueFromRecommendedStore) { |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromRecommendedStore(prefs::kManagedPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore( |
| prefs::kSupervisedUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromRecommendedStore(prefs::kExtensionPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore( |
| prefs::kCommandLinePref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromRecommendedStore(prefs::kUserPref)); |
| EXPECT_TRUE(pref_value_store_->PrefValueFromRecommendedStore( |
| prefs::kRecommendedPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromRecommendedStore(prefs::kDefaultPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromRecommendedStore(prefs::kMissingPref)); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueFromDefaultStore) { |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromDefaultStore(prefs::kManagedPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromDefaultStore(prefs::kSupervisedUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromDefaultStore(prefs::kExtensionPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromDefaultStore(prefs::kCommandLinePref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(prefs::kUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromDefaultStore(prefs::kRecommendedPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueFromDefaultStore(prefs::kDefaultPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueFromDefaultStore(prefs::kMissingPref)); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueUserModifiable) { |
| EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(prefs::kManagedPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueUserModifiable(prefs::kSupervisedUserPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueUserModifiable(prefs::kExtensionPref)); |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueUserModifiable(prefs::kCommandLinePref)); |
| EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(prefs::kUserPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueUserModifiable(prefs::kRecommendedPref)); |
| EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(prefs::kDefaultPref)); |
| EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(prefs::kMissingPref)); |
| } |
| |
| TEST_F(PrefValueStoreTest, PrefValueExtensionModifiable) { |
| EXPECT_FALSE( |
| pref_value_store_->PrefValueExtensionModifiable(prefs::kManagedPref)); |
| EXPECT_FALSE(pref_value_store_->PrefValueExtensionModifiable( |
| prefs::kSupervisedUserPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueExtensionModifiable(prefs::kExtensionPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueExtensionModifiable(prefs::kCommandLinePref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueExtensionModifiable(prefs::kUserPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueExtensionModifiable(prefs::kRecommendedPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueExtensionModifiable(prefs::kDefaultPref)); |
| EXPECT_TRUE( |
| pref_value_store_->PrefValueExtensionModifiable(prefs::kMissingPref)); |
| } |
