diff -r 000000000000 -r 6474c204b198 mobile/android/base/tests/robocop_head.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mobile/android/base/tests/robocop_head.js	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,1233 @@
+/* -*- Mode: JavaScript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et: */
+/* 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/. */
+
+/*
+ * This file contains common code that is loaded before each test file(s).
+ * See http://developer.mozilla.org/en/docs/Writing_xpcshell-based_unit_tests
+ * for more information.
+ */
+
+const _XPCSHELL_TIMEOUT_MS = 5 * 60 * 1000;
+
+var _quit = false;
+var _passed = true;
+var _tests_pending = 0;
+var _passedChecks = 0, _falsePassedChecks = 0;
+var _todoChecks = 0;
+var _cleanupFunctions = [];
+var _pendingTimers = [];
+var _profileInitialized = false;
+
+function _dump(str) {
+  let start = /^TEST-/.test(str) ? "\n" : "";
+  if (typeof _XPCSHELL_PROCESS == "undefined") {
+    dump(start + str);
+  } else {
+    dump(start + _XPCSHELL_PROCESS + ": " + str);
+  }
+}
+
+// Disable automatic network detection, so tests work correctly when
+// not connected to a network.
+let (ios = Components.classes["@mozilla.org/network/io-service;1"]
+           .getService(Components.interfaces.nsIIOService2)) {
+  ios.manageOfflineStatus = false;
+  ios.offline = false;
+}
+
+// Determine if we're running on parent or child
+let runningInParent = true;
+try {
+  runningInParent = Components.classes["@mozilla.org/xre/runtime;1"].
+                    getService(Components.interfaces.nsIXULRuntime).processType
+                    == Components.interfaces.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+}
+catch (e) { }
+
+try {
+  if (runningInParent) {
+    let prefs = Components.classes["@mozilla.org/preferences-service;1"]
+                .getService(Components.interfaces.nsIPrefBranch);
+
+    // disable necko IPC security checks for xpcshell, as they lack the
+    // docshells needed to pass them
+    prefs.setBoolPref("network.disable.ipc.security", true);
+
+    // Disable IPv6 lookups for 'localhost' on windows.
+    if ("@mozilla.org/windows-registry-key;1" in Components.classes) {
+      prefs.setCharPref("network.dns.ipv4OnlyDomains", "localhost");
+    }
+  }
+}
+catch (e) { }
+
+// Enable crash reporting, if possible
+// We rely on the Python harness to set MOZ_CRASHREPORTER_NO_REPORT
+// and handle checking for minidumps.
+// Note that if we're in a child process, we don't want to init the
+// crashreporter component.
+try { // nsIXULRuntime is not available in some configurations.
+  if (runningInParent &&
+      "@mozilla.org/toolkit/crash-reporter;1" in Components.classes) {
+    // Remember to update </toolkit/crashreporter/test/unit/test_crashreporter.js>
+    // too if you change this initial setting.
+    let (crashReporter =
+          Components.classes["@mozilla.org/toolkit/crash-reporter;1"]
+          .getService(Components.interfaces.nsICrashReporter)) {
+      crashReporter.enabled = true;
+      crashReporter.minidumpPath = do_get_cwd();
+    }
+  }
+}
+catch (e) { }
+
+/**
+ * Date.now() is not necessarily monotonically increasing (insert sob story
+ * about times not being the right tool to use for measuring intervals of time,
+ * robarnold can tell all), so be wary of error by erring by at least
+ * _timerFuzz ms.
+ */
+const _timerFuzz = 15;
+
+function _Timer(func, delay) {
+  delay = Number(delay);
+  if (delay < 0)
+    do_throw("do_timeout() delay must be nonnegative");
+
+  if (typeof func !== "function")
+    do_throw("string callbacks no longer accepted; use a function!");
+
+  this._func = func;
+  this._start = Date.now();
+  this._delay = delay;
+
+  var timer = Components.classes["@mozilla.org/timer;1"]
+                        .createInstance(Components.interfaces.nsITimer);
+  timer.initWithCallback(this, delay + _timerFuzz, timer.TYPE_ONE_SHOT);
+
+  // Keep timer alive until it fires
+  _pendingTimers.push(timer);
+}
+_Timer.prototype = {
+  QueryInterface: function(iid) {
+    if (iid.equals(Components.interfaces.nsITimerCallback) ||
+        iid.equals(Components.interfaces.nsISupports))
+      return this;
+
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  },
+
+  notify: function(timer) {
+    _pendingTimers.splice(_pendingTimers.indexOf(timer), 1);
+
+    // The current nsITimer implementation can undershoot, but even if it
+    // couldn't, paranoia is probably a virtue here given the potential for
+    // random orange on tinderboxen.
+    var end = Date.now();
+    var elapsed = end - this._start;
+    if (elapsed >= this._delay) {
+      try {
+        this._func.call(null);
+      } catch (e) {
+        do_throw("exception thrown from do_timeout callback: " + e);
+      }
+      return;
+    }
+
+    // Timer undershot, retry with a little overshoot to try to avoid more
+    // undershoots.
+    var newDelay = this._delay - elapsed;
+    do_timeout(newDelay, this._func);
+  }
+};
+
+function _do_main() {
+  if (_quit)
+    return;
+
+  _dump("TEST-INFO | (xpcshell/head.js) | running event loop\n");
+
+  var thr = Components.classes["@mozilla.org/thread-manager;1"]
+                      .getService().currentThread;
+
+  while (!_quit)
+    thr.processNextEvent(true);
+
+  while (thr.hasPendingEvents())
+    thr.processNextEvent(true);
+}
+
+function _do_quit() {
+  _dump("TEST-INFO | (xpcshell/head.js) | exiting test\n");
+
+  _quit = true;
+}
+
+function _dump_exception_stack(stack) {
+  stack.split("\n").forEach(function(frame) {
+    if (!frame)
+      return;
+    // frame is of the form "fname(args)@file:line"
+    let frame_regexp = new RegExp("(.*)\\(.*\\)@(.*):(\\d*)", "g");
+    let parts = frame_regexp.exec(frame);
+    if (parts)
+        dump("JS frame :: " + parts[2] + " :: " + (parts[1] ? parts[1] : "anonymous")
+             + " :: line " + parts[3] + "\n");
+    else /* Could be a -e (command line string) style location. */
+        dump("JS frame :: " + frame + "\n");
+  });
+}
+
+/**
+ * Overrides idleService with a mock.  Idle is commonly used for maintenance
+ * tasks, thus if a test uses a service that requires the idle service, it will
+ * start handling them.
+ * This behaviour would cause random failures and slowdown tests execution,
+ * for example by running database vacuum or cleanups for each test.
+ *
+ * @note Idle service is overridden by default.  If a test requires it, it will
+ *       have to call do_get_idle() function at least once before use.
+ */
+var _fakeIdleService = {
+  get registrar() {
+    delete this.registrar;
+    return this.registrar =
+      Components.manager.QueryInterface(Components.interfaces.nsIComponentRegistrar);
+  },
+  contractID: "@mozilla.org/widget/idleservice;1",
+  get CID() this.registrar.contractIDToCID(this.contractID),
+
+  activate: function FIS_activate()
+  {
+    if (!this.originalFactory) {
+      // Save original factory.
+      this.originalFactory =
+        Components.manager.getClassObject(Components.classes[this.contractID],
+                                          Components.interfaces.nsIFactory);
+      // Unregister original factory.
+      this.registrar.unregisterFactory(this.CID, this.originalFactory);
+      // Replace with the mock.
+      this.registrar.registerFactory(this.CID, "Fake Idle Service",
+                                     this.contractID, this.factory
+      );
+    }
+  },
+
+  deactivate: function FIS_deactivate()
+  {
+    if (this.originalFactory) {
+      // Unregister the mock.
+      this.registrar.unregisterFactory(this.CID, this.factory);
+      // Restore original factory.
+      this.registrar.registerFactory(this.CID, "Idle Service",
+                                     this.contractID, this.originalFactory);
+      delete this.originalFactory;
+    }
+  },
+
+  factory: {
+    // nsIFactory
+    createInstance: function (aOuter, aIID)
+    {
+      if (aOuter) {
+        throw Components.results.NS_ERROR_NO_AGGREGATION;
+      }
+      return _fakeIdleService.QueryInterface(aIID);
+    },
+    lockFactory: function (aLock) {
+      throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
+    },
+    QueryInterface: function(aIID) {
+      if (aIID.equals(Components.interfaces.nsIFactory) ||
+          aIID.equals(Components.interfaces.nsISupports)) {
+        return this;
+      }
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  },
+
+  // nsIIdleService
+  get idleTime() 0,
+  addIdleObserver: function () {},
+  removeIdleObserver: function () {},
+
+  QueryInterface: function(aIID) {
+    // Useful for testing purposes, see test_get_idle.js.
+    if (aIID.equals(Components.interfaces.nsIFactory)) {
+      return this.factory;
+    }
+    if (aIID.equals(Components.interfaces.nsIIdleService) ||
+        aIID.equals(Components.interfaces.nsISupports)) {
+      return this;
+    }
+    throw Components.results.NS_ERROR_NO_INTERFACE;
+  }
+}
+
+/**
+ * Restores the idle service factory if needed and returns the service's handle.
+ * @return A handle to the idle service.
+ */
+function do_get_idle() {
+  _fakeIdleService.deactivate();
+  return Components.classes[_fakeIdleService.contractID]
+                   .getService(Components.interfaces.nsIIdleService);
+}
+
+// Map resource://test/ to current working directory and
+// resource://testing-common/ to the shared test modules directory.
+function _register_protocol_handlers() {
+  let (ios = Components.classes["@mozilla.org/network/io-service;1"]
+             .getService(Components.interfaces.nsIIOService)) {
+    let protocolHandler =
+      ios.getProtocolHandler("resource")
+         .QueryInterface(Components.interfaces.nsIResProtocolHandler);
+    let curDirURI = ios.newFileURI(do_get_cwd());
+    protocolHandler.setSubstitution("test", curDirURI);
+
+    if (this._TESTING_MODULES_DIR) {
+      let modulesFile = Components.classes["@mozilla.org/file/local;1"].
+                        createInstance(Components.interfaces.nsILocalFile);
+      modulesFile.initWithPath(_TESTING_MODULES_DIR);
+
+      if (!modulesFile.exists()) {
+        throw new Error("Specified modules directory does not exist: " +
+                        _TESTING_MODULES_DIR);
+      }
+
+      if (!modulesFile.isDirectory()) {
+        throw new Error("Specified modules directory is not a directory: " +
+                        _TESTING_MODULES_DIR);
+      }
+
+      let modulesURI = ios.newFileURI(modulesFile);
+
+      protocolHandler.setSubstitution("testing-common", modulesURI);
+    }
+  }
+}
+
+function _execute_test() {
+  _register_protocol_handlers();
+
+  // Override idle service by default.
+  // Call do_get_idle() to restore the factory and get the service.
+  _fakeIdleService.activate();
+
+  // Terminate asynchronous tests when a global timeout occurs.
+  do_timeout(_XPCSHELL_TIMEOUT_MS, function _do_main_timeout() {
+    try {
+      do_throw("test timed out");
+    } catch (e if e == Components.results.NS_ERROR_ABORT) {
+      // We don't want do_timeout to report the do_throw exception again.
+    }
+  });
+
+  // _HEAD_FILES is dynamically defined by <runxpcshelltests.py>.
+  _load_files(_HEAD_FILES);
+  // _TEST_FILE is dynamically defined by <runxpcshelltests.py>.
+  _load_files(_TEST_FILE);
+
+  try {
+    do_test_pending();
+    run_test();
+    do_test_finished();
+    _do_main();
+  } catch (e) {
+    _passed = false;
+    // do_check failures are already logged and set _quit to true and throw
+    // NS_ERROR_ABORT. If both of those are true it is likely this exception
+    // has already been logged so there is no need to log it again. It's
+    // possible that this will mask an NS_ERROR_ABORT that happens after a
+    // do_check failure though.
+    if (!_quit || e != Components.results.NS_ERROR_ABORT) {
+      msg = "TEST-UNEXPECTED-FAIL | ";
+      if (e.fileName) {
+        msg += e.fileName;
+        if (e.lineNumber) {
+          msg += ":" + e.lineNumber;
+        }
+      } else {
+        msg += "xpcshell/head.js";
+      }
+      msg += " | " + e;
+      if (e.stack) {
+        _dump(msg + " - See following stack:\n");
+        _dump_exception_stack(e.stack);
+      }
+      else {
+        _dump(msg + "\n");
+      }
+    }
+  }
+
+  // _TAIL_FILES is dynamically defined by <runxpcshelltests.py>.
+  _load_files(_TAIL_FILES);
+
+  // Execute all of our cleanup functions.
+  var func;
+  while ((func = _cleanupFunctions.pop()))
+    func();
+
+  // Restore idle service to avoid leaks.
+  _fakeIdleService.deactivate();
+
+  if (!_passed)
+    return;
+
+  var truePassedChecks = _passedChecks - _falsePassedChecks;
+  if (truePassedChecks > 0) {
+    _dump("TEST-PASS | (xpcshell/head.js) | " + truePassedChecks + " (+ " +
+            _falsePassedChecks + ") check(s) passed\n");
+    _dump("TEST-INFO | (xpcshell/head.js) | " + _todoChecks +
+            " check(s) todo\n");
+  } else {
+    // ToDo: switch to TEST-UNEXPECTED-FAIL when all tests have been updated. (Bug 496443)
+    _dump("TEST-INFO | (xpcshell/head.js) | No (+ " + _falsePassedChecks + ") checks actually run\n");
+  }
+}
+
+/**
+ * Loads files.
+ *
+ * @param aFiles Array of files to load.
+ */
+function _load_files(aFiles) {
+  function loadTailFile(element, index, array) {
+    load(element);
+  }
+
+  aFiles.forEach(loadTailFile);
+}
+
+
+/************** Functions to be used from the tests **************/
+
+/**
+ * Prints a message to the output log.
+ */
+function do_print(msg) {
+  var caller_stack = Components.stack.caller;
+  _dump("TEST-INFO | " + caller_stack.filename + " | " + msg + "\n");
+}
+
+/**
+ * Calls the given function at least the specified number of milliseconds later.
+ * The callback will not undershoot the given time, but it might overshoot --
+ * don't expect precision!
+ *
+ * @param delay : uint
+ *   the number of milliseconds to delay
+ * @param callback : function() : void
+ *   the function to call
+ */
+function do_timeout(delay, func) {
+  new _Timer(func, Number(delay));
+}
+
+function do_execute_soon(callback) {
+  do_test_pending();
+  var tm = Components.classes["@mozilla.org/thread-manager;1"]
+                     .getService(Components.interfaces.nsIThreadManager);
+
+  tm.mainThread.dispatch({
+    run: function() {
+      try {
+        callback();
+      } catch (e) {
+        // do_check failures are already logged and set _quit to true and throw
+        // NS_ERROR_ABORT. If both of those are true it is likely this exception
+        // has already been logged so there is no need to log it again. It's
+        // possible that this will mask an NS_ERROR_ABORT that happens after a
+        // do_check failure though.
+        if (!_quit || e != Components.results.NS_ERROR_ABORT) {
+          _dump("TEST-UNEXPECTED-FAIL | (xpcshell/head.js) | " + e);
+          if (e.stack) {
+            dump(" - See following stack:\n");
+            _dump_exception_stack(e.stack);
+          }
+          else {
+            dump("\n");
+          }
+          _do_quit();
+        }
+      }
+      finally {
+        do_test_finished();
+      }
+    }
+  }, Components.interfaces.nsIThread.DISPATCH_NORMAL);
+}
+
+function do_throw(text, stack) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  _passed = false;
+  _dump("TEST-UNEXPECTED-FAIL | " + stack.filename + " | " + text +
+        " - See following stack:\n");
+  var frame = Components.stack;
+  while (frame != null) {
+    _dump(frame + "\n");
+    frame = frame.caller;
+  }
+
+  _do_quit();
+  throw Components.results.NS_ERROR_ABORT;
+}
+
+function do_throw_todo(text, stack) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  _passed = false;
+  _dump("TEST-UNEXPECTED-PASS | " + stack.filename + " | " + text +
+        " - See following stack:\n");
+  var frame = Components.stack;
+  while (frame != null) {
+    _dump(frame + "\n");
+    frame = frame.caller;
+  }
+
+  _do_quit();
+  throw Components.results.NS_ERROR_ABORT;
+}
+
+function do_report_unexpected_exception(ex, text) {
+  var caller_stack = Components.stack.caller;
+  text = text ? text + " - " : "";
+
+  _passed = false;
+  _dump("TEST-UNEXPECTED-FAIL | " + caller_stack.filename + " | " + text +
+        "Unexpected exception " + ex + ", see following stack:\n" + ex.stack +
+        "\n");
+
+  _do_quit();
+  throw Components.results.NS_ERROR_ABORT;
+}
+
+function do_note_exception(ex, text) {
+  var caller_stack = Components.stack.caller;
+  text = text ? text + " - " : "";
+
+  _dump("TEST-INFO | " + caller_stack.filename + " | " + text +
+        "Swallowed exception " + ex + ", see following stack:\n" + ex.stack +
+        "\n");
+}
+
+function _do_check_neq(left, right, stack, todo) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  var text = left + " != " + right;
+  if (left == right) {
+    if (!todo) {
+      do_throw(text, stack);
+    } else {
+      ++_todoChecks;
+      _dump("TEST-KNOWN-FAIL | " + stack.filename + " | [" + stack.name +
+            " : " + stack.lineNumber + "] " + text +"\n");
+    }
+  } else {
+    if (!todo) {
+      ++_passedChecks;
+      _dump("TEST-PASS | " + stack.filename + " | [" + stack.name + " : " +
+            stack.lineNumber + "] " + text + "\n");
+    } else {
+      do_throw_todo(text, stack);
+    }
+  }
+}
+
+function do_check_neq(left, right, stack) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  _do_check_neq(left, right, stack, false);
+}
+
+function todo_check_neq(left, right, stack) {
+  if (!stack)
+      stack = Components.stack.caller;
+
+  _do_check_neq(left, right, stack, true);
+}
+
+function do_report_result(passed, text, stack, todo) {
+  if (passed) {
+    if (todo) {
+      do_throw_todo(text, stack);
+    } else {
+      ++_passedChecks;
+      _dump("TEST-PASS | " + stack.filename + " | [" + stack.name + " : " +
+            stack.lineNumber + "] " + text + "\n");
+    }
+  } else {
+    if (todo) {
+      ++_todoChecks;
+      _dump("TEST-KNOWN-FAIL | " + stack.filename + " | [" + stack.name +
+            " : " + stack.lineNumber + "] " + text +"\n");
+    } else {
+      do_throw(text, stack);
+    }
+  }
+}
+
+function _do_check_eq(left, right, stack, todo) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  var text = left + " == " + right;
+  do_report_result(left == right, text, stack, todo);
+}
+
+function do_check_eq(left, right, stack) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  _do_check_eq(left, right, stack, false);
+}
+
+function todo_check_eq(left, right, stack) {
+  if (!stack)
+      stack = Components.stack.caller;
+
+  _do_check_eq(left, right, stack, true);
+}
+
+function do_check_true(condition, stack) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  do_check_eq(condition, true, stack);
+}
+
+function todo_check_true(condition, stack) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  todo_check_eq(condition, true, stack);
+}
+
+function do_check_false(condition, stack) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  do_check_eq(condition, false, stack);
+}
+
+function todo_check_false(condition, stack) {
+  if (!stack)
+    stack = Components.stack.caller;
+
+  todo_check_eq(condition, false, stack);
+}
+
+function do_check_null(condition, stack=Components.stack.caller) {
+  do_check_eq(condition, null, stack);
+}
+
+function todo_check_null(condition, stack=Components.stack.caller) {
+  todo_check_eq(condition, null, stack);
+}
+
+/**
+ * Check that |value| matches |pattern|.
+ *
+ * A |value| matches a pattern |pattern| if any one of the following is true:
+ *
+ * - |value| and |pattern| are both objects; |pattern|'s enumerable
+ *   properties' values are valid patterns; and for each enumerable
+ *   property |p| of |pattern|, plus 'length' if present at all, |value|
+ *   has a property |p| whose value matches |pattern.p|. Note that if |j|
+ *   has other properties not present in |p|, |j| may still match |p|.
+ *
+ * - |value| and |pattern| are equal string, numeric, or boolean literals
+ *
+ * - |pattern| is |undefined| (this is a wildcard pattern)
+ *
+ * - typeof |pattern| == "function", and |pattern(value)| is true.
+ *
+ * For example:
+ *
+ * do_check_matches({x:1}, {x:1})       // pass
+ * do_check_matches({x:1}, {})          // fail: all pattern props required
+ * do_check_matches({x:1}, {x:2})       // fail: values must match
+ * do_check_matches({x:1}, {x:1, y:2})  // pass: extra props tolerated
+ *
+ * // Property order is irrelevant.
+ * do_check_matches({x:"foo", y:"bar"}, {y:"bar", x:"foo"}) // pass
+ *
+ * do_check_matches({x:undefined}, {x:1}) // pass: 'undefined' is wildcard
+ * do_check_matches({x:undefined}, {x:2})
+ * do_check_matches({x:undefined}, {y:2}) // fail: 'x' must still be there
+ *
+ * // Patterns nest.
+ * do_check_matches({a:1, b:{c:2,d:undefined}}, {a:1, b:{c:2,d:3}})
+ *
+ * // 'length' property counts, even if non-enumerable.
+ * do_check_matches([3,4,5], [3,4,5])     // pass
+ * do_check_matches([3,4,5], [3,5,5])     // fail; value doesn't match
+ * do_check_matches([3,4,5], [3,4,5,6])   // fail; length doesn't match
+ *
+ * // functions in patterns get applied.
+ * do_check_matches({foo:function (v) v.length == 2}, {foo:"hi"}) // pass
+ * do_check_matches({foo:function (v) v.length == 2}, {bar:"hi"}) // fail
+ * do_check_matches({foo:function (v) v.length == 2}, {foo:"hello"}) // fail
+ *
+ * // We don't check constructors, prototypes, or classes. However, if
+ * // pattern has a 'length' property, we require values to match that as
+ * // well, even if 'length' is non-enumerable in the pattern. So arrays
+ * // are useful as patterns.
+ * do_check_matches({0:0, 1:1, length:2}, [0,1])  // pass
+ * do_check_matches({0:1}, [1,2])                 // pass
+ * do_check_matches([0], {0:0, length:1})         // pass
+ *
+ * Notes:
+ *
+ * The 'length' hack gives us reasonably intuitive handling of arrays.
+ *
+ * This is not a tight pattern-matcher; it's only good for checking data
+ * from well-behaved sources. For example:
+ * - By default, we don't mind values having extra properties.
+ * - We don't check for proxies or getters.
+ * - We don't check the prototype chain.
+ * However, if you know the values are, say, JSON, which is pretty
+ * well-behaved, and if you want to tolerate additional properties
+ * appearing on the JSON for backward-compatibility, then do_check_matches
+ * is ideal. If you do want to be more careful, you can use function
+ * patterns to implement more stringent checks.
+ */
+function do_check_matches(pattern, value, stack=Components.stack.caller, todo=false) {
+  var matcher = pattern_matcher(pattern);
+  var text = "VALUE: " + uneval(value) + "\nPATTERN: " + uneval(pattern) + "\n";
+  var diagnosis = []
+  if (matcher(value, diagnosis)) {
+    do_report_result(true, "value matches pattern:\n" + text, stack, todo);
+  } else {
+    text = ("value doesn't match pattern:\n" +
+            text +
+            "DIAGNOSIS: " +
+            format_pattern_match_failure(diagnosis[0]) + "\n");
+    do_report_result(false, text, stack, todo);
+  }
+}
+
+function todo_check_matches(pattern, value, stack=Components.stack.caller) {
+  do_check_matches(pattern, value, stack, true);
+}
+
+// Return a pattern-matching function of one argument, |value|, that
+// returns true if |value| matches |pattern|.
+//
+// If the pattern doesn't match, and the pattern-matching function was
+// passed its optional |diagnosis| argument, the pattern-matching function
+// sets |diagnosis|'s '0' property to a JSON-ish description of the portion
+// of the pattern that didn't match, which can be formatted legibly by
+// format_pattern_match_failure.
+function pattern_matcher(pattern) {
+  function explain(diagnosis, reason) {
+    if (diagnosis) {
+      diagnosis[0] = reason;
+    }
+    return false;
+  }
+  if (typeof pattern == "function") {
+    return pattern;
+  } else if (typeof pattern == "object" && pattern) {
+    var matchers = [[p, pattern_matcher(pattern[p])] for (p in pattern)];
+    // Kludge: include 'length', if not enumerable. (If it is enumerable,
+    // we picked it up in the array comprehension, above.
+    ld = Object.getOwnPropertyDescriptor(pattern, 'length');
+    if (ld && !ld.enumerable) {
+      matchers.push(['length', pattern_matcher(pattern.length)])
+    }
+    return function (value, diagnosis) {
+      if (!(value && typeof value == "object")) {
+        return explain(diagnosis, "value not object");
+      }
+      for (let [p, m] of matchers) {
+        var element_diagnosis = [];
+        if (!(p in value && m(value[p], element_diagnosis))) {
+          return explain(diagnosis, { property:p,
+                                      diagnosis:element_diagnosis[0] });
+        }
+      }
+      return true;
+    };
+  } else if (pattern === undefined) {
+    return function(value) { return true; };
+  } else {
+    return function (value, diagnosis) {
+      if (value !== pattern) {
+        return explain(diagnosis, "pattern " + uneval(pattern) + " not === to value " + uneval(value));
+      }
+      return true;
+    };
+  }
+}
+
+// Format an explanation for a pattern match failure, as stored in the
+// second argument to a matching function.
+function format_pattern_match_failure(diagnosis, indent="") {
+  var a;
+  if (!diagnosis) {
+    a = "Matcher did not explain reason for mismatch.";
+  } else if (typeof diagnosis == "string") {
+    a = diagnosis;
+  } else if (diagnosis.property) {
+    a = "Property " + uneval(diagnosis.property) + " of object didn't match:\n";
+    a += format_pattern_match_failure(diagnosis.diagnosis, indent + "  ");
+  }
+  return indent + a;
+}
+
+function do_test_pending() {
+  ++_tests_pending;
+
+  _dump("TEST-INFO | (xpcshell/head.js) | test " + _tests_pending +
+         " pending\n");
+}
+
+function do_test_finished() {
+  _dump("TEST-INFO | (xpcshell/head.js) | test " + _tests_pending +
+         " finished\n");
+
+  if (--_tests_pending == 0)
+    _do_quit();
+}
+
+function do_get_file(path, allowNonexistent) {
+  try {
+    let lf = Components.classes["@mozilla.org/file/directory_service;1"]
+      .getService(Components.interfaces.nsIProperties)
+      .get("CurWorkD", Components.interfaces.nsILocalFile);
+
+    let bits = path.split("/");
+    for (let i = 0; i < bits.length; i++) {
+      if (bits[i]) {
+        if (bits[i] == "..")
+          lf = lf.parent;
+        else
+          lf.append(bits[i]);
+      }
+    }
+
+    if (!allowNonexistent && !lf.exists()) {
+      // Not using do_throw(): caller will continue.
+      _passed = false;
+      var stack = Components.stack.caller;
+      _dump("TEST-UNEXPECTED-FAIL | " + stack.filename + " | [" +
+            stack.name + " : " + stack.lineNumber + "] " + lf.path +
+            " does not exist\n");
+    }
+
+    return lf;
+  }
+  catch (ex) {
+    do_throw(ex.toString(), Components.stack.caller);
+  }
+
+  return null;
+}
+
+// do_get_cwd() isn't exactly self-explanatory, so provide a helper
+function do_get_cwd() {
+  return do_get_file("");
+}
+
+function do_load_manifest(path) {
+  var lf = do_get_file(path);
+  const nsIComponentRegistrar = Components.interfaces.nsIComponentRegistrar;
+  do_check_true(Components.manager instanceof nsIComponentRegistrar);
+  // Previous do_check_true() is not a test check.
+  ++_falsePassedChecks;
+  Components.manager.autoRegister(lf);
+}
+
+/**
+ * Parse a DOM document.
+ *
+ * @param aPath File path to the document.
+ * @param aType Content type to use in DOMParser.
+ *
+ * @return nsIDOMDocument from the file.
+ */
+function do_parse_document(aPath, aType) {
+  switch (aType) {
+    case "application/xhtml+xml":
+    case "application/xml":
+    case "text/xml":
+      break;
+
+    default:
+      do_throw("type: expected application/xhtml+xml, application/xml or text/xml," +
+                 " got '" + aType + "'",
+               Components.stack.caller);
+  }
+
+  var lf = do_get_file(aPath);
+  const C_i = Components.interfaces;
+  const parserClass = "@mozilla.org/xmlextras/domparser;1";
+  const streamClass = "@mozilla.org/network/file-input-stream;1";
+  var stream = Components.classes[streamClass]
+                         .createInstance(C_i.nsIFileInputStream);
+  stream.init(lf, -1, -1, C_i.nsIFileInputStream.CLOSE_ON_EOF);
+  var parser = Components.classes[parserClass]
+                         .createInstance(C_i.nsIDOMParser);
+  var doc = parser.parseFromStream(stream, null, lf.fileSize, aType);
+  parser = null;
+  stream = null;
+  lf = null;
+  return doc;
+}
+
+/**
+ * Registers a function that will run when the test harness is done running all
+ * tests.
+ *
+ * @param aFunction
+ *        The function to be called when the test harness has finished running.
+ */
+function do_register_cleanup(aFunction)
+{
+  _cleanupFunctions.push(aFunction);
+}
+
+/**
+ * Registers a directory with the profile service,
+ * and return the directory as an nsILocalFile.
+ *
+ * @return nsILocalFile of the profile directory.
+ */
+function do_get_profile() {
+  if (!runningInParent) {
+    _dump("TEST-INFO | (xpcshell/head.js) | Ignoring profile creation from child process.\n");
+    return null;
+  }
+
+  if (!_profileInitialized) {
+    // Since we have a profile, we will notify profile shutdown topics at
+    // the end of the current test, to ensure correct cleanup on shutdown.
+    do_register_cleanup(function() {
+      let obsSvc = Components.classes["@mozilla.org/observer-service;1"].
+                   getService(Components.interfaces.nsIObserverService);
+      obsSvc.notifyObservers(null, "profile-change-net-teardown", null);
+      obsSvc.notifyObservers(null, "profile-change-teardown", null);
+      obsSvc.notifyObservers(null, "profile-before-change", null);
+    });
+  }
+
+  let env = Components.classes["@mozilla.org/process/environment;1"]
+                      .getService(Components.interfaces.nsIEnvironment);
+  // the python harness sets this in the environment for us
+  let profd = env.get("XPCSHELL_TEST_PROFILE_DIR");
+  let file = Components.classes["@mozilla.org/file/local;1"]
+                       .createInstance(Components.interfaces.nsILocalFile);
+  file.initWithPath(profd);
+
+  let dirSvc = Components.classes["@mozilla.org/file/directory_service;1"]
+                         .getService(Components.interfaces.nsIProperties);
+  let provider = {
+    getFile: function(prop, persistent) {
+      persistent.value = true;
+      if (prop == "ProfD" || prop == "ProfLD" || prop == "ProfDS" ||
+          prop == "ProfLDS" || prop == "TmpD") {
+        return file.clone();
+      }
+      throw Components.results.NS_ERROR_FAILURE;
+    },
+    QueryInterface: function(iid) {
+      if (iid.equals(Components.interfaces.nsIDirectoryServiceProvider) ||
+          iid.equals(Components.interfaces.nsISupports)) {
+        return this;
+      }
+      throw Components.results.NS_ERROR_NO_INTERFACE;
+    }
+  };
+  dirSvc.QueryInterface(Components.interfaces.nsIDirectoryService)
+        .registerProvider(provider);
+
+  let obsSvc = Components.classes["@mozilla.org/observer-service;1"].
+        getService(Components.interfaces.nsIObserverService);
+
+  if (!_profileInitialized) {
+    obsSvc.notifyObservers(null, "profile-do-change", "xpcshell-do-get-profile");
+    _profileInitialized = true;
+  }
+
+  // The methods of 'provider' will retain this scope so null out everything
+  // to avoid spurious leak reports.
+  env = null;
+  profd = null;
+  dirSvc = null;
+  provider = null;
+  obsSvc = null;
+  return file.clone();
+}
+
+/**
+ * This function loads head.js (this file) in the child process, so that all
+ * functions defined in this file (do_throw, etc) are available to subsequent
+ * sendCommand calls.  It also sets various constants used by these functions.
+ *
+ * (Note that you may use sendCommand without calling this function first;  you
+ * simply won't have any of the functions in this file available.)
+ */
+function do_load_child_test_harness()
+{
+  // Make sure this isn't called from child process
+  if (!runningInParent) {
+    do_throw("run_test_in_child cannot be called from child!");
+  }
+
+  // Allow to be called multiple times, but only run once
+  if (typeof do_load_child_test_harness.alreadyRun != "undefined")
+    return;
+  do_load_child_test_harness.alreadyRun = 1;
+
+  _XPCSHELL_PROCESS = "parent";
+
+  let command =
+        "const _HEAD_JS_PATH=" + uneval(_HEAD_JS_PATH) + "; "
+      + "const _HTTPD_JS_PATH=" + uneval(_HTTPD_JS_PATH) + "; "
+      + "const _HEAD_FILES=" + uneval(_HEAD_FILES) + "; "
+      + "const _TAIL_FILES=" + uneval(_TAIL_FILES) + "; "
+      + "const _XPCSHELL_PROCESS='child';";
+
+  if (this._TESTING_MODULES_DIR) {
+    command += " const _TESTING_MODULES_DIR=" + uneval(_TESTING_MODULES_DIR) + ";";
+  }
+
+  command += " load(_HEAD_JS_PATH);";
+
+  sendCommand(command);
+}
+
+/**
+ * Runs an entire xpcshell unit test in a child process (rather than in chrome,
+ * which is the default).
+ *
+ * This function returns immediately, before the test has completed.
+ *
+ * @param testFile
+ *        The name of the script to run.  Path format same as load().
+ * @param optionalCallback.
+ *        Optional function to be called (in parent) when test on child is
+ *        complete.  If provided, the function must call do_test_finished();
+ */
+function run_test_in_child(testFile, optionalCallback)
+{
+  var callback = (typeof optionalCallback == 'undefined') ?
+                    do_test_finished : optionalCallback;
+
+  do_load_child_test_harness();
+
+  var testPath = do_get_file(testFile).path.replace(/\\/g, "/");
+  do_test_pending();
+  sendCommand("_dump('CHILD-TEST-STARTED'); "
+              + "const _TEST_FILE=['" + testPath + "']; _execute_test(); "
+              + "_dump('CHILD-TEST-COMPLETED');",
+              callback);
+}
+
+
+/**
+ * Add a test function to the list of tests that are to be run asynchronously.
+ *
+ * Each test function must call run_next_test() when it's done. Test files
+ * should call run_next_test() in their run_test function to execute all
+ * async tests.
+ *
+ * @return the test function that was passed in.
+ */
+let _gTests = [];
+function add_test(func) {
+  _gTests.push([false, func]);
+  return func;
+}
+
+// We lazy import Task.jsm so we don't incur a run-time penalty for all tests.
+let _Task;
+
+/**
+ * Add a test function which is a Task function.
+ *
+ * Task functions are functions fed into Task.jsm's Task.spawn(). They are
+ * generators that emit promises.
+ *
+ * If an exception is thrown, a do_check_* comparison fails, or if a rejected
+ * promise is yielded, the test function aborts immediately and the test is
+ * reported as a failure.
+ *
+ * Unlike add_test(), there is no need to call run_next_test(). The next test
+ * will run automatically as soon the task function is exhausted. To trigger
+ * premature (but successful) termination of the function, simply return or
+ * throw a Task.Result instance.
+ *
+ * Example usage:
+ *
+ * add_task(function test() {
+ *   let result = yield Promise.resolve(true);
+ *
+ *   do_check_true(result);
+ *
+ *   let secondary = yield someFunctionThatReturnsAPromise(result);
+ *   do_check_eq(secondary, "expected value");
+ * });
+ *
+ * add_task(function test_early_return() {
+ *   let result = yield somethingThatReturnsAPromise();
+ *
+ *   if (!result) {
+ *     // Test is ended immediately, with success.
+ *     return;
+ *   }
+ *
+ *   do_check_eq(result, "foo");
+ * });
+ */
+function add_task(func) {
+  if (!_Task) {
+    let ns = {};
+    _Task = Components.utils.import("resource://gre/modules/Task.jsm", ns).Task;
+  }
+
+  _gTests.push([true, func]);
+}
+
+/**
+ * Runs the next test function from the list of async tests.
+ */
+let _gRunningTest = null;
+let _gTestIndex = 0; // The index of the currently running test.
+function run_next_test()
+{
+  function _run_next_test()
+  {
+    if (_gTestIndex < _gTests.length) {
+      do_test_pending();
+      let _isTask;
+      [_isTask, _gRunningTest] = _gTests[_gTestIndex++];
+      _dump("TEST-INFO | " + _TEST_FILE + " | Starting " + _gRunningTest.name);
+
+      if (_isTask) {
+        _Task.spawn(_gRunningTest)
+             .then(run_next_test, do_report_unexpected_exception);
+      } else {
+        // Exceptions do not kill asynchronous tests, so they'll time out.
+        try {
+          _gRunningTest();
+        } catch (e) {
+          do_throw(e);
+        }
+      }
+    }
+  }
+
+  // For sane stacks during failures, we execute this code soon, but not now.
+  // We do this now, before we call do_test_finished(), to ensure the pending
+  // counter (_tests_pending) never reaches 0 while we still have tests to run
+  // (do_execute_soon bumps that counter).
+  do_execute_soon(_run_next_test);
+
+  if (_gRunningTest !== null) {
+    // Close the previous test do_test_pending call.
+    do_test_finished();
+  }
+}
+
+/**
+ * End of code adapted from xpcshell head.js
+ */
+
+
+/**
+ * JavaBridge facilitates communication between Java and JS. See
+ * JavascriptBridge.java for the corresponding JavascriptBridge and docs.
+ */
+
+function JavaBridge(obj) {
+
+  this._EVENT_TYPE = "Robocop:JS";
+  this._target = obj;
+  // The number of replies needed to answer all outstanding sync calls.
+  this._repliesNeeded = 0;
+  this._Services.obs.addObserver(this, this._EVENT_TYPE, false);
+
+  this._sendMessage("notify-loaded", []);
+};
+
+JavaBridge.prototype = {
+
+  _Services: Components.utils.import(
+    "resource://gre/modules/Services.jsm", {}).Services,
+
+  _sendMessageToJava: Components.utils.import(
+    "resource://gre/modules/Messaging.jsm", {}).sendMessageToJava,
+
+  _sendMessage: function (innerType, args) {
+    this._sendMessageToJava({
+      type: this._EVENT_TYPE,
+      innerType: innerType,
+      method: args[0],
+      args: Array.prototype.slice.call(args, 1),
+    });
+  },
+
+  observe: function(subject, topic, data) {
+    let message = JSON.parse(data);
+    if (message.innerType === "sync-reply") {
+      // Reply to our Javascript-to-Java sync call
+      this._repliesNeeded--;
+      return;
+    }
+    // Call the corresponding method on the target
+    try {
+      this._target[message.method].apply(this._target, message.args);
+    } catch (e) {
+      do_report_unexpected_exception(e, "Failed to call " + message.method);
+    }
+    if (message.innerType === "sync-call") {
+      // Reply for sync message
+      this._sendMessage("sync-reply", [message.method]);
+    }
+  },
+
+  /**
+   * Synchronously call a method in Java,
+   * given the method name followed by a list of arguments.
+   */
+  syncCall: function (methodName /*, ... */) {
+    this._sendMessage("sync-call", arguments);
+    let thread = this._Services.tm.currentThread;
+    let initialReplies = this._repliesNeeded;
+    // Need one more reply to answer the current sync call.
+    this._repliesNeeded++;
+    // Wait for the reply to arrive. Normally we would not want to
+    // spin the event loop, but here we're in a test and our API
+    // specifies a synchronous call, so we spin the loop to wait for
+    // the call to finish.
+    while (this._repliesNeeded > initialReplies) {
+      thread.processNextEvent(true);
+    }
+  },
+
+  /**
+   * Asynchronously call a method in Java,
+   * given the method name followed by a list of arguments.
+   */
+  asyncCall: function (methodName /*, ... */) {
+    this._sendMessage("async-call", arguments);
+  },
+
+  /**
+   * Disconnect with Java.
+   */
+  disconnect: function () {
+    this._Services.obs.removeObserver(this, this._EVENT_TYPE);
+  },
+};