1 // Copyright 2011 The Chromium Authors
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 "components/prefs/pref_member.h"
6
7 #include <memory>
8
9 #include "base/functional/bind.h"
10 #include "base/location.h"
11 #include "base/memory/raw_ptr.h"
12 #include "base/synchronization/waitable_event.h"
13 #include "base/task/sequenced_task_runner.h"
14 #include "base/task/thread_pool.h"
15 #include "base/test/task_environment.h"
16 #include "components/prefs/pref_registry_simple.h"
17 #include "components/prefs/testing_pref_service.h"
18 #include "testing/gtest/include/gtest/gtest.h"
19
20 namespace {
21
22 const char kBoolPref[] = "bool";
23 const char kIntPref[] = "int";
24 const char kDoublePref[] = "double";
25 const char kStringPref[] = "string";
26 const char kStringListPref[] = "string_list";
27
RegisterTestPrefs(PrefRegistrySimple * registry)28 void RegisterTestPrefs(PrefRegistrySimple* registry) {
29 registry->RegisterBooleanPref(kBoolPref, false);
30 registry->RegisterIntegerPref(kIntPref, 0);
31 registry->RegisterDoublePref(kDoublePref, 0.0);
32 registry->RegisterStringPref(kStringPref, "default");
33 registry->RegisterListPref(kStringListPref);
34 }
35
36 class GetPrefValueHelper
37 : public base::RefCountedThreadSafe<GetPrefValueHelper> {
38 public:
GetPrefValueHelper()39 GetPrefValueHelper()
40 : value_(false),
41 task_runner_(base::ThreadPool::CreateSequencedTaskRunner({})) {}
42
Init(const std::string & pref_name,PrefService * prefs)43 void Init(const std::string& pref_name, PrefService* prefs) {
44 pref_.Init(pref_name, prefs);
45 pref_.MoveToSequence(task_runner_);
46 }
47
Destroy()48 void Destroy() {
49 pref_.Destroy();
50 }
51
FetchValue()52 void FetchValue() {
53 base::WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
54 base::WaitableEvent::InitialState::NOT_SIGNALED);
55 ASSERT_TRUE(task_runner_->PostTask(
56 FROM_HERE,
57 base::BindOnce(&GetPrefValueHelper::GetPrefValue, this, &event)));
58 event.Wait();
59 }
60
value()61 bool value() { return value_; }
62
63 private:
64 friend class base::RefCountedThreadSafe<GetPrefValueHelper>;
~GetPrefValueHelper()65 ~GetPrefValueHelper() {}
66
GetPrefValue(base::WaitableEvent * event)67 void GetPrefValue(base::WaitableEvent* event) {
68 value_ = pref_.GetValue();
69 event->Signal();
70 }
71
72 BooleanPrefMember pref_;
73 bool value_;
74
75 // The sequence |pref_| runs on.
76 scoped_refptr<base::SequencedTaskRunner> task_runner_;
77 };
78
79 class PrefMemberTestClass {
80 public:
PrefMemberTestClass(PrefService * prefs)81 explicit PrefMemberTestClass(PrefService* prefs)
82 : observe_cnt_(0), prefs_(prefs) {
83 str_.Init(kStringPref, prefs,
84 base::BindRepeating(&PrefMemberTestClass::OnPreferenceChanged,
85 base::Unretained(this)));
86 }
87
OnPreferenceChanged(const std::string & pref_name)88 void OnPreferenceChanged(const std::string& pref_name) {
89 EXPECT_EQ(pref_name, kStringPref);
90 EXPECT_EQ(str_.GetValue(), prefs_->GetString(kStringPref));
91 EXPECT_EQ(str_.IsDefaultValue(),
92 prefs_->FindPreference(kStringPref)->IsDefaultValue());
93 ++observe_cnt_;
94 }
95
96 StringPrefMember str_;
97 int observe_cnt_;
98
99 private:
100 raw_ptr<PrefService> prefs_;
101 };
102
103 } // anonymous namespace
104
105 class PrefMemberTest : public testing::Test {
106 base::test::TaskEnvironment task_environment_;
107 };
108
TEST_F(PrefMemberTest,BasicGetAndSet)109 TEST_F(PrefMemberTest, BasicGetAndSet) {
110 TestingPrefServiceSimple prefs;
111 RegisterTestPrefs(prefs.registry());
112
113 // Test bool
114 BooleanPrefMember boolean;
115 boolean.Init(kBoolPref, &prefs);
116
117 // Check the defaults
118 EXPECT_FALSE(prefs.GetBoolean(kBoolPref));
119 EXPECT_FALSE(boolean.GetValue());
120 EXPECT_FALSE(*boolean);
121 EXPECT_TRUE(boolean.IsDefaultValue());
122
123 // Try changing through the member variable.
124 boolean.SetValue(true);
125 EXPECT_TRUE(boolean.GetValue());
126 EXPECT_TRUE(prefs.GetBoolean(kBoolPref));
127 EXPECT_TRUE(*boolean);
128 EXPECT_FALSE(boolean.IsDefaultValue());
129
130 // Try changing back through the pref.
131 prefs.SetBoolean(kBoolPref, false);
132 EXPECT_FALSE(prefs.GetBoolean(kBoolPref));
133 EXPECT_FALSE(boolean.GetValue());
134 EXPECT_FALSE(*boolean);
135 EXPECT_FALSE(boolean.IsDefaultValue());
136
137 // Test int
138 IntegerPrefMember integer;
139 integer.Init(kIntPref, &prefs);
140
141 // Check the defaults
142 EXPECT_EQ(0, prefs.GetInteger(kIntPref));
143 EXPECT_EQ(0, integer.GetValue());
144 EXPECT_EQ(0, *integer);
145 EXPECT_TRUE(integer.IsDefaultValue());
146
147 // Try changing through the member variable.
148 integer.SetValue(5);
149 EXPECT_EQ(5, integer.GetValue());
150 EXPECT_EQ(5, prefs.GetInteger(kIntPref));
151 EXPECT_EQ(5, *integer);
152 EXPECT_FALSE(integer.IsDefaultValue());
153
154 // Try changing back through the pref.
155 prefs.SetInteger(kIntPref, 2);
156 EXPECT_EQ(2, prefs.GetInteger(kIntPref));
157 EXPECT_EQ(2, integer.GetValue());
158 EXPECT_EQ(2, *integer);
159 EXPECT_FALSE(integer.IsDefaultValue());
160
161 // Test double
162 DoublePrefMember double_member;
163 double_member.Init(kDoublePref, &prefs);
164
165 // Check the defaults
166 EXPECT_EQ(0.0, prefs.GetDouble(kDoublePref));
167 EXPECT_EQ(0.0, double_member.GetValue());
168 EXPECT_EQ(0.0, *double_member);
169 EXPECT_TRUE(double_member.IsDefaultValue());
170
171 // Try changing through the member variable.
172 double_member.SetValue(1.0);
173 EXPECT_EQ(1.0, double_member.GetValue());
174 EXPECT_EQ(1.0, prefs.GetDouble(kDoublePref));
175 EXPECT_EQ(1.0, *double_member);
176 EXPECT_FALSE(double_member.IsDefaultValue());
177
178 // Try changing back through the pref.
179 prefs.SetDouble(kDoublePref, 3.0);
180 EXPECT_EQ(3.0, prefs.GetDouble(kDoublePref));
181 EXPECT_EQ(3.0, double_member.GetValue());
182 EXPECT_EQ(3.0, *double_member);
183 EXPECT_FALSE(double_member.IsDefaultValue());
184
185 // Test string
186 StringPrefMember string;
187 string.Init(kStringPref, &prefs);
188
189 // Check the defaults
190 EXPECT_EQ("default", prefs.GetString(kStringPref));
191 EXPECT_EQ("default", string.GetValue());
192 EXPECT_EQ("default", *string);
193 EXPECT_TRUE(string.IsDefaultValue());
194
195 // Try changing through the member variable.
196 string.SetValue("foo");
197 EXPECT_EQ("foo", string.GetValue());
198 EXPECT_EQ("foo", prefs.GetString(kStringPref));
199 EXPECT_EQ("foo", *string);
200 EXPECT_FALSE(string.IsDefaultValue());
201
202 // Try changing back through the pref.
203 prefs.SetString(kStringPref, "bar");
204 EXPECT_EQ("bar", prefs.GetString(kStringPref));
205 EXPECT_EQ("bar", string.GetValue());
206 EXPECT_EQ("bar", *string);
207 EXPECT_FALSE(string.IsDefaultValue());
208
209 // Test string list
210 base::Value::List expected_list;
211 std::vector<std::string> expected_vector;
212 StringListPrefMember string_list;
213 string_list.Init(kStringListPref, &prefs);
214
215 // Check the defaults
216 EXPECT_EQ(expected_list, prefs.GetList(kStringListPref));
217 EXPECT_EQ(expected_vector, string_list.GetValue());
218 EXPECT_EQ(expected_vector, *string_list);
219 EXPECT_TRUE(string_list.IsDefaultValue());
220
221 // Try changing through the pref member.
222 expected_list.Append("foo");
223 expected_vector.push_back("foo");
224 string_list.SetValue(expected_vector);
225
226 EXPECT_EQ(expected_list, prefs.GetList(kStringListPref));
227 EXPECT_EQ(expected_vector, string_list.GetValue());
228 EXPECT_EQ(expected_vector, *string_list);
229 EXPECT_FALSE(string_list.IsDefaultValue());
230
231 // Try adding through the pref.
232 expected_list.Append("bar");
233 expected_vector.push_back("bar");
234 prefs.SetList(kStringListPref, expected_list.Clone());
235
236 EXPECT_EQ(expected_list, prefs.GetList(kStringListPref));
237 EXPECT_EQ(expected_vector, string_list.GetValue());
238 EXPECT_EQ(expected_vector, *string_list);
239 EXPECT_FALSE(string_list.IsDefaultValue());
240
241 // Try removing through the pref.
242 expected_list.erase(expected_list.begin());
243 expected_vector.erase(expected_vector.begin());
244 prefs.SetList(kStringListPref, expected_list.Clone());
245
246 EXPECT_EQ(expected_list, prefs.GetList(kStringListPref));
247 EXPECT_EQ(expected_vector, string_list.GetValue());
248 EXPECT_EQ(expected_vector, *string_list);
249 EXPECT_FALSE(string_list.IsDefaultValue());
250 }
251
TEST_F(PrefMemberTest,InvalidList)252 TEST_F(PrefMemberTest, InvalidList) {
253 // Set the vector to an initial good value.
254 std::vector<std::string> expected_vector;
255 expected_vector.push_back("foo");
256
257 // Try to add a valid list first.
258 base::Value list(base::Value::Type::LIST);
259 list.GetList().Append("foo");
260 std::vector<std::string> vector;
261 EXPECT_TRUE(subtle::PrefMemberVectorStringUpdate(list, &vector));
262 EXPECT_EQ(expected_vector, vector);
263
264 // Now try to add an invalid list. |vector| should not be changed.
265 list.GetList().Append(0);
266 EXPECT_FALSE(subtle::PrefMemberVectorStringUpdate(list, &vector));
267 EXPECT_EQ(expected_vector, vector);
268 }
269
TEST_F(PrefMemberTest,TwoPrefs)270 TEST_F(PrefMemberTest, TwoPrefs) {
271 // Make sure two DoublePrefMembers stay in sync.
272 TestingPrefServiceSimple prefs;
273 RegisterTestPrefs(prefs.registry());
274
275 DoublePrefMember pref1;
276 pref1.Init(kDoublePref, &prefs);
277 DoublePrefMember pref2;
278 pref2.Init(kDoublePref, &prefs);
279
280 pref1.SetValue(2.3);
281 EXPECT_EQ(2.3, *pref2);
282
283 pref2.SetValue(3.5);
284 EXPECT_EQ(3.5, *pref1);
285
286 prefs.SetDouble(kDoublePref, 4.2);
287 EXPECT_EQ(4.2, *pref1);
288 EXPECT_EQ(4.2, *pref2);
289 }
290
TEST_F(PrefMemberTest,Observer)291 TEST_F(PrefMemberTest, Observer) {
292 TestingPrefServiceSimple prefs;
293 RegisterTestPrefs(prefs.registry());
294
295 PrefMemberTestClass test_obj(&prefs);
296 EXPECT_EQ("default", *test_obj.str_);
297 EXPECT_TRUE(test_obj.str_.IsDefaultValue());
298
299 // Changing the pref from the default value to an explicitly-set version of
300 // the same value fires the observer. The caller may be sensitive to
301 // IsDefaultValue().
302 prefs.SetString(kStringPref, "default");
303 EXPECT_EQ("default", *test_obj.str_);
304 EXPECT_EQ(1, test_obj.observe_cnt_);
305 EXPECT_FALSE(test_obj.str_.IsDefaultValue());
306
307 // Calling SetValue should not fire the observer.
308 test_obj.str_.SetValue("hello");
309 EXPECT_EQ(1, test_obj.observe_cnt_);
310 EXPECT_EQ("hello", prefs.GetString(kStringPref));
311
312 // Changing the pref does fire the observer.
313 prefs.SetString(kStringPref, "world");
314 EXPECT_EQ(2, test_obj.observe_cnt_);
315 EXPECT_EQ("world", *(test_obj.str_));
316
317 // Not changing the value should not fire the observer.
318 prefs.SetString(kStringPref, "world");
319 EXPECT_EQ(2, test_obj.observe_cnt_);
320 EXPECT_EQ("world", *(test_obj.str_));
321
322 prefs.SetString(kStringPref, "hello");
323 EXPECT_EQ(3, test_obj.observe_cnt_);
324 EXPECT_EQ("hello", prefs.GetString(kStringPref));
325 }
326
TEST_F(PrefMemberTest,NoInit)327 TEST_F(PrefMemberTest, NoInit) {
328 // Make sure not calling Init on a PrefMember doesn't cause problems.
329 IntegerPrefMember pref;
330 }
331
TEST_F(PrefMemberTest,MoveToSequence)332 TEST_F(PrefMemberTest, MoveToSequence) {
333 TestingPrefServiceSimple prefs;
334 scoped_refptr<GetPrefValueHelper> helper(new GetPrefValueHelper());
335 RegisterTestPrefs(prefs.registry());
336 helper->Init(kBoolPref, &prefs);
337
338 helper->FetchValue();
339 EXPECT_FALSE(helper->value());
340
341 prefs.SetBoolean(kBoolPref, true);
342
343 helper->FetchValue();
344 EXPECT_TRUE(helper->value());
345
346 helper->Destroy();
347
348 helper->FetchValue();
349 EXPECT_TRUE(helper->value());
350 }
351