import FIREFOX_52_6_0esr_RELEASE from mozilla-esr52 hg repo

modules/libpref/test/unit/data/testPref.js

@@ -0,0 +1,6 @@
+user_pref("testPref.bool1", true);
+user_pref("testPref.bool2", false);
+user_pref("testPref.int1", 23);
+user_pref("testPref.int2", -1236);
+user_pref("testPref.char1", "_testPref");
+user_pref("testPref.char2", "älskar");

modules/libpref/test/unit/data/testPrefSticky.js

@@ -0,0 +1,2 @@
+pref("testPref.unsticky.bool", true);
+sticky_pref("testPref.sticky.bool", false);

modules/libpref/test/unit/data/testPrefStickyUser.js

@@ -0,0 +1,5 @@
+// testPrefSticky.js defined this pref as a sticky_pref(). Once a sticky
+// pref has been changed, it's written as a user_pref().
+// So this test file reflects that scenario.
+// Note the default in testPrefSticky.js is also false.
+user_pref("testPref.sticky.bool", false);

modules/libpref/test/unit/extdata/testExt.js

@@ -0,0 +1,2 @@
+pref("testPref.bool2", true);
+pref("testExtPref.bool", true);

modules/libpref/test/unit/head_libPrefs.js

@@ -0,0 +1,45 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const NS_APP_USER_PROFILE_50_DIR = "ProfD";
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+var Cr = Components.results;
+var Cu = Components.utils;
+
+function do_check_throws(f, result, stack)
+{
+  if (!stack)
+    stack = Components.stack.caller;
+
+  try {
+    f();
+  } catch (exc) {
+    if (exc.result == result)
+      return;
+    do_throw("expected result " + result + ", caught " + exc, stack);
+  }
+  do_throw("expected result " + result + ", none thrown", stack);
+}
+
+var dirSvc = Cc["@mozilla.org/file/directory_service;1"].getService(Ci.nsIProperties);
+
+// Register current test directory as provider for the profile directory.
+var provider = {
+  getFile: function(prop, persistent) {
+    persistent.value = true;
+    if (prop == NS_APP_USER_PROFILE_50_DIR)
+      return dirSvc.get("CurProcD", Ci.nsIFile);
+    throw Components.Exception("Tried to get test directory '" + prop + "'", Cr.NS_ERROR_FAILURE);
+  },
+  QueryInterface: function(iid) {
+    if (iid.equals(Ci.nsIDirectoryServiceProvider) ||
+        iid.equals(Ci.nsISupports)) {
+      return this;
+    }
+    throw Cr.NS_ERROR_NO_INTERFACE;
+  }
+};
+dirSvc.QueryInterface(Ci.nsIDirectoryService).registerProvider(provider);

modules/libpref/test/unit/test_bug345529.js

@@ -0,0 +1,34 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/  */ 
+
+// Regression test for bug 345529 - crash removing an observer during an
+// nsPref:changed notification.
+function run_test() {
+  const Cc = Components.classes;
+  const Ci = Components.interfaces;
+  const PREF_NAME = "testPref";
+
+  var prefs = Cc["@mozilla.org/preferences-service;1"]
+              .getService(Ci.nsIPrefBranch);
+  var observer = {
+    QueryInterface: function QueryInterface(aIID) {
+      if (aIID.equals(Ci.nsIObserver) ||
+          aIID.equals(Ci.nsISupports))
+         return this;
+      throw Components.results.NS_NOINTERFACE;
+    },
+
+    observe: function observe(aSubject, aTopic, aState) {
+      prefs.removeObserver(PREF_NAME, observer);
+    }
+  }
+  prefs.addObserver(PREF_NAME, observer, false);
+
+  prefs.setCharPref(PREF_NAME, "test0")
+  // This second call isn't needed on a clean profile: it makes sure 
+  // the observer gets called even if the pref already had the value
+  // "test0" before this test.
+  prefs.setCharPref(PREF_NAME, "test1")
+
+  do_check_true(true);
+}

modules/libpref/test/unit/test_bug506224.js

@@ -0,0 +1,29 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/  */
+
+function run_test() {
+  const Cc = Components.classes;
+  const Ci = Components.interfaces;
+  const PREF_NAME = "testPref";
+
+  var ps = Cc["@mozilla.org/preferences-service;1"]
+           .getService(Ci.nsIPrefService);
+  var prefs = ps.getDefaultBranch(null);
+  var userprefs = ps.getBranch(null);
+
+  prefs.setCharPref(PREF_NAME, "test0");
+  prefs.lockPref(PREF_NAME);
+  do_check_eq("test0", userprefs.getCharPref(PREF_NAME));
+  do_check_eq(false, userprefs.prefHasUserValue(PREF_NAME));
+
+  var file = do_get_profile();
+  file.append("prefs.js");
+  ps.savePrefFile(file);
+
+  prefs.unlockPref(PREF_NAME);
+  prefs.setCharPref(PREF_NAME, "test1");
+  ps.readUserPrefs(file);
+
+  do_check_eq("test1", userprefs.getCharPref(PREF_NAME));
+  do_check_eq(false, userprefs.prefHasUserValue(PREF_NAME));
+}

modules/libpref/test/unit/test_bug577950.js

@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function run_test() {
+  var ps = Cc["@mozilla.org/preferences-service;1"].
+            getService(Ci.nsIPrefService);
+
+  var pb = Cc["@mozilla.org/preferences-service;1"].
+            getService(Ci.nsIPrefBranch);
+
+  var observer = {
+    QueryInterface: function QueryInterface(aIID) {
+      if (aIID.equals(Ci.nsIObserver) ||
+          aIID.equals(Ci.nsISupports))
+         return this;
+      throw Components.results.NS_NOINTERFACE;
+    },
+
+    observe: function observe(aSubject, aTopic, aState) {
+      // Don't do anything.
+    }
+  }
+
+  /* Set the same pref twice.  This shouldn't leak. */
+  pb.addObserver("UserPref.nonexistent.setIntPref", observer, false);
+  pb.addObserver("UserPref.nonexistent.setIntPref", observer, false);
+}

modules/libpref/test/unit/test_bug790374.js

