components/prefs/pref_member_unittest.cc

   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/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
  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:
  39   GetPrefValueHelper()
  40       : value_(false),
  41         task_runner_(base::ThreadPool::CreateSequencedTaskRunner({})) {}
  42
  43   void Init(const std::string& pref_name, PrefService* prefs) {
  44     pref_.Init(pref_name, prefs);
  45     pref_.MoveToSequence(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(task_runner_->PostTask(
  56         FROM_HERE,
  57         base::BindOnce(&GetPrefValueHelper::GetPrefValue, this, &event)));
  58     event.Wait();
  59   }
  60
  61   bool value() { return value_; }
  62
  63  private:
  64   friend class base::RefCountedThreadSafe<GetPrefValueHelper>;
  65   ~GetPrefValueHelper() {}
  66
  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:
  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
  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
 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
 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.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.Append(0);
 266   EXPECT_FALSE(subtle::PrefMemberVectorStringUpdate(list, &vector));
 267   EXPECT_EQ(expected_vector, vector);
 268 }
 269
 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
 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
 327 TEST_F(PrefMemberTest, NoInit) {
 328   // Make sure not calling Init on a PrefMember doesn't cause problems.
 329   IntegerPrefMember pref;
 330 }
 331
 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 }