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