@@ -0,0 +1,55 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/  */
+
+function run_test() {
+  const Cc = Components.classes;
+  const Ci = Components.interfaces;
+  const Cr = Components.results;
+  const PREF_NAME = "testPref";
+
+  var ps = Cc["@mozilla.org/preferences-service;1"]
+           .getService(Ci.nsIPrefService);
+  var prefs = ps.getDefaultBranch(null);
+  var userprefs = ps.getBranch(null);
+
+  /* First, test to make sure we can parse a float from a string properly. */
+  prefs.setCharPref(PREF_NAME, "9.674");
+  prefs.lockPref(PREF_NAME);
+  var myFloat = 9.674;
+  var fudge = 0.001;
+  var floatPref = userprefs.getFloatPref(PREF_NAME);
+  do_check_true(myFloat+fudge >= floatPref);
+  do_check_true(myFloat-fudge <= floatPref);
+
+  /* Now test some failure conditions. */
+  prefs.unlockPref(PREF_NAME);
+  prefs.setCharPref(PREF_NAME, "");
+  prefs.lockPref(PREF_NAME);
+  do_check_throws(function() {
+    userprefs.getFloatPref(PREF_NAME);
+  }, Cr.NS_ERROR_ILLEGAL_VALUE);
+
+  prefs.unlockPref(PREF_NAME);
+  prefs.setCharPref(PREF_NAME, "18.0a1");
+  prefs.lockPref(PREF_NAME);
+
+  do_check_throws(function() {
+    userprefs.getFloatPref(PREF_NAME);
+  }, Cr.NS_ERROR_ILLEGAL_VALUE);
+
+  prefs.unlockPref(PREF_NAME);
+  prefs.setCharPref(PREF_NAME, "09.25.2012");
+  prefs.lockPref(PREF_NAME);
+
+  do_check_throws(function() {
+    userprefs.getFloatPref(PREF_NAME);
+  }, Cr.NS_ERROR_ILLEGAL_VALUE);
+
+  prefs.unlockPref(PREF_NAME);
+  prefs.setCharPref(PREF_NAME, "aString");
+  prefs.lockPref(PREF_NAME);
+
+  do_check_throws(function() {
+    userprefs.getFloatPref(PREF_NAME);
+  }, Cr.NS_ERROR_ILLEGAL_VALUE);
+}

modules/libpref/test/unit/test_changeType.js

@@ -0,0 +1,63 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Tests for changing the type of a preference (bug 985998) */
+
+const PREF_INVALID = 0;
+const PREF_BOOL    = 128;
+const PREF_INT     = 64;
+const PREF_STRING  = 32;
+
+function run_test() {
+
+  var ps = Cc["@mozilla.org/preferences-service;1"].
+            getService(Ci.nsIPrefService);
+
+  let defaultBranch = ps.getDefaultBranch("");
+  let userBranch = ps.getBranch("");
+
+  //**************************************************************************//
+  // Can't change the type of prefs that have default values
+
+  defaultBranch.setBoolPref("TypeTest.existing.bool", true);
+  defaultBranch.setIntPref("TypeTest.existing.int", 23);
+  defaultBranch.setCharPref("TypeTest.existing.char", "hey");
+
+  // The user branch reads back the expected default
+  do_check_eq(userBranch.getBoolPref("TypeTest.existing.bool"), true);
+  do_check_eq(userBranch.getIntPref("TypeTest.existing.int"), 23);
+  do_check_eq(userBranch.getCharPref("TypeTest.existing.char"), "hey");
+
+  // All the combinations of attempted type changes
+  do_check_throws(function() {
+    userBranch.setCharPref("TypeTest.existing.bool", "boo"); }, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    userBranch.setIntPref("TypeTest.existing.bool", 5); }, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    userBranch.setCharPref("TypeTest.existing.int", "boo"); }, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    userBranch.setBoolPref("TypeTest.existing.int", true); }, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    userBranch.setBoolPref("TypeTest.existing.char", true); }, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    userBranch.setIntPref("TypeTest.existing.char", 6); }, Cr.NS_ERROR_UNEXPECTED);
+
+
+  //**************************************************************************//
+  // Prefs that don't have default values can mutate
+  let pref = "TypeTest.user";
+  userBranch.setBoolPref(pref, true);
+  userBranch.setCharPref(pref, "yay");
+  do_check_eq(userBranch.getCharPref(pref), "yay");
+  userBranch.setIntPref(pref, 7);
+  do_check_eq(userBranch.getIntPref(pref), 7);
+  userBranch.setBoolPref(pref, false);
+  do_check_eq(userBranch.getBoolPref(pref), false);
+  userBranch.setIntPref(pref, 8);
+  do_check_eq(userBranch.getIntPref(pref), 8);
+  userBranch.setCharPref(pref, "whee");
+  do_check_eq(userBranch.getCharPref(pref), "whee");
+  userBranch.setBoolPref(pref, true);
+  do_check_eq(userBranch.getBoolPref(pref), true);
+}

modules/libpref/test/unit/test_dirtyPrefs.js

@@ -0,0 +1,75 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Tests for handling of the preferences 'dirty' flag (bug 985998) */
+
+const PREF_INVALID = 0;
+const PREF_BOOL    = 128;
+const PREF_INT     = 64;
+const PREF_STRING  = 32;
+
+function run_test() {
+
+  var ps = Cc["@mozilla.org/preferences-service;1"].
+            getService(Ci.nsIPrefService);
+
+  let defaultBranch = ps.getDefaultBranch("");
+  let userBranch = ps.getBranch("");
+
+  let prefFile = do_get_profile();
+  prefFile.append("prefs.js");
+
+  //**************************************************************************//
+  // prefs are not dirty after a write
+  ps.savePrefFile(prefFile);
+  do_check_false(ps.dirty);
+
+  // set a new a user value, we should become dirty
+  userBranch.setBoolPref("DirtyTest.new.bool", true);
+  do_check_true(ps.dirty);
+  ps.savePrefFile(prefFile);
+  // Overwrite a pref with the same value => not dirty
+  userBranch.setBoolPref("DirtyTest.new.bool", true);
+  do_check_false(ps.dirty);
+
+  // Repeat for the other two types
+  userBranch.setIntPref("DirtyTest.new.int", 1);
+  do_check_true(ps.dirty);
+  ps.savePrefFile(prefFile);
+  // Overwrite a pref with the same value => not dirty
+  userBranch.setIntPref("DirtyTest.new.int", 1);
+  do_check_false(ps.dirty);
+
+  userBranch.setCharPref("DirtyTest.new.char", "oop");
+  do_check_true(ps.dirty);
+  ps.savePrefFile(prefFile);
+  // Overwrite a pref with the same value => not dirty
+  userBranch.setCharPref("DirtyTest.new.char", "oop");
+  do_check_false(ps.dirty);
+
+  // change *type* of a user value -> dirty
+  userBranch.setBoolPref("DirtyTest.new.char", false);
+  do_check_true(ps.dirty);
+  ps.savePrefFile(prefFile);
+
+  // Set a default pref => not dirty (defaults don't go into prefs.js)
+  defaultBranch.setBoolPref("DirtyTest.existing.bool", true);
+  do_check_false(ps.dirty);
+  // Fail to change type of a pref with default value -> not dirty
+  do_check_throws(function() {
+    userBranch.setCharPref("DirtyTest.existing.bool", "boo"); }, Cr.NS_ERROR_UNEXPECTED);
+  do_check_false(ps.dirty);
+
+  // Set user value same as default, not dirty
+  userBranch.setBoolPref("DirtyTest.existing.bool", true);
+  do_check_false(ps.dirty);
+  // User value different from default, dirty
+  userBranch.setBoolPref("DirtyTest.existing.bool", false);
+  do_check_true(ps.dirty);
+  ps.savePrefFile(prefFile);
+  // Back to default value, dirty again
+  userBranch.setBoolPref("DirtyTest.existing.bool", true);
+  do_check_true(ps.dirty);
+  ps.savePrefFile(prefFile);
+}

