Add m-esr52 at 52.6.0

21 files changed, 3828 insertions, 0 deletions

diff --git a/browser/experiments/test/addons/experiment-1/install.rdf b/browser/experiments/test/addons/experiment-1/install.rdf
new file mode 100644
index 000000000..f9d70054a
--- /dev/null
+++ b/browser/experiments/test/addons/experiment-1/install.rdf
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
+
+  <Description about="urn:mozilla:install-manifest">
+    <em:id>test-experiment-1@tests.mozilla.org</em:id>
+    <em:version>1</em:version>
+    <em:type>128</em:type>
+
+    <!-- Front End MetaData -->
+    <em:name>Test experiment 1</em:name>
+    <em:description>Yet another experiment that experiments experimentally.</em:description>
+
+  </Description>
+</RDF>
diff --git a/browser/experiments/test/addons/experiment-1a/install.rdf b/browser/experiments/test/addons/experiment-1a/install.rdf
new file mode 100644
index 000000000..7806b11b1
--- /dev/null
+++ b/browser/experiments/test/addons/experiment-1a/install.rdf
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
+
+  <Description about="urn:mozilla:install-manifest">
+    <em:id>test-experiment-1@tests.mozilla.org</em:id>
+    <em:version>1.1</em:version>
+    <em:type>128</em:type>
+
+    <!-- Front End MetaData -->
+    <em:name>Test experiment 1.1</em:name>
+    <em:description>And yet another experiment that experiments experimentally.</em:description>
+
+  </Description>
+</RDF>
diff --git a/browser/experiments/test/addons/experiment-2/install.rdf b/browser/experiments/test/addons/experiment-2/install.rdf
new file mode 100644
index 000000000..69122c0ef
--- /dev/null
+++ b/browser/experiments/test/addons/experiment-2/install.rdf
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
+
+  <Description about="urn:mozilla:install-manifest">
+    <em:id>test-experiment-2@tests.mozilla.org</em:id>
+    <em:version>1</em:version>
+    <em:type>128</em:type>
+
+    <!-- Front End MetaData -->
+    <em:name>Test experiment 2</em:name>
+    <em:description>And yet another experiment that experiments experimentally.</em:description>
+
+  </Description>
+</RDF>
diff --git a/browser/experiments/test/addons/experiment-racybranch/bootstrap.js b/browser/experiments/test/addons/experiment-racybranch/bootstrap.js
new file mode 100644
index 000000000..e8278f50f
--- /dev/null
+++ b/browser/experiments/test/addons/experiment-racybranch/bootstrap.js
@@ -0,0 +1,35 @@
+/* exported startup, shutdown, install, uninstall */
+
+var {classes: Cc, interfaces: Ci, utils: Cu} = Components;
+
+Cu.import("resource:///modules/experiments/Experiments.jsm");
+
+var gStarted = false;
+
+function startup(data, reasonCode) {
+  if (gStarted) {
+    return;
+  }
+  gStarted = true;
+
+  // delay realstartup to trigger the race condition
+  Cc['@mozilla.org/thread-manager;1'].getService(Ci.nsIThreadManager)
+    .mainThread.dispatch(realstartup, 0);
+}
+
+function realstartup() {
+  let experiments = Experiments.instance();
+  let experiment = experiments._getActiveExperiment();
+  if (experiment.branch) {
+    Cu.reportError("Found pre-existing branch: " + experiment.branch);
+    return;
+  }
+
+  let branch = "racy-set";
+  experiments.setExperimentBranch(experiment.id, branch)
+    .then(null, Cu.reportError);
+}
+
+function shutdown() { }
+function install() { }
+function uninstall() { }
diff --git a/browser/experiments/test/addons/experiment-racybranch/install.rdf b/browser/experiments/test/addons/experiment-racybranch/install.rdf
new file mode 100644
index 000000000..cebaede56
--- /dev/null
+++ b/browser/experiments/test/addons/experiment-racybranch/install.rdf
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>

+

+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"

+     xmlns:em="http://www.mozilla.org/2004/em-rdf#">

+

+  <Description about="urn:mozilla:install-manifest">

+    <em:id>test-experiment-racybranch@tests.mozilla.org</em:id>

+    <em:version>1</em:version>

+    <em:type>128</em:type>

+

+    <!-- Front End MetaData -->

+    <em:name>Test experiment racybranch</em:name>

+    <em:description>An experiment that sets the experiment branch in a potentially racy way.</em:description>

+

+  </Description>

+</RDF>

