The Tor Browser: toolkit/modules/tests/xpcshell/test

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* Any copyright is dedicated to the Public Domain.

     2  * http://creativecommons.org/publicdomain/zero/1.0/ */

     4 const {classes: Cc, interfaces: Ci, results: Cr, utils: Cu, manager: Cm} = Components;

     6 Cu.import("resource://gre/modules/Preferences.jsm");

     8 function run_test() {

     9   run_next_test();

    10 }

    12 add_test(function test_set_get_pref() {

    13   Preferences.set("test_set_get_pref.integer", 1);

    14   do_check_eq(Preferences.get("test_set_get_pref.integer"), 1);

    16   Preferences.set("test_set_get_pref.string", "foo");

    17   do_check_eq(Preferences.get("test_set_get_pref.string"), "foo");

    19   Preferences.set("test_set_get_pref.boolean", true);

    20   do_check_eq(Preferences.get("test_set_get_pref.boolean"), true);

    22   // Clean up.

    23   Preferences.resetBranch("test_set_get_pref.");

    25   run_next_test();

    26 });

    28 add_test(function test_set_get_branch_pref() {

    29   let prefs = new Preferences("test_set_get_branch_pref.");

    31   prefs.set("something", 1);

    32   do_check_eq(prefs.get("something"), 1);

    33   do_check_false(Preferences.has("something"));

    35   // Clean up.

    36   prefs.reset("something");

    38   run_next_test();

    39 });

    41 add_test(function test_set_get_multiple_prefs() {

    42   Preferences.set({ "test_set_get_multiple_prefs.integer":  1,

    43                     "test_set_get_multiple_prefs.string":   "foo",

    44                     "test_set_get_multiple_prefs.boolean":  true });

    46   let [i, s, b] = Preferences.get(["test_set_get_multiple_prefs.integer",

    47                                    "test_set_get_multiple_prefs.string",

    48                                    "test_set_get_multiple_prefs.boolean"]);

    50   do_check_eq(i, 1);

    51   do_check_eq(s, "foo");

    52   do_check_eq(b, true);

    54   // Clean up.

    55   Preferences.resetBranch("test_set_get_multiple_prefs.");

    57   run_next_test();

    58 });

    60 add_test(function test_get_multiple_prefs_with_default_value() {

    61   Preferences.set({ "test_get_multiple_prefs_with_default_value.a":  1,

    62                     "test_get_multiple_prefs_with_default_value.b":  2 });

    64   let [a, b, c] = Preferences.get(["test_get_multiple_prefs_with_default_value.a",

    65                                    "test_get_multiple_prefs_with_default_value.b",

    66                                    "test_get_multiple_prefs_with_default_value.c"],

    67                                   0);

    69   do_check_eq(a, 1);

    70   do_check_eq(b, 2);

    71   do_check_eq(c, 0);

    73   // Clean up.

    74   Preferences.resetBranch("test_get_multiple_prefs_with_default_value.");

    76   run_next_test();

    77 });

    79 add_test(function test_set_get_unicode_pref() {

    80   Preferences.set("test_set_get_unicode_pref", String.fromCharCode(960));

    81   do_check_eq(Preferences.get("test_set_get_unicode_pref"), String.fromCharCode(960));

    83   // Clean up.

    84   Preferences.reset("test_set_get_unicode_pref");

    86   run_next_test();

    87 });

    89 add_test(function test_set_null_pref() {

    90   try {

    91     Preferences.set("test_set_null_pref", null);

    92     // We expect this to throw, so the test is designed to fail if it doesn't.

    93     do_check_true(false);

    94   }

    95   catch(ex) {}

    97   run_next_test();

    98 });

   100 add_test(function test_set_undefined_pref() {

   101   try {

   102     Preferences.set("test_set_undefined_pref");

   103     // We expect this to throw, so the test is designed to fail if it doesn't.

   104     do_check_true(false);

   105   }

   106   catch(ex) {}

   108   run_next_test();

   109 });

   111 add_test(function test_set_unsupported_pref() {

   112   try {

   113     Preferences.set("test_set_unsupported_pref", new Array());

   114     // We expect this to throw, so the test is designed to fail if it doesn't.

   115     do_check_true(false);

   116   }

   117   catch(ex) {}

   119   run_next_test();

   120 });

   122 // Make sure that we can get a string pref that we didn't set ourselves

   123 // (i.e. that the way we get a string pref using getComplexValue doesn't

   124 // hork us getting a string pref that wasn't set using setComplexValue).

   125 add_test(function test_get_string_pref() {

   126   let svc = Cc["@mozilla.org/preferences-service;1"].

   127             getService(Ci.nsIPrefService).

   128             getBranch("");

   129   svc.setCharPref("test_get_string_pref", "a normal string");

   130   do_check_eq(Preferences.get("test_get_string_pref"), "a normal string");

   132   // Clean up.

   133   Preferences.reset("test_get_string_pref");

   135   run_next_test();

   136 });

   138 add_test(function test_set_get_number_pref() {

   139   Preferences.set("test_set_get_number_pref", 5);

   140   do_check_eq(Preferences.get("test_set_get_number_pref"), 5);

   142   // Non-integer values get converted to integers.

   143   Preferences.set("test_set_get_number_pref", 3.14159);

   144   do_check_eq(Preferences.get("test_set_get_number_pref"), 3);

   146   // Values outside the range -(2^31-1) to 2^31-1 overflow.

   147   try {

   148     Preferences.set("test_set_get_number_pref", Math.pow(2, 31));

   149     // We expect this to throw, so the test is designed to fail if it doesn't.

   150     do_check_true(false);

   151   }

   152   catch(ex) {}

   154   // Clean up.

   155   Preferences.reset("test_set_get_number_pref");

   157   run_next_test();

   158 });

   160 add_test(function test_reset_pref() {

   161   Preferences.set("test_reset_pref", 1);

   162   Preferences.reset("test_reset_pref");

   163   do_check_eq(Preferences.get("test_reset_pref"), undefined);

   165   run_next_test();

   166 });

   168 add_test(function test_reset_pref_branch() {

   169   Preferences.set("test_reset_pref_branch.foo", 1);

   170   Preferences.set("test_reset_pref_branch.bar", 2);

   171   Preferences.resetBranch("test_reset_pref_branch.");

   172   do_check_eq(Preferences.get("test_reset_pref_branch.foo"), undefined);

   173   do_check_eq(Preferences.get("test_reset_pref_branch.bar"), undefined);

   175   run_next_test();

   176 });

   178 // Make sure the module doesn't throw an exception when asked to reset

   179 // a nonexistent pref.

   180 add_test(function test_reset_nonexistent_pref() {

   181   Preferences.reset("test_reset_nonexistent_pref");

   183   run_next_test();

   184 });

   186 // Make sure the module doesn't throw an exception when asked to reset

   187 // a nonexistent pref branch.

   188 add_test(function test_reset_nonexistent_pref_branch() {

   189   Preferences.resetBranch("test_reset_nonexistent_pref_branch.");

   191   run_next_test();

   192 });

   194 add_test(function test_observe_prefs_function() {

   195   let observed = false;

   196   let observer = function() { observed = !observed };

   198   Preferences.observe("test_observe_prefs_function", observer);

   199   Preferences.set("test_observe_prefs_function", "something");

   200   do_check_true(observed);

   202   Preferences.ignore("test_observe_prefs_function", observer);

   203   Preferences.set("test_observe_prefs_function", "something else");

   204   do_check_true(observed);

   206   // Clean up.

   207   Preferences.reset("test_observe_prefs_function");

   209   run_next_test();

   210 });

   212 add_test(function test_observe_prefs_object() {

   213   let observer = {

   214     observed: false,

   215     observe: function() {

   216       this.observed = !this.observed;

   217     }

   218   };

   220   Preferences.observe("test_observe_prefs_object", observer.observe, observer);

   221   Preferences.set("test_observe_prefs_object", "something");

   222   do_check_true(observer.observed);

   224   Preferences.ignore("test_observe_prefs_object", observer.observe, observer);

   225   Preferences.set("test_observe_prefs_object", "something else");

   226   do_check_true(observer.observed);

   228   // Clean up.

   229   Preferences.reset("test_observe_prefs_object");

   231   run_next_test();

   232 });

   234 add_test(function test_observe_prefs_nsIObserver() {

   235   let observer = {

   236     observed: false,

   237     observe: function(subject, topic, data) {

   238       this.observed = !this.observed;

   239       do_check_true(subject instanceof Ci.nsIPrefBranch);

   240       do_check_eq(topic, "nsPref:changed");

   241       do_check_eq(data, "test_observe_prefs_nsIObserver");

   242     }

   243   };

   245   Preferences.observe("test_observe_prefs_nsIObserver", observer);

   246   Preferences.set("test_observe_prefs_nsIObserver", "something");

   247   do_check_true(observer.observed);

   249   Preferences.ignore("test_observe_prefs_nsIObserver", observer);

   250   Preferences.set("test_observe_prefs_nsIObserver", "something else");

   251   do_check_true(observer.observed);

   253   // Clean up.

   254   Preferences.reset("test_observe_prefs_nsIObserver");

   256   run_next_test();

   257 });

   259 /*

   260 add_test(function test_observe_exact_pref() {

   261   let observed = false;

   262   let observer = function() { observed = !observed };

   264   Preferences.observe("test_observe_exact_pref", observer);

   265   Preferences.set("test_observe_exact_pref.sub-pref", "something");

   266   do_check_false(observed);

   268   // Clean up.

   269   Preferences.ignore("test_observe_exact_pref", observer);

   270   Preferences.reset("test_observe_exact_pref.sub-pref");

   272   run_next_test();

   273 });

   274 */

   276 add_test(function test_observe_value_of_set_pref() {

   277   let observer = function(newVal) { do_check_eq(newVal, "something") };

   279   Preferences.observe("test_observe_value_of_set_pref", observer);

   280   Preferences.set("test_observe_value_of_set_pref", "something");

   282   // Clean up.

   283   Preferences.ignore("test_observe_value_of_set_pref", observer);

   284   Preferences.reset("test_observe_value_of_set_pref");

   286   run_next_test();

   287 });

   289 add_test(function test_observe_value_of_reset_pref() {

   290   let observer = function(newVal) { do_check_true(typeof newVal == "undefined") };

   292   Preferences.set("test_observe_value_of_reset_pref", "something");

   293   Preferences.observe("test_observe_value_of_reset_pref", observer);

   294   Preferences.reset("test_observe_value_of_reset_pref");

   296   // Clean up.

   297   Preferences.ignore("test_observe_value_of_reset_pref", observer);

   299   run_next_test();

   300 });

   302 add_test(function test_has_pref() {

   303   do_check_false(Preferences.has("test_has_pref"));

   304   Preferences.set("test_has_pref", "foo");

   305   do_check_true(Preferences.has("test_has_pref"));

   307   Preferences.set("test_has_pref.foo", "foo");

   308   Preferences.set("test_has_pref.bar", "bar");

   309   let [hasFoo, hasBar, hasBaz] = Preferences.has(["test_has_pref.foo",

   310                                                   "test_has_pref.bar",

   311                                                   "test_has_pref.baz"]);

   312   do_check_true(hasFoo);

   313   do_check_true(hasBar);

   314   do_check_false(hasBaz);

   316   // Clean up.

   317   Preferences.resetBranch("test_has_pref");

   319   run_next_test();

   320 });

   322 add_test(function test_isSet_pref() {

   323   // Use a pref that we know has a default value but no user-set value.

   324   // This feels dangerous; perhaps we should create some other default prefs

   325   // that we can use for testing.

   326   do_check_false(Preferences.isSet("toolkit.defaultChromeURI"));

   327   Preferences.set("toolkit.defaultChromeURI", "foo");

   328   do_check_true(Preferences.isSet("toolkit.defaultChromeURI"));

   330   // Clean up.

   331   Preferences.reset("toolkit.defaultChromeURI");

   333   run_next_test();

   334 });

   336 /*

   337 add_test(function test_lock_prefs() {

   338   // Use a pref that we know has a default value.

   339   // This feels dangerous; perhaps we should create some other default prefs

   340   // that we can use for testing.

   341   do_check_false(Preferences.locked("toolkit.defaultChromeURI"));

   342   Preferences.lock("toolkit.defaultChromeURI");

   343   do_check_true(Preferences.locked("toolkit.defaultChromeURI"));

   344   Preferences.unlock("toolkit.defaultChromeURI");

   345   do_check_false(Preferences.locked("toolkit.defaultChromeURI"));

   347   let val = Preferences.get("toolkit.defaultChromeURI");

   348   Preferences.set("toolkit.defaultChromeURI", "test_lock_prefs");

   349   do_check_eq(Preferences.get("toolkit.defaultChromeURI"), "test_lock_prefs");

   350   Preferences.lock("toolkit.defaultChromeURI");

   351   do_check_eq(Preferences.get("toolkit.defaultChromeURI"), val);

   352   Preferences.unlock("toolkit.defaultChromeURI");

   353   do_check_eq(Preferences.get("toolkit.defaultChromeURI"), "test_lock_prefs");

   355   // Clean up.

   356   Preferences.reset("toolkit.defaultChromeURI");

   358   run_next_test();

   359 });

   360 */

The Tor Browser / file revision

toolkit/modules/tests/xpcshell/test_Preferences.js@6474c204b198

toolkit/modules/tests/xpcshell/test_Preferences.js