modules/libpref/test/unit/test_extprefs.js

@@ -0,0 +1,70 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/  */
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+// The profile directory is already set up in the head_ files.
+
+function arrayenumerator(a)
+{
+  return {
+    i_: 0,
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsISimpleEnumerator]),
+    hasMoreElements: function ae_hasMoreElements() {
+      return this.i_ < a.length;
+    },
+    getNext: function ae_getNext() {
+      return a[this.i_++];
+    }
+  };
+}
+
+function run_test() {
+  var ps = Cc["@mozilla.org/preferences-service;1"].
+    getService(Ci.nsIPrefService).QueryInterface(Ci.nsIPrefBranch);
+
+  var extprefs = [do_get_file("extdata")];
+  
+  var extProvider = {
+    QueryInterface: XPCOMUtils.generateQI([Ci.nsIDirectoryServiceProvider,
+                                           Ci.nsIDirectoryServiceProvider2]),
+    getFile: function ep_getFile() {
+      throw Cr.NS_ERROR_FAILURE;
+    },
+    
+    getFiles: function ep_getFiles(key) {
+      if (key != "ExtPrefDL")
+        throw Cr.NS_ERROR_FAILURE;
+
+      return arrayenumerator(extprefs);
+    }
+  };
+  
+  let prefFile = do_get_file("data/testPref.js");
+
+  do_check_throws(function() {
+    ps.getBoolPref("testExtPref.bool");
+  }, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    ps.getBoolPref("testPref.bool1");
+  }, Cr.NS_ERROR_UNEXPECTED);
+  
+  ps.readUserPrefs(prefFile);
+
+  do_check_true(ps.getBoolPref("testPref.bool1"));
+  ps.setBoolPref("testPref.bool1", false);
+  do_check_false(ps.getBoolPref("testPref.bool1"));
+  
+  dirSvc.registerProvider(extProvider);
+  Services.obs.notifyObservers(null, "load-extension-defaults", null);
+
+  // The extension default should be available.
+  do_check_true(ps.getBoolPref("testExtPref.bool"));
+
+  // The extension default should not override existing user prefs
+  do_check_false(ps.getBoolPref("testPref.bool2"));
+
+  // The extension default should not modify existing set values
+  do_check_false(ps.getBoolPref("testPref.bool1"));
+}

modules/libpref/test/unit/test_libPrefs.js

