components/prefs/pref_member_unittest.cc

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