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/bind.h" | |
8 #include "base/memory/ref_counted.h" | |
9 #include "base/memory/scoped_ptr.h" | |
10 #include "base/prefs/pref_notifier.h" | |
11 #include "base/prefs/testing_pref_store.h" | |
12 #include "base/values.h" | |
13 #include "chrome/browser/prefs/pref_value_store.h" | |
14 #include "chrome/common/pref_names.h" | |
15 #include "testing/gmock/include/gmock/gmock.h" | |
16 #include "testing/gtest/include/gtest/gtest.h" | |
17 | |
18 using testing::Mock; | |
19 using testing::_; | |
20 | |
21 namespace { | |
22 | |
23 // Allows to capture pref notifications through gmock. | |
24 class MockPrefNotifier : public PrefNotifier { | |
25 public: | |
26 MOCK_METHOD1(OnPreferenceChanged, void(const std::string&)); | |
27 MOCK_METHOD1(OnInitializationCompleted, void(bool)); | |
28 }; | |
29 | |
30 // Allows to capture sync model associator interaction. | |
31 class MockPrefModelAssociator { | |
32 public: | |
33 MOCK_METHOD1(ProcessPrefChange, void(const std::string&)); | |
34 }; | |
35 | |
36 } // namespace | |
37 | |
38 // Names of the preferences used in this test. | |
39 namespace prefs { | |
40 const char kManagedPref[] = "this.pref.managed"; | |
41 const char kCommandLinePref[] = "this.pref.command_line"; | |
42 const char kExtensionPref[] = "this.pref.extension"; | |
43 const char kUserPref[] = "this.pref.user"; | |
44 const char kRecommendedPref[] = "this.pref.recommended"; | |
45 const char kDefaultPref[] = "this.pref.default"; | |
46 const char kMissingPref[] = "this.pref.does_not_exist"; | |
47 } | |
48 | |
49 // Potentially expected values of all preferences used in this test program. | |
50 namespace managed_pref { | |
51 const char kManagedValue[] = "managed:managed"; | |
52 } | |
53 | |
54 namespace extension_pref { | |
55 const char kManagedValue[] = "extension:managed"; | |
56 const char kExtensionValue[] = "extension:extension"; | |
57 } | |
58 | |
59 namespace command_line_pref { | |
60 const char kManagedValue[] = "command_line:managed"; | |
61 const char kExtensionValue[] = "command_line:extension"; | |
62 const char kCommandLineValue[] = "command_line:command_line"; | |
63 } | |
64 | |
65 namespace user_pref { | |
66 const char kManagedValue[] = "user:managed"; | |
67 const char kExtensionValue[] = "user:extension"; | |
68 const char kCommandLineValue[] = "user:command_line"; | |
69 const char kUserValue[] = "user:user"; | |
70 } | |
71 | |
72 namespace recommended_pref { | |
73 const char kManagedValue[] = "recommended:managed"; | |
74 const char kExtensionValue[] = "recommended:extension"; | |
75 const char kCommandLineValue[] = "recommended:command_line"; | |
76 const char kUserValue[] = "recommended:user"; | |
77 const char kRecommendedValue[] = "recommended:recommended"; | |
78 } | |
79 | |
80 namespace default_pref { | |
81 const char kManagedValue[] = "default:managed"; | |
82 const char kExtensionValue[] = "default:extension"; | |
83 const char kCommandLineValue[] = "default:command_line"; | |
84 const char kUserValue[] = "default:user"; | |
85 const char kRecommendedValue[] = "default:recommended"; | |
86 const char kDefaultValue[] = "default:default"; | |
87 } | |
88 | |
89 class PrefValueStoreTest : public testing::Test { | |
90 protected: | |
91 virtual void SetUp() { | |
92 // Create TestingPrefStores. | |
93 CreateManagedPrefs(); | |
94 CreateExtensionPrefs(); | |
95 CreateCommandLinePrefs(); | |
96 CreateUserPrefs(); | |
97 CreateRecommendedPrefs(); | |
98 CreateDefaultPrefs(); | |
99 sync_associator_.reset(new MockPrefModelAssociator()); | |
100 | |
101 // Create a fresh PrefValueStore. | |
102 pref_value_store_.reset(new PrefValueStore( | |
103 managed_pref_store_, | |
104 extension_pref_store_, | |
105 command_line_pref_store_, | |
106 user_pref_store_, | |
107 recommended_pref_store_, | |
108 default_pref_store_, | |
109 &pref_notifier_)); | |
110 | |
111 pref_value_store_->set_callback( | |
112 base::Bind(&MockPrefModelAssociator::ProcessPrefChange, | |
113 base::Unretained(sync_associator_.get()))); | |
114 } | |
115 | |
116 void CreateManagedPrefs() { | |
117 managed_pref_store_ = new TestingPrefStore; | |
118 managed_pref_store_->SetString( | |
119 prefs::kManagedPref, | |
120 managed_pref::kManagedValue); | |
121 } | |
122 | |
123 void CreateExtensionPrefs() { | |
124 extension_pref_store_ = new TestingPrefStore; | |
125 extension_pref_store_->SetString( | |
126 prefs::kManagedPref, | |
127 extension_pref::kManagedValue); | |
128 extension_pref_store_->SetString( | |
129 prefs::kExtensionPref, | |
130 extension_pref::kExtensionValue); | |
131 } | |
132 | |
133 void CreateCommandLinePrefs() { | |
134 command_line_pref_store_ = new TestingPrefStore; | |
135 command_line_pref_store_->SetString( | |
136 prefs::kManagedPref, | |
137 command_line_pref::kManagedValue); | |
138 command_line_pref_store_->SetString( | |
139 prefs::kExtensionPref, | |
140 command_line_pref::kExtensionValue); | |
141 command_line_pref_store_->SetString( | |
142 prefs::kCommandLinePref, | |
143 command_line_pref::kCommandLineValue); | |
144 } | |
145 | |
146 void CreateUserPrefs() { | |
147 user_pref_store_ = new TestingPrefStore; | |
148 user_pref_store_->SetString( | |
149 prefs::kManagedPref, | |
150 user_pref::kManagedValue); | |
151 user_pref_store_->SetString( | |
152 prefs::kCommandLinePref, | |
153 user_pref::kCommandLineValue); | |
154 user_pref_store_->SetString( | |
155 prefs::kExtensionPref, | |
156 user_pref::kExtensionValue); | |
157 user_pref_store_->SetString( | |
158 prefs::kUserPref, | |
159 user_pref::kUserValue); | |
160 } | |
161 | |
162 void CreateRecommendedPrefs() { | |
163 recommended_pref_store_ = new TestingPrefStore; | |
164 recommended_pref_store_->SetString( | |
165 prefs::kManagedPref, | |
166 recommended_pref::kManagedValue); | |
167 recommended_pref_store_->SetString( | |
168 prefs::kCommandLinePref, | |
169 recommended_pref::kCommandLineValue); | |
170 recommended_pref_store_->SetString( | |
171 prefs::kExtensionPref, | |
172 recommended_pref::kExtensionValue); | |
173 recommended_pref_store_->SetString( | |
174 prefs::kUserPref, | |
175 recommended_pref::kUserValue); | |
176 recommended_pref_store_->SetString( | |
177 prefs::kRecommendedPref, | |
178 recommended_pref::kRecommendedValue); | |
179 } | |
180 | |
181 void CreateDefaultPrefs() { | |
182 default_pref_store_ = new TestingPrefStore; | |
183 default_pref_store_->SetString( | |
184 prefs::kManagedPref, | |
185 default_pref::kManagedValue); | |
186 default_pref_store_->SetString( | |
187 prefs::kCommandLinePref, | |
188 default_pref::kCommandLineValue); | |
189 default_pref_store_->SetString( | |
190 prefs::kExtensionPref, | |
191 default_pref::kExtensionValue); | |
192 default_pref_store_->SetString( | |
193 prefs::kUserPref, | |
194 default_pref::kUserValue); | |
195 default_pref_store_->SetString( | |
196 prefs::kRecommendedPref, | |
197 default_pref::kRecommendedValue); | |
198 default_pref_store_->SetString( | |
199 prefs::kDefaultPref, | |
200 default_pref::kDefaultValue); | |
201 } | |
202 | |
203 void ExpectValueChangeNotifications(const char* name) { | |
204 EXPECT_CALL(pref_notifier_, OnPreferenceChanged(name)); | |
205 EXPECT_CALL(*sync_associator_, ProcessPrefChange(name)); | |
206 } | |
207 | |
208 void CheckAndClearValueChangeNotifications() { | |
209 Mock::VerifyAndClearExpectations(&pref_notifier_); | |
210 Mock::VerifyAndClearExpectations(sync_associator_.get()); | |
211 } | |
212 | |
213 MockPrefNotifier pref_notifier_; | |
214 scoped_ptr<MockPrefModelAssociator> sync_associator_; | |
215 scoped_ptr<PrefValueStore> pref_value_store_; | |
216 | |
217 scoped_refptr<TestingPrefStore> managed_pref_store_; | |
218 scoped_refptr<TestingPrefStore> extension_pref_store_; | |
219 scoped_refptr<TestingPrefStore> command_line_pref_store_; | |
220 scoped_refptr<TestingPrefStore> user_pref_store_; | |
221 scoped_refptr<TestingPrefStore> recommended_pref_store_; | |
222 scoped_refptr<TestingPrefStore> default_pref_store_; | |
223 }; | |
224 | |
225 TEST_F(PrefValueStoreTest, GetValue) { | |
226 const Value* value; | |
227 | |
228 // The following tests read a value from the PrefService. The preferences are | |
229 // set in a way such that all lower-priority stores have a value and we can | |
230 // test whether overrides work correctly. | |
231 | |
232 // Test getting a managed value. | |
233 value = NULL; | |
234 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kManagedPref, | |
235 Value::TYPE_STRING, &value)); | |
236 std::string actual_str_value; | |
237 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
238 EXPECT_EQ(managed_pref::kManagedValue, actual_str_value); | |
239 | |
240 // Test getting an extension value. | |
241 value = NULL; | |
242 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kExtensionPref, | |
243 Value::TYPE_STRING, &value)); | |
244 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
245 EXPECT_EQ(extension_pref::kExtensionValue, actual_str_value); | |
246 | |
247 // Test getting a command-line value. | |
248 value = NULL; | |
249 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kCommandLinePref, | |
250 Value::TYPE_STRING, &value)); | |
251 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
252 EXPECT_EQ(command_line_pref::kCommandLineValue, actual_str_value); | |
253 | |
254 // Test getting a user-set value. | |
255 value = NULL; | |
256 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kUserPref, | |
257 Value::TYPE_STRING, &value)); | |
258 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
259 EXPECT_EQ(user_pref::kUserValue, actual_str_value); | |
260 | |
261 // Test getting a user set value overwriting a recommended value. | |
262 value = NULL; | |
263 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kRecommendedPref, | |
264 Value::TYPE_STRING, &value)); | |
265 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
266 EXPECT_EQ(recommended_pref::kRecommendedValue, | |
267 actual_str_value); | |
268 | |
269 // Test getting a default value. | |
270 value = NULL; | |
271 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDefaultPref, | |
272 Value::TYPE_STRING, &value)); | |
273 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
274 EXPECT_EQ(default_pref::kDefaultValue, actual_str_value); | |
275 | |
276 // Test getting a preference value that the |PrefValueStore| | |
277 // does not contain. | |
278 base::FundamentalValue tmp_dummy_value(true); | |
279 value = &tmp_dummy_value; | |
280 ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref, | |
281 Value::TYPE_STRING, &value)); | |
282 ASSERT_FALSE(value); | |
283 } | |
284 | |
285 TEST_F(PrefValueStoreTest, GetRecommendedValue) { | |
286 const Value* value; | |
287 | |
288 // The following tests read a value from the PrefService. The preferences are | |
289 // set in a way such that all lower-priority stores have a value and we can | |
290 // test whether overrides do not clutter the recommended value. | |
291 | |
292 // Test getting recommended value when a managed value is present. | |
293 value = NULL; | |
294 ASSERT_TRUE(pref_value_store_->GetRecommendedValue( | |
295 prefs::kManagedPref, | |
296 Value::TYPE_STRING, &value)); | |
297 std::string actual_str_value; | |
298 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
299 EXPECT_EQ(recommended_pref::kManagedValue, actual_str_value); | |
300 | |
301 // Test getting recommended value when an extension value is present. | |
302 value = NULL; | |
303 ASSERT_TRUE(pref_value_store_->GetRecommendedValue( | |
304 prefs::kExtensionPref, | |
305 Value::TYPE_STRING, &value)); | |
306 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
307 EXPECT_EQ(recommended_pref::kExtensionValue, actual_str_value); | |
308 | |
309 // Test getting recommended value when a command-line value is present. | |
310 value = NULL; | |
311 ASSERT_TRUE(pref_value_store_->GetRecommendedValue( | |
312 prefs::kCommandLinePref, | |
313 Value::TYPE_STRING, &value)); | |
314 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
315 EXPECT_EQ(recommended_pref::kCommandLineValue, actual_str_value); | |
316 | |
317 // Test getting recommended value when a user-set value is present. | |
318 value = NULL; | |
319 ASSERT_TRUE(pref_value_store_->GetRecommendedValue( | |
320 prefs::kUserPref, | |
321 Value::TYPE_STRING, &value)); | |
322 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
323 EXPECT_EQ(recommended_pref::kUserValue, actual_str_value); | |
324 | |
325 // Test getting recommended value when no higher-priority value is present. | |
326 value = NULL; | |
327 ASSERT_TRUE(pref_value_store_->GetRecommendedValue( | |
328 prefs::kRecommendedPref, | |
329 Value::TYPE_STRING, &value)); | |
330 EXPECT_TRUE(value->GetAsString(&actual_str_value)); | |
331 EXPECT_EQ(recommended_pref::kRecommendedValue, | |
332 actual_str_value); | |
333 | |
334 // Test getting recommended value when no recommended value is present. | |
335 base::FundamentalValue tmp_dummy_value(true); | |
336 value = &tmp_dummy_value; | |
337 ASSERT_FALSE(pref_value_store_->GetRecommendedValue( | |
338 prefs::kDefaultPref, | |
339 Value::TYPE_STRING, &value)); | |
340 ASSERT_FALSE(value); | |
341 | |
342 // Test getting a preference value that the |PrefValueStore| | |
343 // does not contain. | |
344 value = &tmp_dummy_value; | |
345 ASSERT_FALSE(pref_value_store_->GetRecommendedValue( | |
346 prefs::kMissingPref, | |
347 Value::TYPE_STRING, &value)); | |
348 ASSERT_FALSE(value); | |
349 } | |
350 | |
351 TEST_F(PrefValueStoreTest, PrefChanges) { | |
352 // Check pref controlled by highest-priority store. | |
353 ExpectValueChangeNotifications(prefs::kManagedPref); | |
354 managed_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); | |
355 CheckAndClearValueChangeNotifications(); | |
356 | |
357 ExpectValueChangeNotifications(prefs::kManagedPref); | |
358 extension_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); | |
359 CheckAndClearValueChangeNotifications(); | |
360 | |
361 ExpectValueChangeNotifications(prefs::kManagedPref); | |
362 command_line_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); | |
363 CheckAndClearValueChangeNotifications(); | |
364 | |
365 ExpectValueChangeNotifications(prefs::kManagedPref); | |
366 user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); | |
367 CheckAndClearValueChangeNotifications(); | |
368 | |
369 ExpectValueChangeNotifications(prefs::kManagedPref); | |
370 recommended_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); | |
371 CheckAndClearValueChangeNotifications(); | |
372 | |
373 ExpectValueChangeNotifications(prefs::kManagedPref); | |
374 default_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref); | |
375 CheckAndClearValueChangeNotifications(); | |
376 | |
377 // Check pref controlled by user store. | |
378 ExpectValueChangeNotifications(prefs::kUserPref); | |
379 managed_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); | |
380 CheckAndClearValueChangeNotifications(); | |
381 | |
382 ExpectValueChangeNotifications(prefs::kUserPref); | |
383 extension_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); | |
384 CheckAndClearValueChangeNotifications(); | |
385 | |
386 ExpectValueChangeNotifications(prefs::kUserPref); | |
387 command_line_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); | |
388 CheckAndClearValueChangeNotifications(); | |
389 | |
390 ExpectValueChangeNotifications(prefs::kUserPref); | |
391 user_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); | |
392 CheckAndClearValueChangeNotifications(); | |
393 | |
394 ExpectValueChangeNotifications(prefs::kUserPref); | |
395 recommended_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); | |
396 CheckAndClearValueChangeNotifications(); | |
397 | |
398 ExpectValueChangeNotifications(prefs::kUserPref); | |
399 default_pref_store_->NotifyPrefValueChanged(prefs::kUserPref); | |
400 CheckAndClearValueChangeNotifications(); | |
401 | |
402 // Check pref controlled by default-pref store. | |
403 ExpectValueChangeNotifications(prefs::kDefaultPref); | |
404 managed_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); | |
405 CheckAndClearValueChangeNotifications(); | |
406 | |
407 ExpectValueChangeNotifications(prefs::kDefaultPref); | |
408 extension_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); | |
409 CheckAndClearValueChangeNotifications(); | |
410 | |
411 ExpectValueChangeNotifications(prefs::kDefaultPref); | |
412 command_line_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); | |
413 CheckAndClearValueChangeNotifications(); | |
414 | |
415 ExpectValueChangeNotifications(prefs::kDefaultPref); | |
416 user_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); | |
417 CheckAndClearValueChangeNotifications(); | |
418 | |
419 ExpectValueChangeNotifications(prefs::kDefaultPref); | |
420 recommended_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); | |
421 CheckAndClearValueChangeNotifications(); | |
422 | |
423 ExpectValueChangeNotifications(prefs::kDefaultPref); | |
424 default_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref); | |
425 CheckAndClearValueChangeNotifications(); | |
426 } | |
427 | |
428 TEST_F(PrefValueStoreTest, OnInitializationCompleted) { | |
429 EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(0); | |
430 managed_pref_store_->SetInitializationCompleted(); | |
431 extension_pref_store_->SetInitializationCompleted(); | |
432 command_line_pref_store_->SetInitializationCompleted(); | |
433 recommended_pref_store_->SetInitializationCompleted(); | |
434 default_pref_store_->SetInitializationCompleted(); | |
435 Mock::VerifyAndClearExpectations(&pref_notifier_); | |
436 | |
437 // The notification should only be triggered after the last store is done. | |
438 EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(1); | |
439 user_pref_store_->SetInitializationCompleted(); | |
440 Mock::VerifyAndClearExpectations(&pref_notifier_); | |
441 } | |
442 | |
443 TEST_F(PrefValueStoreTest, PrefValueInManagedStore) { | |
444 EXPECT_TRUE(pref_value_store_->PrefValueInManagedStore( | |
445 prefs::kManagedPref)); | |
446 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore( | |
447 prefs::kExtensionPref)); | |
448 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore( | |
449 prefs::kCommandLinePref)); | |
450 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore( | |
451 prefs::kUserPref)); | |
452 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore( | |
453 prefs::kRecommendedPref)); | |
454 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore( | |
455 prefs::kDefaultPref)); | |
456 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore( | |
457 prefs::kMissingPref)); | |
458 } | |
459 | |
460 TEST_F(PrefValueStoreTest, PrefValueInExtensionStore) { | |
461 EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore( | |
462 prefs::kManagedPref)); | |
463 EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore( | |
464 prefs::kExtensionPref)); | |
465 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore( | |
466 prefs::kCommandLinePref)); | |
467 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore( | |
468 prefs::kUserPref)); | |
469 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore( | |
470 prefs::kRecommendedPref)); | |
471 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore( | |
472 prefs::kDefaultPref)); | |
473 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore( | |
474 prefs::kMissingPref)); | |
475 } | |
476 | |
477 TEST_F(PrefValueStoreTest, PrefValueInUserStore) { | |
478 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore( | |
479 prefs::kManagedPref)); | |
480 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore( | |
481 prefs::kExtensionPref)); | |
482 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore( | |
483 prefs::kCommandLinePref)); | |
484 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore( | |
485 prefs::kUserPref)); | |
486 EXPECT_FALSE(pref_value_store_->PrefValueInUserStore( | |
487 prefs::kRecommendedPref)); | |
488 EXPECT_FALSE(pref_value_store_->PrefValueInUserStore( | |
489 prefs::kDefaultPref)); | |
490 EXPECT_FALSE(pref_value_store_->PrefValueInUserStore( | |
491 prefs::kMissingPref)); | |
492 } | |
493 | |
494 TEST_F(PrefValueStoreTest, PrefValueFromExtensionStore) { | |
495 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore( | |
496 prefs::kManagedPref)); | |
497 EXPECT_TRUE(pref_value_store_->PrefValueFromExtensionStore( | |
498 prefs::kExtensionPref)); | |
499 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore( | |
500 prefs::kCommandLinePref)); | |
501 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore( | |
502 prefs::kUserPref)); | |
503 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore( | |
504 prefs::kRecommendedPref)); | |
505 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore( | |
506 prefs::kDefaultPref)); | |
507 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore( | |
508 prefs::kMissingPref)); | |
509 } | |
510 | |
511 TEST_F(PrefValueStoreTest, PrefValueFromUserStore) { | |
512 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore( | |
513 prefs::kManagedPref)); | |
514 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore( | |
515 prefs::kExtensionPref)); | |
516 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore( | |
517 prefs::kCommandLinePref)); | |
518 EXPECT_TRUE(pref_value_store_->PrefValueFromUserStore( | |
519 prefs::kUserPref)); | |
520 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore( | |
521 prefs::kRecommendedPref)); | |
522 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore( | |
523 prefs::kDefaultPref)); | |
524 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore( | |
525 prefs::kMissingPref)); | |
526 } | |
527 | |
528 TEST_F(PrefValueStoreTest, PrefValueFromRecommendedStore) { | |
529 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore( | |
530 prefs::kManagedPref)); | |
531 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore( | |
532 prefs::kExtensionPref)); | |
533 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore( | |
534 prefs::kCommandLinePref)); | |
535 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore( | |
536 prefs::kUserPref)); | |
537 EXPECT_TRUE(pref_value_store_->PrefValueFromRecommendedStore( | |
538 prefs::kRecommendedPref)); | |
539 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore( | |
540 prefs::kDefaultPref)); | |
541 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore( | |
542 prefs::kMissingPref)); | |
543 } | |
544 | |
545 TEST_F(PrefValueStoreTest, PrefValueFromDefaultStore) { | |
546 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore( | |
547 prefs::kManagedPref)); | |
548 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore( | |
549 prefs::kExtensionPref)); | |
550 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore( | |
551 prefs::kCommandLinePref)); | |
552 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore( | |
553 prefs::kUserPref)); | |
554 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore( | |
555 prefs::kRecommendedPref)); | |
556 EXPECT_TRUE(pref_value_store_->PrefValueFromDefaultStore( | |
557 prefs::kDefaultPref)); | |
558 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore( | |
559 prefs::kMissingPref)); | |
560 } | |
561 | |
562 TEST_F(PrefValueStoreTest, PrefValueUserModifiable) { | |
563 EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable( | |
564 prefs::kManagedPref)); | |
565 EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable( | |
566 prefs::kExtensionPref)); | |
567 EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable( | |
568 prefs::kCommandLinePref)); | |
569 EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable( | |
570 prefs::kUserPref)); | |
571 EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable( | |
572 prefs::kRecommendedPref)); | |
573 EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable( | |
574 prefs::kDefaultPref)); | |
575 EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable( | |
576 prefs::kMissingPref)); | |
577 } | |
578 | |
579 TEST_F(PrefValueStoreTest, PrefValueExtensionModifiable) { | |
580 EXPECT_FALSE(pref_value_store_->PrefValueExtensionModifiable( | |
581 prefs::kManagedPref)); | |
582 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable( | |
583 prefs::kExtensionPref)); | |
584 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable( | |
585 prefs::kCommandLinePref)); | |
586 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable( | |
587 prefs::kUserPref)); | |
588 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable( | |
589 prefs::kRecommendedPref)); | |
590 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable( | |
591 prefs::kDefaultPref)); | |
592 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable( | |
593 prefs::kMissingPref)); | |
594 } | |
OLD | NEW |