@@ -0,0 +1,392 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const PREF_INVALID = 0;
+const PREF_BOOL    = 128;
+const PREF_INT     = 64;
+const PREF_STRING  = 32;
+
+const MAX_PREF_LENGTH = 1 * 1024 * 1024;
+
+function makeList(a)
+{
+  var o = {};
+  for(var i=0; i<a.length; i++)
+  {
+    o[a[i]] = '';
+  }
+  return o;
+}
+
+function run_test() {
+
+  var ps = Cc["@mozilla.org/preferences-service;1"].
+            getService(Ci.nsIPrefService);
+
+  var pb2= Cc["@mozilla.org/preferences-service;1"].
+            getService(Ci.nsIPrefBranch);
+
+  var pb = Cc["@mozilla.org/preferences-service;1"].
+            getService(Ci.nsIPrefBranch);
+
+  //**************************************************************************//
+  // Nullsafety
+
+  do_check_throws(function() {
+    pb.getPrefType(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.getBoolPref(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.setBoolPref(null, false); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.getIntPref(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.setIntPref(null, 0); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.getCharPref(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.setCharPref(null, null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.getComplexValue(null, Components.interfaces.nsISupportsString); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.setComplexValue(null, Components.interfaces.nsISupportsString, pb); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.clearUserPref(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.prefHasUserValue(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.lockPref(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.prefIsLocked(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.unlockPref(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.deleteBranch(null); },  Cr.NS_ERROR_INVALID_ARG);
+  do_check_throws(function() {
+    pb.getChildList(null); },  Cr.NS_ERROR_INVALID_ARG);
+
+  //**************************************************************************//
+  // Nonexisting user preferences
+
+  do_check_eq(pb.prefHasUserValue("UserPref.nonexistent.hasUserValue"), false);
+  pb.clearUserPref("UserPref.nonexistent.clearUserPref"); // shouldn't throw
+  do_check_eq(pb.getPrefType("UserPref.nonexistent.getPrefType"), PREF_INVALID);
+  do_check_eq(pb.root, "");
+
+  // bool...
+  do_check_throws(function() {
+    pb.getBoolPref("UserPref.nonexistent.getBoolPref");}, Cr.NS_ERROR_UNEXPECTED);
+  pb.setBoolPref("UserPref.nonexistent.setBoolPref", false);
+  do_check_eq(pb.getBoolPref("UserPref.nonexistent.setBoolPref"), false);
+
+  // int...
+  do_check_throws(function() {
+    pb.getIntPref("UserPref.nonexistent.getIntPref");}, Cr.NS_ERROR_UNEXPECTED);
+  pb.setIntPref("UserPref.nonexistent.setIntPref", 5);
+  do_check_eq(pb.getIntPref("UserPref.nonexistent.setIntPref"), 5);
+
+  // char
+  do_check_throws(function() {
+    pb.getCharPref("UserPref.nonexistent.getCharPref");}, Cr.NS_ERROR_UNEXPECTED);
+  pb.setCharPref("UserPref.nonexistent.setCharPref", "_test");
+  do_check_eq(pb.getCharPref("UserPref.nonexistent.setCharPref"), "_test");
+
+  //**************************************************************************//
+  // Existing user Prefs and data integrity test (round-trip match)
+
+  pb.setBoolPref("UserPref.existing.bool", true);
+  pb.setIntPref("UserPref.existing.int", 23);
+  pb.setCharPref("UserPref.existing.char", "hey");
+
+  // getPref should return the pref value
+  do_check_eq(pb.getBoolPref("UserPref.existing.bool"), true);
+  do_check_eq(pb.getIntPref("UserPref.existing.int"), 23);
+  do_check_eq(pb.getCharPref("UserPref.existing.char"), "hey");
+
+  // setPref should not complain and should change the value of the pref
+  pb.setBoolPref("UserPref.existing.bool", false);
+  do_check_eq(pb.getBoolPref("UserPref.existing.bool"), false);
+  pb.setIntPref("UserPref.existing.int", 24);
+  do_check_eq(pb.getIntPref("UserPref.existing.int"), 24);
+  pb.setCharPref("UserPref.existing.char", "hej då!");
+  do_check_eq(pb.getCharPref("UserPref.existing.char"), "hej då!");
+
+  // prefHasUserValue should return true now
+  do_check_true(pb.prefHasUserValue("UserPref.existing.bool"));
+  do_check_true(pb.prefHasUserValue("UserPref.existing.int"));
+  do_check_true(pb.prefHasUserValue("UserPref.existing.char"));
+
+  // clearUserPref should remove the pref
+  pb.clearUserPref("UserPref.existing.bool");
+  do_check_false(pb.prefHasUserValue("UserPref.existing.bool"));
+  pb.clearUserPref("UserPref.existing.int");
+  do_check_false(pb.prefHasUserValue("UserPref.existing.int"));
+  pb.clearUserPref("UserPref.existing.char");
+  do_check_false(pb.prefHasUserValue("UserPref.existing.char"));
+
+  //**************************************************************************//
+  // Large value test
+
+  let largeStr = new Array(MAX_PREF_LENGTH + 1).join('x');
+  pb.setCharPref("UserPref.large.char", largeStr);
+  largeStr += 'x';
+  do_check_throws(function() {
+    pb.setCharPref("UserPref.large.char", largeStr); }, Cr.NS_ERROR_ILLEGAL_VALUE);
+
+  //**************************************************************************//
+  // getPrefType test
+
+  // bool...
+  pb.setBoolPref("UserPref.getPrefType.bool", true);
+  do_check_eq(pb.getPrefType("UserPref.getPrefType.bool"), PREF_BOOL);
+
+  // int...
+  pb.setIntPref("UserPref.getPrefType.int", -234);
+  do_check_eq(pb.getPrefType("UserPref.getPrefType.int"), PREF_INT);
+
+  // char...
+  pb.setCharPref("UserPref.getPrefType.char", "testing1..2");
+  do_check_eq(pb.getPrefType("UserPref.getPrefType.char"), PREF_STRING);
+
+  //**************************************************************************//
+  // getBranch tests
+  
+  do_check_eq(ps.root, "");
+
+  // bool ...
+  pb.setBoolPref("UserPref.root.boolPref", true);
+  let pb_1 = ps.getBranch("UserPref.root.");
+  do_check_eq(pb_1.getBoolPref("boolPref"), true);
+  let pb_2 = ps.getBranch("UserPref.root.boolPref");
+  do_check_eq(pb_2.getBoolPref(""), true);
+  pb_2.setBoolPref(".anotherPref", false);
+  let pb_3 = ps.getBranch("UserPref.root.boolPre");
+  do_check_eq(pb_3.getBoolPref("f.anotherPref"), false);
+
+  // int ...
+  pb.setIntPref("UserPref.root.intPref", 23);
+  pb_1 = ps.getBranch("UserPref.root.");
+  do_check_eq(pb_1.getIntPref("intPref"), 23);
+  pb_2 = ps.getBranch("UserPref.root.intPref");
+  do_check_eq(pb_2.getIntPref(""), 23);
+  pb_2.setIntPref(".anotherPref", 69);
+  pb_3 = ps.getBranch("UserPref.root.intPre");
+  do_check_eq(pb_3.getIntPref("f.anotherPref"), 69);
+
+  // char...
+  pb.setCharPref("UserPref.root.charPref", "_char");
+  pb_1 = ps.getBranch("UserPref.root.");
+  do_check_eq(pb_1.getCharPref("charPref"), "_char");
+  pb_2 = ps.getBranch("UserPref.root.charPref");
+  do_check_eq(pb_2.getCharPref(""), "_char");
+  pb_2.setCharPref(".anotherPref", "_another");
+  pb_3 = ps.getBranch("UserPref.root.charPre");
+  do_check_eq(pb_3.getCharPref("f.anotherPref"), "_another");
+
+  //**************************************************************************//
+  // getChildlist tests
+
+  // get an already set prefBranch
+  pb1 = ps.getBranch("UserPref.root.");
+  let prefList = pb1.getChildList("");
+  do_check_eq(prefList.length, 6);
+
+  // check for specific prefs in the array : the order is not important
+  do_check_true("boolPref" in makeList(prefList));
+  do_check_true("intPref" in makeList(prefList));
+  do_check_true("charPref" in makeList(prefList));
+  do_check_true("boolPref.anotherPref" in makeList(prefList));
+  do_check_true("intPref.anotherPref" in makeList(prefList));
+  do_check_true("charPref.anotherPref" in makeList(prefList));
+
+  //**************************************************************************//
+  // Default branch tests
+
+  // bool...
+  pb1 = ps.getDefaultBranch("");
+  pb1.setBoolPref("DefaultPref.bool", true);
+  do_check_eq(pb1.getBoolPref("DefaultPref.bool"), true);  
+  do_check_false(pb1.prefHasUserValue("DefaultPref.bool"));
+  ps.setBoolPref("DefaultPref.bool", false);
+  do_check_true(pb1.prefHasUserValue("DefaultPref.bool"));
+  do_check_eq(ps.getBoolPref("DefaultPref.bool"), false); 
+
+  // int...
+  pb1 = ps.getDefaultBranch("");
+  pb1.setIntPref("DefaultPref.int", 100);
+  do_check_eq(pb1.getIntPref("DefaultPref.int"), 100);  
+  do_check_false(pb1.prefHasUserValue("DefaultPref.int"));
+  ps.setIntPref("DefaultPref.int", 50);
+  do_check_true(pb1.prefHasUserValue("DefaultPref.int"));
+  do_check_eq(ps.getIntPref("DefaultPref.int"), 50); 
+
+  // char...
+  pb1 = ps.getDefaultBranch("");
+  pb1.setCharPref("DefaultPref.char", "_default");
+  do_check_eq(pb1.getCharPref("DefaultPref.char"), "_default");  
+  do_check_false(pb1.prefHasUserValue("DefaultPref.char"));
+  ps.setCharPref("DefaultPref.char", "_user");
+  do_check_true(pb1.prefHasUserValue("DefaultPref.char"));
+  do_check_eq(ps.getCharPref("DefaultPref.char"), "_user"); 
+
+  //**************************************************************************//
+  // pref Locking/Unlocking tests
+
+  // locking and unlocking a nonexistent pref should throw
+  do_check_throws(function() {
+    ps.lockPref("DefaultPref.nonexistent");}, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    ps.unlockPref("DefaultPref.nonexistent");}, Cr.NS_ERROR_UNEXPECTED);
+
+  // getting a locked pref branch should return the "default" value
+  do_check_false(ps.prefIsLocked("DefaultPref.char"));
+  ps.lockPref("DefaultPref.char");
+  do_check_eq(ps.getCharPref("DefaultPref.char"), "_default"); 
+  do_check_true(ps.prefIsLocked("DefaultPref.char"));
+
+  // getting an unlocked pref branch should return the "user" value 
+  ps.unlockPref("DefaultPref.char");
+  do_check_eq(ps.getCharPref("DefaultPref.char"), "_user"); 
+  do_check_false(ps.prefIsLocked("DefaultPref.char"));
+
+  // setting the "default" value to a user pref branch should
+  // make prefHasUserValue return false (documented behavior)
+  ps.setCharPref("DefaultPref.char", "_default");
+  do_check_false(pb1.prefHasUserValue("DefaultPref.char"));
+
+  // unlocking and locking multiple times shouldn't throw
+  ps.unlockPref("DefaultPref.char");
+  ps.lockPref("DefaultPref.char");
+  ps.lockPref("DefaultPref.char");
+
+  //**************************************************************************//
+  // resetBranch test
+
+  // NOT IMPLEMENTED YET in module/libpref. So we're not testing !
+  // uncomment the following if resetBranch ever gets implemented.
+  /*ps.resetBranch("DefaultPref");
+  do_check_eq(ps.getBoolPref("DefaultPref.bool"), true);
+  do_check_eq(ps.getIntPref("DefaultPref.int"), 100);
+  do_check_eq(ps.getCharPref("DefaultPref.char"), "_default");*/
+
+  //**************************************************************************//
+  // deleteBranch tests
+
+  // TODO : Really, this should throw!, by documentation.
+  // do_check_throws(function() {
+  // ps.deleteBranch("UserPref.nonexistent.deleteBranch");}, Cr.NS_ERROR_UNEXPECTED);
+
+  ps.deleteBranch("DefaultPref");
+  pb = ps.getBranch("DefaultPref");
+  pb1 = ps.getDefaultBranch("DefaultPref");
+
+  // getting prefs on deleted user branches should throw
+  do_check_throws(function() {
+    pb.getBoolPref("DefaultPref.bool");}, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    pb.getIntPref("DefaultPref.int");}, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    pb.getCharPref("DefaultPref.char");}, Cr.NS_ERROR_UNEXPECTED);
+
+  // getting prefs on deleted default branches should throw
+  do_check_throws(function() {
+    pb1.getBoolPref("DefaultPref.bool");}, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    pb1.getIntPref("DefaultPref.int");}, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    pb1.getCharPref("DefaultPref.char");}, Cr.NS_ERROR_UNEXPECTED);
+
+  //**************************************************************************//
+  // savePrefFile & readPrefFile tests
+
+  // set some prefs
+  ps.setBoolPref("ReadPref.bool", true);
+  ps.setIntPref("ReadPref.int", 230);
+  ps.setCharPref("ReadPref.char", "hello");
+
+  // save those prefs in a file
+  let savePrefFile = do_get_cwd();
+  savePrefFile.append("data");
+  savePrefFile.append("savePref.js");
+  if (savePrefFile.exists())
+    savePrefFile.remove(false);
+  savePrefFile.create(Ci.nsIFile.NORMAL_FILE_TYPE, 0o666);
+  ps.savePrefFile(savePrefFile);
+  ps.resetPrefs();
+
+  // load a preexisting pref file
+  let prefFile = do_get_file("data/testPref.js");
+  ps.readUserPrefs(prefFile);
+
+  // former prefs should have been replaced/lost
+  do_check_throws(function() {
+    do_check_eq(pb.getBoolPref("ReadPref.bool"));}, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    do_check_eq(pb.getIntPref("ReadPref.int"));}, Cr.NS_ERROR_UNEXPECTED);
+  do_check_throws(function() {
+    do_check_eq(pb.getCharPref("ReadPref.char"));}, Cr.NS_ERROR_UNEXPECTED);
+
+  // loaded prefs should read ok.
+  pb = ps.getBranch("testPref.");
+  do_check_eq(pb.getBoolPref("bool1"), true);
+  do_check_eq(pb.getBoolPref("bool2"), false);
+  do_check_eq(pb.getIntPref("int1"), 23);
+  do_check_eq(pb.getIntPref("int2"), -1236);
+  do_check_eq(pb.getCharPref("char1"), "_testPref");
+  do_check_eq(pb.getCharPref("char2"), "älskar");
+
+  // loading our former savePrefFile should allow us to read former prefs
+  ps.readUserPrefs(savePrefFile);
+  // cleanup the file now we don't need it
+  savePrefFile.remove(false);
+  do_check_eq(ps.getBoolPref("ReadPref.bool"), true);
+  do_check_eq(ps.getIntPref("ReadPref.int"), 230);
+  do_check_eq(ps.getCharPref("ReadPref.char"), "hello");
+
+  // ... and still be able to access "prior-to-readUserPrefs" preferences
+  do_check_eq(pb.getBoolPref("bool1"), true);
+  do_check_eq(pb.getBoolPref("bool2"), false);
+  do_check_eq(pb.getIntPref("int1"), 23);
+
+  //**************************************************************************//
+  // preference Observers
+
+  // an observer...
+  var observer = {
+    QueryInterface: function QueryInterface(aIID) {
+      if (aIID.equals(Ci.nsIObserver) ||
+          aIID.equals(Ci.nsISupports))
+         return this;
+      throw Components.results.NS_NOINTERFACE;
+    },
+
+    observe: function observe(aSubject, aTopic, aState) {
+      do_check_eq(aTopic, "nsPref:changed");
+      do_check_eq(aState, "ReadPref.int");
+      do_check_eq(ps.getIntPref(aState), 76);
+      ps.removeObserver("ReadPref.int", this);
+
+      // notification received, we may go on...
+      do_test_finished();
+    }
+  }
+
+  pb2.addObserver("ReadPref.int", observer, false);
+  ps.setIntPref("ReadPref.int", 76);
+
+  // test will continue upon notification...
+  do_test_pending();
+
+  // removed observer should not fire
+  pb2.removeObserver("ReadPref.int", observer);
+  ps.setIntPref("ReadPref.int", 32);
+
+  // let's test observers once more with a non-root prefbranch
+  pb2.getBranch("ReadPref.");
+  pb2.addObserver("int", observer, false);
+  ps.setIntPref("ReadPref.int", 76);
+
+  // test will complete upon notification...
+  do_test_pending();
+}

modules/libpref/test/unit/test_stickyprefs.js

@@ -0,0 +1,170 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/licenses/publicdomain/  */
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+const ps = Services.prefs;
+
+// Once we fetch the profile directory the xpcshell test harness will send
+// a profile-before-change notification at shutdown. This causes the prefs
+// service to flush the prefs file - and the prefs file it uses ends up being
+// testPrefSticky*.js in the test dir. This upsets things in confusing ways :)
+// We avoid this by ensuring our "temp" prefs.js is the current prefs file.
+do_get_profile();
+do_register_cleanup(saveAndReload);
+
+// A little helper to reset the service and load some pref files
+function resetAndLoad(filenames) {
+  ps.resetPrefs();
+  for (let filename of filenames) {
+    ps.readUserPrefs(do_get_file(filename));
+  }
+}
+
+// A little helper that saves the current state to a file in the profile
+// dir, then resets the service and re-reads the file it just saved.
+// Used to test what gets actually written - things the pref service decided
+// not to write don't exist at all after this call.
+function saveAndReload() {
+  let file = do_get_profile();
+  file.append("prefs.js");
+  ps.savePrefFile(file);
+
+  // Now reset the pref service and re-read what we saved.
+  ps.resetPrefs();
+  ps.readUserPrefs(file);
+}
+
+function run_test() {
+  run_next_test();
+}
+
+// A sticky pref should not be written if the value is unchanged.
+add_test(function notWrittenWhenUnchanged() {
+  resetAndLoad(["data/testPrefSticky.js"]);
+  Assert.strictEqual(ps.getBoolPref("testPref.unsticky.bool"), true);
+  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), false);
+
+  // write prefs - but we haven't changed the sticky one, so it shouldn't be written.
+  saveAndReload();
+  // sticky should not have been written to the new file.
+  try {
+    ps.getBoolPref("testPref.sticky.bool");
+    Assert.ok(false, "expected failure reading this pref");
+  } catch (ex) {
+    Assert.ok(ex, "exception reading regular pref");
+  }
+  run_next_test();
+});
+
+// Loading a sticky_pref then a user_pref for the same pref means it should
+// always be written.
+add_test(function writtenOnceLoadedWithoutChange() {
+  // Load the same pref file *as well as* a pref file that has a user_pref for
+  // our sticky with the default value. It should be re-written without us
+  // touching it.
+  resetAndLoad(["data/testPrefSticky.js", "data/testPrefStickyUser.js"]);
+  // reset and re-read what we just wrote - it should be written.
+  saveAndReload();
+  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), false,
+                     "user_pref was written with default value");
+  run_next_test();
+});
+
+// If a sticky pref is explicicitly changed, even to the default, it is written.
+add_test(function writtenOnceLoadedWithChangeNonDefault() {
+  // Load the same pref file *as well as* a pref file that has a user_pref for
+  // our sticky - then change the pref. It should be written.
+  resetAndLoad(["data/testPrefSticky.js", "data/testPrefStickyUser.js"]);
+  // Set a new val and check we wrote it.
+  ps.setBoolPref("testPref.sticky.bool", false);
+  saveAndReload();
+  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), false,
+                     "user_pref was written with custom value");
+  run_next_test();
+});
+
+// If a sticky pref is changed to the non-default value, it is written.
+add_test(function writtenOnceLoadedWithChangeNonDefault() {
+  // Load the same pref file *as well as* a pref file that has a user_pref for
+  // our sticky - then change the pref. It should be written.
+  resetAndLoad(["data/testPrefSticky.js", "data/testPrefStickyUser.js"]);
+  // Set a new val and check we wrote it.
+  ps.setBoolPref("testPref.sticky.bool", true);
+  saveAndReload();
+  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), true,
+                     "user_pref was written with custom value");
+  run_next_test();
+});
+
+// Test that prefHasUserValue always returns true whenever there is a sticky
+// value, even when that value matches the default. This is mainly for
+// about:config semantics - prefs with a sticky value always remain bold and
+// always offer "reset" (which fully resets and drops the sticky value as if
+// the pref had never changed.)
+add_test(function hasUserValue() {
+  // sticky pref without user value.
+  resetAndLoad(["data/testPrefSticky.js"]);
+  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), false);
+  Assert.ok(!ps.prefHasUserValue("testPref.sticky.bool"),
+            "should not initially reflect a user value");
+
+  ps.setBoolPref("testPref.sticky.bool", false);
+  Assert.ok(ps.prefHasUserValue("testPref.sticky.bool"),
+            "should reflect a user value after set to default");
+
+  ps.setBoolPref("testPref.sticky.bool", true);
+  Assert.ok(ps.prefHasUserValue("testPref.sticky.bool"),
+            "should reflect a user value after change to non-default");
+
+  ps.clearUserPref("testPref.sticky.bool");
+  Assert.ok(!ps.prefHasUserValue("testPref.sticky.bool"),
+            "should reset to no user value");
+  ps.setBoolPref("testPref.sticky.bool", false, "expected default");
+
+  // And make sure the pref immediately reflects a user value after load.
+  resetAndLoad(["data/testPrefSticky.js", "data/testPrefStickyUser.js"]);
+  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), false);
+  Assert.ok(ps.prefHasUserValue("testPref.sticky.bool"),
+            "should have a user value when loaded value is the default");
+  run_next_test();
+});
+
+// Test that clearUserPref removes the "sticky" value.
+add_test(function clearUserPref() {
+  // load things such that we have a sticky value which is the same as the
+  // default.
+  resetAndLoad(["data/testPrefSticky.js", "data/testPrefStickyUser.js"]);
+  ps.clearUserPref("testPref.sticky.bool");
+
+  // Once we save prefs the sticky pref should no longer be written.
+  saveAndReload();
+  try {
+    ps.getBoolPref("testPref.sticky.bool");
+    Assert.ok(false, "expected failure reading this pref");
+  } catch (ex) {
+    Assert.ok(ex, "pref doesn't have a sticky value");
+  }
+  run_next_test();
+});
+
+// Test that a pref observer gets a notification fired when a sticky pref
+// has it's value changed to the same value as the default. The reason for
+// this behaviour is that later we might have other code that cares about a
+// pref being sticky (IOW, we notify due to the "state" of the pref changing
+// even if the value has not)
+add_test(function observerFires() {
+  // load things so there's no sticky value.
+  resetAndLoad(["data/testPrefSticky.js"]);
+
+  function observe(subject, topic, data) {
+    Assert.equal(data, "testPref.sticky.bool");
+    ps.removeObserver("testPref.sticky.bool", observe);
+    run_next_test();
+  }
+  ps.addObserver("testPref.sticky.bool", observe, false);
+
+  ps.setBoolPref("testPref.sticky.bool", ps.getBoolPref("testPref.sticky.bool"));
+  // and the observer will fire triggering the next text.
+});

