Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

12 files changed, 2598 insertions, 0 deletions

diff --git a/comm/mail/components/preferences/test/browser/browser.ini b/comm/mail/components/preferences/test/browser/browser.ini
new file mode 100644
index 0000000000..44b7d97a31
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/browser.ini
@@ -0,0 +1,20 @@
+[DEFAULT]
+head = head.js
+prefs =
+  mail.provider.suppress_dialog_on_startup=true
+  mail.spotlight.firstRunDone=true
+  mail.winsearch.firstRunDone=true
+  mailnews.start_page.override_url=about:blank
+  mailnews.start_page.url=about:blank
+subsuite = thunderbird
+
+[browser_chat.js]
+[browser_cloudfile.js]
+support-files = files/icon.svg files/management.html
+[browser_compose.js]
+[browser_general.js]
+[browser_openPreferences.js]
+[browser_privacy.js]
+[browser_sync.js]
+skip-if = !nightly_build
+support-files = files/avatar.png
diff --git a/comm/mail/components/preferences/test/browser/browser_chat.js b/comm/mail/components/preferences/test/browser/browser_chat.js
new file mode 100644
index 0000000000..009f2a9211
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/browser_chat.js
@@ -0,0 +1,74 @@
+/* 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/. */
+
+add_task(async () => {
+  await testCheckboxes(
+    "paneChat",
+    "chatPaneCategory",
+    {
+      checkboxID: "reportIdle",
+      pref: "messenger.status.reportIdle",
+      enabledElements: ["#autoAway", "#timeBeforeAway"],
+    },
+    {
+      checkboxID: "sendTyping",
+      pref: "purple.conversations.im.send_typing",
+    },
+    {
+      checkboxID: "desktopChatNotifications",
+      pref: "mail.chat.show_desktop_notifications",
+    },
+    {
+      checkboxID: "getAttention",
+      pref: "messenger.options.getAttentionOnNewMessages",
+    },
+    {
+      checkboxID: "chatNotification",
+      pref: "mail.chat.play_sound",
+      enabledElements: ["#chatSoundType radio"],
+    }
+  );
+
+  Services.prefs.setBoolPref("messenger.status.reportIdle", true);
+  await testCheckboxes("paneChat", "chatPaneCategory", {
+    checkboxID: "autoAway",
+    pref: "messenger.status.awayWhenIdle",
+    enabledElements: ["#defaultIdleAwayMessage"],
+  });
+
+  Services.prefs.setBoolPref("mail.chat.play_sound", true);
+  await testRadioButtons("paneChat", "chatPaneCategory", {
+    pref: "mail.chat.play_sound.type",
+    states: [
+      {
+        id: "chatSoundSystemSound",
+        prefValue: 0,
+      },
+      {
+        id: "chatSoundCustom",
+        prefValue: 1,
+        enabledElements: ["#chatSoundUrlLocation", "#browseForChatSound"],
+      },
+    ],
+  });
+});
+
+add_task(async function testMessageStylePreview() {
+  await openNewPrefsTab("paneChat", "chatPaneCategory");
+  const conversationLoad = TestUtils.topicObserved("conversation-loaded");
+  const [subject] = await conversationLoad;
+  do {
+    await BrowserTestUtils.waitForEvent(subject, "MessagesDisplayed");
+  } while (subject.getPendingMessagesCount() > 0);
+  const messageParent = subject.contentChatNode;
+  let message = messageParent.firstElementChild;
+  const messages = new Set();
+  while (message) {
+    ok(message._originalMsg);
+    messages.add(message._originalMsg);
+    message = message.nextElementSibling;
+  }
+  is(messages.size, 3, "All 3 messages displayed");
+  await closePrefsTab();
+});
diff --git a/comm/mail/components/preferences/test/browser/browser_cloudfile.js b/comm/mail/components/preferences/test/browser/browser_cloudfile.js
new file mode 100644
index 0000000000..9f395f9ab8
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/browser_cloudfile.js
@@ -0,0 +1,796 @@
+/* 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/. */
+
+/* eslint-env webextensions */
+
+let { cloudFileAccounts } = ChromeUtils.import(
+  "resource:///modules/cloudFileAccounts.jsm"
+);
+let { MockRegistrar } = ChromeUtils.importESModule(
+  "resource://testing-common/MockRegistrar.sys.mjs"
+);
+
+function ManagementScript() {
+  browser.test.onMessage.addListener((message, assertMessage, browserStyle) => {
+    if (message !== "check-style") {
+      return;
+    }
+    function verifyButton(buttonElement, expected) {
+      let buttonStyle = window.getComputedStyle(buttonElement);
+      let buttonBackgroundColor = buttonStyle.backgroundColor;
+      if (browserStyle && expected.hasBrowserStyleClass) {
+        browser.test.assertEq(
+          "rgb(9, 150, 248)",
+          buttonBackgroundColor,
+          assertMessage
+        );
+      } else {
+        browser.test.assertTrue(
+          buttonBackgroundColor !== "rgb(9, 150, 248)",
+          assertMessage
+        );
+      }
+    }
+
+    function verifyCheckboxOrRadio(element, expected) {
+      let style = window.getComputedStyle(element);
+      let styledBackground = element.checked
+        ? "rgb(9, 150, 248)"
+        : "rgb(255, 255, 255)";
+      if (browserStyle && expected.hasBrowserStyleClass) {
+        browser.test.assertEq(
+          styledBackground,
+          style.backgroundColor,
+          assertMessage
+        );
+      } else {
+        browser.test.assertTrue(
+          style.backgroundColor != styledBackground,
+          assertMessage
+        );
+      }
+    }
+
+    let normalButton = document.getElementById("normalButton");
+    let browserStyleButton = document.getElementById("browserStyleButton");
+    verifyButton(normalButton, { hasBrowserStyleClass: false });
+    verifyButton(browserStyleButton, { hasBrowserStyleClass: true });
+
+    let normalCheckbox1 = document.getElementById("normalCheckbox1");
+    let normalCheckbox2 = document.getElementById("normalCheckbox2");
+    let browserStyleCheckbox = document.getElementById("browserStyleCheckbox");
+    verifyCheckboxOrRadio(normalCheckbox1, { hasBrowserStyleClass: false });
+    verifyCheckboxOrRadio(normalCheckbox2, { hasBrowserStyleClass: false });
+    verifyCheckboxOrRadio(browserStyleCheckbox, {
+      hasBrowserStyleClass: true,
+    });
+
+    let normalRadio1 = document.getElementById("normalRadio1");
+    let normalRadio2 = document.getElementById("normalRadio2");
+    let browserStyleRadio = document.getElementById("browserStyleRadio");
+    verifyCheckboxOrRadio(normalRadio1, { hasBrowserStyleClass: false });
+    verifyCheckboxOrRadio(normalRadio2, { hasBrowserStyleClass: false });
+    verifyCheckboxOrRadio(browserStyleRadio, { hasBrowserStyleClass: true });
+
+    browser.test.notifyPass("management-ui-browser_style");
+  });
+  browser.test.sendMessage("management-ui-ready");
+}
+
+let extension;
+async function startExtension(browser_style) {
+  let cloud_file = {
+    name: "Mochitest",
+    management_url: "management.html",
+  };
+
+  switch (browser_style) {
+    case "true":
+      cloud_file.browser_style = true;
+      break;
+    case "false":
+      cloud_file.browser_style = false;
+      break;
+  }
+
+  extension = ExtensionTestUtils.loadExtension({
+    async background() {
+      browser.test.onMessage.addListener(async message => {
+        if (message != "set-configured") {
+          return;
+        }
+        let accounts = await browser.cloudFile.getAllAccounts();
+        for (let account of accounts) {
+          await browser.cloudFile.updateAccount(account.id, {
+            configured: true,
+          });
+        }
+        browser.test.sendMessage("ready");
+      });
+    },
+    files: {
+      "management.html": `<html>
+        <body>
+          <a id="a" href="https://www.example.com/">Click me!</a>
+          <button id="normalButton" name="button" class="default">Default</button>
+          <button id="browserStyleButton" name="button" class="browser-style default">Default</button>
+
+          <input id="normalCheckbox1" type="checkbox"/>
+          <input id="normalCheckbox2" type="checkbox"/><label>Checkbox</label>
+          <div class="browser-style">
+            <input id="browserStyleCheckbox" type="checkbox"><label for="browserStyleCheckbox">Checkbox</label>
+          </div>
+
+          <input id="normalRadio1" type="radio"/>
+          <input id="normalRadio2" type="radio"/><label>Radio</label>
+          <div class="browser-style">
+            <input id="browserStyleRadio" checked="" type="radio"><label for="browserStyleRadio">Radio</label>
+          </div>
+        </body>
+        <script src="management.js" type="text/javascript"></script>
+      </html>`,
+      "management.js": ManagementScript,
+    },
+    manifest: {
+      cloud_file,
+      applications: { gecko: { id: "cloudfile@mochitest" } },
+    },
+  });
+
+  info("Starting extension");
+  await extension.startup();
+
+  if (accountIsConfigured) {
+    extension.sendMessage("set-configured");
+    await extension.awaitMessage("ready");
+  }
+}
+
+add_task(async () => {
+  // Register a fake provider representing a built-in provider. We don't
+  // currently ship any built-in providers, but if we did, we should check
+  // if they are present before doing this. Built-in providers can be
+  // problematic for artifact builds.
+  cloudFileAccounts.registerProvider("Fake-Test", {
+    displayName: "XYZ Fake",
+    type: "ext-fake@extensions.thunderbird.net",
+  });
+  registerCleanupFunction(() => {
+    cloudFileAccounts.unregisterProvider("Fake-Test");
+  });
+});
+
+let accountIsConfigured = false;
+
+// Mock the prompt service. We're going to be asked if we're sure
+// we want to remove an account, so let's say yes.
+
+/** @implements {nsIPromptService} */
+let mockPromptService = {
+  confirmCount: 0,
+  confirm() {
+    this.confirmCount++;
+    return true;
+  },
+  QueryInterface: ChromeUtils.generateQI(["nsIPromptService"]),
+};
+/** @implements {nsIExternalProtocolService} */
+let mockExternalProtocolService = {
+  _loadedURLs: [],
+  externalProtocolHandlerExists(aProtocolScheme) {},
+  getApplicationDescription(aScheme) {},
+  getProtocolHandlerInfo(aProtocolScheme) {},
+  getProtocolHandlerInfoFromOS(aProtocolScheme, aFound) {},
+  isExposedProtocol(aProtocolScheme) {},
+  loadURI(aURI, aWindowContext) {
+    this._loadedURLs.push(aURI.spec);
+  },
+  setProtocolHandlerDefaults(aHandlerInfo, aOSHandlerExists) {},
+  urlLoaded(aURL) {
+    return this._loadedURLs.includes(aURL);
+  },
+  QueryInterface: ChromeUtils.generateQI(["nsIExternalProtocolService"]),
+};
+
+let originalPromptService = Services.prompt;
+Services.prompt = mockPromptService;
+
+let mockExternalProtocolServiceCID = MockRegistrar.register(
+  "@mozilla.org/uriloader/external-protocol-service;1",
+  mockExternalProtocolService
+);
+
+registerCleanupFunction(() => {
+  Services.prompt = originalPromptService;
+  MockRegistrar.unregister(mockExternalProtocolServiceCID);
+});
+
+add_task(async function addRemoveAccounts() {
+  is(cloudFileAccounts.providers.length, 1);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  // Load the preferences tab.
+
+  let { prefsDocument, prefsWindow } = await openNewPrefsTab(
+    "paneCompose",
+    "compositionAttachmentsCategory"
+  );
+
+  // Check everything is as it should be.
+
+  let accountList = prefsDocument.getElementById("cloudFileView");
+  is(accountList.itemCount, 0);
+
+  let buttonList = prefsDocument.getElementById("addCloudFileAccountButtons");
+  ok(!buttonList.hidden);
+  is(buttonList.childElementCount, 1);
+  is(
+    buttonList.children[0].getAttribute("value"),
+    "ext-fake@extensions.thunderbird.net"
+  );
+
+  let menuButton = prefsDocument.getElementById("addCloudFileAccount");
+  ok(menuButton.hidden);
+  is(menuButton.itemCount, 1);
+  is(
+    menuButton.getItemAtIndex(0).getAttribute("value"),
+    "ext-fake@extensions.thunderbird.net"
+  );
+
+  let removeButton = prefsDocument.getElementById("removeCloudFileAccount");
+  ok(removeButton.disabled);
+
+  let cloudFileDefaultPanel = prefsDocument.getElementById(
+    "cloudFileDefaultPanel"
+  );
+  ok(!cloudFileDefaultPanel.hidden);
+
+  let browserWrapper = prefsDocument.getElementById("cloudFileSettingsWrapper");
+  is(browserWrapper.childElementCount, 0);
+
+  // Register our test provider.
+
+  await startExtension();
+  is(cloudFileAccounts.providers.length, 2);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(buttonList.childElementCount, 2);
+  is(
+    buttonList.children[0].getAttribute("value"),
+    "ext-fake@extensions.thunderbird.net"
+  );
+  is(buttonList.children[1].getAttribute("value"), "ext-cloudfile@mochitest");
+  is(
+    buttonList.children[1].style.listStyleImage,
+    `url("chrome://messenger/content/extension.svg")`
+  );
+
+  is(menuButton.itemCount, 2);
+  is(
+    menuButton.getItemAtIndex(0).getAttribute("value"),
+    "ext-fake@extensions.thunderbird.net"
+  );
+  is(
+    menuButton.getItemAtIndex(1).getAttribute("value"),
+    "ext-cloudfile@mochitest"
+  );
+  is(
+    menuButton.getItemAtIndex(1).getAttribute("image"),
+    "chrome://messenger/content/extension.svg"
+  );
+
+  // Create a new account.
+
+  EventUtils.synthesizeMouseAtCenter(
+    buttonList.children[1],
+    { clickCount: 1 },
+    prefsWindow
+  );
+  is(cloudFileAccounts.accounts.length, 1);
+  is(cloudFileAccounts.configuredAccounts.length, 0);
+
+  let account = cloudFileAccounts.accounts[0];
+  let accountKey = account.accountKey;
+  is(cloudFileAccounts.accounts[0].type, "ext-cloudfile@mochitest");
+
+  // Check prefs were updated.
+
+  is(
+    Services.prefs.getCharPref(
+      `mail.cloud_files.accounts.${accountKey}.displayName`
+    ),
+    "Mochitest"
+  );
+  is(
+    Services.prefs.getCharPref(`mail.cloud_files.accounts.${accountKey}.type`),
+    "ext-cloudfile@mochitest"
+  );
+
+  // Check UI was updated.
+
+  is(accountList.itemCount, 1);
+  is(accountList.selectedIndex, 0);
+  ok(!removeButton.disabled);
+
+  let accountListItem = accountList.selectedItem;
+  is(accountListItem.getAttribute("value"), accountKey);
+  is(
+    accountListItem.querySelector(".typeIcon:not(.configuredWarning)").src,
+    "chrome://messenger/content/extension.svg"
+  );
+  is(accountListItem.querySelector("label").value, "Mochitest");
+  is(accountListItem.querySelector(".configuredWarning").hidden, false);
+
+  ok(cloudFileDefaultPanel.hidden);
+  is(browserWrapper.childElementCount, 1);
+
+  let browser = browserWrapper.firstElementChild;
+  if (
+    browser.webProgress?.isLoadingDocument ||
+    browser.currentURI?.spec == "about:blank"
+  ) {
+    await BrowserTestUtils.browserLoaded(browser);
+  }
+  is(
+    browser.currentURI.pathQueryRef,
+    `/management.html?accountId=${accountKey}`
+  );
+  await extension.awaitMessage("management-ui-ready");
+
+  let tabmail = document.getElementById("tabmail");
+  let tabCount = tabmail.tabInfo.length;
+  BrowserTestUtils.synthesizeMouseAtCenter("a", {}, browser);
+  // It might take a moment to get to the external protocol service.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, 500));
+  ok(
+    mockExternalProtocolService.urlLoaded("https://www.example.com/"),
+    "Link click sent to external protocol service."
+  );
+  is(tabmail.tabInfo.length, tabCount, "No new tab opened");
+
+  // Rename the account.
+
+  EventUtils.synthesizeMouseAtCenter(
+    accountListItem,
+    { clickCount: 1 },
+    prefsWindow
+  );
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(
+    prefsDocument.activeElement.closest("input"),
+    accountListItem.querySelector("input")
+  );
+  ok(accountListItem.querySelector("label").hidden);
+  ok(!accountListItem.querySelector("input").hidden);
+  is(accountListItem.querySelector("input").value, "Mochitest");
+  EventUtils.synthesizeKey("VK_RIGHT", undefined, prefsWindow);
+  EventUtils.synthesizeKey("!", undefined, prefsWindow);
+  EventUtils.synthesizeKey("VK_RETURN", undefined, prefsWindow);
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(prefsDocument.activeElement, accountList);
+  ok(!accountListItem.querySelector("label").hidden);
+  is(accountListItem.querySelector("label").value, "Mochitest!");
+  ok(accountListItem.querySelector("input").hidden);
+  is(
+    Services.prefs.getCharPref(
+      `mail.cloud_files.accounts.${accountKey}.displayName`
+    ),
+    "Mochitest!"
+  );
+
+  // Start to rename the account, but bail out.
+
+  EventUtils.synthesizeMouseAtCenter(
+    accountListItem,
+    { clickCount: 1 },
+    prefsWindow
+  );
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(
+    prefsDocument.activeElement.closest("input"),
+    accountListItem.querySelector("input")
+  );
+  EventUtils.synthesizeKey("O", undefined, prefsWindow);
+  EventUtils.synthesizeKey("o", undefined, prefsWindow);
+  EventUtils.synthesizeKey("p", undefined, prefsWindow);
+  EventUtils.synthesizeKey("s", undefined, prefsWindow);
+  EventUtils.synthesizeKey("VK_ESCAPE", undefined, prefsWindow);
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(prefsDocument.activeElement, accountList);
+  ok(!accountListItem.querySelector("label").hidden);
+  is(accountListItem.querySelector("label").value, "Mochitest!");
+  ok(accountListItem.querySelector("input").hidden);
+  is(
+    Services.prefs.getCharPref(
+      `mail.cloud_files.accounts.${accountKey}.displayName`
+    ),
+    "Mochitest!"
+  );
+
+  // Configure the account.
+
+  account.configured = true;
+  accountIsConfigured = true;
+  cloudFileAccounts.emit("accountConfigured", account);
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(accountListItem.querySelector(".configuredWarning").hidden, true);
+  is(cloudFileAccounts.accounts.length, 1);
+  is(cloudFileAccounts.configuredAccounts.length, 1);
+
+  // Remove the test provider. The list item, button, and browser should disappear.
+
+  info("Stopping extension");
+  await extension.unload();
+  is(cloudFileAccounts.providers.length, 1);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(buttonList.childElementCount, 1);
+  is(
+    buttonList.children[0].getAttribute("value"),
+    "ext-fake@extensions.thunderbird.net"
+  );
+  is(menuButton.itemCount, 1);
+  is(
+    menuButton.getItemAtIndex(0).getAttribute("value"),
+    "ext-fake@extensions.thunderbird.net"
+  );
+  is(accountList.itemCount, 0);
+  ok(!cloudFileDefaultPanel.hidden);
+  is(browserWrapper.childElementCount, 0);
+
+  // Re-add the test provider.
+
+  await startExtension();
+
+  is(cloudFileAccounts.providers.length, 2);
+  is(cloudFileAccounts.accounts.length, 1);
+  is(cloudFileAccounts.configuredAccounts.length, 1);
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(buttonList.childElementCount, 2);
+  is(
+    buttonList.children[0].getAttribute("value"),
+    "ext-fake@extensions.thunderbird.net"
+  );
+  is(buttonList.children[1].getAttribute("value"), "ext-cloudfile@mochitest");
+
+  is(menuButton.itemCount, 2);
+  is(
+    menuButton.getItemAtIndex(0).getAttribute("value"),
+    "ext-fake@extensions.thunderbird.net"
+  );
+  is(
+    menuButton.getItemAtIndex(1).getAttribute("value"),
+    "ext-cloudfile@mochitest"
+  );
+
+  is(accountList.itemCount, 1);
+  is(accountList.selectedIndex, -1);
+  ok(removeButton.disabled);
+
+  accountListItem = accountList.getItemAtIndex(0);
+  is(
+    Services.prefs.getCharPref(
+      `mail.cloud_files.accounts.${accountKey}.displayName`
+    ),
+    "Mochitest!"
+  );
+
+  EventUtils.synthesizeMouseAtCenter(
+    accountList.getItemAtIndex(0),
+    { clickCount: 1 },
+    prefsWindow
+  );
+  ok(!removeButton.disabled);
+  EventUtils.synthesizeMouseAtCenter(
+    removeButton,
+    { clickCount: 1 },
+    prefsWindow
+  );
+  is(mockPromptService.confirmCount, 1);
+
+  ok(
+    !Services.prefs.prefHasUserValue(
+      `mail.cloud_files.accounts.${accountKey}.displayName`
+    )
+  );
+  ok(
+    !Services.prefs.prefHasUserValue(
+      `mail.cloud_files.accounts.${accountKey}.type`
+    )
+  );
+
+  is(cloudFileAccounts.providers.length, 2);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  info("Stopping extension");
+  await extension.unload();
+  is(cloudFileAccounts.providers.length, 1);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  // Close the preferences tab.
+
+  await closePrefsTab();
+});
+
+async function subtestBrowserStyle(assertMessage, expected) {
+  is(cloudFileAccounts.providers.length, 1);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  // Load the preferences tab.
+
+  let { prefsDocument, prefsWindow } = await openNewPrefsTab(
+    "paneCompose",
+    "compositionAttachmentsCategory"
+  );
+
+  // Minimal check everything is as it should be.
+
+  let accountList = prefsDocument.getElementById("cloudFileView");
+  is(accountList.itemCount, 0);
+
+  let buttonList = prefsDocument.getElementById("addCloudFileAccountButtons");
+  ok(!buttonList.hidden);
+
+  let browserWrapper = prefsDocument.getElementById("cloudFileSettingsWrapper");
+  is(browserWrapper.childElementCount, 0);
+
+  // Register our test provider.
+
+  await startExtension(expected.browser_style);
+  is(cloudFileAccounts.providers.length, 2);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  await new Promise(resolve => prefsWindow.requestAnimationFrame(resolve));
+
+  is(buttonList.childElementCount, 2);
+  is(buttonList.children[1].getAttribute("value"), "ext-cloudfile@mochitest");
+
+  // Create a new account.
+
+  EventUtils.synthesizeMouseAtCenter(
+    buttonList.children[1],
+    { clickCount: 1 },
+    prefsWindow
+  );
+  is(cloudFileAccounts.accounts.length, 1);
+  is(cloudFileAccounts.configuredAccounts.length, 0);
+
+  let account = cloudFileAccounts.accounts[0];
+  let accountKey = account.accountKey;
+  is(cloudFileAccounts.accounts[0].type, "ext-cloudfile@mochitest");
+
+  // Minimal check UI was updated.
+
+  is(accountList.itemCount, 1);
+  is(accountList.selectedIndex, 0);
+
+  let accountListItem = accountList.selectedItem;
+  is(accountListItem.getAttribute("value"), accountKey);
+
+  is(browserWrapper.childElementCount, 1);
+  let browser = browserWrapper.firstElementChild;
+  if (
+    browser.webProgress?.isLoadingDocument ||
+    browser.currentURI?.spec == "about:blank"
+  ) {
+    await BrowserTestUtils.browserLoaded(browser);
+  }
+  is(
+    browser.currentURI.pathQueryRef,
+    `/management.html?accountId=${accountKey}`
+  );
+  await extension.awaitMessage("management-ui-ready");
+
+  // Test browser_style
+
+  extension.sendMessage(
+    "check-style",
+    assertMessage,
+    expected.browser_style == "true"
+  );
+  await extension.awaitFinish("management-ui-browser_style");
+
+  // Remove the account
+
+  accountListItem = accountList.getItemAtIndex(0);
+  EventUtils.synthesizeMouseAtCenter(
+    accountList.getItemAtIndex(0),
+    { clickCount: 1 },
+    prefsWindow
+  );
+
+  let removeButton = prefsDocument.getElementById("removeCloudFileAccount");
+  ok(!removeButton.disabled);
+  EventUtils.synthesizeMouseAtCenter(
+    removeButton,
+    { clickCount: 1 },
+    prefsWindow
+  );
+  is(mockPromptService.confirmCount, expected.confirmCount);
+
+  is(cloudFileAccounts.providers.length, 2);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  info("Stopping extension");
+  await extension.unload();
+  is(cloudFileAccounts.providers.length, 1);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  // Close the preferences tab.
+
+  await closePrefsTab();
+}
+
+add_task(async function test_without_setting_browser_style() {
+  await subtestBrowserStyle(
+    "Expected correct style when browser_style is excluded",
+    {
+      confirmCount: 2,
+      browser_style: "default",
+    }
+  );
+});
+
+add_task(async function test_with_browser_style_set_to_true() {
+  await subtestBrowserStyle(
+    "Expected correct style when browser_style is set to `true`",
+    {
+      confirmCount: 3,
+      browser_style: "true",
+    }
+  );
+});
+
+add_task(async function test_with_browser_style_set_to_false() {
+  await subtestBrowserStyle(
+    "Expected no style when browser_style is set to `false`",
+    {
+      confirmCount: 4,
+      browser_style: "false",
+    }
+  );
+});
+
+add_task(async function accountListOverflow() {
+  is(cloudFileAccounts.providers.length, 1);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  // Register our test provider.
+
+  await startExtension();
+
+  is(cloudFileAccounts.providers.length, 2);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  // Load the preferences tab.
+
+  let { prefsDocument, prefsWindow } = await openNewPrefsTab(
+    "paneCompose",
+    "compositionAttachmentsCategory"
+  );
+
+  let accountList = prefsDocument.getElementById("cloudFileView");
+  is(accountList.itemCount, 0);
+
+  let buttonList = prefsDocument.getElementById("addCloudFileAccountButtons");
+  ok(!buttonList.hidden);
+  is(buttonList.childElementCount, 2);
+  is(buttonList.children[0].getAttribute("value"), "ext-cloudfile@mochitest");
+
+  let menuButton = prefsDocument.getElementById("addCloudFileAccount");
+  ok(menuButton.hidden);
+
+  // Add new accounts until the list overflows. The list of buttons should be hidden
+  // and the button with the drop-down should appear.
+
+  let count = 0;
+  do {
+    let readyPromise = extension.awaitMessage("management-ui-ready");
+    EventUtils.synthesizeMouseAtCenter(
+      buttonList.children[0],
+      { clickCount: 1 },
+      prefsWindow
+    );
+    await readyPromise;
+    // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+    await new Promise(r => setTimeout(r, 500));
+    if (buttonList.hidden) {
+      break;
+    }
+  } while (++count < 25);
+
+  ok(count < 24); // If count reaches 25, we have a problem.
+  ok(!menuButton.hidden);
+
+  // Remove the added accounts. The list of buttons should not reappear and the
+  // button with the drop-down should remain.
+
+  let removeButton = prefsDocument.getElementById("removeCloudFileAccount");
+  do {
+    EventUtils.synthesizeMouseAtCenter(
+      accountList.getItemAtIndex(0),
+      { clickCount: 1 },
+      prefsWindow
+    );
+    EventUtils.synthesizeMouseAtCenter(
+      removeButton,
+      { clickCount: 1 },
+      prefsWindow
+    );
+    await new Promise(resolve => setTimeout(resolve));
+  } while (--count > 0);
+
+  ok(buttonList.hidden);
+  ok(!menuButton.hidden);
+
+  // Close the preferences tab.
+
+  await closePrefsTab();
+  info("Stopping extension");
+  await extension.unload();
+  Services.prefs.deleteBranch("mail.cloud_files.accounts");
+});
+
+add_task(async function accountListOrder() {
+  is(cloudFileAccounts.providers.length, 1);
+  is(cloudFileAccounts.accounts.length, 0);
+
+  for (let [key, displayName] of [
+    ["someKey1", "carl's Account"],
+    ["someKey2", "Amber's Account"],
+    ["someKey3", "alice's Account"],
+    ["someKey4", "Bob's Account"],
+  ]) {
+    Services.prefs.setCharPref(
+      `mail.cloud_files.accounts.${key}.type`,
+      "ext-cloudfile@mochitest"
+    );
+    Services.prefs.setCharPref(
+      `mail.cloud_files.accounts.${key}.displayName`,
+      displayName
+    );
+  }
+
+  // Register our test provider.
+
+  await startExtension();
+
+  is(cloudFileAccounts.providers.length, 2);
+  is(cloudFileAccounts.accounts.length, 4);
+
+  let { prefsDocument } = await openNewPrefsTab(
+    "paneCompose",
+    "compositionAttachmentsCategory"
+  );
+
+  let accountList = prefsDocument.getElementById("cloudFileView");
+  is(accountList.itemCount, 4);
+
+  is(accountList.getItemAtIndex(0).value, "someKey3");
+  is(accountList.getItemAtIndex(1).value, "someKey2");
+  is(accountList.getItemAtIndex(2).value, "someKey4");
+  is(accountList.getItemAtIndex(3).value, "someKey1");
+
+  await closePrefsTab();
+  info("Stopping extension");
+  await extension.unload();
+  Services.prefs.deleteBranch("mail.cloud_files.accounts");
+});
diff --git a/comm/mail/components/preferences/test/browser/browser_compose.js b/comm/mail/components/preferences/test/browser/browser_compose.js
new file mode 100644
index 0000000000..ea253cb555
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/browser_compose.js
@@ -0,0 +1,87 @@
+/* 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/. */
+
+add_task(async () => {
+  await testCheckboxes(
+    "paneCompose",
+    "compositionMainCategory",
+    {
+      checkboxID: "addExtension",
+      pref: "mail.forward_add_extension",
+    },
+    {
+      checkboxID: "autoSave",
+      pref: "mail.compose.autosave",
+      enabledElements: ["#autoSaveInterval"],
+    },
+    {
+      checkboxID: "mailWarnOnSendAccelKey",
+      pref: "mail.warn_on_send_accel_key",
+    },
+    {
+      checkboxID: "spellCheckBeforeSend",
+      pref: "mail.SpellCheckBeforeSend",
+    },
+    {
+      checkboxID: "inlineSpellCheck",
+      pref: "mail.spellcheck.inline",
+    }
+  );
+
+  await testCheckboxes(
+    "paneCompose",
+    "FontSelect",
+    {
+      checkboxID: "useReaderDefaults",
+      pref: "msgcompose.default_colors",
+      enabledInverted: true,
+      enabledElements: [
+        "#textColorLabel",
+        "#textColorButton",
+        "#backgroundColorLabel",
+        "#backgroundColorButton",
+      ],
+    },
+    {
+      checkboxID: "defaultToParagraph",
+      pref: "mail.compose.default_to_paragraph",
+    }
+  );
+
+  await testCheckboxes(
+    "paneCompose",
+    "compositionAddressingCategory",
+    {
+      checkboxID: "addressingAutocomplete",
+      pref: "mail.enable_autocomplete",
+    },
+    {
+      checkboxID: "autocompleteLDAP",
+      pref: "ldap_2.autoComplete.useDirectory",
+      enabledElements: ["#directoriesList", "#editButton"],
+    },
+    {
+      checkboxID: "emailCollectionOutgoing",
+      pref: "mail.collect_email_address_outgoing",
+      enabledElements: ["#localDirectoriesList"],
+    }
+  );
+});
+
+add_task(async () => {
+  await testCheckboxes(
+    "paneCompose",
+    "compositionAttachmentsCategory",
+    {
+      checkboxID: "attachment_reminder_label",
+      pref: "mail.compose.attachment_reminder",
+      enabledElements: ["#attachment_reminder_button"],
+    },
+    {
+      checkboxID: "enableThreshold",
+      pref: "mail.compose.big_attachments.notify",
+      enabledElements: ["#cloudFileThreshold"],
+    }
+  );
+});
diff --git a/comm/mail/components/preferences/test/browser/browser_general.js b/comm/mail/components/preferences/test/browser/browser_general.js
new file mode 100644
index 0000000000..f011be1e38
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/browser_general.js
@@ -0,0 +1,380 @@
+/* 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/. */
+
+var { MailServices } = ChromeUtils.import(
+  "resource:///modules/MailServices.jsm"
+);
+
+add_task(async () => {
+  requestLongerTimeout(2);
+
+  // Temporarily disable `Once` StaticPrefs check for this test so that we
+  // can change layers.acceleration.disabled without debug builds failing.
+  await SpecialPowers.pushPrefEnv({
+    set: [["preferences.force-disable.check.once.policy", true]],
+  });
+});
+
+add_task(async () => {
+  await testCheckboxes(
+    "paneGeneral",
+    "generalCategory",
+    {
+      checkboxID: "mailnewsStartPageEnabled",
+      pref: "mailnews.start_page.enabled",
+      enabledElements: [
+        "#mailnewsStartPageUrl",
+        "#mailnewsStartPageUrl + button",
+      ],
+    },
+    {
+      checkboxID: "alwaysCheckDefault",
+      pref: "mail.shell.checkDefaultClient",
+    }
+  );
+});
+
+add_task(async () => {
+  await testCheckboxes(
+    "paneGeneral",
+    "scrollingGroup",
+    {
+      checkboxID: "useAutoScroll",
+      pref: "general.autoScroll",
+    },
+    {
+      checkboxID: "useSmoothScrolling",
+      pref: "general.smoothScroll",
+    }
+  );
+});
+
+add_task(async () => {
+  await testCheckboxes(
+    "paneGeneral",
+    "enableGloda",
+    {
+      checkboxID: "enableGloda",
+      pref: "mailnews.database.global.indexer.enabled",
+    },
+    {
+      checkboxID: "allowHWAccel",
+      pref: "layers.acceleration.disabled",
+      prefValues: [true, false],
+    }
+  );
+});
+
+add_task(async () => {
+  if (AppConstants.platform != "macosx") {
+    await testCheckboxes(
+      "paneGeneral",
+      "incomingMailCategory",
+      {
+        checkboxID: "newMailNotification",
+        pref: "mail.biff.play_sound",
+        enabledElements: ["#soundType radio"],
+      },
+      {
+        checkboxID: "newMailNotificationAlert",
+        pref: "mail.biff.show_alert",
+        enabledElements: ["#customizeMailAlert"],
+      }
+    );
+  }
+});
+
+add_task(async () => {
+  if (AppConstants.platform == "macosx") {
+    return;
+  }
+
+  Services.prefs.setBoolPref("mail.biff.play_sound", true);
+
+  await testRadioButtons("paneGeneral", "incomingMailCategory", {
+    pref: "mail.biff.play_sound.type",
+    states: [
+      {
+        id: "system",
+        prefValue: 0,
+      },
+      {
+        id: "custom",
+        prefValue: 1,
+        enabledElements: ["#soundUrlLocation", "#browseForSound"],
+      },
+    ],
+  });
+});
+
+add_task(async () => {
+  await testCheckboxes("paneGeneral", "fontsGroup", {
+    checkboxID: "displayGlyph",
+    pref: "mail.display_glyph",
+  });
+
+  await testCheckboxes(
+    "paneGeneral",
+    "readingAndDisplayCategory",
+    {
+      checkboxID: "automaticallyMarkAsRead",
+      pref: "mailnews.mark_message_read.auto",
+      enabledElements: ["#markAsReadAutoPreferences radio"],
+    },
+    {
+      checkboxID: "closeMsgOnMoveOrDelete",
+      pref: "mail.close_message_window.on_delete",
+    },
+    {
+      checkboxID: "showCondensedAddresses",
+      pref: "mail.showCondensedAddresses",
+    }
+  );
+});
+
+add_task(async () => {
+  Services.prefs.setBoolPref("mailnews.mark_message_read.auto", true);
+
+  await testRadioButtons(
+    "paneGeneral",
+    "mark_read_immediately",
+    {
+      pref: "mailnews.mark_message_read.delay",
+      states: [
+        {
+          id: "mark_read_immediately",
+          prefValue: false,
+        },
+        {
+          id: "markAsReadAfterDelay",
+          prefValue: true,
+          enabledElements: ["#markAsReadDelay"],
+        },
+      ],
+    },
+    {
+      pref: "mail.openMessageBehavior",
+      states: [
+        {
+          id: "newTab",
+          prefValue: 2,
+        },
+        {
+          id: "newWindow",
+          prefValue: 0,
+        },
+        {
+          id: "existingWindow",
+          prefValue: 1,
+        },
+      ],
+    }
+  );
+});
+
+add_task(async () => {
+  // We don't want to wake up the platform search for this test.
+  // if (AppConstants.platform == "macosx") {
+  //   tests.push({
+  //     checkboxID: "searchIntegration",
+  //     pref: "mail.spotlight.enable",
+  //   });
+  // } else if (AppConstants.platform == "win") {
+  //   tests.push({
+  //     checkboxID: "searchIntegration",
+  //     pref: "mail.winsearch.enable",
+  //   });
+  // }
+
+  await testCheckboxes(
+    "paneGeneral",
+    "allowSmartSize",
+    {
+      checkboxID: "allowSmartSize",
+      pref: "browser.cache.disk.smart_size.enabled",
+      prefValues: [true, false],
+      enabledElements: ["#cacheSize"],
+    },
+    {
+      checkboxID: "offlineCompactFolder",
+      pref: "mail.prompt_purge_threshhold",
+      enabledElements: [
+        "#offlineCompactFolderMin",
+        "#offlineCompactFolderAutomatically",
+      ],
+    }
+  );
+});
+
+add_task(async () => {
+  await testRadioButtons("paneGeneral", "formatLocale", {
+    pref: "intl.regional_prefs.use_os_locales",
+    states: [
+      {
+        id: "appLocale",
+        prefValue: false,
+      },
+      {
+        id: "rsLocale",
+        prefValue: true,
+      },
+    ],
+  });
+});
+
+add_task(async () => {
+  await testRadioButtons("paneGeneral", "filesAttachmentCategory", {
+    pref: "browser.download.useDownloadDir",
+    states: [
+      {
+        id: "saveTo",
+        prefValue: true,
+        enabledElements: ["#downloadFolder", "#chooseFolder"],
+      },
+      {
+        id: "alwaysAsk",
+        prefValue: false,
+      },
+    ],
+  });
+});
+
+add_task(async function testTagDialog() {
+  const { prefsDocument, prefsWindow } = await openNewPrefsTab(
+    "paneGeneral",
+    "tagsCategory"
+  );
+
+  let newTagDialogPromise = BrowserTestUtils.promiseAlertDialogOpen(
+    undefined,
+    "chrome://messenger/content/preferences/tagDialog.xhtml",
+    {
+      isSubDialog: true,
+      async callback(dialogWindow) {
+        await TestUtils.waitForCondition(
+          () => Services.focus.focusedWindow == dialogWindow,
+          "waiting for subdialog to be focused"
+        );
+
+        const dialogDocument = dialogWindow.document;
+
+        EventUtils.sendString("tbird", dialogWindow);
+        // "#000080" == rgb(0, 0, 128);
+        dialogDocument.getElementById("tagColorPicker").value = "#000080";
+
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.querySelector("dialog").getButton("accept"),
+          {},
+          dialogWindow
+        );
+        await new Promise(r => setTimeout(r));
+      },
+    }
+  );
+
+  let newTagButton = prefsDocument.getElementById("newTagButton");
+  EventUtils.synthesizeMouseAtCenter(newTagButton, {}, prefsWindow);
+  await newTagDialogPromise;
+
+  let tagList = prefsDocument.getElementById("tagList");
+
+  Assert.ok(
+    tagList.querySelector('richlistitem[value="tbird"]'),
+    "new tbird tag should be in the list"
+  );
+  Assert.equal(
+    tagList.querySelector('richlistitem[value="tbird"]').style.color,
+    "rgb(0, 0, 128)",
+    "tbird tag color should be correct"
+  );
+  Assert.equal(
+    tagList.querySelectorAll('richlistitem[value="tbird"]').length,
+    1,
+    "new tbird tag should be in the list exactly once"
+  );
+
+  Assert.equal(
+    tagList.querySelector('richlistitem[value="tbird"]'),
+    tagList.selectedItem,
+    "tbird tag should be selected"
+  );
+
+  // Now edit the tag. The key should stay the same, name and color will change.
+
+  let editTagDialogPromise = BrowserTestUtils.promiseAlertDialogOpen(
+    undefined,
+    "chrome://messenger/content/preferences/tagDialog.xhtml",
+    {
+      isSubDialog: true,
+      async callback(dialogWindow) {
+        await TestUtils.waitForCondition(
+          () => Services.focus.focusedWindow == dialogWindow,
+          "waiting for subdialog to be focused"
+        );
+
+        const dialogDocument = dialogWindow.document;
+
+        Assert.equal(
+          dialogDocument.getElementById("name").value,
+          "tbird",
+          "should have existing tbird tag name prefilled"
+        );
+        Assert.equal(
+          dialogDocument.getElementById("tagColorPicker").value,
+          "#000080",
+          "should have existing tbird tag color prefilled"
+        );
+
+        EventUtils.sendString("-xx", dialogWindow); // => tbird-xx
+        // "#FFD700" == rgb(255, 215, 0);
+        dialogDocument.getElementById("tagColorPicker").value = "#FFD700";
+
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.querySelector("dialog").getButton("accept"),
+          {},
+          dialogWindow
+        );
+        await new Promise(r => setTimeout(r));
+      },
+    }
+  );
+
+  let editTagButton = prefsDocument.getElementById("editTagButton");
+  EventUtils.synthesizeMouseAtCenter(editTagButton, {}, prefsWindow);
+  await editTagDialogPromise;
+
+  Assert.ok(
+    tagList.querySelector(
+      'richlistitem[value="tbird"] > label[value="tbird-xx"]'
+    ),
+    "tbird-xx tag should be in the list"
+  );
+  Assert.equal(
+    tagList.querySelector('richlistitem[value="tbird"]').style.color,
+    "rgb(255, 215, 0)",
+    "tbird-xx tag color should be correct"
+  );
+  Assert.equal(
+    tagList.querySelectorAll('richlistitem[value="tbird"]').length,
+    1,
+    "tbird-xx tag should be in the list exactly once"
+  );
+
+  // And remove it.
+
+  EventUtils.synthesizeMouseAtCenter(
+    prefsDocument.getElementById("removeTagButton"),
+    {},
+    prefsWindow
+  );
+  await new Promise(r => setTimeout(r));
+
+  Assert.equal(
+    tagList.querySelector('richlistitem[value="tbird"]'),
+    null,
+    "tbird-xx (with key tbird) tag should have been removed from the list"
+  );
+
+  await closePrefsTab();
+});
diff --git a/comm/mail/components/preferences/test/browser/browser_openPreferences.js b/comm/mail/components/preferences/test/browser/browser_openPreferences.js
new file mode 100644
index 0000000000..01aceb085a
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/browser_openPreferences.js
@@ -0,0 +1,37 @@
+/* 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/. */
+
+function getStoredLastSelected() {
+  return Services.xulStore.getValue(
+    "about:preferences",
+    "paneDeck",
+    "lastSelected"
+  );
+}
+
+add_task(async () => {
+  // Check that openPreferencesTab with no arguments and no stored value opens the first pane.
+  Services.xulStore.removeDocument("about:preferences");
+
+  let { prefsWindow } = await openNewPrefsTab();
+  is(prefsWindow.gLastCategory.category, "paneGeneral");
+
+  await closePrefsTab();
+});
+
+add_task(async () => {
+  // Check that openPreferencesTab with one argument opens the right pane…
+  Services.xulStore.removeDocument("about:preferences");
+
+  await openNewPrefsTab("panePrivacy");
+  is(getStoredLastSelected(), "panePrivacy");
+
+  await closePrefsTab();
+
+  // … even with a value in the XULStore.
+  await openNewPrefsTab("paneCompose");
+  is(getStoredLastSelected(), "paneCompose");
+
+  await closePrefsTab();
+});
diff --git a/comm/mail/components/preferences/test/browser/browser_privacy.js b/comm/mail/components/preferences/test/browser/browser_privacy.js
new file mode 100644
index 0000000000..1b91ec35e8
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/browser_privacy.js
@@ -0,0 +1,454 @@
+/* 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/. */
+
+add_task(async () => {
+  await testCheckboxes(
+    "panePrivacy",
+    "privacyCategory",
+    {
+      checkboxID: "acceptRemoteContent",
+      pref: "mailnews.message_display.disable_remote_image",
+      prefValues: [true, false],
+    },
+    {
+      checkboxID: "keepHistory",
+      pref: "places.history.enabled",
+    },
+    {
+      checkboxID: "acceptCookies",
+      pref: "network.cookie.cookieBehavior",
+      prefValues: [2, 0],
+      enabledElements: ["#acceptThirdPartyMenu"],
+      unaffectedElements: ["#cookieExceptions"],
+    },
+    {
+      checkboxID: "privacyDoNotTrackCheckbox",
+      pref: "privacy.donottrackheader.enabled",
+    }
+  );
+});
+
+add_task(async () => {
+  await testCheckboxes(
+    "panePrivacy",
+    "privacyJunkCategory",
+    {
+      checkboxID: "manualMark",
+      pref: "mail.spam.manualMark",
+      enabledElements: ["#manualMarkMode radio"],
+    },
+    {
+      checkboxID: "markAsReadOnSpam",
+      pref: "mail.spam.markAsReadOnSpam",
+    },
+    {
+      checkboxID: "enableJunkLogging",
+      pref: "mail.spam.logging.enabled",
+      enabledElements: ["#openJunkLogButton"],
+    }
+  );
+
+  await testCheckboxes("panePrivacy", "privacySecurityCategory", {
+    checkboxID: "enablePhishingDetector",
+    pref: "mail.phishing.detection.enabled",
+  });
+
+  await testCheckboxes("panePrivacy", "enableAntiVirusQuarantine", {
+    checkboxID: "enableAntiVirusQuarantine",
+    pref: "mailnews.downloadToTempFile",
+  });
+});
+
+add_task(async () => {
+  Services.prefs.setBoolPref("mail.spam.manualMark", true);
+
+  await testRadioButtons("panePrivacy", "privacyJunkCategory", {
+    pref: "mail.spam.manualMarkMode",
+    states: [
+      {
+        id: "manualMarkMode0",
+        prefValue: 0,
+      },
+      {
+        id: "manualMarkMode1",
+        prefValue: 1,
+      },
+    ],
+  });
+});
+
+add_task(async () => {
+  // Telemetry pref is locked.
+  // await testCheckboxes("paneAdvanced", undefined, {
+  //   checkboxID: "submitTelemetryBox",
+  //   pref: "toolkit.telemetry.enabled",
+  // });
+
+  await testCheckboxes("panePrivacy", "enableOCSP", {
+    checkboxID: "enableOCSP",
+    pref: "security.OCSP.enabled",
+    prefValues: [0, 1],
+  });
+});
+
+// Here we'd test the update choices, but I don't want to go near that.
+add_task(async () => {
+  await testRadioButtons("panePrivacy", "enableOCSP", {
+    pref: "security.default_personal_cert",
+    states: [
+      {
+        id: "certSelectionAuto",
+        prefValue: "Select Automatically",
+      },
+      {
+        id: "certSelectionAsk",
+        prefValue: "Ask Every Time",
+      },
+    ],
+  });
+});
+
+add_task(async function testRemoteContentDialog() {
+  const { prefsDocument, prefsWindow } = await openNewPrefsTab("panePrivacy");
+
+  let dialogPromise = BrowserTestUtils.promiseAlertDialogOpen(
+    undefined,
+    "chrome://messenger/content/preferences/permissions.xhtml",
+    {
+      isSubDialog: true,
+      async callback(dialogWindow) {
+        await TestUtils.waitForCondition(
+          () => Services.focus.focusedWindow == dialogWindow,
+          "waiting for subdialog to be focused"
+        );
+
+        const dialogDocument = dialogWindow.document;
+        const url = dialogDocument.getElementById("url");
+        const permissionsTree =
+          dialogDocument.getElementById("permissionsTree");
+
+        EventUtils.sendString("accept.invalid", dialogWindow);
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnAllow"),
+          {},
+          dialogWindow
+        );
+        await new Promise(f => setTimeout(f));
+        Assert.equal(url.value, "", "url input should be cleared");
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          1,
+          "new entry should be added to list"
+        );
+
+        Assert.ok(
+          BrowserTestUtils.is_hidden(
+            dialogDocument.getElementById("btnSession")
+          ),
+          "session button should be hidden"
+        );
+
+        EventUtils.sendString("block.invalid", dialogWindow);
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnBlock"),
+          {},
+          dialogWindow
+        );
+        await new Promise(f => setTimeout(f));
+        Assert.equal(url.value, "", "url input should be cleared");
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          2,
+          "new entry should be added to list"
+        );
+
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnApplyChanges"),
+          {},
+          dialogWindow
+        );
+      },
+    }
+  );
+  let remoteContentExceptions = prefsDocument.getElementById(
+    "remoteContentExceptions"
+  );
+  EventUtils.synthesizeMouseAtCenter(remoteContentExceptions, {}, prefsWindow);
+  await dialogPromise;
+
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  let acceptURI = Services.io.newURI("http://accept.invalid/");
+  let acceptPrincipal = Services.scriptSecurityManager.createContentPrincipal(
+    acceptURI,
+    {}
+  );
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(acceptPrincipal, "image"),
+    Ci.nsIPermissionManager.ALLOW_ACTION,
+    "accept permission should exist for accept.invalid"
+  );
+
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  let blockURI = Services.io.newURI("http://block.invalid/");
+  let blockPrincipal = Services.scriptSecurityManager.createContentPrincipal(
+    blockURI,
+    {}
+  );
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(blockPrincipal, "image"),
+    Ci.nsIPermissionManager.DENY_ACTION,
+    "block permission should exist for block.invalid"
+  );
+
+  dialogPromise = BrowserTestUtils.promiseAlertDialogOpen(
+    undefined,
+    "chrome://messenger/content/preferences/permissions.xhtml",
+    {
+      isSubDialog: true,
+      async callback(dialogWindow) {
+        await TestUtils.waitForCondition(
+          () => Services.focus.focusedWindow == dialogWindow,
+          "waiting for subdialog to be focused"
+        );
+
+        const dialogDocument = dialogWindow.document;
+        const permissionsTree =
+          dialogDocument.getElementById("permissionsTree");
+
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          2,
+          "list should be populated"
+        );
+
+        permissionsTree.view.selection.select(0);
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("removePermission"),
+          {},
+          dialogWindow
+        );
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          1,
+          "row should be removed from list"
+        );
+
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("removeAllPermissions"),
+          {},
+          dialogWindow
+        );
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          0,
+          "row should be removed from list"
+        );
+
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnApplyChanges"),
+          {},
+          dialogWindow
+        );
+      },
+    }
+  );
+  EventUtils.synthesizeMouseAtCenter(remoteContentExceptions, {}, prefsWindow);
+  await dialogPromise;
+
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(acceptPrincipal, "image"),
+    Ci.nsIPermissionManager.UNKNOWN_ACTION,
+    "permission should be removed for accept.invalid"
+  );
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(blockPrincipal, "image"),
+    Ci.nsIPermissionManager.UNKNOWN_ACTION,
+    "permission should be removed for block.invalid"
+  );
+
+  await closePrefsTab();
+});
+
+add_task(async function testCookiesDialog() {
+  const { prefsDocument, prefsWindow } = await openNewPrefsTab("panePrivacy");
+
+  let dialogPromise = BrowserTestUtils.promiseAlertDialogOpen(
+    undefined,
+    "chrome://messenger/content/preferences/permissions.xhtml",
+    {
+      isSubDialog: true,
+      async callback(dialogWindow) {
+        await TestUtils.waitForCondition(
+          () => Services.focus.focusedWindow == dialogWindow,
+          "waiting for subdialog to be focused"
+        );
+
+        const dialogDocument = dialogWindow.document;
+        const url = dialogDocument.getElementById("url");
+        const permissionsTree =
+          dialogDocument.getElementById("permissionsTree");
+
+        EventUtils.sendString("accept.invalid", dialogWindow);
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnAllow"),
+          {},
+          dialogWindow
+        );
+        await new Promise(f => setTimeout(f));
+        Assert.equal(url.value, "", "url input should be cleared");
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          1,
+          "new entry should be added to list"
+        );
+
+        EventUtils.sendString("session.invalid", dialogWindow);
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnSession"),
+          {},
+          dialogWindow
+        );
+        await new Promise(f => setTimeout(f));
+        Assert.equal(url.value, "", "url input should be cleared");
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          2,
+          "new entry should be added to list"
+        );
+
+        EventUtils.sendString("block.invalid", dialogWindow);
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnBlock"),
+          {},
+          dialogWindow
+        );
+        await new Promise(f => setTimeout(f));
+        Assert.equal(url.value, "", "url input should be cleared");
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          3,
+          "new entry should be added to list"
+        );
+
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnApplyChanges"),
+          {},
+          dialogWindow
+        );
+      },
+    }
+  );
+  let cookieExceptions = prefsDocument.getElementById("cookieExceptions");
+  EventUtils.synthesizeMouseAtCenter(cookieExceptions, {}, prefsWindow);
+  await dialogPromise;
+
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  let acceptURI = Services.io.newURI("http://accept.invalid/");
+  let acceptPrincipal = Services.scriptSecurityManager.createContentPrincipal(
+    acceptURI,
+    {}
+  );
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(acceptPrincipal, "cookie"),
+    Ci.nsIPermissionManager.ALLOW_ACTION,
+    "accept permission should exist for accept.invalid"
+  );
+
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  let sessionURI = Services.io.newURI("http://session.invalid/");
+  let sessionPrincipal = Services.scriptSecurityManager.createContentPrincipal(
+    sessionURI,
+    {}
+  );
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(sessionPrincipal, "cookie"),
+    Ci.nsICookiePermission.ACCESS_SESSION,
+    "session permission should exist for session.invalid"
+  );
+
+  // eslint-disable-next-line @microsoft/sdl/no-insecure-url
+  let blockURI = Services.io.newURI("http://block.invalid/");
+  let blockPrincipal = Services.scriptSecurityManager.createContentPrincipal(
+    blockURI,
+    {}
+  );
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(blockPrincipal, "cookie"),
+    Ci.nsIPermissionManager.DENY_ACTION,
+    "block permission should exist for block.invalid"
+  );
+
+  dialogPromise = BrowserTestUtils.promiseAlertDialogOpen(
+    undefined,
+    "chrome://messenger/content/preferences/permissions.xhtml",
+    {
+      isSubDialog: true,
+      async callback(dialogWindow) {
+        await TestUtils.waitForCondition(
+          () => Services.focus.focusedWindow == dialogWindow,
+          "waiting for subdialog to be focused"
+        );
+
+        const dialogDocument = dialogWindow.document;
+        const permissionsTree =
+          dialogDocument.getElementById("permissionsTree");
+
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          3,
+          "list should be populated"
+        );
+
+        permissionsTree.view.selection.select(0);
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("removePermission"),
+          {},
+          dialogWindow
+        );
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          2,
+          "row should be removed from list"
+        );
+
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("removeAllPermissions"),
+          {},
+          dialogWindow
+        );
+        Assert.equal(
+          permissionsTree.view.rowCount,
+          0,
+          "row should be removed from list"
+        );
+
+        EventUtils.synthesizeMouseAtCenter(
+          dialogDocument.getElementById("btnApplyChanges"),
+          {},
+          dialogWindow
+        );
+      },
+    }
+  );
+  EventUtils.synthesizeMouseAtCenter(cookieExceptions, {}, prefsWindow);
+  await dialogPromise;
+
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(acceptPrincipal, "cookie"),
+    Ci.nsIPermissionManager.UNKNOWN_ACTION,
+    "permission should be removed for accept.invalid"
+  );
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(sessionPrincipal, "cookie"),
+    Ci.nsIPermissionManager.UNKNOWN_ACTION,
+    "permission should be removed for session.invalid"
+  );
+  Assert.equal(
+    Services.perms.testPermissionFromPrincipal(blockPrincipal, "cookie"),
+    Ci.nsIPermissionManager.UNKNOWN_ACTION,
+    "permission should be removed for block.invalid"
+  );
+
+  await closePrefsTab();
+});
diff --git a/comm/mail/components/preferences/test/browser/browser_sync.js b/comm/mail/components/preferences/test/browser/browser_sync.js
new file mode 100644
index 0000000000..108695ebb5
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/browser_sync.js
@@ -0,0 +1,419 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, you can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { MockRegistrar } = ChromeUtils.importESModule(
+  "resource://testing-common/MockRegistrar.sys.mjs"
+);
+
+const { FxAccounts } = ChromeUtils.importESModule(
+  "resource://gre/modules/FxAccounts.sys.mjs"
+);
+FxAccounts.config.promiseConnectAccountURI = entryPoint =>
+  `https://example.org/?page=connect&entryPoint=${entryPoint}`;
+FxAccounts.config.promiseManageURI = entryPoint =>
+  `https://example.org/?page=manage&entryPoint=${entryPoint}`;
+FxAccounts.config.promiseChangeAvatarURI = entryPoint =>
+  `https://example.org/?page=avatar&entryPoint=${entryPoint}`;
+
+const ALL_ENGINES = [
+  "accounts",
+  "identities",
+  "addressbooks",
+  "calendars",
+  "passwords",
+];
+const PREF_PREFIX = "services.sync.engine";
+
+let prefsWindow, prefsDocument, tabmail;
+
+add_setup(async function () {
+  for (let engine of ALL_ENGINES) {
+    Services.prefs.setBoolPref(`${PREF_PREFIX}.${engine}`, true);
+  }
+
+  ({ prefsWindow, prefsDocument } = await openNewPrefsTab("paneSync"));
+  tabmail = document.getElementById("tabmail");
+
+  /** @implements {nsIExternalProtocolService} */
+  let mockExternalProtocolService = {
+    QueryInterface: ChromeUtils.generateQI(["nsIExternalProtocolService"]),
+    externalProtocolHandlerExists(protocolScheme) {},
+    isExposedProtocol(protocolScheme) {},
+    loadURI(uri, windowContext) {
+      Assert.report(
+        true,
+        undefined,
+        undefined,
+        `should not be opening ${uri.spec} in an external browser`
+      );
+    },
+  };
+
+  let mockExternalProtocolServiceCID = MockRegistrar.register(
+    "@mozilla.org/uriloader/external-protocol-service;1",
+    mockExternalProtocolService
+  );
+  registerCleanupFunction(() => {
+    MockRegistrar.unregister(mockExternalProtocolServiceCID);
+  });
+});
+
+add_task(async function testSectionStates() {
+  let noFxaAccount = prefsDocument.getElementById("noFxaAccount");
+  let hasFxaAccount = prefsDocument.getElementById("hasFxaAccount");
+  let accountStates = [noFxaAccount, hasFxaAccount];
+
+  let fxaLoginUnverified = prefsDocument.getElementById("fxaLoginUnverified");
+  let fxaLoginRejected = prefsDocument.getElementById("fxaLoginRejected");
+  let fxaLoginVerified = prefsDocument.getElementById("fxaLoginVerified");
+  let loginStates = [fxaLoginUnverified, fxaLoginRejected, fxaLoginVerified];
+
+  let fxaDeviceInfo = prefsDocument.getElementById("fxaDeviceInfo");
+  let syncConnected = prefsDocument.getElementById("syncConnected");
+  let syncDisconnected = prefsDocument.getElementById("syncDisconnected");
+  let syncStates = [syncConnected, syncDisconnected];
+
+  function assertStateVisible(states, visibleState) {
+    for (let state of states) {
+      let visible = BrowserTestUtils.is_visible(state);
+      Assert.equal(
+        visible,
+        state == visibleState,
+        `${state.id} should be ${state == visibleState ? "visible" : "hidden"}`
+      );
+    }
+  }
+
+  function checkStates({
+    accountState,
+    loginState = null,
+    deviceInfoVisible = false,
+    syncState = null,
+  }) {
+    prefsWindow.gSyncPane.updateWeavePrefs();
+    assertStateVisible(accountStates, accountState);
+    assertStateVisible(loginStates, loginState);
+    Assert.equal(
+      BrowserTestUtils.is_visible(fxaDeviceInfo),
+      deviceInfoVisible,
+      `fxaDeviceInfo should be ${deviceInfoVisible ? "visible" : "hidden"}`
+    );
+    assertStateVisible(syncStates, syncState);
+  }
+
+  async function assertTabOpens(target, expectedURL) {
+    if (typeof target == "string") {
+      target = prefsDocument.getElementById(target);
+    }
+
+    let tabPromise = BrowserTestUtils.waitForEvent(window, "TabOpen");
+    EventUtils.synthesizeMouseAtCenter(target, {}, prefsWindow);
+    await tabPromise;
+    let tab = tabmail.currentTabInfo;
+    await BrowserTestUtils.browserLoaded(tab.browser);
+    Assert.equal(
+      tab.browser.currentURI.spec,
+      `https://example.org/${expectedURL}`,
+      "a tab opened to the correct URL"
+    );
+    tabmail.closeTab(tab);
+  }
+
+  info("No account");
+  Assert.equal(prefsWindow.UIState.get().status, "not_configured");
+  checkStates({ accountState: noFxaAccount });
+
+  // Check clicking the Sign In button opens the connect page in a tab.
+  await assertTabOpens("noFxaSignIn", "?page=connect&entryPoint=");
+
+  // Override the window's UIState object with mock values.
+  let baseState = {
+    email: "test@invalid",
+    displayName: "Testy McTest",
+    avatarURL:
+      "https://example.org/browser/comm/mail/components/preferences/test/browser/files/avatar.png",
+    avatarIsDefault: false,
+  };
+  let mockState;
+  prefsWindow.UIState = {
+    ON_UPDATE: "sync-ui-state:update",
+    STATUS_LOGIN_FAILED: "login_failed",
+    STATUS_NOT_CONFIGURED: "not_configured",
+    STATUS_NOT_VERIFIED: "not_verified",
+    STATUS_SIGNED_IN: "signed_in",
+    get() {
+      return mockState;
+    },
+  };
+
+  info("Login not verified");
+  mockState = { ...baseState, status: "not_verified" };
+  checkStates({
+    accountState: hasFxaAccount,
+    loginState: fxaLoginUnverified,
+    deviceInfoVisible: true,
+  });
+  Assert.deepEqual(
+    await prefsDocument.l10n.getAttributes(
+      prefsDocument.getElementById("fxaAccountMailNotVerified")
+    ),
+    {
+      id: "sync-pane-email-not-verified",
+      args: { userEmail: "test@invalid" },
+    },
+    "email address set correctly"
+  );
+
+  // Untested: Resend and remove account buttons.
+
+  info("Login rejected");
+  mockState = { ...baseState, status: "login_failed" };
+  checkStates({
+    accountState: hasFxaAccount,
+    loginState: fxaLoginRejected,
+    deviceInfoVisible: true,
+  });
+  Assert.deepEqual(
+    await prefsDocument.l10n.getAttributes(
+      prefsDocument.getElementById("fxaAccountLoginRejected")
+    ),
+    {
+      id: "sync-signedin-login-failure",
+      args: { userEmail: "test@invalid" },
+    },
+    "email address set correctly"
+  );
+
+  // Untested: Sign in and remove account buttons.
+
+  info("Logged in, sync disabled");
+  mockState = { ...baseState, status: "verified", syncEnabled: false };
+  checkStates({
+    accountState: hasFxaAccount,
+    loginState: fxaLoginVerified,
+    deviceInfoVisible: true,
+    syncState: syncDisconnected,
+  });
+  let photo = fxaLoginVerified.querySelector(".contact-photo");
+  Assert.equal(
+    photo.src,
+    "https://example.org/browser/comm/mail/components/preferences/test/browser/files/avatar.png",
+    "avatar image set correctly"
+  );
+
+  // Check clicking the avatar image opens the avatar page in a tab.
+  await assertTabOpens(photo, "?page=avatar&entryPoint=preferences");
+
+  Assert.equal(
+    prefsDocument.getElementById("fxaDisplayName").textContent,
+    "Testy McTest",
+    "display name set correctly"
+  );
+  Assert.equal(
+    prefsDocument.getElementById("fxaEmailAddress").textContent,
+    "test@invalid",
+    "email address set correctly"
+  );
+
+  // Check clicking the management link opens the management page in a tab.
+  await assertTabOpens("verifiedManage", "?page=manage&entryPoint=preferences");
+
+  // Untested: Sign out button.
+
+  info("Device name section");
+  let deviceNameInput = prefsDocument.getElementById("fxaDeviceNameInput");
+  let deviceNameCancel = prefsDocument.getElementById("fxaDeviceNameCancel");
+  let deviceNameSave = prefsDocument.getElementById("fxaDeviceNameSave");
+  let deviceNameChange = prefsDocument.getElementById(
+    "fxaDeviceNameChangeDeviceName"
+  );
+  Assert.ok(deviceNameInput.readOnly, "input is read-only");
+  Assert.ok(
+    BrowserTestUtils.is_hidden(deviceNameCancel),
+    "cancel button is hidden"
+  );
+  Assert.ok(
+    BrowserTestUtils.is_hidden(deviceNameSave),
+    "save button is hidden"
+  );
+  Assert.ok(
+    BrowserTestUtils.is_visible(deviceNameChange),
+    "change button is visible"
+  );
+
+  EventUtils.synthesizeMouseAtCenter(deviceNameChange, {}, prefsWindow);
+  Assert.ok(!deviceNameInput.readOnly, "input is writeable");
+  Assert.equal(prefsDocument.activeElement, deviceNameInput, "input is active");
+  Assert.ok(
+    BrowserTestUtils.is_visible(deviceNameCancel),
+    "cancel button is visible"
+  );
+  Assert.ok(
+    BrowserTestUtils.is_visible(deviceNameSave),
+    "save button is visible"
+  );
+  Assert.ok(
+    BrowserTestUtils.is_hidden(deviceNameChange),
+    "change button is hidden"
+  );
+
+  EventUtils.synthesizeMouseAtCenter(deviceNameCancel, {}, prefsWindow);
+  Assert.ok(deviceNameInput.readOnly, "input is read-only");
+  Assert.ok(
+    BrowserTestUtils.is_hidden(deviceNameCancel),
+    "cancel button is hidden"
+  );
+  Assert.ok(
+    BrowserTestUtils.is_hidden(deviceNameSave),
+    "save button is hidden"
+  );
+  Assert.ok(
+    BrowserTestUtils.is_visible(deviceNameChange),
+    "change button is visible"
+  );
+
+  // Check the turn on sync button works.
+  await openEngineDialog({ expectEngines: ALL_ENGINES, button: "syncSetup" });
+
+  info("Logged in, sync enabled");
+  mockState = { ...baseState, status: "verified", syncEnabled: true };
+  checkStates({
+    accountState: hasFxaAccount,
+    loginState: fxaLoginVerified,
+    deviceInfoVisible: true,
+    syncState: syncConnected,
+  });
+
+  // Untested: Sync now button.
+
+  // Check the learn more link opens a tab.
+  await assertTabOpens("enginesLearnMore", "?page=learnMore");
+
+  // Untested: Disconnect button.
+});
+
+add_task(async function testEngines() {
+  function assertEnginesEnabled(...expectedEnabled) {
+    for (let engine of ALL_ENGINES) {
+      let enabled = Services.prefs.getBoolPref(`${PREF_PREFIX}.${engine}`);
+      Assert.equal(
+        enabled,
+        expectedEnabled.includes(engine),
+        `${engine} should be ${
+          expectedEnabled.includes(engine) ? "enabled" : "disabled"
+        }`
+      );
+    }
+  }
+
+  function assertEnginesShown(...expectEngines) {
+    let ENGINES_TO_ITEMS = {
+      accounts: "showSyncAccount",
+      identities: "showSyncIdentity",
+      addressbooks: "showSyncAddress",
+      calendars: "showSyncCalendar",
+      passwords: "showSyncPasswords",
+    };
+    let expectItems = expectEngines.map(engine => ENGINES_TO_ITEMS[engine]);
+    let items = Array.from(
+      prefsDocument.querySelectorAll("#showSyncedList > li:not([hidden])"),
+      li => li.id
+    );
+    Assert.deepEqual(items, expectItems, "enabled engines shown correctly");
+  }
+
+  assertEnginesShown(...ALL_ENGINES);
+  Services.prefs.setBoolPref(`${PREF_PREFIX}.accounts`, false);
+  assertEnginesShown("identities", "addressbooks", "calendars", "passwords");
+  Services.prefs.setBoolPref(`${PREF_PREFIX}.identities`, false);
+  Services.prefs.setBoolPref(`${PREF_PREFIX}.addressbooks`, false);
+  Services.prefs.setBoolPref(`${PREF_PREFIX}.calendars`, false);
+  assertEnginesShown("passwords");
+  Services.prefs.setBoolPref(`${PREF_PREFIX}.passwords`, false);
+  assertEnginesShown();
+
+  info("Checking the engine selection dialog");
+  await openEngineDialog({
+    toggleEngines: ["accounts", "identities", "passwords"],
+  });
+
+  assertEnginesEnabled("accounts", "identities", "passwords");
+  assertEnginesShown("accounts", "identities", "passwords");
+
+  await openEngineDialog({
+    expectEngines: ["accounts", "identities", "passwords"],
+    toggleEngines: ["calendars", "passwords"],
+    action: "cancel",
+  });
+
+  assertEnginesEnabled("accounts", "identities", "passwords");
+  assertEnginesShown("accounts", "identities", "passwords");
+
+  await openEngineDialog({
+    expectEngines: ["accounts", "identities", "passwords"],
+    toggleEngines: ["calendars", "passwords"],
+    action: "accept",
+  });
+
+  assertEnginesEnabled("accounts", "identities", "calendars");
+  assertEnginesShown("accounts", "identities", "calendars");
+
+  Services.prefs.setBoolPref(`${PREF_PREFIX}.addressbooks`, true);
+  Services.prefs.setBoolPref(`${PREF_PREFIX}.passwords`, true);
+  assertEnginesShown(...ALL_ENGINES);
+});
+
+async function openEngineDialog({
+  expectEngines = [],
+  toggleEngines = [],
+  action = "accept",
+  button = "syncChangeOptions",
+}) {
+  const ENGINES_TO_CHECKBOXES = {
+    accounts: "configSyncAccount",
+    identities: "configSyncIdentity",
+    addressbooks: "configSyncAddress",
+    calendars: "configSyncCalendar",
+    passwords: "configSyncPasswords",
+  };
+  let dialogPromise = BrowserTestUtils.promiseAlertDialogOpen(
+    undefined,
+    "chrome://messenger/content/preferences/syncDialog.xhtml",
+    { isSubDialog: true }
+  );
+  EventUtils.synthesizeMouseAtCenter(
+    prefsDocument.getElementById(button),
+    {},
+    prefsWindow
+  );
+  let dialogWindow = await dialogPromise;
+  let dialogDocument = dialogWindow.document;
+  await new Promise(resolve => dialogWindow.setTimeout(resolve));
+
+  let expectItems = expectEngines.map(engine => ENGINES_TO_CHECKBOXES[engine]);
+
+  let checkedItems = Array.from(
+    dialogDocument.querySelectorAll(`input[type="checkbox"]`)
+  )
+    .filter(cb => cb.checked)
+    .map(cb => cb.id);
+  Assert.deepEqual(
+    checkedItems,
+    expectItems,
+    "enabled engines checked correctly"
+  );
+
+  for (let toggleItem of toggleEngines) {
+    let checkbox = dialogDocument.getElementById(
+      ENGINES_TO_CHECKBOXES[toggleItem]
+    );
+    checkbox.checked = !checkbox.checked;
+  }
+
+  EventUtils.synthesizeMouseAtCenter(
+    dialogDocument.querySelector("dialog").getButton(action),
+    {},
+    dialogWindow
+  );
+}
diff --git a/comm/mail/components/preferences/test/browser/files/avatar.png b/comm/mail/components/preferences/test/browser/files/avatar.png
new file mode 100644
index 0000000000..ca0894316a
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/files/avatar.png
diff --git a/comm/mail/components/preferences/test/browser/files/icon.svg b/comm/mail/components/preferences/test/browser/files/icon.svg
new file mode 100644
index 0000000000..6c1a552445
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/files/icon.svg
@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16">
+  <circle cx="8" cy="8" r="7.5" fill="#ffffff" stroke="#00aa00" stroke-width="1.5"/>
+  <circle cx="5" cy="6" r="1.5" fill="#00aa00"/>
+  <circle cx="11" cy="6" r="1.5" fill="#00aa00"/>
+  <path d="M 12.83,9.30 C 12.24,11.48 10.26,13 8,13 5.75,13 3.74,11.48 3.17,9.29" fill="none" stroke="#00aa00" stroke-width="1.5"/>
+</svg>
diff --git a/comm/mail/components/preferences/test/browser/files/management.html b/comm/mail/components/preferences/test/browser/files/management.html
new file mode 100644
index 0000000000..7e3561d823
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/files/management.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8"/>
+  <title></title>
+</head>
+<body>
+  <a id="a" href="https://www.example.com/">Click me!</a>
+</body>
+</html>
diff --git a/comm/mail/components/preferences/test/browser/head.js b/comm/mail/components/preferences/test/browser/head.js
new file mode 100644
index 0000000000..12cbdb17f1
--- /dev/null
+++ b/comm/mail/components/preferences/test/browser/head.js
@@ -0,0 +1,314 @@
+/* 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/utilityOverlay.js */
+
+async function openNewPrefsTab(paneID, scrollPaneTo, otherArgs) {
+  let tabmail = document.getElementById("tabmail");
+  let prefsTabMode = tabmail.tabModes.preferencesTab;
+
+  is(prefsTabMode.tabs.length, 0, "Prefs tab is not open");
+
+  let prefsDocument = await new Promise(resolve => {
+    Services.obs.addObserver(function documentLoaded(subject) {
+      if (subject.URL.startsWith("about:preferences")) {
+        Services.obs.removeObserver(documentLoaded, "chrome-document-loaded");
+        subject.ownerGlobal.setTimeout(() => resolve(subject));
+      }
+    }, "chrome-document-loaded");
+    openPreferencesTab(paneID, scrollPaneTo, otherArgs);
+  });
+  ok(prefsDocument.URL.startsWith("about:preferences"), "Prefs tab is open");
+
+  prefsDocument = prefsTabMode.tabs[0].browser.contentDocument;
+  let prefsWindow = prefsDocument.ownerGlobal;
+  prefsWindow.resizeTo(screen.availWidth, screen.availHeight);
+
+  if (paneID) {
+    await new Promise(resolve => prefsWindow.setTimeout(resolve));
+    is(
+      prefsWindow.gLastCategory.category,
+      paneID,
+      `Selected pane is ${paneID}`
+    );
+  } else {
+    // If we don't wait here for other scripts to run, they
+    // could be in a bad state if our test closes the tab.
+    await new Promise(resolve => prefsWindow.setTimeout(resolve));
+  }
+
+  registerCleanupOnce();
+
+  await new Promise(resolve => prefsWindow.setTimeout(resolve));
+  let container = prefsDocument.getElementById("preferencesContainer");
+  if (scrollPaneTo && container.scrollHeight > container.clientHeight) {
+    Assert.greater(
+      container.scrollTop,
+      0,
+      "Prefs page did scroll when it was supposed to"
+    );
+  }
+  return { prefsDocument, prefsWindow };
+}
+
+async function openExistingPrefsTab(paneID, scrollPaneTo, otherArgs) {
+  let tabmail = document.getElementById("tabmail");
+  let prefsTabMode = tabmail.tabModes.preferencesTab;
+
+  is(prefsTabMode.tabs.length, 1, "Prefs tab is open");
+
+  let prefsDocument = prefsTabMode.tabs[0].browser.contentDocument;
+  let prefsWindow = prefsDocument.ownerGlobal;
+  prefsWindow.resizeTo(screen.availWidth, screen.availHeight);
+
+  if (paneID && prefsWindow.gLastCategory.category != paneID) {
+    openPreferencesTab(paneID, scrollPaneTo, otherArgs);
+  }
+
+  await new Promise(resolve => prefsWindow.setTimeout(resolve));
+  is(prefsWindow.gLastCategory.category, paneID, `Selected pane is ${paneID}`);
+
+  if (scrollPaneTo) {
+    Assert.greater(
+      prefsDocument.getElementById("preferencesContainer").scrollTop,
+      0,
+      "Prefs page did scroll when it was supposed to"
+    );
+  }
+
+  registerCleanupOnce();
+  return { prefsDocument, prefsWindow };
+}
+
+function registerCleanupOnce() {
+  if (registerCleanupOnce.alreadyRegistered) {
+    return;
+  }
+  registerCleanupFunction(closePrefsTab);
+  registerCleanupOnce.alreadyRegistered = true;
+}
+
+async function closePrefsTab() {
+  info("Closing prefs tab");
+  let tabmail = document.getElementById("tabmail");
+  let prefsTab = tabmail.tabModes.preferencesTab.tabs[0];
+  if (prefsTab) {
+    tabmail.closeTab(prefsTab);
+  }
+}
+
+/**
+ * Tests a checkbox sets the preference is set in the right state when the preferences tab opens,
+ * that the preference it relates to is set properly, and any UI elements that should be disabled
+ * by it are disabled.
+ *
+ * Each of the tests arguments is an object describing a test, containing:
+ *   checkboxID - the ID of the checkbox to test
+ *   pref - the name of a preference,
+ *   prefValues - an array of two values: pref value when not checked, pref value when checked
+ *                (optional, defaults to [false, true])
+ *   enabledElements - an array of CSS selectors (optional)
+ *   enabledInverted - if the elements should be disabled when the checkbox is checked (optional)
+ *   unaffectedElements - array of CSS selectors that should not be affected by
+ *                        the toggling of the checkbox.
+ */
+async function testCheckboxes(paneID, scrollPaneTo, ...tests) {
+  for (let initiallyChecked of [true, false]) {
+    info(`Opening ${paneID} with prefs set to ${initiallyChecked}`);
+
+    for (let test of tests) {
+      let wantedValue = initiallyChecked;
+      if (test.prefValues) {
+        wantedValue = wantedValue ? test.prefValues[1] : test.prefValues[0];
+      }
+      if (typeof wantedValue == "number") {
+        Services.prefs.setIntPref(test.pref, wantedValue);
+      } else {
+        Services.prefs.setBoolPref(test.pref, wantedValue);
+      }
+    }
+
+    let { prefsDocument, prefsWindow } = await openNewPrefsTab(
+      paneID,
+      scrollPaneTo
+    );
+
+    let testUIState = function (test, checked) {
+      let wantedValue = checked;
+      if (test.prefValues) {
+        wantedValue = wantedValue ? test.prefValues[1] : test.prefValues[0];
+      }
+      let checkbox = prefsDocument.getElementById(test.checkboxID);
+      is(
+        checkbox.checked,
+        checked,
+        wantedValue,
+        "Checkbox " + (checked ? "is" : "isn't") + " checked"
+      );
+      if (typeof wantedValue == "number") {
+        is(
+          Services.prefs.getIntPref(test.pref, -999),
+          wantedValue,
+          `Pref is ${wantedValue}`
+        );
+      } else {
+        is(
+          Services.prefs.getBoolPref(test.pref),
+          wantedValue,
+          `Pref is ${wantedValue}`
+        );
+      }
+
+      if (test.enabledElements) {
+        let disabled = checked;
+        if (test.enabledInverted) {
+          disabled = !disabled;
+        }
+        for (let selector of test.enabledElements) {
+          let elements = prefsDocument.querySelectorAll(selector);
+          ok(
+            elements.length >= 1,
+            `At least one element matched '${selector}'`
+          );
+          for (let element of elements) {
+            is(
+              element.disabled,
+              !disabled,
+              "Element " + (disabled ? "isn't" : "is") + " disabled"
+            );
+          }
+        }
+      }
+    };
+
+    let testUnaffected = function (ids, states) {
+      ids.forEach((sel, index) => {
+        let isOk = prefsDocument.querySelector(sel).disabled === states[index];
+        is(isOk, true, `Element "${sel}" is unaffected`);
+      });
+    };
+
+    for (let test of tests) {
+      info(`Checking ${test.checkboxID}`);
+
+      let unaffectedSelectors = test.unaffectedElements || [];
+      let unaffectedStates = unaffectedSelectors.map(
+        sel => prefsDocument.querySelector(sel).disabled
+      );
+
+      let checkbox = prefsDocument.getElementById(test.checkboxID);
+      checkbox.scrollIntoView(false);
+      testUIState(test, initiallyChecked);
+
+      EventUtils.synthesizeMouseAtCenter(checkbox, {}, prefsWindow);
+      testUIState(test, !initiallyChecked);
+      testUnaffected(unaffectedSelectors, unaffectedStates);
+
+      EventUtils.synthesizeMouseAtCenter(checkbox, {}, prefsWindow);
+      testUIState(test, initiallyChecked);
+      testUnaffected(unaffectedSelectors, unaffectedStates);
+    }
+
+    await closePrefsTab();
+  }
+}
+
+/**
+ * Tests a set of radio buttons is in the right state when the preferences tab opens, and when
+ * the selected button changes that the preference it relates to is set properly, and any related
+ * UI elements that should be disabled are disabled.
+ *
+ * Each of the tests arguments is an object describing a test, containing:
+ *   pref - the name of an integer preference,
+ *   states - an array with each element describing a radio button:
+ *     id - the ID of the button to test,
+ *     prefValue - the value the pref should be set to
+ *     enabledElements - an array of CSS selectors to elements that should be enabled when this
+ *                       radio button is selected (optional)
+ */
+async function testRadioButtons(paneID, scrollPaneTo, ...tests) {
+  for (let { pref, states } of tests) {
+    for (let initialState of states) {
+      info(`Opening ${paneID} with ${pref} set to ${initialState.prefValue}`);
+
+      if (typeof initialState.prefValue == "number") {
+        Services.prefs.setIntPref(pref, initialState.prefValue);
+      } else if (typeof initialState.prefValue == "boolean") {
+        Services.prefs.setBoolPref(pref, initialState.prefValue);
+      } else {
+        Services.prefs.setCharPref(pref, initialState.prefValue);
+      }
+
+      let { prefsDocument, prefsWindow } = await openNewPrefsTab(
+        paneID,
+        scrollPaneTo
+      );
+
+      let testUIState = function (currentState) {
+        info(`Testing with ${pref} set to ${currentState.prefValue}`);
+        for (let state of states) {
+          let isCurrentState = state == currentState;
+          let radio = prefsDocument.getElementById(state.id);
+          is(radio.selected, isCurrentState, `${state.id}.selected`);
+
+          if (state.enabledElements) {
+            for (let selector of state.enabledElements) {
+              let elements = prefsDocument.querySelectorAll(selector);
+              ok(
+                elements.length >= 1,
+                `At least one element matched '${selector}'`
+              );
+              for (let element of elements) {
+                is(
+                  element.disabled,
+                  !isCurrentState,
+                  "Element " + (isCurrentState ? "isn't" : "is") + " disabled"
+                );
+              }
+            }
+          }
+        }
+        if (typeof initialState.prefValue == "number") {
+          is(
+            Services.prefs.getIntPref(pref, -999),
+            currentState.prefValue,
+            `Pref is ${currentState.prefValue}`
+          );
+        } else if (typeof initialState.prefValue == "boolean") {
+          is(
+            Services.prefs.getBoolPref(pref),
+            currentState.prefValue,
+            `Pref is ${currentState.prefValue}`
+          );
+        } else {
+          is(
+            Services.prefs.getCharPref(pref, "FAKE VALUE"),
+            currentState.prefValue,
+            `Pref is ${currentState.prefValue}`
+          );
+        }
+      };
+
+      // Check the initial setup is correct.
+      testUIState(initialState);
+      // Cycle through possible values, checking each one.
+      for (let state of states) {
+        if (state == initialState) {
+          continue;
+        }
+        let radio = prefsDocument.getElementById(state.id);
+        radio.scrollIntoView(false);
+        EventUtils.synthesizeMouseAtCenter(radio, {}, prefsWindow);
+        testUIState(state);
+      }
+      // Go back to the initial value.
+      let initialRadio = prefsDocument.getElementById(initialState.id);
+      initialRadio.scrollIntoView(false);
+      EventUtils.synthesizeMouseAtCenter(initialRadio, {}, prefsWindow);
+      testUIState(initialState);
+
+      await closePrefsTab();
+    }
+  }
+}