1// Copyright (c) 2010 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/bind.h"
6#include "base/bind_helpers.h"
7#include "base/prefs/pref_change_registrar.h"
8#include "base/prefs/pref_observer.h"
9#include "base/prefs/pref_registry_simple.h"
10#include "base/prefs/testing_pref_service.h"
11#include "testing/gmock/include/gmock/gmock.h"
12#include "testing/gtest/include/gtest/gtest.h"
13
14using testing::Mock;
15using testing::Eq;
16
17namespace base {
18namespace {
19
20const char kHomePage[] = "homepage";
21const char kHomePageIsNewTabPage[] = "homepage_is_newtabpage";
22const char kApplicationLocale[] = "intl.app_locale";
23
24// A mock provider that allows us to capture pref observer changes.
25class MockPrefService : public TestingPrefServiceSimple {
26 public:
27  MockPrefService() {}
28  virtual ~MockPrefService() {}
29
30  MOCK_METHOD2(AddPrefObserver,
31               void(const char*, PrefObserver*));
32  MOCK_METHOD2(RemovePrefObserver,
33               void(const char*, PrefObserver*));
34};
35
36}  // namespace
37
38class PrefChangeRegistrarTest : public testing::Test {
39 public:
40  PrefChangeRegistrarTest() {}
41  virtual ~PrefChangeRegistrarTest() {}
42
43 protected:
44  virtual void SetUp() OVERRIDE;
45
46  base::Closure observer() const {
47    return base::Bind(&base::DoNothing);
48  }
49
50  MockPrefService* service() const { return service_.get(); }
51
52 private:
53  scoped_ptr<MockPrefService> service_;
54};
55
56void PrefChangeRegistrarTest::SetUp() {
57  service_.reset(new MockPrefService());
58}
59
60TEST_F(PrefChangeRegistrarTest, AddAndRemove) {
61  PrefChangeRegistrar registrar;
62  registrar.Init(service());
63
64  // Test adding.
65  EXPECT_CALL(*service(),
66              AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
67  EXPECT_CALL(*service(),
68              AddPrefObserver(Eq(std::string("test.pref.2")), &registrar));
69  registrar.Add("test.pref.1", observer());
70  registrar.Add("test.pref.2", observer());
71  EXPECT_FALSE(registrar.IsEmpty());
72
73  // Test removing.
74  Mock::VerifyAndClearExpectations(service());
75  EXPECT_CALL(*service(),
76              RemovePrefObserver(Eq(std::string("test.pref.1")), &registrar));
77  EXPECT_CALL(*service(),
78              RemovePrefObserver(Eq(std::string("test.pref.2")), &registrar));
79  registrar.Remove("test.pref.1");
80  registrar.Remove("test.pref.2");
81  EXPECT_TRUE(registrar.IsEmpty());
82
83  // Explicitly check the expectations now to make sure that the Removes
84  // worked (rather than the registrar destructor doing the work).
85  Mock::VerifyAndClearExpectations(service());
86}
87
88TEST_F(PrefChangeRegistrarTest, AutoRemove) {
89  PrefChangeRegistrar registrar;
90  registrar.Init(service());
91
92  // Setup of auto-remove.
93  EXPECT_CALL(*service(),
94              AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
95  registrar.Add("test.pref.1", observer());
96  Mock::VerifyAndClearExpectations(service());
97  EXPECT_FALSE(registrar.IsEmpty());
98
99  // Test auto-removing.
100  EXPECT_CALL(*service(),
101              RemovePrefObserver(Eq(std::string("test.pref.1")), &registrar));
102}
103
104TEST_F(PrefChangeRegistrarTest, RemoveAll) {
105  PrefChangeRegistrar registrar;
106  registrar.Init(service());
107
108  EXPECT_CALL(*service(),
109              AddPrefObserver(Eq(std::string("test.pref.1")), &registrar));
110  EXPECT_CALL(*service(),
111              AddPrefObserver(Eq(std::string("test.pref.2")), &registrar));
112  registrar.Add("test.pref.1", observer());
113  registrar.Add("test.pref.2", observer());
114  Mock::VerifyAndClearExpectations(service());
115
116  EXPECT_CALL(*service(),
117              RemovePrefObserver(Eq(std::string("test.pref.1")), &registrar));
118  EXPECT_CALL(*service(),
119              RemovePrefObserver(Eq(std::string("test.pref.2")), &registrar));
120  registrar.RemoveAll();
121  EXPECT_TRUE(registrar.IsEmpty());
122
123  // Explicitly check the expectations now to make sure that the RemoveAll
124  // worked (rather than the registrar destructor doing the work).
125  Mock::VerifyAndClearExpectations(service());
126}
127
128class ObserveSetOfPreferencesTest : public testing::Test {
129 public:
130  virtual void SetUp() {
131    pref_service_.reset(new TestingPrefServiceSimple);
132    PrefRegistrySimple* registry = pref_service_->registry();
133    registry->RegisterStringPref(kHomePage, "http://google.com");
134    registry->RegisterBooleanPref(kHomePageIsNewTabPage, false);
135    registry->RegisterStringPref(kApplicationLocale, std::string());
136  }
137
138  PrefChangeRegistrar* CreatePrefChangeRegistrar() {
139    PrefChangeRegistrar* pref_set = new PrefChangeRegistrar();
140    base::Closure callback = base::Bind(&base::DoNothing);
141    pref_set->Init(pref_service_.get());
142    pref_set->Add(kHomePage, callback);
143    pref_set->Add(kHomePageIsNewTabPage, callback);
144    return pref_set;
145  }
146
147  MOCK_METHOD1(OnPreferenceChanged, void(const std::string&));
148
149  scoped_ptr<TestingPrefServiceSimple> pref_service_;
150};
151
152TEST_F(ObserveSetOfPreferencesTest, IsObserved) {
153  scoped_ptr<PrefChangeRegistrar> pref_set(CreatePrefChangeRegistrar());
154  EXPECT_TRUE(pref_set->IsObserved(kHomePage));
155  EXPECT_TRUE(pref_set->IsObserved(kHomePageIsNewTabPage));
156  EXPECT_FALSE(pref_set->IsObserved(kApplicationLocale));
157}
158
159TEST_F(ObserveSetOfPreferencesTest, IsManaged) {
160  scoped_ptr<PrefChangeRegistrar> pref_set(CreatePrefChangeRegistrar());
161  EXPECT_FALSE(pref_set->IsManaged());
162  pref_service_->SetManagedPref(kHomePage,
163                                new StringValue("http://crbug.com"));
164  EXPECT_TRUE(pref_set->IsManaged());
165  pref_service_->SetManagedPref(kHomePageIsNewTabPage,
166                                new FundamentalValue(true));
167  EXPECT_TRUE(pref_set->IsManaged());
168  pref_service_->RemoveManagedPref(kHomePage);
169  EXPECT_TRUE(pref_set->IsManaged());
170  pref_service_->RemoveManagedPref(kHomePageIsNewTabPage);
171  EXPECT_FALSE(pref_set->IsManaged());
172}
173
174TEST_F(ObserveSetOfPreferencesTest, Observe) {
175  using testing::_;
176  using testing::Mock;
177
178  PrefChangeRegistrar pref_set;
179  PrefChangeRegistrar::NamedChangeCallback callback = base::Bind(
180      &ObserveSetOfPreferencesTest::OnPreferenceChanged,
181      base::Unretained(this));
182  pref_set.Init(pref_service_.get());
183  pref_set.Add(kHomePage, callback);
184  pref_set.Add(kHomePageIsNewTabPage, callback);
185
186  EXPECT_CALL(*this, OnPreferenceChanged(kHomePage));
187  pref_service_->SetUserPref(kHomePage, new StringValue("http://crbug.com"));
188  Mock::VerifyAndClearExpectations(this);
189
190  EXPECT_CALL(*this, OnPreferenceChanged(kHomePageIsNewTabPage));
191  pref_service_->SetUserPref(kHomePageIsNewTabPage,
192                             new FundamentalValue(true));
193  Mock::VerifyAndClearExpectations(this);
194
195  EXPECT_CALL(*this, OnPreferenceChanged(_)).Times(0);
196  pref_service_->SetUserPref(kApplicationLocale, new StringValue("en_US.utf8"));
197  Mock::VerifyAndClearExpectations(this);
198}
199
200}  // namespace base
201