modules/libpref/test/unit/test_warnings.js

@@ -0,0 +1,69 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+Cu.import("resource://gre/modules/Promise.jsm");
+
+var cs = Cc["@mozilla.org/consoleservice;1"].
+  getService(Ci.nsIConsoleService);
+var ps = Cc["@mozilla.org/preferences-service;1"].
+  getService(Ci.nsIPrefService);
+
+function makeBuffer(length) {
+  return new Array(length + 1).join('x');
+}
+
+/**
+ * @resolves |true| if execution proceeded without warning,
+ * |false| if there was a warning.
+ */
+function checkWarning(pref, buffer) {
+  let deferred = Promise.defer();
+  let complete = false;
+  let listener = {
+    observe: function(event) {
+      let message = event.message;
+      if (!(message.startsWith("Warning: attempting to write")
+            && message.includes(pref))) {
+        return;
+      }
+      if (complete) {
+        return;
+      }
+      complete = true;
+      do_print("Warning while setting " + pref);
+      cs.unregisterListener(listener);
+      deferred.resolve(true);
+    }
+  };
+  do_timeout(1000, function() {
+    if (complete) {
+      return;
+    }
+    complete = true;
+    do_print("No warning while setting " + pref);
+    cs.unregisterListener(listener);
+    deferred.resolve(false);
+  });
+  cs.registerListener(listener);
+  ps.setCharPref(pref, buffer);
+  return deferred.promise;
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function() {
+  // Simple change, shouldn't cause a warning
+  do_print("Checking that a simple change doesn't cause a warning");
+  let buf = makeBuffer(100);
+  let warned = yield checkWarning("string.accept", buf);
+  do_check_false(warned);
+
+  // Large change, should cause a warning
+  do_print("Checking that a large change causes a warning");
+  buf = makeBuffer(32 * 1024);
+  warned = yield checkWarning("string.warn", buf);
+  do_check_true(warned);
+});

