Adding upstream version 115.7.0esr.upstream/115.7.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
author: Daniel Baumann <daniel.baumann@progress-linux.org> 2024-04-07 19:33:14 +0000
committer: Daniel Baumann <daniel.baumann@progress-linux.org> 2024-04-07 19:33:14 +0000
commit: 36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree: 105e8c98ddea1c1e4784a60a5a6410fa416be2de /browser/components/contextualidentity/test
parent: Initial commit. (diff)
download: firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
35 files changed, 3599 insertions, 0 deletions
diff --git a/browser/components/contextualidentity/test/browser/blank.html b/browser/components/contextualidentity/test/browser/blank.html
new file mode 100644
index 0000000000..bcc2e389b8
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/blank.html
@@ -0,0 +1,2 @@
+<!doctype html>
+This page intentionally left blank.
diff --git a/browser/components/contextualidentity/test/browser/browser.ini b/browser/components/contextualidentity/test/browser/browser.ini
new file mode 100644
index 0000000000..8bee56df91
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser.ini
@@ -0,0 +1,62 @@
+[DEFAULT]
+support-files =
+  head.js
+  empty_file.html
+  file_reflect_cookie_into_title.html
+  favicon-normal32.png
+  file_set_storages.html
+  serviceworker.html
+  worker.js
+  blank.html
+
+[browser_aboutURLs.js]
+skip-if =
+  os == 'linux' && bits == 64 && !debug # Bug 1731442
+[browser_blobUrl.js]
+[browser_broadcastchannel.js]
+[browser_count_and_remove.js]
+[browser_eme.js]
+skip-if = (os == "win" && processor == "aarch64") # bug 1531927
+[browser_favicon.js]
+[browser_forgetAPI_EME_forgetThisSite.js]
+skip-if = (os == "win" && processor == "aarch64") # bug 1531927
+[browser_forgetAPI_cookie_getCookiesWithOriginAttributes.js]
+[browser_forgetAPI_quota_clearStoragesForPrincipal.js]
+https_first_disabled = true
+skip-if = verify
+[browser_forgetaboutsite.js]
+skip-if = true # Bug 1541885
+[browser_imageCache.js]
+skip-if = (verify && debug && (os == 'win'))
+[browser_middleClick.js]
+skip-if =
+  (verify && debug && (os == 'linux'))
+  apple_silicon # Disabled due to bleedover with other tests when run in regular suites; passes in "failures" jobs
+  os == 'linux' && socketprocess_networking
+  win10_2004 && !debug
+
+[browser_newtabButton.js]
+[browser_originattrs_reopenin.js]
+https_first_disabled = true
+[browser_relatedTab.js]
+[browser_reopenIn.js]
+https_first_disabled = true
+[browser_restore_getCookiesWithOriginAttributes.js]
+[browser_saveLink.js]
+skip-if = (verify && !debug && (os == 'win'))
+support-files =
+  saveLink.sjs
+  !/toolkit/content/tests/browser/common/mockTransfer.js
+[browser_serviceworkers.js]
+[browser_tab_color_update.js]
+[browser_usercontext.js]
+[browser_usercontextid_new_window.js]
+[browser_usercontextid_tabdrop.js]
+https_first_disabled = true
+skip-if = 
+  os == "mac" # Intermittent failure - bug 1268276
+  os == "win" # Intermittent failure - bug 1268276
+[browser_windowName.js]
+tags = openwindow
+[browser_windowOpen.js]
+tags = openwindow
diff --git a/browser/components/contextualidentity/test/browser/browser_aboutURLs.js b/browser/components/contextualidentity/test/browser/browser_aboutURLs.js
new file mode 100644
index 0000000000..b2e43bfe65
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_aboutURLs.js
@@ -0,0 +1,70 @@
+"use strict";
+
+// For some about: URLs, they will take more time to load and cause timeout.
+// See Bug 1270998.
+requestLongerTimeout(2);
+
+add_task(async function () {
+  let aboutURLs = [];
+
+  // List of about: URLs that may cause problem, so we skip them in this test.
+  let skipURLs = [
+    // about:addons triggers an assertion in NS_CompareLoadInfoAndLoadContext:
+    // "The value of mUserContextId in the loadContext and in the loadInfo are not the same"
+    // This is due to a fetch request that has the default user context. Since
+    // the fetch request omits credentials, the user context doesn't matter.
+    "addons",
+    // about:credits and about:logins will initiate network request.
+    "credits",
+    "logins",
+    // about:telemetry will fetch Telemetry asynchronously and takes longer,
+    // so we skip this for now.
+    "telemetry",
+    // about:downloads causes a shutdown leak with stylo-chrome. bug 1419943.
+    "downloads",
+    // about:debugging requires specific wait code for internal pending RDP requests.
+    "debugging",
+    "debugging-new",
+    // about:protections uses RPM to send a message as soon as the page loads,
+    // the page is destoryed before getting a response.
+    "protections",
+  ];
+
+  for (let cid in Cc) {
+    let result = cid.match(
+      /@mozilla.org\/network\/protocol\/about;1\?what\=(.*)$/
+    );
+    if (!result) {
+      continue;
+    }
+
+    let aboutType = result[1];
+    let contract = "@mozilla.org/network/protocol/about;1?what=" + aboutType;
+    try {
+      let am = Cc[contract].getService(Ci.nsIAboutModule);
+      let uri = Services.io.newURI("about:" + aboutType);
+      let flags = am.getURIFlags(uri);
+      if (
+        !(flags & Ci.nsIAboutModule.HIDE_FROM_ABOUTABOUT) &&
+        !skipURLs.includes(aboutType)
+      ) {
+        aboutURLs.push(aboutType);
+      }
+    } catch (e) {
+      // getService might have thrown if the component doesn't actually
+      // implement nsIAboutModule
+    }
+  }
+
+  for (let url of aboutURLs) {
+    info("Loading about:" + url);
+    let tab = BrowserTestUtils.addTab(gBrowser, "about:" + url, {
+      userContextId: 1,
+    });
+    await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+    ok(true, "Done loading about:" + url);
+
+    BrowserTestUtils.removeTab(tab);
+  }
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_blobUrl.js b/browser/components/contextualidentity/test/browser/browser_blobUrl.js
new file mode 100644
index 0000000000..636ffcc301
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_blobUrl.js
@@ -0,0 +1,92 @@
+"use strict";
+
+// Here we want to test that blob URLs are not available cross containers.
+
+const BASE_URI =
+  "http://mochi.test:8888/browser/browser/components/" +
+  "contextualidentity/test/browser/empty_file.html";
+
+add_setup(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+});
+
+add_task(async function test() {
+  info("Creating a tab with UCI = 1...");
+  let tab1 = BrowserTestUtils.addTab(gBrowser, BASE_URI, { userContextId: 1 });
+  is(tab1.getAttribute("usercontextid"), "1", "New tab has UCI equal 1");
+
+  let browser1 = gBrowser.getBrowserForTab(tab1);
+  await BrowserTestUtils.browserLoaded(browser1);
+
+  let blobURL;
+
+  info("Creating a blob URL...");
+  await SpecialPowers.spawn(browser1, [], function () {
+    return Promise.resolve(
+      content.window.URL.createObjectURL(new content.window.Blob([123]))
+    );
+  }).then(newURL => {
+    blobURL = newURL;
+  });
+
+  info("Blob URL: " + blobURL);
+
+  info("Creating a tab with UCI = 2...");
+  let tab2 = BrowserTestUtils.addTab(gBrowser, BASE_URI, { userContextId: 2 });
+  is(tab2.getAttribute("usercontextid"), "2", "New tab has UCI equal 2");
+
+  let browser2 = gBrowser.getBrowserForTab(tab2);
+  await BrowserTestUtils.browserLoaded(browser2);
+
+  await SpecialPowers.spawn(browser2, [blobURL], function (url) {
+    return new Promise(resolve => {
+      var xhr = new content.window.XMLHttpRequest();
+      xhr.onerror = function () {
+        resolve("SendErrored");
+      };
+      xhr.onload = function () {
+        resolve("SendLoaded");
+      };
+      xhr.open("GET", url);
+      xhr.send();
+    });
+  }).then(status => {
+    is(
+      status,
+      "SendErrored",
+      "Using a blob URI from one user context id in another should not work"
+    );
+  });
+
+  info("Creating a tab with UCI = 1...");
+  let tab3 = BrowserTestUtils.addTab(gBrowser, BASE_URI, { userContextId: 1 });
+  is(tab3.getAttribute("usercontextid"), "1", "New tab has UCI equal 1");
+
+  let browser3 = gBrowser.getBrowserForTab(tab3);
+  await BrowserTestUtils.browserLoaded(browser3);
+
+  await SpecialPowers.spawn(browser3, [blobURL], function (url) {
+    return new Promise(resolve => {
+      var xhr = new content.window.XMLHttpRequest();
+      xhr.open("GET", url);
+      try {
+        xhr.send();
+        resolve("SendSucceeded");
+      } catch (e) {
+        resolve("SendThrew");
+      }
+    });
+  }).then(status => {
+    is(
+      status,
+      "SendSucceeded",
+      "Using a blob URI within a single user context id should work"
+    );
+  });
+
+  BrowserTestUtils.removeTab(tab1);
+  BrowserTestUtils.removeTab(tab2);
+  BrowserTestUtils.removeTab(tab3);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_broadcastchannel.js b/browser/components/contextualidentity/test/browser/browser_broadcastchannel.js
new file mode 100644
index 0000000000..0bb27f1146
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_broadcastchannel.js
@@ -0,0 +1,85 @@
+const BASE_ORIGIN = "http://example.com";
+const URI =
+  BASE_ORIGIN +
+  "/browser/browser/components/contextualidentity/test/browser/empty_file.html";
+
+// Opens `uri' in a new tab with the provided userContextId and focuses it.
+// Returns the newly opened tab and browser.
+async function openTabInUserContext(uri, userContextId) {
+  // open the tab in the correct userContextId
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // select tab and make sure its browser is focused
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return { tab, browser };
+}
+
+async function runTestForReceiver(receiver) {
+  let channelName = "contextualidentity-broadcastchannel";
+
+  // reflect the received message on title
+  await SpecialPowers.spawn(receiver.browser, [channelName], function (name) {
+    content.window.testPromise = new content.window.Promise(resolve => {
+      content.window.bc = new content.window.BroadcastChannel(name);
+      content.window.bc.onmessage = function (e) {
+        content.document.title += e.data;
+        resolve();
+      };
+    });
+  });
+
+  let sender1 = await openTabInUserContext(URI, 1);
+  let sender2 = await openTabInUserContext(URI, 2);
+  sender1.message = "Message from user context #1";
+  sender2.message = "Message from user context #2";
+
+  // send a message from a tab in different user context first
+  // then send a message from a tab in the same user context
+  for (let sender of [sender1, sender2]) {
+    await SpecialPowers.spawn(
+      sender.browser,
+      [{ name: channelName, message: sender.message }],
+      function (opts) {
+        let bc = new content.window.BroadcastChannel(opts.name);
+        bc.postMessage(opts.message);
+      }
+    );
+  }
+
+  // Since sender1 sends before sender2, if the title is exactly
+  // sender2's message, sender1's message must've been blocked
+  await SpecialPowers.spawn(
+    receiver.browser,
+    [sender2.message],
+    async function (message) {
+      await content.window.testPromise.then(function () {
+        is(
+          content.document.title,
+          message,
+          "should only receive messages from the same user context"
+        );
+      });
+    }
+  );
+
+  gBrowser.removeTab(sender1.tab);
+  gBrowser.removeTab(sender2.tab);
+}
+
+add_setup(async function () {
+  // make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+});
+
+add_task(async function test() {
+  info("Checking broadcast channel with browser tab receiver");
+  let receiver = await openTabInUserContext(URI, 2);
+  await runTestForReceiver(receiver);
+  gBrowser.removeTab(receiver.tab);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_count_and_remove.js b/browser/components/contextualidentity/test/browser/browser_count_and_remove.js
new file mode 100644
index 0000000000..8f044db94e
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_count_and_remove.js
@@ -0,0 +1,107 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+function openTabInUserContext(userContextId) {
+  let tab = BrowserTestUtils.addTab(gBrowser, "about:blank", { userContextId });
+  gBrowser.selectedTab = tab;
+}
+
+add_setup(async function () {
+  // make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+});
+
+add_task(async function test() {
+  is(
+    ContextualIdentityService.countContainerTabs(),
+    0,
+    "0 container tabs by default."
+  );
+
+  openTabInUserContext(1);
+  is(
+    ContextualIdentityService.countContainerTabs(),
+    1,
+    "1 container tab created"
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(1),
+    1,
+    "1 container tab created with id 1"
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(2),
+    0,
+    "0 container tabs created with id 2"
+  );
+
+  openTabInUserContext(1);
+  is(
+    ContextualIdentityService.countContainerTabs(),
+    2,
+    "2 container tabs created"
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(1),
+    2,
+    "2 container tabs created with id 1"
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(2),
+    0,
+    "0 container tabs created with id 2"
+  );
+
+  openTabInUserContext(2);
+  is(
+    ContextualIdentityService.countContainerTabs(),
+    3,
+    "3 container tab created"
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(1),
+    2,
+    "2 container tabs created with id 1"
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(2),
+    1,
+    "1 container tab created with id 2"
+  );
+
+  await ContextualIdentityService.closeContainerTabs(1);
+  is(
+    ContextualIdentityService.countContainerTabs(),
+    1,
+    "1 container tab created"
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(1),
+    0,
+    "0 container tabs created with id 1"
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(2),
+    1,
+    "1 container tab created with id 2"
+  );
+
+  await ContextualIdentityService.closeContainerTabs();
+  is(
+    ContextualIdentityService.countContainerTabs(),
+    0,
+    "0 container tabs at the end."
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(1),
+    0,
+    "0 container tabs at the end with id 1."
+  );
+  is(
+    ContextualIdentityService.countContainerTabs(2),
+    0,
+    "0 container tabs at the end with id 2."
+  );
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_eme.js b/browser/components/contextualidentity/test/browser/browser_eme.js
new file mode 100644
index 0000000000..8c5f4fab76
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_eme.js
@@ -0,0 +1,223 @@
+/*
+ * Bug 1283325 - A test case to test the EME is originAttributes aware or not.
+ */
+const CC = Components.Constructor;
+
+const TEST_HOST = "example.com";
+const TEST_URL =
+  "http://" +
+  TEST_HOST +
+  "/browser/browser/components/contextualidentity/test/browser/";
+
+const TESTKEY = {
+  initDataType: "keyids",
+  initData: '{"kids":["LwVHf8JLtPrv2GUXFW2v_A"], "type":"persistent-license"}',
+  kid: "LwVHf8JLtPrv2GUXFW2v_A",
+  key: "97b9ddc459c8d5ff23c1f2754c95abe8",
+  sessionType: "persistent-license",
+};
+
+const USER_ID_DEFAULT = 0;
+const USER_ID_PERSONAL = 1;
+
+async function openTabInUserContext(uri, userContextId) {
+  // Open the tab in the correct userContextId.
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // Select tab and make sure its browser is focused.
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return { tab, browser };
+}
+
+function HexToBase64(hex) {
+  var bin = "";
+  for (var i = 0; i < hex.length; i += 2) {
+    bin += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+  }
+  return window
+    .btoa(bin)
+    .replace(/=/g, "")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_");
+}
+
+function Base64ToHex(str) {
+  var bin = window.atob(str.replace(/-/g, "+").replace(/_/g, "/"));
+  var res = "";
+  for (var i = 0; i < bin.length; i++) {
+    res += ("0" + bin.charCodeAt(i).toString(16)).substr(-2);
+  }
+  return res;
+}
+
+function ByteArrayToHex(array) {
+  let bin = String.fromCharCode.apply(null, new Uint8Array(array));
+  let res = "";
+
+  for (let i = 0; i < bin.length; i++) {
+    res += ("0" + bin.charCodeAt(i).toString(16)).substr(-2);
+  }
+
+  return res;
+}
+
+function generateKeyObject(aKid, aKey) {
+  let keyObj = {
+    kty: "oct",
+    kid: aKid,
+    k: HexToBase64(aKey),
+  };
+
+  return new TextEncoder().encode(
+    JSON.stringify({
+      keys: [keyObj],
+    })
+  );
+}
+
+function generateKeyInfo(aData) {
+  let keyInfo = {
+    initDataType: aData.initDataType,
+    initData: new TextEncoder().encode(aData.initData),
+    sessionType: aData.sessionType,
+    keyObj: generateKeyObject(aData.kid, aData.key),
+  };
+
+  return keyInfo;
+}
+
+add_setup(async function () {
+  // Make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["media.mediasource.enabled", true],
+      ["media.mediasource.webm.enabled", true],
+      ["media.clearkey.persistent-license.enabled", true],
+    ],
+  });
+});
+
+add_task(async function test() {
+  // Open a tab with the default container.
+  let defaultContainer = await openTabInUserContext(
+    TEST_URL + "empty_file.html",
+    USER_ID_DEFAULT
+  );
+
+  // Generate the key info for the default container.
+  let keyInfo = generateKeyInfo(TESTKEY);
+
+  // Update the media key for the default container.
+  let result = await SpecialPowers.spawn(
+    defaultContainer.browser,
+    [keyInfo],
+    async function (aKeyInfo) {
+      let access = await content.navigator.requestMediaKeySystemAccess(
+        "org.w3.clearkey",
+        [
+          {
+            initDataTypes: [aKeyInfo.initDataType],
+            videoCapabilities: [{ contentType: "video/webm" }],
+            sessionTypes: ["persistent-license"],
+            persistentState: "required",
+          },
+        ]
+      );
+      let mediaKeys = await access.createMediaKeys();
+      let session = mediaKeys.createSession(aKeyInfo.sessionType);
+      let res = {};
+
+      // Insert the media key.
+      await new Promise(resolve => {
+        session.addEventListener("message", function (event) {
+          session
+            .update(aKeyInfo.keyObj)
+            .then(() => {
+              resolve();
+            })
+            .catch(() => {
+              ok(false, "Update the media key fail.");
+              resolve();
+            });
+        });
+
+        session.generateRequest(aKeyInfo.initDataType, aKeyInfo.initData);
+      });
+
+      let map = session.keyStatuses;
+
+      is(map.size, 1, "One media key has been added.");
+
+      if (map.size === 1) {
+        res.keyId = map.keys().next().value;
+        res.sessionId = session.sessionId;
+      }
+
+      // Close the session.
+      session.close();
+      await session.closed;
+
+      return res;
+    }
+  );
+
+  // Check the media key ID.
+  is(
+    ByteArrayToHex(result.keyId),
+    Base64ToHex(TESTKEY.kid),
+    "The key Id of the default container is correct."
+  );
+
+  // Store the sessionId for the further checking.
+  keyInfo.sessionId = result.sessionId;
+
+  // Open a tab with personal container.
+  let personalContainer = await openTabInUserContext(
+    TEST_URL + "empty_file.html",
+    USER_ID_PERSONAL
+  );
+
+  await SpecialPowers.spawn(
+    personalContainer.browser,
+    [keyInfo],
+    async function (aKeyInfo) {
+      let access = await content.navigator.requestMediaKeySystemAccess(
+        "org.w3.clearkey",
+        [
+          {
+            initDataTypes: [aKeyInfo.initDataType],
+            videoCapabilities: [{ contentType: "video/webm" }],
+            sessionTypes: ["persistent-license"],
+            persistentState: "required",
+          },
+        ]
+      );
+      let mediaKeys = await access.createMediaKeys();
+      let session = mediaKeys.createSession(aKeyInfo.sessionType);
+
+      // First, load the session to check that mediakeys do not share with
+      // default container.
+      await session.load(aKeyInfo.sessionId);
+
+      let map = session.keyStatuses;
+
+      // Check that there is no media key here.
+      is(
+        map.size,
+        0,
+        "No media key should be here for the personal container."
+      );
+    }
+  );
+
+  // Close default container tab.
+  BrowserTestUtils.removeTab(defaultContainer.tab);
+
+  // Close personal container tab.
+  BrowserTestUtils.removeTab(personalContainer.tab);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_favicon.js b/browser/components/contextualidentity/test/browser/browser_favicon.js
new file mode 100644
index 0000000000..d6374ecd3c
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_favicon.js
@@ -0,0 +1,147 @@
+/*
+ * Bug 1270678 - A test case to test does the favicon obey originAttributes.
+ */
+
+let { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+
+const USER_CONTEXTS = ["default", "personal", "work"];
+
+let gHttpServer = null;
+let gUserContextId;
+let gFaviconData;
+
+function getIconFile() {
+  new Promise(resolve => {
+    NetUtil.asyncFetch(
+      {
+        uri: "http://www.example.com/browser/browser/components/contextualidentity/test/browser/favicon-normal32.png",
+        loadUsingSystemPrincipal: true,
+        contentPolicyType: Ci.nsIContentPolicy.TYPE_INTERNAL_IMAGE_FAVICON,
+      },
+      function (inputStream, status) {
+        let size = inputStream.available();
+        gFaviconData = NetUtil.readInputStreamToString(inputStream, size);
+        resolve();
+      }
+    );
+  });
+}
+
+async function openTabInUserContext(uri, userContextId) {
+  // open the tab in the correct userContextId
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // select tab and make sure its browser is focused
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return { tab, browser };
+}
+
+function loadIndexHandler(metadata, response) {
+  response.setStatusLine(metadata.httpVersion, 200, "Ok");
+  response.setHeader("Content-Type", "text/html", false);
+  let body = `
+    <!DOCTYPE HTML>
+      <html>
+        <head>
+          <meta charset='utf-8'>
+          <title>Favicon Test</title>
+        </head>
+        <body>
+          Favicon!!
+        </body>
+    </html>`;
+  response.bodyOutputStream.write(body, body.length);
+}
+
+function loadFaviconHandler(metadata, response) {
+  let expectedCookie = "userContext=" + USER_CONTEXTS[gUserContextId];
+
+  if (metadata.hasHeader("Cookie")) {
+    is(
+      metadata.getHeader("Cookie"),
+      expectedCookie,
+      "The cookie has matched with the expected cookie."
+    );
+  } else {
+    ok(false, "The request should have a cookie.");
+  }
+
+  response.setStatusLine(metadata.httpVersion, 200, "Ok");
+  response.setHeader("Content-Type", "image/png", false);
+  response.bodyOutputStream.write(gFaviconData, gFaviconData.length);
+}
+
+add_setup(async function () {
+  // Make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+
+  // Create a http server for the image cache test.
+  if (!gHttpServer) {
+    gHttpServer = new HttpServer();
+    gHttpServer.registerPathHandler("/", loadIndexHandler);
+    gHttpServer.registerPathHandler("/favicon.png", loadFaviconHandler);
+    gHttpServer.start(-1);
+  }
+});
+
+registerCleanupFunction(() => {
+  gHttpServer.stop(() => {
+    gHttpServer = null;
+  });
+});
+
+add_task(async function test() {
+  waitForExplicitFinish();
+
+  // First, get the icon data.
+  await getIconFile();
+
+  let serverPort = gHttpServer.identity.primaryPort;
+  let testURL = "http://localhost:" + serverPort + "/";
+  let testFaviconURL = "http://localhost:" + serverPort + "/favicon.png";
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    gUserContextId = userContextId;
+
+    // Load the page in 3 different contexts and set a cookie
+    // which should only be visible in that context.
+
+    // Open our tab in the given user context.
+    let tabInfo = await openTabInUserContext(testURL, userContextId);
+
+    // Write a cookie according to the userContext.
+    await SpecialPowers.spawn(
+      tabInfo.browser,
+      [{ userContext: USER_CONTEXTS[userContextId] }],
+      function (arg) {
+        content.document.cookie = "userContext=" + arg.userContext;
+      }
+    );
+
+    let pageURI = NetUtil.newURI(testURL);
+    let favIconURI = NetUtil.newURI(testFaviconURL);
+
+    await new Promise(resolve => {
+      PlacesUtils.favicons.setAndFetchFaviconForPage(
+        pageURI,
+        favIconURI,
+        true,
+        PlacesUtils.favicons.FAVICON_LOAD_NON_PRIVATE,
+        {
+          onComplete() {
+            resolve();
+          },
+        },
+        tabInfo.browser.contentPrincipal
+      );
+    });
+
+    BrowserTestUtils.removeTab(tabInfo.tab);
+  }
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_forgetAPI_EME_forgetThisSite.js b/browser/components/contextualidentity/test/browser/browser_forgetAPI_EME_forgetThisSite.js
new file mode 100644
index 0000000000..d36e47d3cb
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_forgetAPI_EME_forgetThisSite.js
@@ -0,0 +1,259 @@
+/*
+ * Bug 1278037 - A Test case for checking whether forgetting APIs are working for the media key.
+ */
+
+const CC = Components.Constructor;
+
+const TEST_HOST = "example.com";
+const TEST_URL =
+  "http://" +
+  TEST_HOST +
+  "/browser/browser/components/contextualidentity/test/browser/";
+
+const USER_CONTEXTS = ["default", "personal"];
+
+const TEST_EME_KEY = {
+  initDataType: "keyids",
+  initData: '{"kids":["LwVHf8JLtPrv2GUXFW2v_A"], "type":"persistent-license"}',
+  kid: "LwVHf8JLtPrv2GUXFW2v_A",
+  key: "97b9ddc459c8d5ff23c1f2754c95abe8",
+  sessionType: "persistent-license",
+};
+
+//
+// Support functions.
+//
+
+async function openTabInUserContext(uri, userContextId) {
+  // Open the tab in the correct userContextId.
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // Select tab and make sure its browser is focused.
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return { tab, browser };
+}
+
+function HexToBase64(hex) {
+  var bin = "";
+  for (var i = 0; i < hex.length; i += 2) {
+    bin += String.fromCharCode(parseInt(hex.substr(i, 2), 16));
+  }
+  return window
+    .btoa(bin)
+    .replace(/=/g, "")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_");
+}
+
+function Base64ToHex(str) {
+  var bin = window.atob(str.replace(/-/g, "+").replace(/_/g, "/"));
+  var res = "";
+  for (var i = 0; i < bin.length; i++) {
+    res += ("0" + bin.charCodeAt(i).toString(16)).substr(-2);
+  }
+  return res;
+}
+
+function ByteArrayToHex(array) {
+  let bin = String.fromCharCode.apply(null, new Uint8Array(array));
+  let res = "";
+
+  for (let i = 0; i < bin.length; i++) {
+    res += ("0" + bin.charCodeAt(i).toString(16)).substr(-2);
+  }
+
+  return res;
+}
+
+function generateKeyObject(aKid, aKey) {
+  let keyObj = {
+    kty: "oct",
+    kid: aKid,
+    k: HexToBase64(aKey),
+  };
+
+  return new TextEncoder().encode(
+    JSON.stringify({
+      keys: [keyObj],
+    })
+  );
+}
+
+function generateKeyInfo(aData) {
+  let keyInfo = {
+    initDataType: aData.initDataType,
+    initData: new TextEncoder().encode(aData.initData),
+    sessionType: aData.sessionType,
+    keyObj: generateKeyObject(aData.kid, aData.key),
+  };
+
+  return keyInfo;
+}
+
+// Setup a EME key for the given browser, and return the sessionId.
+async function setupEMEKey(browser) {
+  // Generate the key info.
+  let keyInfo = generateKeyInfo(TEST_EME_KEY);
+
+  // Setup the EME key.
+  let result = await SpecialPowers.spawn(
+    browser,
+    [keyInfo],
+    async function (aKeyInfo) {
+      let access = await content.navigator.requestMediaKeySystemAccess(
+        "org.w3.clearkey",
+        [
+          {
+            initDataTypes: [aKeyInfo.initDataType],
+            videoCapabilities: [{ contentType: "video/webm" }],
+            sessionTypes: ["persistent-license"],
+            persistentState: "required",
+          },
+        ]
+      );
+      let mediaKeys = await access.createMediaKeys();
+      let session = mediaKeys.createSession(aKeyInfo.sessionType);
+      let res = {};
+
+      // Insert the EME key.
+      await new Promise(resolve => {
+        session.addEventListener("message", function (event) {
+          session
+            .update(aKeyInfo.keyObj)
+            .then(() => {
+              resolve();
+            })
+            .catch(() => {
+              ok(false, "Update the EME key fail.");
+              resolve();
+            });
+        });
+
+        session.generateRequest(aKeyInfo.initDataType, aKeyInfo.initData);
+      });
+
+      let map = session.keyStatuses;
+
+      is(map.size, 1, "One EME key has been added.");
+
+      if (map.size === 1) {
+        res.keyId = map.keys().next().value;
+        res.sessionId = session.sessionId;
+      }
+
+      // Close the session.
+      session.close();
+      await session.closed;
+
+      return res;
+    }
+  );
+
+  // Check the EME key ID.
+  is(
+    ByteArrayToHex(result.keyId),
+    Base64ToHex(TEST_EME_KEY.kid),
+    "The key Id is correct."
+  );
+  return result.sessionId;
+}
+
+// Check whether the EME key has been cleared.
+async function checkEMEKey(browser, emeSessionId) {
+  // Generate the key info.
+  let keyInfo = generateKeyInfo(TEST_EME_KEY);
+  keyInfo.sessionId = emeSessionId;
+
+  await SpecialPowers.spawn(browser, [keyInfo], async function (aKeyInfo) {
+    let access = await content.navigator.requestMediaKeySystemAccess(
+      "org.w3.clearkey",
+      [
+        {
+          initDataTypes: [aKeyInfo.initDataType],
+          videoCapabilities: [{ contentType: "video/webm" }],
+          sessionTypes: ["persistent-license"],
+          persistentState: "required",
+        },
+      ]
+    );
+    let mediaKeys = await access.createMediaKeys();
+    let session = mediaKeys.createSession(aKeyInfo.sessionType);
+
+    // First, load the session with the sessionId.
+    await session.load(aKeyInfo.sessionId);
+
+    let map = session.keyStatuses;
+
+    // Check that there is no media key here.
+    is(
+      map.size,
+      0,
+      "No media key should be here after forgetThisSite() was called."
+    );
+  });
+}
+
+//
+// Test functions.
+//
+
+add_setup(async function () {
+  // Make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["media.mediasource.enabled", true],
+      ["media.mediasource.webm.enabled", true],
+      ["media.clearkey.persistent-license.enabled", true],
+    ],
+  });
+});
+
+add_task(async function test_EME_forgetThisSite() {
+  let tabs = [];
+  let emeSessionIds = [];
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Open our tab in the given user context.
+    tabs[userContextId] = await openTabInUserContext(
+      TEST_URL + "empty_file.html",
+      userContextId
+    );
+
+    // Setup EME Key.
+    emeSessionIds[userContextId] = await setupEMEKey(
+      tabs[userContextId].browser
+    );
+
+    // Close this tab.
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+
+  // Clear all EME data for a given domain with originAttributes pattern.
+  let mps = Cc["@mozilla.org/gecko-media-plugin-service;1"].getService(
+    Ci.mozIGeckoMediaPluginChromeService
+  );
+  mps.forgetThisSite(TEST_HOST, JSON.stringify({}));
+
+  // Open tabs again to check EME keys have been cleared.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Open our tab in the given user context.
+    tabs[userContextId] = await openTabInUserContext(
+      TEST_URL + "empty_file.html",
+      userContextId
+    );
+
+    // Check whether EME Key has been cleared.
+    await checkEMEKey(
+      tabs[userContextId].browser,
+      emeSessionIds[userContextId]
+    );
+
+    // Close this tab.
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_forgetAPI_cookie_getCookiesWithOriginAttributes.js b/browser/components/contextualidentity/test/browser/browser_forgetAPI_cookie_getCookiesWithOriginAttributes.js
new file mode 100644
index 0000000000..673df942d8
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_forgetAPI_cookie_getCookiesWithOriginAttributes.js
@@ -0,0 +1,95 @@
+/*
+ * Bug 1278037 - A Test case for checking whether forgetting APIs are working for cookies.
+ */
+
+const CC = Components.Constructor;
+
+const TEST_HOST = "example.com";
+const TEST_URL =
+  "http://" +
+  TEST_HOST +
+  "/browser/browser/components/contextualidentity/test/browser/";
+
+const USER_CONTEXTS = ["default", "personal"];
+
+//
+// Support functions.
+//
+
+async function openTabInUserContext(uri, userContextId) {
+  // Open the tab in the correct userContextId.
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // Select tab and make sure its browser is focused.
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return { tab, browser };
+}
+
+function getCookiesForOA(host, userContextId) {
+  return Services.cookies.getCookiesFromHost(host, { userContextId });
+}
+
+//
+// Test functions.
+//
+
+add_setup(async function () {
+  // Make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+});
+
+add_task(async function test_cookie_getCookiesWithOriginAttributes() {
+  let tabs = [];
+  let cookieName = "userContextId";
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Load the page in 2 different contexts and set a cookie
+    // which should only be visible in that context.
+    let value = USER_CONTEXTS[userContextId];
+
+    // Open our tab in the given user context.
+    tabs[userContextId] = await openTabInUserContext(
+      TEST_URL + "file_reflect_cookie_into_title.html?" + value,
+      userContextId
+    );
+
+    // Close this tab.
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+
+  // Check that cookies have been set properly.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    let cookies = getCookiesForOA(TEST_HOST, userContextId);
+    ok(cookies.length, "Cookies available");
+
+    let foundCookie = cookies[0];
+    is(foundCookie.name, cookieName, "Check cookie name");
+    is(foundCookie.value, USER_CONTEXTS[userContextId], "Check cookie value");
+  }
+
+  // Using getCookiesWithOriginAttributes() to get all cookies for a certain
+  // domain by using the originAttributes pattern, and clear all these cookies.
+  for (let cookie of Services.cookies.getCookiesWithOriginAttributes(
+    JSON.stringify({}),
+    TEST_HOST
+  )) {
+    Services.cookies.remove(
+      cookie.host,
+      cookie.name,
+      cookie.path,
+      cookie.originAttributes
+    );
+  }
+
+  // Check that whether cookies has been cleared.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    let cookies = getCookiesForOA(TEST_HOST, userContextId);
+    ok(!cookies.length, "No Cookie should be here");
+  }
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_forgetAPI_quota_clearStoragesForPrincipal.js b/browser/components/contextualidentity/test/browser/browser_forgetAPI_quota_clearStoragesForPrincipal.js
new file mode 100644
index 0000000000..d4b57d08f6
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_forgetAPI_quota_clearStoragesForPrincipal.js
@@ -0,0 +1,170 @@
+/*
+ * Bug 1278037 - A Test case for checking whether forgetting APIs are working for the quota manager.
+ */
+
+const CC = Components.Constructor;
+
+const TEST_HOST = "example.com";
+const TEST_URL =
+  "http://" +
+  TEST_HOST +
+  "/browser/browser/components/contextualidentity/test/browser/";
+
+const USER_CONTEXTS = ["default", "personal"];
+
+//
+// Support functions.
+//
+
+async function openTabInUserContext(uri, userContextId) {
+  // Open the tab in the correct userContextId.
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // Select tab and make sure its browser is focused.
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return { tab, browser };
+}
+
+// Setup an entry for the indexedDB.
+async function setupIndexedDB(browser) {
+  await SpecialPowers.spawn(
+    browser,
+    [{ input: "TestForgetAPIs" }],
+    async function (arg) {
+      let request = content.indexedDB.open("idb", 1);
+
+      request.onerror = function () {
+        throw new Error("error opening db connection");
+      };
+
+      request.onupgradeneeded = event => {
+        let db = event.target.result;
+        let store = db.createObjectStore("obj", { keyPath: "id" });
+        store.createIndex("userContext", "userContext", { unique: false });
+      };
+
+      let db = await new Promise(resolve => {
+        request.onsuccess = event => {
+          resolve(event.target.result);
+        };
+      });
+
+      // Add an entry into the indexedDB.
+      let transaction = db.transaction(["obj"], "readwrite");
+      let store = transaction.objectStore("obj");
+      store.add({ id: 1, userContext: arg.input });
+
+      await new Promise(resolve => {
+        transaction.oncomplete = () => {
+          resolve();
+        };
+      });
+
+      // Check the indexedDB has been set properly.
+      transaction = db.transaction(["obj"], "readonly");
+      store = transaction.objectStore("obj");
+      let getRequest = store.get(1);
+      await new Promise(resolve => {
+        getRequest.onsuccess = () => {
+          let res = getRequest.result;
+          is(res.userContext, arg.input, "Check the indexedDB value");
+          resolve();
+        };
+      });
+    }
+  );
+}
+
+// Check whether the indexedDB has been cleared.
+async function checkIndexedDB(browser) {
+  await SpecialPowers.spawn(browser, [], async function () {
+    let request = content.indexedDB.open("idb", 1);
+
+    let db = await new Promise(done => {
+      request.onsuccess = event => {
+        done(event.target.result);
+      };
+    });
+
+    try {
+      db.transaction(["obj"], "readonly");
+      ok(false, "The indexedDB should not exist");
+    } catch (e) {
+      is(e.name, "NotFoundError", "The indexedDB does not exist as expected");
+    }
+
+    db.close();
+
+    content.indexedDB.deleteDatabase("idb");
+  });
+}
+
+//
+// Test functions.
+//
+
+add_setup(async function () {
+  // Make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+});
+
+add_task(async function test_quota_clearStoragesForPrincipal() {
+  let tabs = [];
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Open our tab in the given user context.
+    tabs[userContextId] = await openTabInUserContext(
+      TEST_URL + "empty_file.html",
+      userContextId
+    );
+
+    // Setup an entry for the indexedDB.
+    await setupIndexedDB(tabs[userContextId].browser);
+
+    // Close this tab.
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+
+  // Using quota manager to clear all indexed DB for a given domain.
+  let caUtils = {};
+  Services.scriptloader.loadSubScript(
+    "chrome://global/content/contentAreaUtils.js",
+    caUtils
+  );
+  let httpURI = caUtils.makeURI("http://" + TEST_HOST);
+  let httpPrincipal = Services.scriptSecurityManager.createContentPrincipal(
+    httpURI,
+    {}
+  );
+  let clearRequest = Services.qms.clearStoragesForPrincipal(
+    httpPrincipal,
+    null,
+    null,
+    true
+  );
+  await new Promise(resolve => {
+    clearRequest.callback = () => {
+      resolve();
+    };
+  });
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Open our tab in the given user context.
+    tabs[userContextId] = await openTabInUserContext(
+      TEST_URL + "empty_file.html",
+      userContextId
+    );
+
+    // Check whether indexed DB has been cleared.
+    await checkIndexedDB(tabs[userContextId].browser);
+
+    // Close this tab.
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_forgetaboutsite.js b/browser/components/contextualidentity/test/browser/browser_forgetaboutsite.js
new file mode 100644
index 0000000000..928675eb3f
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_forgetaboutsite.js
@@ -0,0 +1,425 @@
+/*
+ * Bug 1238183 - Test cases for forgetAboutSite with userContextId.
+ */
+
+const CC = Components.Constructor;
+
+let { ForgetAboutSite } = ChromeUtils.importESModule(
+  "resource://gre/modules/ForgetAboutSite.sys.mjs"
+);
+let { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+
+const USER_CONTEXTS = ["default", "personal"];
+const TEST_HOST = "example.com";
+const TEST_URL =
+  "http://" +
+  TEST_HOST +
+  "/browser/browser/components/contextualidentity/test/browser/";
+const COOKIE_NAME = "userContextId";
+
+// Counter for image load hits.
+let gHits = 0;
+
+let gHttpServer = null;
+
+function imageHandler(metadata, response) {
+  // A 1x1 PNG image.
+  // Source: https://commons.wikimedia.org/wiki/File:1x1.png (Public Domain)
+  const IMAGE = atob(
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEUAA" +
+      "ACnej3aAAAAAXRSTlMAQObYZgAAAApJREFUCNdjYAAAAAIAAeIhvDMAAAAASUVORK5CYII="
+  );
+  gHits++;
+  response.setHeader("Cache-Control", "max-age=10000", false);
+  response.setStatusLine(metadata.httpVersion, 200, "OK");
+  response.setHeader("Content-Type", "image/png", false);
+  response.write(IMAGE);
+}
+
+function loadImagePageHandler(metadata, response) {
+  response.setHeader("Cache-Control", "max-age=10000", false);
+  response.setStatusLine(metadata.httpVersion, 200, "Ok");
+  response.setHeader("Content-Type", "text/html", false);
+  let body =
+    "<!DOCTYPE HTML>\
+              <html>\
+                <head>\
+                  <meta charset='utf-8'>\
+                  <title>Load Image</title>\
+                </head>\
+                <body>\
+                <img src='image.png'>\
+                </body>\
+              </html>";
+  response.bodyOutputStream.write(body, body.length);
+}
+
+async function openTabInUserContext(uri, userContextId) {
+  // Open the tab in the correct userContextId.
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // Select tab and make sure its browser is focused.
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return { tab, browser };
+}
+
+function getCookiesForOA(host, userContextId) {
+  return Services.cookies.getCookiesFromHost(host, { userContextId });
+}
+
+function createURI(uri) {
+  return Services.io.newURI(uri);
+}
+
+function getCacheStorage(where, lci) {
+  if (!lci) {
+    lci = Services.loadContextInfo.default;
+  }
+  switch (where) {
+    case "disk":
+      return Services.cache2.diskCacheStorage(lci);
+    case "memory":
+      return Services.cache2.memoryCacheStorage(lci);
+    case "pin":
+      return Services.cache2.pinningCacheStorage(lci);
+  }
+  return null;
+}
+
+function OpenCacheEntry(key, where, flags, lci) {
+  return new Promise(resolve => {
+    key = createURI(key);
+    function CacheListener() {}
+    CacheListener.prototype = {
+      QueryInterface: ChromeUtils.generateQI(["nsICacheEntryOpenCallback"]),
+
+      onCacheEntryCheck(entry) {
+        return Ci.nsICacheEntryOpenCallback.ENTRY_WANTED;
+      },
+
+      onCacheEntryAvailable(entry, isnew, status) {
+        resolve();
+      },
+
+      run() {
+        let storage = getCacheStorage(where, lci);
+        storage.asyncOpenURI(key, "", flags, this);
+      },
+    };
+
+    new CacheListener().run();
+  });
+}
+
+//
+// Test functions.
+//
+
+// Cookies
+async function test_cookie_cleared() {
+  let tabs = [];
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Load the page in 2 different contexts and set a cookie
+    // which should only be visible in that context.
+    let value = USER_CONTEXTS[userContextId];
+
+    // Open our tab in the given user context.
+    tabs[userContextId] = await openTabInUserContext(
+      TEST_URL + "file_reflect_cookie_into_title.html?" + value,
+      userContextId
+    );
+
+    // Close this tab.
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+  // Check that cookies have been set properly.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    let cookies = getCookiesForOA(TEST_HOST, userContextId);
+    ok(cookies.length, "Cookies available");
+
+    let foundCookie = cookies[0];
+    Assert.equal(foundCookie.name, COOKIE_NAME, "Check cookie name");
+    Assert.equal(
+      foundCookie.value,
+      USER_CONTEXTS[userContextId],
+      "Check cookie value"
+    );
+  }
+
+  // Forget the site.
+  await ForgetAboutSite.removeDataFromDomain(TEST_HOST);
+
+  // Check that whether cookies has been cleared or not.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    let cookies = getCookiesForOA(TEST_HOST, userContextId);
+    ok(!cookies.length, "No Cookie should be here");
+  }
+}
+
+// Cache
+async function test_cache_cleared() {
+  // First, add some caches.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    await OpenCacheEntry(
+      "http://" + TEST_HOST + "/",
+      "disk",
+      Ci.nsICacheStorage.OPEN_NORMALLY,
+      Services.loadContextInfo.custom(false, { userContextId })
+    );
+
+    await OpenCacheEntry(
+      "http://" + TEST_HOST + "/",
+      "memory",
+      Ci.nsICacheStorage.OPEN_NORMALLY,
+      Services.loadContextInfo.custom(false, { userContextId })
+    );
+  }
+
+  // Check that caches have been set correctly.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    let mem = getCacheStorage(
+      "memory",
+      Services.loadContextInfo.custom(false, { userContextId })
+    );
+    let disk = getCacheStorage(
+      "disk",
+      Services.loadContextInfo.custom(false, { userContextId })
+    );
+
+    Assert.ok(
+      mem.exists(createURI("http://" + TEST_HOST + "/"), ""),
+      "The memory cache has been set correctly"
+    );
+    Assert.ok(
+      disk.exists(createURI("http://" + TEST_HOST + "/"), ""),
+      "The disk cache has been set correctly"
+    );
+  }
+
+  // Forget the site.
+  await ForgetAboutSite.removeDataFromDomain(TEST_HOST);
+
+  // Check that do caches be removed or not?
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    let mem = getCacheStorage(
+      "memory",
+      Services.loadContextInfo.custom(false, { userContextId })
+    );
+    let disk = getCacheStorage(
+      "disk",
+      Services.loadContextInfo.custom(false, { userContextId })
+    );
+
+    Assert.ok(
+      !mem.exists(createURI("http://" + TEST_HOST + "/"), ""),
+      "The memory cache is cleared"
+    );
+    Assert.ok(
+      !disk.exists(createURI("http://" + TEST_HOST + "/"), ""),
+      "The disk cache is cleared"
+    );
+  }
+}
+
+// Image Cache
+async function test_image_cache_cleared() {
+  let tabs = [];
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Open our tab in the given user context to cache image.
+    tabs[userContextId] = await openTabInUserContext(
+      "http://localhost:" +
+        gHttpServer.identity.primaryPort +
+        "/loadImage.html",
+      userContextId
+    );
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+
+  let expectedHits = USER_CONTEXTS.length;
+
+  // Check that image cache works with the userContextId.
+  is(
+    gHits,
+    expectedHits,
+    "The image should be loaded" + expectedHits + "times."
+  );
+
+  // Reset the cache count.
+  gHits = 0;
+
+  // Forget the site.
+  await ForgetAboutSite.removeDataFromDomain("localhost");
+
+  // Load again.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Open our tab in the given user context to cache image.
+    tabs[userContextId] = await openTabInUserContext(
+      "http://localhost:" +
+        gHttpServer.identity.primaryPort +
+        "/loadImage.html",
+      userContextId
+    );
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+
+  // Check that image cache was cleared and the server gets another two hits.
+  is(
+    gHits,
+    expectedHits,
+    "The image should be loaded" + expectedHits + "times."
+  );
+}
+
+// Offline Storage
+async function test_storage_cleared() {
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Load the page in 2 different contexts and set the local storage
+    // which should only be visible in that context.
+    let value = USER_CONTEXTS[userContextId];
+
+    // Open our tab in the given user context.
+    let tabInfo = await openTabInUserContext(
+      TEST_URL + "file_set_storages.html?" + value,
+      userContextId
+    );
+
+    // Check that the storages has been set correctly.
+    await SpecialPowers.spawn(
+      tabInfo.browser,
+      [{ userContext: USER_CONTEXTS[userContextId] }],
+      async function (arg) {
+        // Check that the local storage has been set correctly.
+        Assert.equal(
+          content.localStorage.getItem("userContext"),
+          arg.userContext,
+          "Check the local storage value"
+        );
+
+        // Check that the session storage has been set correctly.
+        Assert.equal(
+          content.sessionStorage.getItem("userContext"),
+          arg.userContext,
+          "Check the session storage value"
+        );
+
+        // Check that the indexedDB has been set correctly.
+        let request = content.indexedDB.open("idb", 1);
+
+        let db = await new Promise(done => {
+          request.onsuccess = event => {
+            done(event.target.result);
+          };
+        });
+
+        let transaction = db.transaction(["obj"], "readonly");
+        let store = transaction.objectStore("obj");
+        let storeRequest = store.get(1);
+
+        await new Promise(done => {
+          storeRequest.onsuccess = event => {
+            let res = storeRequest.result;
+            Assert.equal(
+              res.userContext,
+              arg.userContext,
+              "Check the indexedDB value"
+            );
+            done();
+          };
+        });
+      }
+    );
+
+    // Close this tab.
+    BrowserTestUtils.removeTab(tabInfo.tab);
+  }
+
+  // Forget the site.
+  await ForgetAboutSite.removeDataFromDomain(TEST_HOST);
+
+  // Open the tab again without setting the localStorage and check that the
+  // local storage has been cleared or not.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Open our tab in the given user context without setting local storage.
+    let tabInfo = await openTabInUserContext(
+      TEST_URL + "file_set_storages.html",
+      userContextId
+    );
+
+    // Check that do storages be cleared or not.
+    await SpecialPowers.spawn(tabInfo.browser, [], async function () {
+      // Check that does the local storage be cleared or not.
+      Assert.ok(
+        !content.localStorage.getItem("userContext"),
+        "The local storage has been cleared"
+      );
+
+      // Check that does the session storage be cleared or not.
+      Assert.ok(
+        !content.sessionStorage.getItem("userContext"),
+        "The session storage has been cleared"
+      );
+
+      // Check that does the indexedDB be cleared or not.
+      let request = content.indexedDB.open("idb", 1);
+
+      let db = await new Promise(done => {
+        request.onsuccess = event => {
+          done(event.target.result);
+        };
+      });
+      try {
+        db.transaction(["obj"], "readonly");
+        Assert.ok(false, "The indexedDB should not exist");
+      } catch (e) {
+        Assert.equal(
+          e.name,
+          "NotFoundError",
+          "The indexedDB does not exist as expected"
+        );
+      }
+    });
+
+    // Close the tab.
+    BrowserTestUtils.removeTab(tabInfo.tab);
+  }
+}
+
+add_setup(async function () {
+  // Make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+
+  // Create a http server for the image cache test.
+  if (!gHttpServer) {
+    gHttpServer = new HttpServer();
+    gHttpServer.registerPathHandler("/image.png", imageHandler);
+    gHttpServer.registerPathHandler("/loadImage.html", loadImagePageHandler);
+    gHttpServer.start(-1);
+  }
+});
+
+let tests = [
+  test_cookie_cleared,
+  test_cache_cleared,
+  test_image_cache_cleared,
+  test_storage_cleared,
+];
+
+add_task(async function test() {
+  for (let i = 0; i < tests.length; i++) {
+    add_task(tests[i]);
+  }
+});
+
+registerCleanupFunction(() => {
+  gHttpServer.stop(() => {
+    gHttpServer = null;
+  });
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_imageCache.js b/browser/components/contextualidentity/test/browser/browser_imageCache.js
new file mode 100644
index 0000000000..ca9c956c82
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_imageCache.js
@@ -0,0 +1,70 @@
+let { HttpServer } = ChromeUtils.import("resource://testing-common/httpd.js");
+
+const NUM_USER_CONTEXTS = 3;
+
+let gHits = 0;
+
+let server = new HttpServer();
+server.registerPathHandler("/image.png", imageHandler);
+server.registerPathHandler("/file.html", fileHandler);
+server.start(-1);
+
+let BASE_URI = "http://localhost:" + server.identity.primaryPort;
+let IMAGE_URI = BASE_URI + "/image.png";
+let FILE_URI = BASE_URI + "/file.html";
+
+function imageHandler(metadata, response) {
+  gHits++;
+  response.setHeader("Cache-Control", "max-age=10000", false);
+  response.setStatusLine(metadata.httpVersion, 200, "OK");
+  response.setHeader("Content-Type", "image/png", false);
+  var body = atob(
+    "iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAEUlEQVQImWP4z8AAQTAamQkAhpcI+DeMzFcAAAAASUVORK5CYII="
+  );
+  response.bodyOutputStream.write(body, body.length);
+}
+
+function fileHandler(metadata, response) {
+  response.setStatusLine(metadata.httpVersion, 200, "OK");
+  response.setHeader("Content-Type", "text/html", false);
+  let body = `<html><body><image src=${IMAGE_URI}></body></html>`;
+  response.bodyOutputStream.write(body, body.length);
+}
+
+add_setup(async function () {
+  // make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+});
+
+// opens `uri' in a new tab with the provided userContextId and focuses it.
+// returns the newly opened tab
+async function openTabInUserContext(uri, userContextId) {
+  // open the tab in the correct userContextId
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // select tab and make sure its browser is focused
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return tab;
+}
+
+add_task(async function test() {
+  for (
+    let userContextId = 0;
+    userContextId < NUM_USER_CONTEXTS;
+    userContextId++
+  ) {
+    let tab = await openTabInUserContext(FILE_URI, userContextId);
+    gBrowser.removeTab(tab);
+  }
+  is(
+    gHits,
+    NUM_USER_CONTEXTS,
+    "should get an image request for each user contexts"
+  );
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_middleClick.js b/browser/components/contextualidentity/test/browser/browser_middleClick.js
new file mode 100644
index 0000000000..9b9fbcb737
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_middleClick.js
@@ -0,0 +1,50 @@
+"use strict";
+
+const BASE_ORIGIN = "http://example.com";
+const URI =
+  BASE_ORIGIN +
+  "/browser/browser/components/contextualidentity/test/browser/empty_file.html";
+
+add_task(async function () {
+  info("Opening a new container tab...");
+
+  let tab = BrowserTestUtils.addTab(gBrowser, URI, { userContextId: 1 });
+  gBrowser.selectedTab = tab;
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+
+  info("Create a HTMLAnchorElement...");
+  await SpecialPowers.spawn(browser, [URI], function (uri) {
+    let anchor = content.document.createElement("a");
+    anchor.setAttribute("id", "clickMe");
+    anchor.setAttribute("href", uri);
+    anchor.appendChild(content.document.createTextNode("click me!"));
+    content.document.body.appendChild(anchor);
+  });
+
+  info("Synthesize a mouse click and wait for a new tab...");
+  let newTab = await new Promise((resolve, reject) => {
+    gBrowser.tabContainer.addEventListener(
+      "TabOpen",
+      function (openEvent) {
+        resolve(openEvent.target);
+      },
+      { once: true }
+    );
+
+    BrowserTestUtils.synthesizeMouseAtCenter(
+      "#clickMe",
+      { button: 1 },
+      browser
+    );
+  });
+
+  is(newTab.getAttribute("usercontextid"), "1", "Correct UserContextId?");
+
+  // newTab shouldn't be closed in the same event tick as TabOpen.
+  await TestUtils.waitForTick();
+
+  BrowserTestUtils.removeTab(tab);
+  BrowserTestUtils.removeTab(newTab);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_newtabButton.js b/browser/components/contextualidentity/test/browser/browser_newtabButton.js
new file mode 100644
index 0000000000..02f50f27d6
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_newtabButton.js
@@ -0,0 +1,214 @@
+"use strict";
+
+// Testing that when the user opens the add tab menu and clicks menu items
+// the correct context id is opened
+
+function findPopup(browser = gBrowser) {
+  return browser.tabContainer.querySelector(".new-tab-popup");
+}
+
+function findContextPopup() {
+  return document.querySelector("#new-tab-button-popup");
+}
+
+add_task(async function test_containers_no_left_click() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["privacy.userContext.newTabContainerOnLeftClick.enabled", false],
+    ],
+  });
+
+  let newTabButton = gBrowser.tabContainer.newTabButton;
+  ok(newTabButton, "New tab button exists");
+  ok(!newTabButton.hidden, "New tab button is visible");
+  let popup = findPopup();
+  ok(popup, "new tab should have a popup");
+
+  // Test context menu
+  let contextMenu = findContextPopup();
+  is(contextMenu.state, "closed", "Context menu is initally closed.");
+
+  let popupshown = BrowserTestUtils.waitForEvent(contextMenu, "popupshown");
+
+  let target = gBrowser.tabContainer.newTabButton;
+  EventUtils.synthesizeMouseAtCenter(target, { type: "contextmenu" });
+  await popupshown;
+
+  is(contextMenu.state, "open", "Context menu is open.");
+  let contextIdItems = contextMenu.querySelectorAll("menuitem");
+  // 4 + default + manage containers
+  is(contextIdItems.length, 6, "Has 6 menu items");
+  contextMenu.hidePopup();
+});
+
+add_task(async function test_containers_with_left_click() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["privacy.userContext.newTabContainerOnLeftClick.enabled", true],
+    ],
+  });
+
+  let newTabButton = gBrowser.tabContainer.newTabButton;
+  ok(newTabButton, "New tab button exists");
+  ok(!newTabButton.hidden, "New tab button is visible");
+
+  await BrowserTestUtils.waitForCondition(
+    () => !!findPopup(),
+    "Wait for popup to exist"
+  );
+  let popup = findPopup();
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(popup, "popupshown");
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(popup, "popuphidden");
+  EventUtils.synthesizeMouseAtCenter(newTabButton, { type: "mousedown" });
+  await popupShownPromise;
+  let contextIdItems = popup.querySelectorAll("menuitem");
+  // 4 + default + manage containers
+  is(contextIdItems.length, 6, "Has 6 menu items");
+  popup.hidePopup();
+  await popupHiddenPromise;
+
+  for (let i = 0; i <= 4; i++) {
+    popupShownPromise = BrowserTestUtils.waitForEvent(popup, "popupshown");
+    EventUtils.synthesizeMouseAtCenter(newTabButton, { type: "mousedown" });
+
+    await popupShownPromise;
+    let contextIdItem = popup.querySelector(
+      `menuitem[data-usercontextid="${i}"]`
+    );
+
+    ok(contextIdItem, `User context id ${i} exists`);
+
+    // waitForNewTab doesn't work for default tabs due to a different code path that doesn't cause a load event
+    let waitForTabPromise = BrowserTestUtils.waitForEvent(
+      gBrowser.tabContainer,
+      "TabOpen"
+    );
+    EventUtils.synthesizeMouseAtCenter(contextIdItem, {});
+
+    let tabEvent = await waitForTabPromise;
+    let tab = tabEvent.target;
+    if (i > 0) {
+      is(
+        tab.getAttribute("usercontextid"),
+        "" + i,
+        `New tab has UCI equal ${i}`
+      );
+    } else {
+      ok(!tab.hasAttribute("usercontextid"), `New tab has no UCI`);
+    }
+    BrowserTestUtils.removeTab(tab);
+  }
+
+  // Test context menu
+  let contextMenu = findContextPopup();
+  is(contextMenu.state, "closed", "Context menu is initally closed.");
+
+  let popupshown = BrowserTestUtils.waitForEvent(contextMenu, "popupshown");
+
+  let target = gBrowser.tabContainer.newTabButton;
+  EventUtils.synthesizeMouseAtCenter(target, { type: "contextmenu" });
+  await popupshown;
+
+  is(contextMenu.state, "open", "Context menu is open.");
+  contextIdItems = contextMenu.querySelectorAll("menuitem");
+  // 4 + default + manage containers
+  is(contextIdItems.length, 6, "Has 6 menu items");
+  contextMenu.hidePopup();
+});
+
+add_task(async function test_no_containers_no_left_click() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", false],
+      ["privacy.userContext.newTabContainerOnLeftClick.enabled", false],
+    ],
+  });
+
+  let newTabButton = gBrowser.tabContainer.newTabButton;
+  ok(newTabButton, "New tab button exists");
+  ok(!newTabButton.hidden, "New tab button is visible");
+  let popup = findPopup();
+  ok(!popup, "new tab should not have a popup");
+
+  // Test context menu
+  let contextMenu = findContextPopup();
+  let target = gBrowser.tabContainer.newTabButton;
+  EventUtils.synthesizeMouseAtCenter(target, { type: "contextmenu" });
+  is(contextMenu.state, "closed", "Context menu does not open.");
+});
+
+add_task(async function test_private_mode() {
+  let privateWindow = await BrowserTestUtils.openNewBrowserWindow({
+    private: true,
+  });
+  let privateDocument = privateWindow.document;
+  let { tabContainer } = privateWindow.gBrowser;
+  let newTab = tabContainer.newTabButton;
+  let newTab2 = privateDocument.getElementById("new-tab-button");
+  // Check to ensure we are talking about the right button
+  ok(!!newTab.clientWidth, "new tab button should not be hidden");
+  ok(!newTab2.clientWidth, "overflow new tab button should be hidden");
+  let popup = findPopup(privateWindow.gBrowser);
+  ok(!popup, "new tab should not have a popup");
+  await BrowserTestUtils.closeWindow(privateWindow);
+});
+
+add_task(async function test_opening_container_tab_context() {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["privacy.userContext.newTabContainerOnLeftClick.enabled", true],
+    ],
+  });
+
+  let newTabButton = gBrowser.tabContainer.newTabButton;
+  ok(newTabButton, "New tab button exists");
+  ok(!newTabButton.hidden, "New tab button is visible");
+
+  let popup = findContextPopup();
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(popup, "popupshown");
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(popup, "popuphidden");
+  EventUtils.synthesizeMouseAtCenter(newTabButton, { type: "contextmenu" });
+  await popupShownPromise;
+  let contextIdItems = popup.querySelectorAll("menuitem");
+  // 4 + default + manage containers
+  is(contextIdItems.length, 6, "Has 6 menu items");
+  popup.hidePopup();
+  await popupHiddenPromise;
+
+  for (let i = 0; i <= 4; i++) {
+    popupShownPromise = BrowserTestUtils.waitForEvent(popup, "popupshown");
+    EventUtils.synthesizeMouseAtCenter(newTabButton, { type: "contextmenu" });
+
+    await popupShownPromise;
+    let contextIdItem = popup.querySelector(
+      `menuitem[data-usercontextid="${i}"]`
+    );
+
+    ok(contextIdItem, `User context id ${i} exists`);
+
+    // waitForNewTab doesn't work for default tabs due to a different code path that doesn't cause a load event
+    let waitForTabPromise = BrowserTestUtils.waitForEvent(
+      gBrowser.tabContainer,
+      "TabOpen"
+    );
+    popup.activateItem(contextIdItem);
+
+    let tabEvent = await waitForTabPromise;
+    let tab = tabEvent.target;
+    if (i > 0) {
+      is(
+        tab.getAttribute("usercontextid"),
+        "" + i,
+        `New tab has UCI equal ${i}`
+      );
+    } else {
+      ok(!tab.hasAttribute("usercontextid"), `New tab has no UCI`);
+    }
+    BrowserTestUtils.removeTab(tab);
+  }
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_originattrs_reopenin.js b/browser/components/contextualidentity/test/browser/browser_originattrs_reopenin.js
new file mode 100644
index 0000000000..306f2da1ab
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_originattrs_reopenin.js
@@ -0,0 +1,184 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* import-globals-from ../../../../base/content/test/tabs/helper_origin_attrs_testing.js */
+loadTestSubscript(
+  "../../../../base/content/test/tabs/helper_origin_attrs_testing.js"
+);
+
+const PATH =
+  "/browser/browser/components/contextualidentity/test/browser/blank.html";
+
+const URI_EXAMPLECOM = "https://example.com/" + PATH;
+const URI_EXAMPLEORG = "https://example.org/" + PATH;
+
+var TEST_CASES = [
+  URI_EXAMPLECOM,
+  URI_EXAMPLEORG,
+  "about:preferences",
+  "about:config",
+];
+
+var remoteTypes;
+
+var xulFrameLoaderCreatedCounter = {};
+
+function handleEventLocal(aEvent) {
+  if (aEvent.type != "XULFrameLoaderCreated") {
+    return;
+  }
+  // Ignore <browser> element in about:preferences and any other special pages
+  if ("gBrowser" in aEvent.target.ownerGlobal) {
+    xulFrameLoaderCreatedCounter.numCalledSoFar++;
+  }
+}
+const NUM_PAGES_OPEN_FOR_EACH_TEST_CASE = 5;
+add_setup(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      // don't preload tabs so we don't have extra XULFrameLoaderCreated events
+      // firing
+      ["browser.newtab.preload", false],
+    ],
+  });
+
+  requestLongerTimeout(5);
+});
+
+function setupRemoteTypes() {
+  remoteTypes = {
+    regular: { "about:preferences": null, "about:config": null },
+    1: { "about:preferences": null, "about:config": null },
+    2: { "about:preferences": null, "about:config": null },
+    3: { "about:preferences": null, "about:config": null },
+  };
+  if (gFissionBrowser) {
+    remoteTypes.regular[URI_EXAMPLECOM] = "webIsolated=https://example.com";
+    remoteTypes.regular[URI_EXAMPLEORG] = "webIsolated=https://example.org";
+    remoteTypes["1"][URI_EXAMPLECOM] =
+      "webIsolated=https://example.com^userContextId=1";
+    remoteTypes["1"][URI_EXAMPLEORG] =
+      "webIsolated=https://example.org^userContextId=1";
+    remoteTypes["2"][URI_EXAMPLECOM] =
+      "webIsolated=https://example.com^userContextId=2";
+    remoteTypes["2"][URI_EXAMPLEORG] =
+      "webIsolated=https://example.org^userContextId=2";
+    remoteTypes["3"][URI_EXAMPLECOM] =
+      "webIsolated=https://example.com^userContextId=3";
+    remoteTypes["3"][URI_EXAMPLEORG] =
+      "webIsolated=https://example.org^userContextId=3";
+  } else {
+    remoteTypes.regular[URI_EXAMPLECOM] = "web";
+    remoteTypes.regular[URI_EXAMPLEORG] = "web";
+    remoteTypes["1"][URI_EXAMPLECOM] = "web";
+    remoteTypes["1"][URI_EXAMPLEORG] = "web";
+    remoteTypes["2"][URI_EXAMPLECOM] = "web";
+    remoteTypes["2"][URI_EXAMPLEORG] = "web";
+    remoteTypes["3"][URI_EXAMPLECOM] = "web";
+    remoteTypes["3"][URI_EXAMPLEORG] = "web";
+  }
+}
+
+add_task(async function testReopen() {
+  setupRemoteTypes();
+  /**
+   * Open a regular tab
+   * For each url
+   *  navigate regular tab to that url
+   *  pid_seen = [regular tab pid]
+   *  For each container
+   *    reopen regular tab in that container
+   *    verify remote type
+   *    reopen container tab in regular tab
+   *  Close all the tabs
+   * This tests that behaviour of reopening tabs is correct
+   */
+
+  let regularPage = await openURIInRegularTab("about:blank");
+  var currRemoteType;
+
+  for (const uri of TEST_CASES) {
+    // Navigate regular tab to a test-uri
+    let loaded = BrowserTestUtils.browserLoaded(
+      regularPage.tab.linkedBrowser,
+      false,
+      uri
+    );
+    await BrowserTestUtils.loadURIString(regularPage.tab.linkedBrowser, uri);
+    await loaded;
+    info(`Start Opened ${uri} in a regular tab`);
+    currRemoteType = regularPage.tab.linkedBrowser.remoteType;
+    is(currRemoteType, remoteTypes.regular[uri], "correct remote type");
+
+    let containerTabs = [];
+
+    // Reopen this test-uri in different containers and ensure pids are different
+    for (var userCtxId = 1; userCtxId <= NUM_USER_CONTEXTS; userCtxId++) {
+      // Prepare the reopen menu
+      let reopenMenu = await openReopenMenuForTab(regularPage.tab);
+
+      // Add a listener for XULFrameLoaderCreated
+      initXulFrameLoaderCreatedCounter(xulFrameLoaderCreatedCounter);
+      regularPage.tab.ownerGlobal.gBrowser.addEventListener(
+        "XULFrameLoaderCreated",
+        handleEventLocal
+      );
+
+      // Reopen the page in a container
+      let containerTab = await openTabInContainer(
+        gBrowser,
+        uri,
+        reopenMenu,
+        userCtxId.toString()
+      );
+      info(`Re-opened ${uri} in a container tab ${userCtxId}`);
+
+      // Check correct remote type
+      currRemoteType = containerTab.linkedBrowser.remoteType;
+      is(
+        currRemoteType,
+        remoteTypes[userCtxId.toString()][uri],
+        "correct remote type"
+      );
+
+      // Check that XULFrameLoaderCreated has fired off correct number of times
+      is(
+        xulFrameLoaderCreatedCounter.numCalledSoFar,
+        1,
+        `XULFrameLoaderCreated was fired once when reopening ${uri} in container ${userCtxId}`
+      );
+      regularPage.tab.ownerGlobal.gBrowser.removeEventListener(
+        "XULFrameLoaderCreated",
+        handleEventLocal
+      );
+
+      // Save the tab so we can close it later
+      containerTabs.push(containerTab);
+    }
+    let containedTabsOpenedInNoContainer = [];
+
+    for (const containerTab of containerTabs) {
+      info(`About to re-open ${uri} in a regular, no-container tab`);
+      let reopenMenu = await openReopenMenuForTab(containerTab);
+      let reopenedInNoContainerTab = await openTabInContainer(
+        gBrowser,
+        uri,
+        reopenMenu,
+        "0"
+      );
+      info(`Re-opened ${uri} in a regular, no-container tab`);
+      // Check remote type
+      currRemoteType = reopenedInNoContainerTab.linkedBrowser.remoteType;
+      is(currRemoteType, remoteTypes.regular[uri], "correct remote type");
+      containedTabsOpenedInNoContainer.push(reopenedInNoContainerTab);
+    }
+
+    // Close tabs
+    for (const tab of containerTabs.concat(containedTabsOpenedInNoContainer)) {
+      BrowserTestUtils.removeTab(tab);
+    }
+  }
+  BrowserTestUtils.removeTab(regularPage.tab);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_relatedTab.js b/browser/components/contextualidentity/test/browser/browser_relatedTab.js
new file mode 100644
index 0000000000..3451d3d16e
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_relatedTab.js
@@ -0,0 +1,94 @@
+"use strict";
+
+/*
+ * Bug 1325014 - Adding tab related to current tab inherits current tab's container usercontextid unless otherwise specified
+ */
+
+add_task(async function () {
+  let tab = BrowserTestUtils.addTab(gBrowser, "about:blank", {
+    userContextId: 1,
+  });
+  let ReferrerInfo = Components.Constructor(
+    "@mozilla.org/referrer-info;1",
+    "nsIReferrerInfo",
+    "init"
+  );
+
+  gBrowser.selectedTab = tab;
+  let relatedTab = BrowserTestUtils.addTab(gBrowser, "about:blank", {
+    relatedToCurrent: true,
+  });
+  is(
+    relatedTab.getAttribute("usercontextid"),
+    "1",
+    "Related tab (relatedToCurrent) inherits current tab's usercontextid"
+  );
+  is(
+    relatedTab.linkedBrowser.contentPrincipal.userContextId,
+    1,
+    "Related tab's browser actually inherits the current tab's usercontextid"
+  );
+  BrowserTestUtils.removeTab(relatedTab);
+
+  gBrowser.selectedTab = tab;
+  relatedTab = BrowserTestUtils.addTab(gBrowser, "about:blank", {
+    relatedToCurrent: true,
+    userContextId: 2,
+  });
+  is(
+    relatedTab.getAttribute("usercontextid"),
+    "2",
+    "Related tab (relatedToCurrent) with overridden usercontextid"
+  );
+  is(
+    relatedTab.linkedBrowser.contentPrincipal.userContextId,
+    2,
+    "Related tab's browser actually gets overridden usercontextid"
+  );
+  BrowserTestUtils.removeTab(relatedTab);
+
+  gBrowser.selectedTab = tab;
+  let referrerInfo = new ReferrerInfo(
+    Ci.nsIReferrerInfo.EMPTY,
+    true,
+    gBrowser.currentURI
+  );
+  relatedTab = BrowserTestUtils.addTab(gBrowser, "about:blank", {
+    referrerInfo,
+  });
+  is(
+    relatedTab.getAttribute("usercontextid"),
+    "1",
+    "Related tab (referrer) inherits current tab's usercontextid"
+  );
+  is(
+    relatedTab.linkedBrowser.contentPrincipal.userContextId,
+    1,
+    "Related tab's browser (referrer) actually inherits the current tab's usercontextid"
+  );
+  BrowserTestUtils.removeTab(relatedTab);
+
+  gBrowser.selectedTab = tab;
+  referrerInfo = new ReferrerInfo(
+    Ci.nsIReferrerInfo.EMPTY,
+    true,
+    gBrowser.currentURI
+  );
+  relatedTab = BrowserTestUtils.addTab(gBrowser, "about:blank", {
+    referrerInfo,
+    userContextId: 2,
+  });
+  is(
+    relatedTab.getAttribute("usercontextid"),
+    "2",
+    "Related tab (referrer) with overridden usercontextid"
+  );
+  is(
+    relatedTab.linkedBrowser.contentPrincipal.userContextId,
+    2,
+    "Related tab's browser (referrer) actually gets overridden usercontextid"
+  );
+  BrowserTestUtils.removeTab(relatedTab);
+
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_reopenIn.js b/browser/components/contextualidentity/test/browser/browser_reopenIn.js
new file mode 100644
index 0000000000..9bda63b201
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_reopenIn.js
@@ -0,0 +1,164 @@
+"use strict";
+
+const TEST_HOST = "example.com";
+const TEST_URL =
+  "http://" +
+  TEST_HOST +
+  "/browser/browser/components/contextualidentity/test/browser/";
+
+async function openTabMenuFor(tab) {
+  let tabMenu = tab.ownerDocument.getElementById("tabContextMenu");
+
+  let tabMenuShown = BrowserTestUtils.waitForEvent(tabMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(
+    tab,
+    { type: "contextmenu" },
+    tab.ownerGlobal
+  );
+  await tabMenuShown;
+
+  return tabMenu;
+}
+
+async function openReopenMenuForTab(tab) {
+  await openTabMenuFor(tab);
+
+  let reopenItem = tab.ownerDocument.getElementById(
+    "context_reopenInContainer"
+  );
+  ok(!reopenItem.hidden, "Reopen in Container item should be shown");
+
+  let reopenMenu = reopenItem.getElementsByTagName("menupopup")[0];
+  let reopenMenuShown = BrowserTestUtils.waitForEvent(reopenMenu, "popupshown");
+  reopenItem.openMenu(true);
+  await reopenMenuShown;
+
+  return reopenMenu;
+}
+
+function checkMenuItem(reopenMenu, shown, hidden) {
+  for (let id of shown) {
+    ok(
+      reopenMenu.querySelector(`menuitem[data-usercontextid="${id}"]`),
+      `User context id ${id} should exist`
+    );
+  }
+  for (let id of hidden) {
+    ok(
+      !reopenMenu.querySelector(`menuitem[data-usercontextid="${id}"]`),
+      `User context id ${id} shouldn't exist`
+    );
+  }
+}
+
+function openTabInContainer(gBrowser, reopenMenu, id) {
+  let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, TEST_URL, true);
+  let menuitem = reopenMenu.querySelector(
+    `menuitem[data-usercontextid="${id}"]`
+  );
+  reopenMenu.activateItem(menuitem);
+  return tabPromise;
+}
+
+add_task(async function testReopen() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    url: TEST_URL,
+  });
+  ok(
+    !tab.hasAttribute("usercontextid"),
+    "Tab with No Container should be opened"
+  );
+
+  let reopenMenu = await openReopenMenuForTab(tab);
+  checkMenuItem(reopenMenu, [1, 2, 3, 4], [0]);
+
+  let containerTab = await openTabInContainer(gBrowser, reopenMenu, "1");
+
+  is(
+    containerTab.getAttribute("usercontextid"),
+    "1",
+    "Tab with UCI=1 should be opened"
+  );
+  is(
+    containerTab.linkedBrowser.currentURI.spec,
+    TEST_URL,
+    "Same page should be opened"
+  );
+
+  reopenMenu = await openReopenMenuForTab(containerTab);
+  checkMenuItem(reopenMenu, [0, 2, 3, 4], [1]);
+
+  let noContainerTab = await openTabInContainer(gBrowser, reopenMenu, "0");
+
+  ok(
+    !noContainerTab.hasAttribute("usercontextid"),
+    "Tab with no UCI should be opened"
+  );
+  is(
+    noContainerTab.linkedBrowser.currentURI.spec,
+    TEST_URL,
+    "Same page should be opened"
+  );
+
+  BrowserTestUtils.removeTab(tab);
+  BrowserTestUtils.removeTab(containerTab);
+  BrowserTestUtils.removeTab(noContainerTab);
+});
+
+add_task(async function testDisabled() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", false]],
+  });
+
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser,
+    url: TEST_URL,
+  });
+  ok(
+    !tab.hasAttribute("usercontextid"),
+    "Tab with No Container should be opened"
+  );
+
+  let tabMenu = await openTabMenuFor(tab);
+  let reopenItem = document.getElementById("context_reopenInContainer");
+  ok(reopenItem.hidden, "Reopen in Container item should be hidden");
+
+  // Close the tab menu.
+  tabMenu.hidePopup();
+
+  BrowserTestUtils.removeTab(tab);
+});
+
+add_task(async function testPrivateMode() {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+
+  let privateWindow = await BrowserTestUtils.openNewBrowserWindow({
+    private: true,
+  });
+  let tab = await BrowserTestUtils.openNewForegroundTab({
+    gBrowser: privateWindow.gBrowser,
+    url: TEST_URL,
+  });
+  ok(
+    !tab.hasAttribute("usercontextid"),
+    "Tab with No Container should be opened"
+  );
+
+  let tabMenu = await openTabMenuFor(tab);
+  let reopenItem = privateWindow.document.getElementById(
+    "context_reopenInContainer"
+  );
+  ok(reopenItem.hidden, "Reopen in Container item should be hidden");
+
+  // Close the tab menu.
+  tabMenu.hidePopup();
+
+  await BrowserTestUtils.closeWindow(privateWindow);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_restore_getCookiesWithOriginAttributes.js b/browser/components/contextualidentity/test/browser/browser_restore_getCookiesWithOriginAttributes.js
new file mode 100644
index 0000000000..df79de9ca2
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_restore_getCookiesWithOriginAttributes.js
@@ -0,0 +1,122 @@
+/*
+ * Bug 1334587 - A Test case for checking whether forgetting APIs are working for cookies.
+ */
+
+const CC = Components.Constructor;
+
+const TEST_HOST = "example.com";
+const TEST_URL =
+  "http://" +
+  TEST_HOST +
+  "/browser/browser/components/contextualidentity/test/browser/";
+
+const USER_CONTEXTS = ["default", "personal", "work"];
+
+const DELETE_CONTEXT = 1;
+const COOKIE_NAME = "userContextId";
+
+//
+// Support functions.
+//
+
+async function openTabInUserContext(uri, userContextId) {
+  // Open the tab in the correct userContextId.
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // Select tab and make sure its browser is focused.
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+  return { tab, browser };
+}
+
+function getCookiesForOA(host, userContextId) {
+  return Services.cookies.getCookiesFromHost(host, { userContextId });
+}
+
+//
+// Test functions.
+//
+
+add_setup(async function () {
+  // Make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+});
+
+function checkCookies(ignoreContext = null) {
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    if (ignoreContext && userContextId === String(ignoreContext)) {
+      continue;
+    }
+    let cookies = getCookiesForOA(TEST_HOST, userContextId);
+    ok(cookies.length, "Cookies available");
+
+    let foundCookie = cookies[0];
+    is(foundCookie.name, COOKIE_NAME, "Check cookie name");
+    is(foundCookie.value, USER_CONTEXTS[userContextId], "Check cookie value");
+  }
+}
+
+function deleteCookies(onlyContext = null) {
+  // Using getCookiesWithOriginAttributes() to get all cookies for a certain
+  // domain by using the originAttributes pattern, and clear all these cookies.
+  for (let cookie of Services.cookies.getCookiesWithOriginAttributes(
+    JSON.stringify({}),
+    TEST_HOST
+  )) {
+    if (!onlyContext || cookie.originAttributes.userContextId == onlyContext) {
+      Services.cookies.remove(
+        cookie.host,
+        cookie.name,
+        cookie.path,
+        cookie.originAttributes
+      );
+    }
+  }
+}
+
+add_task(async function test_cookie_getCookiesWithOriginAttributes() {
+  let tabs = [];
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Load the page in different contexts and set a cookie
+    // which should only be visible in that context.
+    let value = USER_CONTEXTS[userContextId];
+
+    // Open our tab in the given user context.
+    tabs[userContextId] = await openTabInUserContext(
+      TEST_URL + "file_reflect_cookie_into_title.html?" + value,
+      userContextId
+    );
+
+    // Close this tab.
+    BrowserTestUtils.removeTab(tabs[userContextId].tab);
+  }
+
+  // Check that cookies have been set properly.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    let cookies = getCookiesForOA(TEST_HOST, userContextId);
+    ok(cookies.length, "Cookies available");
+
+    let foundCookie = cookies[0];
+    is(foundCookie.name, COOKIE_NAME, "Check cookie name");
+    is(foundCookie.value, USER_CONTEXTS[userContextId], "Check cookie value");
+  }
+  checkCookies();
+
+  deleteCookies(DELETE_CONTEXT);
+
+  checkCookies(DELETE_CONTEXT);
+
+  deleteCookies();
+
+  // Check that whether cookies has been cleared.
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    let cookies = getCookiesForOA(TEST_HOST, userContextId);
+    ok(!cookies.length, "No Cookie should be here");
+  }
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_saveLink.js b/browser/components/contextualidentity/test/browser/browser_saveLink.js
new file mode 100644
index 0000000000..65f60f7eef
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_saveLink.js
@@ -0,0 +1,134 @@
+"use strict";
+
+const BASE_ORIGIN = "https://example.com";
+const URI =
+  BASE_ORIGIN +
+  "/browser/browser/components/contextualidentity/test/browser/saveLink.sjs";
+
+let MockFilePicker = SpecialPowers.MockFilePicker;
+MockFilePicker.init(window);
+
+add_setup(async function () {
+  info("Setting the prefs.");
+
+  // make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      // This test does a redirect from https to http and it checks the
+      // cookies. This is incompatible with the cookie SameSite schemeful
+      // feature and we need to disable it.
+      ["network.cookie.sameSite.schemeful", false],
+      // This Test trys to download mixed content
+      // so we need to make sure that this is not blocked
+      ["dom.block_download_insecure", false],
+    ],
+  });
+});
+
+add_task(async function test() {
+  info("Let's open a new window");
+  let win = await BrowserTestUtils.openNewBrowserWindow();
+
+  info("Opening tab with UCI: 1");
+  let tab = BrowserTestUtils.addTab(win.gBrowser, URI + "?UCI=1", {
+    userContextId: 1,
+  });
+
+  // select tab and make sure its browser is focused
+  win.gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  info("Waiting to load content");
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+
+  let popupShownPromise = BrowserTestUtils.waitForEvent(
+    win.document,
+    "popupshown"
+  );
+
+  await BrowserTestUtils.synthesizeMouseAtCenter(
+    "#fff",
+    { type: "contextmenu", button: 2 },
+    win.gBrowser.selectedBrowser
+  );
+  info("Right clicked!");
+
+  await popupShownPromise;
+  info("Context menu opened");
+
+  info("Let's create a temporary dir");
+  let tempDir = createTemporarySaveDirectory();
+  let destFile;
+
+  MockFilePicker.displayDirectory = tempDir;
+  MockFilePicker.showCallback = fp => {
+    info("MockFilePicker showCallback");
+
+    let fileName = fp.defaultString;
+    destFile = tempDir.clone();
+    destFile.append(fileName);
+
+    MockFilePicker.setFiles([destFile]);
+    MockFilePicker.filterIndex = 1; // kSaveAsType_URL
+
+    info("MockFilePicker showCallback done");
+  };
+
+  let transferCompletePromise = new Promise(resolve => {
+    function onTransferComplete(downloadSuccess) {
+      ok(downloadSuccess, "File should have been downloaded successfully");
+      resolve();
+    }
+
+    mockTransferCallback = onTransferComplete;
+    mockTransferRegisterer.register();
+  });
+
+  registerCleanupFunction(function () {
+    mockTransferRegisterer.unregister();
+    MockFilePicker.cleanup();
+    tempDir.remove(true);
+  });
+
+  // Select "Save Link As" option from context menu
+  let saveLinkCommand = win.document.getElementById("context-savelink");
+  info("saveLinkCommand: " + saveLinkCommand);
+  saveLinkCommand.doCommand();
+
+  let contextMenu = win.document.getElementById("contentAreaContextMenu");
+  let popupHiddenPromise = BrowserTestUtils.waitForEvent(
+    contextMenu,
+    "popuphidden"
+  );
+  contextMenu.hidePopup();
+  await popupHiddenPromise;
+  info("popup hidden");
+
+  await transferCompletePromise;
+
+  // Let's query the SJS to know if the download happened with the correct cookie.
+  let response = await fetch(URI + "?result=1");
+  let text = await response.text();
+  is(text, "Result:UCI=1", "Correct cookie used: -" + text + "-");
+
+  info("Closing the window");
+  await BrowserTestUtils.closeWindow(win);
+});
+
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/toolkit/content/tests/browser/common/mockTransfer.js",
+  this
+);
+
+function createTemporarySaveDirectory() {
+  let saveDir = Services.dirsvc.get("TmpD", Ci.nsIFile);
+  saveDir.append("testsavedir");
+  if (!saveDir.exists()) {
+    info("create testsavedir!");
+    saveDir.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755);
+  }
+  info("return from createTempSaveDir: " + saveDir.path);
+  return saveDir;
+}
diff --git a/browser/components/contextualidentity/test/browser/browser_serviceworkers.js b/browser/components/contextualidentity/test/browser/browser_serviceworkers.js
new file mode 100644
index 0000000000..4f42c55d73
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_serviceworkers.js
@@ -0,0 +1,121 @@
+let swm = Cc["@mozilla.org/serviceworkers/manager;1"].getService(
+  Ci.nsIServiceWorkerManager
+);
+
+const BASE_ORIGIN = "https://example.com";
+const URI =
+  BASE_ORIGIN +
+  "/browser/browser/components/contextualidentity/test/browser/serviceworker.html";
+const NUM_USER_CONTEXTS = 3;
+
+// opens `uri' in a new tab with the provided userContextId and focuses it.
+// returns the newly opened tab
+function openTabInUserContext(uri, userContextId) {
+  // open the tab in the correct userContextId
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // select tab and make sure its browser is focused
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  return tab;
+}
+
+add_setup(async function () {
+  // make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["dom.ipc.processCount", 1],
+    ],
+  });
+});
+
+let infos = [];
+
+add_task(async function test() {
+  // Open the same URI in multiple user contexts, and make sure we have a
+  // separate service worker in each of the contexts
+  for (
+    let userContextId = 0;
+    userContextId < NUM_USER_CONTEXTS;
+    userContextId++
+  ) {
+    // Open a tab in given user contexts
+    let tab = openTabInUserContext(URI, userContextId);
+
+    // wait for tab load
+    await BrowserTestUtils.browserLoaded(gBrowser.getBrowserForTab(tab));
+
+    // remove the tab
+    gBrowser.removeTab(tab);
+  }
+
+  if (!allRegistered()) {
+    await promiseAllRegistered();
+  }
+  ok(true, "all service workers are registered");
+
+  // Unregistered all service workers added in this test
+  for (let info of infos) {
+    await promiseUnregister(info);
+  }
+});
+
+function allRegistered() {
+  let results = [];
+  let registrations = swm.getAllRegistrations();
+  for (let i = 0; i < registrations.length; i++) {
+    let info = registrations.queryElementAt(
+      i,
+      Ci.nsIServiceWorkerRegistrationInfo
+    );
+    let principal = info.principal;
+    if (principal.originNoSuffix === BASE_ORIGIN) {
+      results[principal.userContextId] = true;
+      infos[principal.userContextId] = info;
+    }
+  }
+  for (
+    let userContextId = 0;
+    userContextId < NUM_USER_CONTEXTS;
+    userContextId++
+  ) {
+    if (!results[userContextId]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function promiseAllRegistered() {
+  return new Promise(function (resolve) {
+    let listener = {
+      onRegister() {
+        if (allRegistered()) {
+          swm.removeListener(listener);
+          resolve();
+        }
+      },
+    };
+    swm.addListener(listener);
+  });
+}
+
+function promiseUnregister(info) {
+  return new Promise(function (resolve) {
+    swm.unregister(
+      info.principal,
+      {
+        unregisterSucceeded(aState) {
+          ok(aState, "ServiceWorkerRegistration exists");
+          resolve();
+        },
+        unregisterFailed(aState) {
+          ok(false, "unregister should succeed");
+        },
+      },
+      info.scope
+    );
+  });
+}
diff --git a/browser/components/contextualidentity/test/browser/browser_tab_color_update.js b/browser/components/contextualidentity/test/browser/browser_tab_color_update.js
new file mode 100644
index 0000000000..e4ae649d0a
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_tab_color_update.js
@@ -0,0 +1,42 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+async function openTabInUserContext(uri, userContextId) {
+  // open the tab in the correct userContextId
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser, false, uri);
+  return { tab };
+}
+
+/**
+ * When a container's colour changes, the tab colour should update.
+ */
+add_task(async function test_tab_color_updates() {
+  const kId = 2;
+  let { tab } = await openTabInUserContext("https://example.com/", kId);
+  let contextIdInfo = ContextualIdentityService.getPublicIdentityFromId(kId);
+  ok(
+    tab.classList.contains("identity-color-" + contextIdInfo.color),
+    `Should use color ${contextIdInfo.color} for tab`
+  );
+
+  // The container has a localized name which isn't in the contextIdInfo object.
+  // We need to pass a valid name for the update to go through, so make one up.
+  let name = "Foo";
+  // Don't hardcode a colour so changes in defaults won't cause the following
+  // test to fail or be a no-op.
+  let otherColor = contextIdInfo.color == "green" ? "orange" : "green";
+  registerCleanupFunction(() => ContextualIdentityService.resetDefault());
+  ContextualIdentityService.update(kId, name, contextIdInfo.icon, otherColor);
+
+  ok(
+    tab.classList.contains("identity-color-" + otherColor),
+    `Should use color ${otherColor} for tab after update`
+  );
+
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_usercontext.js b/browser/components/contextualidentity/test/browser/browser_usercontext.js
new file mode 100644
index 0000000000..dafdf95394
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_usercontext.js
@@ -0,0 +1,88 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const USER_CONTEXTS = ["default", "personal", "work"];
+
+const BASE_URI =
+  "http://mochi.test:8888/browser/browser/components/" +
+  "contextualidentity/test/browser/file_reflect_cookie_into_title.html";
+
+// opens `uri' in a new tab with the provided userContextId and focuses it.
+// returns the newly opened tab
+function openTabInUserContext(uri, userContextId) {
+  // open the tab in the correct userContextId
+  let tab = BrowserTestUtils.addTab(gBrowser, uri, { userContextId });
+
+  // select tab and make sure its browser is focused
+  gBrowser.selectedTab = tab;
+  tab.ownerGlobal.focus();
+
+  return tab;
+}
+
+add_setup(async function () {
+  // make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["dom.ipc.processCount", 1],
+    ],
+  });
+});
+
+add_task(async function test() {
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // load the page in 3 different contexts and set a cookie
+    // which should only be visible in that context
+    let cookie = USER_CONTEXTS[userContextId];
+
+    // open our tab in the given user context
+    let tab = openTabInUserContext(BASE_URI + "?" + cookie, userContextId);
+
+    // wait for tab load
+    await BrowserTestUtils.browserLoaded(gBrowser.getBrowserForTab(tab));
+
+    // remove the tab
+    gBrowser.removeTab(tab);
+  }
+
+  {
+    // Set a cookie in a different context so we can detect if that affects
+    // cross-context properly. If we don't do that, we get an UNEXPECTED-PASS
+    // for the localStorage case for the last tab we set.
+    let tab = openTabInUserContext(BASE_URI + "?foo", 9999);
+    await BrowserTestUtils.browserLoaded(gBrowser.getBrowserForTab(tab));
+    gBrowser.removeTab(tab);
+  }
+
+  for (let userContextId of Object.keys(USER_CONTEXTS)) {
+    // Load the page without setting the cookie this time
+    let expectedContext = USER_CONTEXTS[userContextId];
+
+    let tab = openTabInUserContext(BASE_URI, userContextId);
+
+    // wait for load
+    let browser = gBrowser.getBrowserForTab(tab);
+    await BrowserTestUtils.browserLoaded(browser);
+
+    // get the title
+    let title = browser.contentTitle.trim().split("|");
+
+    // check each item in the title and validate it meets expectatations
+    for (let part of title) {
+      let [storageMethodName, value] = part.split("=");
+      is(
+        value,
+        expectedContext,
+        "the title reflects the expected contextual identity of " +
+          expectedContext +
+          " for method " +
+          storageMethodName +
+          ": " +
+          value
+      );
+    }
+
+    gBrowser.removeTab(tab);
+  }
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_usercontextid_new_window.js b/browser/components/contextualidentity/test/browser/browser_usercontextid_new_window.js
new file mode 100644
index 0000000000..5fd4c6f3c2
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_usercontextid_new_window.js
@@ -0,0 +1,93 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// Test that the content of new browser windows have the expected
+// userContextId when it passed as the window arguments.
+
+const TEST_URI =
+  getRootDirectory(gTestPath).replace(
+    "chrome://mochitests/content",
+    "http://mochi.test:8888"
+  ) + "empty_file.html";
+
+function openWindowWithUserContextId(userContextId, isPrivate) {
+  let flags = "chrome,dialog=no,all";
+  if (isPrivate) {
+    flags += ",private";
+  }
+
+  let args = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+
+  let urlSupports = Cc["@mozilla.org/supports-string;1"].createInstance(
+    Ci.nsISupportsString
+  );
+  urlSupports.data = TEST_URI;
+  args.appendElement(urlSupports);
+
+  args.appendElement(null);
+  args.appendElement(null);
+  args.appendElement(null);
+  args.appendElement(null);
+
+  let userContextIdSupports = Cc[
+    "@mozilla.org/supports-PRUint32;1"
+  ].createInstance(Ci.nsISupportsPRUint32);
+  userContextIdSupports.data = userContextId;
+  args.appendElement(userContextIdSupports);
+
+  args.appendElement(Services.scriptSecurityManager.getSystemPrincipal());
+  args.appendElement(Services.scriptSecurityManager.getSystemPrincipal());
+  args.appendElement(Services.scriptSecurityManager.getSystemPrincipal());
+
+  let windowPromise = BrowserTestUtils.waitForNewWindow({ url: TEST_URI });
+  Services.ww.openWindow(
+    null,
+    AppConstants.BROWSER_CHROME_URL,
+    "_blank",
+    flags,
+    args
+  );
+  return windowPromise;
+}
+
+add_setup(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [["privacy.userContext.enabled", true]],
+  });
+});
+
+add_task(async function test_new_window() {
+  let win = await openWindowWithUserContextId(1, false);
+
+  await SpecialPowers.spawn(win.gBrowser.selectedBrowser, [TEST_URI], url => {
+    Assert.equal(content.document.URL, url, "expected document URL");
+    let { originAttributes } = content.document.nodePrincipal;
+    Assert.equal(originAttributes.userContextId, 1, "expected userContextId");
+    Assert.equal(
+      originAttributes.privateBrowsingId,
+      0,
+      "expected non-private context"
+    );
+  });
+
+  await BrowserTestUtils.closeWindow(win);
+});
+
+add_task(async function test_new_private_window() {
+  let win = await openWindowWithUserContextId(1, true);
+
+  await SpecialPowers.spawn(win.gBrowser.selectedBrowser, [TEST_URI], url => {
+    Assert.equal(content.document.URL, url, "expected document URL");
+    let { originAttributes } = content.document.nodePrincipal;
+    Assert.equal(originAttributes.userContextId, 1, "expected userContextId");
+    Assert.equal(
+      originAttributes.privateBrowsingId,
+      1,
+      "expected private context"
+    );
+  });
+
+  await BrowserTestUtils.closeWindow(win);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_usercontextid_tabdrop.js b/browser/components/contextualidentity/test/browser/browser_usercontextid_tabdrop.js
new file mode 100644
index 0000000000..bddf39eb87
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_usercontextid_tabdrop.js
@@ -0,0 +1,181 @@
+"use strict";
+
+let EventUtils = {};
+Services.scriptloader.loadSubScript(
+  "chrome://mochikit/content/tests/SimpleTest/EventUtils.js",
+  EventUtils
+);
+
+/**
+ * Dragging an URL to a tab without userContextId set.
+ */
+add_task(async function () {
+  let tab = BrowserTestUtils.addTab(gBrowser, "http://example.com/");
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  let awaitDrop = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "drop");
+  let newTabPromise = BrowserTestUtils.waitForNewTab(
+    gBrowser,
+    "http://test1.example.com/",
+    true
+  );
+
+  // A drop type of "link" onto an existing tab would normally trigger a
+  // load in that same tab, but tabbrowser code in _getDragTargetTab treats
+  // drops on the outer edges of a tab differently (loading a new tab
+  // instead). Make events created by synthesizeDrop have all of their
+  // coordinates set to 0 (screenX/screenY), so they're treated as drops
+  // on the outer edge of the tab, thus they open new tabs.
+  let event = {
+    clientX: 0,
+    clientY: 0,
+    screenX: 0,
+    screenY: 0,
+  };
+  EventUtils.synthesizeDrop(
+    tab,
+    tab,
+    [[{ type: "text/plain", data: "http://test1.example.com/" }]],
+    "link",
+    window,
+    undefined,
+    event
+  );
+
+  await awaitDrop;
+
+  let tab2 = await newTabPromise;
+  Assert.ok(
+    !tab2.hasAttribute("usercontextid"),
+    "Tab shouldn't have usercontextid attribute"
+  );
+
+  await SpecialPowers.spawn(tab2.linkedBrowser, [], async function () {
+    Assert.equal(content.document.documentURI, "http://test1.example.com/");
+    Assert.equal(
+      content.document.nodePrincipal.originAttributes.userContextId,
+      0
+    );
+
+    // referrer is empty when urls are dragged to new or existing tabs.
+    // If this changes in the future, it would be okay to send the referrer
+    // in this case because we are creating a new tab with the default
+    // usercontextid as the original tab.
+    Assert.equal(content.document.referrer, "", "referrer should be empty");
+  });
+
+  BrowserTestUtils.removeTab(tab);
+  BrowserTestUtils.removeTab(tab2);
+});
+
+/**
+ * When dragging an URL to a new tab, the new tab should have the same
+ * userContextId as the original tab.
+ */
+add_task(async function () {
+  let tab = BrowserTestUtils.addTab(gBrowser, "http://example.com/", {
+    userContextId: 1,
+  });
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  let awaitDrop = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "drop");
+  let newTabPromise = BrowserTestUtils.waitForNewTab(
+    gBrowser,
+    "http://test1.example.com/",
+    true
+  );
+
+  // A drop type of "link" onto an existing tab would normally trigger a
+  // load in that same tab, but tabbrowser code in _getDragTargetTab treats
+  // drops on the outer edges of a tab differently (loading a new tab
+  // instead). Make events created by synthesizeDrop have all of their
+  // coordinates set to 0 (screenX/screenY), so they're treated as drops
+  // on the outer edge of the tab, thus they open new tabs.
+  let event = {
+    clientX: 0,
+    clientY: 0,
+    screenX: 0,
+    screenY: 0,
+  };
+  EventUtils.synthesizeDrop(
+    tab,
+    tab,
+    [[{ type: "text/plain", data: "http://test1.example.com/" }]],
+    "link",
+    window,
+    undefined,
+    event
+  );
+
+  await awaitDrop;
+
+  let tab2 = await newTabPromise;
+  Assert.equal(tab2.getAttribute("usercontextid"), 1);
+
+  await SpecialPowers.spawn(tab2.linkedBrowser, [], async function () {
+    Assert.equal(content.document.documentURI, "http://test1.example.com/");
+    Assert.equal(
+      content.document.nodePrincipal.originAttributes.userContextId,
+      1
+    );
+
+    // referrer is empty when urls are dragged to new or existing tabs.
+    // If this changes in the future, it would be okay to send the referrer
+    // in this case because we are creating a new tab with the same
+    // usercontextid as the original tab.
+    Assert.equal(content.document.referrer, "", "referrer should be empty");
+  });
+
+  BrowserTestUtils.removeTab(tab);
+  BrowserTestUtils.removeTab(tab2);
+});
+
+/**
+ * When dragging a URL from one tab or link on a tab to an existing tab, the
+ * existing tab should not change its userContextId.
+ * Ex: if you drag a link from tab 1 with userContext 1 to tab 2 with
+ * userContext 2, the link will open in tab 2 with userContext 2.
+ */
+add_task(async function () {
+  let tab = BrowserTestUtils.addTab(gBrowser, "http://example.com/", {
+    userContextId: 1,
+  });
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  let tab2 = BrowserTestUtils.addTab(gBrowser, "http://example.org/", {
+    userContextId: 2,
+  });
+  await BrowserTestUtils.browserLoaded(tab2.linkedBrowser);
+
+  let awaitDrop = BrowserTestUtils.waitForEvent(gBrowser.tabContainer, "drop");
+
+  EventUtils.synthesizeDrop(
+    tab,
+    tab2,
+    [[{ type: "text/plain", data: "http://test1.example.com/" }]],
+    "link",
+    window
+  );
+
+  await awaitDrop;
+  Assert.equal(tab2.getAttribute("usercontextid"), 2);
+
+  await BrowserTestUtils.browserLoaded(tab2.linkedBrowser);
+
+  await SpecialPowers.spawn(tab2.linkedBrowser, [], async function () {
+    Assert.equal(content.document.documentURI, "http://test1.example.com/");
+    Assert.equal(
+      content.document.nodePrincipal.originAttributes.userContextId,
+      2
+    );
+
+    // referrer is empty when urls are dragged to new or existing tabs.
+    // If this changes in the future, we should ensure that we are not sending
+    // a referrer for this case!  When opening links across user contexts, we
+    // don't want the referrer to follow the user from one context to another.
+    Assert.equal(content.document.referrer, "", "referrer should be empty");
+  });
+
+  BrowserTestUtils.removeTab(tab);
+  BrowserTestUtils.removeTab(tab2);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_windowName.js b/browser/components/contextualidentity/test/browser/browser_windowName.js
new file mode 100644
index 0000000000..5ba2cc0e0a
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_windowName.js
@@ -0,0 +1,80 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const USER_CONTEXTS = ["default", "personal", "work"];
+
+const BASE_URI =
+  "http://mochi.test:8888/browser/browser/components/" +
+  "contextualidentity/test/browser/empty_file.html";
+
+add_setup(async function () {
+  // make sure userContext is enabled.
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["browser.link.open_newwindow", 3],
+    ],
+  });
+});
+
+add_task(async function test() {
+  info("Creating first tab...");
+  let tab1 = BrowserTestUtils.addTab(gBrowser, BASE_URI + "?old", {
+    userContextId: 1,
+  });
+  let browser1 = gBrowser.getBrowserForTab(tab1);
+  await BrowserTestUtils.browserLoaded(browser1);
+  await SpecialPowers.spawn(browser1, [], function (opts) {
+    content.window.name = "tab-1";
+  });
+
+  info("Creating second tab...");
+  let tab2 = BrowserTestUtils.addTab(gBrowser, BASE_URI + "?old", {
+    userContextId: 2,
+  });
+  let browser2 = gBrowser.getBrowserForTab(tab2);
+  await BrowserTestUtils.browserLoaded(browser2);
+  await SpecialPowers.spawn(browser2, [], function (opts) {
+    content.window.name = "tab-2";
+  });
+
+  // Let's try to open a window from tab1 with a name 'tab-2'.
+  info("Opening a window from the first tab...");
+  await SpecialPowers.spawn(
+    browser1,
+    [{ url: BASE_URI + "?new" }],
+    async function (opts) {
+      await new content.window.wrappedJSObject.Promise(resolve => {
+        let w = content.window.wrappedJSObject.open(opts.url, "tab-2");
+        w.onload = function () {
+          resolve();
+        };
+      });
+    }
+  );
+
+  is(browser1.contentTitle, "?old", "Tab1 title must be 'old'");
+  is(browser1.contentPrincipal.userContextId, 1, "Tab1 UCI must be 1");
+
+  is(browser2.contentTitle, "?old", "Tab2 title must be 'old'");
+  is(browser2.contentPrincipal.userContextId, 2, "Tab2 UCI must be 2");
+
+  let found = false;
+  for (let i = 0; i < gBrowser.tabs.length; ++i) {
+    let tab = gBrowser.tabs[i];
+    let browser = gBrowser.getBrowserForTab(tab);
+    if (browser.contentTitle == "?new") {
+      is(browser.contentPrincipal.userContextId, 1, "Tab3 UCI must be 1");
+      isnot(browser, browser1, "Tab3 is not browser 1");
+      isnot(browser, browser2, "Tab3 is not browser 2");
+      gBrowser.removeTab(tab);
+      found = true;
+      break;
+    }
+  }
+
+  ok(found, "We have tab3");
+
+  gBrowser.removeTab(tab1);
+  gBrowser.removeTab(tab2);
+});
diff --git a/browser/components/contextualidentity/test/browser/browser_windowOpen.js b/browser/components/contextualidentity/test/browser/browser_windowOpen.js
new file mode 100644
index 0000000000..d550b03ed8
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/browser_windowOpen.js
@@ -0,0 +1,41 @@
+"use strict";
+
+// Here we want to test that a new opened window shows the same UI of the
+// parent one if this has been loaded from a particular container.
+
+const BASE_URI =
+  "http://mochi.test:8888/browser/browser/components/" +
+  "contextualidentity/test/browser/empty_file.html";
+
+add_setup(async function () {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["privacy.userContext.enabled", true],
+      ["browser.link.open_newwindow", 2],
+    ],
+  });
+});
+
+add_task(async function test() {
+  info("Creating a tab with UCI = 1...");
+  let tab = BrowserTestUtils.addTab(gBrowser, BASE_URI, { userContextId: 1 });
+  is(tab.getAttribute("usercontextid"), "1", "New tab has UCI equal 1");
+
+  let browser = gBrowser.getBrowserForTab(tab);
+  await BrowserTestUtils.browserLoaded(browser);
+
+  info("Opening a new window from this tab...");
+  let newWinPromise = BrowserTestUtils.waitForNewWindow({ url: BASE_URI });
+  SpecialPowers.spawn(browser, [BASE_URI], function (url) {
+    content.window.newWindow = content.window.open(url, "_blank");
+  });
+
+  let newWin = await newWinPromise;
+  let newTab = newWin.gBrowser.selectedTab;
+
+  is(newTab.getAttribute("usercontextid"), "1", "New tab has UCI equal 1");
+
+  info("Closing the new window and tab...");
+  await BrowserTestUtils.closeWindow(newWin);
+  BrowserTestUtils.removeTab(tab);
+});
diff --git a/browser/components/contextualidentity/test/browser/empty_file.html b/browser/components/contextualidentity/test/browser/empty_file.html
new file mode 100644
index 0000000000..c6d11dcd57
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/empty_file.html
@@ -0,0 +1,5 @@
+<html><body>
+<script>
+document.title = window.location.search;
+</script>
+</body></html>
diff --git a/browser/components/contextualidentity/test/browser/favicon-normal32.png b/browser/components/contextualidentity/test/browser/favicon-normal32.png
new file mode 100644
index 0000000000..5535363c94
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/favicon-normal32.png
diff --git a/browser/components/contextualidentity/test/browser/file_reflect_cookie_into_title.html b/browser/components/contextualidentity/test/browser/file_reflect_cookie_into_title.html
new file mode 100644
index 0000000000..cc05453507
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/file_reflect_cookie_into_title.html
@@ -0,0 +1,22 @@
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>title not set</title>
+    <script>
+      // if we have a query string, use it to set the cookie and localStorage
+      if (window.location.search.length) {
+        let context_name = window.location.search.substr(1);
+        document.cookie = "userContextId=" + context_name;
+        localStorage.setItem("userContext", context_name);
+      }
+
+      // get the cookie
+      let [name, val] = document.cookie.split("=");
+
+      // set the title to reflect the cookie and local storage values we find
+      document.title = "cookie=" + val + "|"
+                       + "local=" + localStorage.getItem("userContext");
+    </script>
+  </head>
+  <body></body>
+</html>
diff --git a/browser/components/contextualidentity/test/browser/file_set_storages.html b/browser/components/contextualidentity/test/browser/file_set_storages.html
new file mode 100644
index 0000000000..96c46f9062
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/file_set_storages.html
@@ -0,0 +1,41 @@
+<html>
+  <head>
+    <meta charset="UTF-8">
+    <title>Bug 1238183</title>
+  </head>
+  <body>
+    <script type="application/javascript">
+      "use strict";
+
+      // if we have a query string, use it to set storages
+      if (window.location.search.length) {
+        let context_name = window.location.search.substr(1);
+        localStorage.setItem("userContext", context_name);
+        sessionStorage.setItem("userContext", context_name);
+
+        let request = indexedDB.open("idb", 1);
+
+        request.onerror = function() {
+          throw new Error("error opening db connection");
+        };
+
+        request.onupgradeneeded = event => {
+          let db = event.target.result;
+          let store = db.createObjectStore("obj", { keyPath: "id" });
+          store.createIndex("userContext", "userContext", { unique: false });
+        };
+
+        request.onsuccess = event => {
+          let db = request.result;
+          let transaction = db.transaction(["obj"], "readwrite");
+          let store = transaction.objectStore("obj");
+          store.add({id: 1, userContext: context_name});
+
+          transaction.oncomplete = () => {
+            db.close();
+          };
+        };
+      }
+    </script>
+  </body>
+</html>
diff --git a/browser/components/contextualidentity/test/browser/head.js b/browser/components/contextualidentity/test/browser/head.js
new file mode 100644
index 0000000000..b5bf451d25
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/head.js
@@ -0,0 +1,48 @@
+async function openTabMenuFor(tab) {
+  let tabMenu = tab.ownerDocument.getElementById("tabContextMenu");
+
+  let tabMenuShown = BrowserTestUtils.waitForEvent(tabMenu, "popupshown");
+  EventUtils.synthesizeMouseAtCenter(
+    tab,
+    { type: "contextmenu" },
+    tab.ownerGlobal
+  );
+  await tabMenuShown;
+
+  return tabMenu;
+}
+
+async function openReopenMenuForTab(tab) {
+  await openTabMenuFor(tab);
+
+  let reopenItem = tab.ownerDocument.getElementById(
+    "context_reopenInContainer"
+  );
+  ok(!reopenItem.hidden, "Reopen in Container item should be shown");
+
+  const menuPopup = reopenItem.menupopup;
+  const menuPopupPromise = BrowserTestUtils.waitForEvent(
+    menuPopup,
+    "popupshown"
+  );
+  info(`About to open a popup`);
+  reopenItem.openMenu(true);
+  info(`Waiting for the menu popup promise`);
+  await menuPopupPromise;
+  info(`Awaited menu popup promise`);
+  return menuPopup;
+}
+
+function openTabInContainer(gBrowser, url, reopenMenu, id) {
+  let tabPromise = BrowserTestUtils.waitForNewTab(gBrowser, url, true);
+  let menuitem = reopenMenu.querySelector(
+    `menuitem[data-usercontextid="${id}"]`
+  );
+  info(`about to activate item`);
+  reopenMenu.activateItem(menuitem);
+  return tabPromise;
+}
+
+function loadTestSubscript(filePath) {
+  Services.scriptloader.loadSubScript(new URL(filePath, gTestPath).href, this);
+}
diff --git a/browser/components/contextualidentity/test/browser/saveLink.sjs b/browser/components/contextualidentity/test/browser/saveLink.sjs
new file mode 100644
index 0000000000..bbdb756364
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/saveLink.sjs
@@ -0,0 +1,55 @@
+const HTTP_ORIGIN = "http://example.com";
+const HTTPS_ORIGIN = "https://example.com";
+const URI_PATH =
+  "/browser/browser/components/contextualidentity/test/browser/saveLink.sjs";
+
+Cu.importGlobalProperties(["URLSearchParams"]);
+
+function handleRequest(aRequest, aResponse) {
+  var params = new URLSearchParams(aRequest.queryString);
+
+  // This is the first request, where we set the cookie.
+  if (params.has("UCI")) {
+    aResponse.setStatusLine(aRequest.httpVersion, 200);
+    aResponse.setHeader("Set-Cookie", "UCI=" + params.get("UCI"));
+    aResponse.write(
+      "<html><body><a href='" +
+        HTTPS_ORIGIN +
+        URI_PATH +
+        "?redirect=1' id='fff'>this is a link</a></body></html>"
+    );
+    return;
+  }
+
+  // Second request. This is the save-as content, but we make a redirect to see
+  // if we are able to follow it.
+  if (params.has("redirect")) {
+    aResponse.setStatusLine(aRequest.httpVersion, 302, "Found");
+    aResponse.setHeader(
+      "Location",
+      HTTP_ORIGIN + URI_PATH + "?download=1",
+      false
+    );
+    aResponse.write("Redirect!");
+    return;
+  }
+
+  // This is the 3rd request where we offer the content to be saved.
+  if (params.has("download")) {
+    setState("downloadUCI", aRequest.getHeader("Cookie"));
+    aResponse.setStatusLine(aRequest.httpVersion, 200);
+    aResponse.write("All Good!");
+    return;
+  }
+
+  // This is the last request to check that the download happened with the correct cookie
+  if (params.has("result")) {
+    aResponse.setStatusLine(aRequest.httpVersion, 200);
+    aResponse.write("Result:" + getState("downloadUCI"));
+    return;
+  }
+
+  // We should not be here!
+  aResponse.setStatusLine(aRequest.httpVersion, 500);
+  aResponse.write("ERROR!!!");
+}
diff --git a/browser/components/contextualidentity/test/browser/serviceworker.html b/browser/components/contextualidentity/test/browser/serviceworker.html
new file mode 100644
index 0000000000..11edd001a2
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/serviceworker.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <script>
+       navigator.serviceWorker.register("worker.js");
+    </script>
+  </head>
+  <body>
+    This is a test page.
+  </body>
+<html>
diff --git a/browser/components/contextualidentity/test/browser/worker.js b/browser/components/contextualidentity/test/browser/worker.js
new file mode 100644
index 0000000000..2aba167d18
--- /dev/null
+++ b/browser/components/contextualidentity/test/browser/worker.js
@@ -0,0 +1 @@
+// empty worker, always succeed!
author	Daniel Baumann <daniel.baumann@progress-linux.org>	2024-04-07 19:33:14 +0000
committer	Daniel Baumann <daniel.baumann@progress-linux.org>	2024-04-07 19:33:14 +0000
commit	36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree	105e8c98ddea1c1e4784a60a5a6410fa416be2de /browser/components/contextualidentity/test
parent	Initial commit. (diff)
download	firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip