pref_member_unittest.cc revision 3345a6884c488ff3a535c2c9acdd33d74b37e311 
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 "chrome/browser/prefs/dummy_pref_store.h"
6#include "chrome/browser/prefs/pref_member.h"
7#include "chrome/browser/prefs/pref_value_store.h"
8#include "chrome/common/notification_service.h"
9#include "chrome/test/testing_pref_service.h"
10#include "testing/gtest/include/gtest/gtest.h"
11
12namespace {
13
14static const char kBoolPref[] = "bool";
15static const char kIntPref[] = "int";
16static const char kRealPref[] = "real";
17static const char kStringPref[] = "string";
18
19void RegisterTestPrefs(PrefService* prefs) {
20  prefs->RegisterBooleanPref(kBoolPref, false);
21  prefs->RegisterIntegerPref(kIntPref, 0);
22  prefs->RegisterRealPref(kRealPref, 0.0);
23  prefs->RegisterStringPref(kStringPref, "default");
24}
25
26class PrefMemberTestClass : public NotificationObserver {
27 public:
28  explicit PrefMemberTestClass(PrefService* prefs)
29      : observe_cnt_(0), prefs_(prefs) {
30    str_.Init(kStringPref, prefs, this);
31  }
32
33  virtual void Observe(NotificationType type,
34                       const NotificationSource& source,
35                       const NotificationDetails& details) {
36    DCHECK(NotificationType::PREF_CHANGED == type);
37    PrefService* prefs_in = Source<PrefService>(source).ptr();
38    EXPECT_EQ(prefs_in, prefs_);
39    std::string* pref_name_in = Details<std::string>(details).ptr();
40    EXPECT_EQ(*pref_name_in, kStringPref);
41    EXPECT_EQ(str_.GetValue(), prefs_->GetString(kStringPref));
42    ++observe_cnt_;
43  }
44
45  StringPrefMember str_;
46  int observe_cnt_;
47
48 private:
49  PrefService* prefs_;
50};
51
52}  // anonymous namespace
53
54TEST(PrefMemberTest, BasicGetAndSet) {
55  TestingPrefService prefs;
56  RegisterTestPrefs(&prefs);
57
58  // Test bool
59  BooleanPrefMember boolean;
60  boolean.Init(kBoolPref, &prefs, NULL);
61
62  // Check the defaults
63  EXPECT_FALSE(prefs.GetBoolean(kBoolPref));
64  EXPECT_FALSE(boolean.GetValue());
65  EXPECT_FALSE(*boolean);
66
67  // Try changing through the member variable.
68  boolean.SetValue(true);
69  EXPECT_TRUE(boolean.GetValue());
70  EXPECT_TRUE(prefs.GetBoolean(kBoolPref));
71  EXPECT_TRUE(*boolean);
72
73  // Try changing back through the pref.
74  prefs.SetBoolean(kBoolPref, false);
75  EXPECT_FALSE(prefs.GetBoolean(kBoolPref));
76  EXPECT_FALSE(boolean.GetValue());
77  EXPECT_FALSE(*boolean);
78
79  // Test int
80  IntegerPrefMember integer;
81  integer.Init(kIntPref, &prefs, NULL);
82
83  // Check the defaults
84  EXPECT_EQ(0, prefs.GetInteger(kIntPref));
85  EXPECT_EQ(0, integer.GetValue());
86  EXPECT_EQ(0, *integer);
87
88  // Try changing through the member variable.
89  integer.SetValue(5);
90  EXPECT_EQ(5, integer.GetValue());
91  EXPECT_EQ(5, prefs.GetInteger(kIntPref));
92  EXPECT_EQ(5, *integer);
93
94  // Try changing back through the pref.
95  prefs.SetInteger(kIntPref, 2);
96  EXPECT_EQ(2, prefs.GetInteger(kIntPref));
97  EXPECT_EQ(2, integer.GetValue());
98  EXPECT_EQ(2, *integer);
99
100  // Test real (double)
101  RealPrefMember real;
102  real.Init(kRealPref, &prefs, NULL);
103
104  // Check the defaults
105  EXPECT_EQ(0.0, prefs.GetReal(kRealPref));
106  EXPECT_EQ(0.0, real.GetValue());
107  EXPECT_EQ(0.0, *real);
108
109  // Try changing through the member variable.
110  real.SetValue(1.0);
111  EXPECT_EQ(1.0, real.GetValue());
112  EXPECT_EQ(1.0, prefs.GetReal(kRealPref));
113  EXPECT_EQ(1.0, *real);
114
115  // Try changing back through the pref.
116  prefs.SetReal(kRealPref, 3.0);
117  EXPECT_EQ(3.0, prefs.GetReal(kRealPref));
118  EXPECT_EQ(3.0, real.GetValue());
119  EXPECT_EQ(3.0, *real);
120
121  // Test string
122  StringPrefMember string;
123  string.Init(kStringPref, &prefs, NULL);
124
125  // Check the defaults
126  EXPECT_EQ("default", prefs.GetString(kStringPref));
127  EXPECT_EQ("default", string.GetValue());
128  EXPECT_EQ("default", *string);
129
130  // Try changing through the member variable.
131  string.SetValue("foo");
132  EXPECT_EQ("foo", string.GetValue());
133  EXPECT_EQ("foo", prefs.GetString(kStringPref));
134  EXPECT_EQ("foo", *string);
135
136  // Try changing back through the pref.
137  prefs.SetString(kStringPref, "bar");
138  EXPECT_EQ("bar", prefs.GetString(kStringPref));
139  EXPECT_EQ("bar", string.GetValue());
140  EXPECT_EQ("bar", *string);
141}
142
143TEST(PrefMemberTest, TwoPrefs) {
144  // Make sure two RealPrefMembers stay in sync.
145  TestingPrefService prefs;
146  RegisterTestPrefs(&prefs);
147
148  RealPrefMember pref1;
149  pref1.Init(kRealPref, &prefs, NULL);
150  RealPrefMember pref2;
151  pref2.Init(kRealPref, &prefs, NULL);
152
153  pref1.SetValue(2.3);
154  EXPECT_EQ(2.3, *pref2);
155
156  pref2.SetValue(3.5);
157  EXPECT_EQ(3.5, *pref1);
158
159  prefs.SetReal(kRealPref, 4.2);
160  EXPECT_EQ(4.2, *pref1);
161  EXPECT_EQ(4.2, *pref2);
162}
163
164TEST(PrefMemberTest, Observer) {
165  TestingPrefService prefs;
166  RegisterTestPrefs(&prefs);
167
168  PrefMemberTestClass test_obj(&prefs);
169  EXPECT_EQ("default", *test_obj.str_);
170
171  // Calling SetValue should not fire the observer.
172  test_obj.str_.SetValue("hello");
173  EXPECT_EQ(0, test_obj.observe_cnt_);
174  EXPECT_EQ("hello", prefs.GetString(kStringPref));
175
176  // Changing the pref does fire the observer.
177  prefs.SetString(kStringPref, "world");
178  EXPECT_EQ(1, test_obj.observe_cnt_);
179  EXPECT_EQ("world", *(test_obj.str_));
180
181  // Not changing the value should not fire the observer.
182  prefs.SetString(kStringPref, "world");
183  EXPECT_EQ(1, test_obj.observe_cnt_);
184  EXPECT_EQ("world", *(test_obj.str_));
185
186  prefs.SetString(kStringPref, "hello");
187  EXPECT_EQ(2, test_obj.observe_cnt_);
188  EXPECT_EQ("hello", prefs.GetString(kStringPref));
189}
190
191TEST(PrefMemberTest, NoInit) {
192  // Make sure not calling Init on a PrefMember doesn't cause problems.
193  IntegerPrefMember pref;
194}
195