modules/libpref/test/unit/xpcshell.ini

@@ -0,0 +1,18 @@
+[DEFAULT]
+head = head_libPrefs.js
+tail =
+support-files =
+  data/testPref.js
+  extdata/testExt.js
+
+[test_warnings.js]
+[test_bug345529.js]
+[test_bug506224.js]
+[test_bug577950.js]
+[test_bug790374.js]
+[test_stickyprefs.js]
+support-files = data/testPrefSticky.js data/testPrefStickyUser.js
+[test_changeType.js]
+[test_dirtyPrefs.js]
+[test_extprefs.js]
+[test_libPrefs.js]

modules/libpref/test/unit_ipc/test_existing_prefs.js

@@ -0,0 +1,21 @@
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+
+function isParentProcess() {
+    let appInfo = Cc["@mozilla.org/xre/app-info;1"];
+    return (!appInfo || appInfo.getService(Ci.nsIXULRuntime).processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT);
+}
+
+function run_test() {
+  if (isParentProcess() == false) {
+
+    do_load_child_test_harness();
+ 
+    var pb = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+    pb.setBoolPref("Test.IPC.bool.new", true);
+    pb.setIntPref("Test.IPC.int.new", 23);
+    pb.setCharPref("Test.IPC.char.new", "hey");
+
+    run_test_in_child("test_observed_prefs.js");
+  }
+}

