From 961b4bd2e16d48fc6a6077a5b0b1c83ba89242b9 Mon Sep 17 00:00:00 2001 From: Philipp von Weitershausen Date: Thu, 19 May 2011 21:14:13 -0700 Subject: [PATCH] Bug 613277 - Add tests from JSModules repository --- services/sync/tests/unit/test_Observers.js | 77 ++++ services/sync/tests/unit/test_Preferences.js | 354 +++++++++++++++++++ 2 files changed, 431 insertions(+) create mode 100644 services/sync/tests/unit/test_Observers.js create mode 100644 services/sync/tests/unit/test_Preferences.js diff --git a/services/sync/tests/unit/test_Observers.js b/services/sync/tests/unit/test_Observers.js new file mode 100644 index 00000000000..c85eacf019c --- /dev/null +++ b/services/sync/tests/unit/test_Observers.js @@ -0,0 +1,77 @@ +Components.utils.import("resource://services-sync/ext/Observers.js"); + +let gSubject = {}; + +function test_function_observer() { + let foo = false; + + let onFoo = function(subject, data) { + foo = !foo; + do_check_eq(subject, gSubject); + do_check_eq(data, "some data"); + }; + + Observers.add("foo", onFoo); + Observers.notify("foo", gSubject, "some data"); + + // The observer was notified after being added. + do_check_true(foo); + + Observers.remove("foo", onFoo); + Observers.notify("foo"); + + // The observer was not notified after being removed. + do_check_true(foo); +} + +function test_method_observer() { + let obj = { + foo: false, + onFoo: function(subject, data) { + this.foo = !this.foo; + do_check_eq(subject, gSubject); + do_check_eq(data, "some data"); + } + }; + + // The observer is notified after being added. + Observers.add("foo", obj.onFoo, obj); + Observers.notify("foo", gSubject, "some data"); + do_check_true(obj.foo); + + // The observer is not notified after being removed. + Observers.remove("foo", obj.onFoo, obj); + Observers.notify("foo"); + do_check_true(obj.foo); +} + +function test_object_observer() { + let obj = { + foo: false, + observe: function(subject, topic, data) { + this.foo = !this.foo; + + do_check_eq(subject, gSubject); + do_check_eq(topic, "foo"); + do_check_eq(data, "some data"); + } + }; + + Observers.add("foo", obj); + Observers.notify("foo", gSubject, "some data"); + + // The observer is notified after being added. + do_check_true(obj.foo); + + Observers.remove("foo", obj); + Observers.notify("foo"); + + // The observer is not notified after being removed. + do_check_true(obj.foo); +} + +function run_test() { + test_function_observer(); + test_method_observer(); + test_object_observer(); +} diff --git a/services/sync/tests/unit/test_Preferences.js b/services/sync/tests/unit/test_Preferences.js new file mode 100644 index 00000000000..105834fe8e6 --- /dev/null +++ b/services/sync/tests/unit/test_Preferences.js @@ -0,0 +1,354 @@ +Components.utils.import("resource://services-sync/ext/Preferences.js"); + +function test_set_get_pref() { + Preferences.set("test_set_get_pref.integer", 1); + do_check_eq(Preferences.get("test_set_get_pref.integer"), 1); + + Preferences.set("test_set_get_pref.string", "foo"); + do_check_eq(Preferences.get("test_set_get_pref.string"), "foo"); + + Preferences.set("test_set_get_pref.boolean", true); + do_check_eq(Preferences.get("test_set_get_pref.boolean"), true); + + // Clean up. + Preferences.resetBranch("test_set_get_pref."); +} + +function test_set_get_branch_pref() { + let prefs = new Preferences("test_set_get_branch_pref."); + + prefs.set("something", 1); + do_check_eq(prefs.get("something"), 1); + do_check_false(Preferences.has("something")); + + // Clean up. + prefs.reset("something"); +} + +function test_set_get_multiple_prefs() { + Preferences.set({ "test_set_get_multiple_prefs.integer": 1, + "test_set_get_multiple_prefs.string": "foo", + "test_set_get_multiple_prefs.boolean": true }); + + let [i, s, b] = Preferences.get(["test_set_get_multiple_prefs.integer", + "test_set_get_multiple_prefs.string", + "test_set_get_multiple_prefs.boolean"]); + + do_check_eq(i, 1); + do_check_eq(s, "foo"); + do_check_eq(b, true); + + // Clean up. + Preferences.resetBranch("test_set_get_multiple_prefs."); +} + +function test_get_multiple_prefs_with_default_value() { + Preferences.set({ "test_get_multiple_prefs_with_default_value.a": 1, + "test_get_multiple_prefs_with_default_value.b": 2 }); + + let [a, b, c] = Preferences.get(["test_get_multiple_prefs_with_default_value.a", + "test_get_multiple_prefs_with_default_value.b", + "test_get_multiple_prefs_with_default_value.c"], + 0); + + do_check_eq(a, 1); + do_check_eq(b, 2); + do_check_eq(c, 0); + + // Clean up. + Preferences.resetBranch("test_get_multiple_prefs_with_default_value."); +} + +function test_set_get_unicode_pref() { + Preferences.set("test_set_get_unicode_pref", String.fromCharCode(960)); + do_check_eq(Preferences.get("test_set_get_unicode_pref"), String.fromCharCode(960)); + + // Clean up. + Preferences.reset("test_set_get_unicode_pref"); +} + +function test_set_null_pref() { + try { + Preferences.set("test_set_null_pref", null); + // We expect this to throw, so the test is designed to fail if it doesn't. + do_check_true(false); + } + catch(ex) {} +} + +function test_set_undefined_pref() { + try { + Preferences.set("test_set_undefined_pref"); + // We expect this to throw, so the test is designed to fail if it doesn't. + do_check_true(false); + } + catch(ex) {} +} + +function test_set_unsupported_pref() { + try { + Preferences.set("test_set_unsupported_pref", new Array()); + // We expect this to throw, so the test is designed to fail if it doesn't. + do_check_true(false); + } + catch(ex) {} +} + +// Make sure that we can get a string pref that we didn't set ourselves +// (i.e. that the way we get a string pref using getComplexValue doesn't +// hork us getting a string pref that wasn't set using setComplexValue). +function test_get_string_pref() { + let svc = Cc["@mozilla.org/preferences-service;1"]. + getService(Ci.nsIPrefService). + getBranch(""); + svc.setCharPref("test_get_string_pref", "a normal string"); + do_check_eq(Preferences.get("test_get_string_pref"), "a normal string"); + + // Clean up. + Preferences.reset("test_get_string_pref"); +} + +function test_set_get_number_pref() { + Preferences.set("test_set_get_number_pref", 5); + do_check_eq(Preferences.get("test_set_get_number_pref"), 5); + + // Non-integer values get converted to integers. + Preferences.set("test_set_get_number_pref", 3.14159); + do_check_eq(Preferences.get("test_set_get_number_pref"), 3); + + // Values outside the range -(2^31-1) to 2^31-1 overflow. + try { + Preferences.set("test_set_get_number_pref", Math.pow(2, 31)); + // We expect this to throw, so the test is designed to fail if it doesn't. + do_check_true(false); + } + catch(ex) {} + + // Clean up. + Preferences.reset("test_set_get_number_pref"); +} + +function test_reset_pref() { + Preferences.set("test_reset_pref", 1); + Preferences.reset("test_reset_pref"); + do_check_eq(Preferences.get("test_reset_pref"), undefined); +} + +function test_reset_pref_branch() { + Preferences.set("test_reset_pref_branch.foo", 1); + Preferences.set("test_reset_pref_branch.bar", 2); + Preferences.resetBranch("test_reset_pref_branch."); + do_check_eq(Preferences.get("test_reset_pref_branch.foo"), undefined); + do_check_eq(Preferences.get("test_reset_pref_branch.bar"), undefined); +} + +// Make sure the module doesn't throw an exception when asked to reset +// a nonexistent pref. +function test_reset_nonexistent_pref() { + Preferences.reset("test_reset_nonexistent_pref"); +} + +// Make sure the module doesn't throw an exception when asked to reset +// a nonexistent pref branch. +function test_reset_nonexistent_pref_branch() { + Preferences.resetBranch("test_reset_nonexistent_pref_branch."); +} + +function test_observe_prefs_function() { + let observed = false; + let observer = function() { observed = !observed }; + + Preferences.observe("test_observe_prefs_function", observer); + Preferences.set("test_observe_prefs_function", "something"); + do_check_true(observed); + + Preferences.ignore("test_observe_prefs_function", observer); + Preferences.set("test_observe_prefs_function", "something else"); + do_check_true(observed); + + // Clean up. + Preferences.reset("test_observe_prefs_function"); +} + +function test_observe_prefs_object() { + let observer = { + observed: false, + observe: function() { + this.observed = !this.observed; + } + }; + + Preferences.observe("test_observe_prefs_object", observer.observe, observer); + Preferences.set("test_observe_prefs_object", "something"); + do_check_true(observer.observed); + + Preferences.ignore("test_observe_prefs_object", observer.observe, observer); + Preferences.set("test_observe_prefs_object", "something else"); + do_check_true(observer.observed); + + // Clean up. + Preferences.reset("test_observe_prefs_object"); +} + +function test_observe_prefs_nsIObserver() { + let observer = { + observed: false, + observe: function(subject, topic, data) { + this.observed = !this.observed; + do_check_true(subject instanceof Ci.nsIPrefBranch2); + do_check_eq(topic, "nsPref:changed"); + do_check_eq(data, "test_observe_prefs_nsIObserver"); + } + }; + + Preferences.observe("test_observe_prefs_nsIObserver", observer); + Preferences.set("test_observe_prefs_nsIObserver", "something"); + do_check_true(observer.observed); + + Preferences.ignore("test_observe_prefs_nsIObserver", observer); + Preferences.set("test_observe_prefs_nsIObserver", "something else"); + do_check_true(observer.observed); + + // Clean up. + Preferences.reset("test_observe_prefs_nsIObserver"); +} + +function test_observe_exact_pref() { + let observed = false; + let observer = function() { observed = !observed }; + + Preferences.observe("test_observe_exact_pref", observer); + Preferences.set("test_observe_exact_pref.sub-pref", "something"); + do_check_false(observed); + + // Clean up. + Preferences.ignore("test_observe_exact_pref", observer); + Preferences.reset("test_observe_exact_pref.sub-pref"); +} + +function test_observe_value_of_set_pref() { + let observer = function(newVal) { do_check_eq(newVal, "something") }; + + Preferences.observe("test_observe_value_of_set_pref", observer); + Preferences.set("test_observe_value_of_set_pref", "something"); + + // Clean up. + Preferences.ignore("test_observe_value_of_set_pref", observer); + Preferences.reset("test_observe_value_of_set_pref"); +} + +function test_observe_value_of_reset_pref() { + let observer = function(newVal) { do_check_true(typeof newVal == "undefined") }; + + Preferences.set("test_observe_value_of_reset_pref", "something"); + Preferences.observe("test_observe_value_of_reset_pref", observer); + Preferences.reset("test_observe_value_of_reset_pref"); + + // Clean up. + Preferences.ignore("test_observe_value_of_reset_pref", observer); +} + +function test_has_pref() { + do_check_false(Preferences.has("test_has_pref")); + Preferences.set("test_has_pref", "foo"); + do_check_true(Preferences.has("test_has_pref")); + + Preferences.set("test_has_pref.foo", "foo"); + Preferences.set("test_has_pref.bar", "bar"); + let [hasFoo, hasBar, hasBaz] = Preferences.has(["test_has_pref.foo", + "test_has_pref.bar", + "test_has_pref.baz"]); + do_check_true(hasFoo); + do_check_true(hasBar); + do_check_false(hasBaz); + + // Clean up. + Preferences.resetBranch("test_has_pref"); +} + +function test_isSet_pref() { + // Use a pref that we know has a default value but no user-set value. + // This feels dangerous; perhaps we should create some other default prefs + // that we can use for testing. + do_check_false(Preferences.isSet("toolkit.defaultChromeURI")); + Preferences.set("toolkit.defaultChromeURI", "foo"); + do_check_true(Preferences.isSet("toolkit.defaultChromeURI")); + + // Clean up. + Preferences.reset("toolkit.defaultChromeURI"); +} + +function test_lock_prefs() { + // Use a pref that we know has a default value. + // This feels dangerous; perhaps we should create some other default prefs + // that we can use for testing. + do_check_false(Preferences.locked("toolkit.defaultChromeURI")); + Preferences.lock("toolkit.defaultChromeURI"); + do_check_true(Preferences.locked("toolkit.defaultChromeURI")); + Preferences.unlock("toolkit.defaultChromeURI"); + do_check_false(Preferences.locked("toolkit.defaultChromeURI")); + + let val = Preferences.get("toolkit.defaultChromeURI"); + Preferences.set("toolkit.defaultChromeURI", "test_lock_prefs"); + do_check_eq(Preferences.get("toolkit.defaultChromeURI"), "test_lock_prefs"); + Preferences.lock("toolkit.defaultChromeURI"); + do_check_eq(Preferences.get("toolkit.defaultChromeURI"), val); + Preferences.unlock("toolkit.defaultChromeURI"); + do_check_eq(Preferences.get("toolkit.defaultChromeURI"), "test_lock_prefs"); + + // Clean up. + Preferences.reset("toolkit.defaultChromeURI"); +} + +function test_site_prefs() { + let prefs = Preferences.site("www.example.com"); + + prefs.set("test_site_prefs.integer", 1); + do_check_eq(prefs.get("test_site_prefs.integer"), 1); + do_check_true(prefs.has("test_site_prefs.integer")); + do_check_false(Preferences.has("test_site_prefs.integer")); + prefs.reset("test_site_prefs.integer"); + do_check_false(prefs.has("test_site_prefs.integer")); + + prefs.set("test_site_prefs.string", "foo"); + do_check_eq(prefs.get("test_site_prefs.string"), "foo"); + do_check_true(prefs.has("test_site_prefs.string")); + do_check_false(Preferences.has("test_site_prefs.string")); + prefs.reset("test_site_prefs.string"); + do_check_false(prefs.has("test_site_prefs.string")); + + prefs.set("test_site_prefs.boolean", true); + do_check_eq(prefs.get("test_site_prefs.boolean"), true); + do_check_true(prefs.has("test_site_prefs.boolean")); + do_check_false(Preferences.has("test_site_prefs.boolean")); + prefs.reset("test_site_prefs.boolean"); + do_check_false(prefs.has("test_site_prefs.boolean")); +} + + +function run_test() { + test_set_get_pref(); + test_set_get_branch_pref(); + test_set_get_multiple_prefs(); + test_get_multiple_prefs_with_default_value(); + test_set_get_unicode_pref(); + test_set_null_pref(); + test_set_undefined_pref(); + test_set_unsupported_pref(); + test_get_string_pref(); + test_set_get_number_pref(); + test_reset_pref(); + test_reset_pref_branch(); + test_reset_nonexistent_pref(); + test_reset_nonexistent_pref_branch(); + test_observe_prefs_function(); + test_observe_prefs_object(); + test_observe_prefs_nsIObserver(); + //test_observe_exact_pref(); + test_observe_value_of_set_pref(); + test_observe_value_of_reset_pref(); + test_has_pref(); + test_isSet_pref(); + //test_lock_prefs(); + test_site_prefs(); +}