The Tor Browser: toolkit/components/contentprefs/tests/unit_cps2/head.js@6474c204b198 (annotated)

toolkit/components/contentprefs/tests/unit_cps2/head.js@6474c204b198 (annotated)

toolkit/components/contentprefs/tests/unit_cps2/head.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

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

 /* 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 { interfaces: Ci, classes: Cc, results: Cr, utils: Cu } = Components;
 Cu.import("resource://gre/modules/Services.jsm");
 var cps;
 var asyncRunner;
 var next;
 (function init() {
   // There has to be a profile directory before the CPS service is gotten.
   do_get_profile();
 })();
 function runAsyncTests(tests) {
   do_test_pending();
   cps = Cc["@mozilla.org/content-pref/service;1"].
         getService(Ci.nsIContentPrefService2);
   // Without this the private-browsing service tries to open a dialog when you
   // change its enabled state.
   Services.prefs.setBoolPref("browser.privatebrowsing.keep_current_session",
                              true);
   let s = {};
   Cu.import("resource://test/AsyncRunner.jsm", s);
   asyncRunner = new s.AsyncRunner({
     done: do_test_finished,
     error: function (err) {
       // xpcshell test functions like do_check_eq throw NS_ERROR_ABORT on
       // failure.  Ignore those and catch only uncaught exceptions.
       if (err !== Cr.NS_ERROR_ABORT) {
         if (err.stack) {
           err = err + "\n\nTraceback (most recent call first):\n" + err.stack +
                       "\nUseless do_throw stack:";
         }
         do_throw(err);
       }
     },
     consoleError: function (scriptErr) {
       // As much as possible make sure the error is related to the test.  On the
       // other hand if this fails to catch a test-related error, we'll hang.
       let filename = scriptErr.sourceName || scriptErr.toString() || "";
       if (/contentpref/i.test(filename))
         do_throw(scriptErr);
     }
   });
   next = asyncRunner.next.bind(asyncRunner);
   do_register_cleanup(function () {
     asyncRunner.destroy();
     asyncRunner = null;
   });
   tests.forEach(function (test) {
     function gen() {
       do_print("Running " + test.name);
       yield test();
       yield reset();
     }
     asyncRunner.appendIterator(gen());
   });
   // reset() ends up calling asyncRunner.next(), starting the tests.
   reset();
 }
 function makeCallback(callbacks) {
   callbacks = callbacks || {};
   ["handleResult", "handleError"].forEach(function (meth) {
     if (!callbacks[meth])
       callbacks[meth] = function () {
         do_throw(meth + " shouldn't be called.");
       };
   });
   if (!callbacks.handleCompletion)
     callbacks.handleCompletion = function (reason) {
       do_check_eq(reason, Ci.nsIContentPrefCallback2.COMPLETE_OK);
       next();
     };
   return callbacks;
 }
 function do_check_throws(fn) {
   let threw = false;
   try {
     fn();
   }
   catch (err) {
     threw = true;
   }
   do_check_true(threw);
 }
 function sendMessage(msg, callback) {
   let obj = callback || {};
   let ref = Cu.getWeakReference(obj);
   cps.QueryInterface(Ci.nsIObserver).observe(ref, "test:" + msg, null);
   return "value" in obj ? obj.value : undefined;
 }
 function reset() {
   sendMessage("reset", next);
 }
 function set(group, name, val, context) {
   cps.set(group, name, val, context, makeCallback());
 }
 function setGlobal(name, val, context) {
   cps.setGlobal(name, val, context, makeCallback());
 }
 function prefOK(actual, expected, strict) {
   do_check_true(actual instanceof Ci.nsIContentPref);
   do_check_eq(actual.domain, expected.domain);
   do_check_eq(actual.name, expected.name);
   if (strict)
     do_check_true(actual.value === expected.value);
   else
     do_check_eq(actual.value, expected.value);
 }
 function getOK(args, expectedVal, expectedGroup, strict) {
   if (args.length == 2)
     args.push(undefined);
   let expectedPrefs = expectedVal === undefined ? [] :
                       [{ domain: expectedGroup || args[0],
                          name: args[1],
                          value: expectedVal }];
   yield getOKEx("getByDomainAndName", args, expectedPrefs, strict);
 }
 function getSubdomainsOK(args, expectedGroupValPairs) {
   if (args.length == 2)
     args.push(undefined);
   let expectedPrefs = expectedGroupValPairs.map(function ([group, val]) {
     return { domain: group, name: args[1], value: val };
   });
   yield getOKEx("getBySubdomainAndName", args, expectedPrefs);
 }
 function getGlobalOK(args, expectedVal) {
   if (args.length == 1)
     args.push(undefined);
   let expectedPrefs = expectedVal === undefined ? [] :
                       [{ domain: null, name: args[0], value: expectedVal }];
   yield getOKEx("getGlobal", args, expectedPrefs);
 }
 function getOKEx(methodName, args, expectedPrefs, strict, context) {
   let actualPrefs = [];
   args.push(makeCallback({
     handleResult: function (pref) actualPrefs.push(pref)
   }));
   yield cps[methodName].apply(cps, args);
   arraysOfArraysOK([actualPrefs], [expectedPrefs], function (actual, expected) {
     prefOK(actual, expected, strict);
   });
 }
 function getCachedOK(args, expectedIsCached, expectedVal, expectedGroup,
                      strict) {
   if (args.length == 2)
     args.push(undefined);
   let expectedPref = !expectedIsCached ? null : {
     domain: expectedGroup || args[0],
     name: args[1],
     value: expectedVal
   };
   getCachedOKEx("getCachedByDomainAndName", args, expectedPref, strict);
 }
 function getCachedSubdomainsOK(args, expectedGroupValPairs) {
   if (args.length == 2)
     args.push(undefined);
   let len = {};
   args.push(len);
   let actualPrefs = cps.getCachedBySubdomainAndName.apply(cps, args);
   actualPrefs = actualPrefs.sort(function (a, b) {
     return a.domain.localeCompare(b.domain);
   });
   do_check_eq(actualPrefs.length, len.value);
   let expectedPrefs = expectedGroupValPairs.map(function ([group, val]) {
     return { domain: group, name: args[1], value: val };
   });
   arraysOfArraysOK([actualPrefs], [expectedPrefs], prefOK);
 }
 function getCachedGlobalOK(args, expectedIsCached, expectedVal) {
   if (args.length == 1)
     args.push(undefined);
   let expectedPref = !expectedIsCached ? null : {
     domain: null,
     name: args[0],
     value: expectedVal
   };
   getCachedOKEx("getCachedGlobal", args, expectedPref);
 }
 function getCachedOKEx(methodName, args, expectedPref, strict) {
   let actualPref = cps[methodName].apply(cps, args);
   if (expectedPref)
     prefOK(actualPref, expectedPref, strict);
   else
     do_check_true(actualPref === null);
 }
 function arraysOfArraysOK(actual, expected, cmp) {
   cmp = cmp || function (a, b) do_check_eq(a, b);
   do_check_eq(actual.length, expected.length);
   actual.forEach(function (actualChildArr, i) {
     let expectedChildArr = expected[i];
     do_check_eq(actualChildArr.length, expectedChildArr.length);
     actualChildArr.forEach(function (actualElt, j) {
       let expectedElt = expectedChildArr[j];
       cmp(actualElt, expectedElt);
     });
   });
 }
 function dbOK(expectedRows) {
   let db = sendMessage("db");
   let stmt = db.createAsyncStatement(
     "SELECT groups.name AS grp, settings.name AS name, prefs.value AS value " +
     "FROM prefs " +
     "LEFT JOIN groups ON groups.id = prefs.groupID " +
     "LEFT JOIN settings ON settings.id = prefs.settingID " +
     "UNION " +
     // These second two SELECTs get the rows of the groups and settings tables
     // that aren't referenced by the prefs table.  Neither should return any
     // rows if the component is working properly.
     "SELECT groups.name AS grp, NULL AS name, NULL AS value " +
     "FROM groups " +
     "WHERE id NOT IN (" +
       "SELECT DISTINCT groupID " +
       "FROM prefs " +
       "WHERE groupID NOTNULL" +
     ") " +
     "UNION " +
     "SELECT NULL AS grp, settings.name AS name, NULL AS value " +
     "FROM settings " +
     "WHERE id NOT IN (" +
       "SELECT DISTINCT settingID " +
       "FROM prefs " +
       "WHERE settingID NOTNULL" +
     ") " +
     "ORDER BY value ASC, grp ASC, name ASC"
   );
   let actualRows = [];
   let cols = ["grp", "name", "value"];
   db.executeAsync([stmt], 1, {
     handleCompletion: function (reason) {
       arraysOfArraysOK(actualRows, expectedRows);
       next();
     },
     handleResult: function (results) {
       let row = null;
       while (row = results.getNextRow()) {
         actualRows.push(cols.map(function (c) row.getResultByName(c)));
       }
     },
     handleError: function (err) {
       do_throw(err);
     }
   });
   stmt.finalize();
 }
 function on(event, names, dontRemove) {
   let args = {
     reset: function () {
       for (let prop in this) {
         if (Array.isArray(this[prop]))
           this[prop].splice(0, this[prop].length);
       }
     },
   };
   let observers = {};
   names.forEach(function (name) {
     let obs = {};
     ["onContentPrefSet", "onContentPrefRemoved"].forEach(function (meth) {
       obs[meth] = function () do_throw(meth + " should not be called");
     });
     obs["onContentPref" + event] = function () {
       args[name].push(Array.slice(arguments));
     };
     observers[name] = obs;
     args[name] = [];
     args[name].observer = obs;
     cps.addObserverForName(name, obs);
   });
   do_execute_soon(function () {
     if (!dontRemove)
       names.forEach(function (n) cps.removeObserverForName(n, observers[n]));
     next(args);
   });
 }
 function wait() {
   do_execute_soon(next);
 }
 function observerArgsOK(actualArgs, expectedArgs) {
   do_check_neq(actualArgs, undefined);
   arraysOfArraysOK(actualArgs, expectedArgs);
 }