ImportantFileWriter

chrome/common/pref_service_unittest.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
@@ skipping 59 matching lines @@
     new_pref_value_ = new_pref_value;
   }
 
  private:
   bool observer_fired_;
   const PrefService* prefs_;
   const std::wstring pref_name_;
   std::wstring new_pref_value_;
 };
 
-// This test is disabled. See issue 8339.
 TEST_F(PrefServiceTest, Basic) {
-  PrefService prefs;
+  {
+    // Test that it fails on nonexistent file.
+    FilePath bogus_input_file = data_dir_.AppendASCII("read.txt");
+    PrefService prefs(bogus_input_file, NULL);
+    EXPECT_FALSE(prefs.ReloadPersistentPrefs());
+  }
 
-  // Test that it fails on nonexistent file.
-  FilePath bogus_input_file = data_dir_.AppendASCII("read.txt");
-  EXPECT_FALSE(prefs.LoadPersistentPrefs(bogus_input_file));
+  ASSERT_TRUE(file_util::CopyFile(data_dir_.AppendASCII("read.json"),
+                                  test_dir_.AppendASCII("write.json")));
 
   // Test that the persistent value can be loaded.
-  FilePath input_file = data_dir_.AppendASCII("read.json");
+  FilePath input_file = test_dir_.AppendASCII("write.json");
   ASSERT_TRUE(file_util::PathExists(input_file));
-  ASSERT_TRUE(prefs.LoadPersistentPrefs(input_file));
+  PrefService prefs(input_file, NULL);
+  ASSERT_TRUE(prefs.ReloadPersistentPrefs());
 
   // Register test prefs.
   const wchar_t kNewWindowsInTabs[] = L"tabs.new_windows_in_tabs";
   const wchar_t kMaxTabs[] = L"tabs.max_tabs";
   const wchar_t kLongIntPref[] = L"long_int.pref";
   prefs.RegisterStringPref(prefs::kHomePage, L"");
   prefs.RegisterBooleanPref(kNewWindowsInTabs, false);
   prefs.RegisterIntegerPref(kMaxTabs, 0);
   prefs.RegisterStringPref(kLongIntPref, L"2147483648");
 
@@ skipping 29 matching lines @@
   prefs.SetInt64(kLongIntPref, 214748364842LL);
   EXPECT_EQ(214748364842LL, prefs.GetInt64(kLongIntPref));
 
   EXPECT_EQ(FilePath::StringType(FILE_PATH_LITERAL("/usr/local/")),
       prefs.GetFilePath(kSomeDirectory).value());
   prefs.SetFilePath(kSomeDirectory, some_path);
   EXPECT_EQ(some_path.value(), prefs.GetFilePath(kSomeDirectory).value());
 
   // Serialize and compare to expected output.
   FilePath output_file = test_dir_.AppendASCII("write.json");
-  prefs.pref_filename_ = output_file;
-  ASSERT_TRUE(prefs.SavePersistentPrefs(NULL));
   FilePath golden_output_file = data_dir_.AppendASCII("write.golden.json");
   ASSERT_TRUE(file_util::PathExists(golden_output_file));
-  ASSERT_TRUE(file_util::ContentsEqual(golden_output_file, output_file));
+  ASSERT_TRUE(prefs.SavePersistentPrefs());
+  EXPECT_TRUE(file_util::ContentsEqual(golden_output_file, output_file));
+  ASSERT_TRUE(file_util::Delete(output_file, false));
 }
 
 TEST_F(PrefServiceTest, Overlay) {
   const std::string transient =
     "{\"bool\":true, \"int\":2, \"real\":2.0, \"string\":\"transient\","
     "\"dictionary\":{\"value\":\"transient\"},"
     "\"list\":[\"transient\"]}";
 
   std::wstring persistent_string(L"persistent");
   std::wstring transient_string(L"transient");
 
-  PrefService prefs;
-
   FilePath persistent_file = data_dir_.AppendASCII("overlay.json");
-  EXPECT_TRUE(prefs.LoadPersistentPrefs(persistent_file));
+  PrefService prefs(persistent_file, NULL);
+  EXPECT_TRUE(prefs.ReloadPersistentPrefs());
 
   Value* transient_value;
   {
     JSONStringValueSerializer serializer(transient);
     transient_value = serializer.Deserialize(NULL);
     ASSERT_TRUE(transient_value);
   }
   prefs.transient()->Set(transient_string, transient_value);
 
   Value* both_transient_value;
@@ skipping 102 matching lines @@
     Value* member_value;
     ASSERT_TRUE(result_value->Get(0, &member_value));
     ASSERT_TRUE(member_value);
     std::wstring result_string;
     ASSERT_TRUE(member_value->GetAsString(&result_string));
     ASSERT_EQ(transient_string, result_string);
   }
 }
 
 TEST_F(PrefServiceTest, Observers) {
-  PrefService prefs;
-
   FilePath input_file = data_dir_.AppendASCII("read.json");
   EXPECT_TRUE(file_util::PathExists(input_file));
-  EXPECT_TRUE(prefs.LoadPersistentPrefs(input_file));
+
+  PrefService prefs(input_file, NULL);
+
+  EXPECT_TRUE(prefs.ReloadPersistentPrefs());
 
   const wchar_t pref_name[] = L"homepage";
   prefs.RegisterStringPref(pref_name, L"");
   EXPECT_EQ(std::wstring(L"http://www.cnn.com"), prefs.GetString(pref_name));
 
   const std::wstring new_pref_value(L"http://www.google.com/");
   TestPrefObserver obs(&prefs, pref_name, new_pref_value);
   prefs.AddPrefObserver(pref_name, &obs);
   // This should fire the checks in TestPrefObserver::Observe.
   prefs.SetString(pref_name, new_pref_value);
@@ skipping 20 matching lines @@
   EXPECT_FALSE(obs.observer_fired());
   EXPECT_TRUE(obs2.observer_fired());
 
   // Ok, clean up.
   prefs.RemovePrefObserver(pref_name, &obs2);
 }
 
 // TODO(port): port this test to POSIX.
 #if defined(OS_WIN)
 TEST_F(PrefServiceTest, LocalizedPrefs) {
-  PrefService prefs;
+  PrefService prefs(FilePath(), NULL);
   const wchar_t kBoolean[] = L"boolean";
   const wchar_t kInteger[] = L"integer";
   const wchar_t kString[] = L"string";
   prefs.RegisterLocalizedBooleanPref(kBoolean, IDS_LOCALE_BOOL);
   prefs.RegisterLocalizedIntegerPref(kInteger, IDS_LOCALE_INT);
   prefs.RegisterLocalizedStringPref(kString, IDS_LOCALE_STRING);
 
   // The locale default should take preference over the user default.
   EXPECT_FALSE(prefs.GetBoolean(kBoolean));
   EXPECT_EQ(1, prefs.GetInteger(kInteger));
   EXPECT_EQ(L"hello", prefs.GetString(kString));
 
   prefs.SetBoolean(kBoolean, true);
   EXPECT_TRUE(prefs.GetBoolean(kBoolean));
   prefs.SetInteger(kInteger, 5);
   EXPECT_EQ(5, prefs.GetInteger(kInteger));
   prefs.SetString(kString, L"foo");
   EXPECT_EQ(L"foo", prefs.GetString(kString));
 }
 #endif
 
 TEST_F(PrefServiceTest, NoObserverFire) {
-  PrefService prefs;
+  PrefService prefs(FilePath(), NULL);
 
   const wchar_t pref_name[] = L"homepage";
   prefs.RegisterStringPref(pref_name, L"");
 
   const std::wstring new_pref_value(L"http://www.google.com/");
   TestPrefObserver obs(&prefs, pref_name, new_pref_value);
   prefs.AddPrefObserver(pref_name, &obs);
   // This should fire the checks in TestPrefObserver::Observe.
   prefs.SetString(pref_name, new_pref_value);
 
@@ skipping 14 matching lines @@
   // Clearing the pref again should not cause the pref to fire.
   obs.Reset(L"");
   prefs.ClearPref(pref_name);
   EXPECT_FALSE(obs.observer_fired());
 
   // Ok, clean up.
   prefs.RemovePrefObserver(pref_name, &obs);
 }
 
 TEST_F(PrefServiceTest, HasPrefPath) {
-  PrefService prefs;
+  PrefService prefs(FilePath(), NULL);
 
   const wchar_t path[] = L"fake.path";
 
   // Shouldn't initially have a path.
   EXPECT_FALSE(prefs.HasPrefPath(path));
 
   // Register the path. This doesn't set a value, so the path still shouldn't
   // exist.
   prefs.RegisterStringPref(path, std::wstring());
   EXPECT_FALSE(prefs.HasPrefPath(path));
 
   // Set a value and make sure we have a path.
-  prefs.persistent_->SetString(path, L"blah");
+  prefs.SetString(path, L"blah");
   EXPECT_TRUE(prefs.HasPrefPath(path));
 }