diff --git a/browser/experiments/test/xpcshell/.eslintrc.js b/browser/experiments/test/xpcshell/.eslintrc.js
new file mode 100644
index 000000000..1f540a05b
--- /dev/null
+++ b/browser/experiments/test/xpcshell/.eslintrc.js
@@ -0,0 +1,15 @@
+"use strict";
+
+module.exports = {
+  "extends": [
+    "../../../../testing/xpcshell/xpcshell.eslintrc.js"
+  ],
+
+  "rules": {
+    "no-unused-vars": ["error", {
+      "vars": "all",
+      "varsIgnorePattern": "^(Cc|Ci|Cr|Cu|EXPORTED_SYMBOLS)$",
+      "args": "none"
+    }]
+  }
+};
diff --git a/browser/experiments/test/xpcshell/experiments_1.manifest b/browser/experiments/test/xpcshell/experiments_1.manifest
new file mode 100644
index 000000000..0401ea328
--- /dev/null
+++ b/browser/experiments/test/xpcshell/experiments_1.manifest
@@ -0,0 +1,19 @@
+{
+  "version": 1,
+  "experiments": [
+    {
+      "id": "test-experiment-1@tests.mozilla.org",
+      "xpiURL": "https://experiments.mozilla.org/foo.xpi",
+      "xpiHash": "sha1:cb1eb32b89d86d78b7326f416cf404548c5e0099",
+      "startTime": 1393000000,
+      "endTime": 1394000000,
+      "appName": ["Firefox", "Fennec"],
+      "minVersion": "28",
+      "maxVersion": "30",
+      "maxActiveSeconds": 60,
+      "os": ["windows", "linux", "osx"],
+      "channel": ["daily", "weekly", "nightly"],
+      "jsfilter": "function filter(context) { return true; }"
+    }
+  ]
+}
diff --git a/browser/experiments/test/xpcshell/head.js b/browser/experiments/test/xpcshell/head.js
new file mode 100644
index 000000000..ae356ea2d
--- /dev/null
+++ b/browser/experiments/test/xpcshell/head.js
@@ -0,0 +1,199 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/* exported PREF_EXPERIMENTS_ENABLED, PREF_LOGGING_LEVEL, PREF_LOGGING_DUMP
+            PREF_MANIFEST_URI, PREF_FETCHINTERVAL, EXPERIMENT1_ID,
+            EXPERIMENT1_NAME, EXPERIMENT1_XPI_SHA1, EXPERIMENT1A_NAME,
+            EXPERIMENT1A_XPI_SHA1, EXPERIMENT2_ID, EXPERIMENT2_XPI_SHA1,
+            EXPERIMENT3_ID, EXPERIMENT4_ID, FAKE_EXPERIMENTS_1,
+            FAKE_EXPERIMENTS_2, gAppInfo, removeCacheFile, defineNow,
+            futureDate, dateToSeconds, loadAddonManager, promiseRestartManager,
+            startAddonManagerOnly, getExperimentAddons, replaceExperiments */
+
+var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Promise.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource://testing-common/AddonManagerTesting.jsm");
+Cu.import("resource://testing-common/AddonTestUtils.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "AddonManager",
+                                  "resource://gre/modules/AddonManager.jsm");
+
+const PREF_EXPERIMENTS_ENABLED  = "experiments.enabled";
+const PREF_LOGGING_LEVEL        = "experiments.logging.level";
+const PREF_LOGGING_DUMP         = "experiments.logging.dump";
+const PREF_MANIFEST_URI         = "experiments.manifest.uri";
+const PREF_FETCHINTERVAL        = "experiments.manifest.fetchIntervalSeconds";
+const PREF_TELEMETRY_ENABLED    = "toolkit.telemetry.enabled";
+
+function getExperimentPath(base) {
+  let p = do_get_cwd();
+  p.append(base);
+  return p.path;
+}
+
+function sha1File(path) {
+  let f = Cc["@mozilla.org/file/local;1"]
+            .createInstance(Ci.nsILocalFile);
+  f.initWithPath(path);
+  let hasher = Cc["@mozilla.org/security/hash;1"]
+                 .createInstance(Ci.nsICryptoHash);
+  hasher.init(hasher.SHA1);
+
+  let is = Cc["@mozilla.org/network/file-input-stream;1"]
+             .createInstance(Ci.nsIFileInputStream);
+  is.init(f, -1, 0, 0);
+  hasher.updateFromStream(is, Math.pow(2, 32) - 1);
+  is.close();
+  let bytes = hasher.finish(false);
+
+  let rv = "";
+  for (let i = 0; i < bytes.length; i++) {
+    rv += ("0" + bytes.charCodeAt(i).toString(16)).substr(-2);
+  }
+  return rv;
+}
+
+const EXPERIMENT1_ID       = "test-experiment-1@tests.mozilla.org";
+const EXPERIMENT1_XPI_NAME = "experiment-1.xpi";
+const EXPERIMENT1_NAME     = "Test experiment 1";
+const EXPERIMENT1_PATH     = getExperimentPath(EXPERIMENT1_XPI_NAME);
+const EXPERIMENT1_XPI_SHA1 = "sha1:" + sha1File(EXPERIMENT1_PATH);
+
+
+const EXPERIMENT1A_XPI_NAME = "experiment-1a.xpi";
+const EXPERIMENT1A_NAME     = "Test experiment 1.1";
+const EXPERIMENT1A_PATH     = getExperimentPath(EXPERIMENT1A_XPI_NAME);
+const EXPERIMENT1A_XPI_SHA1 = "sha1:" + sha1File(EXPERIMENT1A_PATH);
+
+const EXPERIMENT2_ID       = "test-experiment-2@tests.mozilla.org"
+const EXPERIMENT2_XPI_NAME = "experiment-2.xpi";
+const EXPERIMENT2_PATH     = getExperimentPath(EXPERIMENT2_XPI_NAME);
+const EXPERIMENT2_XPI_SHA1 = "sha1:" + sha1File(EXPERIMENT2_PATH);
+
+const EXPERIMENT3_ID       = "test-experiment-3@tests.mozilla.org";
+const EXPERIMENT4_ID       = "test-experiment-4@tests.mozilla.org";
+
+const FAKE_EXPERIMENTS_1 = [
+  {
+    id: "id1",
+    name: "experiment1",
+    description: "experiment 1",
+    active: true,
+    detailUrl: "https://dummy/experiment1",
+    branch: "foo",
+  },
+];
+
+const FAKE_EXPERIMENTS_2 = [
+  {
+    id: "id2",
+    name: "experiment2",
+    description: "experiment 2",
+    active: false,
+    endDate: new Date(2014, 2, 11, 2, 4, 35, 42).getTime(),
+    detailUrl: "https://dummy/experiment2",
+    branch: null,
+  },
+  {
+    id: "id1",
+    name: "experiment1",
+    description: "experiment 1",
+    active: false,
+    endDate: new Date(2014, 2, 10, 0, 0, 0, 0).getTime(),
+    detailURL: "https://dummy/experiment1",
+    branch: null,
+  },
+];
+
+var gAppInfo = null;
+
+function removeCacheFile() {
+  let path = OS.Path.join(OS.Constants.Path.profileDir, "experiments.json");
+  return OS.File.remove(path);
+}
+
+function patchPolicy(policy, data) {
+  for (let key of Object.keys(data)) {
+    Object.defineProperty(policy, key, {
+      value: data[key],
+      writable: true,
+    });
+  }
+}
+
+function defineNow(policy, time) {
+  patchPolicy(policy, { now: () => new Date(time) });
+}
+
+function futureDate(date, offset) {
+  return new Date(date.getTime() + offset);
+}
+
+function dateToSeconds(date) {
+  return date.getTime() / 1000;
+}
+
+var gGlobalScope = this;
+function loadAddonManager() {
+  AddonTestUtils.init(gGlobalScope);
+  AddonTestUtils.overrideCertDB();
+  createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "1.9.2");
+  return AddonTestUtils.promiseStartupManager();
+}
+
+const {
+  promiseRestartManager,
+} = AddonTestUtils;
+
+// Starts the addon manager without creating app info. We can't directly use
+// |loadAddonManager| defined above in test_conditions.js as it would make the test fail.
+function startAddonManagerOnly() {
+  let addonManager = Cc["@mozilla.org/addons/integration;1"]
+                       .getService(Ci.nsIObserver)
+                       .QueryInterface(Ci.nsITimerCallback);
+  addonManager.observe(null, "addons-startup", null);
+}
+
+function getExperimentAddons(previous=false) {
+  let deferred = Promise.defer();
+
+  AddonManager.getAddonsByTypes(["experiment"], (addons) => {
+    if (previous) {
+      deferred.resolve(addons);
+    } else {
+      deferred.resolve(addons.filter(a => !a.appDisabled));
+    }
+  });
+
+  return deferred.promise;
+}
+
+function createAppInfo(ID="xpcshell@tests.mozilla.org", name="XPCShell",
+                       version="1.0", platformVersion="1.0") {
+  AddonTestUtils.createAppInfo(ID, name, version, platformVersion);
+  gAppInfo = AddonTestUtils.appInfo;
+}
+
+/**
+ * Replace the experiments on an Experiments with a new list.
+ *
+ * This monkeypatches getExperiments(). It doesn't monkeypatch the internal
+ * experiments list. So its utility is not as great as it could be.
+ */
+function replaceExperiments(experiment, list) {
+  Object.defineProperty(experiment, "getExperiments", {
+    writable: true,
+    value: () => {
+      return Promise.resolve(list);
+    },
+  });
+}
+
+// Experiments require Telemetry to be enabled, and that's not true for debug
+// builds. Let's just enable it here instead of going through each test.
+Services.prefs.setBoolPref(PREF_TELEMETRY_ENABLED, true);
diff --git a/browser/experiments/test/xpcshell/test_activate.js b/browser/experiments/test/xpcshell/test_activate.js
new file mode 100644
index 000000000..60deafbfb
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_activate.js
@@ -0,0 +1,151 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://testing-common/httpd.js");
+Cu.import("resource:///modules/experiments/Experiments.jsm");
+
+const SEC_IN_ONE_DAY  = 24 * 60 * 60;
+const MS_IN_ONE_DAY   = SEC_IN_ONE_DAY * 1000;
+
+var gHttpServer = null;
+var gHttpRoot   = null;
+var gPolicy     = null;
+
+function ManifestEntry(data) {
+  this.id        = data.id        || EXPERIMENT1_ID;
+  this.xpiURL    = data.xpiURL    || gHttpRoot + EXPERIMENT1_XPI_NAME;
+  this.xpiHash   = data.xpiHash   || EXPERIMENT1_XPI_SHA1;
+  this.appName   = data.appName   || ["XPCShell"];
+  this.channel   = data.appName   || ["nightly"];
+  this.startTime = data.startTime || new Date(2010, 0, 1, 12).getTime() / 1000;
+  this.endTime   = data.endTime   || new Date(9001, 0, 1, 12).getTime() / 1000;
+  this.maxActiveSeconds = data.maxActiveSeconds || 5 * SEC_IN_ONE_DAY;
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_setup() {
+  loadAddonManager();
+  gPolicy = new Experiments.Policy();
+
+  gHttpServer = new HttpServer();
+  gHttpServer.start(-1);
+  let port = gHttpServer.identity.primaryPort;
+  gHttpRoot = "http://localhost:" + port + "/";
+  gHttpServer.registerDirectory("/", do_get_cwd());
+  do_register_cleanup(() => gHttpServer.stop(() => {}));
+
+  patchPolicy(gPolicy, {
+    updatechannel: () => "nightly",
+  });
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+});
+
+function isApplicable(experiment) {
+  let deferred = Promise.defer();
+  experiment.isApplicable().then(
+    result => deferred.resolve({ applicable: true,  reason: null }),
+    reason => deferred.resolve({ applicable: false, reason: reason })
+  );
+
+  return deferred.promise;
+}
+
+add_task(function* test_startStop() {
+  let baseDate  = new Date(2014, 5, 1, 12);
+  let startDate = futureDate(baseDate, 30 * MS_IN_ONE_DAY);
+  let endDate   = futureDate(baseDate, 60 * MS_IN_ONE_DAY);
+  let manifestData = new ManifestEntry({
+    startTime:        dateToSeconds(startDate),
+    endTime:          dateToSeconds(endDate),
+    maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+  });
+  let experiment = new Experiments.ExperimentEntry(gPolicy);
+  experiment.initFromManifestData(manifestData);
+
+  // We need to associate it with the singleton so the onInstallStarted
+  // Addon Manager listener will know about it.
+  Experiments.instance()._experiments = new Map();
+  Experiments.instance()._experiments.set(experiment.id, experiment);
+
+  let result;
+
+  defineNow(gPolicy, baseDate);
+  result = yield isApplicable(experiment);
+  Assert.equal(result.applicable, false, "Experiment should not be applicable.");
+  Assert.equal(experiment.enabled, false, "Experiment should not be enabled.");
+
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "No experiment add-ons are installed.");
+
+  defineNow(gPolicy, futureDate(startDate, 5 * MS_IN_ONE_DAY));
+  result = yield isApplicable(experiment);
+  Assert.equal(result.applicable, true, "Experiment should now be applicable.");
+  Assert.equal(experiment.enabled, false, "Experiment should not be enabled.");
+
+  let changes = yield experiment.start();
+  Assert.equal(changes, experiment.ADDON_CHANGE_INSTALL, "Add-on was installed.");
+  addons = yield getExperimentAddons();
+  Assert.equal(experiment.enabled, true, "Experiment should now be enabled.");
+  Assert.equal(addons.length, 1, "1 experiment add-on is installed.");
+  Assert.equal(addons[0].id, experiment._addonId, "The add-on is the one we expect.");
+  Assert.equal(addons[0].userDisabled, false, "The add-on is not userDisabled.");
+  Assert.ok(addons[0].isActive, "The add-on is active.");
+
+  changes = yield experiment.stop();
+  Assert.equal(changes, experiment.ADDON_CHANGE_UNINSTALL, "Add-on was uninstalled.");
+  addons = yield getExperimentAddons();
+  Assert.equal(experiment.enabled, false, "Experiment should not be enabled.");
+  Assert.equal(addons.length, 0, "Experiment should be uninstalled from the Addon Manager.");
+
+  changes = yield experiment.start();
+  Assert.equal(changes, experiment.ADDON_CHANGE_INSTALL, "Add-on was installed.");
+  addons = yield getExperimentAddons();
+  Assert.equal(experiment.enabled, true, "Experiment should now be enabled.");
+  Assert.equal(addons.length, 1, "1 experiment add-on is installed.");
+  Assert.equal(addons[0].id, experiment._addonId, "The add-on is the one we expect.");
+  Assert.equal(addons[0].userDisabled, false, "The add-on is not userDisabled.");
+  Assert.ok(addons[0].isActive, "The add-on is active.");
+
+  result = yield experiment.shouldStop();
+  Assert.equal(result.shouldStop, false, "shouldStop should be false.");
+  Assert.equal(experiment.enabled, true, "Experiment should be enabled.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "Experiment still in add-ons manager.");
+  Assert.ok(addons[0].isActive, "The add-on is still active.");
+
+  defineNow(gPolicy, futureDate(endDate, MS_IN_ONE_DAY));
+  result = yield experiment.shouldStop();
+  Assert.equal(result.shouldStop, true, "shouldStop should now be true.");
+  changes = yield experiment.stop();
+  Assert.equal(changes, experiment.ADDON_CHANGE_UNINSTALL, "Add-on should be uninstalled.");
+  Assert.equal(experiment.enabled, false, "Experiment should be disabled.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Experiment add-on is uninstalled.");
+
+  // Ensure hash validation works.
+  // We set an incorrect hash and expect the install to fail.
+  experiment._manifestData.xpiHash = "sha1:41014dcc66b4dcedcd973491a1530a32f0517d8a";
+  let errored = false;
+  try {
+    yield experiment.start();
+  } catch (ex) {
+    errored = true;
+  }
+  Assert.ok(experiment._failedStart, "Experiment failed to start.");
+  Assert.ok(errored, "start() threw an exception.");
+
+  // Make sure "ignore hashes" mode works.
+  gPolicy.ignoreHashes = true;
+  changes = yield experiment.start();
+  Assert.equal(changes, experiment.ADDON_CHANGE_INSTALL);
+  yield experiment.stop();
+  gPolicy.ignoreHashes = false;
+});
diff --git a/browser/experiments/test/xpcshell/test_api.js b/browser/experiments/test/xpcshell/test_api.js
new file mode 100644
index 000000000..9f0112570
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_api.js
@@ -0,0 +1,1647 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://testing-common/httpd.js");
+Cu.import("resource://testing-common/AddonManagerTesting.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "Experiments",
+  "resource:///modules/experiments/Experiments.jsm");
+
+const MANIFEST_HANDLER         = "manifests/handler";
+
+const SEC_IN_ONE_DAY  = 24 * 60 * 60;
+const MS_IN_ONE_DAY   = SEC_IN_ONE_DAY * 1000;
+
+var gHttpServer          = null;
+var gHttpRoot            = null;
+var gDataRoot            = null;
+var gPolicy              = null;
+var gManifestObject      = null;
+var gManifestHandlerURI  = null;
+var gTimerScheduleOffset = -1;
+
+function uninstallExperimentAddons() {
+  return Task.spawn(function* () {
+    let addons = yield getExperimentAddons();
+    for (let a of addons) {
+      yield AddonManagerTesting.uninstallAddonByID(a.id);
+    }
+  });
+}
+
+function testCleanup(experimentsInstance) {
+  return Task.spawn(function* () {
+    yield promiseRestartManager();
+    yield uninstallExperimentAddons();
+    yield removeCacheFile();
+  });
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_setup() {
+  loadAddonManager();
+
+  gHttpServer = new HttpServer();
+  gHttpServer.start(-1);
+  let port = gHttpServer.identity.primaryPort;
+  gHttpRoot = "http://localhost:" + port + "/";
+  gDataRoot = gHttpRoot + "data/";
+  gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
+  gHttpServer.registerDirectory("/data/", do_get_cwd());
+  gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
+    response.setStatusLine(null, 200, "OK");
+    response.write(JSON.stringify(gManifestObject));
+    response.processAsync();
+    response.finish();
+  });
+  do_register_cleanup(() => gHttpServer.stop(() => {}));
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
+  Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
+
+  gPolicy = new Experiments.Policy();
+  patchPolicy(gPolicy, {
+    updatechannel: () => "nightly",
+    oneshotTimer: (callback, timeout, thisObj, name) => gTimerScheduleOffset = timeout,
+  });
+});
+
+add_task(function* test_contract() {
+  Cc["@mozilla.org/browser/experiments-service;1"].getService();
+});
+
+// Test basic starting and stopping of experiments.
+
+add_task(function* test_getExperiments() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate1 = futureDate(baseDate,  50 * MS_IN_ONE_DAY);
+  let endDate1   = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
+  let startDate2 = futureDate(baseDate, 150 * MS_IN_ONE_DAY);
+  let endDate2   = futureDate(baseDate, 200 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT2_ID,
+        xpiURL:           gDataRoot + EXPERIMENT2_XPI_NAME,
+        xpiHash:          EXPERIMENT2_XPI_SHA1,
+        startTime:        dateToSeconds(startDate2),
+        endTime:          dateToSeconds(endDate2),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate1),
+        endTime:          dateToSeconds(endDate1),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  // Data to compare the result of Experiments.getExperiments() against.
+
+  let experimentListData = [
+    {
+      id: EXPERIMENT2_ID,
+      name: "Test experiment 2",
+      description: "And yet another experiment that experiments experimentally.",
+    },
+    {
+      id: EXPERIMENT1_ID,
+      name: EXPERIMENT1_NAME,
+      description: "Yet another experiment that experiments experimentally.",
+    },
+  ];
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+  // Use updateManifest() to provide for coverage of that path.
+
+  let now = baseDate;
+  gTimerScheduleOffset = -1;
+  defineNow(gPolicy, now);
+
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  Assert.equal(experiments.getActiveExperimentID(), null,
+               "getActiveExperimentID should return null");
+
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Precondition: No experiment add-ons are installed.");
+
+  try {
+    yield experiments.getExperimentBranch();
+    Assert.ok(false, "getExperimentBranch should fail with no experiment");
+  }
+  catch (e) {
+    Assert.ok(true, "getExperimentBranch correctly threw");
+  }
+
+  // Trigger update, clock set for experiment 1 to start.
+
+  now = futureDate(startDate1, 5 * MS_IN_ONE_DAY);
+  gTimerScheduleOffset = -1;
+  defineNow(gPolicy, now);
+
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  Assert.equal(experiments.getActiveExperimentID(), EXPERIMENT1_ID,
+               "getActiveExperimentID should return the active experiment1");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "An experiment add-on was installed.");
+
+  experimentListData[1].active = true;
+  experimentListData[1].endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
+  for (let k of Object.keys(experimentListData[1])) {
+    Assert.equal(experimentListData[1][k], list[0][k],
+                 "Property " + k + " should match reference data.");
+  }
+
+  let b = yield experiments.getExperimentBranch();
+  Assert.strictEqual(b, null, "getExperimentBranch should return null by default");
+
+  b = yield experiments.getExperimentBranch(EXPERIMENT1_ID);
+  Assert.strictEqual(b, null, "getExperimentsBranch should return null (with id)");
+
+  yield experiments.setExperimentBranch(EXPERIMENT1_ID, "foo");
+  b = yield experiments.getExperimentBranch();
+  Assert.strictEqual(b, "foo", "getExperimentsBranch should return the set value");
+
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  Assert.equal(gTimerScheduleOffset, 10 * MS_IN_ONE_DAY,
+               "Experiment re-evaluation should have been scheduled correctly.");
+
+  // Trigger update, clock set for experiment 1 to stop.
+
+  now = futureDate(endDate1, 1000);
+  gTimerScheduleOffset = -1;
+  defineNow(gPolicy, now);
+
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  Assert.equal(experiments.getActiveExperimentID(), null,
+               "getActiveExperimentID should return null again");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "The experiment add-on should be uninstalled.");
+
+  experimentListData[1].active = false;
+  experimentListData[1].endDate = now.getTime();
+  for (let k of Object.keys(experimentListData[1])) {
+    Assert.equal(experimentListData[1][k], list[0][k],
+                 "Property " + k + " should match reference data.");
+  }
+
+  Assert.equal(gTimerScheduleOffset, startDate2 - now,
+               "Experiment re-evaluation should have been scheduled correctly.");
+
+  // Trigger update, clock set for experiment 2 to start.
+  // Use notify() to provide for coverage of that path.
+
+  now = startDate2;
+  gTimerScheduleOffset = -1;
+  defineNow(gPolicy, now);
+
+  yield experiments.notify();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  Assert.equal(experiments.getActiveExperimentID(), EXPERIMENT2_ID,
+               "getActiveExperimentID should return the active experiment2");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 2, "Experiment list should have 2 entries now.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "An experiment add-on is installed.");
+
+  experimentListData[0].active = true;
+  experimentListData[0].endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
+  for (let i=0; i<experimentListData.length; ++i) {
+    let entry = experimentListData[i];
+    for (let k of Object.keys(entry)) {
+      Assert.equal(entry[k], list[i][k],
+                   "Entry " + i + " - Property '" + k + "' should match reference data.");
+    }
+  }
+
+  Assert.equal(gTimerScheduleOffset, 10 * MS_IN_ONE_DAY,
+               "Experiment re-evaluation should have been scheduled correctly.");
+
+  // Trigger update, clock set for experiment 2 to stop.
+
+  now = futureDate(startDate2, 10 * MS_IN_ONE_DAY + 1000);
+  gTimerScheduleOffset = -1;
+  defineNow(gPolicy, now);
+  yield experiments.notify();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  Assert.equal(experiments.getActiveExperimentID(), null,
+               "getActiveExperimentID should return null again2");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 2, "Experiment list should have 2 entries now.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "No experiments add-ons are installed.");
+
+  experimentListData[0].active = false;
+  experimentListData[0].endDate = now.getTime();
+  for (let i=0; i<experimentListData.length; ++i) {
+    let entry = experimentListData[i];
+    for (let k of Object.keys(entry)) {
+      Assert.equal(entry[k], list[i][k],
+                   "Entry " + i + " - Property '" + k + "' should match reference data.");
+    }
+  }
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+add_task(function* test_getActiveExperimentID() {
+  // Check that getActiveExperimentID returns the correct result even
+  // after .uninit()
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate1 = futureDate(baseDate,  50 * MS_IN_ONE_DAY);
+  let endDate1   = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate1),
+        endTime:          dateToSeconds(endDate1),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let now = futureDate(startDate1, 5 * MS_IN_ONE_DAY);
+  gTimerScheduleOffset = -1;
+  defineNow(gPolicy, now);
+
+  let experiments = new Experiments.Experiments(gPolicy);
+  yield experiments.updateManifest();
+
+  Assert.equal(experiments.getActiveExperimentID(), EXPERIMENT1_ID,
+               "getActiveExperimentID should return the active experiment1");
+
+  yield promiseRestartManager();
+  Assert.equal(experiments.getActiveExperimentID(), EXPERIMENT1_ID,
+               "getActiveExperimentID should return the active experiment1 after uninit()");
+
+  yield testCleanup(experiments);
+});
+
+// Test that we handle the experiments addon already being
+// installed properly.
+// We should just pave over them.
+
+add_task(function* test_addonAlreadyInstalled() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate  = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate    = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Trigger update, clock set for the experiment to start.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active.");
+
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "1 add-on is installed.");
+
+  // Install conflicting addon.
+
+  yield AddonManagerTesting.installXPIFromURL(gDataRoot + EXPERIMENT1_XPI_NAME, EXPERIMENT1_XPI_SHA1);
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "1 add-on is installed.");
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should still have 1 entry.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+add_task(function* test_lastActiveToday() {
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  replaceExperiments(experiments, FAKE_EXPERIMENTS_1);
+
+  let e = yield experiments.getExperiments();
+  Assert.equal(e.length, 1, "Monkeypatch successful.");
+  Assert.equal(e[0].id, "id1", "ID looks sane");
+  Assert.ok(e[0].active, "Experiment is active.");
+
+  let lastActive = yield experiments.lastActiveToday();
+  Assert.equal(e[0], lastActive, "Last active object is expected.");
+
+  replaceExperiments(experiments, FAKE_EXPERIMENTS_2);
+  e = yield experiments.getExperiments();
+  Assert.equal(e.length, 2, "Monkeypatch successful.");
+
+  defineNow(gPolicy, e[0].endDate);
+
+  lastActive = yield experiments.lastActiveToday();
+  Assert.ok(lastActive, "Have a last active experiment");
+  Assert.equal(lastActive, e[0], "Last active object is expected.");
+
+  yield testCleanup(experiments);
+});
+
+// Test explicitly disabling experiments.
+
+add_task(function* test_disableExperiment() {
+  // Dates this test is based on.
+
+  let startDate = new Date(2004, 10, 9, 12);
+  let endDate   = futureDate(startDate, 100 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  // Data to compare the result of Experiments.getExperiments() against.
+
+  let experimentInfo = {
+    id: EXPERIMENT1_ID,
+    name: EXPERIMENT1_NAME,
+    description: "Yet another experiment that experiments experimentally.",
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set for the experiment to start.
+
+  let now = futureDate(startDate, 5 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+
+  experimentInfo.active = true;
+  experimentInfo.endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
+  for (let k of Object.keys(experimentInfo)) {
+    Assert.equal(experimentInfo[k], list[0][k],
+                 "Property " + k + " should match reference data.");
+  }
+
+  // Test disabling the experiment.
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.disableExperiment("foo");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+
+  experimentInfo.active = false;
+  experimentInfo.endDate = now.getTime();
+  for (let k of Object.keys(experimentInfo)) {
+    Assert.equal(experimentInfo[k], list[0][k],
+                 "Property " + k + " should match reference data.");
+  }
+
+  // Test that updating the list doesn't re-enable it.
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+
+  for (let k of Object.keys(experimentInfo)) {
+    Assert.equal(experimentInfo[k], list[0][k],
+                 "Property " + k + " should match reference data.");
+  }
+
+  yield testCleanup(experiments);
+});
+
+add_task(function* test_disableExperimentsFeature() {
+  // Dates this test is based on.
+
+  let startDate = new Date(2004, 10, 9, 12);
+  let endDate   = futureDate(startDate, 100 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  // Data to compare the result of Experiments.getExperiments() against.
+
+  let experimentInfo = {
+    id: EXPERIMENT1_ID,
+    name: EXPERIMENT1_NAME,
+    description: "Yet another experiment that experiments experimentally.",
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+  Assert.equal(experiments.enabled, true, "Experiments feature should be enabled.");
+
+  // Trigger update, clock set for the experiment to start.
+
+  let now = futureDate(startDate, 5 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+
+  experimentInfo.active = true;
+  experimentInfo.endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
+  for (let k of Object.keys(experimentInfo)) {
+    Assert.equal(experimentInfo[k], list[0][k],
+                 "Property " + k + " should match reference data.");
+  }
+
+  // Test disabling experiments.
+
+  experiments._toggleExperimentsEnabled(false);
+  yield experiments.notify();
+  Assert.equal(experiments.enabled, false, "Experiments feature should be disabled now.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+
+  experimentInfo.active = false;
+  experimentInfo.endDate = now.getTime();
+  for (let k of Object.keys(experimentInfo)) {
+    Assert.equal(experimentInfo[k], list[0][k],
+                 "Property " + k + " should match reference data.");
+  }
+
+  // Test that updating the list doesn't re-enable it.
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  try {
+    yield experiments.updateManifest();
+  } catch (e) {
+    // Exception expected, the feature is disabled.
+  }
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+
+  for (let k of Object.keys(experimentInfo)) {
+    Assert.equal(experimentInfo[k], list[0][k],
+                 "Property " + k + " should match reference data.");
+  }
+
+  yield testCleanup(experiments);
+});
+
+// Test that after a failed experiment install:
+// * the next applicable experiment gets installed
+// * changing the experiments data later triggers re-evaluation
+
+add_task(function* test_installFailure() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate   = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      {
+        id:               EXPERIMENT2_ID,
+        xpiURL:           gDataRoot + EXPERIMENT2_XPI_NAME,
+        xpiHash:          EXPERIMENT2_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  // Data to compare the result of Experiments.getExperiments() against.
+
+  let experimentListData = [
+    {
+      id: EXPERIMENT1_ID,
+      name: EXPERIMENT1_NAME,
+      description: "Yet another experiment that experiments experimentally.",
+    },
+    {
+      id: EXPERIMENT2_ID,
+      name: "Test experiment 2",
+      description: "And yet another experiment that experiments experimentally.",
+    },
+  ];
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Trigger update, clock set for experiment 1 & 2 to start,
+  // invalid hash for experiment 1.
+  // Order in the manifest matters, so we should start experiment 1,
+  // fail to install it & start experiment 2 instead.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].xpiHash = "sha1:0000000000000000000000000000000000000000";
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT2_ID, "Experiment 2 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 2 should be active.");
+
+  // Trigger update, clock set for experiment 2 to stop.
+
+  now = futureDate(now, 20 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  experimentListData[0].active = false;
+  experimentListData[0].endDate = now;
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT2_ID, "Experiment 2 should be the sole entry.");
+  Assert.equal(list[0].active, false, "Experiment should not be active.");
+
+  // Trigger update with a fixed entry for experiment 1,
+  // which should get re-evaluated & started now.
+
+  now = futureDate(now, 20 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].xpiHash = EXPERIMENT1_XPI_SHA1;
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  experimentListData[0].active = true;
+  experimentListData[0].endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 2, "Experiment list should have 2 entries now.");
+
+  for (let i=0; i<experimentListData.length; ++i) {
+    let entry = experimentListData[i];
+    for (let k of Object.keys(entry)) {
+      Assert.equal(entry[k], list[i][k],
+                   "Entry " + i + " - Property '" + k + "' should match reference data.");
+    }
+  }
+
+  yield testCleanup(experiments);
+});
+
+// Test that after an experiment was disabled by user action,
+// the experiment is not activated again if manifest data changes.
+
+add_task(function* test_userDisabledAndUpdated() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate   = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Trigger update, clock set for experiment 1 to start.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active.");
+  let todayActive = yield experiments.lastActiveToday();
+  Assert.ok(todayActive, "Last active for today reports a value.");
+  Assert.equal(todayActive.id, list[0].id, "The entry is what we expect.");
+
+  // Explicitly disable an experiment.
+
+  now = futureDate(now, 20 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.disableExperiment("foo");
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, false, "Experiment should not be active anymore.");
+  todayActive = yield experiments.lastActiveToday();
+  Assert.ok(todayActive, "Last active for today still returns a value.");
+  Assert.equal(todayActive.id, list[0].id, "The ID is still the same.");
+
+  // Trigger an update with a faked change for experiment 1.
+
+  now = futureDate(now, 20 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  experiments._experiments.get(EXPERIMENT1_ID)._manifestData.xpiHash =
+    "sha1:0000000000000000000000000000000000000000";
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, expectedObserverFireCount,
+               "Experiments observer should not have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, false, "Experiment should still be inactive.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+// Test that changing the hash for an active experiments triggers an
+// update for it.
+
+add_task(function* test_updateActiveExperiment() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate   = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  let todayActive = yield experiments.lastActiveToday();
+  Assert.equal(todayActive, null, "No experiment active today.");
+
+  // Trigger update, clock set for the experiment to start.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active.");
+  Assert.equal(list[0].name, EXPERIMENT1_NAME, "Experiments name should match.");
+  todayActive = yield experiments.lastActiveToday();
+  Assert.ok(todayActive, "todayActive() returns a value.");
+  Assert.equal(todayActive.id, list[0].id, "It returns the active experiment.");
+
+  // Trigger an update for the active experiment by changing it's hash (and xpi)
+  // in the manifest.
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].xpiHash = EXPERIMENT1A_XPI_SHA1;
+  gManifestObject.experiments[0].xpiURL = gDataRoot + EXPERIMENT1A_XPI_NAME;
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should still be active.");
+  Assert.equal(list[0].name, EXPERIMENT1A_NAME, "Experiments name should have been updated.");
+  todayActive = yield experiments.lastActiveToday();
+  Assert.equal(todayActive.id, list[0].id, "last active today is still sane.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+// Tests that setting the disable flag for an active experiment
+// stops it.
+
+add_task(function* test_disableActiveExperiment() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate   = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Trigger update, clock set for the experiment to start.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active.");
+
+  // Trigger an update with the experiment being disabled.
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].disabled = true;
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, false, "Experiment 1 should be disabled.");
+
+  // Check that the experiment stays disabled.
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  delete gManifestObject.experiments[0].disabled;
+  yield experiments.updateManifest();
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, false, "Experiment 1 should still be disabled.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+// Test that:
+// * setting the frozen flag for a not-yet-started experiment keeps
+//   it from starting
+// * after a removing the frozen flag, the experiment can still start
+
+add_task(function* test_freezePendingExperiment() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate   = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Trigger update, clock set for the experiment to start but frozen.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].frozen = true;
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, expectedObserverFireCount,
+               "Experiments observer should have not been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should have no entries yet.");
+
+  // Trigger an update with the experiment not being frozen anymore.
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  delete gManifestObject.experiments[0].frozen;
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active now.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+// Test that setting the frozen flag for an active experiment doesn't
+// stop it.
+
+add_task(function* test_freezeActiveExperiment() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate   = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Trigger update, clock set for the experiment to start.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active.");
+  Assert.equal(list[0].name, EXPERIMENT1_NAME, "Experiments name should match.");
+
+  // Trigger an update with the experiment being disabled.
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].frozen = true;
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should still be active.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+// Test that removing an active experiment from the manifest doesn't
+// stop it.
+
+add_task(function* test_removeActiveExperiment() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate  = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate    = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+  let startDate2 = futureDate(baseDate, 20000 * MS_IN_ONE_DAY);
+  let endDate2   = futureDate(baseDate, 30000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      {
+        id:               EXPERIMENT2_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT2_XPI_SHA1,
+        startTime:        dateToSeconds(startDate2),
+        endTime:          dateToSeconds(endDate2),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Trigger update, clock set for the experiment to start.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active.");
+  Assert.equal(list[0].name, EXPERIMENT1_NAME, "Experiments name should match.");
+
+  // Trigger an update with experiment 1 missing from the manifest
+
+  now = futureDate(now, 1 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].frozen = true;
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should still be active.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+// Test that we correctly handle experiment start & install failures.
+
+add_task(function* test_invalidUrl() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate   = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME + ".invalid",
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        0,
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set for the experiment to start.
+
+  let now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gTimerScheduleOffset = null;
+
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  Assert.equal(gTimerScheduleOffset, null, "No new timer should have been scheduled.");
+
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+// Test that we handle it properly when active experiment addons are being
+// uninstalled.
+
+add_task(function* test_unexpectedUninstall() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate  = futureDate(baseDate,   100 * MS_IN_ONE_DAY);
+  let endDate    = futureDate(baseDate, 10000 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Trigger update, clock set for the experiment to start.
+
+  now = futureDate(startDate, 10 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, true, "Experiment 1 should be active.");
+
+  // Uninstall the addon through the addon manager instead of stopping it through
+  // the experiments API.
+
+  yield AddonManagerTesting.uninstallAddonByID(EXPERIMENT1_ID);
+  yield experiments._mainTask;
+
+  yield experiments.notify();
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.equal(list[0].active, false, "Experiment 1 should not be active anymore.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield testCleanup(experiments);
+});
+
+// If the Addon Manager knows of an experiment that we don't, it should get
+// uninstalled.
+add_task(function* testUnknownExperimentsUninstalled() {
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Precondition: No experiment add-ons are present.");
+
+  // Simulate us not listening.
+  experiments._unregisterWithAddonManager();
+  yield AddonManagerTesting.installXPIFromURL(gDataRoot + EXPERIMENT1_XPI_NAME, EXPERIMENT1_XPI_SHA1);
+  experiments._registerWithAddonManager();
+
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "Experiment 1 installed via AddonManager");
+
+  // Simulate no known experiments.
+  gManifestObject = {
+    "version": 1,
+    experiments: [],
+  };
+
+  yield experiments.updateManifest();
+  let fromManifest = yield experiments.getExperiments();
+  Assert.equal(fromManifest.length, 0, "No experiments known in manifest.");
+
+  // And the unknown add-on should be gone.
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Experiment 1 was uninstalled.");
+
+  yield testCleanup(experiments);
+});
+
+// If someone else installs an experiment add-on, we detect and stop that.
+add_task(function* testForeignExperimentInstall() {
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [],
+  };
+
+  yield experiments.init();
+
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Precondition: No experiment add-ons present.");
+
+  let failed = false;
+  try {
+    yield AddonManagerTesting.installXPIFromURL(gDataRoot + EXPERIMENT1_XPI_NAME, EXPERIMENT1_XPI_SHA1);
+  } catch (ex) {
+    failed = true;
+  }
+  Assert.ok(failed, "Add-on install should not have completed successfully");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Add-on install should have been cancelled.");
+
+  yield testCleanup(experiments);
+});
+
+// Experiment add-ons will be disabled after Addon Manager restarts. Ensure
+// we enable them automatically.
+add_task(function* testEnabledAfterRestart() {
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id: EXPERIMENT1_ID,
+        xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash: EXPERIMENT1_XPI_SHA1,
+        startTime: gPolicy.now().getTime() / 1000 - 60,
+        endTime: gPolicy.now().getTime() / 1000 + 60,
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName: ["XPCShell"],
+        channel: ["nightly"],
+      },
+    ],
+  };
+
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Precondition: No experiment add-ons installed.");
+
+  yield experiments.updateManifest();
+  let fromManifest = yield experiments.getExperiments();
+  Assert.equal(fromManifest.length, 1, "A single experiment is known.");
+
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "A single experiment add-on is installed.");
+  Assert.ok(addons[0].isActive, "That experiment is active.");
+
+  dump("Restarting Addon Manager\n");
+  yield promiseRestartManager();
+  experiments = new Experiments.Experiments(gPolicy);
+
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "The experiment is still there after restart.");
+  Assert.ok(addons[0].userDisabled, "But it is disabled.");
+  Assert.equal(addons[0].isActive, false, "And not active.");
+
+  yield experiments.updateManifest();
+  Assert.ok(addons[0].isActive, "It activates when the manifest is evaluated.");
+
+  yield testCleanup(experiments);
+});
+
+// If experiment add-ons were ever started, maxStartTime shouldn't be evaluated
+// anymore. Ensure that if maxStartTime is passed but experiment has started
+// already, maxStartTime does not cause deactivation.
+
+add_task(function* testMaxStartTimeEvaluation() {
+
+  // Dates the following tests are based on.
+
+  let startDate    = new Date(2014, 5, 1, 12);
+  let now          = futureDate(startDate, 10   * MS_IN_ONE_DAY);
+  let maxStartDate = futureDate(startDate, 100  * MS_IN_ONE_DAY);
+  let endDate      = futureDate(startDate, 1000 * MS_IN_ONE_DAY);
+
+  defineNow(gPolicy, now);
+
+  // The manifest data we test with.
+  // We set a value for maxStartTime.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate),
+        endTime:          dateToSeconds(endDate),
+        maxActiveSeconds: 1000 * SEC_IN_ONE_DAY,
+        maxStartTime:     dateToSeconds(maxStartDate),
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Precondition: No experiment add-ons installed.");
+
+  yield experiments.updateManifest();
+  let fromManifest = yield experiments.getExperiments();
+  Assert.equal(fromManifest.length, 1, "A single experiment is known.");
+
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "A single experiment add-on is installed.");
+  Assert.ok(addons[0].isActive, "That experiment is active.");
+
+  dump("Setting current time to maxStartTime + 100 days and reloading manifest\n");
+  now = futureDate(maxStartDate, 100 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  yield experiments.updateManifest();
+
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "The experiment is still there.");
+  Assert.ok(addons[0].isActive, "It is still active.");
+
+  yield testCleanup(experiments);
+});
+
+// Test coverage for an add-on uninstall disabling the experiment and that it stays
+// disabled over restarts.
+add_task(function* test_foreignUninstallAndRestart() {
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id: EXPERIMENT1_ID,
+        xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash: EXPERIMENT1_XPI_SHA1,
+        startTime: gPolicy.now().getTime() / 1000 - 60,
+        endTime: gPolicy.now().getTime() / 1000 + 60,
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName: ["XPCShell"],
+        channel: ["nightly"],
+      },
+    ],
+  };
+
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Precondition: No experiment add-ons installed.");
+
+  yield experiments.updateManifest();
+  let experimentList = yield experiments.getExperiments();
+  Assert.equal(experimentList.length, 1, "A single experiment is known.");
+
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "A single experiment add-on is installed.");
+  Assert.ok(addons[0].isActive, "That experiment is active.");
+
+  yield AddonManagerTesting.uninstallAddonByID(EXPERIMENT1_ID);
+  yield experiments._mainTask;
+
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Experiment add-on should have been removed.");
+
+  experimentList = yield experiments.getExperiments();
+  Assert.equal(experimentList.length, 1, "A single experiment is known.");
+  Assert.equal(experimentList[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.ok(!experimentList[0].active, "Experiment 1 should not be active anymore.");
+
+  // Fake restart behaviour.
+  yield promiseRestartManager();
+  experiments = new Experiments.Experiments(gPolicy);
+  yield experiments.updateManifest();
+
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "No experiment add-ons installed.");
+
+  experimentList = yield experiments.getExperiments();
+  Assert.equal(experimentList.length, 1, "A single experiment is known.");
+  Assert.equal(experimentList[0].id, EXPERIMENT1_ID, "Experiment 1 should be the sole entry.");
+  Assert.ok(!experimentList[0].active, "Experiment 1 should not be active.");
+
+  yield testCleanup(experiments);
+});
diff --git a/browser/experiments/test/xpcshell/test_cache.js b/browser/experiments/test/xpcshell/test_cache.js
new file mode 100644
index 000000000..4f2bce881
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_cache.js
@@ -0,0 +1,399 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://testing-common/httpd.js");
+XPCOMUtils.defineLazyModuleGetter(this, "Experiments",
+  "resource:///modules/experiments/Experiments.jsm");
+
+const MANIFEST_HANDLER         = "manifests/handler";
+
+const SEC_IN_ONE_DAY  = 24 * 60 * 60;
+const MS_IN_ONE_DAY   = SEC_IN_ONE_DAY * 1000;
+
+var gHttpServer          = null;
+var gHttpRoot            = null;
+var gDataRoot            = null;
+var gPolicy              = null;
+var gManifestObject      = null;
+var gManifestHandlerURI  = null;
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_setup() {
+  loadAddonManager();
+  yield removeCacheFile();
+
+  gHttpServer = new HttpServer();
+  gHttpServer.start(-1);
+  let port = gHttpServer.identity.primaryPort;
+  gHttpRoot = "http://localhost:" + port + "/";
+  gDataRoot = gHttpRoot + "data/";
+  gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
+  gHttpServer.registerDirectory("/data/", do_get_cwd());
+  gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
+    response.setStatusLine(null, 200, "OK");
+    response.write(JSON.stringify(gManifestObject));
+    response.processAsync();
+    response.finish();
+  });
+  do_register_cleanup(() => gHttpServer.stop(() => {}));
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
+  Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
+
+  gPolicy = new Experiments.Policy();
+  patchPolicy(gPolicy, {
+    updatechannel: () => "nightly",
+    oneshotTimer: (callback, timeout, thisObj, name) => {},
+  });
+});
+
+function checkExperimentListsEqual(list, list2) {
+  Assert.equal(list.length, list2.length, "Lists should have the same length.")
+
+  for (let i=0; i<list.length; ++i) {
+    for (let k of Object.keys(list[i])) {
+      Assert.equal(list[i][k], list2[i][k],
+                   "Field '" + k + "' should match for list entry " + i + ".");
+    }
+  }
+}
+
+function checkExperimentSerializations(experimentEntryIterator) {
+  for (let experiment of experimentEntryIterator) {
+    let experiment2 = new Experiments.ExperimentEntry(gPolicy);
+    let jsonStr = JSON.stringify(experiment.toJSON());
+    Assert.ok(experiment2.initFromCacheData(JSON.parse(jsonStr)),
+              "Should have initialized successfully from JSON serialization.");
+    Assert.equal(JSON.stringify(experiment), JSON.stringify(experiment2),
+                 "Object stringifications should match.");
+  }
+}
+
+function validateCache(cachedExperiments, experimentIds) {
+  let cachedExperimentIds = new Set(cachedExperiments);
+  Assert.equal(cachedExperimentIds.size, experimentIds.length,
+               "The number of cached experiments does not match with the provided list");
+  for (let id of experimentIds) {
+    Assert.ok(cachedExperimentIds.has(id), "The cache must contain the experiment with id " + id);
+  }
+}
+
+// Set up an experiments instance and check if it is properly restored from cache.
+
+add_task(function* test_cache() {
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      {
+        id:               EXPERIMENT2_ID,
+        xpiURL:           gDataRoot + EXPERIMENT2_XPI_NAME,
+        xpiHash:          EXPERIMENT2_XPI_SHA1,
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      {
+        id:               EXPERIMENT3_ID,
+        xpiURL:           "https://inval.id/foo.xpi",
+        xpiHash:          "sha1:0000000000000000000000000000000000000000",
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  // Setup dates for the experiments.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDates = [];
+  let endDates   = [];
+
+  for (let i=0; i<gManifestObject.experiments.length; ++i) {
+    let experiment = gManifestObject.experiments[i];
+    startDates.push(futureDate(baseDate, (50 + (150 * i)) * MS_IN_ONE_DAY));
+    endDates  .push(futureDate(startDates[i], 50 * MS_IN_ONE_DAY));
+    experiment.startTime = dateToSeconds(startDates[i]);
+    experiment.endTime   = dateToSeconds(endDates[i]);
+  }
+
+  // Data to compare the result of Experiments.getExperiments() against.
+
+  let experimentListData = [
+    {
+      id: EXPERIMENT2_ID,
+      name: "Test experiment 2",
+      description: "And yet another experiment that experiments experimentally.",
+    },
+    {
+      id: EXPERIMENT1_ID,
+      name: EXPERIMENT1_NAME,
+      description: "Yet another experiment that experiments experimentally.",
+    },
+  ];
+
+  // Trigger update & re-init, clock set to before any activation.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+
+  let experiments = new Experiments.Experiments(gPolicy);
+  yield experiments.updateManifest();
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+  checkExperimentSerializations(experiments._experiments.values());
+
+  yield promiseRestartManager();
+  experiments = new Experiments.Experiments(gPolicy);
+
+  yield experiments._run();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+  checkExperimentSerializations(experiments._experiments.values());
+
+  // Re-init, clock set for experiment 1 to start.
+
+  now = futureDate(startDates[0], 5 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+
+  yield promiseRestartManager();
+  experiments = new Experiments.Experiments(gPolicy);
+  yield experiments._run();
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+
+  experimentListData[1].active = true;
+  experimentListData[1].endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
+  checkExperimentListsEqual(experimentListData.slice(1), list);
+  checkExperimentSerializations(experiments._experiments.values());
+
+  let branch = yield experiments.getExperimentBranch(EXPERIMENT1_ID);
+  Assert.strictEqual(branch, null);
+
+  yield experiments.setExperimentBranch(EXPERIMENT1_ID, "testbranch");
+  branch = yield experiments.getExperimentBranch(EXPERIMENT1_ID);
+  Assert.strictEqual(branch, "testbranch");
+
+  // Re-init, clock set for experiment 1 to stop.
+
+  now = futureDate(now, 20 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+
+  yield promiseRestartManager();
+  experiments = new Experiments.Experiments(gPolicy);
+  yield experiments._run();
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+
+  experimentListData[1].active = false;
+  experimentListData[1].endDate = now.getTime();
+  checkExperimentListsEqual(experimentListData.slice(1), list);
+  checkExperimentSerializations(experiments._experiments.values());
+
+  branch = yield experiments.getExperimentBranch(EXPERIMENT1_ID);
+  Assert.strictEqual(branch, "testbranch");
+
+  // Re-init, clock set for experiment 2 to start.
+
+  now = futureDate(startDates[1], 20 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+
+  yield promiseRestartManager();
+  experiments = new Experiments.Experiments(gPolicy);
+  yield experiments._run();
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 2, "Experiment list should have 2 entries.");
+
+  experimentListData[0].active = true;
+  experimentListData[0].endDate = now.getTime() + 10 * MS_IN_ONE_DAY;
+  checkExperimentListsEqual(experimentListData, list);
+  checkExperimentSerializations(experiments._experiments.values());
+
+  // Re-init, clock set for experiment 2 to stop.
+
+  now = futureDate(now, 20 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+
+  yield promiseRestartManager();
+  experiments = new Experiments.Experiments(gPolicy);
+  yield experiments._run();
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 2, "Experiment list should have 2 entries.");
+
+  experimentListData[0].active = false;
+  experimentListData[0].endDate = now.getTime();
+  checkExperimentListsEqual(experimentListData, list);
+  checkExperimentSerializations(experiments._experiments.values());
+
+  // Cleanup.
+
+  yield experiments._toggleExperimentsEnabled(false);
+  yield promiseRestartManager();
+  yield removeCacheFile();
+});
+
+add_task(function* test_expiration() {
+  // The manifest data we test with.
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      {
+        id:               EXPERIMENT2_ID,
+        xpiURL:           gDataRoot + EXPERIMENT2_XPI_NAME,
+        xpiHash:          EXPERIMENT2_XPI_SHA1,
+        maxActiveSeconds: 50 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      // The 3rd experiment will never run, so it's ok to use experiment's 2 data.
+      {
+        id:               EXPERIMENT3_ID,
+        xpiURL:           gDataRoot + EXPERIMENT2_XPI_NAME,
+        xpiHash:          EXPERIMENT2_XPI_SHA1,
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      }
+    ],
+  };
+
+  // Data to compare the result of Experiments.getExperiments() against.
+  let experimentListData = [
+    {
+      id: EXPERIMENT2_ID,
+      name: "Test experiment 2",
+      description: "And yet another experiment that experiments experimentally.",
+    },
+    {
+      id: EXPERIMENT1_ID,
+      name: EXPERIMENT1_NAME,
+      description: "Yet another experiment that experiments experimentally.",
+    },
+  ];
+
+  // Setup dates for the experiments.
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDates = [];
+  let endDates   = [];
+
+  for (let i=0; i<gManifestObject.experiments.length; ++i) {
+    let experiment = gManifestObject.experiments[i];
+    // Spread out experiments in time so that one experiment can end and expire while
+    // the next is still running.
+    startDates.push(futureDate(baseDate, (50 + (200 * i)) * MS_IN_ONE_DAY));
+    endDates  .push(futureDate(startDates[i], 50 * MS_IN_ONE_DAY));
+    experiment.startTime = dateToSeconds(startDates[i]);
+    experiment.endTime   = dateToSeconds(endDates[i]);
+  }
+
+  let now = null;
+  let experiments = null;
+
+  let setDateAndRestartExperiments = new Task.async(function* (newDate) {
+    now = newDate;
+    defineNow(gPolicy, now);
+
+    yield promiseRestartManager();
+    experiments = new Experiments.Experiments(gPolicy);
+    yield experiments._run();
+  });
+
+  // Trigger update & re-init, clock set to before any activation.
+  now = baseDate;
+  defineNow(gPolicy, now);
+
+  experiments = new Experiments.Experiments(gPolicy);
+  yield experiments.updateManifest();
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  // Re-init, clock set for experiment 1 to start...
+  yield setDateAndRestartExperiments(startDates[0]);
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "The first experiment should have started.");
+
+  // ... init again, and set the clock so that the first experiment ends.
+  yield setDateAndRestartExperiments(endDates[0]);
+
+  // The experiment just ended, it should still be in the cache, but marked
+  // as finished.
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+
+  experimentListData[1].active = false;
+  experimentListData[1].endDate = now.getTime();
+  checkExperimentListsEqual(experimentListData.slice(1), list);
+  validateCache([...experiments._experiments.keys()], [EXPERIMENT1_ID, EXPERIMENT2_ID, EXPERIMENT3_ID]);
+
+  // Start the second experiment.
+  yield setDateAndRestartExperiments(startDates[1]);
+
+  // The experiments cache should contain the finished experiment and the
+  // one that's still running.
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 2, "Experiment list should have 2 entries.");
+
+  experimentListData[0].active = true;
+  experimentListData[0].endDate = now.getTime() + 50 * MS_IN_ONE_DAY;
+  checkExperimentListsEqual(experimentListData, list);
+
+  // Move the clock in the future, just 31 days after the start date of the second experiment,
+  // so that the cache for the first experiment expires and the second experiment is still running.
+  yield setDateAndRestartExperiments(futureDate(startDates[1], 31 * MS_IN_ONE_DAY));
+  validateCache([...experiments._experiments.keys()], [EXPERIMENT2_ID, EXPERIMENT3_ID]);
+
+  // Make sure that the expired experiment is not reported anymore.
+  let history = yield experiments.getExperiments();
+  Assert.equal(history.length, 1, "Experiments older than 180 days must be removed from the cache.");
+
+  // Test that we don't write expired experiments in the cache.
+  yield setDateAndRestartExperiments(now);
+  validateCache([...experiments._experiments.keys()], [EXPERIMENT2_ID, EXPERIMENT3_ID]);
+
+  // The first experiment should be expired and not in the cache, it ended more than
+  // 180 days ago. We should see the one still running in the cache.
+  history = yield experiments.getExperiments();
+  Assert.equal(history.length, 1, "Expired experiments must not be saved to cache.");
+  checkExperimentListsEqual(experimentListData.slice(0, 1), history);
+
+  // Test that experiments that are cached locally but never ran are removed from cache
+  // when they are removed from the manifest (this is cached data, not really history).
+  gManifestObject["experiments"] = gManifestObject["experiments"].slice(1, 1);
+  yield experiments.updateManifest();
+  validateCache([...experiments._experiments.keys()], [EXPERIMENT2_ID]);
+
+  // Cleanup.
+  yield experiments._toggleExperimentsEnabled(false);
+  yield promiseRestartManager();
+  yield removeCacheFile();
+});
diff --git a/browser/experiments/test/xpcshell/test_cacherace.js b/browser/experiments/test/xpcshell/test_cacherace.js
new file mode 100644
index 000000000..ff77cfdc4
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_cacherace.js
@@ -0,0 +1,102 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://testing-common/httpd.js");
+Cu.import("resource://gre/modules/Timer.jsm");
+
+const MANIFEST_HANDLER         = "manifests/handler";
+
+const SEC_IN_ONE_DAY  = 24 * 60 * 60;
+const MS_IN_ONE_DAY   = SEC_IN_ONE_DAY * 1000;
+
+var gHttpServer          = null;
+var gHttpRoot            = null;
+var gDataRoot            = null;
+var gPolicy              = null;
+var gManifestObject      = null;
+var gManifestHandlerURI  = null;
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_setup() {
+  loadAddonManager();
+  yield removeCacheFile();
+
+  gHttpServer = new HttpServer();
+  gHttpServer.start(-1);
+  let port = gHttpServer.identity.primaryPort;
+  gHttpRoot = "http://localhost:" + port + "/";
+  gDataRoot = gHttpRoot + "data/";
+  gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
+  gHttpServer.registerDirectory("/data/", do_get_cwd());
+  gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
+    response.setStatusLine(null, 200, "OK");
+    response.write(JSON.stringify(gManifestObject));
+    response.processAsync();
+    response.finish();
+  });
+  do_register_cleanup(() => gHttpServer.stop(() => {}));
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
+  Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
+
+  let ExperimentsScope = Cu.import("resource:///modules/experiments/Experiments.jsm");
+  let Experiments = ExperimentsScope.Experiments;
+
+  gPolicy = new Experiments.Policy();
+  patchPolicy(gPolicy, {
+    updatechannel: () => "nightly",
+    delayCacheWrite: (promise) => {
+      return new Promise((resolve, reject) => {
+        promise.then(
+          (result) => { setTimeout(() => resolve(result), 500); },
+          (err) => { reject(err); }
+        );
+      });
+    },
+  });
+
+  let now = new Date(2014, 5, 1, 12);
+  defineNow(gPolicy, now);
+
+  let experimentName = "experiment-racybranch.xpi";
+  let experimentPath = getExperimentPath(experimentName);
+  let experimentHash = "sha1:" + sha1File(experimentPath);
+
+  gManifestObject = {
+    version: 1,
+    experiments: [
+      {
+        id: "test-experiment-racybranch@tests.mozilla.org",
+        xpiURL: gDataRoot + "experiment-racybranch.xpi",
+        xpiHash: experimentHash,
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName: ["XPCShell"],
+        channel: ["nightly"],
+        startTime: dateToSeconds(futureDate(now, -MS_IN_ONE_DAY)),
+        endTime: dateToSeconds(futureDate(now, MS_IN_ONE_DAY)),
+      },
+    ],
+  };
+
+  do_print("gManifestObject: " + JSON.stringify(gManifestObject));
+
+  // In order for the addon manager to work properly, we hack
+  // Experiments.instance which is used by the XPIProvider
+  let experiments = new Experiments.Experiments(gPolicy);
+  Assert.strictEqual(ExperimentsScope.gExperiments, null);
+  ExperimentsScope.gExperiments = experiments;
+
+  yield experiments.updateManifest();
+  let active = experiments._getActiveExperiment();
+  Assert.ok(active);
+  Assert.equal(active.branch, "racy-set");
+  Assert.ok(!experiments._dirty);
+});
diff --git a/browser/experiments/test/xpcshell/test_conditions.js b/browser/experiments/test/xpcshell/test_conditions.js
new file mode 100644
index 000000000..23c147fdb
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_conditions.js
@@ -0,0 +1,325 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+
+Cu.import("resource:///modules/experiments/Experiments.jsm");
+Cu.import("resource://gre/modules/TelemetryController.jsm", this);
+
+const SEC_IN_ONE_DAY = 24 * 60 * 60;
+
+var gPolicy     = null;
+
+function ManifestEntry(data) {
+  this.id = EXPERIMENT1_ID;
+  this.xpiURL = "http://localhost:1/dummy.xpi";
+  this.xpiHash = EXPERIMENT1_XPI_SHA1;
+  this.startTime = new Date(2010, 0, 1, 12).getTime() / 1000;
+  this.endTime = new Date(9001, 0, 1, 12).getTime() / 1000;
+  this.maxActiveSeconds = SEC_IN_ONE_DAY;
+  this.appName = ["XPCShell"];
+  this.channel = ["nightly"];
+
+  data = data || {};
+  for (let k of Object.keys(data)) {
+    this[k] = data[k];
+  }
+
+  if (!this.endTime) {
+    this.endTime = this.startTime + 5 * SEC_IN_ONE_DAY;
+  }
+}
+
+function applicableFromManifestData(data, policy) {
+  let manifestData = new ManifestEntry(data);
+  let entry = new Experiments.ExperimentEntry(policy);
+  entry.initFromManifestData(manifestData);
+  return entry.isApplicable();
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_setup() {
+  createAppInfo();
+  do_get_profile();
+  startAddonManagerOnly();
+  yield TelemetryController.testSetup();
+  gPolicy = new Experiments.Policy();
+
+  patchPolicy(gPolicy, {
+    updatechannel: () => "nightly",
+    locale: () => "en-US",
+    random: () => 0.5,
+  });
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+});
+
+function arraysEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+
+  for (let i=0; i<a.length; ++i) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// This function exists solely to be .toSource()d
+const sanityFilter = function filter(c) {
+  if (c.telemetryEnvironment === undefined) {
+    throw Error("No .telemetryEnvironment");
+  }
+  if (c.telemetryEnvironment.build == undefined) {
+    throw Error("No .telemetryEnvironment.build");
+  }
+  return true;
+}
+
+// Utility function to generate build ID for previous/next date.
+function addDate(buildId, diff) {
+  let m = /^([0-9]{4})([0-9]{2})([0-9]{2})(.*)$/.exec(buildId);
+  if (!m) {
+    throw Error("Unsupported build ID: " + buildId);
+  }
+  let year = Number.parseInt(m[1], 10);
+  let month = Number.parseInt(m[2], 10);
+  let date = Number.parseInt(m[3], 10);
+  let remainingParts = m[4];
+
+  let d = new Date();
+  d.setUTCFullYear(year, month - 1, date);
+  d.setTime(d.getTime() + diff * 24 * 60 * 60 * 1000);
+
+  let yearStr = String(d.getUTCFullYear());
+  let monthStr = ("0" + String(d.getUTCMonth() + 1)).slice(-2);
+  let dateStr = ("0" + String(d.getUTCDate())).slice(-2);
+  return yearStr + monthStr + dateStr + remainingParts;
+}
+function prevDate(buildId) {
+  return addDate(buildId, -1);
+}
+function nextDate(buildId) {
+  return addDate(buildId, 1);
+}
+
+add_task(function* test_simpleFields() {
+  let testData = [
+    // "expected applicable?", failure reason or null, manifest data
+
+    // misc. environment
+
+    [false, ["appName"], {appName: []}],
+    [false, ["appName"], {appName: ["foo", gAppInfo.name + "-invalid"]}],
+    [true,  null,        {appName: ["not-an-app-name", gAppInfo.name]}],
+
+    [false, ["os"], {os: []}],
+    [false, ["os"], {os: ["42", "abcdef"]}],
+    [true,  null,   {os: [gAppInfo.OS, "plan9"]}],
+
+    [false, ["channel"], {channel: []}],
+    [false, ["channel"], {channel: ["foo", gPolicy.updatechannel() + "-invalid"]}],
+    [true,  null,        {channel: ["not-a-channel", gPolicy.updatechannel()]}],
+
+    [false, ["locale"], {locale: []}],
+    [false, ["locale"], {locale: ["foo", gPolicy.locale + "-invalid"]}],
+    [true,  null,       {locale: ["not-a-locale", gPolicy.locale()]}],
+
+    // version
+
+    [false, ["version"], {version: []}],
+    [false, ["version"], {version: ["-1", gAppInfo.version + "-invalid", "asdf", "0,4", "99.99", "0.1.1.1"]}],
+    [true,  null,        {version: ["99999999.999", "-1", gAppInfo.version]}],
+
+    [false, ["minVersion"], {minVersion: "1.0.1"}],
+    [true,  null,           {minVersion: "1.0b1"}],
+    [true,  null,           {minVersion: "1.0"}],
+    [true,  null,           {minVersion: "0.9"}],
+
+    [false, ["maxVersion"], {maxVersion: "0.1"}],
+    [false, ["maxVersion"], {maxVersion: "0.9.9"}],
+    [false, ["maxVersion"], {maxVersion: "1.0b1"}],
+    [true,  ["maxVersion"], {maxVersion: "1.0"}],
+    [true,  ["maxVersion"], {maxVersion: "1.7pre"}],
+
+    // build id
+
+    [false, ["buildIDs"], {buildIDs: []}],
+    [false, ["buildIDs"], {buildIDs: ["not-a-build-id", gAppInfo.platformBuildID + "-invalid"]}],
+    [true,  null,         {buildIDs: ["not-a-build-id", gAppInfo.platformBuildID]}],
+
+    [true,  null,           {minBuildID: prevDate(gAppInfo.platformBuildID)}],
+    [true,  null,           {minBuildID: gAppInfo.platformBuildID}],
+    [false, ["minBuildID"], {minBuildID: nextDate(gAppInfo.platformBuildID)}],
+
+    [false, ["maxBuildID"], {maxBuildID: prevDate(gAppInfo.platformBuildID)}],
+    [true,  null,           {maxBuildID: gAppInfo.platformBuildID}],
+    [true,  null,           {maxBuildID: nextDate(gAppInfo.platformBuildID)}],
+
+    // sample
+
+    [false, ["sample"], {sample: -1 }],
+    [false, ["sample"], {sample: 0.0}],
+    [false, ["sample"], {sample: 0.1}],
+    [true,  null,       {sample: 0.5}],
+    [true,  null,       {sample: 0.6}],
+    [true,  null,       {sample: 1.0}],
+    [true,  null,       {sample: 0.5}],
+
+    // experiment control
+
+    [false, ["disabled"], {disabled: true}],
+    [true,  null,         {disabled: false}],
+
+    [false, ["frozen"], {frozen: true}],
+    [true,  null,       {frozen: false}],
+
+    [false, null, {frozen: true,  disabled: true}],
+    [false, null, {frozen: true,  disabled: false}],
+    [false, null, {frozen: false, disabled: true}],
+    [true,  null, {frozen: false, disabled: false}],
+
+    // jsfilter
+
+    [true,  null, {jsfilter: "function filter(c) { return true; }"}],
+    [false, ["jsfilter-false"], {jsfilter: "function filter(c) { return false; }"}],
+    [true,  null, {jsfilter: "function filter(c) { return 123; }"}], // truthy
+    [false, ["jsfilter-false"], {jsfilter: "function filter(c) { return ''; }"}], // falsy
+    [false, ["jsfilter-false"], {jsfilter: "function filter(c) { var a = []; }"}], // undefined
+    [false, ["jsfilter-threw", "some error"], {jsfilter: "function filter(c) { throw new Error('some error'); }"}],
+    [false, ["jsfilter-evalfailed"], {jsfilter: "123, this won't work"}],
+    [true,  null, {jsfilter: "var filter = " + sanityFilter.toSource()}],
+  ];
+
+  for (let i=0; i<testData.length; ++i) {
+    let entry = testData[i];
+    let applicable;
+    let reason = null;
+
+    yield applicableFromManifestData(entry[2], gPolicy).then(
+      value => applicable = value,
+      value => {
+        applicable = false;
+        reason = value;
+      }
+    );
+
+    Assert.equal(applicable, entry[0],
+      "Experiment entry applicability should match for test "
+      + i + ": " + JSON.stringify(entry[2]));
+
+    let expectedReason = entry[1];
+    if (!applicable && expectedReason) {
+      Assert.ok(arraysEqual(reason, expectedReason),
+        "Experiment rejection reasons should match for test " + i + ". "
+        + "Got " + JSON.stringify(reason) + ", expected "
+        + JSON.stringify(expectedReason));
+    }
+  }
+});
+
+add_task(function* test_times() {
+  let now = new Date(2014, 5, 6, 12);
+  let nowSec = now.getTime() / 1000;
+  let testData = [
+    // "expected applicable?", rejection reason or null, fake now date, manifest data
+
+    // start time
+
+    [true,  null, now,
+      {startTime: nowSec -  5 * SEC_IN_ONE_DAY,
+         endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [true,  null, now,
+      {startTime: nowSec,
+         endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [false,  "startTime", now,
+      {startTime: nowSec +  5 * SEC_IN_ONE_DAY,
+         endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+
+    // end time
+
+    [false,  "endTime", now,
+      {startTime: nowSec -  5 * SEC_IN_ONE_DAY,
+         endTime: nowSec - 10 * SEC_IN_ONE_DAY}],
+    [false,  "endTime", now,
+      {startTime: nowSec -  5 * SEC_IN_ONE_DAY,
+         endTime: nowSec -  5 * SEC_IN_ONE_DAY}],
+
+    // max start time
+
+    [false,  "maxStartTime", now,
+      {maxStartTime: nowSec - 15 * SEC_IN_ONE_DAY,
+          startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+            endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [false,  "maxStartTime", now,
+      {maxStartTime: nowSec -  1 * SEC_IN_ONE_DAY,
+          startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+            endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [false,  "maxStartTime", now,
+      {maxStartTime: nowSec - 10 * SEC_IN_ONE_DAY,
+          startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+            endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [true,  null, now,
+      {maxStartTime: nowSec,
+          startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+            endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [true,  null, now,
+      {maxStartTime: nowSec +  1 * SEC_IN_ONE_DAY,
+          startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+            endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+
+    // max active seconds
+
+    [true,  null, now,
+      {maxActiveSeconds:           5 * SEC_IN_ONE_DAY,
+              startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+                endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [true,  null, now,
+      {maxActiveSeconds:          10 * SEC_IN_ONE_DAY,
+              startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+                endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [true,  null, now,
+      {maxActiveSeconds:          15 * SEC_IN_ONE_DAY,
+              startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+                endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+    [true,  null, now,
+      {maxActiveSeconds:          20 * SEC_IN_ONE_DAY,
+              startTime: nowSec - 10 * SEC_IN_ONE_DAY,
+                endTime: nowSec + 10 * SEC_IN_ONE_DAY}],
+  ];
+
+  for (let i=0; i<testData.length; ++i) {
+    let entry = testData[i];
+    let applicable;
+    let reason = null;
+    defineNow(gPolicy, entry[2]);
+
+    yield applicableFromManifestData(entry[3], gPolicy).then(
+      value => applicable = value,
+      value => {
+        applicable = false;
+        reason = value;
+      }
+    );
+
+    Assert.equal(applicable, entry[0],
+      "Experiment entry applicability should match for test "
+      + i + ": " + JSON.stringify([entry[2], entry[3]]));
+    if (!applicable && entry[1]) {
+      Assert.equal(reason, entry[1], "Experiment rejection reason should match for test " + i);
+    }
+  }
+});
+
+add_task(function* test_shutdown() {
+  yield TelemetryController.testShutdown();
+});
diff --git a/browser/experiments/test/xpcshell/test_disableExperiments.js b/browser/experiments/test/xpcshell/test_disableExperiments.js
new file mode 100644
index 000000000..8441b922d
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_disableExperiments.js
@@ -0,0 +1,180 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://testing-common/httpd.js");
+Cu.import("resource://testing-common/AddonManagerTesting.jsm");
+
+XPCOMUtils.defineLazyModuleGetter(this, "Experiments",
+  "resource:///modules/experiments/Experiments.jsm");
+
+const MANIFEST_HANDLER         = "manifests/handler";
+
+const SEC_IN_ONE_DAY  = 24 * 60 * 60;
+const MS_IN_ONE_DAY   = SEC_IN_ONE_DAY * 1000;
+
+var gHttpServer          = null;
+var gHttpRoot            = null;
+var gDataRoot            = null;
+var gPolicy              = null;
+var gManifestObject      = null;
+var gManifestHandlerURI  = null;
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_setup() {
+  loadAddonManager();
+
+  gHttpServer = new HttpServer();
+  gHttpServer.start(-1);
+  let port = gHttpServer.identity.primaryPort;
+  gHttpRoot = "http://localhost:" + port + "/";
+  gDataRoot = gHttpRoot + "data/";
+  gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
+  gHttpServer.registerDirectory("/data/", do_get_cwd());
+  gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
+    response.setStatusLine(null, 200, "OK");
+    response.write(JSON.stringify(gManifestObject));
+    response.processAsync();
+    response.finish();
+  });
+  do_register_cleanup(() => gHttpServer.stop(() => {}));
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
+  Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
+
+  gPolicy = new Experiments.Policy();
+  patchPolicy(gPolicy, {
+    updatechannel: () => "nightly",
+    oneshotTimer: (callback, timeout, thisObj, name) => {},
+  });
+});
+
+// Test disabling the feature stops current and future experiments.
+
+add_task(function* test_disableExperiments() {
+  const OBSERVER_TOPIC = "experiments-changed";
+  let observerFireCount = 0;
+  let expectedObserverFireCount = 0;
+  let observer = () => ++observerFireCount;
+  Services.obs.addObserver(observer, OBSERVER_TOPIC, false);
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate1 = futureDate(baseDate,  50 * MS_IN_ONE_DAY);
+  let endDate1   = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
+  let startDate2 = futureDate(baseDate, 150 * MS_IN_ONE_DAY);
+  let endDate2   = futureDate(baseDate, 200 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT2_ID,
+        xpiURL:           gDataRoot + EXPERIMENT2_XPI_NAME,
+        xpiHash:          EXPERIMENT2_XPI_SHA1,
+        startTime:        dateToSeconds(startDate2),
+        endTime:          dateToSeconds(endDate2),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate1),
+        endTime:          dateToSeconds(endDate1),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+  // Use updateManifest() to provide for coverage of that path.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+  let addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "Precondition: No experiment add-ons are installed.");
+
+  // Trigger update, clock set for experiment 1 to start.
+
+  now = futureDate(startDate1, 5 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+
+  yield experiments.updateManifest();
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+  Assert.equal(list[0].active, true, "Experiment should be active.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 1, "An experiment add-on was installed.");
+
+  // Disable the experiments feature. Check that we stop the running experiment.
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, false);
+  yield experiments._mainTask;
+
+  Assert.equal(observerFireCount, ++expectedObserverFireCount,
+               "Experiments observer should have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+  Assert.equal(list[0].active, false, "Experiment entry should not be active.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "The experiment add-on should be uninstalled.");
+
+  // Trigger update, clock set for experiment 2 to start. Verify we don't start it.
+
+  now = startDate2;
+  defineNow(gPolicy, now);
+
+  try {
+    yield experiments.updateManifest();
+  } catch (e) {
+    // This exception is expected, we rethrow everything else
+    if (e.message != "experiments are disabled") {
+      throw e;
+    }
+  }
+
+  experiments.notify();
+  yield experiments._mainTask;
+
+  Assert.equal(observerFireCount, expectedObserverFireCount,
+               "Experiments observer should not have been called.");
+
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should still have 1 entry.");
+  Assert.equal(list[0].active, false, "Experiment entry should not be active.");
+  addons = yield getExperimentAddons();
+  Assert.equal(addons.length, 0, "There should still be no experiment add-on installed.");
+
+  // Cleanup.
+
+  Services.obs.removeObserver(observer, OBSERVER_TOPIC);
+  yield promiseRestartManager();
+  yield removeCacheFile();
+});
diff --git a/browser/experiments/test/xpcshell/test_fetch.js b/browser/experiments/test/xpcshell/test_fetch.js
new file mode 100644
index 000000000..e8d76fa35
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_fetch.js
@@ -0,0 +1,68 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://testing-common/httpd.js");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource:///modules/experiments/Experiments.jsm");
+
+var gHttpServer = null;
+var gHttpRoot   = null;
+var gPolicy     = new Experiments.Policy();
+
+function run_test() {
+  loadAddonManager();
+
+  gHttpServer = new HttpServer();
+  gHttpServer.start(-1);
+  let port = gHttpServer.identity.primaryPort;
+  gHttpRoot = "http://localhost:" + port + "/";
+  gHttpServer.registerDirectory("/", do_get_cwd());
+  do_register_cleanup(() => gHttpServer.stop(() => {}));
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+
+  patchPolicy(gPolicy, {
+    updatechannel: () => "nightly",
+  });
+
+  run_next_test();
+}
+
+add_task(function* test_fetchAndCache() {
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, gHttpRoot + "experiments_1.manifest");
+  let ex = new Experiments.Experiments(gPolicy);
+
+  Assert.equal(ex._experiments, null, "There should be no cached experiments yet.");
+  yield ex.updateManifest();
+  Assert.notEqual(ex._experiments.size, 0, "There should be cached experiments now.");
+
+  yield promiseRestartManager();
+});
+
+add_task(function* test_checkCache() {
+  let ex = new Experiments.Experiments(gPolicy);
+  yield ex.notify();
+  Assert.notEqual(ex._experiments.size, 0, "There should be cached experiments now.");
+
+  yield promiseRestartManager();
+});
+
+add_task(function* test_fetchInvalid() {
+  yield removeCacheFile();
+
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, gHttpRoot + "experiments_1.manifest");
+  let ex = new Experiments.Experiments(gPolicy);
+  yield ex.updateManifest();
+  Assert.notEqual(ex._experiments.size, 0, "There should be experiments");
+
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, gHttpRoot + "invalid.manifest");
+  yield ex.updateManifest()
+  Assert.notEqual(ex._experiments.size, 0, "There should still be experiments: fetch failure shouldn't remove them.");
+
+  yield promiseRestartManager();
+});
diff --git a/browser/experiments/test/xpcshell/test_nethang_bug1012924.js b/browser/experiments/test/xpcshell/test_nethang_bug1012924.js
new file mode 100644
index 000000000..7ef604901
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_nethang_bug1012924.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://testing-common/httpd.js");
+Cu.import("resource:///modules/experiments/Experiments.jsm");
+
+const MANIFEST_HANDLER         = "manifests/handler";
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_setup() {
+  loadAddonManager();
+  do_get_profile();
+
+  let httpServer = new HttpServer();
+  httpServer.start(-1);
+  let port = httpServer.identity.primaryPort;
+  let httpRoot = "http://localhost:" + port + "/";
+  let handlerURI = httpRoot + MANIFEST_HANDLER;
+  httpServer.registerPathHandler("/" + MANIFEST_HANDLER,
+    (request, response) => {
+      response.processAsync();
+      response.setStatus(null, 200, "OK");
+      response.write("["); // never finish!
+    });
+
+  do_register_cleanup(() => httpServer.stop(() => {}));
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, handlerURI);
+  Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
+
+  let experiments = Experiments.instance();
+  experiments.updateManifest().then(
+    () => {
+      Assert.ok(true, "updateManifest finished successfully");
+    },
+    (e) => {
+      do_throw("updateManifest should not have failed: got error " + e);
+    });
+  yield experiments.uninit();
+});
diff --git a/browser/experiments/test/xpcshell/test_previous_provider.js b/browser/experiments/test/xpcshell/test_previous_provider.js
new file mode 100644
index 000000000..f7186e159
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_previous_provider.js
@@ -0,0 +1,179 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://gre/modules/Promise.jsm");
+Cu.import("resource:///modules/experiments/Experiments.jsm");
+Cu.import("resource://testing-common/httpd.js");
+
+var gDataRoot;
+var gHttpServer;
+var gManifestObject;
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function test_setup() {
+  loadAddonManager();
+  do_get_profile();
+
+  gHttpServer = new HttpServer();
+  gHttpServer.start(-1);
+  let httpRoot = "http://localhost:" + gHttpServer.identity.primaryPort + "/";
+  gDataRoot = httpRoot + "data/";
+  gHttpServer.registerDirectory("/data/", do_get_cwd());
+  gHttpServer.registerPathHandler("/manifests/handler", (req, res) => {
+    res.setStatusLine(null, 200, "OK");
+    res.write(JSON.stringify(gManifestObject));
+    res.processAsync();
+    res.finish();
+  });
+  do_register_cleanup(() => gHttpServer.stop(() => {}));
+
+  Services.prefs.setBoolPref("experiments.enabled", true);
+  Services.prefs.setCharPref("experiments.manifest.uri",
+                             httpRoot + "manifests/handler");
+  Services.prefs.setBoolPref("experiments.logging.dump", true);
+  Services.prefs.setCharPref("experiments.logging.level", "Trace");
+});
+
+add_task(function* test_provider_basic() {
+  let e = Experiments.instance();
+
+  let provider = new Experiments.PreviousExperimentProvider(e);
+  e._setPreviousExperimentsProvider(provider);
+
+  let deferred = Promise.defer();
+  provider.getAddonsByTypes(["experiment"], (addons) => {
+    deferred.resolve(addons);
+  });
+  let experimentAddons = yield deferred.promise;
+  Assert.ok(Array.isArray(experimentAddons), "getAddonsByTypes returns an Array.");
+  Assert.equal(experimentAddons.length, 0, "No previous add-ons returned.");
+
+  gManifestObject = {
+    version: 1,
+    experiments: [
+      {
+        id: EXPERIMENT1_ID,
+        xpiURL: gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash: EXPERIMENT1_XPI_SHA1,
+        startTime: Date.now() / 1000 - 60,
+        endTime: Date.now() / 1000 + 60,
+        maxActiveSeconds: 60,
+        appName: ["XPCShell"],
+        channel: [e._policy.updatechannel()],
+      },
+    ],
+  };
+
+  yield e.updateManifest();
+
+  deferred = Promise.defer();
+  provider.getAddonsByTypes(["experiment"], (addons) => {
+    deferred.resolve(addons);
+  });
+  experimentAddons = yield deferred.promise;
+  Assert.equal(experimentAddons.length, 0, "Still no previous experiment.");
+
+  let experiments = yield e.getExperiments();
+  Assert.equal(experiments.length, 1, "1 experiment present.");
+  Assert.ok(experiments[0].active, "It is active.");
+
+  // Deactivate it.
+  defineNow(e._policy, new Date(gManifestObject.experiments[0].endTime * 1000 + 1000));
+  yield e.updateManifest();
+
+  experiments = yield e.getExperiments();
+  Assert.equal(experiments.length, 1, "1 experiment present.");
+  Assert.equal(experiments[0].active, false, "It isn't active.");
+
+  deferred = Promise.defer();
+  provider.getAddonsByTypes(["experiment"], (addons) => {
+    deferred.resolve(addons);
+  });
+  experimentAddons = yield deferred.promise;
+  Assert.equal(experimentAddons.length, 1, "1 previous add-on known.");
+  Assert.equal(experimentAddons[0].id, EXPERIMENT1_ID, "ID matches expected.");
+
+  deferred = Promise.defer();
+  provider.getAddonByID(EXPERIMENT1_ID, (addon) => {
+    deferred.resolve(addon);
+  });
+  let addon = yield deferred.promise;
+  Assert.ok(addon, "We got an add-on from its ID.");
+  Assert.equal(addon.id, EXPERIMENT1_ID, "ID matches expected.");
+  Assert.ok(addon.appDisabled, "Add-on is a previous experiment.");
+  Assert.ok(addon.userDisabled, "Add-on is disabled.");
+  Assert.equal(addon.type, "experiment", "Add-on is an experiment.");
+  Assert.equal(addon.isActive, false, "Add-on is not active.");
+  Assert.equal(addon.permissions, 0, "Add-on has no permissions.");
+
+  deferred = Promise.defer();
+  AddonManager.getAddonsByTypes(["experiment"], (addons) => {
+    deferred.resolve(addons);
+  });
+  experimentAddons = yield deferred.promise;
+  Assert.equal(experimentAddons.length, 1, "Got 1 experiment from add-on manager.");
+  Assert.equal(experimentAddons[0].id, EXPERIMENT1_ID, "ID matches expected.");
+  Assert.ok(experimentAddons[0].appDisabled, "It is a previous experiment add-on.");
+});
+
+add_task(function* test_active_and_previous() {
+  // Building on the previous test, activate experiment 2.
+  let e = Experiments.instance();
+  let provider = new Experiments.PreviousExperimentProvider(e);
+  e._setPreviousExperimentsProvider(provider);
+
+  gManifestObject = {
+    version: 1,
+    experiments: [
+      {
+        id: EXPERIMENT2_ID,
+        xpiURL: gDataRoot + EXPERIMENT2_XPI_NAME,
+        xpiHash: EXPERIMENT2_XPI_SHA1,
+        startTime: Date.now() / 1000 - 60,
+        endTime: Date.now() / 1000 + 60,
+        maxActiveSeconds: 60,
+        appName: ["XPCShell"],
+        channel: [e._policy.updatechannel()],
+      },
+    ],
+  };
+
+  defineNow(e._policy, new Date());
+  yield e.updateManifest();
+
+  let experiments = yield e.getExperiments();
+  Assert.equal(experiments.length, 2, "2 experiments known.");
+
+  let deferred = Promise.defer();
+  provider.getAddonsByTypes(["experiment"], (addons) => {
+    deferred.resolve(addons);
+  });
+  let experimentAddons = yield deferred.promise;
+  Assert.equal(experimentAddons.length, 1, "1 previous experiment.");
+
+  deferred = Promise.defer();
+  AddonManager.getAddonsByTypes(["experiment"], (addons) => {
+    deferred.resolve(addons);
+  });
+  experimentAddons = yield deferred.promise;
+  Assert.equal(experimentAddons.length, 2, "2 experiment add-ons known.");
+
+  for (let addon of experimentAddons) {
+    if (addon.id == EXPERIMENT1_ID) {
+      Assert.equal(addon.isActive, false, "Add-on is not active.");
+      Assert.ok(addon.appDisabled, "Should be a previous experiment.");
+    }
+    else if (addon.id == EXPERIMENT2_ID) {
+      Assert.ok(addon.isActive, "Add-on is active.");
+      Assert.ok(!addon.appDisabled, "Should not be a previous experiment.");
+    }
+    else {
+      throw new Error("Unexpected add-on ID: " + addon.id);
+    }
+  }
+});
diff --git a/browser/experiments/test/xpcshell/test_telemetry.js b/browser/experiments/test/xpcshell/test_telemetry.js
new file mode 100644
index 000000000..02bd15d2b
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_telemetry.js
@@ -0,0 +1,294 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource://testing-common/httpd.js");
+Cu.import("resource://gre/modules/TelemetryLog.jsm");
+var bsp = Cu.import("resource:///modules/experiments/Experiments.jsm");
+
+
+const MANIFEST_HANDLER         = "manifests/handler";
+
+const SEC_IN_ONE_DAY  = 24 * 60 * 60;
+const MS_IN_ONE_DAY   = SEC_IN_ONE_DAY * 1000;
+
+
+var gHttpServer          = null;
+var gHttpRoot            = null;
+var gDataRoot            = null;
+var gPolicy              = null;
+var gManifestObject      = null;
+var gManifestHandlerURI  = null;
+
+const TLOG = bsp.TELEMETRY_LOG;
+
+function checkEvent(event, id, data)
+{
+  do_print("Checking message " + id);
+  Assert.equal(event[0], id, "id should match");
+  Assert.ok(event[1] > 0, "timestamp should be greater than 0");
+
+  if (data === undefined) {
+   Assert.equal(event.length, 2, "event array should have 2 entries");
+  } else {
+    Assert.equal(event.length, data.length + 2, "event entry count should match expected count");
+    for (var i = 0; i < data.length; ++i) {
+      Assert.equal(typeof(event[i + 2]), "string", "event entry should be a string");
+      Assert.equal(event[i + 2], data[i], "event entry should match expected entry");
+    }
+  }
+}
+
+function run_test() {
+  run_next_test();
+}
+
+add_task(function* test_setup() {
+  loadAddonManager();
+
+  gHttpServer = new HttpServer();
+  gHttpServer.start(-1);
+  let port = gHttpServer.identity.primaryPort;
+  gHttpRoot = "http://localhost:" + port + "/";
+  gDataRoot = gHttpRoot + "data/";
+  gManifestHandlerURI = gHttpRoot + MANIFEST_HANDLER;
+  gHttpServer.registerDirectory("/data/", do_get_cwd());
+  gHttpServer.registerPathHandler("/" + MANIFEST_HANDLER, (request, response) => {
+    response.setStatusLine(null, 200, "OK");
+    response.write(JSON.stringify(gManifestObject));
+    response.processAsync();
+    response.finish();
+  });
+  do_register_cleanup(() => gHttpServer.stop(() => {}));
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setIntPref(PREF_LOGGING_LEVEL, 0);
+  Services.prefs.setBoolPref(PREF_LOGGING_DUMP, true);
+  Services.prefs.setCharPref(PREF_MANIFEST_URI, gManifestHandlerURI);
+  Services.prefs.setIntPref(PREF_FETCHINTERVAL, 0);
+
+  gPolicy = new Experiments.Policy();
+  let dummyTimer = { cancel: () => {}, clear: () => {} };
+  patchPolicy(gPolicy, {
+    updatechannel: () => "nightly",
+    oneshotTimer: (callback, timeout, thisObj, name) => dummyTimer,
+  });
+
+  yield removeCacheFile();
+});
+
+// Test basic starting and stopping of experiments.
+
+add_task(function* test_telemetryBasics() {
+  // Check TelemetryLog instead of TelemetrySession.getPayload().log because
+  // TelemetrySession gets Experiments.instance() and side-effects log entries.
+
+  let expectedLogLength = 0;
+
+  // Dates the following tests are based on.
+
+  let baseDate   = new Date(2014, 5, 1, 12);
+  let startDate1 = futureDate(baseDate,  50 * MS_IN_ONE_DAY);
+  let endDate1   = futureDate(baseDate, 100 * MS_IN_ONE_DAY);
+  let startDate2 = futureDate(baseDate, 150 * MS_IN_ONE_DAY);
+  let endDate2   = futureDate(baseDate, 200 * MS_IN_ONE_DAY);
+
+  // The manifest data we test with.
+
+  gManifestObject = {
+    "version": 1,
+    experiments: [
+      {
+        id:               EXPERIMENT1_ID,
+        xpiURL:           gDataRoot + EXPERIMENT1_XPI_NAME,
+        xpiHash:          EXPERIMENT1_XPI_SHA1,
+        startTime:        dateToSeconds(startDate1),
+        endTime:          dateToSeconds(endDate1),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+      {
+        id:               EXPERIMENT2_ID,
+        xpiURL:           gDataRoot + EXPERIMENT2_XPI_NAME,
+        xpiHash:          EXPERIMENT2_XPI_SHA1,
+        startTime:        dateToSeconds(startDate2),
+        endTime:          dateToSeconds(endDate2),
+        maxActiveSeconds: 10 * SEC_IN_ONE_DAY,
+        appName:          ["XPCShell"],
+        channel:          ["nightly"],
+      },
+    ],
+  };
+
+  let experiments = new Experiments.Experiments(gPolicy);
+
+  // Trigger update, clock set to before any activation.
+  // Use updateManifest() to provide for coverage of that path.
+
+  let now = baseDate;
+  defineNow(gPolicy, now);
+
+  yield experiments.updateManifest();
+  let list = yield experiments.getExperiments();
+  Assert.equal(list.length, 0, "Experiment list should be empty.");
+
+  expectedLogLength += 2;
+  let log = TelemetryLog.entries();
+  do_print("Telemetry log: " + JSON.stringify(log));
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-2], TLOG.ACTIVATION_KEY,
+             [TLOG.ACTIVATION.REJECTED, EXPERIMENT1_ID, "startTime"]);
+  checkEvent(log[log.length-1], TLOG.ACTIVATION_KEY,
+             [TLOG.ACTIVATION.REJECTED, EXPERIMENT2_ID, "startTime"]);
+
+  // Trigger update, clock set for experiment 1 to start.
+
+  now = futureDate(startDate1, 5 * MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+
+  yield experiments.updateManifest();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry now.");
+
+  expectedLogLength += 1;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries. Got " + log.toSource());
+  checkEvent(log[log.length-1], TLOG.ACTIVATION_KEY,
+             [TLOG.ACTIVATION.ACTIVATED, EXPERIMENT1_ID]);
+
+  // Trigger update, clock set for experiment 1 to stop.
+
+  now = futureDate(endDate1, 1000);
+  defineNow(gPolicy, now);
+
+  yield experiments.updateManifest();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entry.");
+
+  expectedLogLength += 2;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-2], TLOG.TERMINATION_KEY,
+             [TLOG.TERMINATION.EXPIRED, EXPERIMENT1_ID]);
+  checkEvent(log[log.length-1], TLOG.ACTIVATION_KEY,
+             [TLOG.ACTIVATION.REJECTED, EXPERIMENT2_ID, "startTime"]);
+
+  // Trigger update, clock set for experiment 2 to start with invalid hash.
+
+  now = startDate2;
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[1].xpiHash = "sha1:0000000000000000000000000000000000000000";
+
+  yield experiments.updateManifest();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 1, "Experiment list should have 1 entries.");
+
+  expectedLogLength += 1;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-1], TLOG.ACTIVATION_KEY,
+             [TLOG.ACTIVATION.INSTALL_FAILURE, EXPERIMENT2_ID]);
+
+  // Trigger update, clock set for experiment 2 to properly start now.
+
+  now = futureDate(now, MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[1].xpiHash = EXPERIMENT2_XPI_SHA1;
+
+  yield experiments.updateManifest();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 2, "Experiment list should have 2 entries.");
+
+  expectedLogLength += 1;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-1], TLOG.ACTIVATION_KEY,
+             [TLOG.ACTIVATION.ACTIVATED, EXPERIMENT2_ID]);
+
+  // Fake user uninstall of experiment via add-on manager.
+
+  now = futureDate(now, MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+
+  yield experiments.disableExperiment(TLOG.TERMINATION.ADDON_UNINSTALLED);
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 2, "Experiment list should have 2 entries.");
+
+  expectedLogLength += 1;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-1], TLOG.TERMINATION_KEY,
+             [TLOG.TERMINATION.ADDON_UNINSTALLED, EXPERIMENT2_ID]);
+
+  // Trigger update with experiment 1a ready to start.
+
+  now = futureDate(now, MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].id      = EXPERIMENT3_ID;
+  gManifestObject.experiments[0].endTime = dateToSeconds(futureDate(now, 50 * MS_IN_ONE_DAY));
+
+  yield experiments.updateManifest();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 3, "Experiment list should have 3 entries.");
+
+  expectedLogLength += 1;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-1], TLOG.ACTIVATION_KEY,
+             [TLOG.ACTIVATION.ACTIVATED, EXPERIMENT3_ID]);
+
+  // Trigger disable of an experiment via the API.
+
+  now = futureDate(now, MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+
+  yield experiments.disableExperiment(TLOG.TERMINATION.FROM_API);
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 3, "Experiment list should have 3 entries.");
+
+  expectedLogLength += 1;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-1], TLOG.TERMINATION_KEY,
+             [TLOG.TERMINATION.FROM_API, EXPERIMENT3_ID]);
+
+  // Trigger update with experiment 1a ready to start.
+
+  now = futureDate(now, MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].id      = EXPERIMENT4_ID;
+  gManifestObject.experiments[0].endTime = dateToSeconds(futureDate(now, 50 * MS_IN_ONE_DAY));
+
+  yield experiments.updateManifest();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 4, "Experiment list should have 4 entries.");
+
+  expectedLogLength += 1;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-1], TLOG.ACTIVATION_KEY,
+             [TLOG.ACTIVATION.ACTIVATED, EXPERIMENT4_ID]);
+
+  // Trigger experiment termination by something other than expiry via the manifest.
+
+  now = futureDate(now, MS_IN_ONE_DAY);
+  defineNow(gPolicy, now);
+  gManifestObject.experiments[0].os = "Plan9";
+
+  yield experiments.updateManifest();
+  list = yield experiments.getExperiments();
+  Assert.equal(list.length, 4, "Experiment list should have 4 entries.");
+
+  expectedLogLength += 1;
+  log = TelemetryLog.entries();
+  Assert.equal(log.length, expectedLogLength, "Telemetry log should have " + expectedLogLength + " entries.");
+  checkEvent(log[log.length-1], TLOG.TERMINATION_KEY,
+             [TLOG.TERMINATION.RECHECK, EXPERIMENT4_ID, "os"]);
+
+  // Cleanup.
+
+  yield promiseRestartManager();
+  yield removeCacheFile();
+});
diff --git a/browser/experiments/test/xpcshell/test_telemetry_disabled.js b/browser/experiments/test/xpcshell/test_telemetry_disabled.js
new file mode 100644
index 000000000..74f85ccfc
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_telemetry_disabled.js
@@ -0,0 +1,21 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+Cu.import("resource:///modules/experiments/Experiments.jsm");
+
+add_test(function test_experiments_activation() {
+  do_get_profile();
+  loadAddonManager();
+
+  Services.prefs.setBoolPref(PREF_EXPERIMENTS_ENABLED, true);
+  Services.prefs.setBoolPref(PREF_TELEMETRY_ENABLED, false);
+
+  let experiments = Experiments.instance();
+  Assert.ok(!experiments.enabled, "Experiments must be disabled if Telemetry is disabled.");
+
+  // TODO: Test that Experiments are turned back on when bug 1232648 lands.
+
+  run_next_test();
+});
diff --git a/browser/experiments/test/xpcshell/test_upgrade.js b/browser/experiments/test/xpcshell/test_upgrade.js
new file mode 100644
index 000000000..f094a406d
--- /dev/null
+++ b/browser/experiments/test/xpcshell/test_upgrade.js
@@ -0,0 +1,52 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+Cu.import("resource:///modules/experiments/Experiments.jsm");
+
+var cacheData = {
+  _enabled: true,
+  _manifestData: {
+    id: "foobartestid",
+    xpiURL: "http://example.com/foo.xpi",
+    xpiHash: "sha256:abcde",
+    startTime: 0,
+    endTime: 2000000000,
+    maxActiveSeconds: 40000000,
+    appName: "TestApp",
+    channel: "test-foo",
+  },
+  _needsUpdate: false,
+  _randomValue: 0.5,
+  _failedStart: false,
+  _name: "Foo",
+  _description: "Foobar",
+  _homepageURL: "",
+  _addonId: "foo@test",
+  _startDate: 0,
+  _endDate: 2000000000,
+  _branch: null
+};
+
+add_task(function* test_valid() {
+  let e = new Experiments.ExperimentEntry();
+  Assert.ok(e.initFromCacheData(cacheData));
+  Assert.ok(e.enabled);
+});
+
+add_task(function* test_upgrade() {
+  let e = new Experiments.ExperimentEntry();
+  delete cacheData._branch;
+  Assert.ok(e.initFromCacheData(cacheData));
+  Assert.ok(e.enabled);
+});
+
+add_task(function* test_missing() {
+  let e = new Experiments.ExperimentEntry();
+  delete cacheData._name;
+  Assert.ok(!e.initFromCacheData(cacheData));
+});
+
+function run_test() {
+  run_next_test();
+}
diff --git a/browser/experiments/test/xpcshell/xpcshell.ini b/browser/experiments/test/xpcshell/xpcshell.ini
new file mode 100644
index 000000000..5ea30976c
--- /dev/null
+++ b/browser/experiments/test/xpcshell/xpcshell.ini
@@ -0,0 +1,31 @@
+[DEFAULT]
+head = head.js
+tail =
+tags = addons
+firefox-appdir = browser
+skip-if = toolkit == 'android'
+support-files =
+  experiments_1.manifest
+  experiment-1.xpi
+  experiment-1a.xpi
+  experiment-2.xpi
+  experiment-racybranch.xpi
+  !/toolkit/mozapps/extensions/test/xpcshell/head_addons.js
+generated-files =
+  experiment-1.xpi
+  experiment-1a.xpi
+  experiment-2.xpi
+  experiment-racybranch.xpi
+
+[test_activate.js]
+[test_api.js]
+[test_cache.js]
+[test_cacherace.js]
+[test_conditions.js]
+[test_disableExperiments.js]
+[test_fetch.js]
+[test_telemetry.js]
+[test_telemetry_disabled.js]
+[test_previous_provider.js]
+[test_upgrade.js]
+[test_nethang_bug1012924.js]