modules/libpref/test/unit_ipc/test_initial_prefs.js

@@ -0,0 +1,18 @@
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+
+function isParentProcess() {
+    let appInfo = Cc["@mozilla.org/xre/app-info;1"];
+    return (!appInfo || appInfo.getService(Ci.nsIXULRuntime).processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT);
+}
+
+function run_test() {
+  if (isParentProcess() == false) {
+      var pb = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+      pb.setBoolPref("Test.IPC.bool", true);
+      pb.setIntPref("Test.IPC.int", 23);
+      pb.setCharPref("Test.IPC.char", "hey");
+
+      run_test_in_child("test_existing_prefs.JS");
+  }
+}

modules/libpref/test/unit_ipc/test_large_pref.js

@@ -0,0 +1,98 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Large preferences should not be set in the child process.
+// Non-string preferences are not tested here, because their behavior
+// should not be affected by this filtering.
+
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+
+function isParentProcess() {
+    let appInfo = Cc["@mozilla.org/xre/app-info;1"];
+    return (!appInfo || appInfo.getService(Ci.nsIXULRuntime).processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT);
+}
+
+function makeBuffer(length) {
+    let string = "x";
+    while (string.length < length) {
+      string = string + string;
+    }
+    if (string.length > length) {
+      string = string.substring(length - string.length);
+    }
+    return string;
+}
+
+// from prefapi.h
+const MAX_ADVISABLE_PREF_LENGTH = 4 * 1024;
+
+const largeString = makeBuffer(MAX_ADVISABLE_PREF_LENGTH + 1);
+const smallString = makeBuffer(4);
+
+const testValues = [
+  {name: "None", value: undefined},
+  {name: "Small", value: smallString},
+  {name: "Large", value: largeString},
+];
+
+function prefName(def, user) {
+  return "Test.IPC.default" + def.name + "User" + user.name;
+}
+
+function expectedPrefValue(def, user) {
+  if (user.value) {
+    return user.value;
+  }
+  return def.value;
+}
+
+function run_test() {
+  let pb = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+  let ps = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefService);
+  let defaultBranch = ps.getDefaultBranch("");
+
+  let isParent = isParentProcess();
+  if (isParent) {
+    // Set all combinations of none, small and large, for default and user prefs.
+    for (let def of testValues) {
+      for (let user of testValues) {
+        let currPref = prefName(def, user);
+        if (def.value) {
+          defaultBranch.setCharPref(currPref, def.value);
+        }
+        if (user.value) {
+          pb.setCharPref(currPref, user.value);
+        }
+      }
+    }
+
+    run_test_in_child("test_large_pref.js");
+  }
+
+  // Check that each preference is set or not set, as appropriate.
+  for (let def of testValues) {
+    for (let user of testValues) {
+      if (!def.value && !user.value) {
+        continue;
+      }
+      let pref_name = prefName(def, user);
+      if (isParent || (def.name != "Large" && user.name != "Large")) {
+        do_check_eq(pb.getCharPref(pref_name), expectedPrefValue(def, user));
+      } else {
+        // This is the child, and either the default or user value is
+        // large, so the preference should not be set.
+        let prefExists;
+        try {
+          pb.getCharPref(pref_name);
+          prefExists = true;
+        } catch(e) {
+          prefExists = false;
+        }
+        ok(!prefExists,
+           "Pref " + pref_name + " should not be set in the child");
+      }
+    }
+  }
+}

