blob: dff37f74f0f83c4ffe0f80f3fb46860245661170 [file] [log] [blame]
// 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));
}