modules/libpref/test/unit_ipc/test_observed_prefs.js

@@ -0,0 +1,16 @@
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+
+function isParentProcess() {
+    let appInfo = Cc["@mozilla.org/xre/app-info;1"];
+    return (!appInfo || appInfo.getService(Ci.nsIXULRuntime).processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT);
+}
+
+function run_test() {
+  if (isParentProcess() == false) {
+      var pb = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+      do_check_eq(pb.getBoolPref("Test.IPC.bool.new"), true);
+      do_check_eq(pb.getIntPref("Test.IPC.int.new"), 23);
+      do_check_eq(pb.getCharPref("Test.IPC.char.new"), "hey");
+  }
+}

modules/libpref/test/unit_ipc/test_update_prefs.js

@@ -0,0 +1,38 @@
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+
+function isParentProcess() {
+    let appInfo = Cc["@mozilla.org/xre/app-info;1"];
+    return (!appInfo || appInfo.getService(Ci.nsIXULRuntime).processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT);
+}
+
+function run_test() {
+  if (isParentProcess()) {
+
+    do_load_child_test_harness();
+
+    var pb = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+
+    // these prefs are set after the child has been created.
+    pb.setBoolPref("Test.IPC.bool.new", true);
+    pb.setIntPref("Test.IPC.int.new", 23);
+    pb.setCharPref("Test.IPC.char.new", "hey");
+
+    run_test_in_child("test_observed_prefs.js", testPrefClear);
+  }
+}
+
+function testPrefClear() {
+  var pb = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+  pb.clearUserPref("Test.IPC.bool.new");
+
+  sendCommand(
+'var pb = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);\n'+
+'pb.prefHasUserValue("Test.IPC.bool.new");\n',
+    checkWasCleared);
+}
+
+function checkWasCleared(existsStr) {
+    do_check_eq(existsStr, "false");
+    do_test_finished();
+}

modules/libpref/test/unit_ipc/test_user_default_prefs.js

@@ -0,0 +1,76 @@
+var Ci = Components.interfaces;
+var Cc = Components.classes;
+
+var pb = Cc["@mozilla.org/preferences-service;1"].getService(Ci.nsIPrefBranch);
+
+// This pref is chosen somewhat arbitrarily --- we just need one
+// that's guaranteed to have a default value.
+const kPrefName = 'intl.accept_languages'; // of type char, which we
+                                           // assume below
+var initialValue = null;
+
+function check_child_pref_info_eq(continuation) {
+    sendCommand(
+        'var pb = Components.classes["@mozilla.org/preferences-service;1"].getService(Components.interfaces.nsIPrefBranch);\n'+
+        // Returns concatenation "[value],[isUser]"
+        'pb.getCharPref("'+ kPrefName +'")+ "," +'+
+        'pb.prefHasUserValue("'+ kPrefName +'");',
+        function (info) {
+            let [ value, isUser ] = info.split(',');
+            do_check_eq(pb.getCharPref(kPrefName), value);
+            do_check_eq(pb.prefHasUserValue(kPrefName), isUser == "true");
+            continuation();
+        });
+}
+
+function run_test() {
+    // We finish in clean_up()
+    do_test_pending();
+
+    try {
+        if (pb.getCharPref('dom.ipc.processPrelaunch.enabled')) {
+            dump('WARNING: Content process may already have launched, so this test may not be meaningful.');
+        }
+    } catch(e) { }
+
+    initialValue = pb.getCharPref(kPrefName);
+
+    test_user_setting();
+}
+
+function test_user_setting() {
+    // We rely on setting this before the content process starts up.
+    // When it starts up, it should recognize this as a user pref, not
+    // a default pref.
+    pb.setCharPref(kPrefName, 'i-imaginarylanguage');
+    // NB: processing of the value-change notification in the child
+    // process triggered by the above set happens-before the remaining
+    // code here
+    check_child_pref_info_eq(function () {
+            do_check_eq(pb.prefHasUserValue(kPrefName), true);
+
+            test_cleared_is_default();
+        });
+}
+
+function test_cleared_is_default() {
+    pb.clearUserPref(kPrefName);
+    // NB: processing of the value-change notification in the child
+    // process triggered by the above set happens-before the remaining
+    // code here
+    check_child_pref_info_eq(function () {
+            do_check_eq(pb.prefHasUserValue(kPrefName), false);
+
+            clean_up();
+        });
+}
+
+function clean_up() {
+    pb.setCharPref(kPrefName, initialValue);
+    // NB: processing of the value-change notification in the child
+    // process triggered by the above set happens-before the remaining
+    // code here
+    check_child_pref_info_eq(function () {
+            do_test_finished();
+        });
+}

modules/libpref/test/unit_ipc/xpcshell.ini

@@ -0,0 +1,11 @@
+[DEFAULT]
+head = 
+tail = 
+skip-if = toolkit == 'android'
+
+[test_existing_prefs.js]
+[test_initial_prefs.js]
+[test_large_pref.js]
+[test_observed_prefs.js]
+[test_update_prefs.js]
+[test_user_default_prefs.js]